ATOMIC_BOOL_LOCK_FREE :: true

ATOMIC_CHAR_LOCK_FREE :: true

ATOMIC_CHAR16_T_LOCK_FREE :: true

ATOMIC_CHAR32_T_LOCK_FREE :: true

ATOMIC_INT_LOCK_FREE :: true

ATOMIC_LLONG_LOCK_FREE :: true

ATOMIC_LONG_LOCK_FREE :: true

ATOMIC_POINTER_LOCK_FREE :: true

ATOMIC_SHORT_LOCK_FREE :: true

ATOMIC_WCHAR_T_LOCK_FREE :: true

BUFSIZ :: 512

CHAR_BIT :: 8

CLOCKS_PER_SEC :: 1000

EDOM :: 33

EILSEQ :: 42

EOF :: int(-1)

ERANGE :: 34

EXIT_FAILURE :: 1

EXIT_SUCCESS :: 0

FILENAME_MAX :: 260

FOPEN_MAX :: 20

FP_ILOGB0 :: FP_ILOGBNAN

FP_ILOGBNAN :: -1 - int((~uint(0)) >> 1)

FP_INFINITE :: 1

FP_NAN :: 0

FP_NORMAL :: 3

FP_SUBNORMAL :: 4

FP_ZERO :: 2

HUGE_VAL :: double(INFINITY)

HUGE_VALF :: INFINITY

INFINITY :: 0h7ff00000_00000000

INT16_MAX :: c.INT16_MAX

INT16_MIN :: c.INT16_MIN

INT32_MAX :: c.INT32_MAX

INT32_MIN :: c.INT32_MIN

INT64_MAX :: c.INT64_MAX

INT64_MIN :: c.INT64_MIN

INT8_MAX :: c.INT8_MAX

INT8_MIN :: c.INT8_MIN

L_tmpnam :: 15

LC_ALL :: 0

LC_COLLATE :: 1

LC_CTYPE :: 2

LC_MESSAGES :: 6

LC_MONETARY :: 3

LC_NUMERIC :: 4

LC_TIME :: 5

MATH_ERREXCEPT :: 2

math_errhandling :: 2

MATH_ERRNO :: 1

memory_order_acq_rel :: memory_order.acq_rel

memory_order_acquire :: memory_order.acquire

memory_order_consume :: memory_order.consume

memory_order_relaxed :: memory_order.relaxed

memory_order_release :: memory_order.release

memory_order_seq_cst :: memory_order.seq_cst

mtx_plain :: 1

mtx_recursive :: 0x100

mtx_timed :: 4

NDEBUG :: !ODIN_DEBUG

NULL :: rawptr(uintptr(0))

PTRDIFF_MAX :: c.PTRDIFF_MAX

PTRDIFF_MIN :: c.PTRDIFF_MIN

RAND_MAX :: 0x7fff

SEEK_CUR :: 1

SEEK_END :: 2

SEEK_SET :: 0

SIG_ATOMIC_MAX :: max(sig_atomic_t)

SIG_ATOMIC_MIN :: min(sig_atomic_t)

SIG_DFL :: rawptr(uintptr(0))

SIG_ERR :: rawptr(~uintptr(0))

SIG_IGN :: rawptr(uintptr(1))

SIGABRT :: 22

SIGFPE :: 8

SIGILL :: 4

SIGINT :: 2

SIGSEGV :: 11

SIGTERM :: 15

SIZE_MAX :: c.SIZE_MAX

thrd_busy :: 3

thrd_error :: 4

thrd_nomem :: 1

thrd_success :: 0

thrd_timedout :: 2

TIME_UTC :: 1

TMP_MAX :: 32767

TSS_DTOR_ITERATIONS :: 4

UINT16_MAX :: c.UINT16_MAX

UINT32_MAX :: c.UINT32_MAX

UINT64_MAX :: c.UINT64_MAX

UINT8_MAX :: c.UINT8_MAX

WCHAR_MAX :: c.WCHAR_MAX

WCHAR_MIN :: c.WCHAR_MIN

WEOF :: ~wint_t(0)

WINT_MAX :: 1 << (size_of(wint_t) * 8)

WINT_MIN :: 0

atomic_bool :: distinct atomic_bool

atomic_char :: distinct atomic_char

atomic_char16_t :: distinct atomic_char16_t

atomic_char32_t :: distinct atomic_char32_t

atomic_flag :: distinct atomic_flag

atomic_int :: distinct atomic_int

atomic_int_fast16_t :: distinct atomic_int_fast16_t

atomic_int_fast32_t :: distinct atomic_int_fast32_t

atomic_int_fast64_t :: distinct atomic_int_fast64_t

atomic_int_fast8_t :: distinct atomic_int_fast8_t

atomic_int_least16_t :: distinct atomic_int_least16_t

atomic_int_least32_t :: distinct atomic_int_least32_t

atomic_int_least64_t :: distinct atomic_int_least64_t

