Update dependencies (#1813)

1 files changed, 1199 insertions, 0 deletions

diff --git a/vendor/modernc.org/libc/musl_windows_arm64.go b/vendor/modernc.org/libc/musl_windows_arm64.go
new file mode 100644
index 00000000..2804cdc9
--- /dev/null
+++ b/vendor/modernc.org/libc/musl_windows_arm64.go
@@ -0,0 +1,1199 @@
+// Code generated by 'ccgo -D__environ=environ -export-externs X -hide __syscall0,__syscall1,__syscall2,__syscall3,__syscall4,__syscall5,__syscall6 -nostdinc -nostdlib -o ../musl_windows_arm64.go -pkgname libc -static-locals-prefix _s -Iarch\aarch64 -Iarch/generic -Iobj/src/internal -Isrc/include -Isrc/internal -Iobj/include -Iinclude copyright.c src/ctype/isalnum.c src/ctype/isalpha.c src/ctype/isdigit.c src/ctype/islower.c src/ctype/isprint.c src/ctype/isspace.c src/ctype/isxdigit.c src/env/putenv.c src/env/setenv.c src/env/unsetenv.c src/multibyte/wcrtomb.c src/multibyte/wcsrtombs.c src/multibyte/wcstombs.c src/stdlib/bsearch.c src/string/strchrnul.c src/string/strdup.c', DO NOT EDIT.
+
+package libc
+
+import (
+	"math"
+	"reflect"
+	"sync/atomic"
+	"unsafe"
+)
+
+var _ = math.Pi
+var _ reflect.Kind
+var _ atomic.Value
+var _ unsafe.Pointer
+
+// musl as a whole is licensed under the following standard MIT license:
+//
+// ----------------------------------------------------------------------
+// Copyright © 2005-2020 Rich Felker, et al.
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// ----------------------------------------------------------------------
+//
+// Authors/contributors include:
+//
+// A. Wilcox
+// Ada Worcester
+// Alex Dowad
+// Alex Suykov
+// Alexander Monakov
+// Andre McCurdy
+// Andrew Kelley
+// Anthony G. Basile
+// Aric Belsito
+// Arvid Picciani
+// Bartosz Brachaczek
+// Benjamin Peterson
+// Bobby Bingham
+// Boris Brezillon
+// Brent Cook
+// Chris Spiegel
+// Clément Vasseur
+// Daniel Micay
+// Daniel Sabogal
+// Daurnimator
+// David Carlier
+// David Edelsohn
+// Denys Vlasenko
+// Dmitry Ivanov
+// Dmitry V. Levin
+// Drew DeVault
+// Emil Renner Berthing
+// Fangrui Song
+// Felix Fietkau
+// Felix Janda
+// Gianluca Anzolin
+// Hauke Mehrtens
+// He X
+// Hiltjo Posthuma
+// Isaac Dunham
+// Jaydeep Patil
+// Jens Gustedt
+// Jeremy Huntwork
+// Jo-Philipp Wich
+// Joakim Sindholt
+// John Spencer
+// Julien Ramseier
+// Justin Cormack
+// Kaarle Ritvanen
+// Khem Raj
+// Kylie McClain
+// Leah Neukirchen
+// Luca Barbato
+// Luka Perkov
+// M Farkas-Dyck (Strake)
+// Mahesh Bodapati
+// Markus Wichmann
+// Masanori Ogino
+// Michael Clark
+// Michael Forney
+// Mikhail Kremnyov
+// Natanael Copa
+// Nicholas J. Kain
+// orc
+// Pascal Cuoq
+// Patrick Oppenlander
+// Petr Hosek
+// Petr Skocik
+// Pierre Carrier
+// Reini Urban
+// Rich Felker
+// Richard Pennington
+// Ryan Fairfax
+// Samuel Holland
+// Segev Finer
+// Shiz
+// sin
+// Solar Designer
+// Stefan Kristiansson
+// Stefan O'Rear
+// Szabolcs Nagy
+// Timo Teräs
+// Trutz Behn
+// Valentin Ochs
+// Will Dietz
+// William Haddon
+// William Pitcock
+//
+// Portions of this software are derived from third-party works licensed
+// under terms compatible with the above MIT license:
+//
+// The TRE regular expression implementation (src/regex/reg* and
+// src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
+// under a 2-clause BSD license (license text in the source files). The
+// included version has been heavily modified by Rich Felker in 2012, in
+// the interests of size, simplicity, and namespace cleanliness.
+//
+// Much of the math library code (src/math/* and src/complex/*) is
+// Copyright © 1993,2004 Sun Microsystems or
+// Copyright © 2003-2011 David Schultz or
+// Copyright © 2003-2009 Steven G. Kargl or
+// Copyright © 2003-2009 Bruce D. Evans or
+// Copyright © 2008 Stephen L. Moshier or
+// Copyright © 2017-2018 Arm Limited
+// and labelled as such in comments in the individual source files. All
+// have been licensed under extremely permissive terms.
+//
+// The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
+// The Android Open Source Project and is licensed under a two-clause BSD
+// license. It was taken from Bionic libc, used on Android.
+//
+// The AArch64 memcpy and memset code (src/string/aarch64/*) are
+// Copyright © 1999-2019, Arm Limited.
+//
+// The implementation of DES for crypt (src/crypt/crypt_des.c) is
+// Copyright © 1994 David Burren. It is licensed under a BSD license.
+//
+// The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
+// originally written by Solar Designer and placed into the public
+// domain. The code also comes with a fallback permissive license for use
+// in jurisdictions that may not recognize the public domain.
+//
+// The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
+// Valentin Ochs and is licensed under an MIT-style license.
+//
+// The x86_64 port was written by Nicholas J. Kain and is licensed under
+// the standard MIT terms.
+//
+// The mips and microblaze ports were originally written by Richard
+// Pennington for use in the ellcc project. The original code was adapted
+// by Rich Felker for build system and code conventions during upstream
+// integration. It is licensed under the standard MIT terms.
+//
+// The mips64 port was contributed by Imagination Technologies and is
+// licensed under the standard MIT terms.
+//
+// The powerpc port was also originally written by Richard Pennington,
+// and later supplemented and integrated by John Spencer. It is licensed
+// under the standard MIT terms.
+//
+// All other files which have no copyright comments are original works
+// produced specifically for use as part of this library, written either
+// by Rich Felker, the main author of the library, or by one or more
+// contibutors listed above. Details on authorship of individual files
+// can be found in the git version control history of the project. The
+// omission of copyright and license comments in each file is in the
+// interest of source tree size.
+//
+// In addition, permission is hereby granted for all public header files
+// (include/* and arch/*/bits/*) and crt files intended to be linked into
+// applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
+// the copyright notice and permission notice otherwise required by the
+// license, and to use these files without any requirement of
+// attribution. These files include substantial contributions from:
+//
+// Bobby Bingham
+// John Spencer
+// Nicholas J. Kain
+// Rich Felker
+// Richard Pennington
+// Stefan Kristiansson
+// Szabolcs Nagy
+//
+// all of whom have explicitly granted such permission.
+//
+// This file previously contained text expressing a belief that most of
+// the files covered by the above exception were sufficiently trivial not
+// to be subject to copyright, resulting in confusion over whether it
+// negated the permissions granted in the license. In the spirit of
+// permissive licensing, and of not having licensing issues being an
+// obstacle to adoption, that text has been removed.
+const ( /* copyright.c:194:1: */
+	__musl__copyright__ = 0
+)
+
+const ( /* pthread_impl.h:58:1: */
+	DT_EXITING  = 0
+	DT_JOINABLE = 1
+	DT_DETACHED = 2
+)
+
+type ptrdiff_t = int64 /* <builtin>:3:26 */
+
+type size_t = uint64 /* <builtin>:9:23 */
+
+type wchar_t = uint16 /* <builtin>:15:24 */
+
+type va_list = uintptr /* <builtin>:50:27 */
+
+type __locale_struct = struct{ cat [6]uintptr } /* alltypes.h:351:9 */
+
+type locale_t = uintptr /* alltypes.h:351:32 */
+
+func Xisalnum(tls *TLS, c int32) int32 { /* isalnum.c:3:5: */
+	return Bool32(func() int32 {
+		if 0 != 0 {
+			return Xisalpha(tls, c)
+		}
+		return Bool32(uint32(c)|uint32(32)-uint32('a') < uint32(26))
+	}() != 0 || func() int32 {
+		if 0 != 0 {
+			return Xisdigit(tls, c)
+		}
+		return Bool32(uint32(c)-uint32('0') < uint32(10))
+	}() != 0)
+}
+
+func X__isalnum_l(tls *TLS, c int32, l locale_t) int32 { /* isalnum.c:8:5: */
+	return Xisalnum(tls, c)
+}
+
+func Xisalpha(tls *TLS, c int32) int32 { /* isalpha.c:4:5: */
+	return Bool32(uint32(c)|uint32(32)-uint32('a') < uint32(26))
+}
+
+func X__isalpha_l(tls *TLS, c int32, l locale_t) int32 { /* isalpha.c:9:5: */
+	return Xisalpha(tls, c)
+}
+
+func Xisdigit(tls *TLS, c int32) int32 { /* isdigit.c:4:5: */
+	return Bool32(uint32(c)-uint32('0') < uint32(10))
+}
+
+func X__isdigit_l(tls *TLS, c int32, l locale_t) int32 { /* isdigit.c:9:5: */
+	return Xisdigit(tls, c)
+}
+
+func Xislower(tls *TLS, c int32) int32 { /* islower.c:4:5: */
+	return Bool32(uint32(c)-uint32('a') < uint32(26))
+}
+
+func X__islower_l(tls *TLS, c int32, l locale_t) int32 { /* islower.c:9:5: */
+	return Xislower(tls, c)
+}
+
+func Xisprint(tls *TLS, c int32) int32 { /* isprint.c:4:5: */
+	return Bool32(uint32(c)-uint32(0x20) < uint32(0x5f))
+}
+
+func X__isprint_l(tls *TLS, c int32, l locale_t) int32 { /* isprint.c:9:5: */
+	return Xisprint(tls, c)
+}
+
+func Xisspace(tls *TLS, c int32) int32 { /* isspace.c:4:5: */
+	return Bool32(c == ' ' || uint32(c)-uint32('\t') < uint32(5))
+}
+
+func X__isspace_l(tls *TLS, c int32, l locale_t) int32 { /* isspace.c:9:5: */
+	return Xisspace(tls, c)
+}
+
+func Xisxdigit(tls *TLS, c int32) int32 { /* isxdigit.c:3:5: */
+	return Bool32(func() int32 {
+		if 0 != 0 {
+			return Xisdigit(tls, c)
+		}
+		return Bool32(uint32(c)-uint32('0') < uint32(10))
+	}() != 0 || uint32(c)|uint32(32)-uint32('a') < uint32(6))
+}
+
+func X__isxdigit_l(tls *TLS, c int32, l locale_t) int32 { /* isxdigit.c:8:5: */
+	return Xisxdigit(tls, c)
+}
+
+type div_t = struct {
+	quot int32
+	rem  int32
+} /* stdlib.h:62:35 */
+type ldiv_t = struct {
+	quot int32
+	rem  int32
+} /* stdlib.h:63:36 */
+type lldiv_t = struct {
+	quot int64
+	rem  int64
+} /* stdlib.h:64:41 */
+
+type ssize_t = int32 /* alltypes.h:73:15 */
+
+type intptr_t = int32 /* alltypes.h:78:15 */
+
+type off_t = int32 /* alltypes.h:170:16 */
+
+type pid_t = int32 /* alltypes.h:243:13 */
+
+type uid_t = uint32 /* alltypes.h:253:18 */
+
+type gid_t = uint32 /* alltypes.h:258:18 */
+
+type useconds_t = uint32 /* alltypes.h:268:18 */
+
+func X__putenv(tls *TLS, s uintptr, l size_t, r uintptr) int32 { /* putenv.c:8:5: */
+	var i size_t
+	var newenv uintptr
+	var tmp uintptr
+	//TODO for (char **e = __environ; *e; e++, i++)
+	var e uintptr
+	i = uint64(0)
+	if !(Environ() != 0) {
+		goto __1
+	}
+	//TODO for (char **e = __environ; *e; e++, i++)
+	e = Environ()
+__2:
+	if !(*(*uintptr)(unsafe.Pointer(e)) != 0) {
+		goto __4
+	}
+	if !!(Xstrncmp(tls, s, *(*uintptr)(unsafe.Pointer(e)), l+uint64(1)) != 0) {
+		goto __5
+	}
+	tmp = *(*uintptr)(unsafe.Pointer(e))
+	*(*uintptr)(unsafe.Pointer(e)) = s
+	X__env_rm_add(tls, tmp, r)
+	return 0
+__5:
+	;
+	goto __3
+__3:
+	e += 8
+	i++
+	goto __2
+	goto __4
+__4:
+	;
+__1:
+	;
+	if !(Environ() == _soldenv) {
+		goto __6
+	}
+	newenv = Xrealloc(tls, _soldenv, uint64(unsafe.Sizeof(uintptr(0)))*(i+uint64(2)))
+	if !!(newenv != 0) {
+		goto __8
+	}
+	goto oom
+__8:
+	;
+	goto __7
+__6:
+	newenv = Xmalloc(tls, uint64(unsafe.Sizeof(uintptr(0)))*(i+uint64(2)))
+	if !!(newenv != 0) {
+		goto __9
+	}
+	goto oom
+__9:
+	;
+	if !(i != 0) {
+		goto __10
+	}
+	Xmemcpy(tls, newenv, Environ(), uint64(unsafe.Sizeof(uintptr(0)))*i)
+__10:
+	;
+	Xfree(tls, _soldenv)
+__7:
+	;
+	*(*uintptr)(unsafe.Pointer(newenv + uintptr(i)*8)) = s
+	*(*uintptr)(unsafe.Pointer(newenv + uintptr(i+uint64(1))*8)) = uintptr(0)
+	*(*uintptr)(unsafe.Pointer(EnvironP())) = AssignPtrUintptr(uintptr(unsafe.Pointer(&_soldenv)), newenv)
+	if !(r != 0) {
+		goto __11
+	}
+	X__env_rm_add(tls, uintptr(0), r)
+__11:
+	;
+	return 0
+oom:
+	Xfree(tls, r)
+	return -1
+}
+
+var _soldenv uintptr /* putenv.c:22:14: */
+
+func Xputenv(tls *TLS, s uintptr) int32 { /* putenv.c:43:5: */
+	var l size_t = size_t((int64(X__strchrnul(tls, s, '=')) - int64(s)) / 1)
+	if !(l != 0) || !(int32(*(*int8)(unsafe.Pointer(s + uintptr(l)))) != 0) {
+		return Xunsetenv(tls, s)
+	}
+	return X__putenv(tls, s, l, uintptr(0))
+}
+
+func X__env_rm_add(tls *TLS, old uintptr, new uintptr) { /* setenv.c:5:6: */
+	//TODO for (size_t i=0; i < env_alloced_n; i++)
+	var i size_t = uint64(0)
+	for ; i < _senv_alloced_n; i++ {
+		if *(*uintptr)(unsafe.Pointer(_senv_alloced + uintptr(i)*8)) == old {
+			*(*uintptr)(unsafe.Pointer(_senv_alloced + uintptr(i)*8)) = new
+			Xfree(tls, old)
+			return
+		} else if !(int32(*(*uintptr)(unsafe.Pointer(_senv_alloced + uintptr(i)*8))) != 0) && new != 0 {
+			*(*uintptr)(unsafe.Pointer(_senv_alloced + uintptr(i)*8)) = new
+			new = uintptr(0)
+		}
+	}
+	if !(new != 0) {
+		return
+	}
+	var t uintptr = Xrealloc(tls, _senv_alloced, uint64(unsafe.Sizeof(uintptr(0)))*(_senv_alloced_n+uint64(1)))
+	if !(t != 0) {
+		return
+	}
+	*(*uintptr)(unsafe.Pointer(AssignPtrUintptr(uintptr(unsafe.Pointer(&_senv_alloced)), t) + uintptr(PostIncUint64(&_senv_alloced_n, 1))*8)) = new
+}
+
+var _senv_alloced uintptr  /* setenv.c:7:14: */
+var _senv_alloced_n size_t /* setenv.c:8:16: */
+
+func Xsetenv(tls *TLS, var1 uintptr, value uintptr, overwrite int32) int32 { /* setenv.c:26:5: */
+	var s uintptr
+	var l1 size_t
+	var l2 size_t
+
+	if !(var1 != 0) || !(int32(AssignUint64(&l1, size_t((int64(X__strchrnul(tls, var1, '='))-int64(var1))/1))) != 0) || *(*int8)(unsafe.Pointer(var1 + uintptr(l1))) != 0 {
+		*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 22
+		return -1
+	}
+	if !(overwrite != 0) && Xgetenv(tls, var1) != 0 {
+		return 0
+	}
+
+	l2 = Xstrlen(tls, value)
+	s = Xmalloc(tls, l1+l2+uint64(2))
+	if !(s != 0) {
+		return -1
+	}
+	Xmemcpy(tls, s, var1, l1)
+	*(*int8)(unsafe.Pointer(s + uintptr(l1))) = int8('=')
+	Xmemcpy(tls, s+uintptr(l1)+uintptr(1), value, l2+uint64(1))
+	return X__putenv(tls, s, l1, s)
+}
+
+func Xunsetenv(tls *TLS, name uintptr) int32 { /* unsetenv.c:9:5: */
+	var l size_t = size_t((int64(X__strchrnul(tls, name, '=')) - int64(name)) / 1)
+	if !(l != 0) || *(*int8)(unsafe.Pointer(name + uintptr(l))) != 0 {
+		*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 22
+		return -1
+	}
+	if Environ() != 0 {
+		var e uintptr = Environ()
+		var eo uintptr = e
+		for ; *(*uintptr)(unsafe.Pointer(e)) != 0; e += 8 {
+			//TODO if (!strncmp(name, *e, l) && l[*e] == '=')
+			if !(Xstrncmp(tls, name, *(*uintptr)(unsafe.Pointer(e)), l) != 0) && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(e)) + uintptr(l)))) == '=' {
+				X__env_rm_add(tls, *(*uintptr)(unsafe.Pointer(e)), uintptr(0))
+			} else if eo != e {
+				*(*uintptr)(unsafe.Pointer(PostIncUintptr(&eo, 8))) = *(*uintptr)(unsafe.Pointer(e))
+			} else {
+				eo += 8
+			}
+		}
+		if eo != e {
+			*(*uintptr)(unsafe.Pointer(eo)) = uintptr(0)
+		}
+	}
+	return 0
+}
+
+type wint_t = uint32 /* alltypes.h:21:18 */
+
+type wctype_t = uint32 /* alltypes.h:211:23 */
+
+type __mbstate_t = struct {
+	__opaque1 uint32
+	__opaque2 uint32
+} /* alltypes.h:345:9 */
+
+type mbstate_t = __mbstate_t /* alltypes.h:345:63 */
+
+type tm = struct {
+	tm_sec    int32
+	tm_min    int32
+	tm_hour   int32
+	tm_mday   int32
+	tm_mon    int32
+	tm_year   int32
+	tm_wday   int32
+	tm_yday   int32
+	tm_isdst  int32
+	tm_gmtoff int32
+	tm_zone   uintptr
+} /* wchar.h:138:1 */
+
+type uintptr_t = uint32 /* alltypes.h:63:24 */
+
+type int8_t = int8 /* alltypes.h:104:25 */
+
+type int16_t = int16 /* alltypes.h:109:25 */
+
+type int32_t = int32 /* alltypes.h:114:25 */
+
+type int64_t = int32 /* alltypes.h:119:25 */
+
+type intmax_t = int32 /* alltypes.h:124:25 */
+
+type uint8_t = uint8 /* alltypes.h:129:25 */
+
+type uint16_t = uint16 /* alltypes.h:134:25 */
+
+type uint32_t = uint32 /* alltypes.h:139:25 */
+
+type uint64_t = uint32 /* alltypes.h:144:25 */
+
+type uintmax_t = uint32 /* alltypes.h:154:25 */
+
+type int_fast8_t = int8_t   /* stdint.h:22:16 */
+type int_fast64_t = int64_t /* stdint.h:23:17 */
+
+type int_least8_t = int8_t   /* stdint.h:25:17 */
+type int_least16_t = int16_t /* stdint.h:26:17 */
+type int_least32_t = int32_t /* stdint.h:27:17 */
+type int_least64_t = int64_t /* stdint.h:28:17 */
+
+type uint_fast8_t = uint8_t   /* stdint.h:30:17 */
+type uint_fast64_t = uint64_t /* stdint.h:31:18 */
+
+type uint_least8_t = uint8_t   /* stdint.h:33:18 */
+type uint_least16_t = uint16_t /* stdint.h:34:18 */
+type uint_least32_t = uint32_t /* stdint.h:35:18 */
+type uint_least64_t = uint64_t /* stdint.h:36:18 */
+
+type int_fast16_t = int32_t   /* stdint.h:1:17 */
+type int_fast32_t = int32_t   /* stdint.h:2:17 */
+type uint_fast16_t = uint32_t /* stdint.h:3:18 */
+type uint_fast32_t = uint32_t /* stdint.h:4:18 */
+
+// Upper 6 state bits are a negative integer offset to bound-check next byte
+//    equivalent to: ( (b-0x80) | (b+offset) ) & ~0x3f
+
+// Interval [a,b). Either a must be 80 or b must be c0, lower 3 bits clear.
+
+// Arbitrary encoding for representing code units instead of characters.
+
+// Get inline definition of MB_CUR_MAX.
+
+type lconv = struct {
+	decimal_point      uintptr
+	thousands_sep      uintptr
+	grouping           uintptr
+	int_curr_symbol    uintptr
+	currency_symbol    uintptr
+	mon_decimal_point  uintptr
+	mon_thousands_sep  uintptr
+	mon_grouping       uintptr
+	positive_sign      uintptr
+	negative_sign      uintptr
+	int_frac_digits    int8
+	frac_digits        int8
+	p_cs_precedes      int8
+	p_sep_by_space     int8
+	n_cs_precedes      int8
+	n_sep_by_space     int8
+	p_sign_posn        int8
+	n_sign_posn        int8
+	int_p_cs_precedes  int8
+	int_p_sep_by_space int8
+	int_n_cs_precedes  int8
+	int_n_sep_by_space int8
+	int_p_sign_posn    int8
+	int_n_sign_posn    int8
+	_                  [2]byte
+} /* locale.h:24:1 */
+
+type _G_fpos64_t = struct {
+	_        [0]uint64
+	__opaque [16]int8
+} /* stdio.h:54:9 */
+
+type fpos_t = _G_fpos64_t /* stdio.h:58:3 */
+
+// Support signed or unsigned plain-char
+
+// Implementation choices...
+
+// Arbitrary numbers...
+
+// POSIX/SUS requirements follow. These numbers come directly
+// from SUS and have nothing to do with the host system.
+
+type __locale_map = struct {
+	__map    uintptr
+	map_size size_t
+	name     [24]int8
+	next     uintptr
+} /* alltypes.h:351:9 */
+
+type tls_module = struct {
+	next   uintptr
+	image  uintptr
+	len    size_t
+	size   size_t
+	align  size_t
+	offset size_t
+} /* libc.h:14:1 */
+
+type __libc = struct {
+	can_do_threads  int8
+	threaded        int8
+	secure          int8
+	need_locks      int8
+	threads_minus_1 int32
+	auxv            uintptr
+	tls_head        uintptr
+	tls_size        size_t
+	tls_align       size_t
+	tls_cnt         size_t
+	page_size       size_t
+	global_locale   struct{ cat [6]uintptr }
+} /* libc.h:20:1 */
+
+type time_t = int32 /* alltypes.h:93:16 */
+
+type clockid_t = int32 /* alltypes.h:222:13 */
+
+type timespec = struct {
+	tv_sec  time_t
+	tv_nsec int32
+} /* alltypes.h:237:1 */
+
+type __pthread = struct {
+	self          uintptr
+	dtv           uintptr
+	prev          uintptr
+	next          uintptr
+	sysinfo       uintptr_t
+	canary        uintptr_t
+	canary2       uintptr_t
+	tid           int32
+	errno_val     int32
+	detach_state  int32
+	cancel        int32
+	canceldisable uint8
+	cancelasync   uint8
+	tsd_used      uint8 /* unsigned char tsd_used: 1, unsigned char dlerror_flag: 1 */
+	_             [1]byte
+	map_base      uintptr
+	map_size      size_t
+	stack         uintptr
+	stack_size    size_t
+	guard_size    size_t
+	result        uintptr
+	cancelbuf     uintptr
+	tsd           uintptr
+	robust_list   struct {
+		head    uintptr
+		off     int32
+		_       [4]byte
+		pending uintptr
+	}
+	timer_id      int32
+	_             [4]byte
+	locale        locale_t
+	killlock      [1]int32
+	_             [4]byte
+	dlerror_buf   uintptr
+	stdio_locks   uintptr
+	canary_at_end uintptr_t
+	_             [4]byte
+	dtv_copy      uintptr
+} /* alltypes.h:281:9 */
+
+type pthread_t = uintptr /* alltypes.h:281:26 */
+
+type pthread_once_t = int32 /* alltypes.h:287:13 */
+
+type pthread_key_t = uint32 /* alltypes.h:292:18 */
+
+type pthread_spinlock_t = int32 /* alltypes.h:297:13 */
+
+type pthread_mutexattr_t = struct{ __attr uint32 } /* alltypes.h:302:37 */
+
+type pthread_condattr_t = struct{ __attr uint32 } /* alltypes.h:307:37 */
+
+type pthread_barrierattr_t = struct{ __attr uint32 } /* alltypes.h:312:37 */
+
+type pthread_rwlockattr_t = struct{ __attr [2]uint32 } /* alltypes.h:317:40 */
+
+type __sigset_t = struct{ __bits [32]uint32 } /* alltypes.h:357:9 */
+
+type sigset_t = __sigset_t /* alltypes.h:357:71 */
+
+type pthread_attr_t = struct{ __u struct{ __i [9]int32 } } /* alltypes.h:380:147 */
+
+type pthread_mutex_t = struct {
+	__u struct {
+		_   [0]uint64
+		__i [6]int32
+		_   [24]byte
+	}
+} /* alltypes.h:385:157 */
+
+type pthread_cond_t = struct {
+	__u struct {
+		_   [0]uint64
+		__i [12]int32
+	}
+} /* alltypes.h:395:112 */
+
+type pthread_rwlock_t = struct {
+	__u struct {
+		_   [0]uint64
+		__i [8]int32
+		_   [32]byte
+	}
+} /* alltypes.h:405:139 */
+
+type pthread_barrier_t = struct {
+	__u struct {
+		_   [0]uint64
+		__i [5]int32
+		_   [20]byte
+	}
+} /* alltypes.h:410:137 */
+
+type sched_param = struct {
+	sched_priority int32
+	__reserved1    int32
+	__reserved2    [2]struct {
+		__reserved1 time_t
+		__reserved2 int32
+	}
+	__reserved3 int32
+} /* sched.h:19:1 */
+
+type timer_t = uintptr /* alltypes.h:217:14 */
+
+type clock_t = int32 /* alltypes.h:227:14 */
+
+type itimerspec = struct {
+	it_interval struct {
+		tv_sec  time_t
+		tv_nsec int32
+	}
+	it_value struct {
+		tv_sec  time_t
+		tv_nsec int32
+	}
+} /* time.h:80:1 */
+
+type sigevent = struct {
+	sigev_value struct {
+		_         [0]uint64
+		sival_int int32
+		_         [4]byte
+	}
+	sigev_signo             int32
+	sigev_notify            int32
+	sigev_notify_function   uintptr
+	sigev_notify_attributes uintptr
+	__pad                   [44]int8
+	_                       [4]byte
+} /* time.h:107:1 */
+
+type __ptcb = struct {
+	__f    uintptr
+	__x    uintptr
+	__next uintptr
+} /* alltypes.h:281:9 */
+
+type sigaltstack = struct {
+	ss_sp    uintptr
+	ss_flags int32
+	_        [4]byte
+	ss_size  size_t
+} /* signal.h:44:9 */
+
+type stack_t = sigaltstack /* signal.h:44:28 */
+
+type greg_t = uint32        /* signal.h:10:23 */
+type gregset_t = [34]uint32 /* signal.h:11:23 */
+
+type fpregset_t = struct {
+	vregs [32]float64
+	fpsr  uint32
+	fpcr  uint32
+} /* signal.h:17:3 */
+type sigcontext = struct {
+	fault_address uint32
+	regs          [31]uint32
+	sp            uint32
+	pc            uint32
+	pstate        uint32
+	_             [4]byte
+	__reserved    [256]float64
+} /* signal.h:18:9 */
+
+type mcontext_t = sigcontext /* signal.h:23:3 */
+
+type _aarch64_ctx = struct {
+	magic uint32
+	size  uint32
+} /* signal.h:29:1 */
+
+type fpsimd_context = struct {
+	head struct {
+		magic uint32
+		size  uint32
+	}
+	fpsr  uint32
+	fpcr  uint32
+	vregs [32]float64
+} /* signal.h:33:1 */
+
+type esr_context = struct {
+	head struct {
+		magic uint32
+		size  uint32
+	}
+	esr uint32
+} /* signal.h:39:1 */
+
+type extra_context = struct {
+	head struct {
+		magic uint32
+		size  uint32
+	}
+	datap      uint32
+	size       uint32
+	__reserved [3]uint32
+} /* signal.h:43:1 */
+
+type sve_context = struct {
+	head struct {
+		magic uint32
+		size  uint32
+	}
+	vl         uint16
+	__reserved [3]uint16
+} /* signal.h:49:1 */
+
+type __ucontext = struct {
+	uc_flags    uint32
+	_           [4]byte
+	uc_link     uintptr
+	uc_stack    stack_t
+	uc_sigmask  sigset_t
+	uc_mcontext mcontext_t
+} /* signal.h:99:9 */
+
+type ucontext_t = __ucontext /* signal.h:105:3 */
+
+type sigval = struct {
+	_         [0]uint64
+	sival_int int32
+	_         [4]byte
+} /* time.h:107:1 */
+
+type siginfo_t = struct {
+	si_signo    int32
+	si_errno    int32
+	si_code     int32
+	_           [4]byte
+	__si_fields struct {
+		_     [0]uint64
+		__pad [116]int8
+		_     [4]byte
+	}
+} /* signal.h:145:3 */
+
+type sigaction = struct {
+	__sa_handler struct{ sa_handler uintptr }
+	sa_mask      sigset_t
+	sa_flags     int32
+	_            [4]byte
+	sa_restorer  uintptr
+} /* signal.h:167:1 */
+
+type sig_t = uintptr /* signal.h:251:14 */
+
+type sig_atomic_t = int32 /* signal.h:269:13 */
+
+type mode_t = uint32 /* alltypes.h:160:18 */
+
+type syscall_arg_t = int32 /* syscall.h:22:14 */
+
+func a_ll(tls *TLS, p uintptr) int32 { /* atomic_arch.h:2:19: */
+	var v int32
+	panic(`arch\aarch64\atomic_arch.h:5:2: assembler statements not supported`)
+	return v
+}
+
+func a_sc(tls *TLS, p uintptr, v int32) int32 { /* atomic_arch.h:10:19: */
+	var r int32
+	panic(`arch\aarch64\atomic_arch.h:13:2: assembler statements not supported`)
+	return BoolInt32(!(r != 0))
+}
+
+func a_barrier(tls *TLS) { /* atomic_arch.h:18:20: */
+	panic(`arch\aarch64\atomic_arch.h:20:2: assembler statements not supported`)
+}
+
+func a_ll_p(tls *TLS, p uintptr) uintptr { /* atomic_arch.h:38:20: */
+	var v uintptr
+	panic(`arch\aarch64\atomic_arch.h:41:2: assembler statements not supported`)
+	return v
+}
+
+func a_sc_p(tls *TLS, p uintptr, v uintptr) int32 { /* atomic_arch.h:46:19: */
+	var r int32
+	panic(`arch\aarch64\atomic_arch.h:49:2: assembler statements not supported`)
+	return BoolInt32(!(r != 0))
+}
+
+func a_ctz_64(tls *TLS, x uint64_t) int32 { /* atomic_arch.h:68:19: */
+	panic(`arch\aarch64\atomic_arch.h:70:2: assembler statements not supported`)
+	return int32(x)
+}
+
+func a_fetch_add(tls *TLS, p uintptr, v int32) int32 { /* atomic.h:46:19: */
+	var old int32
+
+	for __ccgo := true; __ccgo; __ccgo = !(a_sc(tls, p, int32(uint32(old)+uint32(v))) != 0) {
+		old = a_ll(tls, p)
+	}
+
+	return old
+}
+
+func a_fetch_and(tls *TLS, p uintptr, v int32) int32 { /* atomic.h:59:19: */
+	var old int32
+
+	for __ccgo := true; __ccgo; __ccgo = !(a_sc(tls, p, old&v) != 0) {
+		old = a_ll(tls, p)
+	}
+
+	return old
+}
+
+func a_fetch_or(tls *TLS, p uintptr, v int32) int32 { /* atomic.h:72:19: */
+	var old int32
+
+	for __ccgo := true; __ccgo; __ccgo = !(a_sc(tls, p, old|v) != 0) {
+		old = a_ll(tls, p)
+	}
+
+	return old
+}
+
+func a_and(tls *TLS, p uintptr, v int32) { /* atomic.h:151:20: */
+	a_fetch_and(tls, p, v)
+}
+
+func a_or(tls *TLS, p uintptr, v int32) { /* atomic.h:159:20: */
+	a_fetch_or(tls, p, v)
+}
+
+func a_or_64(tls *TLS, p uintptr, v uint64_t) { /* atomic.h:220:20: */
+	bp := tls.Alloc(8)
+	defer tls.Free(8)
+
+	*(*struct {
+		v uint64_t
+		_ [4]byte
+	})(unsafe.Pointer(bp)) = func() (r struct {
+		v uint64_t
+		_ [4]byte
+	}) {
+		*(*uint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = v
+		return r
+	}()
+	if *(*uint32_t)(unsafe.Pointer(bp)) != 0 {
+		a_or(tls, p, int32(*(*uint32_t)(unsafe.Pointer(bp))))
+	}
+	if *(*uint32_t)(unsafe.Pointer(bp + 1*4)) != 0 {
+		a_or(tls, p+uintptr(1)*4, int32(*(*uint32_t)(unsafe.Pointer(bp + 1*4))))
+	}
+}
+
+func a_ctz_32(tls *TLS, x uint32_t) int32 { /* atomic.h:256:19: */
+	return int32(_sdebruijn32[x&-x*uint32_t(0x076be629)>>27])
+}
+
+var _sdebruijn32 = [32]int8{
+	int8(0), int8(1), int8(23), int8(2), int8(29), int8(24), int8(19), int8(3), int8(30), int8(27), int8(25), int8(11), int8(20), int8(8), int8(4), int8(13),
+	int8(31), int8(22), int8(28), int8(18), int8(26), int8(10), int8(7), int8(12), int8(21), int8(17), int8(9), int8(6), int8(16), int8(5), int8(15), int8(14),
+} /* atomic.h:261:20 */
+
+type __timer = struct {
+	timerid int32
+	_       [4]byte
+	thread  pthread_t
+} /* pthread_impl.h:64:1 */
+
+func __pthread_self(tls *TLS) uintptr { /* pthread_arch.h:1:30: */
+	var self uintptr
+	panic(`arch\aarch64\pthread_arch.h:4:2: assembler statements not supported`)
+	return self - uintptr(uint64(unsafe.Sizeof(__pthread{})))
+}
+
+func Xwcrtomb(tls *TLS, s uintptr, wc wchar_t, st uintptr) size_t { /* wcrtomb.c:6:8: */
+	if !(s != 0) {
+		return uint64(1)
+	}
+	if uint32(wc) < uint32(0x80) {
+		*(*int8)(unsafe.Pointer(s)) = int8(wc)
+		return uint64(1)
+	} else if func() int32 {
+		if !!(int32(*(*uintptr)(unsafe.Pointer((*__pthread)(unsafe.Pointer(__pthread_self(tls))).locale))) != 0) {
+			return 4
+		}
+		return 1
+	}() == 1 {
+		if !(uint32(wc)-uint32(0xdf80) < uint32(0x80)) {
+			*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 84
+			return Uint64FromInt32(-1)
+		}
+		*(*int8)(unsafe.Pointer(s)) = int8(wc)
+		return uint64(1)
+	} else if uint32(wc) < uint32(0x800) {
+		*(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = int8(0xc0 | int32(wc)>>6)
+		*(*int8)(unsafe.Pointer(s)) = int8(0x80 | int32(wc)&0x3f)
+		return uint64(2)
+	} else if uint32(wc) < uint32(0xd800) || uint32(wc)-uint32(0xe000) < uint32(0x2000) {
+		*(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = int8(0xe0 | int32(wc)>>12)
+		*(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = int8(0x80 | int32(wc)>>6&0x3f)
+		*(*int8)(unsafe.Pointer(s)) = int8(0x80 | int32(wc)&0x3f)
+		return uint64(3)
+	} else if uint32(wc)-uint32(0x10000) < uint32(0x100000) {
+		*(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = int8(0xf0 | int32(wc)>>18)
+		*(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = int8(0x80 | int32(wc)>>12&0x3f)
+		*(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = int8(0x80 | int32(wc)>>6&0x3f)
+		*(*int8)(unsafe.Pointer(s)) = int8(0x80 | int32(wc)&0x3f)
+		return uint64(4)
+	}
+	*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 84
+	return Uint64FromInt32(-1)
+}
+
+func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n size_t, st uintptr) size_t { /* wcsrtombs.c:3:8: */
+	bp := tls.Alloc(4)
+	defer tls.Free(4)
+
+	var ws2 uintptr
+	// var buf [4]int8 at bp, 4
+
+	var N size_t = n
+	var l size_t
+	if !(s != 0) {
+		n = uint64(0)
+		ws2 = *(*uintptr)(unsafe.Pointer(ws))
+		for ; *(*wchar_t)(unsafe.Pointer(ws2)) != 0; ws2 += 2 {
+			if uint32(*(*wchar_t)(unsafe.Pointer(ws2))) >= 0x80 {
+				l = Xwcrtomb(tls, bp, *(*wchar_t)(unsafe.Pointer(ws2)), uintptr(0))
+				if !(l+uint64(1) != 0) {
+					return Uint64FromInt32(-1)
+				}
+				n = n + l
+			} else {
+				n++
+			}
+		}
+		return n
+	}
+	for n >= uint64(4) {
+		if uint32(*(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))))-1 >= 0x7f {
+			if !(int32(*(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) != 0) {
+				*(*int8)(unsafe.Pointer(s)) = int8(0)
+				*(*uintptr)(unsafe.Pointer(ws)) = uintptr(0)
+				return N - n
+			}
+			l = Xwcrtomb(tls, s, *(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0))
+			if !(l+uint64(1) != 0) {
+				return Uint64FromInt32(-1)
+			}
+			s += uintptr(l)
+			n = n - l
+		} else {
+			*(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = int8(*(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))))
+			n--
+		}
+		*(*uintptr)(unsafe.Pointer(ws)) += 2
+	}
+	for n != 0 {
+		if uint32(*(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))))-1 >= 0x7f {
+			if !(int32(*(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) != 0) {
+				*(*int8)(unsafe.Pointer(s)) = int8(0)
+				*(*uintptr)(unsafe.Pointer(ws)) = uintptr(0)
+				return N - n
+			}
+			l = Xwcrtomb(tls, bp, *(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0))
+			if !(l+uint64(1) != 0) {
+				return Uint64FromInt32(-1)
+			}
+			if l > n {
+				return N - n
+			}
+			Xwcrtomb(tls, s, *(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0))
+			s += uintptr(l)
+			n = n - l
+		} else {
+			*(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = int8(*(*wchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))))
+			n--
+		}
+		*(*uintptr)(unsafe.Pointer(ws)) += 2
+	}
+	return N
+}
+
+func Xwcstombs(tls *TLS, s uintptr, ws uintptr, n size_t) size_t { /* wcstombs.c:4:8: */
+	bp := tls.Alloc(8)
+	defer tls.Free(8)
+	*(*uintptr)(unsafe.Pointer(bp)) = ws
+
+	//TODO return wcsrtombs(s, &(const wchar_t *){ws}, n, 0);
+	return Xwcsrtombs(tls, s, bp, n, uintptr(0))
+}
+
+func Xbsearch(tls *TLS, key uintptr, base uintptr, nel size_t, width size_t, cmp uintptr) uintptr { /* bsearch.c:3:6: */
+	var try uintptr
+	var sign int32
+	for nel > uint64(0) {
+		try = base + uintptr(width*(nel/uint64(2)))
+		sign = (*struct {
+			f func(*TLS, uintptr, uintptr) int32
+		})(unsafe.Pointer(&struct{ uintptr }{cmp})).f(tls, key, try)
+		if sign < 0 {
+			nel = nel / uint64(2)
+		} else if sign > 0 {
+			base = try + uintptr(width)
+			nel = nel - (nel/uint64(2) + uint64(1))
+		} else {
+			return try
+		}
+	}
+	return uintptr(0)
+}
+
+// Support signed or unsigned plain-char
+
+// Implementation choices...
+
+// Arbitrary numbers...
+
+// POSIX/SUS requirements follow. These numbers come directly
+// from SUS and have nothing to do with the host system.
+
+func X__strchrnul(tls *TLS, s uintptr, c int32) uintptr { /* strchrnul.c:10:6: */
+	c = int32(uint8(c))
+	if !(c != 0) {
+		return s + uintptr(Xstrlen(tls, s))
+	}
+	var w uintptr
+	for ; uint64(s)%uint64(unsafe.Sizeof(size_t(0))) != 0; s++ {
+		if !(int32(*(*int8)(unsafe.Pointer(s))) != 0) || int32(*(*uint8)(unsafe.Pointer(s))) == c {
+			return s
+		}
+	}
+	var k size_t = Uint64(Uint64FromInt32(-1)) / uint64(255) * size_t(c)
+	for w = s; !((*(*uint64)(unsafe.Pointer(w))-Uint64(Uint64FromInt32(-1))/uint64(255)) & ^*(*uint64)(unsafe.Pointer(w)) & (Uint64(Uint64FromInt32(-1))/uint64(255)*uint64(255/2+1)) != 0) && !((*(*uint64)(unsafe.Pointer(w))^k-Uint64(Uint64FromInt32(-1))/uint64(255)) & ^(*(*uint64)(unsafe.Pointer(w))^k) & (Uint64(Uint64FromInt32(-1))/uint64(255)*uint64(255/2+1)) != 0); w += 8 {
+	}
+	s = w
+	for ; *(*int8)(unsafe.Pointer(s)) != 0 && int32(*(*uint8)(unsafe.Pointer(s))) != c; s++ {
+	}
+	return s
+}
+
+func Xstrdup(tls *TLS, s uintptr) uintptr { /* strdup.c:4:6: */
+	var l size_t = Xstrlen(tls, s)
+	var d uintptr = Xmalloc(tls, l+uint64(1))
+	if !(d != 0) {
+		return uintptr(0)
+	}
+	return Xmemcpy(tls, d, s, l+uint64(1))
+}