libc_linux_amd64.go

//go:build linux && amd64 && go1.25

// Code generated by c2go-bind. DO NOT EDIT.
// Licensing follows the translated input and its third-party provenance; see
// the c2go-libc NOTICE, provenance inventory, and bundled license texts.

package libc

import (
	"unsafe"
)

// ─── Types ──────────────────────────────────────────────────
type cookie_io_functions_t struct {
	read  uintptr
	write uintptr
	seek  uintptr
	close uintptr
}
type div_t struct {
	quot int32
	rem  int32
}
type entry struct {
	key  *byte
	data unsafe.Pointer
}
type imaxdiv_t struct {
	quot int64
	rem  int64
}
type ldiv_t struct {
	quot int64
	rem  int64
}
type lldiv_t struct {
	quot int64
	rem  int64
}

// ─── Forward-only opaque types ───────────────────
// Types declared in C as `typedef struct X X;` without a
// matching definition in any c2go-compiled TU. Emitted as
// zero-size opaque structs; pointers to them remain valid
// handles but contents are inaccessible from Go-side code.
type __dirstream struct{}
type __locale_struct struct{}
type __mbstate_t struct{}
type __va_list_tag struct{}
type dirent struct{}
type glob_t struct{}
type hsearch_data struct{}
type iovec struct{}
type lconv struct{}
type option struct{}
type pthread_condattr_t struct{}
type pthread_mutexattr_t struct{}
type pthread_rwlockattr_t struct{}
type re_pattern_buffer struct{}
type regmatch_t struct{}
type rlimit struct{}
type rusage struct{}
type sigaction struct{}
type stat struct{}
type termios struct{}
type timespec struct{}
type timeval struct{}
type tm struct{}
type tre_mem_struct struct{}
type utsname struct{}
type winsize struct{}

// ─── Function declarations ──────────────────────────────────
// Bodies provided by clang-emitted Plan 9 .s with TEXT ·<name>(SB)
// at ABI0. Go compiler auto-generates the ABIInternal wrapper.

func SnprintfProbe(buf *byte, n int32, depth int32) int32

//go:linkname AssertFail github.com/c2gohq/c2go_libc.__assert_fail
func AssertFail(expr *byte, file *byte, line int32, fn *byte)

//go:linkname C2goFileRawClose github.com/c2gohq/c2go_libc.__c2go_file_raw_close
func C2goFileRawClose(f *FILE) int32

//go:linkname C2goFileRawFdopen github.com/c2gohq/c2go_libc.__c2go_file_raw_fdopen
func C2goFileRawFdopen(f *FILE, fd int32, mode *byte, storage *byte, storage_size uint64) int32

//go:linkname C2goFileRawFgetwc github.com/c2gohq/c2go_libc.__c2go_file_raw_fgetwc
func C2goFileRawFgetwc(f *FILE) uint32

//go:linkname C2goFileRawFgetws github.com/c2gohq/c2go_libc.__c2go_file_raw_fgetws
func C2goFileRawFgetws(s *int32, n int32, f *FILE) *int32

//go:linkname C2goFileRawFmemopen github.com/c2gohq/c2go_libc.__c2go_file_raw_fmemopen
func C2goFileRawFmemopen(f *FILE, cookie_storage unsafe.Pointer, cookie_storage_size uint64, storage *byte, storage_size uint64, buf unsafe.Pointer, size uint64, mode *byte) int32

//go:linkname C2goFileRawFputwc github.com/c2gohq/c2go_libc.__c2go_file_raw_fputwc
func C2goFileRawFputwc(c int32, f *FILE) uint32

//go:linkname C2goFileRawFputws github.com/c2gohq/c2go_libc.__c2go_file_raw_fputws
func C2goFileRawFputws(ws *int32, f *FILE) int32

//go:linkname C2goFileRawFwide github.com/c2gohq/c2go_libc.__c2go_file_raw_fwide
func C2goFileRawFwide(f *FILE, mode int32) int32

//go:linkname C2goFileRawGetdelimManaged github.com/c2gohq/c2go_libc.__c2go_file_raw_getdelim_managed
func C2goFileRawGetdelimManaged(s *unsafe.Pointer, n *uint64, delim int32, f *FILE) int64

//go:linkname C2goFileRawOpen github.com/c2gohq/c2go_libc.__c2go_file_raw_open
func C2goFileRawOpen(f *FILE, filename *byte, mode *byte, storage *byte, storage_size uint64) int32

//go:linkname C2goFileRawStdinit github.com/c2gohq/c2go_libc.__c2go_file_raw_stdinit
func C2goFileRawStdinit(f *FILE, which int32, storage *byte, storage_size uint64) int32

//go:linkname C2goFileRawUngetwc github.com/c2gohq/c2go_libc.__c2go_file_raw_ungetwc
func C2goFileRawUngetwc(c uint32, f *FILE) uint32

//go:linkname C2goFileRawVfscanfManaged github.com/c2gohq/c2go_libc.__c2go_file_raw_vfscanf_managed
func C2goFileRawVfscanfManaged(f *FILE, fmt *byte, ap *__va_list_tag) int32

//go:linkname C2goFileRawVfwprintf github.com/c2gohq/c2go_libc.__c2go_file_raw_vfwprintf
func C2goFileRawVfwprintf(f *FILE, fmt *int32, ap *__va_list_tag) int32

//go:linkname C2goFileRawVfwscanfManaged github.com/c2gohq/c2go_libc.__c2go_file_raw_vfwscanf_managed
func C2goFileRawVfwscanfManaged(f *FILE, fmt *int32, ap *__va_list_tag) int32

//go:linkname C2goFinalize github.com/c2gohq/c2go_libc.__c2go_finalize
func C2goFinalize()

//go:linkname C2goPthreadRun github.com/c2gohq/c2go_libc.__c2go_pthread_run
func C2goPthreadRun(start uintptr, arg unsafe.Pointer) unsafe.Pointer

//go:linkname C2goPthreadRunDtor github.com/c2gohq/c2go_libc.__c2go_pthread_run_dtor
func C2goPthreadRunDtor(fn uintptr, arg unsafe.Pointer)

//go:linkname C2goPthreadRunVoid github.com/c2gohq/c2go_libc.__c2go_pthread_run_void
func C2goPthreadRunVoid(fn uintptr)
func __c2go_signal_dispatch_abort()

//go:linkname C2goSignalRun github.com/c2gohq/c2go_libc.__c2go_signal_run
func C2goSignalRun(sig int32, h uint64)

//go:linkname C2goStdfile github.com/c2gohq/c2go_libc.__c2go_stdfile
func C2goStdfile(which int32) *FILE

//go:linkname C2goVsscanfManaged github.com/c2gohq/c2go_libc.__c2go_vsscanf_managed
func C2goVsscanfManaged(s *byte, fmt *byte, ap *__va_list_tag) int32

//go:linkname C2goVswscanfManaged github.com/c2gohq/c2go_libc.__c2go_vswscanf_managed
func C2goVswscanfManaged(s *int32, fmt *int32, ap *__va_list_tag) int32
func __cos(x float64, y float64) float64
func __cosdf(x float64) float32

//go:linkname CtypeGetMbCurMax github.com/c2gohq/c2go_libc.__ctype_get_mb_cur_max
func CtypeGetMbCurMax() uint64

//go:linkname EnvironSync github.com/c2gohq/c2go_libc.__environ_sync
func EnvironSync()
func __expo2(x float64, sign float64) float64
func __expo2f(x float32, sign float32) float32
func __fesetround(r int32) int32
func __getopt_msg(a *byte, b *byte, c *byte, l uint64)
func __lgamma_r(x float64, signgamp *int32) float64
func __lgammaf_r(x float32, signgamp *int32) float32
func __mbrtoc32(pc *uint32, src *byte, n uint64, st *__mbstate_t) uint64
func __qsort_r(base unsafe.Pointer, nel uint64, width uint64, cmp uintptr, arg unsafe.Pointer)
func __rand48_step(xi *uint16, lc *uint16) uint64
func __rem_pio2(x float64, y *float64) int32
func __rem_pio2_large(x *float64, y *float64, e0 int32, nx int32, prec int32) int32
func __rem_pio2f(x float32, y *float64) int32
func __sin(x float64, y float64, iy int32) float64
func __sindf(x float64) float32
func __strcoll_l(l *byte, r *byte, loc *__locale_struct) int32
func __strxfrm_l(dest *byte, src *byte, n uint64, loc *__locale_struct) uint64

//go:linkname SurrogateToUtf8 github.com/c2gohq/c2go_libc.__surrogate_to_utf8
func SurrogateToUtf8(s *byte, hi uint32, lo uint32) uint64
func __tan(x float64, y float64, odd int32) float64
func __tandf(x float64, odd int32) float32
func __tre_mem_alloc_impl(mem *tre_mem_struct, provided int32, provided_block unsafe.Pointer, zero int32, size uint64) unsafe.Pointer
func __tre_mem_destroy(mem *tre_mem_struct)
func __tre_mem_new_impl(provided int32, provided_block unsafe.Pointer) *tre_mem_struct
func __tsearch_balance(p *unsafe.Pointer) int32
func __wcscoll_l(l *int32, r *int32, locale *__locale_struct) int32
func __wcsxfrm_l(dest *int32, src *int32, n uint64, loc *__locale_struct) uint64

//go:linkname A64l github.com/c2gohq/c2go_libc.a64l
func A64l(s *byte) int64

//go:linkname Abort github.com/c2gohq/c2go_libc.abort
func Abort()

//go:linkname Abs github.com/c2gohq/c2go_libc.abs
func Abs(a int32) int32

//go:linkname Access github.com/c2gohq/c2go_libc.access
func Access(path *byte, amode int32) int32

//go:linkname Acos github.com/c2gohq/c2go_libc.acos
func Acos(x float64) float64

//go:linkname Acosf github.com/c2gohq/c2go_libc.acosf
func Acosf(x float32) float32

//go:linkname Acosh github.com/c2gohq/c2go_libc.acosh
func Acosh(x float64) float64

//go:linkname Acoshf github.com/c2gohq/c2go_libc.acoshf
func Acoshf(x float32) float32

//go:linkname Alphasort github.com/c2gohq/c2go_libc.alphasort
func Alphasort(a **dirent, b **dirent) int32

//go:linkname Asctime github.com/c2gohq/c2go_libc.asctime
func Asctime(tm *tm) *byte

//go:linkname AsctimeR github.com/c2gohq/c2go_libc.asctime_r
func AsctimeR(tm *tm, buf *byte) *byte

//go:linkname Asin github.com/c2gohq/c2go_libc.asin
func Asin(x float64) float64

//go:linkname Asinf github.com/c2gohq/c2go_libc.asinf
func Asinf(x float32) float32

//go:linkname Asinh github.com/c2gohq/c2go_libc.asinh
func Asinh(x float64) float64

//go:linkname Asinhf github.com/c2gohq/c2go_libc.asinhf
func Asinhf(x float32) float32

//go:linkname Asprintf github.com/c2gohq/c2go_libc.asprintf
func Asprintf(s **byte, fmt *byte, argptrs unsafe.Pointer) int32

//go:linkname AtQuickExit github.com/c2gohq/c2go_libc.at_quick_exit
func AtQuickExit(f uintptr) int32

//go:linkname Atan github.com/c2gohq/c2go_libc.atan
func Atan(x float64) float64

//go:linkname Atan2 github.com/c2gohq/c2go_libc.atan2
func Atan2(y float64, x float64) float64

//go:linkname Atan2f github.com/c2gohq/c2go_libc.atan2f
func Atan2f(y float32, x float32) float32

//go:linkname Atanf github.com/c2gohq/c2go_libc.atanf
func Atanf(x float32) float32

//go:linkname Atanh github.com/c2gohq/c2go_libc.atanh
func Atanh(x float64) float64

//go:linkname Atanhf github.com/c2gohq/c2go_libc.atanhf
func Atanhf(x float32) float32

//go:linkname Atexit github.com/c2gohq/c2go_libc.atexit
func Atexit(f uintptr) int32

//go:linkname Atof github.com/c2gohq/c2go_libc.atof
func Atof(s *byte) float64

//go:linkname Atoi github.com/c2gohq/c2go_libc.atoi
func Atoi(s *byte) int32