atomic_int_least8_t :: distinct atomic_int_least8_t

atomic_intmax_t :: distinct atomic_intmax_t

atomic_intptr_t :: distinct atomic_intptr_t

atomic_llong :: distinct atomic_llong

atomic_long :: distinct atomic_long

atomic_ptrdiff_t :: distinct atomic_ptrdiff_t

atomic_schar :: distinct atomic_schar

atomic_short :: distinct atomic_short

atomic_size_t :: distinct atomic_size_t

atomic_uchar :: distinct atomic_uchar

atomic_uint :: distinct atomic_uint

atomic_uint_fast16_t :: distinct atomic_uint_fast16_t

atomic_uint_fast32_t :: distinct atomic_uint_fast32_t

atomic_uint_fast64_t :: distinct atomic_uint_fast64_t

atomic_uint_fast8_t :: distinct atomic_uint_fast8_t

atomic_uint_least16_t :: distinct atomic_uint_least16_t

atomic_uint_least32_t :: distinct atomic_uint_least32_t

atomic_uint_least64_t :: distinct atomic_uint_least64_t

atomic_uint_least8_t :: distinct atomic_uint_least8_t

atomic_uintmax_t :: distinct atomic_uintmax_t

atomic_uintptr_t :: distinct atomic_uintptr_t

atomic_ullong :: distinct atomic_ullong

atomic_ulong :: distinct atomic_ulong

atomic_ushort :: distinct atomic_ushort

atomic_wchar_t :: distinct atomic_wchar_t

bool :: bool

char :: u8

char16_t :: u16

char32_t :: u32

clock_t :: distinct clock_t

cnd_t :: distinct cnd_t

complex_double :: distinct complex_double

complex_float :: distinct complex_float

div_t :: div_t

double :: f64

double_t :: f64

FILE :: FILE

float :: f32

float_t :: f32

fpos_t :: distinct fpos_t

int :: i32

int_fast16_t :: i32

int_fast32_t :: i32

int_fast64_t :: i64

int_fast8_t :: i8

int_least16_t :: i16

int_least32_t :: i32

int_least64_t :: i64

int_least8_t :: i8

int16_t :: i16

int32_t :: i32

int64_t :: i64

int8_t :: i8

intmax_t :: i64

intptr_t :: int

jmp_buf :: jmp_buf

lconv :: lconv

ldiv_t :: ldiv_t

lldiv_t :: lldiv_t

Locale_Category :: Locale_Category

long :: i32

longlong :: i64

mbstate_t :: mbstate_t

memory_order :: memory_order

mtx_t :: distinct mtx_t

once_flag :: distinct once_flag

ptrdiff_t :: ptrdiff_t

schar :: i8

short :: i16

sig_atomic_t :: distinct sig_atomic_t

size_t :: uint

ssize_t :: int

thrd_start_t :: thrd_start_t

thrd_t :: thrd_t

time_t :: distinct time_t

timespec :: timespec

tm :: tm

tss_dtor_t :: tss_dtor_t

tss_t :: distinct tss_t

uchar :: u8

uint :: u32

uint_fast16_t :: u32

uint_fast32_t :: u32

uint_fast64_t :: u64

uint_fast8_t :: u8

uint_least16_t :: u16

uint_least32_t :: u32

uint_least64_t :: u64

uint_least8_t :: u8

uint16_t :: u16

uint32_t :: u32

uint64_t :: u64

uint8_t :: u8

uintmax_t :: u64

uintptr_t :: uintptr

ulong :: u32

ulonglong :: u64

ushort :: u16

va_list :: va_list

wchar_t :: u16

wctrans_t :: distinct wctrans_t

wctype_t :: distinct wctype_t

Whence :: Whence

wint_t :: distinct wint_t

abort :: proc "c" () ---

abs :: proc "c" (j: i32) -> i32 ---

aligned_alloc :: proc "c" (alignment, size: uint) -> rawptr {…}

aligned_free :: proc "c" (ptr: rawptr) {…}

asctime :: proc "c" (timeptr: ^tm) -> [^]u8 ---

at_quick_exit :: proc "c" (func: proc "c" ()) -> i32 ---

atexit :: proc "c" (func: proc "c" ()) -> i32 ---

atof :: proc "c" (nptr: cstring) -> f64 ---

atoi :: proc "c" (nptr: cstring) -> i32 ---

atol :: proc "c" (nptr: cstring) -> i32 ---

atoll :: proc "c" (nptr: cstring) -> i64 ---

atomic_compare_exchange_strong :: proc(object, expected: ^$T, desired: $T) -> bool {…}

atomic_compare_exchange_strong_explicit :: proc(object, expected: ^$T, desired: $T, success, failure: memory_order) -> bool {…}

atomic_compare_exchange_weak :: proc(object, expected: ^$T, desired: $T) -> bool {…}

atomic_compare_exchange_weak_explicit :: proc(object, expected: ^$T, desired: $T, success, failure: memory_order) -> bool {…}

