Documentation

Index

Constants

This section is empty.

Variables

View Source
var CAPI = map[string]struct{}{}/* 250 elements not displayed */
View Source
var Xenviron uintptr

    Keep these outside of the var block otherwise go generate will miss them.

    View Source
    var Xin6addr_any uintptr //TODO
    
    View Source
    var Xstderr = uintptr(unsafe.Pointer(&stderr))
    View Source
    var Xstdin = uintptr(unsafe.Pointer(&stdin))
    View Source
    var Xstdout = uintptr(unsafe.Pointer(&stdout))

    Functions

    func AssignAddFloat32

    func AssignAddFloat32(p *float32, v float32) float32

    func AssignAddFloat64

    func AssignAddFloat64(p *float64, v float64) float64

    func AssignAddInt16

    func AssignAddInt16(p *int16, v int16) int16

    func AssignAddInt32

    func AssignAddInt32(p *int32, v int32) int32

    func AssignAddInt64

    func AssignAddInt64(p *int64, v int64) int64

    func AssignAddInt8

    func AssignAddInt8(p *int8, v int8) int8

    func AssignAddPtrFloat32

    func AssignAddPtrFloat32(p uintptr, v float32) float32

    func AssignAddPtrFloat64

    func AssignAddPtrFloat64(p uintptr, v float64) float64

    func AssignAddPtrInt16

    func AssignAddPtrInt16(p uintptr, v int16) int16

    func AssignAddPtrInt32

    func AssignAddPtrInt32(p uintptr, v int32) int32

    func AssignAddPtrInt64

    func AssignAddPtrInt64(p uintptr, v int64) int64

    func AssignAddPtrInt8

    func AssignAddPtrInt8(p uintptr, v int8) int8

    func AssignAddPtrUint16

    func AssignAddPtrUint16(p uintptr, v uint16) uint16

    func AssignAddPtrUint32

    func AssignAddPtrUint32(p uintptr, v uint32) uint32

    func AssignAddPtrUint64

    func AssignAddPtrUint64(p uintptr, v uint64) uint64

    func AssignAddPtrUint8

    func AssignAddPtrUint8(p uintptr, v uint8) uint8

    func AssignAddPtrUintptr

    func AssignAddPtrUintptr(p uintptr, v uintptr) uintptr

    func AssignAddUint16

    func AssignAddUint16(p *uint16, v uint16) uint16

    func AssignAddUint32

    func AssignAddUint32(p *uint32, v uint32) uint32

    func AssignAddUint64

    func AssignAddUint64(p *uint64, v uint64) uint64

    func AssignAddUint8

    func AssignAddUint8(p *uint8, v uint8) uint8

    func AssignAddUintptr

    func AssignAddUintptr(p *uintptr, v uintptr) uintptr

    func AssignAndInt16

    func AssignAndInt16(p *int16, v int16) int16

    func AssignAndInt32

    func AssignAndInt32(p *int32, v int32) int32

    func AssignAndInt64

    func AssignAndInt64(p *int64, v int64) int64

    func AssignAndInt8

    func AssignAndInt8(p *int8, v int8) int8

    func AssignAndPtrInt16

    func AssignAndPtrInt16(p uintptr, v int16) int16

    func AssignAndPtrInt32

    func AssignAndPtrInt32(p uintptr, v int32) int32

    func AssignAndPtrInt64

    func AssignAndPtrInt64(p uintptr, v int64) int64

    func AssignAndPtrInt8

    func AssignAndPtrInt8(p uintptr, v int8) int8

    func AssignAndPtrUint16

    func AssignAndPtrUint16(p uintptr, v uint16) uint16

    func AssignAndPtrUint32

    func AssignAndPtrUint32(p uintptr, v uint32) uint32

    func AssignAndPtrUint64

    func AssignAndPtrUint64(p uintptr, v uint64) uint64

    func AssignAndPtrUint8

    func AssignAndPtrUint8(p uintptr, v uint8) uint8

    func AssignAndPtrUintptr

    func AssignAndPtrUintptr(p uintptr, v uintptr) uintptr

    func AssignAndUint16

    func AssignAndUint16(p *uint16, v uint16) uint16

    func AssignAndUint32

    func AssignAndUint32(p *uint32, v uint32) uint32

    func AssignAndUint64

    func AssignAndUint64(p *uint64, v uint64) uint64

    func AssignAndUint8

    func AssignAndUint8(p *uint8, v uint8) uint8

    func AssignAndUintptr

    func AssignAndUintptr(p *uintptr, v uintptr) uintptr

    func AssignBitFieldPtr16Int16

    func AssignBitFieldPtr16Int16(p uintptr, v int16, w, off int, mask uint16) int16

    func AssignBitFieldPtr16Int32

    func AssignBitFieldPtr16Int32(p uintptr, v int32, w, off int, mask uint16) int32

    func AssignBitFieldPtr16Int64

    func AssignBitFieldPtr16Int64(p uintptr, v int64, w, off int, mask uint16) int64

    func AssignBitFieldPtr16Int8

    func AssignBitFieldPtr16Int8(p uintptr, v int8, w, off int, mask uint16) int8

    func AssignBitFieldPtr16Uint16

    func AssignBitFieldPtr16Uint16(p uintptr, v uint16, w, off int, mask uint16) uint16

    func AssignBitFieldPtr16Uint32

    func AssignBitFieldPtr16Uint32(p uintptr, v uint32, w, off int, mask uint16) uint32

    func AssignBitFieldPtr16Uint64

    func AssignBitFieldPtr16Uint64(p uintptr, v uint64, w, off int, mask uint16) uint64

    func AssignBitFieldPtr16Uint8

    func AssignBitFieldPtr16Uint8(p uintptr, v uint8, w, off int, mask uint16) uint8

    func AssignBitFieldPtr32Int16

    func AssignBitFieldPtr32Int16(p uintptr, v int16, w, off int, mask uint32) int16

    func AssignBitFieldPtr32Int32

    func AssignBitFieldPtr32Int32(p uintptr, v int32, w, off int, mask uint32) int32

    func AssignBitFieldPtr32Int64

    func AssignBitFieldPtr32Int64(p uintptr, v int64, w, off int, mask uint32) int64

    func AssignBitFieldPtr32Int8

    func AssignBitFieldPtr32Int8(p uintptr, v int8, w, off int, mask uint32) int8

    func AssignBitFieldPtr32Uint16

    func AssignBitFieldPtr32Uint16(p uintptr, v uint16, w, off int, mask uint32) uint16

    func AssignBitFieldPtr32Uint32

    func AssignBitFieldPtr32Uint32(p uintptr, v uint32, w, off int, mask uint32) uint32

    func AssignBitFieldPtr32Uint64

    func AssignBitFieldPtr32Uint64(p uintptr, v uint64, w, off int, mask uint32) uint64

    func AssignBitFieldPtr32Uint8

    func AssignBitFieldPtr32Uint8(p uintptr, v uint8, w, off int, mask uint32) uint8

    func AssignBitFieldPtr64Int16

    func AssignBitFieldPtr64Int16(p uintptr, v int16, w, off int, mask uint64) int16

    func AssignBitFieldPtr64Int32

    func AssignBitFieldPtr64Int32(p uintptr, v int32, w, off int, mask uint64) int32

    func AssignBitFieldPtr64Int64

    func AssignBitFieldPtr64Int64(p uintptr, v int64, w, off int, mask uint64) int64

    func AssignBitFieldPtr64Int8

    func AssignBitFieldPtr64Int8(p uintptr, v int8, w, off int, mask uint64) int8

    func AssignBitFieldPtr64Uint16

    func AssignBitFieldPtr64Uint16(p uintptr, v uint16, w, off int, mask uint64) uint16

    func AssignBitFieldPtr64Uint32

    func AssignBitFieldPtr64Uint32(p uintptr, v uint32, w, off int, mask uint64) uint32

    func AssignBitFieldPtr64Uint64

    func AssignBitFieldPtr64Uint64(p uintptr, v uint64, w, off int, mask uint64) uint64

    func AssignBitFieldPtr64Uint8

    func AssignBitFieldPtr64Uint8(p uintptr, v uint8, w, off int, mask uint64) uint8

    func AssignBitFieldPtr8Int16

    func AssignBitFieldPtr8Int16(p uintptr, v int16, w, off int, mask uint8) int16

    func AssignBitFieldPtr8Int32

    func AssignBitFieldPtr8Int32(p uintptr, v int32, w, off int, mask uint8) int32

    func AssignBitFieldPtr8Int64

    func AssignBitFieldPtr8Int64(p uintptr, v int64, w, off int, mask uint8) int64

    func AssignBitFieldPtr8Int8

    func AssignBitFieldPtr8Int8(p uintptr, v int8, w, off int, mask uint8) int8

    func AssignBitFieldPtr8Uint16

    func AssignBitFieldPtr8Uint16(p uintptr, v uint16, w, off int, mask uint8) uint16

    func AssignBitFieldPtr8Uint32

    func AssignBitFieldPtr8Uint32(p uintptr, v uint32, w, off int, mask uint8) uint32

    func AssignBitFieldPtr8Uint64

    func AssignBitFieldPtr8Uint64(p uintptr, v uint64, w, off int, mask uint8) uint64

    func AssignBitFieldPtr8Uint8

    func AssignBitFieldPtr8Uint8(p uintptr, v uint8, w, off int, mask uint8) uint8

    func AssignDivFloat32

    func AssignDivFloat32(p *float32, v float32) float32

    func AssignDivFloat64

    func AssignDivFloat64(p *float64, v float64) float64

    func AssignDivInt16

    func AssignDivInt16(p *int16, v int16) int16

    func AssignDivInt32

    func AssignDivInt32(p *int32, v int32) int32

    func AssignDivInt64

    func AssignDivInt64(p *int64, v int64) int64

    func AssignDivInt8

    func AssignDivInt8(p *int8, v int8) int8

    func AssignDivPtrFloat32

    func AssignDivPtrFloat32(p uintptr, v float32) float32

    func AssignDivPtrFloat64

    func AssignDivPtrFloat64(p uintptr, v float64) float64

    func AssignDivPtrInt16

    func AssignDivPtrInt16(p uintptr, v int16) int16

    func AssignDivPtrInt32

    func AssignDivPtrInt32(p uintptr, v int32) int32

    func AssignDivPtrInt64

    func AssignDivPtrInt64(p uintptr, v int64) int64

    func AssignDivPtrInt8

    func AssignDivPtrInt8(p uintptr, v int8) int8

    func AssignDivPtrUint16

    func AssignDivPtrUint16(p uintptr, v uint16) uint16

    func AssignDivPtrUint32

    func AssignDivPtrUint32(p uintptr, v uint32) uint32

    func AssignDivPtrUint64

    func AssignDivPtrUint64(p uintptr, v uint64) uint64

    func AssignDivPtrUint8

    func AssignDivPtrUint8(p uintptr, v uint8) uint8

    func AssignDivPtrUintptr

    func AssignDivPtrUintptr(p uintptr, v uintptr) uintptr

    func AssignDivUint16

    func AssignDivUint16(p *uint16, v uint16) uint16

    func AssignDivUint32

    func AssignDivUint32(p *uint32, v uint32) uint32

    func AssignDivUint64

    func AssignDivUint64(p *uint64, v uint64) uint64

    func AssignDivUint8

    func AssignDivUint8(p *uint8, v uint8) uint8

    func AssignDivUintptr

    func AssignDivUintptr(p *uintptr, v uintptr) uintptr

    func AssignFloat32

    func AssignFloat32(p *float32, v float32) float32

    func AssignFloat64

    func AssignFloat64(p *float64, v float64) float64

    func AssignInt16

    func AssignInt16(p *int16, v int16) int16

    func AssignInt32

    func AssignInt32(p *int32, v int32) int32

    func AssignInt64

    func AssignInt64(p *int64, v int64) int64

    func AssignInt8

    func AssignInt8(p *int8, v int8) int8

    func AssignMulFloat32

    func AssignMulFloat32(p *float32, v float32) float32

    func AssignMulFloat64

    func AssignMulFloat64(p *float64, v float64) float64

    func AssignMulInt16

    func AssignMulInt16(p *int16, v int16) int16

    func AssignMulInt32

    func AssignMulInt32(p *int32, v int32) int32

    func AssignMulInt64

    func AssignMulInt64(p *int64, v int64) int64

    func AssignMulInt8

    func AssignMulInt8(p *int8, v int8) int8

    func AssignMulPtrFloat32

    func AssignMulPtrFloat32(p uintptr, v float32) float32

    func AssignMulPtrFloat64

    func AssignMulPtrFloat64(p uintptr, v float64) float64

    func AssignMulPtrInt16

    func AssignMulPtrInt16(p uintptr, v int16) int16

    func AssignMulPtrInt32

    func AssignMulPtrInt32(p uintptr, v int32) int32

    func AssignMulPtrInt64

    func AssignMulPtrInt64(p uintptr, v int64) int64

    func AssignMulPtrInt8

    func AssignMulPtrInt8(p uintptr, v int8) int8

    func AssignMulPtrUint16

    func AssignMulPtrUint16(p uintptr, v uint16) uint16

    func AssignMulPtrUint32

    func AssignMulPtrUint32(p uintptr, v uint32) uint32

    func AssignMulPtrUint64

    func AssignMulPtrUint64(p uintptr, v uint64) uint64

    func AssignMulPtrUint8

    func AssignMulPtrUint8(p uintptr, v uint8) uint8

    func AssignMulPtrUintptr

    func AssignMulPtrUintptr(p uintptr, v uintptr) uintptr

    func AssignMulUint16

    func AssignMulUint16(p *uint16, v uint16) uint16

    func AssignMulUint32

    func AssignMulUint32(p *uint32, v uint32) uint32

    func AssignMulUint64

    func AssignMulUint64(p *uint64, v uint64) uint64

    func AssignMulUint8

    func AssignMulUint8(p *uint8, v uint8) uint8

    func AssignMulUintptr

    func AssignMulUintptr(p *uintptr, v uintptr) uintptr

    func AssignOrInt16

    func AssignOrInt16(p *int16, v int16) int16

    func AssignOrInt32

    func AssignOrInt32(p *int32, v int32) int32

    func AssignOrInt64

    func AssignOrInt64(p *int64, v int64) int64

    func AssignOrInt8

    func AssignOrInt8(p *int8, v int8) int8

    func AssignOrPtrInt16

    func AssignOrPtrInt16(p uintptr, v int16) int16

    func AssignOrPtrInt32

    func AssignOrPtrInt32(p uintptr, v int32) int32

    func AssignOrPtrInt64

    func AssignOrPtrInt64(p uintptr, v int64) int64

    func AssignOrPtrInt8

    func AssignOrPtrInt8(p uintptr, v int8) int8

    func AssignOrPtrUint16

    func AssignOrPtrUint16(p uintptr, v uint16) uint16

    func AssignOrPtrUint32

    func AssignOrPtrUint32(p uintptr, v uint32) uint32

    func AssignOrPtrUint64

    func AssignOrPtrUint64(p uintptr, v uint64) uint64

    func AssignOrPtrUint8

    func AssignOrPtrUint8(p uintptr, v uint8) uint8

    func AssignOrPtrUintptr

    func AssignOrPtrUintptr(p uintptr, v uintptr) uintptr

    func AssignOrUint16

    func AssignOrUint16(p *uint16, v uint16) uint16

    func AssignOrUint32

    func AssignOrUint32(p *uint32, v uint32) uint32

    func AssignOrUint64

    func AssignOrUint64(p *uint64, v uint64) uint64

    func AssignOrUint8

    func AssignOrUint8(p *uint8, v uint8) uint8

    func AssignOrUintptr

    func AssignOrUintptr(p *uintptr, v uintptr) uintptr

    func AssignPtrFloat32

    func AssignPtrFloat32(p uintptr, v float32) float32

    func AssignPtrFloat64

    func AssignPtrFloat64(p uintptr, v float64) float64

    func AssignPtrInt16

    func AssignPtrInt16(p uintptr, v int16) int16

    func AssignPtrInt32

    func AssignPtrInt32(p uintptr, v int32) int32

    func AssignPtrInt64

    func AssignPtrInt64(p uintptr, v int64) int64

    func AssignPtrInt8

    func AssignPtrInt8(p uintptr, v int8) int8

    func AssignPtrUint16

    func AssignPtrUint16(p uintptr, v uint16) uint16

    func AssignPtrUint32

    func AssignPtrUint32(p uintptr, v uint32) uint32

    func AssignPtrUint64

    func AssignPtrUint64(p uintptr, v uint64) uint64

    func AssignPtrUint8

    func AssignPtrUint8(p uintptr, v uint8) uint8

    func AssignPtrUintptr

    func AssignPtrUintptr(p uintptr, v uintptr) uintptr

    func AssignRemInt16

    func AssignRemInt16(p *int16, v int16) int16

    func AssignRemInt32

    func AssignRemInt32(p *int32, v int32) int32

    func AssignRemInt64

    func AssignRemInt64(p *int64, v int64) int64

    func AssignRemInt8

    func AssignRemInt8(p *int8, v int8) int8

    func AssignRemPtrInt16

    func AssignRemPtrInt16(p uintptr, v int16) int16

    func AssignRemPtrInt32

    func AssignRemPtrInt32(p uintptr, v int32) int32

    func AssignRemPtrInt64

    func AssignRemPtrInt64(p uintptr, v int64) int64

    func AssignRemPtrInt8

    func AssignRemPtrInt8(p uintptr, v int8) int8

    func AssignRemPtrUint16

    func AssignRemPtrUint16(p uintptr, v uint16) uint16

    func AssignRemPtrUint32

    func AssignRemPtrUint32(p uintptr, v uint32) uint32

    func AssignRemPtrUint64

    func AssignRemPtrUint64(p uintptr, v uint64) uint64

    func AssignRemPtrUint8

    func AssignRemPtrUint8(p uintptr, v uint8) uint8

    func AssignRemPtrUintptr

    func AssignRemPtrUintptr(p uintptr, v uintptr) uintptr

    func AssignRemUint16

    func AssignRemUint16(p *uint16, v uint16) uint16

    func AssignRemUint32

    func AssignRemUint32(p *uint32, v uint32) uint32

    func AssignRemUint64

    func AssignRemUint64(p *uint64, v uint64) uint64

    func AssignRemUint8

    func AssignRemUint8(p *uint8, v uint8) uint8

    func AssignRemUintptr

    func AssignRemUintptr(p *uintptr, v uintptr) uintptr

    func AssignShlInt16

    func AssignShlInt16(p *int16, v int) int16

    func AssignShlInt32

    func AssignShlInt32(p *int32, v int) int32

    func AssignShlInt64

    func AssignShlInt64(p *int64, v int) int64

    func AssignShlInt8

    func AssignShlInt8(p *int8, v int) int8

    func AssignShlPtrInt16

    func AssignShlPtrInt16(p uintptr, v int) int16

    func AssignShlPtrInt32

    func AssignShlPtrInt32(p uintptr, v int) int32

    func AssignShlPtrInt64

    func AssignShlPtrInt64(p uintptr, v int) int64

    func AssignShlPtrInt8

    func AssignShlPtrInt8(p uintptr, v int) int8

    func AssignShlPtrUint16

    func AssignShlPtrUint16(p uintptr, v int) uint16

    func AssignShlPtrUint32

    func AssignShlPtrUint32(p uintptr, v int) uint32

    func AssignShlPtrUint64

    func AssignShlPtrUint64(p uintptr, v int) uint64

    func AssignShlPtrUint8

    func AssignShlPtrUint8(p uintptr, v int) uint8

    func AssignShlPtrUintptr

    func AssignShlPtrUintptr(p uintptr, v int) uintptr

    func AssignShlUint16

    func AssignShlUint16(p *uint16, v int) uint16

    func AssignShlUint32

    func AssignShlUint32(p *uint32, v int) uint32

    func AssignShlUint64

    func AssignShlUint64(p *uint64, v int) uint64

    func AssignShlUint8

    func AssignShlUint8(p *uint8, v int) uint8

    func AssignShlUintptr

    func AssignShlUintptr(p *uintptr, v int) uintptr

    func AssignShrInt16

    func AssignShrInt16(p *int16, v int) int16

    func AssignShrInt32

    func AssignShrInt32(p *int32, v int) int32

    func AssignShrInt64

    func AssignShrInt64(p *int64, v int) int64

    func AssignShrInt8

    func AssignShrInt8(p *int8, v int) int8

    func AssignShrPtrInt16

    func AssignShrPtrInt16(p uintptr, v int) int16

    func AssignShrPtrInt32

    func AssignShrPtrInt32(p uintptr, v int) int32

    func AssignShrPtrInt64

    func AssignShrPtrInt64(p uintptr, v int) int64

    func AssignShrPtrInt8

    func AssignShrPtrInt8(p uintptr, v int) int8

    func AssignShrPtrUint16

    func AssignShrPtrUint16(p uintptr, v int) uint16

    func AssignShrPtrUint32

    func AssignShrPtrUint32(p uintptr, v int) uint32

    func AssignShrPtrUint64

    func AssignShrPtrUint64(p uintptr, v int) uint64

    func AssignShrPtrUint8

    func AssignShrPtrUint8(p uintptr, v int) uint8

    func AssignShrPtrUintptr

    func AssignShrPtrUintptr(p uintptr, v int) uintptr

    func AssignShrUint16

    func AssignShrUint16(p *uint16, v int) uint16

    func AssignShrUint32

    func AssignShrUint32(p *uint32, v int) uint32

    func AssignShrUint64

    func AssignShrUint64(p *uint64, v int) uint64

    func AssignShrUint8

    func AssignShrUint8(p *uint8, v int) uint8

    func AssignShrUintptr

    func AssignShrUintptr(p *uintptr, v int) uintptr

    func AssignSubFloat32

    func AssignSubFloat32(p *float32, v float32) float32

    func AssignSubFloat64

    func AssignSubFloat64(p *float64, v float64) float64

    func AssignSubInt16

    func AssignSubInt16(p *int16, v int16) int16

    func AssignSubInt32

    func AssignSubInt32(p *int32, v int32) int32

    func AssignSubInt64

    func AssignSubInt64(p *int64, v int64) int64

    func AssignSubInt8

    func AssignSubInt8(p *int8, v int8) int8

    func AssignSubPtrFloat32

    func AssignSubPtrFloat32(p uintptr, v float32) float32

    func AssignSubPtrFloat64

    func AssignSubPtrFloat64(p uintptr, v float64) float64

    func AssignSubPtrInt16

    func AssignSubPtrInt16(p uintptr, v int16) int16

    func AssignSubPtrInt32

    func AssignSubPtrInt32(p uintptr, v int32) int32

    func AssignSubPtrInt64

    func AssignSubPtrInt64(p uintptr, v int64) int64

    func AssignSubPtrInt8

    func AssignSubPtrInt8(p uintptr, v int8) int8

    func AssignSubPtrUint16

    func AssignSubPtrUint16(p uintptr, v uint16) uint16

    func AssignSubPtrUint32

    func AssignSubPtrUint32(p uintptr, v uint32) uint32

    func AssignSubPtrUint64

    func AssignSubPtrUint64(p uintptr, v uint64) uint64

    func AssignSubPtrUint8

    func AssignSubPtrUint8(p uintptr, v uint8) uint8

    func AssignSubPtrUintptr

    func AssignSubPtrUintptr(p uintptr, v uintptr) uintptr

    func AssignSubUint16

    func AssignSubUint16(p *uint16, v uint16) uint16

    func AssignSubUint32

    func AssignSubUint32(p *uint32, v uint32) uint32

    func AssignSubUint64

    func AssignSubUint64(p *uint64, v uint64) uint64

    func AssignSubUint8

    func AssignSubUint8(p *uint8, v uint8) uint8

    func AssignSubUintptr

    func AssignSubUintptr(p *uintptr, v uintptr) uintptr

    func AssignUint16

    func AssignUint16(p *uint16, v uint16) uint16

    func AssignUint32

    func AssignUint32(p *uint32, v uint32) uint32

    func AssignUint64

    func AssignUint64(p *uint64, v uint64) uint64

    func AssignUint8

    func AssignUint8(p *uint8, v uint8) uint8

    func AssignUintptr

    func AssignUintptr(p *uintptr, v uintptr) uintptr

    func AssignXorInt16

    func AssignXorInt16(p *int16, v int16) int16

    func AssignXorInt32

    func AssignXorInt32(p *int32, v int32) int32

    func AssignXorInt64

    func AssignXorInt64(p *int64, v int64) int64

    func AssignXorInt8

    func AssignXorInt8(p *int8, v int8) int8

    func AssignXorPtrInt16

    func AssignXorPtrInt16(p uintptr, v int16) int16

    func AssignXorPtrInt32

    func AssignXorPtrInt32(p uintptr, v int32) int32

    func AssignXorPtrInt64

    func AssignXorPtrInt64(p uintptr, v int64) int64

    func AssignXorPtrInt8

    func AssignXorPtrInt8(p uintptr, v int8) int8

    func AssignXorPtrUint16

    func AssignXorPtrUint16(p uintptr, v uint16) uint16

    func AssignXorPtrUint32

    func AssignXorPtrUint32(p uintptr, v uint32) uint32

    func AssignXorPtrUint64

    func AssignXorPtrUint64(p uintptr, v uint64) uint64

    func AssignXorPtrUint8

    func AssignXorPtrUint8(p uintptr, v uint8) uint8

    func AssignXorPtrUintptr

    func AssignXorPtrUintptr(p uintptr, v uintptr) uintptr

    func AssignXorUint16

    func AssignXorUint16(p *uint16, v uint16) uint16

    func AssignXorUint32

    func AssignXorUint32(p *uint32, v uint32) uint32

    func AssignXorUint64

    func AssignXorUint64(p *uint64, v uint64) uint64

    func AssignXorUint8

    func AssignXorUint8(p *uint8, v uint8) uint8

    func AssignXorUintptr

    func AssignXorUintptr(p *uintptr, v uintptr) uintptr

    func Bool32

    func Bool32(b bool) int32

    func Bool64

    func Bool64(b bool) int64

    func BoolInt16

    func BoolInt16(b bool) int16

    func BoolInt32

    func BoolInt32(b bool) int32

    func BoolInt64

    func BoolInt64(b bool) int64

    func BoolInt8

    func BoolInt8(b bool) int8

    func BoolUint16

    func BoolUint16(b bool) uint16

    func BoolUint32

    func BoolUint32(b bool) uint32

    func BoolUint64

    func BoolUint64(b bool) uint64

    func BoolUint8

    func BoolUint8(b bool) uint8

    func CString

    func CString(s string) (uintptr, error)

    func CloseTLS

    func CloseTLS(t *TLS)

    func CplInt16

    func CplInt16(n int16) int16

    func CplInt32

    func CplInt32(n int32) int32

    func CplInt64

    func CplInt64(n int64) int64

    func CplInt8

    func CplInt8(n int8) int8

    func CplUint16

    func CplUint16(n uint16) uint16

    func CplUint32

    func CplUint32(n uint32) uint32

    func CplUint64

    func CplUint64(n uint64) uint64

    func CplUint8

    func CplUint8(n uint8) uint8

    func CplUintptr

    func CplUintptr(n uintptr) uintptr

    func Float32

    func Float32(n float32) float32

    func Float32FromFloat32

    func Float32FromFloat32(n float32) float32

    func Float32FromFloat64

    func Float32FromFloat64(n float64) float32

    func Float32FromInt16

    func Float32FromInt16(n int16) float32

    func Float32FromInt32

    func Float32FromInt32(n int32) float32

    func Float32FromInt64

    func Float32FromInt64(n int64) float32

    func Float32FromInt8

    func Float32FromInt8(n int8) float32

    func Float32FromUint16

    func Float32FromUint16(n uint16) float32

    func Float32FromUint32

    func Float32FromUint32(n uint32) float32

    func Float32FromUint64

    func Float32FromUint64(n uint64) float32

    func Float32FromUint8

    func Float32FromUint8(n uint8) float32

    func Float32FromUintptr

    func Float32FromUintptr(n uintptr) float32

    func Float64

    func Float64(n float64) float64

    func Float64FromFloat32

    func Float64FromFloat32(n float32) float64

    func Float64FromFloat64

    func Float64FromFloat64(n float64) float64

    func Float64FromInt16

    func Float64FromInt16(n int16) float64

    func Float64FromInt32

    func Float64FromInt32(n int32) float64

    func Float64FromInt64

    func Float64FromInt64(n int64) float64

    func Float64FromInt8

    func Float64FromInt8(n int8) float64

    func Float64FromUint16

    func Float64FromUint16(n uint16) float64

    func Float64FromUint32

    func Float64FromUint32(n uint32) float64

    func Float64FromUint64

    func Float64FromUint64(n uint64) float64

    func Float64FromUint8

    func Float64FromUint8(n uint8) float64

    func Float64FromUintptr

    func Float64FromUintptr(n uintptr) float64

    func GoBytes

    func GoBytes(s uintptr, n int) []byte

    func GoString

    func GoString(s uintptr) string

    func Int16

    func Int16(n int16) int16

    func Int16FromFloat32

    func Int16FromFloat32(n float32) int16

    func Int16FromFloat64

    func Int16FromFloat64(n float64) int16

    func Int16FromInt16

    func Int16FromInt16(n int16) int16

    func Int16FromInt32

    func Int16FromInt32(n int32) int16

    func Int16FromInt64

    func Int16FromInt64(n int64) int16

    func Int16FromInt8

    func Int16FromInt8(n int8) int16

    func Int16FromUint16

    func Int16FromUint16(n uint16) int16

    func Int16FromUint32

    func Int16FromUint32(n uint32) int16

    func Int16FromUint64

    func Int16FromUint64(n uint64) int16

    func Int16FromUint8

    func Int16FromUint8(n uint8) int16

    func Int16FromUintptr

    func Int16FromUintptr(n uintptr) int16

    func Int32

    func Int32(n int32) int32

    func Int32FromFloat32

    func Int32FromFloat32(n float32) int32

    func Int32FromFloat64

    func Int32FromFloat64(n float64) int32

    func Int32FromInt16

    func Int32FromInt16(n int16) int32

    func Int32FromInt32

    func Int32FromInt32(n int32) int32

    func Int32FromInt64

    func Int32FromInt64(n int64) int32

    func Int32FromInt8

    func Int32FromInt8(n int8) int32

    func Int32FromUint16

    func Int32FromUint16(n uint16) int32

    func Int32FromUint32

    func Int32FromUint32(n uint32) int32

    func Int32FromUint64

    func Int32FromUint64(n uint64) int32

    func Int32FromUint8

    func Int32FromUint8(n uint8) int32

    func Int32FromUintptr

    func Int32FromUintptr(n uintptr) int32

    func Int64

    func Int64(n int64) int64

    func Int64FromFloat32

    func Int64FromFloat32(n float32) int64

    func Int64FromFloat64

    func Int64FromFloat64(n float64) int64

    func Int64FromInt16

    func Int64FromInt16(n int16) int64

    func Int64FromInt32

    func Int64FromInt32(n int32) int64

    func Int64FromInt64

    func Int64FromInt64(n int64) int64

    func Int64FromInt8

    func Int64FromInt8(n int8) int64

    func Int64FromUint16

    func Int64FromUint16(n uint16) int64

    func Int64FromUint32

    func Int64FromUint32(n uint32) int64

    func Int64FromUint64

    func Int64FromUint64(n uint64) int64

    func Int64FromUint8

    func Int64FromUint8(n uint8) int64

    func Int64FromUintptr

    func Int64FromUintptr(n uintptr) int64

    func Int8

    func Int8(n int8) int8

    func Int8FromFloat32

    func Int8FromFloat32(n float32) int8

    func Int8FromFloat64

    func Int8FromFloat64(n float64) int8

    func Int8FromInt16

    func Int8FromInt16(n int16) int8

    func Int8FromInt32

    func Int8FromInt32(n int32) int8

    func Int8FromInt64

    func Int8FromInt64(n int64) int8

    func Int8FromInt8

    func Int8FromInt8(n int8) int8

    func Int8FromUint16

    func Int8FromUint16(n uint16) int8

    func Int8FromUint32

    func Int8FromUint32(n uint32) int8

    func Int8FromUint64

    func Int8FromUint64(n uint64) int8

    func Int8FromUint8

    func Int8FromUint8(n uint8) int8

    func Int8FromUintptr

    func Int8FromUintptr(n uintptr) int8

    func NegInt16

    func NegInt16(n int16) int16

    func NegInt32

    func NegInt32(n int32) int32

    func NegInt64

    func NegInt64(n int64) int64

    func NegInt8

    func NegInt8(n int8) int8

    func NegUint16

    func NegUint16(n uint16) uint16

    func NegUint32

    func NegUint32(n uint32) uint32

    func NegUint64

    func NegUint64(n uint64) uint64

    func NegUint8

    func NegUint8(n uint8) uint8

    func NegUintptr

    func NegUintptr(n uintptr) uintptr

    func PostDecBitFieldPtr16Int16

    func PostDecBitFieldPtr16Int16(p uintptr, d int16, w, off int, mask uint16) (r int16)

    func PostDecBitFieldPtr16Int32

    func PostDecBitFieldPtr16Int32(p uintptr, d int32, w, off int, mask uint16) (r int32)

    func PostDecBitFieldPtr16Int64

    func PostDecBitFieldPtr16Int64(p uintptr, d int64, w, off int, mask uint16) (r int64)

    func PostDecBitFieldPtr16Int8

    func PostDecBitFieldPtr16Int8(p uintptr, d int8, w, off int, mask uint16) (r int8)

    func PostDecBitFieldPtr16Uint16

    func PostDecBitFieldPtr16Uint16(p uintptr, d uint16, w, off int, mask uint16) (r uint16)

    func PostDecBitFieldPtr16Uint32

    func PostDecBitFieldPtr16Uint32(p uintptr, d uint32, w, off int, mask uint16) (r uint32)

    func PostDecBitFieldPtr16Uint64

    func PostDecBitFieldPtr16Uint64(p uintptr, d uint64, w, off int, mask uint16) (r uint64)

    func PostDecBitFieldPtr16Uint8

    func PostDecBitFieldPtr16Uint8(p uintptr, d uint8, w, off int, mask uint16) (r uint8)

    func PostDecBitFieldPtr32Int16

    func PostDecBitFieldPtr32Int16(p uintptr, d int16, w, off int, mask uint32) (r int16)

    func PostDecBitFieldPtr32Int32

    func PostDecBitFieldPtr32Int32(p uintptr, d int32, w, off int, mask uint32) (r int32)

    func PostDecBitFieldPtr32Int64

    func PostDecBitFieldPtr32Int64(p uintptr, d int64, w, off int, mask uint32) (r int64)

    func PostDecBitFieldPtr32Int8

    func PostDecBitFieldPtr32Int8(p uintptr, d int8, w, off int, mask uint32) (r int8)

    func PostDecBitFieldPtr32Uint16

    func PostDecBitFieldPtr32Uint16(p uintptr, d uint16, w, off int, mask uint32) (r uint16)

    func PostDecBitFieldPtr32Uint32

    func PostDecBitFieldPtr32Uint32(p uintptr, d uint32, w, off int, mask uint32) (r uint32)

    func PostDecBitFieldPtr32Uint64

    func PostDecBitFieldPtr32Uint64(p uintptr, d uint64, w, off int, mask uint32) (r uint64)

    func PostDecBitFieldPtr32Uint8

    func PostDecBitFieldPtr32Uint8(p uintptr, d uint8, w, off int, mask uint32) (r uint8)

    func PostDecBitFieldPtr64Int16

    func PostDecBitFieldPtr64Int16(p uintptr, d int16, w, off int, mask uint64) (r int16)

    func PostDecBitFieldPtr64Int32

    func PostDecBitFieldPtr64Int32(p uintptr, d int32, w, off int, mask uint64) (r int32)

    func PostDecBitFieldPtr64Int64

    func PostDecBitFieldPtr64Int64(p uintptr, d int64, w, off int, mask uint64) (r int64)

    func PostDecBitFieldPtr64Int8

    func PostDecBitFieldPtr64Int8(p uintptr, d int8, w, off int, mask uint64) (r int8)

    func PostDecBitFieldPtr64Uint16

    func PostDecBitFieldPtr64Uint16(p uintptr, d uint16, w, off int, mask uint64) (r uint16)

    func PostDecBitFieldPtr64Uint32

    func PostDecBitFieldPtr64Uint32(p uintptr, d uint32, w, off int, mask uint64) (r uint32)

    func PostDecBitFieldPtr64Uint64

    func PostDecBitFieldPtr64Uint64(p uintptr, d uint64, w, off int, mask uint64) (r uint64)

    func PostDecBitFieldPtr64Uint8

    func PostDecBitFieldPtr64Uint8(p uintptr, d uint8, w, off int, mask uint64) (r uint8)

    func PostDecBitFieldPtr8Int16

    func PostDecBitFieldPtr8Int16(p uintptr, d int16, w, off int, mask uint8) (r int16)

    func PostDecBitFieldPtr8Int32

    func PostDecBitFieldPtr8Int32(p uintptr, d int32, w, off int, mask uint8) (r int32)

    func PostDecBitFieldPtr8Int64

    func PostDecBitFieldPtr8Int64(p uintptr, d int64, w, off int, mask uint8) (r int64)

    func PostDecBitFieldPtr8Int8

    func PostDecBitFieldPtr8Int8(p uintptr, d int8, w, off int, mask uint8) (r int8)

    func PostDecBitFieldPtr8Uint16

    func PostDecBitFieldPtr8Uint16(p uintptr, d uint16, w, off int, mask uint8) (r uint16)

    func PostDecBitFieldPtr8Uint32

    func PostDecBitFieldPtr8Uint32(p uintptr, d uint32, w, off int, mask uint8) (r uint32)

    func PostDecBitFieldPtr8Uint64

    func PostDecBitFieldPtr8Uint64(p uintptr, d uint64, w, off int, mask uint8) (r uint64)

    func PostDecBitFieldPtr8Uint8

    func PostDecBitFieldPtr8Uint8(p uintptr, d uint8, w, off int, mask uint8) (r uint8)

    func PostDecFloat32

    func PostDecFloat32(p *float32, d float32) float32

    func PostDecFloat64

    func PostDecFloat64(p *float64, d float64) float64

    func PostDecInt16

    func PostDecInt16(p *int16, d int16) int16

    func PostDecInt32

    func PostDecInt32(p *int32, d int32) int32

    func PostDecInt64

    func PostDecInt64(p *int64, d int64) int64

    func PostDecInt8

    func PostDecInt8(p *int8, d int8) int8

    func PostDecUint16

    func PostDecUint16(p *uint16, d uint16) uint16

    func PostDecUint32

    func PostDecUint32(p *uint32, d uint32) uint32

    func PostDecUint64

    func PostDecUint64(p *uint64, d uint64) uint64

    func PostDecUint8

    func PostDecUint8(p *uint8, d uint8) uint8

    func PostDecUintptr

    func PostDecUintptr(p *uintptr, d uintptr) uintptr

    func PostIncBitFieldPtr16Int16

    func PostIncBitFieldPtr16Int16(p uintptr, d int16, w, off int, mask uint16) (r int16)

    func PostIncBitFieldPtr16Int32

    func PostIncBitFieldPtr16Int32(p uintptr, d int32, w, off int, mask uint16) (r int32)

    func PostIncBitFieldPtr16Int64

    func PostIncBitFieldPtr16Int64(p uintptr, d int64, w, off int, mask uint16) (r int64)

    func PostIncBitFieldPtr16Int8

    func PostIncBitFieldPtr16Int8(p uintptr, d int8, w, off int, mask uint16) (r int8)

    func PostIncBitFieldPtr16Uint16

    func PostIncBitFieldPtr16Uint16(p uintptr, d uint16, w, off int, mask uint16) (r uint16)

    func PostIncBitFieldPtr16Uint32

    func PostIncBitFieldPtr16Uint32(p uintptr, d uint32, w, off int, mask uint16) (r uint32)

    func PostIncBitFieldPtr16Uint64

    func PostIncBitFieldPtr16Uint64(p uintptr, d uint64, w, off int, mask uint16) (r uint64)

    func PostIncBitFieldPtr16Uint8

    func PostIncBitFieldPtr16Uint8(p uintptr, d uint8, w, off int, mask uint16) (r uint8)

    func PostIncBitFieldPtr32Int16

    func PostIncBitFieldPtr32Int16(p uintptr, d int16, w, off int, mask uint32) (r int16)

    func PostIncBitFieldPtr32Int32

    func PostIncBitFieldPtr32Int32(p uintptr, d int32, w, off int, mask uint32) (r int32)

    func PostIncBitFieldPtr32Int64

    func PostIncBitFieldPtr32Int64(p uintptr, d int64, w, off int, mask uint32) (r int64)

    func PostIncBitFieldPtr32Int8

    func PostIncBitFieldPtr32Int8(p uintptr, d int8, w, off int, mask uint32) (r int8)

    func PostIncBitFieldPtr32Uint16

    func PostIncBitFieldPtr32Uint16(p uintptr, d uint16, w, off int, mask uint32) (r uint16)

    func PostIncBitFieldPtr32Uint32

    func PostIncBitFieldPtr32Uint32(p uintptr, d uint32, w, off int, mask uint32) (r uint32)

    func PostIncBitFieldPtr32Uint64

    func PostIncBitFieldPtr32Uint64(p uintptr, d uint64, w, off int, mask uint32) (r uint64)

    func PostIncBitFieldPtr32Uint8

    func PostIncBitFieldPtr32Uint8(p uintptr, d uint8, w, off int, mask uint32) (r uint8)

    func PostIncBitFieldPtr64Int16

    func PostIncBitFieldPtr64Int16(p uintptr, d int16, w, off int, mask uint64) (r int16)

    func PostIncBitFieldPtr64Int32

    func PostIncBitFieldPtr64Int32(p uintptr, d int32, w, off int, mask uint64) (r int32)

    func PostIncBitFieldPtr64Int64

    func PostIncBitFieldPtr64Int64(p uintptr, d int64, w, off int, mask uint64) (r int64)

    func PostIncBitFieldPtr64Int8

    func PostIncBitFieldPtr64Int8(p uintptr, d int8, w, off int, mask uint64) (r int8)

    func PostIncBitFieldPtr64Uint16

    func PostIncBitFieldPtr64Uint16(p uintptr, d uint16, w, off int, mask uint64) (r uint16)

    func PostIncBitFieldPtr64Uint32

    func PostIncBitFieldPtr64Uint32(p uintptr, d uint32, w, off int, mask uint64) (r uint32)

    func PostIncBitFieldPtr64Uint64

    func PostIncBitFieldPtr64Uint64(p uintptr, d uint64, w, off int, mask uint64) (r uint64)

    func PostIncBitFieldPtr64Uint8

    func PostIncBitFieldPtr64Uint8(p uintptr, d uint8, w, off int, mask uint64) (r uint8)

    func PostIncBitFieldPtr8Int16

    func PostIncBitFieldPtr8Int16(p uintptr, d int16, w, off int, mask uint8) (r int16)

    func PostIncBitFieldPtr8Int32

    func PostIncBitFieldPtr8Int32(p uintptr, d int32, w, off int, mask uint8) (r int32)

    func PostIncBitFieldPtr8Int64

    func PostIncBitFieldPtr8Int64(p uintptr, d int64, w, off int, mask uint8) (r int64)

    func PostIncBitFieldPtr8Int8

    func PostIncBitFieldPtr8Int8(p uintptr, d int8, w, off int, mask uint8) (r int8)

    func PostIncBitFieldPtr8Uint16

    func PostIncBitFieldPtr8Uint16(p uintptr, d uint16, w, off int, mask uint8) (r uint16)

    func PostIncBitFieldPtr8Uint32

    func PostIncBitFieldPtr8Uint32(p uintptr, d uint32, w, off int, mask uint8) (r uint32)

    func PostIncBitFieldPtr8Uint64

    func PostIncBitFieldPtr8Uint64(p uintptr, d uint64, w, off int, mask uint8) (r uint64)

    func PostIncBitFieldPtr8Uint8

    func PostIncBitFieldPtr8Uint8(p uintptr, d uint8, w, off int, mask uint8) (r uint8)

    func PostIncFloat32

    func PostIncFloat32(p *float32, d float32) float32

    func PostIncFloat64

    func PostIncFloat64(p *float64, d float64) float64

    func PostIncInt16

    func PostIncInt16(p *int16, d int16) int16

    func PostIncInt32

    func PostIncInt32(p *int32, d int32) int32

    func PostIncInt64

    func PostIncInt64(p *int64, d int64) int64

    func PostIncInt8

    func PostIncInt8(p *int8, d int8) int8

    func PostIncUint16

    func PostIncUint16(p *uint16, d uint16) uint16

    func PostIncUint32

    func PostIncUint32(p *uint32, d uint32) uint32

    func PostIncUint64

    func PostIncUint64(p *uint64, d uint64) uint64

    func PostIncUint8

    func PostIncUint8(p *uint8, d uint8) uint8

    func PostIncUintptr

    func PostIncUintptr(p *uintptr, d uintptr) uintptr

    func PreDecFloat32

    func PreDecFloat32(p *float32, d float32) float32

    func PreDecFloat64

    func PreDecFloat64(p *float64, d float64) float64

    func PreDecInt16

    func PreDecInt16(p *int16, d int16) int16

    func PreDecInt32

    func PreDecInt32(p *int32, d int32) int32

    func PreDecInt64

    func PreDecInt64(p *int64, d int64) int64

    func PreDecInt8

    func PreDecInt8(p *int8, d int8) int8

    func PreDecUint16

    func PreDecUint16(p *uint16, d uint16) uint16

    func PreDecUint32

    func PreDecUint32(p *uint32, d uint32) uint32

    func PreDecUint64

    func PreDecUint64(p *uint64, d uint64) uint64

    func PreDecUint8

    func PreDecUint8(p *uint8, d uint8) uint8

    func PreDecUintptr

    func PreDecUintptr(p *uintptr, d uintptr) uintptr

    func PreIncFloat32

    func PreIncFloat32(p *float32, d float32) float32

    func PreIncFloat64

    func PreIncFloat64(p *float64, d float64) float64

    func PreIncInt16

    func PreIncInt16(p *int16, d int16) int16

    func PreIncInt32

    func PreIncInt32(p *int32, d int32) int32

    func PreIncInt64

    func PreIncInt64(p *int64, d int64) int64

    func PreIncInt8

    func PreIncInt8(p *int8, d int8) int8

    func PreIncUint16

    func PreIncUint16(p *uint16, d uint16) uint16

    func PreIncUint32

    func PreIncUint32(p *uint32, d uint32) uint32

    func PreIncUint64

    func PreIncUint64(p *uint64, d uint64) uint64

    func PreIncUint8

    func PreIncUint8(p *uint8, d uint8) uint8

    func PreIncUintptr

    func PreIncUintptr(p *uintptr, d uintptr) uintptr

    func SetBitFieldPtr16Int16

    func SetBitFieldPtr16Int16(p uintptr, v int16, off int, mask uint16)

    func SetBitFieldPtr16Int32

    func SetBitFieldPtr16Int32(p uintptr, v int32, off int, mask uint16)

    func SetBitFieldPtr16Int64

    func SetBitFieldPtr16Int64(p uintptr, v int64, off int, mask uint16)

    func SetBitFieldPtr16Int8

    func SetBitFieldPtr16Int8(p uintptr, v int8, off int, mask uint16)

    func SetBitFieldPtr16Uint16

    func SetBitFieldPtr16Uint16(p uintptr, v uint16, off int, mask uint16)

    func SetBitFieldPtr16Uint32

    func SetBitFieldPtr16Uint32(p uintptr, v uint32, off int, mask uint16)

    func SetBitFieldPtr16Uint64

    func SetBitFieldPtr16Uint64(p uintptr, v uint64, off int, mask uint16)

    func SetBitFieldPtr16Uint8

    func SetBitFieldPtr16Uint8(p uintptr, v uint8, off int, mask uint16)

    func SetBitFieldPtr32Int16

    func SetBitFieldPtr32Int16(p uintptr, v int16, off int, mask uint32)

    func SetBitFieldPtr32Int32

    func SetBitFieldPtr32Int32(p uintptr, v int32, off int, mask uint32)

    func SetBitFieldPtr32Int64

    func SetBitFieldPtr32Int64(p uintptr, v int64, off int, mask uint32)

    func SetBitFieldPtr32Int8

    func SetBitFieldPtr32Int8(p uintptr, v int8, off int, mask uint32)

    func SetBitFieldPtr32Uint16

    func SetBitFieldPtr32Uint16(p uintptr, v uint16, off int, mask uint32)

    func SetBitFieldPtr32Uint32

    func SetBitFieldPtr32Uint32(p uintptr, v uint32, off int, mask uint32)

    func SetBitFieldPtr32Uint64

    func SetBitFieldPtr32Uint64(p uintptr, v uint64, off int, mask uint32)

    func SetBitFieldPtr32Uint8

    func SetBitFieldPtr32Uint8(p uintptr, v uint8, off int, mask uint32)

    func SetBitFieldPtr64Int16

    func SetBitFieldPtr64Int16(p uintptr, v int16, off int, mask uint64)

    func SetBitFieldPtr64Int32

    func SetBitFieldPtr64Int32(p uintptr, v int32, off int, mask uint64)

    func SetBitFieldPtr64Int64

    func SetBitFieldPtr64Int64(p uintptr, v int64, off int, mask uint64)

    func SetBitFieldPtr64Int8

    func SetBitFieldPtr64Int8(p uintptr, v int8, off int, mask uint64)

    func SetBitFieldPtr64Uint16

    func SetBitFieldPtr64Uint16(p uintptr, v uint16, off int, mask uint64)

    func SetBitFieldPtr64Uint32

    func SetBitFieldPtr64Uint32(p uintptr, v uint32, off int, mask uint64)

    func SetBitFieldPtr64Uint64

    func SetBitFieldPtr64Uint64(p uintptr, v uint64, off int, mask uint64)

    func SetBitFieldPtr64Uint8

    func SetBitFieldPtr64Uint8(p uintptr, v uint8, off int, mask uint64)

    func SetBitFieldPtr8Int16

    func SetBitFieldPtr8Int16(p uintptr, v int16, off int, mask uint8)

    func SetBitFieldPtr8Int32

    func SetBitFieldPtr8Int32(p uintptr, v int32, off int, mask uint8)

    func SetBitFieldPtr8Int64

    func SetBitFieldPtr8Int64(p uintptr, v int64, off int, mask uint8)

    func SetBitFieldPtr8Int8

    func SetBitFieldPtr8Int8(p uintptr, v int8, off int, mask uint8)

    func SetBitFieldPtr8Uint16

    func SetBitFieldPtr8Uint16(p uintptr, v uint16, off int, mask uint8)

    func SetBitFieldPtr8Uint32

    func SetBitFieldPtr8Uint32(p uintptr, v uint32, off int, mask uint8)

    func SetBitFieldPtr8Uint64

    func SetBitFieldPtr8Uint64(p uintptr, v uint64, off int, mask uint8)

    func SetBitFieldPtr8Uint8

    func SetBitFieldPtr8Uint8(p uintptr, v uint8, off int, mask uint8)

    func SetEnviron

    func SetEnviron(env []string)

    func Start

    func Start(main func(*TLS, int32, uintptr) int32)

    func Uint16

    func Uint16(n uint16) uint16

    func Uint16FromFloat32

    func Uint16FromFloat32(n float32) uint16

    func Uint16FromFloat64

    func Uint16FromFloat64(n float64) uint16

    func Uint16FromInt16

    func Uint16FromInt16(n int16) uint16

    func Uint16FromInt32

    func Uint16FromInt32(n int32) uint16

    func Uint16FromInt64

    func Uint16FromInt64(n int64) uint16

    func Uint16FromInt8

    func Uint16FromInt8(n int8) uint16

    func Uint16FromUint16

    func Uint16FromUint16(n uint16) uint16

    func Uint16FromUint32

    func Uint16FromUint32(n uint32) uint16

    func Uint16FromUint64

    func Uint16FromUint64(n uint64) uint16

    func Uint16FromUint8

    func Uint16FromUint8(n uint8) uint16

    func Uint16FromUintptr

    func Uint16FromUintptr(n uintptr) uint16

    func Uint32

    func Uint32(n uint32) uint32

    func Uint32FromFloat32

    func Uint32FromFloat32(n float32) uint32

    func Uint32FromFloat64

    func Uint32FromFloat64(n float64) uint32

    func Uint32FromInt16

    func Uint32FromInt16(n int16) uint32

    func Uint32FromInt32

    func Uint32FromInt32(n int32) uint32

    func Uint32FromInt64

    func Uint32FromInt64(n int64) uint32

    func Uint32FromInt8

    func Uint32FromInt8(n int8) uint32

    func Uint32FromUint16

    func Uint32FromUint16(n uint16) uint32

    func Uint32FromUint32

    func Uint32FromUint32(n uint32) uint32

    func Uint32FromUint64

    func Uint32FromUint64(n uint64) uint32

    func Uint32FromUint8

    func Uint32FromUint8(n uint8) uint32

    func Uint32FromUintptr

    func Uint32FromUintptr(n uintptr) uint32

    func Uint64

    func Uint64(n uint64) uint64

    func Uint64FromFloat32

    func Uint64FromFloat32(n float32) uint64

    func Uint64FromFloat64

    func Uint64FromFloat64(n float64) uint64

    func Uint64FromInt16

    func Uint64FromInt16(n int16) uint64

    func Uint64FromInt32

    func Uint64FromInt32(n int32) uint64

    func Uint64FromInt64

    func Uint64FromInt64(n int64) uint64

    func Uint64FromInt8

    func Uint64FromInt8(n int8) uint64

    func Uint64FromUint16

    func Uint64FromUint16(n uint16) uint64

    func Uint64FromUint32

    func Uint64FromUint32(n uint32) uint64

    func Uint64FromUint64

    func Uint64FromUint64(n uint64) uint64

    func Uint64FromUint8

    func Uint64FromUint8(n uint8) uint64

    func Uint64FromUintptr

    func Uint64FromUintptr(n uintptr) uint64

    func Uint8

    func Uint8(n uint8) uint8

    func Uint8FromFloat32

    func Uint8FromFloat32(n float32) uint8

    func Uint8FromFloat64

    func Uint8FromFloat64(n float64) uint8

    func Uint8FromInt16

    func Uint8FromInt16(n int16) uint8

    func Uint8FromInt32

    func Uint8FromInt32(n int32) uint8

    func Uint8FromInt64

    func Uint8FromInt64(n int64) uint8

    func Uint8FromInt8

    func Uint8FromInt8(n int8) uint8

    func Uint8FromUint16

    func Uint8FromUint16(n uint16) uint8

    func Uint8FromUint32

    func Uint8FromUint32(n uint32) uint8

    func Uint8FromUint64

    func Uint8FromUint64(n uint64) uint8

    func Uint8FromUint8

    func Uint8FromUint8(n uint8) uint8

    func Uint8FromUintptr

    func Uint8FromUintptr(n uintptr) uint8

    func Uintptr

    func Uintptr(n uintptr) uintptr

    func UintptrFromFloat32

    func UintptrFromFloat32(n float32) uintptr

    func UintptrFromFloat64

    func UintptrFromFloat64(n float64) uintptr

    func UintptrFromInt16

    func UintptrFromInt16(n int16) uintptr

    func UintptrFromInt32

    func UintptrFromInt32(n int32) uintptr

    func UintptrFromInt64

    func UintptrFromInt64(n int64) uintptr

    func UintptrFromInt8

    func UintptrFromInt8(n int8) uintptr

    func UintptrFromUint16

    func UintptrFromUint16(n uint16) uintptr

    func UintptrFromUint32

    func UintptrFromUint32(n uint32) uintptr

    func UintptrFromUint64

    func UintptrFromUint64(n uint64) uintptr

    func UintptrFromUint8

    func UintptrFromUint8(n uint8) uintptr

    func UintptrFromUintptr

    func UintptrFromUintptr(n uintptr) uintptr

    func VaFloat32

    func VaFloat32(app *uintptr) float32

    func VaFloat64

    func VaFloat64(app *uintptr) float64

    func VaInt32

    func VaInt32(app *uintptr) int32

    func VaInt64

    func VaInt64(app *uintptr) int64

    func VaList

    func VaList(p uintptr, args ...interface{}) (r uintptr)

      VaList fills a varargs list at p with args and returns uintptr(p). The list must have been allocated by caller and it must not be in Go managed memory, ie. it must be pinned. Caller is responsible for freeing the list.

      Individual arguments must be one of int, uint, int32, uint32, int64, uint64, float64, uintptr or Intptr. Other types will panic.

      Note: The C translated to Go varargs ABI alignment for all types is 8 at all architectures.

      func VaUint32

      func VaUint32(app *uintptr) uint32

      func VaUint64

      func VaUint64(app *uintptr) uint64

      func VaUintptr

      func VaUintptr(app *uintptr) uintptr

      func Watch

      func Watch(x ...interface{})

      func WatchInt

      func WatchInt(p uintptr, s string)

      func WatchUintptr

      func WatchUintptr(p uintptr, s string)

      func X_IO_putc

      func X_IO_putc(t *TLS, c int32, fp uintptr) int32

        int _IO_putc(int c, _IO_FILE *fp);

        func X__assert_fail

        func X__assert_fail(t *TLS, assertion, file uintptr, line uint32, function uintptr)

          void __assert_fail(const char * assertion, const char * file, unsigned int line, const char * function);

          func X__builtin_abort

          func X__builtin_abort(t *TLS)

          func X__builtin_abs

          func X__builtin_abs(t *TLS, j int32) int32

          func X__builtin_copysign

          func X__builtin_copysign(t *TLS, x, y float64) float64

            double __builtin_copysign ( double x, double y );

            func X__builtin_copysignf

            func X__builtin_copysignf(t *TLS, x, y float32) float32

              float __builtin_copysignf ( float x, float y );

              func X__builtin_exit

              func X__builtin_exit(t *TLS, status int32)

              func X__builtin_expect

              func X__builtin_expect(t *TLS, exp, c long) long

                long __builtin_expect (long exp, long c)

                func X__builtin_fabs

                func X__builtin_fabs(t *TLS, x float64) float64

                func X__builtin_free

                func X__builtin_free(t *TLS, ptr uintptr)

                func X__builtin_huge_val

                func X__builtin_huge_val(t *TLS) float64

                  double __builtin_huge_val (void);

                  func X__builtin_huge_valg

                  func X__builtin_huge_valg(t *TLS) float32

                    float __builtin_huge_valf (void);

                    func X__builtin_inf

                    func X__builtin_inf(t *TLS) float64

                      double __builtin_inf (void)

                      func X__builtin_inff

                      func X__builtin_inff(t *TLS) float32

                        float __builtin_inf (void)

                        func X__builtin_malloc

                        func X__builtin_malloc(t *TLS, size Size_t) uintptr

                        func X__builtin_memcmp

                        func X__builtin_memcmp(t *TLS, s1, s2 uintptr, n Size_t) int32

                        func X__builtin_memcpy

                        func X__builtin_memcpy(t *TLS, dest, src uintptr, n Size_t) (r uintptr)

                        func X__builtin_memset

                        func X__builtin_memset(t *TLS, s uintptr, c int32, n Size_t) uintptr

                        func X__builtin_prefetch

                        func X__builtin_prefetch(t *TLS, addr, args uintptr)

                          void __builtin_prefetch (const void *addr, ...)

                          func X__builtin_printf

                          func X__builtin_printf(t *TLS, s, args uintptr) int32

                          func X__builtin_snprintf

                          func X__builtin_snprintf(t *TLS, str uintptr, size Size_t, format, args uintptr) (r int32)

                          func X__builtin_sprintf

                          func X__builtin_sprintf(t *TLS, str, format, args uintptr) (r int32)

                          func X__builtin_strchr

                          func X__builtin_strchr(t *TLS, s uintptr, c int32) uintptr

                          func X__builtin_strcmp

                          func X__builtin_strcmp(t *TLS, s1, s2 uintptr) int32

                          func X__builtin_strcpy

                          func X__builtin_strcpy(t *TLS, dest, src uintptr) uintptr

                          func X__builtin_trap

                          func X__builtin_trap(t *TLS)

                            void __builtin_trap (void)

                            func X__builtin_unreachable

                            func X__builtin_unreachable(t *TLS)

                              void __builtin_unreachable (void)

                              func X__ctype_b_loc

                              func X__ctype_b_loc(t *TLS) uintptr

                              func X__errno_location

                              func X__errno_location(t *TLS) uintptr

                                int * __errno_location(void);

                                func X__isnan

                                func X__isnan(t *TLS, arg float64) int32

                                  int __isnan(double arg);

                                  func X__isnanf

                                  func X__isnanf(t *TLS, arg float32) int32

                                    int __isnanf(float arg);

                                    func X__isnanl

                                    func X__isnanl(t *TLS, arg float64) int32

                                      int __isnan(long double arg);

                                      func X__isoc99_sscanf

                                      func X__isoc99_sscanf(t *TLS, str, format, va uintptr) int32

                                      func X_exit

                                      func X_exit(t *TLS, status int32)

                                        void _exit(int status);

                                        func Xabort

                                        func Xabort(t *TLS)

                                          void abort(void);

                                          func Xabs

                                          func Xabs(t *TLS, j int32) int32

                                            int abs(int j);

                                            func Xaccept

                                            func Xaccept(t *TLS, sockfd int32, addr uintptr, addrlen uintptr) int32

                                              int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

                                              func Xaccess

                                              func Xaccess(t *TLS, pathname uintptr, mode int32) int32

                                                int access(const char *pathname, int mode);

                                                func Xacos

                                                func Xacos(t *TLS, x float64) float64

                                                  double acos(double x);

                                                  func Xalarm

                                                  func Xalarm(t *TLS, seconds uint32) uint32

                                                    unsigned int alarm(unsigned int seconds);

                                                    func Xasin

                                                    func Xasin(t *TLS, x float64) float64

                                                      double asin(double x);

                                                      func Xatan

                                                      func Xatan(t *TLS, x float64) float64

                                                        double atan(double x);

                                                        func Xatan2

                                                        func Xatan2(t *TLS, x, y float64) float64

                                                          double atan2(double y, double x);

                                                          func Xatof

                                                          func Xatof(t *TLS, nptr uintptr) float64

                                                            double atof(const char *nptr);

                                                            func Xatoi

                                                            func Xatoi(t *TLS, nptr uintptr) int32

                                                              int atoi(const char *nptr);

                                                              func Xatol

                                                              func Xatol(t *TLS, nptr uintptr) (r long)

                                                                long atol(const char *nptr);

                                                                func Xbacktrace

                                                                func Xbacktrace(t *TLS, buf uintptr, size int32) int32

                                                                  int backtrace(void **buffer, int size);

                                                                  func Xbacktrace_symbols_fd

                                                                  func Xbacktrace_symbols_fd(t *TLS, buffer uintptr, size, fd int32) int32

                                                                    void backtrace_symbols_fd(void *const *buffer, int size, int fd);

                                                                    func Xbind

                                                                    func Xbind(t *TLS, sockfd int32, addr uintptr, addrlen uint32) int32

                                                                      int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

                                                                      func Xcalloc

                                                                      func Xcalloc(t *TLS, n, size Size_t) uintptr

                                                                        void *calloc(size_t nmemb, size_t size);

                                                                        func Xceil

                                                                        func Xceil(t *TLS, x float64) float64

                                                                          double ceil(double x);

                                                                          func Xcfgetospeed

                                                                          func Xcfgetospeed(t *TLS, termios_p uintptr) uint32

                                                                            speed_t cfgetospeed(const struct termios *termios_p);

                                                                            func Xcfsetispeed

                                                                            func Xcfsetispeed(t *TLS, termios_p uintptr, speed uint32) int32

                                                                              int cfsetispeed(struct termios *termios_p, speed_t speed);

                                                                              func Xcfsetospeed

                                                                              func Xcfsetospeed(t *TLS, termios_p uintptr, speed uint32) int32

                                                                                int cfsetospeed(struct termios *termios_p, speed_t speed);

                                                                                func Xchdir

                                                                                func Xchdir(t *TLS, path uintptr) int32

                                                                                  int chdir(const char *path);

                                                                                  func Xchmod

                                                                                  func Xchmod(t *TLS, pathname uintptr, mode uint32) int32

                                                                                    int chmod(const char *pathname, mode_t mode)

                                                                                    func Xchown

                                                                                    func Xchown(t *TLS, pathname uintptr, owner, group uint32) int32

                                                                                      int chown(const char *pathname, uid_t owner, gid_t group);

                                                                                      func Xclose

                                                                                      func Xclose(t *TLS, fd int32) int32

                                                                                        int close(int fd);

                                                                                        func Xclosedir

                                                                                        func Xclosedir(t *TLS, dir uintptr) int32

                                                                                          int closedir(DIR *dirp);

                                                                                          func Xconnect

                                                                                          func Xconnect(t *TLS, sockfd int32, addr uintptr, addrlen uint32) int32

                                                                                            int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

                                                                                            func Xcos

                                                                                            func Xcos(t *TLS, x float64) float64

                                                                                              double cos(double x);

                                                                                              func Xcosf

                                                                                              func Xcosf(t *TLS, x float32) float32

                                                                                                float cosf(float x);

                                                                                                func Xcosh

                                                                                                func Xcosh(t *TLS, x float64) float64

                                                                                                  double cosh(double x);

                                                                                                  func Xdlclose

                                                                                                  func Xdlclose(t *TLS, handle uintptr) int32

                                                                                                    int dlclose(void *handle);

                                                                                                    func Xdlerror

                                                                                                    func Xdlerror(t *TLS) uintptr

                                                                                                      char *dlerror(void);

                                                                                                      func Xdlopen

                                                                                                      func Xdlopen(t *TLS, filename uintptr, flags int32) uintptr

                                                                                                        void *dlopen(const char *filename, int flags);

                                                                                                        func Xdlsym

                                                                                                        func Xdlsym(t *TLS, handle, symbol uintptr) uintptr

                                                                                                          void *dlsym(void *handle, const char *symbol);

                                                                                                          func Xdup2

                                                                                                          func Xdup2(t *TLS, oldfd, newfd int32) int32

                                                                                                            int dup2(int oldfd, int newfd);

                                                                                                            func Xexecvp

                                                                                                            func Xexecvp(t *TLS, file, argv uintptr) int32

                                                                                                              int execvp(const char *file, char *const argv[]);

                                                                                                              func Xexit

                                                                                                              func Xexit(t *TLS, status int32)

                                                                                                                void exit(int status);

                                                                                                                func Xexp

                                                                                                                func Xexp(t *TLS, x float64) float64

                                                                                                                  double exp(double x);

                                                                                                                  func Xfabs

                                                                                                                  func Xfabs(t *TLS, x float64) float64

                                                                                                                    double fabs(double x);

                                                                                                                    func Xfabsf

                                                                                                                    func Xfabsf(t *TLS, x float32) float32

                                                                                                                      float fabs(float x);

                                                                                                                      func Xfchmod

                                                                                                                      func Xfchmod(t *TLS, fd int32, mode uint32) int32

                                                                                                                        int fchmod(int fd, mode_t mode);

                                                                                                                        func Xfchown

                                                                                                                        func Xfchown(t *TLS, fd int32, owner, group uint32) int32

                                                                                                                          int fchown(int fd, uid_t owner, gid_t group);

                                                                                                                          func Xfclose

                                                                                                                          func Xfclose(t *TLS, stream uintptr) int32

                                                                                                                            int fclose(FILE *stream);

                                                                                                                            func Xfcntl

                                                                                                                            func Xfcntl(t *TLS, fd, cmd int32, args uintptr) int32

                                                                                                                              int fcntl(int fd, int cmd, ... /* arg */ );

                                                                                                                              func Xfcntl64

                                                                                                                              func Xfcntl64(t *TLS, fd, cmd int32, args uintptr) int32

                                                                                                                                int fcntl64(int fd, int cmd, ... /* arg */ );

                                                                                                                                func Xfdopen

                                                                                                                                func Xfdopen(t *TLS, fd int32, mode uintptr) uintptr

                                                                                                                                  FILE *fdopen(int fd, const char *mode);

                                                                                                                                  func Xfflush

                                                                                                                                  func Xfflush(t *TLS, stream uintptr) int32

                                                                                                                                    int fflush(FILE *stream);

                                                                                                                                    func Xfgetc

                                                                                                                                    func Xfgetc(t *TLS, stream uintptr) int32

                                                                                                                                      int fgetc(FILE *stream);

                                                                                                                                      func Xfgets

                                                                                                                                      func Xfgets(t *TLS, s uintptr, size int32, stream uintptr) uintptr

                                                                                                                                        char *fgets(char *s, int size, FILE *stream);

                                                                                                                                        func Xfileno

                                                                                                                                        func Xfileno(t *TLS, stream uintptr) int32

                                                                                                                                          int fileno(FILE *stream);

                                                                                                                                          func Xfloor

                                                                                                                                          func Xfloor(t *TLS, x float64) float64

                                                                                                                                            double floor(double x);

                                                                                                                                            func Xfmod

                                                                                                                                            func Xfmod(t *TLS, x, y float64) float64

                                                                                                                                              double fmod(double x, double y);

                                                                                                                                              func Xfopen

                                                                                                                                              func Xfopen(t *TLS, pathname, mode uintptr) uintptr

                                                                                                                                                FILE *fopen(const char *pathname, const char *mode);

                                                                                                                                                func Xfopen64

                                                                                                                                                func Xfopen64(t *TLS, pathname, mode uintptr) uintptr

                                                                                                                                                  FILE *fopen64(const char *pathname, const char *mode);

                                                                                                                                                  func Xfork

                                                                                                                                                  func Xfork(t *TLS) int32

                                                                                                                                                    pid_t fork(void);

                                                                                                                                                    func Xfprintf

                                                                                                                                                    func Xfprintf(t *TLS, stream, format, args uintptr) int32

                                                                                                                                                      int fprintf(FILE *stream, const char *format, ...);

                                                                                                                                                      func Xfputc

                                                                                                                                                      func Xfputc(t *TLS, c int32, stream uintptr) int32

                                                                                                                                                        int fputc(int c, FILE *stream);

                                                                                                                                                        func Xfputs

                                                                                                                                                        func Xfputs(t *TLS, s, stream uintptr) int32

                                                                                                                                                          int fputs(const char *s, FILE *stream);

                                                                                                                                                          func Xfree

                                                                                                                                                          func Xfree(t *TLS, ptr uintptr)

                                                                                                                                                            void free(void *ptr);

                                                                                                                                                            func Xfreeaddrinfo

                                                                                                                                                            func Xfreeaddrinfo(t *TLS, res uintptr)

                                                                                                                                                              void freeaddrinfo(struct addrinfo *res);

                                                                                                                                                              func Xfrexp

                                                                                                                                                              func Xfrexp(t *TLS, x float64, exp uintptr) float64

                                                                                                                                                                double frexp(double x, int *exp);

                                                                                                                                                                func Xfseek

                                                                                                                                                                func Xfseek(t *TLS, stream uintptr, offset long, whence int32) int32

                                                                                                                                                                  int fseek(FILE *stream, long offset, int whence);

                                                                                                                                                                  func Xfstat64

                                                                                                                                                                  func Xfstat64(t *TLS, fd int32, statbuf uintptr) int32

                                                                                                                                                                    int fstat(int fd, struct stat *statbuf);

                                                                                                                                                                    func Xfsync

                                                                                                                                                                    func Xfsync(t *TLS, fd int32) int32

                                                                                                                                                                      int fsync(int fd);

                                                                                                                                                                      func Xftell

                                                                                                                                                                      func Xftell(t *TLS, stream uintptr) long

                                                                                                                                                                        long ftell(FILE *stream);

                                                                                                                                                                        func Xftruncate

                                                                                                                                                                        func Xftruncate(t *TLS, fd int32, length Intptr) int32

                                                                                                                                                                          int ftruncate(int fd, off_t length);

                                                                                                                                                                          func Xftruncate64

                                                                                                                                                                          func Xftruncate64(t *TLS, fd int32, length int64) int32

                                                                                                                                                                            int ftruncate(int fd, off_t length);

                                                                                                                                                                            func Xfts_close

                                                                                                                                                                            func Xfts_close(t *TLS, ftsp uintptr) int32

                                                                                                                                                                              int fts_close(FTS *ftsp);

                                                                                                                                                                              func Xfts_open

                                                                                                                                                                              func Xfts_open(t *TLS, path_argv uintptr, options int32, compar uintptr) uintptr

                                                                                                                                                                                FTS *fts_open(char * const *path_argv, int options, int (*compar)(const FTSENT **, const FTSENT **));

                                                                                                                                                                                func Xfts_read

                                                                                                                                                                                func Xfts_read(t *TLS, ftsp uintptr) uintptr

                                                                                                                                                                                  FTSENT *fts_read(FTS *ftsp);

                                                                                                                                                                                  func Xgai_strerror

                                                                                                                                                                                  func Xgai_strerror(t *TLS, errcode int32) uintptr

                                                                                                                                                                                    const char *gai_strerror(int errcode);

                                                                                                                                                                                    func Xgetaddrinfo

                                                                                                                                                                                    func Xgetaddrinfo(t *TLS, node, service, hints, addrinfo uintptr) int32

                                                                                                                                                                                      int getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res);

                                                                                                                                                                                      func Xgetcwd

                                                                                                                                                                                      func Xgetcwd(t *TLS, buf uintptr, size Size_t) uintptr

                                                                                                                                                                                        char *getcwd(char *buf, size_t size);

                                                                                                                                                                                        func Xgetenv

                                                                                                                                                                                        func Xgetenv(t *TLS, name uintptr) uintptr

                                                                                                                                                                                          char *getenv(const char *name);

                                                                                                                                                                                          func Xgeteuid

                                                                                                                                                                                          func Xgeteuid(t *TLS) uint32

                                                                                                                                                                                            uid_t geteuid(void);

                                                                                                                                                                                            func Xgetgrgid

                                                                                                                                                                                            func Xgetgrgid(t *TLS, gid uint32) uintptr

                                                                                                                                                                                              struct group *getgrgid(gid_t gid);

                                                                                                                                                                                              func Xgetgrnam

                                                                                                                                                                                              func Xgetgrnam(t *TLS, name uintptr) uintptr

                                                                                                                                                                                                struct group *getgrnam(const char *name);

                                                                                                                                                                                                func Xgethostbyaddr

                                                                                                                                                                                                func Xgethostbyaddr(t *TLS, addr uintptr, len uint32, type1 int32) uintptr

                                                                                                                                                                                                  struct hostent *gethostbyaddr(const void *addr, socklen_t len, int type);

                                                                                                                                                                                                  func Xgethostbyname

                                                                                                                                                                                                  func Xgethostbyname(t *TLS, name uintptr) uintptr

                                                                                                                                                                                                    struct hostent *gethostbyname(const char *name);

                                                                                                                                                                                                    func Xgetnameinfo

                                                                                                                                                                                                    func Xgetnameinfo(t *TLS, addr uintptr, addrlen uint32, host uintptr, hostlen uint32, serv uintptr, servlen uint32, flags int32) int32

                                                                                                                                                                                                      int getnameinfo(const struct sockaddr *addr, socklen_t addrlen, char *host, socklen_t hostlen, char *serv, socklen_t servlen, int flags);

                                                                                                                                                                                                      func Xgetpeername

                                                                                                                                                                                                      func Xgetpeername(t *TLS, sockfd int32, addr uintptr, addrlen uintptr) int32

                                                                                                                                                                                                        int getpeername(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

                                                                                                                                                                                                        func Xgetpid

                                                                                                                                                                                                        func Xgetpid(t *TLS) int32

                                                                                                                                                                                                          pid_t getpid(void);

                                                                                                                                                                                                          func Xgetpwnam

                                                                                                                                                                                                          func Xgetpwnam(t *TLS, name uintptr) uintptr

                                                                                                                                                                                                            struct passwd *getpwnam(const char *name);

                                                                                                                                                                                                            func Xgetpwuid

                                                                                                                                                                                                            func Xgetpwuid(t *TLS, uid uint32) uintptr

                                                                                                                                                                                                              struct passwd *getpwuid(uid_t uid);

                                                                                                                                                                                                              func Xgetrlimit

                                                                                                                                                                                                              func Xgetrlimit(t *TLS, resource int32, rlim uintptr) int32

                                                                                                                                                                                                                int getrlimit(int resource, struct rlimit *rlim);

                                                                                                                                                                                                                func Xgetrusage

                                                                                                                                                                                                                func Xgetrusage(t *TLS, who int32, usage uintptr) int32

                                                                                                                                                                                                                  int getrusage(int who, struct rusage *usage);

                                                                                                                                                                                                                  func Xgetservbyname

                                                                                                                                                                                                                  func Xgetservbyname(t *TLS, name, proto uintptr) uintptr

                                                                                                                                                                                                                    struct servent *getservbyname(const char *name, const char *proto);

                                                                                                                                                                                                                    func Xgetsockname

                                                                                                                                                                                                                    func Xgetsockname(t *TLS, sockfd int32, addr, addrlen uintptr) int32

                                                                                                                                                                                                                      int getsockname(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

                                                                                                                                                                                                                      func Xgetsockopt

                                                                                                                                                                                                                      func Xgetsockopt(t *TLS, sockfd, level, optname int32, optval, optlen uintptr) int32

                                                                                                                                                                                                                        int getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optlen);

                                                                                                                                                                                                                        func Xgettimeofday

                                                                                                                                                                                                                        func Xgettimeofday(t *TLS, tv, tz uintptr) int32

                                                                                                                                                                                                                          int gettimeofday(struct timeval *tv, struct timezone *tz);

                                                                                                                                                                                                                          func Xgetuid

                                                                                                                                                                                                                          func Xgetuid(t *TLS) uint32

                                                                                                                                                                                                                            uid_t getuid(void);

                                                                                                                                                                                                                            func Xgmtime_r

                                                                                                                                                                                                                            func Xgmtime_r(t *TLS, timep, result uintptr) uintptr

                                                                                                                                                                                                                              struct tm *gmtime_r(const time_t *timep, struct tm *result);

                                                                                                                                                                                                                              func Xhtonl

                                                                                                                                                                                                                              func Xhtonl(t *TLS, hostlong uint32) uint32

                                                                                                                                                                                                                                uint32_t htonl(uint32_t hostlong);

                                                                                                                                                                                                                                func Xhtons

                                                                                                                                                                                                                                func Xhtons(t *TLS, hostshort uint16) uint16

                                                                                                                                                                                                                                  uint16_t htons(uint16_t hostshort);

                                                                                                                                                                                                                                  func Xhypot

                                                                                                                                                                                                                                  func Xhypot(t *TLS, x, y float64) float64

                                                                                                                                                                                                                                    double hypot(double x, double y);

                                                                                                                                                                                                                                    func Xinet_ntoa

                                                                                                                                                                                                                                    func Xinet_ntoa(t *TLS, in struct{ Fs_addr uint32 }) uintptr

                                                                                                                                                                                                                                      char *inet_ntoa(struct in_addr in);

                                                                                                                                                                                                                                      func Xioctl

                                                                                                                                                                                                                                      func Xioctl(t *TLS, fd int32, request ulong, va uintptr) int32

                                                                                                                                                                                                                                        int ioctl(int fd, unsigned long request, ...);

                                                                                                                                                                                                                                        func Xisatty

                                                                                                                                                                                                                                        func Xisatty(t *TLS, fd int32) int32

                                                                                                                                                                                                                                          int isatty(int fd);

                                                                                                                                                                                                                                          func Xldexp

                                                                                                                                                                                                                                          func Xldexp(t *TLS, x float64, exp int32) float64

                                                                                                                                                                                                                                            double ldexp(double x, int exp);

                                                                                                                                                                                                                                            func Xlink(t *TLS, oldpath, newpath uintptr) int32

                                                                                                                                                                                                                                              int link(const char *oldpath, const char *newpath);

                                                                                                                                                                                                                                              func Xlisten

                                                                                                                                                                                                                                              func Xlisten(t *TLS, sockfd, backlog int32) int32

                                                                                                                                                                                                                                                int listen(int sockfd, int backlog);

                                                                                                                                                                                                                                                func Xlocaltime

                                                                                                                                                                                                                                                func Xlocaltime(_ *TLS, timep uintptr) uintptr

                                                                                                                                                                                                                                                  struct tm *localtime(const time_t *timep);

                                                                                                                                                                                                                                                  func Xlocaltime_r

                                                                                                                                                                                                                                                  func Xlocaltime_r(_ *TLS, timep, r uintptr) uintptr

                                                                                                                                                                                                                                                    struct tm *localtime_r(const time_t *timep, struct tm *result);

                                                                                                                                                                                                                                                    func Xlog

                                                                                                                                                                                                                                                    func Xlog(t *TLS, x float64) float64

                                                                                                                                                                                                                                                      double log(double x);

                                                                                                                                                                                                                                                      func Xlog10

                                                                                                                                                                                                                                                      func Xlog10(t *TLS, x float64) float64

                                                                                                                                                                                                                                                        double log10(double x);

                                                                                                                                                                                                                                                        func Xlseek64

                                                                                                                                                                                                                                                        func Xlseek64(t *TLS, fd int32, offset int64, whence int32) int64

                                                                                                                                                                                                                                                          off64_t lseek64(int fd, off64_t offset, int whence);

                                                                                                                                                                                                                                                          func Xlstat

                                                                                                                                                                                                                                                          func Xlstat(t *TLS, pathname, statbuf uintptr) int32

                                                                                                                                                                                                                                                            int lstat(const char *pathname, struct stat *statbuf);

                                                                                                                                                                                                                                                            func Xlstat64

                                                                                                                                                                                                                                                            func Xlstat64(t *TLS, pathname, stat uintptr) int32

                                                                                                                                                                                                                                                              int lstat(const char *pathname, struct stat *statbuf);

                                                                                                                                                                                                                                                              func Xmalloc

                                                                                                                                                                                                                                                              func Xmalloc(t *TLS, size Size_t) (r uintptr)

                                                                                                                                                                                                                                                                void *malloc(size_t size);

                                                                                                                                                                                                                                                                func Xmemchr

                                                                                                                                                                                                                                                                func Xmemchr(t *TLS, s uintptr, c int32, n Size_t) uintptr

                                                                                                                                                                                                                                                                  void *memchr(const void *s, int c, size_t n);

                                                                                                                                                                                                                                                                  func Xmemcmp

                                                                                                                                                                                                                                                                  func Xmemcmp(t *TLS, s1, s2 uintptr, n Size_t) int32

                                                                                                                                                                                                                                                                    int memcmp(const void *s1, const void *s2, size_t n);

                                                                                                                                                                                                                                                                    func Xmemcpy

                                                                                                                                                                                                                                                                    func Xmemcpy(t *TLS, dest, src uintptr, n Size_t) (r uintptr)

                                                                                                                                                                                                                                                                      void *memcpy(void *dest, const void *src, size_t n);

                                                                                                                                                                                                                                                                      func Xmemmove

                                                                                                                                                                                                                                                                      func Xmemmove(t *TLS, dest, src uintptr, n Size_t) uintptr

                                                                                                                                                                                                                                                                        void *memmove(void *dest, const void *src, size_t n);

                                                                                                                                                                                                                                                                        func Xmemset

                                                                                                                                                                                                                                                                        func Xmemset(t *TLS, s uintptr, c int32, n Size_t) uintptr

                                                                                                                                                                                                                                                                          void *memset(void *s, int c, size_t n)

                                                                                                                                                                                                                                                                          func Xmkdir

                                                                                                                                                                                                                                                                          func Xmkdir(t *TLS, path uintptr, mode uint32) int32

                                                                                                                                                                                                                                                                            int mkdir(const char *path, mode_t mode);

                                                                                                                                                                                                                                                                            func Xmkfifo

                                                                                                                                                                                                                                                                            func Xmkfifo(t *TLS, pathname uintptr, mode uint32) int32

                                                                                                                                                                                                                                                                              int mkfifo(const char *pathname, mode_t mode);

                                                                                                                                                                                                                                                                              func Xmknod

                                                                                                                                                                                                                                                                              func Xmknod(t *TLS, pathname uintptr, mode uint32, dev uint64) int32

                                                                                                                                                                                                                                                                                int mknod(const char *pathname, mode_t mode, dev_t dev);

                                                                                                                                                                                                                                                                                func Xmkstemp

                                                                                                                                                                                                                                                                                func Xmkstemp(t *TLS, template uintptr) int32

                                                                                                                                                                                                                                                                                  int mkstemp(char *template);

                                                                                                                                                                                                                                                                                  func Xmkstemps

                                                                                                                                                                                                                                                                                  func Xmkstemps(t *TLS, template uintptr, suffixlen int32) int32

                                                                                                                                                                                                                                                                                    int mkstemps(char *template, int suffixlen);

                                                                                                                                                                                                                                                                                    func Xmmap64

                                                                                                                                                                                                                                                                                    func Xmmap64(t *TLS, addr uintptr, length Size_t, prot, flags, fd int32, offset Ssize_t) uintptr

                                                                                                                                                                                                                                                                                      void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);

                                                                                                                                                                                                                                                                                      func Xmodf

                                                                                                                                                                                                                                                                                      func Xmodf(t *TLS, x float64, iptr uintptr) float64

                                                                                                                                                                                                                                                                                        double modf(double x, double *iptr);

                                                                                                                                                                                                                                                                                        func Xmunmap

                                                                                                                                                                                                                                                                                        func Xmunmap(t *TLS, addr uintptr, length Size_t) int32

                                                                                                                                                                                                                                                                                          int munmap(void *addr, size_t length);

                                                                                                                                                                                                                                                                                          func Xnl_langinfo

                                                                                                                                                                                                                                                                                          func Xnl_langinfo(t *TLS, item int32) uintptr

                                                                                                                                                                                                                                                                                            char *nl_langinfo(nl_item item);

                                                                                                                                                                                                                                                                                            func Xntohs

                                                                                                                                                                                                                                                                                            func Xntohs(t *TLS, netshort uint16) uint16

                                                                                                                                                                                                                                                                                              uint16_t ntohs(uint16_t netshort);

                                                                                                                                                                                                                                                                                              func Xopen

                                                                                                                                                                                                                                                                                              func Xopen(t *TLS, pathname uintptr, flags int32, args uintptr) int32

                                                                                                                                                                                                                                                                                                int open(const char *pathname, int flags, ...);

                                                                                                                                                                                                                                                                                                func Xopen64

                                                                                                                                                                                                                                                                                                func Xopen64(t *TLS, pathname uintptr, flags int32, args uintptr) int32

                                                                                                                                                                                                                                                                                                  int open(const char *pathname, int flags, ...);

                                                                                                                                                                                                                                                                                                  func Xopendir

                                                                                                                                                                                                                                                                                                  func Xopendir(t *TLS, name uintptr) uintptr

                                                                                                                                                                                                                                                                                                    DIR *opendir(const char *name);

                                                                                                                                                                                                                                                                                                    func Xpclose

                                                                                                                                                                                                                                                                                                    func Xpclose(t *TLS, stream uintptr) int32

                                                                                                                                                                                                                                                                                                      int pclose(FILE *stream);

                                                                                                                                                                                                                                                                                                      func Xperror

                                                                                                                                                                                                                                                                                                      func Xperror(t *TLS, s uintptr)

                                                                                                                                                                                                                                                                                                        void perror(const char *s);

                                                                                                                                                                                                                                                                                                        func Xpipe

                                                                                                                                                                                                                                                                                                        func Xpipe(t *TLS, pipefd uintptr) int32

                                                                                                                                                                                                                                                                                                          int pipe(int pipefd[2]);

                                                                                                                                                                                                                                                                                                          func Xpopen

                                                                                                                                                                                                                                                                                                          func Xpopen(t *TLS, command, typ uintptr) uintptr

                                                                                                                                                                                                                                                                                                            FILE *popen(const char *command, const char *type);

                                                                                                                                                                                                                                                                                                            func Xpow

                                                                                                                                                                                                                                                                                                            func Xpow(t *TLS, x, y float64) float64

                                                                                                                                                                                                                                                                                                              double pow(double x, double y);

                                                                                                                                                                                                                                                                                                              func Xprintf

                                                                                                                                                                                                                                                                                                              func Xprintf(t *TLS, s, args uintptr) int32

                                                                                                                                                                                                                                                                                                                int printf(const char *format, ...);

                                                                                                                                                                                                                                                                                                                func Xputc

                                                                                                                                                                                                                                                                                                                func Xputc(t *TLS, c int32, fp uintptr) int32

                                                                                                                                                                                                                                                                                                                func Xputchar

                                                                                                                                                                                                                                                                                                                func Xputchar(t *TLS, c int32) int32

                                                                                                                                                                                                                                                                                                                  int putchar(int c);

                                                                                                                                                                                                                                                                                                                  func Xputs

                                                                                                                                                                                                                                                                                                                  func Xputs(t *TLS, s uintptr) int32

                                                                                                                                                                                                                                                                                                                    int puts(const char *s);

                                                                                                                                                                                                                                                                                                                    func Xqsort

                                                                                                                                                                                                                                                                                                                    func Xqsort(t *TLS, base uintptr, nmemb, size Size_t, compar uintptr)

                                                                                                                                                                                                                                                                                                                      void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));

                                                                                                                                                                                                                                                                                                                      func Xraise

                                                                                                                                                                                                                                                                                                                      func Xraise(t *TLS, sig int32) int32

                                                                                                                                                                                                                                                                                                                        int raise(int sig);

                                                                                                                                                                                                                                                                                                                        func Xrand

                                                                                                                                                                                                                                                                                                                        func Xrand(t *TLS) int32

                                                                                                                                                                                                                                                                                                                          int rand(void);

                                                                                                                                                                                                                                                                                                                          func Xreaddir

                                                                                                                                                                                                                                                                                                                          func Xreaddir(t *TLS, dir uintptr) uintptr

                                                                                                                                                                                                                                                                                                                            struct dirent *readdir(DIR *dirp);

                                                                                                                                                                                                                                                                                                                            func Xreaddir64

                                                                                                                                                                                                                                                                                                                            func Xreaddir64(t *TLS, dir uintptr) uintptr

                                                                                                                                                                                                                                                                                                                              struct dirent *readdir(DIR *dirp);

                                                                                                                                                                                                                                                                                                                              func Xrealloc

                                                                                                                                                                                                                                                                                                                              func Xrealloc(t *TLS, ptr uintptr, size Size_t) uintptr

                                                                                                                                                                                                                                                                                                                                void *realloc(void *ptr, size_t size);

                                                                                                                                                                                                                                                                                                                                func Xrealpath

                                                                                                                                                                                                                                                                                                                                func Xrealpath(t *TLS, path, resolved_path uintptr) uintptr

                                                                                                                                                                                                                                                                                                                                  char *realpath(const char *path, char *resolved_path);

                                                                                                                                                                                                                                                                                                                                  func Xrename

                                                                                                                                                                                                                                                                                                                                  func Xrename(t *TLS, oldpath, newpath uintptr) int32

                                                                                                                                                                                                                                                                                                                                    int rename(const char *oldpath, const char *newpath);

                                                                                                                                                                                                                                                                                                                                    func Xrewind

                                                                                                                                                                                                                                                                                                                                    func Xrewind(t *TLS, stream uintptr)

                                                                                                                                                                                                                                                                                                                                      void rewind(FILE *stream);

                                                                                                                                                                                                                                                                                                                                      func Xrmdir

                                                                                                                                                                                                                                                                                                                                      func Xrmdir(t *TLS, pathname uintptr) int32

                                                                                                                                                                                                                                                                                                                                        int rmdir(const char *pathname);

                                                                                                                                                                                                                                                                                                                                        func Xround

                                                                                                                                                                                                                                                                                                                                        func Xround(t *TLS, x float64) float64

                                                                                                                                                                                                                                                                                                                                          double round(double x);

                                                                                                                                                                                                                                                                                                                                          func Xselect

                                                                                                                                                                                                                                                                                                                                          func Xselect(t *TLS, nfds int32, readfds, writefds, exceptfds, timeout uintptr) int32

                                                                                                                                                                                                                                                                                                                                            int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

                                                                                                                                                                                                                                                                                                                                            func Xsetlocale

                                                                                                                                                                                                                                                                                                                                            func Xsetlocale(t *TLS, category int32, locale uintptr) uintptr

                                                                                                                                                                                                                                                                                                                                              char *setlocale(int category, const char *locale);

                                                                                                                                                                                                                                                                                                                                              func Xsetrlimit

                                                                                                                                                                                                                                                                                                                                              func Xsetrlimit(t *TLS, resource int32, rlim uintptr) int32

                                                                                                                                                                                                                                                                                                                                                int setrlimit(int resource, const struct rlimit *rlim);

                                                                                                                                                                                                                                                                                                                                                func Xsetsockopt

                                                                                                                                                                                                                                                                                                                                                func Xsetsockopt(t *TLS, sockfd, level, optname int32, optval uintptr, optlen uint32) int32

                                                                                                                                                                                                                                                                                                                                                  int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);

                                                                                                                                                                                                                                                                                                                                                  func Xsetvbuf

                                                                                                                                                                                                                                                                                                                                                  func Xsetvbuf(t *TLS, stream, buf uintptr, mode int32, size Size_t) int32

                                                                                                                                                                                                                                                                                                                                                    int setvbuf(FILE *stream, char *buf, int mode, size_t size);

                                                                                                                                                                                                                                                                                                                                                    func Xshutdown

                                                                                                                                                                                                                                                                                                                                                    func Xshutdown(t *TLS, sockfd, how int32) int32

                                                                                                                                                                                                                                                                                                                                                      int shutdown(int sockfd, int how);

                                                                                                                                                                                                                                                                                                                                                      func Xsigaction

                                                                                                                                                                                                                                                                                                                                                      func Xsigaction(t *TLS, signum int32, act, oldact uintptr) int32

                                                                                                                                                                                                                                                                                                                                                        int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

                                                                                                                                                                                                                                                                                                                                                        func Xsin

                                                                                                                                                                                                                                                                                                                                                        func Xsin(t *TLS, x float64) float64

                                                                                                                                                                                                                                                                                                                                                          double sin(double x);

                                                                                                                                                                                                                                                                                                                                                          func Xsinf

                                                                                                                                                                                                                                                                                                                                                          func Xsinf(t *TLS, x float32) float32

                                                                                                                                                                                                                                                                                                                                                            float sinf(float x);

                                                                                                                                                                                                                                                                                                                                                            func Xsinh

                                                                                                                                                                                                                                                                                                                                                            func Xsinh(t *TLS, x float64) float64

                                                                                                                                                                                                                                                                                                                                                              double sinh(double x);

                                                                                                                                                                                                                                                                                                                                                              func Xsleep

                                                                                                                                                                                                                                                                                                                                                              func Xsleep(t *TLS, seconds uint32) uint32

                                                                                                                                                                                                                                                                                                                                                                unsigned int sleep(unsigned int seconds);

                                                                                                                                                                                                                                                                                                                                                                func Xsnprintf

                                                                                                                                                                                                                                                                                                                                                                func Xsnprintf(t *TLS, str uintptr, size Size_t, format, args uintptr) (r int32)

                                                                                                                                                                                                                                                                                                                                                                  int snprintf(char *str, size_t size, const char *format, ...);

                                                                                                                                                                                                                                                                                                                                                                  func Xsocket

                                                                                                                                                                                                                                                                                                                                                                  func Xsocket(t *TLS, domain, type1, protocol int32) int32

                                                                                                                                                                                                                                                                                                                                                                    int socket(int domain, int type, int protocol);

                                                                                                                                                                                                                                                                                                                                                                    func Xsprintf

                                                                                                                                                                                                                                                                                                                                                                    func Xsprintf(t *TLS, str, format, args uintptr) (r int32)

                                                                                                                                                                                                                                                                                                                                                                      int sprintf(char *str, const char *format, ...);

                                                                                                                                                                                                                                                                                                                                                                      func Xsqrt

                                                                                                                                                                                                                                                                                                                                                                      func Xsqrt(t *TLS, x float64) float64

                                                                                                                                                                                                                                                                                                                                                                        double sqrt(double x);

                                                                                                                                                                                                                                                                                                                                                                        func Xsscanf

                                                                                                                                                                                                                                                                                                                                                                        func Xsscanf(t *TLS, str, format, va uintptr) int32

                                                                                                                                                                                                                                                                                                                                                                          int sscanf(const char *str, const char *format, ...);

                                                                                                                                                                                                                                                                                                                                                                          func Xstat

                                                                                                                                                                                                                                                                                                                                                                          func Xstat(t *TLS, pathname, stat uintptr) int32

                                                                                                                                                                                                                                                                                                                                                                            int stat(const char *pathname, struct stat *statbuf);

                                                                                                                                                                                                                                                                                                                                                                            func Xstat64

                                                                                                                                                                                                                                                                                                                                                                            func Xstat64(t *TLS, pathname, stat uintptr) int32

                                                                                                                                                                                                                                                                                                                                                                              int stat(const char *pathname, struct stat *statbuf);

                                                                                                                                                                                                                                                                                                                                                                              func Xstrcasecmp

                                                                                                                                                                                                                                                                                                                                                                              func Xstrcasecmp(t *TLS, s1, s2 uintptr) int32

                                                                                                                                                                                                                                                                                                                                                                                int strcasecmp(const char *s1, const char *s2);

                                                                                                                                                                                                                                                                                                                                                                                func Xstrcat

                                                                                                                                                                                                                                                                                                                                                                                func Xstrcat(t *TLS, dest, src uintptr) uintptr

                                                                                                                                                                                                                                                                                                                                                                                  char *strcat(char *dest, const char *src)

                                                                                                                                                                                                                                                                                                                                                                                  func Xstrchr

                                                                                                                                                                                                                                                                                                                                                                                  func Xstrchr(t *TLS, s uintptr, c int32) uintptr

                                                                                                                                                                                                                                                                                                                                                                                    char *strchr(const char *s, int c)

                                                                                                                                                                                                                                                                                                                                                                                    func Xstrcmp

                                                                                                                                                                                                                                                                                                                                                                                    func Xstrcmp(t *TLS, s1, s2 uintptr) int32

                                                                                                                                                                                                                                                                                                                                                                                      int strcmp(const char *s1, const char *s2)

                                                                                                                                                                                                                                                                                                                                                                                      func Xstrcpy

                                                                                                                                                                                                                                                                                                                                                                                      func Xstrcpy(t *TLS, dest, src uintptr) uintptr

                                                                                                                                                                                                                                                                                                                                                                                        char *strcpy(char *dest, const char *src)

                                                                                                                                                                                                                                                                                                                                                                                        func Xstrdup

                                                                                                                                                                                                                                                                                                                                                                                        func Xstrdup(t *TLS, s uintptr) uintptr

                                                                                                                                                                                                                                                                                                                                                                                          char *strdup(const char *s);

                                                                                                                                                                                                                                                                                                                                                                                          func Xstrerror

                                                                                                                                                                                                                                                                                                                                                                                          func Xstrerror(t *TLS, errnum int32) uintptr

                                                                                                                                                                                                                                                                                                                                                                                            char *strerror(int errnum);

                                                                                                                                                                                                                                                                                                                                                                                            func Xstrncmp

                                                                                                                                                                                                                                                                                                                                                                                            func Xstrncmp(t *TLS, s1, s2 uintptr, n Size_t) int32

                                                                                                                                                                                                                                                                                                                                                                                              int strncmp(const char *s1, const char *s2, size_t n)

                                                                                                                                                                                                                                                                                                                                                                                              func Xstrncpy

                                                                                                                                                                                                                                                                                                                                                                                              func Xstrncpy(t *TLS, dest, src uintptr, n Size_t) uintptr

                                                                                                                                                                                                                                                                                                                                                                                                char *strncpy(char *dest, const char *src, size_t n)

                                                                                                                                                                                                                                                                                                                                                                                                func Xstrpbrk

                                                                                                                                                                                                                                                                                                                                                                                                func Xstrpbrk(t *TLS, s, accept uintptr) uintptr

                                                                                                                                                                                                                                                                                                                                                                                                  char *strpbrk(const char *s, const char *accept);

                                                                                                                                                                                                                                                                                                                                                                                                  func Xstrrchr

                                                                                                                                                                                                                                                                                                                                                                                                  func Xstrrchr(t *TLS, s uintptr, c int32) uintptr

                                                                                                                                                                                                                                                                                                                                                                                                    char *strrchr(const char *s, int c)

                                                                                                                                                                                                                                                                                                                                                                                                    func Xstrstr

                                                                                                                                                                                                                                                                                                                                                                                                    func Xstrstr(t *TLS, haystack, needle uintptr) uintptr

                                                                                                                                                                                                                                                                                                                                                                                                      char *strstr(const char *haystack, const char *needle);

                                                                                                                                                                                                                                                                                                                                                                                                      func Xstrtol

                                                                                                                                                                                                                                                                                                                                                                                                      func Xstrtol(t *TLS, nptr, endptr uintptr, base int32) (r long)

                                                                                                                                                                                                                                                                                                                                                                                                        long int strtol(const char *nptr, char **endptr, int base);

                                                                                                                                                                                                                                                                                                                                                                                                        func Xstrtoul

                                                                                                                                                                                                                                                                                                                                                                                                        func Xstrtoul(t *TLS, nptr, endptr uintptr, base int32) (r ulong)

                                                                                                                                                                                                                                                                                                                                                                                                          unsigned long int strtoul(const char *nptr, char **endptr, int base);

                                                                                                                                                                                                                                                                                                                                                                                                          func Xsymlink(t *TLS, target, linkpath uintptr) int32

                                                                                                                                                                                                                                                                                                                                                                                                            int symlink(const char *target, const char *linkpath);

                                                                                                                                                                                                                                                                                                                                                                                                            func Xsysconf

                                                                                                                                                                                                                                                                                                                                                                                                            func Xsysconf(t *TLS, name int32) long

                                                                                                                                                                                                                                                                                                                                                                                                              long sysconf(int name);

                                                                                                                                                                                                                                                                                                                                                                                                              func Xsystem

                                                                                                                                                                                                                                                                                                                                                                                                              func Xsystem(t *TLS, command uintptr) int32

                                                                                                                                                                                                                                                                                                                                                                                                                int system(const char *command);

                                                                                                                                                                                                                                                                                                                                                                                                                func Xtan

                                                                                                                                                                                                                                                                                                                                                                                                                func Xtan(t *TLS, x float64) float64

                                                                                                                                                                                                                                                                                                                                                                                                                  double tan(double x);

                                                                                                                                                                                                                                                                                                                                                                                                                  func Xtanh

                                                                                                                                                                                                                                                                                                                                                                                                                  func Xtanh(t *TLS, x float64) float64

                                                                                                                                                                                                                                                                                                                                                                                                                    double tanh(double x);

                                                                                                                                                                                                                                                                                                                                                                                                                    func Xtcgetattr

                                                                                                                                                                                                                                                                                                                                                                                                                    func Xtcgetattr(t *TLS, fd int32, termios_p uintptr) int32

                                                                                                                                                                                                                                                                                                                                                                                                                      int tcgetattr(int fd, struct termios *termios_p);

                                                                                                                                                                                                                                                                                                                                                                                                                      func Xtcsetattr

                                                                                                                                                                                                                                                                                                                                                                                                                      func Xtcsetattr(t *TLS, fd, optional_actions int32, termios_p uintptr) int32

                                                                                                                                                                                                                                                                                                                                                                                                                        int tcsetattr(int fd, int optional_actions, const struct termios *termios_p);

                                                                                                                                                                                                                                                                                                                                                                                                                        func Xtolower

                                                                                                                                                                                                                                                                                                                                                                                                                        func Xtolower(t *TLS, c int32) int32

                                                                                                                                                                                                                                                                                                                                                                                                                          int tolower(int c);

                                                                                                                                                                                                                                                                                                                                                                                                                          func Xtoupper

                                                                                                                                                                                                                                                                                                                                                                                                                          func Xtoupper(t *TLS, c int32) int32

                                                                                                                                                                                                                                                                                                                                                                                                                            int toupper(int c);

                                                                                                                                                                                                                                                                                                                                                                                                                            func Xtzset

                                                                                                                                                                                                                                                                                                                                                                                                                            func Xtzset(t *TLS)

                                                                                                                                                                                                                                                                                                                                                                                                                              void tzset (void);

                                                                                                                                                                                                                                                                                                                                                                                                                              func Xumask

                                                                                                                                                                                                                                                                                                                                                                                                                              func Xumask(t *TLS, mask uint32) uint32

                                                                                                                                                                                                                                                                                                                                                                                                                                mode_t umask(mode_t mask);

                                                                                                                                                                                                                                                                                                                                                                                                                                func Xuname

                                                                                                                                                                                                                                                                                                                                                                                                                                func Xuname(t *TLS, buf uintptr) int32

                                                                                                                                                                                                                                                                                                                                                                                                                                  int uname(struct utsname *buf);

                                                                                                                                                                                                                                                                                                                                                                                                                                  func Xunlink(t *TLS, pathname uintptr) int32

                                                                                                                                                                                                                                                                                                                                                                                                                                    int unlink(const char *pathname);

                                                                                                                                                                                                                                                                                                                                                                                                                                    func Xusleep

                                                                                                                                                                                                                                                                                                                                                                                                                                    func Xusleep(t *TLS, usec uint32) int32

                                                                                                                                                                                                                                                                                                                                                                                                                                      int usleep(useconds_t usec);

                                                                                                                                                                                                                                                                                                                                                                                                                                      func Xutime

                                                                                                                                                                                                                                                                                                                                                                                                                                      func Xutime(t *TLS, file, times uintptr) int32

                                                                                                                                                                                                                                                                                                                                                                                                                                        int utime(const char *filename, const struct utimbuf *times);

                                                                                                                                                                                                                                                                                                                                                                                                                                        func Xutimes

                                                                                                                                                                                                                                                                                                                                                                                                                                        func Xutimes(t *TLS, filename, times uintptr) int32

                                                                                                                                                                                                                                                                                                                                                                                                                                          int utimes(const char *filename, const struct timeval times[2]);

                                                                                                                                                                                                                                                                                                                                                                                                                                          func Xvfprintf

                                                                                                                                                                                                                                                                                                                                                                                                                                          func Xvfprintf(t *TLS, stream, format, ap uintptr) int32

                                                                                                                                                                                                                                                                                                                                                                                                                                            int vfprintf(FILE *stream, const char *format, va_list ap);

                                                                                                                                                                                                                                                                                                                                                                                                                                            func Xvprintf

                                                                                                                                                                                                                                                                                                                                                                                                                                            func Xvprintf(t *TLS, s, ap uintptr) int32

                                                                                                                                                                                                                                                                                                                                                                                                                                              int vprintf(const char *format, va_list ap);

                                                                                                                                                                                                                                                                                                                                                                                                                                              func Xwaitpid

                                                                                                                                                                                                                                                                                                                                                                                                                                              func Xwaitpid(t *TLS, pid int32, wstatus uintptr, optname int32) int32

                                                                                                                                                                                                                                                                                                                                                                                                                                                pid_t waitpid(pid_t pid, int *wstatus, int options);

                                                                                                                                                                                                                                                                                                                                                                                                                                                Types

                                                                                                                                                                                                                                                                                                                                                                                                                                                type Intptr

                                                                                                                                                                                                                                                                                                                                                                                                                                                type Intptr = int64

                                                                                                                                                                                                                                                                                                                                                                                                                                                func Xlseek

                                                                                                                                                                                                                                                                                                                                                                                                                                                func Xlseek(t *TLS, fd int32, offset Intptr, whence int32) Intptr

                                                                                                                                                                                                                                                                                                                                                                                                                                                  off_t lseek(int fd, off_t offset, int whence);

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func Xmktime

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func Xmktime(t *TLS, ptm uintptr) Intptr

                                                                                                                                                                                                                                                                                                                                                                                                                                                    time_t mktime(struct tm *tm);

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func Xsignal

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func Xsignal(t *TLS, signum int32, handler uintptr) Intptr

                                                                                                                                                                                                                                                                                                                                                                                                                                                      sighandler_t signal(int signum, sighandler_t handler);

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func Xtime

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func Xtime(t *TLS, tloc uintptr) Intptr

                                                                                                                                                                                                                                                                                                                                                                                                                                                        time_t time(time_t *tloc);

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type RawMem

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type RawMem [1<<50 - 1]byte

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Size_t

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Size_t = uint64

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func X__builtin_strlen

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func X__builtin_strlen(t *TLS, s uintptr) Size_t

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func Xfread

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func Xfread(t *TLS, ptr uintptr, size, nmemb Size_t, stream uintptr) Size_t

                                                                                                                                                                                                                                                                                                                                                                                                                                                          size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func Xfwrite

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func Xfwrite(t *TLS, ptr uintptr, size, nmemb Size_t, stream uintptr) Size_t

                                                                                                                                                                                                                                                                                                                                                                                                                                                            size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func Xstrcspn

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func Xstrcspn(t *TLS, s, reject uintptr) (r Size_t)

                                                                                                                                                                                                                                                                                                                                                                                                                                                              size_t strcspn(const char *s, const char *reject);

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func Xstrlen

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func Xstrlen(t *TLS, s uintptr) Size_t

                                                                                                                                                                                                                                                                                                                                                                                                                                                                size_t strlen(const char *s)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Ssize_t

                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Ssize_t = int64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func Xread

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func Xread(t *TLS, fd int32, buf uintptr, count Size_t) Ssize_t

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ssize_t read(int fd, void *buf, size_t count);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func Xreadlink(t *TLS, path, buf uintptr, bufsize Size_t) Ssize_t

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ssize_t readlink(const char *restrict path, char *restrict buf, size_t bufsize);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func Xrecv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func Xrecv(t *TLS, sockfd int32, buf uintptr, len Size_t, flags int32) Ssize_t

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ssize_t recv(int sockfd, void *buf, size_t len, int flags);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func Xsend

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func Xsend(t *TLS, sockfd int32, buf uintptr, len Size_t, flags int32) Ssize_t

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ssize_t send(int sockfd, const void *buf, size_t len, int flags);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func Xwrite

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func Xwrite(t *TLS, fd int32, buf uintptr, count Size_t) Ssize_t

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ssize_t write(int fd, const void *buf, size_t count);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TLS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TLS struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ID int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewTLS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewTLS() *TLS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*TLS) Alloc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (t *TLS) Alloc(n int) (r uintptr)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*TLS) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (t *TLS) Close()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*TLS) DynAlloc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (t *TLS) DynAlloc(a *[]uintptr, n uintptr) uintptr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*TLS) Free

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (t *TLS) Free(n int)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*TLS) FreeList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (t *TLS) FreeList(a []uintptr)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Directories

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Path Synopsis
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          libc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          pwd