//go:linkname Atol github.com/c2gohq/c2go_libc.atol
func Atol(s *byte) int64

//go:linkname Atoll github.com/c2gohq/c2go_libc.atoll
func Atoll(s *byte) int64

//go:linkname Basename github.com/c2gohq/c2go_libc.basename
func Basename(s *byte) *byte

//go:linkname BindTextdomainCodeset github.com/c2gohq/c2go_libc.bind_textdomain_codeset
func BindTextdomainCodeset(domainname *byte, codeset *byte) *byte

//go:linkname Bindtextdomain github.com/c2gohq/c2go_libc.bindtextdomain
func Bindtextdomain(domainname *byte, dirname *byte) *byte

//go:linkname Bsearch github.com/c2gohq/c2go_libc.bsearch
func Bsearch(key unsafe.Pointer, base unsafe.Pointer, nel uint64, width uint64, cmp uintptr) unsafe.Pointer

//go:linkname Btowc github.com/c2gohq/c2go_libc.btowc
func Btowc(c int32) uint32

//go:linkname Bzero github.com/c2gohq/c2go_libc.bzero
func Bzero(s unsafe.Pointer, n uint64)

//go:linkname C16rtomb github.com/c2gohq/c2go_libc.c16rtomb
func C16rtomb(s *byte, c16 uint16, ps *__mbstate_t) uint64

//go:linkname C32rtomb github.com/c2gohq/c2go_libc.c32rtomb
func C32rtomb(s *byte, c32 uint32, ps *__mbstate_t) uint64

//go:linkname Cbrt github.com/c2gohq/c2go_libc.cbrt
func Cbrt(x float64) float64

//go:linkname Cbrtf github.com/c2gohq/c2go_libc.cbrtf
func Cbrtf(x float32) float32

//go:linkname Ceil github.com/c2gohq/c2go_libc.ceil
func Ceil(x float64) float64

//go:linkname Ceilf github.com/c2gohq/c2go_libc.ceilf
func Ceilf(x float32) float32

//go:linkname Cfgetispeed github.com/c2gohq/c2go_libc.cfgetispeed
func Cfgetispeed(tio *termios) uint32

//go:linkname Cfgetospeed github.com/c2gohq/c2go_libc.cfgetospeed
func Cfgetospeed(tio *termios) uint32

//go:linkname Cfmakeraw github.com/c2gohq/c2go_libc.cfmakeraw
func Cfmakeraw(t *termios)

//go:linkname Cfsetispeed github.com/c2gohq/c2go_libc.cfsetispeed
func Cfsetispeed(tio *termios, speed uint32) int32

//go:linkname Cfsetospeed github.com/c2gohq/c2go_libc.cfsetospeed
func Cfsetospeed(tio *termios, speed uint32) int32

//go:linkname Cfsetspeed github.com/c2gohq/c2go_libc.cfsetspeed
func Cfsetspeed(tio *termios, speed uint32) int32

//go:linkname Chdir github.com/c2gohq/c2go_libc.chdir
func Chdir(path *byte) int32

//go:linkname Chmod github.com/c2gohq/c2go_libc.chmod
func Chmod(path *byte, mode uint32) int32

//go:linkname Chown github.com/c2gohq/c2go_libc.chown
func Chown(path *byte, uid uint32, gid uint32) int32

//go:linkname Clearenv github.com/c2gohq/c2go_libc.clearenv
func Clearenv() int32

//go:linkname Clearerr github.com/c2gohq/c2go_libc.clearerr
func Clearerr(f *FILE)

//go:linkname Clock github.com/c2gohq/c2go_libc.clock
func Clock() int64

//go:linkname ClockGetres github.com/c2gohq/c2go_libc.clock_getres
func ClockGetres(id int32, ts *timespec) int32

//go:linkname ClockGettime github.com/c2gohq/c2go_libc.clock_gettime
func ClockGettime(id int32, ts *timespec) int32

//go:linkname Close github.com/c2gohq/c2go_libc.close
func Close(fd int32) int32

//go:linkname Closedir github.com/c2gohq/c2go_libc.closedir
func Closedir(d *__dirstream) int32

//go:linkname Copysign github.com/c2gohq/c2go_libc.copysign
func Copysign(x float64, y float64) float64

//go:linkname Copysignf github.com/c2gohq/c2go_libc.copysignf
func Copysignf(x float32, y float32) float32

//go:linkname Cos github.com/c2gohq/c2go_libc.cos
func Cos(x float64) float64

//go:linkname Cosf github.com/c2gohq/c2go_libc.cosf
func Cosf(x float32) float32

//go:linkname Cosh github.com/c2gohq/c2go_libc.cosh
func Cosh(x float64) float64

//go:linkname Coshf github.com/c2gohq/c2go_libc.coshf
func Coshf(x float32) float32

//go:linkname Creat github.com/c2gohq/c2go_libc.creat
func Creat(path *byte, mode uint32) int32

//go:linkname Ctime github.com/c2gohq/c2go_libc.ctime
func Ctime(t *int64) *byte

//go:linkname CtimeR github.com/c2gohq/c2go_libc.ctime_r
func CtimeR(t *int64, buf *byte) *byte

//go:linkname Dcgettext github.com/c2gohq/c2go_libc.dcgettext
func Dcgettext(domainname *byte, msgid *byte, category int32) *byte

//go:linkname Dcngettext github.com/c2gohq/c2go_libc.dcngettext
func Dcngettext(domainname *byte, msgid1 *byte, msgid2 *byte, n uint64, category int32) *byte

//go:linkname Dgettext github.com/c2gohq/c2go_libc.dgettext
func Dgettext(domainname *byte, msgid *byte) *byte

//go:linkname Difftime github.com/c2gohq/c2go_libc.difftime
func Difftime(t1 int64, t0 int64) float64

//go:linkname Dirfd github.com/c2gohq/c2go_libc.dirfd
func Dirfd(d *__dirstream) int32

//go:linkname Dirname github.com/c2gohq/c2go_libc.dirname
func Dirname(s *byte) *byte

//go:linkname Div github.com/c2gohq/c2go_libc.div
func Div(num int32, den int32) (int32, int32)

//go:linkname Dngettext github.com/c2gohq/c2go_libc.dngettext
func Dngettext(domainname *byte, msgid1 *byte, msgid2 *byte, n uint64) *byte

//go:linkname Dprintf github.com/c2gohq/c2go_libc.dprintf
func Dprintf(fd int32, fmt *byte, argptrs unsafe.Pointer) int32

//go:linkname Drand48 github.com/c2gohq/c2go_libc.drand48
func Drand48() float64

//go:linkname Dup github.com/c2gohq/c2go_libc.dup
func Dup(fd int32) int32

//go:linkname Dup2 github.com/c2gohq/c2go_libc.dup2
func Dup2(oldfd int32, newfd int32) int32

//go:linkname Dup3 github.com/c2gohq/c2go_libc.dup3
func Dup3(oldfd int32, newfd int32, flags int32) int32

//go:linkname Duplocale github.com/c2gohq/c2go_libc.duplocale
func Duplocale(loc *__locale_struct) *__locale_struct

//go:linkname Erand48 github.com/c2gohq/c2go_libc.erand48
func Erand48(s *uint16) float64

//go:linkname Erf github.com/c2gohq/c2go_libc.erf
func Erf(x float64) float64

//go:linkname Erfc github.com/c2gohq/c2go_libc.erfc
func Erfc(x float64) float64

//go:linkname Erfcf github.com/c2gohq/c2go_libc.erfcf
func Erfcf(x float32) float32

//go:linkname Erff github.com/c2gohq/c2go_libc.erff
func Erff(x float32) float32

//go:linkname Err github.com/c2gohq/c2go_libc.err
func Err(status int32, fmt *byte, argptrs unsafe.Pointer)

//go:linkname Errx github.com/c2gohq/c2go_libc.errx
func Errx(status int32, fmt *byte, argptrs unsafe.Pointer)

//go:linkname Exit github.com/c2gohq/c2go_libc.exit
func Exit(code int32)

//go:linkname Exp github.com/c2gohq/c2go_libc.exp
func Exp(x float64) float64

//go:linkname Exp10 github.com/c2gohq/c2go_libc.exp10
func Exp10(x float64) float64

//go:linkname Exp2 github.com/c2gohq/c2go_libc.exp2
func Exp2(x float64) float64

//go:linkname Exp2f github.com/c2gohq/c2go_libc.exp2f
func Exp2f(x float32) float32

//go:linkname Expf github.com/c2gohq/c2go_libc.expf
func Expf(x float32) float32

//go:linkname ExplicitBzero github.com/c2gohq/c2go_libc.explicit_bzero
func ExplicitBzero(d unsafe.Pointer, n uint64)

//go:linkname Expm1 github.com/c2gohq/c2go_libc.expm1
func Expm1(x float64) float64

//go:linkname Expm1f github.com/c2gohq/c2go_libc.expm1f
func Expm1f(x float32) float32

//go:linkname Fabs github.com/c2gohq/c2go_libc.fabs
func Fabs(x float64) float64

//go:linkname Fabsf github.com/c2gohq/c2go_libc.fabsf
func Fabsf(x float32) float32

//go:linkname Fchdir github.com/c2gohq/c2go_libc.fchdir
func Fchdir(fd int32) int32

//go:linkname Fchmod github.com/c2gohq/c2go_libc.fchmod
func Fchmod(fd int32, mode uint32) int32

//go:linkname Fchown github.com/c2gohq/c2go_libc.fchown
func Fchown(fd int32, uid uint32, gid uint32) int32

//go:linkname Fclose github.com/c2gohq/c2go_libc.fclose
func Fclose(f *FILE) int32

//go:linkname Fcntl github.com/c2gohq/c2go_libc.fcntl
func Fcntl(fd int32, cmd int32, argptrs unsafe.Pointer) int32

//go:linkname Fdatasync github.com/c2gohq/c2go_libc.fdatasync
func Fdatasync(fd int32) int32

//go:linkname Fdim github.com/c2gohq/c2go_libc.fdim
func Fdim(x float64, y float64) float64

//go:linkname Fdimf github.com/c2gohq/c2go_libc.fdimf
func Fdimf(x float32, y float32) float32

//go:linkname Fdopen github.com/c2gohq/c2go_libc.fdopen
func Fdopen(fd int32, mode *byte) *FILE

//go:linkname Fdopendir github.com/c2gohq/c2go_libc.fdopendir
func Fdopendir(fd int32) *__dirstream

//go:linkname Feclearexcept github.com/c2gohq/c2go_libc.feclearexcept
func Feclearexcept(mask int32) int32

//go:linkname Fegetenv github.com/c2gohq/c2go_libc.fegetenv
func Fegetenv(envp *uint32) int32

//go:linkname Fegetround github.com/c2gohq/c2go_libc.fegetround
func Fegetround() int32

//go:linkname Feof github.com/c2gohq/c2go_libc.feof
func Feof(f *FILE) int32

//go:linkname Feraiseexcept github.com/c2gohq/c2go_libc.feraiseexcept
func Feraiseexcept(mask int32) int32

//go:linkname Ferror github.com/c2gohq/c2go_libc.ferror
func Ferror(f *FILE) int32

//go:linkname Fesetenv github.com/c2gohq/c2go_libc.fesetenv
func Fesetenv(envp *uint32) int32

//go:linkname Fesetround github.com/c2gohq/c2go_libc.fesetround
func Fesetround(r int32) int32

//go:linkname Fetestexcept github.com/c2gohq/c2go_libc.fetestexcept
func Fetestexcept(mask int32) int32

//go:linkname Fflush github.com/c2gohq/c2go_libc.fflush
func Fflush(f *FILE) int32

//go:linkname Ffs github.com/c2gohq/c2go_libc.ffs
func Ffs(i int32) int32

//go:linkname Ffsl github.com/c2gohq/c2go_libc.ffsl
func Ffsl(i int64) int32

//go:linkname Ffsll github.com/c2gohq/c2go_libc.ffsll
func Ffsll(i int64) int32

//go:linkname Fgetc github.com/c2gohq/c2go_libc.fgetc
func Fgetc(f *FILE) int32

//go:linkname Fgetpos github.com/c2gohq/c2go_libc.fgetpos
func Fgetpos(f *FILE, pos *int64) int32