atomic_exchange :: proc(object: ^$T, desired: $T) -> $$deferred_return {…}

atomic_exchange_explicit :: proc(object: ^$T, desired: $T, order: memory_order) -> $$deferred_return {…}

atomic_fetch_add :: proc(object: ^$T, operand: $T) -> $$deferred_return {…}

atomic_fetch_add_explicit :: proc(object: ^$T, operand: $T, order: memory_order) -> $$deferred_return {…}

atomic_fetch_and :: proc(object: ^$T, operand: $T) -> $$deferred_return {…}

atomic_fetch_and_explicit :: proc(object: ^$T, operand: $T, order: memory_order) -> $$deferred_return {…}

atomic_fetch_or :: proc(object: ^$T, operand: $T) -> $$deferred_return {…}

atomic_fetch_or_explicit :: proc(object: ^$T, operand: $T, order: memory_order) -> $$deferred_return {…}

atomic_fetch_sub :: proc(object: ^$T, operand: $T) -> $$deferred_return {…}

atomic_fetch_sub_explicit :: proc(object: ^$T, operand: $T, order: memory_order) -> $$deferred_return {…}

atomic_fetch_xor :: proc(object: ^$T, operand: $T) -> $$deferred_return {…}

atomic_fetch_xor_explicit :: proc(object: ^$T, operand: $T, order: memory_order) -> $$deferred_return {…}

atomic_flag_clear :: proc(flag: ^atomic_flag) {…}

atomic_flag_clear_explicit :: proc(flag: ^atomic_flag, order: memory_order) {…}

atomic_flag_test_and_set :: proc(flag: ^atomic_flag) -> bool {…}

atomic_flag_test_and_set_explicit :: proc(flag: ^atomic_flag, order: memory_order) -> bool {…}

atomic_init :: proc(obj: ^$T, value: $T) {…}

atomic_is_lock_free :: proc(obj: ^$T) -> bool {…}

atomic_load :: proc(object: ^$T) -> $$deferred_return {…}

atomic_load_explicit :: proc(object: ^$T, order: memory_order) {…}

atomic_signal_fence :: proc(order: memory_order) {…}

atomic_store :: proc(object: ^$T, desired: $T) {…}

atomic_store_explicit :: proc(object: ^$T, desired: $T, order: memory_order) {…}

atomic_thread_fence :: proc(order: memory_order) {…}

ATOMIC_VAR_INIT :: proc(value: $T) -> $$deferred_return {…}

bsearch :: proc "c" (key, base: rawptr, nmemb, size: uint, compar: proc "c" (lhs, rhs: rawptr) -> i32) -> rawptr ---

btowc :: proc "c" (c: i32) -> wint_t ---

c16rtomb :: proc "c" (s: ^u8, c16: u16, ps: ^mbstate_t) -> uint ---

c32rtomb :: proc "c" (s: ^u8, c32: u32, ps: ^mbstate_t) -> uint ---

cabs :: proc "c" (z: complex_double) -> f64 ---

cabsf :: proc "c" (z: complex_float) -> f32 ---

cacos :: proc "c" (z: complex_double) -> complex_double ---

cacosf :: proc "c" (z: complex_float) -> complex_float ---

cacosh :: proc "c" (z: complex_double) -> complex_double ---

cacoshf :: proc "c" (z: complex_float) -> complex_float ---

@(link_name="_Call_once")

call_once :: proc "c" (flag: ^once_flag, func: proc "c" ()) ---

calloc :: proc "c" (nmemb, size: uint) -> rawptr ---

carg :: proc "c" (z: complex_double) -> f64 ---

cargf :: proc "c" (z: complex_float) -> f32 ---

casin :: proc "c" (z: complex_double) -> complex_double ---

casinf :: proc "c" (z: complex_float) -> complex_float ---

casinh :: proc "c" (z: complex_double) -> complex_double ---

casinhf :: proc "c" (z: complex_float) -> complex_float ---

catan :: proc "c" (z: complex_double) -> complex_double ---

catanf :: proc "c" (z: complex_float) -> complex_float ---

catanh :: proc "c" (z: complex_double) -> complex_double ---

catanhf :: proc "c" (z: complex_float) -> complex_float ---

ccos :: proc "c" (z: complex_double) -> complex_double ---

ccosf :: proc "c" (z: complex_float) -> complex_float ---

ccosh :: proc "c" (z: complex_double) -> complex_double ---

ccoshf :: proc "c" (z: complex_float) -> complex_float ---

cexp :: proc "c" (z: complex_double) -> complex_double ---

cexpf :: proc "c" (z: complex_float) -> complex_float ---

cimag :: proc "c" (z: complex_double) -> f64 ---

cimagf :: proc "c" (z: complex_float) -> f32 ---

clearerr :: proc "c" (stream: ^FILE) ---

clock :: proc "c" () -> clock_t ---

clog :: proc "c" (z: complex_double) -> complex_double ---

clogf :: proc "c" (z: complex_float) -> complex_float ---

CMPLX :: proc(x, y: f64) -> complex_double {…}

CMPLXF :: proc(x, y: f32) -> complex_float {…}

@(link_name="_Cnd_broadcast")

cnd_broadcast :: proc "c" (cond: ^cnd_t) -> i32 ---

@(link_name="_Cnd_destroy")

cnd_destroy :: proc "c" (cond: ^cnd_t) ---

@(link_name="_Cnd_init")

cnd_init :: proc "c" (cond: ^cnd_t) -> i32 ---

@(link_name="_Cnd_signal")

cnd_signal :: proc "c" (cond: ^cnd_t) -> i32 ---

@(link_name="_Cnd_timedwait")

cnd_timedwait :: proc "c" (cond: ^cnd_t, mtx: ^mtx_t, ts: ^timespec) -> i32 ---

@(link_name="_Cnd_wait")

cnd_wait :: proc "c" (cond: ^cnd_t, mtx: ^mtx_t) -> i32 ---

conj :: proc "c" (z: complex_double) -> complex_double ---

conjf :: proc "c" (z: complex_float) -> complex_float ---

cpow :: proc "c" (x, y: complex_double) -> complex_double ---

cpowf :: proc "c" (x, y: complex_float) -> complex_float ---

cproj :: proc "c" (z: complex_double) -> complex_double ---

cprojf :: proc "c" (z: complex_float) -> complex_float ---

creal :: proc "c" (z: complex_double) -> f64 ---

crealf :: proc "c" (z: complex_float) -> f32 ---

csin :: proc "c" (z: complex_double) -> complex_double ---

csinf :: proc "c" (z: complex_float) -> complex_float ---

csinh :: proc "c" (z: complex_double) -> complex_double ---

csinhf :: proc "c" (z: complex_float) -> complex_float ---

csqrt :: proc "c" (z: complex_double) -> complex_double ---

csqrtf :: proc "c" (z: complex_float) -> complex_float ---

ctan :: proc "c" (z: complex_double) -> complex_double ---

ctanf :: proc "c" (z: complex_float) -> complex_float ---

ctanh :: proc "c" (z: complex_double) -> complex_double ---

ctanhf :: proc "c" (z: complex_float) -> complex_float ---

@(link_name="_ctime64")

ctime :: proc "c" (timer: ^time_t) -> [^]u8 ---

@(link_name="_difftime64")

difftime :: proc "c" (time1, time2: time_t) -> f64 ---

div :: proc "c" (numer, denom: i32) -> div_t ---

errno :: proc "contextless" () -> ^i32 {…}

exit :: proc "c" (status: i32) -> ! ---

fclose :: proc "c" (stream: ^FILE) -> i32 ---

feof :: proc "c" (stream: ^FILE) -> i32 ---

ferror :: proc "c" (stream: ^FILE) -> i32 ---

fflush :: proc "c" (stream: ^FILE) -> i32 ---

fgetc :: proc "c" (stream: ^FILE) -> i32 ---

@(link_name=LFGETPOS)

fgetpos :: proc "c" (stream: ^FILE, pos: ^fpos_t) -> i32 ---

fgets :: proc "c" (s: [^]u8, n: i32, stream: ^FILE) -> [^]u8 ---

fgetws :: proc "c" (s: [^]u16, n: i32, stream: ^FILE) -> u16 ---

fopen :: proc "c" (filename, mode: cstring) -> ^FILE ---

fprintf :: proc "c" (stream: ^FILE, format: cstring, args: ..any) -> i32 ---

fputc :: proc "c" (s: i32, stream: ^FILE) -> i32 ---

fputwc :: proc "c" (c: u16, stream: ^FILE) -> wint_t ---

fputws :: proc "c" (s: [^]u16, stream: ^FILE) -> i32 ---

fread :: proc "c" (ptr: rawptr, size: uint, nmemb: uint, stream: ^FILE) -> uint ---

free :: proc "c" (ptr: rawptr) ---

freopen :: proc "c" (filename, mode: cstring, stream: ^FILE) -> ^FILE ---

fscanf :: proc "c" (stream: ^FILE, format: cstring, args: ..any) -> i32 ---

fseek :: proc "c" (stream: ^FILE, offset: i32, whence: Whence) -> i32 ---

@(link_name=LFSETPOS)

fsetpos :: proc "c" (stream: ^FILE, pos: ^fpos_t) -> i32 ---

ftell :: proc "c" (stream: ^FILE) -> i32 ---

fwgetc :: proc "c" (stream: ^FILE) -> wint_t ---

fwide :: proc "c" (stream: ^FILE, mode: i32) -> i32 ---

fwprintf :: proc "c" (stream: ^FILE, format: [^]u16, arg: ..any) -> i32 ---

fwrite :: proc "c" (ptr: rawptr, size: uint, nmemb: uint, stream: ^FILE) -> uint ---

fwscanf :: proc "c" (stream: ^FILE, format: [^]u16, arg: ..any) -> i32 ---