//go:linkname Fgets github.com/c2gohq/c2go_libc.fgets
func Fgets(s *byte, n int32, f *FILE) *byte

//go:linkname Fgetwc github.com/c2gohq/c2go_libc.fgetwc
func Fgetwc(f *FILE) uint32

//go:linkname Fgetws github.com/c2gohq/c2go_libc.fgetws
func Fgetws(s *int32, n int32, f *FILE) *int32

//go:linkname Fileno github.com/c2gohq/c2go_libc.fileno
func Fileno(f *FILE) int32

//go:linkname Flock github.com/c2gohq/c2go_libc.flock
func Flock(fd int32, op int32) int32

//go:linkname Flockfile github.com/c2gohq/c2go_libc.flockfile
func Flockfile(f *FILE)

//go:linkname Floor github.com/c2gohq/c2go_libc.floor
func Floor(x float64) float64

//go:linkname Floorf github.com/c2gohq/c2go_libc.floorf
func Floorf(x float32) float32

//go:linkname Fma github.com/c2gohq/c2go_libc.fma
func Fma(x float64, y float64, z float64) float64

//go:linkname Fmaf github.com/c2gohq/c2go_libc.fmaf
func Fmaf(x float32, y float32, z float32) float32

//go:linkname Fmax github.com/c2gohq/c2go_libc.fmax
func Fmax(x float64, y float64) float64

//go:linkname Fmaxf github.com/c2gohq/c2go_libc.fmaxf
func Fmaxf(x float32, y float32) float32

//go:linkname Fmemopen github.com/c2gohq/c2go_libc.fmemopen
func Fmemopen(buf unsafe.Pointer, size uint64, mode *byte) *FILE

//go:linkname Fmin github.com/c2gohq/c2go_libc.fmin
func Fmin(x float64, y float64) float64

//go:linkname Fminf github.com/c2gohq/c2go_libc.fminf
func Fminf(x float32, y float32) float32

//go:linkname Fmod github.com/c2gohq/c2go_libc.fmod
func Fmod(x float64, y float64) float64

//go:linkname Fmodf github.com/c2gohq/c2go_libc.fmodf
func Fmodf(x float32, y float32) float32

//go:linkname Fnmatch github.com/c2gohq/c2go_libc.fnmatch
func Fnmatch(pat *byte, str *byte, flags int32) int32

//go:linkname Fopen github.com/c2gohq/c2go_libc.fopen
func Fopen(filename *byte, mode *byte) *FILE

//go:linkname Fopencookie github.com/c2gohq/c2go_libc.fopencookie
func Fopencookie(cookie unsafe.Pointer, mode *byte, iofuncs cookie_io_functions_t) *FILE

//go:linkname Fprintf github.com/c2gohq/c2go_libc.fprintf
func Fprintf(f *FILE, fmt *byte, argptrs unsafe.Pointer) int32

//go:linkname Fputc github.com/c2gohq/c2go_libc.fputc
func Fputc(c int32, f *FILE) int32

//go:linkname Fputs github.com/c2gohq/c2go_libc.fputs
func Fputs(s *byte, f *FILE) int32

//go:linkname Fputwc github.com/c2gohq/c2go_libc.fputwc
func Fputwc(c int32, f *FILE) uint32

//go:linkname Fputws github.com/c2gohq/c2go_libc.fputws
func Fputws(ws *int32, f *FILE) int32

//go:linkname Fread github.com/c2gohq/c2go_libc.fread
func Fread(destv unsafe.Pointer, size uint64, nmemb uint64, f *FILE) uint64

//go:linkname Freelocale github.com/c2gohq/c2go_libc.freelocale
func Freelocale(loc *__locale_struct)

//go:linkname Freopen github.com/c2gohq/c2go_libc.freopen
func Freopen(filename *byte, mode *byte, f *FILE) *FILE

//go:linkname Frexp github.com/c2gohq/c2go_libc.frexp
func Frexp(x float64, e *int32) float64

//go:linkname Frexpf github.com/c2gohq/c2go_libc.frexpf
func Frexpf(x float32, e *int32) float32

//go:linkname Fscanf github.com/c2gohq/c2go_libc.fscanf
func Fscanf(f *FILE, fmt *byte, argptrs unsafe.Pointer) int32

//go:linkname Fseek github.com/c2gohq/c2go_libc.fseek
func Fseek(f *FILE, off int64, whence int32) int32

//go:linkname Fseeko github.com/c2gohq/c2go_libc.fseeko
func Fseeko(f *FILE, off int64, whence int32) int32

//go:linkname Fsetpos github.com/c2gohq/c2go_libc.fsetpos
func Fsetpos(f *FILE, pos *int64) int32

//go:linkname Fstat github.com/c2gohq/c2go_libc.fstat
func Fstat(fd int32, buf *stat) int32

//go:linkname Fstatat github.com/c2gohq/c2go_libc.fstatat
func Fstatat(dirfd int32, path *byte, st *stat, flags int32) int32

//go:linkname Fsync github.com/c2gohq/c2go_libc.fsync
func Fsync(fd int32) int32

//go:linkname Ftell github.com/c2gohq/c2go_libc.ftell
func Ftell(f *FILE) int64

//go:linkname Ftello github.com/c2gohq/c2go_libc.ftello
func Ftello(f *FILE) int64

//go:linkname Ftruncate github.com/c2gohq/c2go_libc.ftruncate
func Ftruncate(fd int32, len int64) int32

//go:linkname Ftrylockfile github.com/c2gohq/c2go_libc.ftrylockfile
func Ftrylockfile(f *FILE) int32

//go:linkname Ftw github.com/c2gohq/c2go_libc.ftw
func Ftw(path *byte, fn uintptr, fd_limit int32) int32

//go:linkname Funlockfile github.com/c2gohq/c2go_libc.funlockfile
func Funlockfile(f *FILE)

//go:linkname Futimens github.com/c2gohq/c2go_libc.futimens
func Futimens(fd int32, times *timespec) int32

//go:linkname Fwide github.com/c2gohq/c2go_libc.fwide
func Fwide(f *FILE, mode int32) int32

//go:linkname Fwprintf github.com/c2gohq/c2go_libc.fwprintf
func Fwprintf(f *FILE, fmt *int32, argptrs unsafe.Pointer) int32

//go:linkname Fwrite github.com/c2gohq/c2go_libc.fwrite
func Fwrite(src unsafe.Pointer, size uint64, nmemb uint64, f *FILE) uint64

//go:linkname Fwscanf github.com/c2gohq/c2go_libc.fwscanf
func Fwscanf(f *FILE, fmt *int32, argptrs unsafe.Pointer) int32

//go:linkname Getc github.com/c2gohq/c2go_libc.getc
func Getc(f *FILE) int32

//go:linkname Getchar github.com/c2gohq/c2go_libc.getchar
func Getchar() int32

//go:linkname Getcwd github.com/c2gohq/c2go_libc.getcwd
func Getcwd(buf *byte, size uint64) *byte

//go:linkname Getdelim github.com/c2gohq/c2go_libc.getdelim
func Getdelim(s **byte, n *uint64, delim int32, f *FILE) int64

//go:linkname Getentropy github.com/c2gohq/c2go_libc.getentropy
func Getentropy(buf unsafe.Pointer, n uint64) int32

//go:linkname Gethostname github.com/c2gohq/c2go_libc.gethostname
func Gethostname(buf *byte, n uint64) int32

//go:linkname Getline github.com/c2gohq/c2go_libc.getline
func Getline(s **byte, n *uint64, f *FILE) int64

//go:linkname Getopt github.com/c2gohq/c2go_libc.getopt
func Getopt(argc int32, argv **byte, optstring *byte) int32

//go:linkname GetoptLong github.com/c2gohq/c2go_libc.getopt_long
func GetoptLong(argc int32, argv **byte, optstring *byte, longopts *option, idx *int32) int32

//go:linkname GetoptLongOnly github.com/c2gohq/c2go_libc.getopt_long_only
func GetoptLongOnly(argc int32, argv **byte, optstring *byte, longopts *option, idx *int32) int32

//go:linkname Getpagesize github.com/c2gohq/c2go_libc.getpagesize
func Getpagesize() int32

//go:linkname Getrlimit github.com/c2gohq/c2go_libc.getrlimit
func Getrlimit(resource int32, rlim *rlimit) int32

//go:linkname Getrusage github.com/c2gohq/c2go_libc.getrusage
func Getrusage(who int32, ru *rusage) int32

//go:linkname Getsubopt github.com/c2gohq/c2go_libc.getsubopt
func Getsubopt(opt **byte, keys **byte, val **byte) int32

//go:linkname Gettext github.com/c2gohq/c2go_libc.gettext
func Gettext(msgid *byte) *byte

//go:linkname Gettimeofday github.com/c2gohq/c2go_libc.gettimeofday
func Gettimeofday(tv *timeval, tz unsafe.Pointer) int32

//go:linkname Getw github.com/c2gohq/c2go_libc.getw
func Getw(f *FILE) int32

//go:linkname Getwc github.com/c2gohq/c2go_libc.getwc
func Getwc(f *FILE) uint32

//go:linkname Getwchar github.com/c2gohq/c2go_libc.getwchar
func Getwchar() uint32

//go:linkname Glob github.com/c2gohq/c2go_libc.glob
func Glob(pat *byte, flags int32, errfunc uintptr, g *glob_t) int32

//go:linkname Globfree github.com/c2gohq/c2go_libc.globfree
func Globfree(g *glob_t)

//go:linkname Gmtime github.com/c2gohq/c2go_libc.gmtime
func Gmtime(t *int64) *tm

//go:linkname GmtimeR github.com/c2gohq/c2go_libc.gmtime_r
func GmtimeR(t *int64, tm *tm) *tm

//go:linkname Hcreate github.com/c2gohq/c2go_libc.hcreate
func Hcreate(nel uint64) int32

//go:linkname HcreateR github.com/c2gohq/c2go_libc.hcreate_r
func HcreateR(nel uint64, htab *hsearch_data) int32

//go:linkname Hdestroy github.com/c2gohq/c2go_libc.hdestroy
func Hdestroy()

//go:linkname HdestroyR github.com/c2gohq/c2go_libc.hdestroy_r
func HdestroyR(htab *hsearch_data)

//go:linkname Hsearch github.com/c2gohq/c2go_libc.hsearch
func Hsearch(item entry, action uintptr) *entry

//go:linkname HsearchR github.com/c2gohq/c2go_libc.hsearch_r
func HsearchR(item entry, action uintptr, retval **entry, htab *hsearch_data) int32

//go:linkname Hypot github.com/c2gohq/c2go_libc.hypot
func Hypot(x float64, y float64) float64

//go:linkname Hypotf github.com/c2gohq/c2go_libc.hypotf
func Hypotf(x float32, y float32) float32
func iconv(cd unsafe.Pointer, in **byte, inleft *uint64, out **byte, outleft *uint64) uint64
func iconv_close(cd unsafe.Pointer) int32
func iconv_open(to *byte, from *byte) unsafe.Pointer

//go:linkname Ilogb github.com/c2gohq/c2go_libc.ilogb
func Ilogb(x float64) int32

//go:linkname Ilogbf github.com/c2gohq/c2go_libc.ilogbf
func Ilogbf(x float32) int32

//go:linkname Imaxabs github.com/c2gohq/c2go_libc.imaxabs
func Imaxabs(a int64) int64

//go:linkname Imaxdiv github.com/c2gohq/c2go_libc.imaxdiv
func Imaxdiv(num int64, den int64) (int64, int64)

//go:linkname Initstate github.com/c2gohq/c2go_libc.initstate
func Initstate(seed uint32, state *byte, size uint64) *byte

//go:linkname Insque github.com/c2gohq/c2go_libc.insque
func Insque(element unsafe.Pointer, pred unsafe.Pointer)

//go:linkname Ioctl github.com/c2gohq/c2go_libc.ioctl
func Ioctl(fd int32, req int32, argptrs unsafe.Pointer) int32

//go:linkname Isalnum github.com/c2gohq/c2go_libc.isalnum
func Isalnum(c int32) int32

//go:linkname IsalnumL github.com/c2gohq/c2go_libc.isalnum_l
func IsalnumL(c int32, l *__locale_struct) int32

//go:linkname Isalpha github.com/c2gohq/c2go_libc.isalpha
func Isalpha(c int32) int32