getc :: proc "c" (stream: ^FILE) -> i32 ---

getchar :: proc "c" () -> i32 ---

getenv :: proc "c" (name: cstring) -> cstring ---

getwc :: proc "c" (stream: ^FILE) -> wint_t ---

getwchar :: proc "c" () -> wint_t ---

@(link_name="_gmtime64")

gmtime :: proc "c" (timer: ^time_t) -> ^tm ---

isalnum :: proc "c" (c: i32) -> i32 ---

isalpha :: proc "c" (c: i32) -> i32 ---

isblank :: proc "c" (c: i32) -> i32 ---

iscntrl :: proc "c" (c: i32) -> i32 ---

isdigit :: proc "c" (c: i32) -> i32 ---

isfinite :: proc(x: $T) -> bool {…}

isgraph :: proc "c" (c: i32) -> i32 ---

isgreater :: proc(x, y: $T) -> bool {…}

isgreaterequal :: proc(x, y: $T) -> bool {…}

isinf :: proc(x: $T) -> bool {…}

isless :: proc(x, y: $T) -> bool {…}

islessequal :: proc(x, y: $T) -> bool {…}

islessgreater :: proc(x, y: $T) -> bool {…}

islower :: proc "c" (c: i32) -> i32 ---

isnan :: proc(x: $T) -> bool {…}

isnormal :: proc(x: $T) -> bool {…}

isprint :: proc "c" (c: i32) -> i32 ---

ispunct :: proc "c" (c: i32) -> i32 ---

isspace :: proc "c" (c: i32) -> i32 ---

isunordered :: proc(x, y: $T) -> bool {…}

isupper :: proc "c" (c: i32) -> i32 ---

iswalnum :: proc "c" (wc: wint_t) -> i32 ---

iswalpha :: proc "c" (wc: wint_t) -> i32 ---

iswblank :: proc "c" (wc: wint_t) -> i32 ---

iswcntrl :: proc "c" (wc: wint_t) -> i32 ---

iswctype :: proc "c" (wc: wint_t, desc: wctype_t) -> i32 ---

iswdigit :: proc "c" (wc: wint_t) -> i32 ---

iswgraph :: proc "c" (wc: wint_t) -> i32 ---

iswlower :: proc "c" (wc: wint_t) -> i32 ---

iswprint :: proc "c" (wc: wint_t) -> i32 ---

iswpunct :: proc "c" (wc: wint_t) -> i32 ---

iswspace :: proc "c" (wc: wint_t) -> i32 ---

iswupper :: proc "c" (wc: wint_t) -> i32 ---

iswxdigit :: proc "c" (wc: wint_t) -> i32 ---

isxdigit :: proc "c" (c: i32) -> i32 ---

kill_dependency :: proc(value: $T) -> $$deferred_return {…}

labs :: proc "c" (j: i32) -> i32 ---

ldiv :: proc "c" (numer, denom: i32) -> ldiv_t ---

llabs :: proc "c" (j: i64) -> i64 ---

lldiv :: proc "c" (numer, denom: i64) -> lldiv_t ---

localeconv :: proc "c" () -> ^lconv ---

@(link_name="_localtime64")

localtime :: proc "c" (timer: ^time_t) -> ^tm ---

@(link_name=LLONGJMP)

longjmp :: proc "c" (env: ^jmp_buf, val: i32) -> ! ---

malloc :: proc "c" (size: uint) -> rawptr ---

MB_CUR_MAX :: proc() -> uint {…}

mblen :: proc "c" (s: cstring, n: uint) -> i32 ---

mbrlen :: proc "c" (s: cstring, n: uint, ps: ^mbstate_t) -> uint ---

mbrtoc16 :: proc "c" (pc16: [^]u16, s: cstring, n: uint, ps: ^mbstate_t) -> uint ---

mbrtoc32 :: proc "c" (pc32: [^]u32, s: cstring, n: uint, ps: ^mbstate_t) -> uint ---

mbrtowc :: proc "c" (pwc: [^]u16, s: cstring, n: uint, ps: ^mbstate_t) -> uint ---

mbsinit :: proc "c" (ps: ^mbstate_t) -> i32 ---

mbsrtowcs :: proc "c" (dst: [^]u16, src: ^cstring, len: uint, ps: ^mbstate_t) -> uint ---

mbstowcs :: proc "c" (pwcs: ^u16, s: cstring, n: uint) -> uint ---

mbtowc :: proc "c" (pwc: ^u16, s: cstring, n: uint) -> i32 ---

memchr :: proc "c" (s: rawptr, c: i32, n: uint) -> rawptr ---

memcmp :: proc "c" (s1, s2: rawptr, n: uint) -> i32 ---

memcpy :: proc "c" (s1, s2: rawptr, n: uint) -> rawptr ---

memmove :: proc "c" (s1, s2: rawptr, n: uint) -> rawptr ---

memset :: proc "c" (s: rawptr, c: i32, n: uint) -> rawptr {…}

mktime :: proc "c" (timeptr: ^tm) -> time_t ---

@(link_name="_Mtx_destroy")

mtx_destroy :: proc "c" (mtx: ^mtx_t) ---

@(link_name="_Mtx_init")

mtx_init :: proc "c" (mtx: ^mtx_t, type: i32) -> i32 ---

@(link_name="_Mtx_lock")

mtx_lock :: proc "c" (mtx: ^mtx_t) -> i32 ---

@(link_name="_Mtx_timedlock")

mtx_timedlock :: proc "c" (mtx: ^mtx_t, ts: ^timespec) -> i32 ---

@(link_name="_Mtx_trylock")

mtx_trylock :: proc "c" (mtx: ^mtx_t) -> i32 ---

@(link_name="_Mtx_unlock")

mtx_unlock :: proc "c" (mtx: ^mtx_t) -> i32 ---

perror :: proc "c" (s: cstring) ---

printf :: proc "c" (format: cstring, args: ..any) -> i32 ---

putc :: proc "c" (c: i32, stream: ^FILE) -> i32 ---

putchar :: proc "c" (c: i32) -> i32 ---

puts :: proc "c" (s: cstring) -> i32 ---

putwc :: proc "c" (c: u16, stream: ^FILE) -> wint_t ---

putwchar :: proc "c" (c: u16) -> wint_t ---

qsort :: proc "c" (base: rawptr, nmemb, size: uint, compar: proc "c" (lhs, rhs: rawptr) -> i32) ---

quick_exit :: proc "c" (status: i32) -> ! ---

raise :: proc "c" (sig: i32) -> i32 ---

rand :: proc "c" () -> i32 ---

realloc :: proc "c" (ptr: rawptr, size: uint) -> rawptr ---

remove :: proc "c" (filename: cstring) -> i32 ---

@(link_name=LRENAME)

rename :: proc "c" (old, new: cstring) -> i32 ---

rewind :: proc "c" (stream: ^FILE) ---

scanf :: proc "c" (format: cstring, args: ..any) -> i32 ---

setbuf :: proc "c" (stream: ^FILE, buf: [^]u8) ---

@(link_name="_setjmp")

setjmp :: proc "c" (env: ^jmp_buf, hack: rawptr = nil) -> i32 ---

@(link_name=LSETLOCALE)

setlocale :: proc "c" (category: Locale_Category, locale: cstring) -> cstring ---

setvbuf :: proc "c" (stream: ^FILE, buf: [^]u8, mode: i32, size: uint) -> i32 ---

signal :: proc "c" (sig: i32, func: proc "c" (i32)) -> proc "c" (i32) ---

snprintf :: proc "c" (s: [^]u8, n: uint, format: cstring, args: ..any) -> i32 ---

srand :: proc "c" (seed: u32) ---

sscanf :: proc "c" (s, format: cstring, args: ..any) -> i32 ---

strcat :: proc "c" (s1: [^]u8, s2: cstring) -> [^]u8 ---

strchr :: proc "c" (s: cstring, c: i32) -> [^]u8 ---

strcmp :: proc "c" (s1, s2: cstring) -> i32 ---

strcoll :: proc "c" (s1, s2: cstring) -> i32 ---

strcpn :: proc "c" (s1, s2: cstring) -> [^]u8 ---

strcpy :: proc "c" (s1: [^]u8, s2: cstring) -> [^]u8 ---

strcspn :: proc "c" (s1, s2: cstring) -> uint ---

strerror :: proc "c" (errnum: i32) -> cstring ---

strftime :: proc "c" (s: [^]u8, maxsize: uint, format: cstring, timeptr: ^tm) -> uint ---

strlen :: proc "c" (s: cstring) -> uint ---

strncat :: proc "c" (s1: [^]u8, s2: cstring, n: uint) -> [^]u8 ---

strncmp :: proc "c" (s1, s2: cstring, n: uint) -> i32 ---

strncpy :: proc "c" (s1: [^]u8, s2: cstring, n: uint) -> [^]u8 ---

strpbrk :: proc "c" (s1, s2: cstring) -> [^]u8 ---

strrchr :: proc "c" (s: [^]u8, c: i32) -> [^]u8 ---

strtod :: proc "c" (nptr: cstring, endptr: ^[^]u8) -> f64 ---

strtof :: proc "c" (nptr: cstring, endptr: ^[^]u8) -> f32 ---

strtok :: proc "c" (s1: [^]u8, s2: cstring) -> [^]u8 ---

strtol :: proc "c" (nptr: cstring, endptr: ^[^]u8, base: i32) -> i32 ---

strtoll :: proc "c" (nptr: cstring, endptr: ^[^]u8, base: i32) -> i64 ---

strtoul :: proc "c" (nptr: cstring, endptr: ^[^]u8, base: i32) -> u32 ---

strtoull :: proc "c" (nptr: cstring, endptr: ^[^]u8, base: i32) -> u64 ---