//go:linkname IsalphaL github.com/c2gohq/c2go_libc.isalpha_l
func IsalphaL(c int32, l *__locale_struct) int32

//go:linkname Isascii github.com/c2gohq/c2go_libc.isascii
func Isascii(c int32) int32

//go:linkname Isatty github.com/c2gohq/c2go_libc.isatty
func Isatty(fd int32) int32

//go:linkname Isblank github.com/c2gohq/c2go_libc.isblank
func Isblank(c int32) int32

//go:linkname IsblankL github.com/c2gohq/c2go_libc.isblank_l
func IsblankL(c int32, l *__locale_struct) int32

//go:linkname Iscntrl github.com/c2gohq/c2go_libc.iscntrl
func Iscntrl(c int32) int32

//go:linkname IscntrlL github.com/c2gohq/c2go_libc.iscntrl_l
func IscntrlL(c int32, l *__locale_struct) int32

//go:linkname Isdigit github.com/c2gohq/c2go_libc.isdigit
func Isdigit(c int32) int32

//go:linkname IsdigitL github.com/c2gohq/c2go_libc.isdigit_l
func IsdigitL(c int32, l *__locale_struct) int32

//go:linkname Isgraph github.com/c2gohq/c2go_libc.isgraph
func Isgraph(c int32) int32

//go:linkname IsgraphL github.com/c2gohq/c2go_libc.isgraph_l
func IsgraphL(c int32, l *__locale_struct) int32

//go:linkname Islower github.com/c2gohq/c2go_libc.islower
func Islower(c int32) int32

//go:linkname IslowerL github.com/c2gohq/c2go_libc.islower_l
func IslowerL(c int32, l *__locale_struct) int32

//go:linkname Isprint github.com/c2gohq/c2go_libc.isprint
func Isprint(c int32) int32

//go:linkname IsprintL github.com/c2gohq/c2go_libc.isprint_l
func IsprintL(c int32, l *__locale_struct) int32

//go:linkname Ispunct github.com/c2gohq/c2go_libc.ispunct
func Ispunct(c int32) int32

//go:linkname IspunctL github.com/c2gohq/c2go_libc.ispunct_l
func IspunctL(c int32, l *__locale_struct) int32

//go:linkname Isspace github.com/c2gohq/c2go_libc.isspace
func Isspace(c int32) int32

//go:linkname IsspaceL github.com/c2gohq/c2go_libc.isspace_l
func IsspaceL(c int32, l *__locale_struct) int32

//go:linkname Isupper github.com/c2gohq/c2go_libc.isupper
func Isupper(c int32) int32

//go:linkname IsupperL github.com/c2gohq/c2go_libc.isupper_l
func IsupperL(c int32, l *__locale_struct) int32

//go:linkname Iswalnum github.com/c2gohq/c2go_libc.iswalnum
func Iswalnum(wc uint32) int32

//go:linkname IswalnumL github.com/c2gohq/c2go_libc.iswalnum_l
func IswalnumL(c uint32, l *__locale_struct) int32

//go:linkname Iswalpha github.com/c2gohq/c2go_libc.iswalpha
func Iswalpha(wc uint32) int32

//go:linkname IswalphaL github.com/c2gohq/c2go_libc.iswalpha_l
func IswalphaL(c uint32, l *__locale_struct) int32

//go:linkname Iswblank github.com/c2gohq/c2go_libc.iswblank
func Iswblank(wc uint32) int32

//go:linkname IswblankL github.com/c2gohq/c2go_libc.iswblank_l
func IswblankL(c uint32, l *__locale_struct) int32

//go:linkname Iswcntrl github.com/c2gohq/c2go_libc.iswcntrl
func Iswcntrl(wc uint32) int32

//go:linkname IswcntrlL github.com/c2gohq/c2go_libc.iswcntrl_l
func IswcntrlL(c uint32, l *__locale_struct) int32

//go:linkname Iswctype github.com/c2gohq/c2go_libc.iswctype
func Iswctype(wc uint32, t uint64) int32

//go:linkname IswctypeL github.com/c2gohq/c2go_libc.iswctype_l
func IswctypeL(c uint32, t uint64, l *__locale_struct) int32

//go:linkname Iswdigit github.com/c2gohq/c2go_libc.iswdigit
func Iswdigit(wc uint32) int32

//go:linkname IswdigitL github.com/c2gohq/c2go_libc.iswdigit_l
func IswdigitL(c uint32, l *__locale_struct) int32

//go:linkname Iswgraph github.com/c2gohq/c2go_libc.iswgraph
func Iswgraph(wc uint32) int32

//go:linkname IswgraphL github.com/c2gohq/c2go_libc.iswgraph_l
func IswgraphL(c uint32, l *__locale_struct) int32

//go:linkname Iswlower github.com/c2gohq/c2go_libc.iswlower
func Iswlower(wc uint32) int32

//go:linkname IswlowerL github.com/c2gohq/c2go_libc.iswlower_l
func IswlowerL(c uint32, l *__locale_struct) int32

//go:linkname Iswprint github.com/c2gohq/c2go_libc.iswprint
func Iswprint(wc uint32) int32

//go:linkname IswprintL github.com/c2gohq/c2go_libc.iswprint_l
func IswprintL(c uint32, l *__locale_struct) int32

//go:linkname Iswpunct github.com/c2gohq/c2go_libc.iswpunct
func Iswpunct(wc uint32) int32

//go:linkname IswpunctL github.com/c2gohq/c2go_libc.iswpunct_l
func IswpunctL(c uint32, l *__locale_struct) int32

//go:linkname Iswspace github.com/c2gohq/c2go_libc.iswspace
func Iswspace(wc uint32) int32

//go:linkname IswspaceL github.com/c2gohq/c2go_libc.iswspace_l
func IswspaceL(c uint32, l *__locale_struct) int32

//go:linkname Iswupper github.com/c2gohq/c2go_libc.iswupper
func Iswupper(wc uint32) int32

//go:linkname IswupperL github.com/c2gohq/c2go_libc.iswupper_l
func IswupperL(c uint32, l *__locale_struct) int32

//go:linkname Iswxdigit github.com/c2gohq/c2go_libc.iswxdigit
func Iswxdigit(wc uint32) int32

//go:linkname IswxdigitL github.com/c2gohq/c2go_libc.iswxdigit_l
func IswxdigitL(c uint32, l *__locale_struct) int32

//go:linkname Isxdigit github.com/c2gohq/c2go_libc.isxdigit
func Isxdigit(c int32) int32

//go:linkname IsxdigitL github.com/c2gohq/c2go_libc.isxdigit_l
func IsxdigitL(c int32, l *__locale_struct) int32

//go:linkname J0 github.com/c2gohq/c2go_libc.j0
func J0(x float64) float64

//go:linkname J1 github.com/c2gohq/c2go_libc.j1
func J1(x float64) float64

//go:linkname Jn github.com/c2gohq/c2go_libc.jn
func Jn(n int32, x float64) float64

//go:linkname Jrand48 github.com/c2gohq/c2go_libc.jrand48
func Jrand48(s *uint16) int64

//go:linkname L64a github.com/c2gohq/c2go_libc.l64a
func L64a(x0 int64) *byte

//go:linkname Labs github.com/c2gohq/c2go_libc.labs
func Labs(a int64) int64

//go:linkname Lchown github.com/c2gohq/c2go_libc.lchown
func Lchown(path *byte, uid uint32, gid uint32) int32

//go:linkname Lcong48 github.com/c2gohq/c2go_libc.lcong48
func Lcong48(p *uint16)

//go:linkname Ldexp github.com/c2gohq/c2go_libc.ldexp
func Ldexp(x float64, n int32) float64

//go:linkname Ldexpf github.com/c2gohq/c2go_libc.ldexpf
func Ldexpf(x float32, n int32) float32

//go:linkname Ldiv github.com/c2gohq/c2go_libc.ldiv
func Ldiv(num int64, den int64) (int64, int64)

//go:linkname Lfind github.com/c2gohq/c2go_libc.lfind
func Lfind(key unsafe.Pointer, base unsafe.Pointer, nelp *uint64, width uint64, compar uintptr) unsafe.Pointer

//go:linkname Lgamma github.com/c2gohq/c2go_libc.lgamma
func Lgamma(x float64) float64

//go:linkname LgammaR github.com/c2gohq/c2go_libc.lgamma_r
func LgammaR(x float64, signgamp *int32) float64

//go:linkname Lgammaf github.com/c2gohq/c2go_libc.lgammaf
func Lgammaf(x float32) float32

//go:linkname LgammafR github.com/c2gohq/c2go_libc.lgammaf_r
func LgammafR(x float32, signgamp *int32) float32

//go:linkname Link github.com/c2gohq/c2go_libc.link
func Link(from *byte, to *byte) int32

//go:linkname Llabs github.com/c2gohq/c2go_libc.llabs
func Llabs(a int64) int64

//go:linkname Lldiv github.com/c2gohq/c2go_libc.lldiv
func Lldiv(num int64, den int64) (int64, int64)

//go:linkname Llrint github.com/c2gohq/c2go_libc.llrint
func Llrint(x float64) int64

//go:linkname Llrintf github.com/c2gohq/c2go_libc.llrintf
func Llrintf(x float32) int64

//go:linkname Llround github.com/c2gohq/c2go_libc.llround
func Llround(x float64) int64

//go:linkname Llroundf github.com/c2gohq/c2go_libc.llroundf
func Llroundf(x float32) int64

//go:linkname Localeconv github.com/c2gohq/c2go_libc.localeconv
func Localeconv() *lconv

//go:linkname Localtime github.com/c2gohq/c2go_libc.localtime
func Localtime(t *int64) *tm

//go:linkname LocaltimeR github.com/c2gohq/c2go_libc.localtime_r
func LocaltimeR(t *int64, tm *tm) *tm

//go:linkname Lockf github.com/c2gohq/c2go_libc.lockf
func Lockf(fd int32, op int32, size int64) int32

//go:linkname Log github.com/c2gohq/c2go_libc.log
func Log(x float64) float64

//go:linkname Log10 github.com/c2gohq/c2go_libc.log10
func Log10(x float64) float64

//go:linkname Log10f github.com/c2gohq/c2go_libc.log10f
func Log10f(x float32) float32

//go:linkname Log1p github.com/c2gohq/c2go_libc.log1p
func Log1p(x float64) float64

//go:linkname Log1pf github.com/c2gohq/c2go_libc.log1pf
func Log1pf(x float32) float32

//go:linkname Log2 github.com/c2gohq/c2go_libc.log2
func Log2(x float64) float64

//go:linkname Log2f github.com/c2gohq/c2go_libc.log2f
func Log2f(x float32) float32

//go:linkname Logb github.com/c2gohq/c2go_libc.logb
func Logb(x float64) float64

//go:linkname Logbf github.com/c2gohq/c2go_libc.logbf
func Logbf(x float32) float32

//go:linkname Logf github.com/c2gohq/c2go_libc.logf
func Logf(x float32) float32

//go:linkname Lrand48 github.com/c2gohq/c2go_libc.lrand48
func Lrand48() int64

//go:linkname Lrint github.com/c2gohq/c2go_libc.lrint
func Lrint(x float64) int64

//go:linkname Lrintf github.com/c2gohq/c2go_libc.lrintf
func Lrintf(x float32) int64

//go:linkname Lround github.com/c2gohq/c2go_libc.lround
func Lround(x float64) int64

//go:linkname Lroundf github.com/c2gohq/c2go_libc.lroundf
func Lroundf(x float32) int64

//go:linkname Lsearch github.com/c2gohq/c2go_libc.lsearch
func Lsearch(key unsafe.Pointer, base unsafe.Pointer, nelp *uint64, width uint64, compar uintptr) unsafe.Pointer

//go:linkname Lseek github.com/c2gohq/c2go_libc.lseek
func Lseek(fd int32, off int64, whence int32) int64

//go:linkname Lstat github.com/c2gohq/c2go_libc.lstat
func Lstat(path *byte, buf *stat) int32

//go:linkname Mblen github.com/c2gohq/c2go_libc.mblen
func Mblen(s *byte, n uint64) int32

//go:linkname Mbrlen github.com/c2gohq/c2go_libc.mbrlen
func Mbrlen(s *byte, n uint64, st *__mbstate_t) uint64