strxfrm :: proc "c" (s1: [^]u8, s2: cstring, n: uint) -> uint ---

swprintf :: proc "c" (stream: ^FILE, n: uint, format: [^]u16, arg: ..any) -> i32 ---

swscanf :: proc "c" (s, format: [^]u16, arg: ..any) -> i32 ---

system :: proc "c" (cmd: cstring) -> i32 ---

@(link_name="_Thrd_create")

thrd_create :: proc "c" (thr: ^thrd_t, func: thrd_start_t, arg: rawptr) -> i32 ---

@(link_name="_Thrd_current")

thrd_current :: proc "c" () -> thrd_t ---

@(link_name="_Thrd_detach")

thrd_detach :: proc "c" (thr: thrd_t) -> i32 ---

@(link_name="_Thrd_equal")

thrd_equal :: proc "c" (lhs, rhs: thrd_t) -> i32 ---

@(link_name="_Thrd_exit")

thrd_exit :: proc "c" (res: i32) -> ! ---

@(link_name="_Thrd_join")

thrd_join :: proc "c" (thr: thrd_t, res: ^i32) -> i32 ---

@(link_name="_Thrd_sleep")

thrd_sleep :: proc "c" (duration, remaining: ^timespec) -> i32 ---

@(link_name="_Thrd_yield")

thrd_yield :: proc "c" () ---

@(link_name="_time64")

time :: proc "c" (timer: ^time_t) -> time_t ---

@(link_name="_timespec64_get")

timespec_get :: proc "c" (ts: ^timespec, base: i32) -> i32 ---

tmpfile :: proc "c" () -> ^FILE ---

tmpnam :: proc "c" (s: [^]u8) -> [^]u8 ---

to_stream :: proc(file: ^FILE) -> Stream {…}

tolower :: proc "c" (c: i32) -> i32 ---

toupper :: proc "c" (c: i32) -> i32 ---

towctrans :: proc "c" (wc: wint_t, desc: wctrans_t) -> wint_t ---

towlower :: proc "c" (wc: wint_t) -> wint_t ---

towupper :: proc "c" (wc: wint_t) -> wint_t ---

@(link_name="_Tss_create")

tss_create :: proc "c" (key: ^tss_t, dtor: tss_dtor_t) -> i32 ---

@(link_name="_Tss_delete")

tss_delete :: proc "c" (key: tss_t) ---

@(link_name="_Tss_get")

tss_get :: proc "c" (key: tss_t) -> rawptr ---

@(link_name="_Tss_set")

tss_set :: proc "c" (key: tss_t, val: rawptr) -> i32 ---

ungetc :: proc "c" (c: i32, stream: ^FILE) -> i32 ---

ungetwc :: proc "c" (c: u16, stream: ^FILE) -> wint_t ---

va_copy :: proc(dst, src: ^va_list) {…}

va_end :: proc(ap: ^va_list) {…}

va_start :: proc(ap: ^va_list, _: any) {…}

vfprintf :: proc "c" (stream: ^FILE, format: cstring, arg: ^va_list) -> i32 ---

vfscanf :: proc "c" (stream: ^FILE, format: cstring, arg: ^va_list) -> i32 ---

vfwprintf :: proc "c" (stream: ^FILE, format: [^]u16, arg: va_list) -> i32 ---

vfwscanf :: proc "c" (stream: ^FILE, format: [^]u16, arg: va_list) -> i32 ---

vprintf :: proc "c" (format: cstring, arg: ^va_list) -> i32 ---

vscanf :: proc "c" (format: cstring, arg: ^va_list) -> i32 ---

vsnprintf :: proc "c" (s: [^]u8, n: uint, format: cstring, arg: ^va_list) -> i32 ---

vsprintf :: proc "c" (s: [^]u8, format: cstring, arg: ^va_list) -> i32 ---

vsscanf :: proc "c" (s, format: cstring, arg: ^va_list) -> i32 ---

vswprintf :: proc "c" (s: [^]u16, n: uint, format: [^]u16, arg: va_list) -> i32 ---

vswscanf :: proc "c" (s, format: [^]u16, arg: va_list) -> i32 ---

vwprintf :: proc "c" (format: [^]u16, arg: va_list) -> i32 ---

vwscanf :: proc "c" (format: [^]u16, arg: va_list) -> i32 ---

wcrtomb :: proc "c" (s: ^u8, wc: u16, ps: ^mbstate_t) -> uint ---

wcscat :: proc "c" (s1, s2: [^]u16) -> [^]u16 ---

wcschr :: proc "c" (s: [^]u16, c: u16) -> [^]u16 ---

wcscmp :: proc "c" (s1, s2: [^]u16) -> i32 ---

wcscoll :: proc "c" (s1, s2: [^]u16) -> i32 ---

wcscpy :: proc "c" (s1, s2: [^]u16) -> [^]u16 ---

wcscspn :: proc "c" (s1, s2: [^]u16) -> uint ---