//go:linkname Mbrtoc16 github.com/c2gohq/c2go_libc.mbrtoc16
func Mbrtoc16(pc16 *uint16, s *byte, n uint64, ps *__mbstate_t) uint64

//go:linkname Mbrtoc32 github.com/c2gohq/c2go_libc.mbrtoc32
func Mbrtoc32(pc32 *uint32, s *byte, n uint64, ps *__mbstate_t) uint64

//go:linkname Mbrtowc github.com/c2gohq/c2go_libc.mbrtowc
func Mbrtowc(wc *int32, src *byte, n uint64, st *__mbstate_t) uint64

//go:linkname Mbsinit github.com/c2gohq/c2go_libc.mbsinit
func Mbsinit(st *__mbstate_t) int32

//go:linkname Mbsnrtowcs github.com/c2gohq/c2go_libc.mbsnrtowcs
func Mbsnrtowcs(wcs *int32, src **byte, n uint64, wn uint64, st *__mbstate_t) uint64

//go:linkname Mbsrtowcs github.com/c2gohq/c2go_libc.mbsrtowcs
func Mbsrtowcs(ws *int32, src **byte, wn uint64, st *__mbstate_t) uint64

//go:linkname Mbstowcs github.com/c2gohq/c2go_libc.mbstowcs
func Mbstowcs(ws *int32, s *byte, wn uint64) uint64

//go:linkname Mbtowc github.com/c2gohq/c2go_libc.mbtowc
func Mbtowc(wc *int32, src *byte, n uint64) int32

//go:linkname Memccpy github.com/c2gohq/c2go_libc.memccpy
func Memccpy(dest unsafe.Pointer, src unsafe.Pointer, c int32, n uint64) unsafe.Pointer

//go:linkname Memchr github.com/c2gohq/c2go_libc.memchr
func Memchr(src unsafe.Pointer, c int32, n uint64) unsafe.Pointer

//go:linkname Memcmp github.com/c2gohq/c2go_libc.memcmp
func Memcmp(vl unsafe.Pointer, vr unsafe.Pointer, n uint64) int32

//go:linkname Memcpy github.com/c2gohq/c2go_libc.memcpy
func Memcpy(dest unsafe.Pointer, src unsafe.Pointer, n uint64) unsafe.Pointer

//go:linkname Memmem github.com/c2gohq/c2go_libc.memmem
func Memmem(h0 unsafe.Pointer, k uint64, n0 unsafe.Pointer, l uint64) unsafe.Pointer

//go:linkname Memmove github.com/c2gohq/c2go_libc.memmove
func Memmove(dest unsafe.Pointer, src unsafe.Pointer, n uint64) unsafe.Pointer

//go:linkname Mempcpy github.com/c2gohq/c2go_libc.mempcpy
func Mempcpy(dest unsafe.Pointer, src unsafe.Pointer, n uint64) unsafe.Pointer

//go:linkname Memrchr github.com/c2gohq/c2go_libc.memrchr
func Memrchr(m unsafe.Pointer, c int32, n uint64) unsafe.Pointer

//go:linkname Memset github.com/c2gohq/c2go_libc.memset
func Memset(dest unsafe.Pointer, c int32, n uint64) unsafe.Pointer

//go:linkname Mkdir github.com/c2gohq/c2go_libc.mkdir
func Mkdir(path *byte, mode uint32) int32

//go:linkname Mkdirat github.com/c2gohq/c2go_libc.mkdirat
func Mkdirat(dirfd int32, path *byte, mode uint32) int32

//go:linkname Mkdtemp github.com/c2gohq/c2go_libc.mkdtemp
func Mkdtemp(template *byte) *byte

//go:linkname Mkfifo github.com/c2gohq/c2go_libc.mkfifo
func Mkfifo(path *byte, mode uint32) int32

//go:linkname Mkstemp github.com/c2gohq/c2go_libc.mkstemp
func Mkstemp(template *byte) int32

//go:linkname Mkstemps github.com/c2gohq/c2go_libc.mkstemps
func Mkstemps(template *byte, suffixlen int32) int32

//go:linkname Mktime github.com/c2gohq/c2go_libc.mktime
func Mktime(tm *tm) int64

//go:linkname Modf github.com/c2gohq/c2go_libc.modf
func Modf(x float64, iptr *float64) float64

//go:linkname Modff github.com/c2gohq/c2go_libc.modff
func Modff(x float32, iptr *float32) float32

//go:linkname Mrand48 github.com/c2gohq/c2go_libc.mrand48
func Mrand48() int64

//go:linkname Nan github.com/c2gohq/c2go_libc.nan
func Nan(s *byte) float64

//go:linkname Nanf github.com/c2gohq/c2go_libc.nanf
func Nanf(s *byte) float32

//go:linkname Nanosleep github.com/c2gohq/c2go_libc.nanosleep
func Nanosleep(req *timespec, rem *timespec) int32

//go:linkname Nearbyint github.com/c2gohq/c2go_libc.nearbyint
func Nearbyint(x float64) float64

//go:linkname Nearbyintf github.com/c2gohq/c2go_libc.nearbyintf
func Nearbyintf(x float32) float32

//go:linkname Newlocale github.com/c2gohq/c2go_libc.newlocale
func Newlocale(mask int32, name *byte, base *__locale_struct) *__locale_struct

//go:linkname Nextafter github.com/c2gohq/c2go_libc.nextafter
func Nextafter(x float64, y float64) float64

//go:linkname Nextafterf github.com/c2gohq/c2go_libc.nextafterf
func Nextafterf(x float32, y float32) float32

//go:linkname Nexttoward github.com/c2gohq/c2go_libc.nexttoward
func Nexttoward(x float64, y float64) float64

//go:linkname Nexttowardf github.com/c2gohq/c2go_libc.nexttowardf
func Nexttowardf(x float32, y float64) float32

//go:linkname Nftw github.com/c2gohq/c2go_libc.nftw
func Nftw(path *byte, fn uintptr, fd_limit int32, flags int32) int32

//go:linkname Ngettext github.com/c2gohq/c2go_libc.ngettext
func Ngettext(msgid1 *byte, msgid2 *byte, n uint64) *byte

//go:linkname NlLanginfo github.com/c2gohq/c2go_libc.nl_langinfo
func NlLanginfo(item int32) *byte

//go:linkname NlLanginfoL github.com/c2gohq/c2go_libc.nl_langinfo_l
func NlLanginfoL(item int32, loc *__locale_struct) *byte

//go:linkname Nrand48 github.com/c2gohq/c2go_libc.nrand48
func Nrand48(s *uint16) int64

//go:linkname Open github.com/c2gohq/c2go_libc.open
func Open(path *byte, flags int32, argptrs unsafe.Pointer) int32

//go:linkname OpenMemstream github.com/c2gohq/c2go_libc.open_memstream
func OpenMemstream(bufp **byte, sizep *uint64) *FILE

//go:linkname Openat github.com/c2gohq/c2go_libc.openat
func Openat(dirfd int32, path *byte, flags int32, argptrs unsafe.Pointer) int32

//go:linkname Opendir github.com/c2gohq/c2go_libc.opendir
func Opendir(name *byte) *__dirstream

//go:linkname Pclose github.com/c2gohq/c2go_libc.pclose
func Pclose(f *FILE) int32

//go:linkname Perror github.com/c2gohq/c2go_libc.perror
func Perror(msg *byte)

//go:linkname Pipe github.com/c2gohq/c2go_libc.pipe
func Pipe(fds *int32) int32

//go:linkname Pipe2 github.com/c2gohq/c2go_libc.pipe2
func Pipe2(fds *int32, flags int32) int32

//go:linkname Popen github.com/c2gohq/c2go_libc.popen
func Popen(command *byte, mode *byte) *FILE

//go:linkname PosixFallocate github.com/c2gohq/c2go_libc.posix_fallocate
func PosixFallocate(fd int32, off int64, len int64) int32

//go:linkname PosixMemalign github.com/c2gohq/c2go_libc.posix_memalign
func PosixMemalign(res *unsafe.Pointer, align uint64, len uint64) int32

//go:linkname Pow github.com/c2gohq/c2go_libc.pow
func Pow(x float64, y float64) float64

//go:linkname Pow10 github.com/c2gohq/c2go_libc.pow10
func Pow10(x float64) float64

//go:linkname Powf github.com/c2gohq/c2go_libc.powf
func Powf(x float32, y float32) float32

//go:linkname Pread github.com/c2gohq/c2go_libc.pread
func Pread(fd int32, buf unsafe.Pointer, n uint64, off int64) int64

//go:linkname Printf github.com/c2gohq/c2go_libc.printf
func Printf(fmt *byte, argptrs unsafe.Pointer) int32

//go:linkname Psignal github.com/c2gohq/c2go_libc.psignal
func Psignal(sig int32, msg *byte)

//go:linkname PthreadAtfork github.com/c2gohq/c2go_libc.pthread_atfork
func PthreadAtfork(prepare uintptr, parent uintptr, child uintptr) int32

//go:linkname PthreadCondattrDestroy github.com/c2gohq/c2go_libc.pthread_condattr_destroy
func PthreadCondattrDestroy(a *pthread_condattr_t) int32

//go:linkname PthreadCondattrInit github.com/c2gohq/c2go_libc.pthread_condattr_init
func PthreadCondattrInit(a *pthread_condattr_t) int32

//go:linkname PthreadMutexattrDestroy github.com/c2gohq/c2go_libc.pthread_mutexattr_destroy
func PthreadMutexattrDestroy(a *pthread_mutexattr_t) int32

//go:linkname PthreadMutexattrGettype github.com/c2gohq/c2go_libc.pthread_mutexattr_gettype
func PthreadMutexattrGettype(a *pthread_mutexattr_t, typ *int32) int32

//go:linkname PthreadMutexattrInit github.com/c2gohq/c2go_libc.pthread_mutexattr_init
func PthreadMutexattrInit(a *pthread_mutexattr_t) int32

//go:linkname PthreadMutexattrSettype github.com/c2gohq/c2go_libc.pthread_mutexattr_settype
func PthreadMutexattrSettype(a *pthread_mutexattr_t, typ int32) int32

//go:linkname PthreadRwlockattrDestroy github.com/c2gohq/c2go_libc.pthread_rwlockattr_destroy
func PthreadRwlockattrDestroy(a *pthread_rwlockattr_t) int32

//go:linkname PthreadRwlockattrInit github.com/c2gohq/c2go_libc.pthread_rwlockattr_init
func PthreadRwlockattrInit(a *pthread_rwlockattr_t) int32

//go:linkname Putc github.com/c2gohq/c2go_libc.putc
func Putc(c int32, f *FILE) int32

//go:linkname Putchar github.com/c2gohq/c2go_libc.putchar
func Putchar(c int32) int32

//go:linkname Putenv github.com/c2gohq/c2go_libc.putenv
func Putenv(s *byte) int32

//go:linkname Puts github.com/c2gohq/c2go_libc.puts
func Puts(s *byte) int32

//go:linkname Putw github.com/c2gohq/c2go_libc.putw
func Putw(x int32, f *FILE) int32

//go:linkname Putwc github.com/c2gohq/c2go_libc.putwc
func Putwc(c int32, f *FILE) uint32

//go:linkname Putwchar github.com/c2gohq/c2go_libc.putwchar
func Putwchar(c int32) uint32

//go:linkname Pwrite github.com/c2gohq/c2go_libc.pwrite
func Pwrite(fd int32, buf unsafe.Pointer, n uint64, off int64) int64

//go:linkname Qsort github.com/c2gohq/c2go_libc.qsort
func Qsort(base unsafe.Pointer, nel uint64, width uint64, cmp uintptr)

//go:linkname QsortR github.com/c2gohq/c2go_libc.qsort_r
func QsortR(base unsafe.Pointer, nel uint64, width uint64, cmp uintptr, arg unsafe.Pointer)

//go:linkname QuickExit github.com/c2gohq/c2go_libc.quick_exit
func QuickExit(code int32)

//go:linkname Raise github.com/c2gohq/c2go_libc.raise
func Raise(sig int32) int32

//go:linkname Rand github.com/c2gohq/c2go_libc.rand
func Rand() int32

//go:linkname RandR github.com/c2gohq/c2go_libc.rand_r
func RandR(seed *uint32) int32