wcsftime :: proc "c" (s: [^]u16, maxsize: uint, format: [^]u16, timeptr: ^tm) -> uint ---

wcslen :: proc "c" (s: [^]u16) -> uint ---

wcsncat :: proc "c" (s1, s2: [^]u16, n: uint) -> [^]u16 ---

wcsncmp :: proc "c" (s1, s2: [^]u16, n: uint) -> i32 ---

wcsncpy :: proc "c" (s1, s2: [^]u16, n: uint) -> [^]u16 ---

wcspbrk :: proc "c" (s1, s2: [^]u16) -> [^]u16 ---

wcsrchr :: proc "c" (s: [^]u16, c: u16) -> [^]u16 ---

wcsrtombs :: proc "c" (dst: ^u8, src: ^[^]u16, len: uint, ps: ^mbstate_t) -> uint ---

wcsspn :: proc "c" (s1, s2: [^]u16) -> uint ---

wcsstr :: proc "c" (s1, s2: [^]u16) -> [^]u16 ---

wcstod :: proc "c" (nptr: [^]u16, endptr: ^[^]u16) -> f64 ---

wcstof :: proc "c" (nptr: [^]u16, endptr: ^[^]u16) -> f32 ---

wcstok :: proc "c" (s1, s2: [^]u16, ptr: ^[^]u16) -> [^]u16 ---

wcstol :: proc "c" (nptr: [^]u16, endptr: ^[^]u16, base: i32) -> i32 ---

wcstoll :: proc "c" (nptr: [^]u16, endptr: ^[^]u16, base: i32) -> i64 ---

wcstombs :: proc "c" (s: [^]u8, pwcs: ^u16, n: uint) -> uint ---

wcstoul :: proc "c" (nptr: [^]u16, endptr: ^[^]u16, base: i32) -> u32 ---

wcstoull :: proc "c" (nptr: [^]u16, endptr: ^[^]u16, base: i32) -> u64 ---

wcsxfrm :: proc "c" (s1, s2: [^]u16, n: uint) -> uint ---

wctob :: proc "c" (c: wint_t) -> i32 ---

wctomb :: proc "c" (s: [^]u8, wc: u16) -> i32 ---

wctrans :: proc "c" (property: cstring) -> wctrans_t ---

wctype :: proc "c" (property: cstring) -> wctype_t ---

wmemchr :: proc "c" (s: [^]u16, c: u16, n: uint) -> [^]u16 ---

wmemcmp :: proc "c" (s1, s2: [^]u16, n: uint) -> i32 ---

wmemcpy :: proc "c" (s1, s2: [^]u16, n: uint) -> [^]u16 ---

wmemmove :: proc "c" (s1, s2: [^]u16, n: uint) -> [^]u16 ---

wmemset :: proc "c" (s: [^]u16, c: u16, n: uint) -> [^]u16 ---

wprintf :: proc "c" (format: [^]u16, arg: ..any) -> i32 ---

wscanf :: proc "c" (format: [^]u16, arg: ..any) -> i32 ---

acos :: proc{
	libc_acos,
	libc_acosf,
	cacos,
	cacosf,
}

acosf :: proc{
	libc_acosf,
}

acosh :: proc{
	libc_acosh,
	libc_acoshf,
	cacosh,
	cacoshf,
}

acoshf :: proc{
	libc_acoshf,
}

asin :: proc{
	libc_asin,
	libc_asinf,
	casin,
	casinf,
}

asinf :: proc{
	libc_asinf,
}

asinh :: proc{
	libc_asinh,
	libc_asinhf,
	casinh,
	casinhf,
}

asinhf :: proc{
	libc_asinhf,
}

atan :: proc{
	libc_atan,
	libc_atanf,
	catan,
	catanf,
}

atan2 :: proc{
	libc_atan2,
	libc_atan2f,
}

atan2f :: proc{
	libc_atan2f,
}

atanf :: proc{
	libc_atanf,
}

atanh :: proc{
	libc_atanh,
	libc_atanhf,
	catanh,
	catanhf,
}

atanhf :: proc{
	libc_atanhf,
}

cbrt :: proc{
	libc_cbrt,
	libc_cbrtf,
}

cbrtf :: proc{
	libc_cbrtf,
}

ceil :: proc{
	libc_ceil,
	libc_ceilf,
}

ceilf :: proc{
	libc_ceilf,
}

copysign :: proc{
	libc_copysign,
	libc_copysignf,
}

copysignf :: proc{
	libc_copysignf,
}

cos :: proc{
	libc_cos,
	libc_cosf,
	ccos,
	ccosf,
}

cosf :: proc{
	libc_cosf,
}

cosh :: proc{
	libc_cosh,
	libc_coshf,
	ccosh,
	ccoshf,
}

coshf :: proc{
	libc_coshf,
}

erf :: proc{
	libc_erf,
	libc_erff,
}

erfc :: proc{
	libc_erfc,
	libc_erfcf,
}