//go:linkname Random github.com/c2gohq/c2go_libc.random
func Random() int64

//go:linkname Read github.com/c2gohq/c2go_libc.read
func Read(fd int32, buf unsafe.Pointer, n uint64) int64

//go:linkname Readdir github.com/c2gohq/c2go_libc.readdir
func Readdir(d *__dirstream) *dirent

//go:linkname ReaddirR github.com/c2gohq/c2go_libc.readdir_r
func ReaddirR(d *__dirstream, entry *dirent, result **dirent) int32

//go:linkname Readlink github.com/c2gohq/c2go_libc.readlink
func Readlink(path *byte, buf *byte, bufsiz uint64) int64

//go:linkname Readv github.com/c2gohq/c2go_libc.readv
func Readv(fd int32, iov *iovec, iovcnt int32) int64

//go:linkname Reallocarray github.com/c2gohq/c2go_libc.reallocarray
func Reallocarray(ptr unsafe.Pointer, m uint64, n uint64) unsafe.Pointer

//go:linkname Realpath github.com/c2gohq/c2go_libc.realpath
func Realpath(path *byte, resolved_path *byte) *byte

//go:linkname Regcomp github.com/c2gohq/c2go_libc.regcomp
func Regcomp(preg *re_pattern_buffer, regex *byte, cflags int32) int32

//go:linkname Regerror github.com/c2gohq/c2go_libc.regerror
func Regerror(e int32, preg *re_pattern_buffer, buf *byte, size uint64) uint64

//go:linkname Regexec github.com/c2gohq/c2go_libc.regexec
func Regexec(preg *re_pattern_buffer, string *byte, nmatch uint64, pmatch *regmatch_t, eflags int32) int32

//go:linkname Regfree github.com/c2gohq/c2go_libc.regfree
func Regfree(preg *re_pattern_buffer)

//go:linkname Remainder github.com/c2gohq/c2go_libc.remainder
func Remainder(x float64, y float64) float64

//go:linkname Remainderf github.com/c2gohq/c2go_libc.remainderf
func Remainderf(x float32, y float32) float32

//go:linkname Remove github.com/c2gohq/c2go_libc.remove
func Remove(path *byte) int32

//go:linkname Remque github.com/c2gohq/c2go_libc.remque
func Remque(element unsafe.Pointer)

//go:linkname Remquo github.com/c2gohq/c2go_libc.remquo
func Remquo(x float64, y float64, quo *int32) float64

//go:linkname Remquof github.com/c2gohq/c2go_libc.remquof
func Remquof(x float32, y float32, quo *int32) float32

//go:linkname Rename github.com/c2gohq/c2go_libc.rename
func Rename(from *byte, to *byte) int32

//go:linkname Renameat github.com/c2gohq/c2go_libc.renameat
func Renameat(fromfd int32, from *byte, tofd int32, to *byte) int32

//go:linkname Rewind github.com/c2gohq/c2go_libc.rewind
func Rewind(f *FILE)

//go:linkname Rewinddir github.com/c2gohq/c2go_libc.rewinddir
func Rewinddir(d *__dirstream)

//go:linkname Rint github.com/c2gohq/c2go_libc.rint
func Rint(x float64) float64

//go:linkname Rintf github.com/c2gohq/c2go_libc.rintf
func Rintf(x float32) float32

//go:linkname Rmdir github.com/c2gohq/c2go_libc.rmdir
func Rmdir(path *byte) int32

//go:linkname Round github.com/c2gohq/c2go_libc.round
func Round(x float64) float64

//go:linkname Roundf github.com/c2gohq/c2go_libc.roundf
func Roundf(x float32) float32

//go:linkname Scalbln github.com/c2gohq/c2go_libc.scalbln
func Scalbln(x float64, n int64) float64

//go:linkname Scalblnf github.com/c2gohq/c2go_libc.scalblnf
func Scalblnf(x float32, n int64) float32

//go:linkname Scalbn github.com/c2gohq/c2go_libc.scalbn
func Scalbn(x float64, n int32) float64

//go:linkname Scalbnf github.com/c2gohq/c2go_libc.scalbnf
func Scalbnf(x float32, n int32) float32

//go:linkname Scandir github.com/c2gohq/c2go_libc.scandir
func Scandir(path *byte, res ***dirent, sel uintptr, cmp uintptr) int32

//go:linkname Scanf github.com/c2gohq/c2go_libc.scanf
func Scanf(fmt *byte, argptrs unsafe.Pointer) int32

//go:linkname Seed48 github.com/c2gohq/c2go_libc.seed48
func Seed48(s *uint16) *uint16

//go:linkname Setbuf github.com/c2gohq/c2go_libc.setbuf
func Setbuf(f *FILE, buf *byte)

//go:linkname Setbuffer github.com/c2gohq/c2go_libc.setbuffer
func Setbuffer(f *FILE, buf *byte, size uint64)

//go:linkname Setlinebuf github.com/c2gohq/c2go_libc.setlinebuf
func Setlinebuf(f *FILE)

//go:linkname Setlocale github.com/c2gohq/c2go_libc.setlocale
func Setlocale(cat int32, name *byte) *byte

//go:linkname Setstate github.com/c2gohq/c2go_libc.setstate
func Setstate(state *byte) *byte

//go:linkname Setvbuf github.com/c2gohq/c2go_libc.setvbuf
func Setvbuf(f *FILE, buf *byte, mode int32, size uint64) int32

//go:linkname Sigaction github.com/c2gohq/c2go_libc.sigaction
func Sigaction(sig int32, act *sigaction, old *sigaction) int32

//go:linkname Sigaddset github.com/c2gohq/c2go_libc.sigaddset
func Sigaddset(set *uint64, sig int32) int32

//go:linkname Sigdelset github.com/c2gohq/c2go_libc.sigdelset
func Sigdelset(set *uint64, sig int32) int32

//go:linkname Sigemptyset github.com/c2gohq/c2go_libc.sigemptyset
func Sigemptyset(set *uint64) int32

//go:linkname Sigfillset github.com/c2gohq/c2go_libc.sigfillset
func Sigfillset(set *uint64) int32

//go:linkname Sigismember github.com/c2gohq/c2go_libc.sigismember
func Sigismember(set *uint64, sig int32) int32

//go:linkname Signal github.com/c2gohq/c2go_libc.signal
func Signal(sig int32, h uintptr) uintptr

//go:linkname Sin github.com/c2gohq/c2go_libc.sin
func Sin(x float64) float64

//go:linkname Sincos github.com/c2gohq/c2go_libc.sincos
func Sincos(x float64, sin *float64, cos *float64)

//go:linkname Sincosf github.com/c2gohq/c2go_libc.sincosf
func Sincosf(x float32, sin *float32, cos *float32)

//go:linkname Sinf github.com/c2gohq/c2go_libc.sinf
func Sinf(x float32) float32

//go:linkname Sinh github.com/c2gohq/c2go_libc.sinh
func Sinh(x float64) float64

//go:linkname Sinhf github.com/c2gohq/c2go_libc.sinhf
func Sinhf(x float32) float32

//go:linkname Sleep github.com/c2gohq/c2go_libc.sleep
func Sleep(seconds uint32) uint32

//go:linkname Snprintf github.com/c2gohq/c2go_libc.snprintf
func Snprintf(s *byte, n uint64, fmt *byte, argptrs unsafe.Pointer) int32

//go:linkname Sprintf github.com/c2gohq/c2go_libc.sprintf
func Sprintf(s *byte, fmt *byte, argptrs unsafe.Pointer) int32

//go:linkname Sqrt github.com/c2gohq/c2go_libc.sqrt
func Sqrt(x float64) float64

//go:linkname Sqrtf github.com/c2gohq/c2go_libc.sqrtf
func Sqrtf(x float32) float32

//go:linkname Srand github.com/c2gohq/c2go_libc.srand
func Srand(s uint32)

//go:linkname Srand48 github.com/c2gohq/c2go_libc.srand48
func Srand48(seed int64)

//go:linkname Srandom github.com/c2gohq/c2go_libc.srandom
func Srandom(seed uint32)

//go:linkname Sscanf github.com/c2gohq/c2go_libc.sscanf
func Sscanf(s *byte, fmt *byte, argptrs unsafe.Pointer) int32

//go:linkname Stat github.com/c2gohq/c2go_libc.stat
func Stat(path *byte, buf *stat) int32

//go:linkname Stpcpy github.com/c2gohq/c2go_libc.stpcpy
func Stpcpy(d *byte, s *byte) *byte

//go:linkname Stpncpy github.com/c2gohq/c2go_libc.stpncpy
func Stpncpy(d *byte, s *byte, n uint64) *byte

//go:linkname Strcasecmp github.com/c2gohq/c2go_libc.strcasecmp
func Strcasecmp(_l *byte, _r *byte) int32

//go:linkname StrcasecmpL github.com/c2gohq/c2go_libc.strcasecmp_l
func StrcasecmpL(l *byte, r *byte, loc *__locale_struct) int32

//go:linkname Strcasestr github.com/c2gohq/c2go_libc.strcasestr
func Strcasestr(h *byte, n *byte) *byte

//go:linkname Strcat github.com/c2gohq/c2go_libc.strcat
func Strcat(dest *byte, src *byte) *byte

//go:linkname Strchr github.com/c2gohq/c2go_libc.strchr
func Strchr(s *byte, c int32) *byte

//go:linkname Strchrnul github.com/c2gohq/c2go_libc.strchrnul
func Strchrnul(s *byte, c int32) *byte

//go:linkname Strcmp github.com/c2gohq/c2go_libc.strcmp
func Strcmp(l *byte, r *byte) int32

//go:linkname Strcoll github.com/c2gohq/c2go_libc.strcoll
func Strcoll(l *byte, r *byte) int32

//go:linkname StrcollL github.com/c2gohq/c2go_libc.strcoll_l
func StrcollL(l *byte, r *byte, loc *__locale_struct) int32

//go:linkname Strcpy github.com/c2gohq/c2go_libc.strcpy
func Strcpy(dest *byte, src *byte) *byte

//go:linkname Strcspn github.com/c2gohq/c2go_libc.strcspn
func Strcspn(s *byte, c *byte) uint64

//go:linkname Strdup github.com/c2gohq/c2go_libc.strdup
func Strdup(s *byte) *byte

//go:linkname Strerror github.com/c2gohq/c2go_libc.strerror
func Strerror(e int32) *byte

//go:linkname StrerrorL github.com/c2gohq/c2go_libc.strerror_l
func StrerrorL(e int32, loc *__locale_struct) *byte

//go:linkname StrerrorR github.com/c2gohq/c2go_libc.strerror_r
func StrerrorR(err int32, buf *byte, buflen uint64) int32

//go:linkname Strfmon github.com/c2gohq/c2go_libc.strfmon
func Strfmon(s *byte, n uint64, fmt *byte, argptrs unsafe.Pointer) int64

//go:linkname StrfmonL github.com/c2gohq/c2go_libc.strfmon_l
func StrfmonL(s *byte, n uint64, loc *__locale_struct, fmt *byte, argptrs unsafe.Pointer) int64

//go:linkname Strftime github.com/c2gohq/c2go_libc.strftime
func Strftime(s *byte, n uint64, f *byte, tm *tm) uint64

//go:linkname StrftimeL github.com/c2gohq/c2go_libc.strftime_l
func StrftimeL(s *byte, n uint64, f *byte, tm *tm, loc *__locale_struct) uint64

//go:linkname Strlcat github.com/c2gohq/c2go_libc.strlcat
func Strlcat(d *byte, s *byte, n uint64) uint64

//go:linkname Strlcpy github.com/c2gohq/c2go_libc.strlcpy
func Strlcpy(d *byte, s *byte, n uint64) uint64

//go:linkname Strlen github.com/c2gohq/c2go_libc.strlen
func Strlen(s *byte) uint64

//go:linkname Strncasecmp github.com/c2gohq/c2go_libc.strncasecmp
func Strncasecmp(_l *byte, _r *byte, n uint64) int32

//go:linkname StrncasecmpL github.com/c2gohq/c2go_libc.strncasecmp_l
func StrncasecmpL(l *byte, r *byte, n uint64, loc *__locale_struct) int32

//go:linkname Strncat github.com/c2gohq/c2go_libc.strncat
func Strncat(d *byte, s *byte, n uint64) *byte

//go:linkname Strncmp github.com/c2gohq/c2go_libc.strncmp
func Strncmp(_l *byte, _r *byte, n uint64) int32

//go:linkname Strncpy github.com/c2gohq/c2go_libc.strncpy
func Strncpy(d *byte, s *byte, n uint64) *byte

//go:linkname Strndup github.com/c2gohq/c2go_libc.strndup
func Strndup(s *byte, n uint64) *byte

//go:linkname Strnlen github.com/c2gohq/c2go_libc.strnlen
func Strnlen(s *byte, n uint64) uint64

//go:linkname Strpbrk github.com/c2gohq/c2go_libc.strpbrk
func Strpbrk(s *byte, b *byte) *byte

//go:linkname Strptime github.com/c2gohq/c2go_libc.strptime
func Strptime(s *byte, f *byte, tm *tm) *byte

//go:linkname Strrchr github.com/c2gohq/c2go_libc.strrchr
func Strrchr(s *byte, c int32) *byte

//go:linkname Strsep github.com/c2gohq/c2go_libc.strsep
func Strsep(str **byte, sep *byte) *byte

//go:linkname Strsignal github.com/c2gohq/c2go_libc.strsignal
func Strsignal(signum int32) *byte

//go:linkname Strspn github.com/c2gohq/c2go_libc.strspn
func Strspn(s *byte, c *byte) uint64

//go:linkname Strstr github.com/c2gohq/c2go_libc.strstr
func Strstr(h *byte, n *byte) *byte

//go:linkname Strtod github.com/c2gohq/c2go_libc.strtod
func Strtod(s *byte, p **byte) float64

//go:linkname StrtodL github.com/c2gohq/c2go_libc.strtod_l
func StrtodL(s *byte, p **byte, l *__locale_struct) float64

//go:linkname Strtof github.com/c2gohq/c2go_libc.strtof
func Strtof(s *byte, p **byte) float32

//go:linkname StrtofL github.com/c2gohq/c2go_libc.strtof_l
func StrtofL(s *byte, p **byte, l *__locale_struct) float32

//go:linkname Strtoimax github.com/c2gohq/c2go_libc.strtoimax
func Strtoimax(nptr *byte, endptr **byte, base int32) int64

//go:linkname Strtok github.com/c2gohq/c2go_libc.strtok
func Strtok(s *byte, sep *byte) *byte

//go:linkname StrtokR github.com/c2gohq/c2go_libc.strtok_r
func StrtokR(s *byte, sep *byte, p **byte) *byte

//go:linkname Strtol github.com/c2gohq/c2go_libc.strtol
func Strtol(s *byte, p **byte, base int32) int64

//go:linkname Strtold github.com/c2gohq/c2go_libc.strtold
func Strtold(s *byte, p **byte) float64

//go:linkname StrtoldL github.com/c2gohq/c2go_libc.strtold_l
func StrtoldL(s *byte, p **byte, l *__locale_struct) float64

//go:linkname Strtoll github.com/c2gohq/c2go_libc.strtoll
func Strtoll(s *byte, p **byte, base int32) int64

//go:linkname Strtoul github.com/c2gohq/c2go_libc.strtoul
func Strtoul(s *byte, p **byte, base int32) uint64

//go:linkname Strtoull github.com/c2gohq/c2go_libc.strtoull
func Strtoull(s *byte, p **byte, base int32) uint64

//go:linkname Strtoumax github.com/c2gohq/c2go_libc.strtoumax
func Strtoumax(nptr *byte, endptr **byte, base int32) uint64

//go:linkname Strverscmp github.com/c2gohq/c2go_libc.strverscmp
func Strverscmp(l0 *byte, r0 *byte) int32

//go:linkname Strxfrm github.com/c2gohq/c2go_libc.strxfrm
func Strxfrm(dest *byte, src *byte, n uint64) uint64

//go:linkname StrxfrmL github.com/c2gohq/c2go_libc.strxfrm_l
func StrxfrmL(dest *byte, src *byte, n uint64, loc *__locale_struct) uint64

//go:linkname Swab github.com/c2gohq/c2go_libc.swab
func Swab(_src unsafe.Pointer, _dest unsafe.Pointer, n int64)

//go:linkname Swprintf github.com/c2gohq/c2go_libc.swprintf
func Swprintf(s *int32, n uint64, fmt *int32, argptrs unsafe.Pointer) int32

//go:linkname Swscanf github.com/c2gohq/c2go_libc.swscanf
func Swscanf(s *int32, fmt *int32, argptrs unsafe.Pointer) int32

//go:linkname Symlink github.com/c2gohq/c2go_libc.symlink
func Symlink(target *byte, linkpath *byte) int32

//go:linkname Sync github.com/c2gohq/c2go_libc.sync
func Sync()

//go:linkname Sysconf github.com/c2gohq/c2go_libc.sysconf
func Sysconf(name int32) int64

//go:linkname Tan github.com/c2gohq/c2go_libc.tan
func Tan(x float64) float64

//go:linkname Tanf github.com/c2gohq/c2go_libc.tanf
func Tanf(x float32) float32

//go:linkname Tanh github.com/c2gohq/c2go_libc.tanh
func Tanh(x float64) float64

//go:linkname Tanhf github.com/c2gohq/c2go_libc.tanhf
func Tanhf(x float32) float32

//go:linkname Tcdrain github.com/c2gohq/c2go_libc.tcdrain
func Tcdrain(fd int32) int32

//go:linkname Tcflow github.com/c2gohq/c2go_libc.tcflow
func Tcflow(fd int32, action int32) int32

//go:linkname Tcflush github.com/c2gohq/c2go_libc.tcflush
func Tcflush(fd int32, queue int32) int32

//go:linkname Tcgetattr github.com/c2gohq/c2go_libc.tcgetattr
func Tcgetattr(fd int32, tio *termios) int32

//go:linkname Tcgetpgrp github.com/c2gohq/c2go_libc.tcgetpgrp
func Tcgetpgrp(fd int32) int32

//go:linkname Tcgetsid github.com/c2gohq/c2go_libc.tcgetsid
func Tcgetsid(fd int32) int32

//go:linkname Tcgetwinsize github.com/c2gohq/c2go_libc.tcgetwinsize
func Tcgetwinsize(fd int32, wsz *winsize) int32

//go:linkname Tcsendbreak github.com/c2gohq/c2go_libc.tcsendbreak
func Tcsendbreak(fd int32, dur int32) int32

//go:linkname Tcsetattr github.com/c2gohq/c2go_libc.tcsetattr
func Tcsetattr(fd int32, act int32, tio *termios) int32

//go:linkname Tcsetpgrp github.com/c2gohq/c2go_libc.tcsetpgrp
func Tcsetpgrp(fd int32, pgrp int32) int32

//go:linkname Tcsetwinsize github.com/c2gohq/c2go_libc.tcsetwinsize
func Tcsetwinsize(fd int32, wsz *winsize) int32

//go:linkname Tdelete github.com/c2gohq/c2go_libc.tdelete
func Tdelete(key unsafe.Pointer, rootp *unsafe.Pointer, cmp uintptr) unsafe.Pointer

//go:linkname Tdestroy github.com/c2gohq/c2go_libc.tdestroy
func Tdestroy(root unsafe.Pointer, freekey uintptr)

//go:linkname Textdomain github.com/c2gohq/c2go_libc.textdomain
func Textdomain(domainname *byte) *byte

//go:linkname Tfind github.com/c2gohq/c2go_libc.tfind
func Tfind(key unsafe.Pointer, rootp *unsafe.Pointer, cmp uintptr) unsafe.Pointer

//go:linkname Tgamma github.com/c2gohq/c2go_libc.tgamma
func Tgamma(x float64) float64

//go:linkname Tgammaf github.com/c2gohq/c2go_libc.tgammaf
func Tgammaf(x float32) float32

//go:linkname Time github.com/c2gohq/c2go_libc.time
func Time(t *int64) int64

//go:linkname Timegm github.com/c2gohq/c2go_libc.timegm
func Timegm(tm *tm) int64

//go:linkname TimespecGet github.com/c2gohq/c2go_libc.timespec_get
func TimespecGet(ts *timespec, base int32) int32

//go:linkname Tmpfile github.com/c2gohq/c2go_libc.tmpfile
func Tmpfile() *FILE

//go:linkname Toascii github.com/c2gohq/c2go_libc.toascii
func Toascii(c int32) int32

//go:linkname Tolower github.com/c2gohq/c2go_libc.tolower
func Tolower(c int32) int32

//go:linkname TolowerL github.com/c2gohq/c2go_libc.tolower_l
func TolowerL(c int32, l *__locale_struct) int32

//go:linkname Toupper github.com/c2gohq/c2go_libc.toupper
func Toupper(c int32) int32

//go:linkname ToupperL github.com/c2gohq/c2go_libc.toupper_l
func ToupperL(c int32, l *__locale_struct) int32

//go:linkname Towctrans github.com/c2gohq/c2go_libc.towctrans
func Towctrans(wc uint32, trans int32) uint32

//go:linkname TowctransL github.com/c2gohq/c2go_libc.towctrans_l
func TowctransL(c uint32, t int32, l *__locale_struct) uint32

//go:linkname Towlower github.com/c2gohq/c2go_libc.towlower
func Towlower(wc uint32) uint32

//go:linkname TowlowerL github.com/c2gohq/c2go_libc.towlower_l
func TowlowerL(c uint32, l *__locale_struct) uint32

//go:linkname Towupper github.com/c2gohq/c2go_libc.towupper
func Towupper(wc uint32) uint32

//go:linkname TowupperL github.com/c2gohq/c2go_libc.towupper_l
func TowupperL(c uint32, l *__locale_struct) uint32

//go:linkname Trunc github.com/c2gohq/c2go_libc.trunc
func Trunc(x float64) float64

//go:linkname Truncate github.com/c2gohq/c2go_libc.truncate
func Truncate(path *byte, len int64) int32

//go:linkname Truncf github.com/c2gohq/c2go_libc.truncf
func Truncf(x float32) float32

//go:linkname Tsearch github.com/c2gohq/c2go_libc.tsearch
func Tsearch(key unsafe.Pointer, rootp *unsafe.Pointer, cmp uintptr) unsafe.Pointer

//go:linkname Twalk github.com/c2gohq/c2go_libc.twalk
func Twalk(root unsafe.Pointer, action uintptr)

//go:linkname Tzset github.com/c2gohq/c2go_libc.tzset
func Tzset()

//go:linkname Umask github.com/c2gohq/c2go_libc.umask
func Umask(mask uint32) uint32

//go:linkname Uname github.com/c2gohq/c2go_libc.uname
func Uname(uts *utsname) int32

//go:linkname Ungetc github.com/c2gohq/c2go_libc.ungetc
func Ungetc(c int32, f *FILE) int32

//go:linkname Ungetwc github.com/c2gohq/c2go_libc.ungetwc
func Ungetwc(c uint32, f *FILE) uint32

//go:linkname Unlink github.com/c2gohq/c2go_libc.unlink
func Unlink(path *byte) int32

//go:linkname Unlinkat github.com/c2gohq/c2go_libc.unlinkat
func Unlinkat(dirfd int32, path *byte, flags int32) int32

//go:linkname Uselocale github.com/c2gohq/c2go_libc.uselocale
func Uselocale(loc *__locale_struct) *__locale_struct

//go:linkname Usleep github.com/c2gohq/c2go_libc.usleep
func Usleep(useconds uint32) int32

//go:linkname Utimensat github.com/c2gohq/c2go_libc.utimensat
func Utimensat(dirfd int32, path *byte, times *timespec, flags int32) int32

//go:linkname Utimes github.com/c2gohq/c2go_libc.utimes
func Utimes(path *byte, times *timeval) int32

//go:linkname Vasprintf github.com/c2gohq/c2go_libc.vasprintf
func Vasprintf(s **byte, fmt *byte, ap *__va_list_tag) int32

//go:linkname Vdprintf github.com/c2gohq/c2go_libc.vdprintf
func Vdprintf(fd int32, fmt *byte, ap *__va_list_tag) int32

//go:linkname Verr github.com/c2gohq/c2go_libc.verr
func Verr(status int32, fmt *byte, ap *__va_list_tag)

//go:linkname Verrx github.com/c2gohq/c2go_libc.verrx
func Verrx(status int32, fmt *byte, ap *__va_list_tag)

//go:linkname Versionsort github.com/c2gohq/c2go_libc.versionsort
func Versionsort(a **dirent, b **dirent) int32

//go:linkname Vfprintf github.com/c2gohq/c2go_libc.vfprintf
func Vfprintf(f *FILE, fmt *byte, ap *__va_list_tag) int32

//go:linkname Vfscanf github.com/c2gohq/c2go_libc.vfscanf
func Vfscanf(f *FILE, fmt *byte, ap *__va_list_tag) int32

//go:linkname Vfwprintf github.com/c2gohq/c2go_libc.vfwprintf
func Vfwprintf(f *FILE, fmt *int32, ap *__va_list_tag) int32

//go:linkname Vfwscanf github.com/c2gohq/c2go_libc.vfwscanf
func Vfwscanf(f *FILE, fmt *int32, ap *__va_list_tag) int32

//go:linkname Vprintf github.com/c2gohq/c2go_libc.vprintf
func Vprintf(fmt *byte, ap *__va_list_tag) int32

//go:linkname Vscanf github.com/c2gohq/c2go_libc.vscanf
func Vscanf(fmt *byte, ap *__va_list_tag) int32

//go:linkname Vsnprintf github.com/c2gohq/c2go_libc.vsnprintf
func Vsnprintf(s *byte, n uint64, fmt *byte, ap *__va_list_tag) int32

//go:linkname Vsprintf github.com/c2gohq/c2go_libc.vsprintf
func Vsprintf(s *byte, fmt *byte, ap *__va_list_tag) int32

//go:linkname Vsscanf github.com/c2gohq/c2go_libc.vsscanf
func Vsscanf(s *byte, fmt *byte, ap *__va_list_tag) int32

//go:linkname Vswprintf github.com/c2gohq/c2go_libc.vswprintf
func Vswprintf(s *int32, n uint64, fmt *int32, ap *__va_list_tag) int32

//go:linkname Vswscanf github.com/c2gohq/c2go_libc.vswscanf
func Vswscanf(s *int32, fmt *int32, ap *__va_list_tag) int32

//go:linkname Vwarn github.com/c2gohq/c2go_libc.vwarn
func Vwarn(fmt *byte, ap *__va_list_tag)

//go:linkname Vwarnx github.com/c2gohq/c2go_libc.vwarnx
func Vwarnx(fmt *byte, ap *__va_list_tag)

//go:linkname Vwprintf github.com/c2gohq/c2go_libc.vwprintf
func Vwprintf(fmt *int32, ap *__va_list_tag) int32

//go:linkname Vwscanf github.com/c2gohq/c2go_libc.vwscanf
func Vwscanf(fmt *int32, ap *__va_list_tag) int32

//go:linkname Warn github.com/c2gohq/c2go_libc.warn
func Warn(fmt *byte, argptrs unsafe.Pointer)

//go:linkname Warnx github.com/c2gohq/c2go_libc.warnx
func Warnx(fmt *byte, argptrs unsafe.Pointer)

//go:linkname Wcpcpy github.com/c2gohq/c2go_libc.wcpcpy
func Wcpcpy(d *int32, s *int32) *int32

//go:linkname Wcpncpy github.com/c2gohq/c2go_libc.wcpncpy
func Wcpncpy(d *int32, s *int32, n uint64) *int32

//go:linkname Wcrtomb github.com/c2gohq/c2go_libc.wcrtomb
func Wcrtomb(s *byte, wc int32, st *__mbstate_t) uint64

//go:linkname Wcscasecmp github.com/c2gohq/c2go_libc.wcscasecmp
func Wcscasecmp(l *int32, r *int32) int32

//go:linkname WcscasecmpL github.com/c2gohq/c2go_libc.wcscasecmp_l
func WcscasecmpL(l *int32, r *int32, locale *__locale_struct) int32

//go:linkname Wcscat github.com/c2gohq/c2go_libc.wcscat
func Wcscat(dest *int32, src *int32) *int32

//go:linkname Wcschr github.com/c2gohq/c2go_libc.wcschr
func Wcschr(s *int32, c int32) *int32

//go:linkname Wcscmp github.com/c2gohq/c2go_libc.wcscmp
func Wcscmp(l *int32, r *int32) int32

//go:linkname Wcscoll github.com/c2gohq/c2go_libc.wcscoll
func Wcscoll(l *int32, r *int32) int32

//go:linkname WcscollL github.com/c2gohq/c2go_libc.wcscoll_l
func WcscollL(l *int32, r *int32, loc *__locale_struct) int32

//go:linkname Wcscpy github.com/c2gohq/c2go_libc.wcscpy
func Wcscpy(d *int32, s *int32) *int32

//go:linkname Wcscspn github.com/c2gohq/c2go_libc.wcscspn
func Wcscspn(s *int32, c *int32) uint64

//go:linkname Wcsdup github.com/c2gohq/c2go_libc.wcsdup
func Wcsdup(s *int32) *int32

//go:linkname Wcsftime github.com/c2gohq/c2go_libc.wcsftime
func Wcsftime(wcs *int32, n uint64, f *int32, tm *tm) uint64

//go:linkname WcsftimeL github.com/c2gohq/c2go_libc.wcsftime_l
func WcsftimeL(wcs *int32, n uint64, f *int32, tm *tm, loc *__locale_struct) uint64

//go:linkname Wcslen github.com/c2gohq/c2go_libc.wcslen
func Wcslen(s *int32) uint64

//go:linkname Wcsncasecmp github.com/c2gohq/c2go_libc.wcsncasecmp
func Wcsncasecmp(l *int32, r *int32, n uint64) int32

//go:linkname WcsncasecmpL github.com/c2gohq/c2go_libc.wcsncasecmp_l
func WcsncasecmpL(l *int32, r *int32, n uint64, locale *__locale_struct) int32

//go:linkname Wcsncat github.com/c2gohq/c2go_libc.wcsncat
func Wcsncat(d *int32, s *int32, n uint64) *int32

//go:linkname Wcsncmp github.com/c2gohq/c2go_libc.wcsncmp
func Wcsncmp(l *int32, r *int32, n uint64) int32

//go:linkname Wcsncpy github.com/c2gohq/c2go_libc.wcsncpy
func Wcsncpy(d *int32, s *int32, n uint64) *int32

//go:linkname Wcsnlen github.com/c2gohq/c2go_libc.wcsnlen
func Wcsnlen(s *int32, n uint64) uint64

//go:linkname Wcsnrtombs github.com/c2gohq/c2go_libc.wcsnrtombs
func Wcsnrtombs(dst *byte, wcs **int32, wn uint64, n uint64, st *__mbstate_t) uint64

//go:linkname Wcspbrk github.com/c2gohq/c2go_libc.wcspbrk
func Wcspbrk(s *int32, b *int32) *int32

//go:linkname Wcsrchr github.com/c2gohq/c2go_libc.wcsrchr
func Wcsrchr(s *int32, c int32) *int32

//go:linkname Wcsrtombs github.com/c2gohq/c2go_libc.wcsrtombs
func Wcsrtombs(s *byte, ws **int32, n uint64, st *__mbstate_t) uint64

//go:linkname Wcsspn github.com/c2gohq/c2go_libc.wcsspn
func Wcsspn(s *int32, c *int32) uint64

//go:linkname Wcsstr github.com/c2gohq/c2go_libc.wcsstr
func Wcsstr(h *int32, n *int32) *int32

//go:linkname Wcstod github.com/c2gohq/c2go_libc.wcstod
func Wcstod(s *int32, p **int32) float64

//go:linkname Wcstof github.com/c2gohq/c2go_libc.wcstof
func Wcstof(s *int32, p **int32) float32

//go:linkname Wcstoimax github.com/c2gohq/c2go_libc.wcstoimax
func Wcstoimax(s *int32, p **int32, base int32) int64

//go:linkname Wcstok github.com/c2gohq/c2go_libc.wcstok
func Wcstok(s *int32, sep *int32, p **int32) *int32

//go:linkname Wcstol github.com/c2gohq/c2go_libc.wcstol
func Wcstol(s *int32, p **int32, base int32) int64

//go:linkname Wcstold github.com/c2gohq/c2go_libc.wcstold
func Wcstold(s *int32, p **int32) float64

//go:linkname Wcstoll github.com/c2gohq/c2go_libc.wcstoll
func Wcstoll(s *int32, p **int32, base int32) int64

//go:linkname Wcstombs github.com/c2gohq/c2go_libc.wcstombs
func Wcstombs(s *byte, ws *int32, n uint64) uint64

//go:linkname Wcstoul github.com/c2gohq/c2go_libc.wcstoul
func Wcstoul(s *int32, p **int32, base int32) uint64

//go:linkname Wcstoull github.com/c2gohq/c2go_libc.wcstoull
func Wcstoull(s *int32, p **int32, base int32) uint64

//go:linkname Wcstoumax github.com/c2gohq/c2go_libc.wcstoumax
func Wcstoumax(s *int32, p **int32, base int32) uint64

//go:linkname Wcswcs github.com/c2gohq/c2go_libc.wcswcs
func Wcswcs(haystack *int32, needle *int32) *int32

//go:linkname Wcswidth github.com/c2gohq/c2go_libc.wcswidth
func Wcswidth(wcs *int32, n uint64) int32

//go:linkname Wcsxfrm github.com/c2gohq/c2go_libc.wcsxfrm
func Wcsxfrm(dest *int32, src *int32, n uint64) uint64

//go:linkname WcsxfrmL github.com/c2gohq/c2go_libc.wcsxfrm_l
func WcsxfrmL(dest *int32, src *int32, n uint64, loc *__locale_struct) uint64

//go:linkname Wctob github.com/c2gohq/c2go_libc.wctob
func Wctob(c uint32) int32

//go:linkname Wctomb github.com/c2gohq/c2go_libc.wctomb
func Wctomb(s *byte, wc int32) int32

//go:linkname Wctrans github.com/c2gohq/c2go_libc.wctrans
func Wctrans(class *byte) int32

//go:linkname WctransL github.com/c2gohq/c2go_libc.wctrans_l
func WctransL(s *byte, l *__locale_struct) int32

//go:linkname Wctype github.com/c2gohq/c2go_libc.wctype
func Wctype(s *byte) uint64

//go:linkname WctypeL github.com/c2gohq/c2go_libc.wctype_l
func WctypeL(s *byte, l *__locale_struct) uint64

//go:linkname Wcwidth github.com/c2gohq/c2go_libc.wcwidth
func Wcwidth(wc int32) int32

//go:linkname Wmemchr github.com/c2gohq/c2go_libc.wmemchr
func Wmemchr(s *int32, c int32, n uint64) *int32

//go:linkname Wmemcmp github.com/c2gohq/c2go_libc.wmemcmp
func Wmemcmp(l *int32, r *int32, n uint64) int32

//go:linkname Wmemcpy github.com/c2gohq/c2go_libc.wmemcpy
func Wmemcpy(d *int32, s *int32, n uint64) *int32

//go:linkname Wmemmove github.com/c2gohq/c2go_libc.wmemmove
func Wmemmove(d *int32, s *int32, n uint64) *int32

//go:linkname Wmemset github.com/c2gohq/c2go_libc.wmemset
func Wmemset(d *int32, c int32, n uint64) *int32

//go:linkname Wprintf github.com/c2gohq/c2go_libc.wprintf
func Wprintf(fmt *int32, argptrs unsafe.Pointer) int32

//go:linkname Write github.com/c2gohq/c2go_libc.write
func Write(fd int32, buf unsafe.Pointer, n uint64) int64

//go:linkname Writev github.com/c2gohq/c2go_libc.writev
func Writev(fd int32, iov *iovec, iovcnt int32) int64

//go:linkname Wscanf github.com/c2gohq/c2go_libc.wscanf
func Wscanf(fmt *int32, argptrs unsafe.Pointer) int32

//go:linkname Y0 github.com/c2gohq/c2go_libc.y0
func Y0(x float64) float64

//go:linkname Y1 github.com/c2gohq/c2go_libc.y1
func Y1(x float64) float64

//go:linkname Yn github.com/c2gohq/c2go_libc.yn
func Yn(n int32, x float64) float64