modernc.org/xdmcp@v1.0.17/internal/test/main_linux_amd64.go

// Code generated by 'ccgo -export-fields F -lmodernc.org/xdmcp/lib -o internal/test/main_linux_amd64.go -trace-translation-units /tmp/go-generate-689401485/cdb.json test/Array', DO NOT EDIT.

package main

import (
	"math"
	"reflect"
	"sync/atomic"
	"unsafe"

	"modernc.org/libc"
	"modernc.org/libc/sys/types"
	"modernc.org/xdmcp/lib"
)

var _ = math.Pi
var _ reflect.Kind
var _ atomic.Value
var _ unsafe.Pointer
var _ types.Size_t

func main() { libc.Start(main1) }

// was definitions for sign-extending bitfields on architectures without
// native types smaller than 64-bit, now just backwards compatibility

// this version should leave result of type (t *), but that should only be
// used when not in MUSTCOPY

//
//
// Copyright 1989, 1991, 1998  The Open Group
//
// Permission to use, copy, modify, distribute, and sell this software and its
// documentation for any purpose is hereby granted without fee, provided that
// the above copyright notice appear in all copies and that both that
// copyright notice and this permission notice appear in supporting
// documentation.
//
// 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
// OPEN GROUP 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.
//
// Except as contained in this notice, the name of The Open Group shall not be
// used in advertising or otherwise to promote the sale, use or other dealings
// in this Software without prior written authorization from The Open Group.
//  *
//

// Definitions to make function prototypes manageable

// Function prototype configuration (see configure for more info)

// http://clang.llvm.org/docs/LanguageExtensions.html#has-attribute

// Added in X11R6.9, so available in any version of modular xproto

// Added in X11R6.9, so available in any version of modular xproto

// Branch prediction hints for individual conditionals
// requires xproto >= 7.0.9

// Bulk branch prediction hints via marking error path functions as "cold"
// requires xproto >= 7.0.25

// Added in X11R6.9, so available in any version of modular xproto

// requires xproto >= 7.0.30

// requires xproto >= 7.0.17

// Added in X11R6.9, so available in any version of modular xproto

// requires xproto >= 7.0.22 - since this uses either gcc or C99 variable
//    argument macros, must be only used inside #ifdef _X_NONNULL guards, as
//    many legacy X clients are compiled in C89 mode still.

// requires xproto >= 7.0.22

// C99 keyword "inline" or equivalent extensions in pre-C99 compilers
// requires xproto >= 7.0.9
//    (introduced in 7.0.8 but didn't support all compilers until 7.0.9)

// C99 keyword "restrict" or equivalent extensions in pre-C99 compilers
// requires xproto >= 7.0.21

// requires xproto >= 7.0.30

// IANA has assigned FF0X:0:0:0:0:0:0:12B as the permanently assigned
// multicast addresses for XDMCP, where X in the prefix may be replaced
// by any valid scope identifier, such as 1 for Node-Local, 2 for Link-Local,
// 5 for Site-Local, and so on.  We set the default here to the Link-Local
// version to most closely match the old IPv4 subnet broadcast behavior.
// Both xdm and X -query allow specifying a different address if a different
// scope is defined.

const ( /* Xdmcp.h:46:1: */
	BROADCAST_QUERY = 1
	QUERY           = 2
	INDIRECT_QUERY  = 3
	FORWARD_QUERY   = 4
	WILLING         = 5
	UNWILLING       = 6
	REQUEST         = 7
	ACCEPT          = 8
	DECLINE         = 9
	MANAGE          = 10
	REFUSE          = 11
	FAILED          = 12
	KEEPALIVE       = 13
	ALIVE           = 14
)

const ( /* Xdmcp.h:52:1: */
	XDM_QUERY                   = 0
	XDM_BROADCAST               = 1
	XDM_INDIRECT                = 2
	XDM_COLLECT_QUERY           = 3
	XDM_COLLECT_BROADCAST_QUERY = 4
	XDM_COLLECT_INDIRECT_QUERY  = 5
	XDM_START_CONNECTION        = 6
	XDM_AWAIT_REQUEST_RESPONSE  = 7
	XDM_AWAIT_MANAGE_RESPONSE   = 8
	XDM_MANAGE                  = 9
	XDM_RUN_SESSION             = 10
	XDM_OFF                     = 11
	XDM_AWAIT_USER_INPUT        = 12
	XDM_KEEPALIVE               = 13
	XDM_AWAIT_ALIVE_RESPONSE    = 14
	XDM_KEEP_ME_LAST            = 15
)

// A null pointer constant.

// XPG requires a few symbols from <sys/wait.h> being defined.
// Definitions of flag bits for `waitpid' et al.
//    Copyright (C) 1992-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// Bits in the third argument to `waitpid'.

// Bits in the fourth argument to `waitid'.

// The following values are used by the `waitid' function.

// The Linux kernel defines these bare, rather than an enum,
//    which causes a conflict if the include order is reversed.

const ( /* waitflags.h:52:1: */
	P_ALL  = 0 // Wait for any child.
	P_PID  = 1 // Wait for specified process.
	P_PGID = 2
)

type ptrdiff_t = int64 /* <builtin>:3:26 */

type size_t = uint64 /* <builtin>:9:23 */

type wchar_t = int32 /* <builtin>:15:24 */

// The tag name of this struct is _G_fpos_t to preserve historic
//    C++ mangled names for functions taking fpos_t arguments.
//    That name should not be used in new code.
type _G_fpos_t = struct {
	F__pos   int64
	F__state struct {
		F__count int32
		F__value struct{ F__wch uint32 }
	}
} /* __fpos_t.h:10:9 */

// bits/types.h -- definitions of __*_t types underlying *_t types.
//    Copyright (C) 2002-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// Never include this file directly; use <sys/types.h> instead.

// The tag name of this struct is _G_fpos64_t to preserve historic
//    C++ mangled names for functions taking fpos_t and/or fpos64_t
//    arguments.  That name should not be used in new code.
type _G_fpos64_t = struct {
	F__pos   int64
	F__state struct {
		F__count int32
		F__value struct{ F__wch uint32 }
	}
} /* __fpos64_t.h:10:9 */

type _IO_FILE = struct {
	F_flags          int32
	F__ccgo_pad1     [4]byte
	F_IO_read_ptr    uintptr
	F_IO_read_end    uintptr
	F_IO_read_base   uintptr
	F_IO_write_base  uintptr
	F_IO_write_ptr   uintptr
	F_IO_write_end   uintptr
	F_IO_buf_base    uintptr
	F_IO_buf_end     uintptr
	F_IO_save_base   uintptr
	F_IO_backup_base uintptr
	F_IO_save_end    uintptr
	F_markers        uintptr
	F_chain          uintptr
	F_fileno         int32
	F_flags2         int32
	F_old_offset     int64
	F_cur_column     uint16
	F_vtable_offset  int8
	F_shortbuf       [1]int8
	F__ccgo_pad2     [4]byte
	F_lock           uintptr
	F_offset         int64
	F_codecvt        uintptr
	F_wide_data      uintptr
	F_freeres_list   uintptr
	F_freeres_buf    uintptr
	F__pad5          size_t
	F_mode           int32
	F_unused2        [20]int8
} /* __FILE.h:4:1 */

// The opaque type of streams.  This is the definition used elsewhere.
type FILE = _IO_FILE /* FILE.h:7:25 */

// These macros are used by bits/stdio.h and internal headers.

// Many more flag bits are defined internally.

type va_list = uintptr /* stdio.h:52:24 */

type off_t = int64 /* stdio.h:65:19 */

type ssize_t = int64 /* stdio.h:77:19 */

// The type of the second argument to `fgetpos' and `fsetpos'.
type fpos_t = _G_fpos64_t /* stdio.h:86:20 */

// A null pointer constant.

// XPG requires a few symbols from <sys/wait.h> being defined.
// Definitions of flag bits for `waitpid' et al.
//    Copyright (C) 1992-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// Bits in the third argument to `waitpid'.

// Bits in the fourth argument to `waitid'.

// The following values are used by the `waitid' function.

// The Linux kernel defines these bare, rather than an enum,
//    which causes a conflict if the include order is reversed.

type idtype_t = uint32 /* waitflags.h:57:3 */
// Definitions of status bits for `wait' et al.
//    Copyright (C) 1992-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// Everything extant so far uses these same bits.

// If WIFEXITED(STATUS), the low-order 8 bits of the status.

// If WIFSIGNALED(STATUS), the terminating signal.

// If WIFSTOPPED(STATUS), the signal that stopped the child.

// Nonzero if STATUS indicates normal termination.

// Nonzero if STATUS indicates termination by a signal.

// Nonzero if STATUS indicates the child is stopped.

// Nonzero if STATUS indicates the child continued after a stop.  We only
//    define this if <bits/waitflags.h> provides the WCONTINUED flag bit.

// Nonzero if STATUS indicates the child dumped core.

// Macros for constructing status values.

// Define the macros <sys/wait.h> also would define this way.

// _FloatN API tests for enablement.
// Macros to control TS 18661-3 glibc features on x86.
//    Copyright (C) 2017-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// Copyright (C) 1991-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// Defined to 1 if the current compiler invocation provides a
//    floating-point type with the IEEE 754 binary128 format, and this
//    glibc includes corresponding *f128 interfaces for it.  The required
//    libgcc support was added some time after the basic compiler
//    support, for x86_64 and x86.

// Defined to 1 if __HAVE_FLOAT128 is 1 and the type is ABI-distinct
//    from the default float, double and long double types in this glibc.

// Defined to 1 if the current compiler invocation provides a
//    floating-point type with the right format for _Float64x, and this
//    glibc includes corresponding *f64x interfaces for it.

// Defined to 1 if __HAVE_FLOAT64X is 1 and _Float64x has the format
//    of long double.  Otherwise, if __HAVE_FLOAT64X is 1, _Float64x has
//    the format of _Float128, which must be different from that of long
//    double.

// Defined to concatenate the literal suffix to be used with _Float128
//    types, if __HAVE_FLOAT128 is 1.

// Defined to a complex binary128 type if __HAVE_FLOAT128 is 1.

// The remaining of this file provides support for older compilers.

// The type _Float128 exists only since GCC 7.0.

// __builtin_huge_valf128 doesn't exist before GCC 7.0.

// Older GCC has only a subset of built-in functions for _Float128 on
//    x86, and __builtin_infq is not usable in static initializers.
//    Converting a narrower sNaN to _Float128 produces a quiet NaN, so
//    attempts to use _Float128 sNaNs will not work properly with older
//    compilers.

// In math/math.h, __MATH_TG will expand signbit to __builtin_signbit*,
//    e.g.: __builtin_signbitf128, before GCC 6.  However, there has never
//    been a __builtin_signbitf128 in GCC and the type-generic builtin is
//    only available since GCC 6.

// Macros to control TS 18661-3 glibc features where the same
//    definitions are appropriate for all platforms.
//    Copyright (C) 2017-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// Copyright (C) 1991-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// Properties of long double type.  ldbl-96 version.
//    Copyright (C) 2016-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License  published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// long double is distinct from double, so there is nothing to
//    define here.

// This header should be included at the bottom of each bits/floatn.h.
//    It defines the following macros for each _FloatN and _FloatNx type,
//    where the same definitions, or definitions based only on the macros
//    in bits/floatn.h, are appropriate for all glibc configurations.

// Defined to 1 if the current compiler invocation provides a
//    floating-point type with the right format for this type, and this
//    glibc includes corresponding *fN or *fNx interfaces for it.

// Defined to 1 if the corresponding __HAVE_<type> macro is 1 and the
//    type is the first with its format in the sequence of (the default
//    choices for) float, double, long double, _Float16, _Float32,
//    _Float64, _Float128, _Float32x, _Float64x, _Float128x for this
//    glibc; that is, if functions present once per floating-point format
//    rather than once per type are present for this type.
//
//    All configurations supported by glibc have _Float32 the same format
//    as float, _Float64 and _Float32x the same format as double, the
//    _Float64x the same format as either long double or _Float128.  No
//    configurations support _Float128x or, as of GCC 7, have compiler
//    support for a type meeting the requirements for _Float128x.

// Defined to 1 if the corresponding _FloatN type is not binary compatible
//    with the corresponding ISO C type in the current compilation unit as
//    opposed to __HAVE_DISTINCT_FLOATN, which indicates the default types built
//    in glibc.

// Defined to 1 if any _FloatN or _FloatNx types that are not
//    ABI-distinct are however distinct types at the C language level (so
//    for the purposes of __builtin_types_compatible_p and _Generic).

// Defined to concatenate the literal suffix to be used with _FloatN
//    or _FloatNx types, if __HAVE_<type> is 1.  The corresponding
//    literal suffixes exist since GCC 7, for C only.

// Defined to a complex type if __HAVE_<type> is 1.

// The remaining of this file provides support for older compilers.

// If double, long double and _Float64 all have the same set of
//    values, TS 18661-3 requires the usual arithmetic conversions on
//    long double and _Float64 to produce _Float64.  For this to be the
//    case when building with a compiler without a distinct _Float64
//    type, _Float64 must be a typedef for long double, not for
//    double.

// Returned by `div'.
type div_t = struct {
	Fquot int32
	Frem  int32
} /* stdlib.h:62:5 */

// Returned by `ldiv'.
type ldiv_t = struct {
	Fquot int64
	Frem  int64
} /* stdlib.h:70:5 */

// Returned by `lldiv'.
type lldiv_t = struct {
	Fquot int64
	Frem  int64
} /* stdlib.h:80:5 */

// Copyright (C) 1991-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

//	POSIX Standard: 2.6 Primitive System Data Types	<sys/types.h>

// Copyright (C) 1991-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// bits/types.h -- definitions of __*_t types underlying *_t types.
//    Copyright (C) 2002-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// Never include this file directly; use <sys/types.h> instead.

type u_char = uint8                     /* types.h:33:18 */
type u_short = uint16                   /* types.h:34:19 */
type u_int = uint32                     /* types.h:35:17 */
type u_long = uint64                    /* types.h:36:18 */
type quad_t = int64                     /* types.h:37:18 */
type u_quad_t = uint64                  /* types.h:38:20 */
type fsid_t = struct{ F__val [2]int32 } /* types.h:39:18 */
type loff_t = int64                     /* types.h:42:18 */

type ino_t = uint64 /* types.h:49:19 */

type dev_t = uint64 /* types.h:59:17 */

type gid_t = uint32 /* types.h:64:17 */

type mode_t = uint32 /* types.h:69:18 */

type nlink_t = uint64 /* types.h:74:19 */

type uid_t = uint32 /* types.h:79:17 */

type pid_t = int32 /* types.h:97:17 */

type id_t = uint32 /* types.h:103:16 */

type daddr_t = int32   /* types.h:114:19 */
type caddr_t = uintptr /* types.h:115:19 */

type key_t = int32 /* types.h:121:17 */

// bits/types.h -- definitions of __*_t types underlying *_t types.
//    Copyright (C) 2002-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// Never include this file directly; use <sys/types.h> instead.

// Returned by `clock'.
type clock_t = int64 /* clock_t.h:7:19 */

// bits/types.h -- definitions of __*_t types underlying *_t types.
//    Copyright (C) 2002-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// Never include this file directly; use <sys/types.h> instead.

// Clock ID used in clock and timer functions.
type clockid_t = int32 /* clockid_t.h:7:21 */

// bits/types.h -- definitions of __*_t types underlying *_t types.
//    Copyright (C) 2002-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// Never include this file directly; use <sys/types.h> instead.

// Returned by `time'.
type time_t = int64 /* time_t.h:7:18 */

// bits/types.h -- definitions of __*_t types underlying *_t types.
//    Copyright (C) 2002-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// Never include this file directly; use <sys/types.h> instead.

// Timer ID returned by `timer_create'.
type timer_t = uintptr /* timer_t.h:7:19 */

// Copyright (C) 1989-2020 Free Software Foundation, Inc.
//
// This file is part of GCC.
//
// GCC is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// GCC is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
//
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

// ISO C Standard:  7.17  Common definitions  <stddef.h>

// Any one of these symbols __need_* means that GNU libc
//    wants us just to define one data type.  So don't define
//    the symbols that indicate this file's entire job has been done.

// This avoids lossage on SunOS but only if stdtypes.h comes first.
//    There's no way to win with the other order!  Sun lossage.

// Sequent's header files use _PTRDIFF_T_ in some conflicting way.
//    Just ignore it.

// On VxWorks, <type/vxTypesBase.h> may have defined macros like
//    _TYPE_size_t which will typedef size_t.  fixincludes patched the
//    vxTypesBase.h so that this macro is only defined if _GCC_SIZE_T is
//    not defined, and so that defining this macro defines _GCC_SIZE_T.
//    If we find that the macros are still defined at this point, we must
//    invoke them so that the type is defined as expected.

// In case nobody has defined these types, but we aren't running under
//    GCC 2.00, make sure that __PTRDIFF_TYPE__, __SIZE_TYPE__, and
//    __WCHAR_TYPE__ have reasonable values.  This can happen if the
//    parts of GCC is compiled by an older compiler, that actually
//    include gstddef.h, such as collect2.

// Signed type of difference of two pointers.

// Define this type if we are doing the whole job,
//    or if we want this type in particular.

// Unsigned type of `sizeof' something.

// Define this type if we are doing the whole job,
//    or if we want this type in particular.

// Wide character type.
//    Locale-writers should change this as necessary to
//    be big enough to hold unique values not between 0 and 127,
//    and not (wchar_t) -1, for each defined multibyte character.

// Define this type if we are doing the whole job,
//    or if we want this type in particular.

// A null pointer constant.

// Old compatibility names for C types.
type ulong = uint64  /* types.h:148:27 */
type ushort = uint16 /* types.h:149:28 */
type uint = uint32   /* types.h:150:22 */

// These size-specific names are used by some of the inet code.

// Define intN_t types.
//    Copyright (C) 2017-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// bits/types.h -- definitions of __*_t types underlying *_t types.
//    Copyright (C) 2002-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// Never include this file directly; use <sys/types.h> instead.

type int8_t = int8   /* stdint-intn.h:24:18 */
type int16_t = int16 /* stdint-intn.h:25:19 */
type int32_t = int32 /* stdint-intn.h:26:19 */
type int64_t = int64 /* stdint-intn.h:27:19 */

// These were defined by ISO C without the first `_'.
type u_int8_t = uint8   /* types.h:158:19 */
type u_int16_t = uint16 /* types.h:159:20 */
type u_int32_t = uint32 /* types.h:160:20 */
type u_int64_t = uint64 /* types.h:161:20 */

type register_t = int32 /* types.h:164:13 */

// A set of signals to be blocked, unblocked, or waited for.
type sigset_t = struct{ F__val [16]uint64 } /* sigset_t.h:7:20 */

// Get definition of timer specification structures.

// bits/types.h -- definitions of __*_t types underlying *_t types.
//    Copyright (C) 2002-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// Never include this file directly; use <sys/types.h> instead.

// A time value that is accurate to the nearest
//    microsecond but also has a range of years.
type timeval = struct {
	Ftv_sec  int64
	Ftv_usec int64
} /* struct_timeval.h:8:1 */

// NB: Include guard matches what <linux/time.h> uses.

// bits/types.h -- definitions of __*_t types underlying *_t types.
//    Copyright (C) 2002-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// Never include this file directly; use <sys/types.h> instead.

// Endian macros for string.h functions
//    Copyright (C) 1992-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <http://www.gnu.org/licenses/>.

// POSIX.1b structure for a time value.  This is like a `struct timeval' but
//    has nanoseconds instead of microseconds.
type timespec = struct {
	Ftv_sec  int64
	Ftv_nsec int64
} /* struct_timespec.h:10:1 */

type suseconds_t = int64 /* select.h:43:23 */

// Some versions of <linux/posix_types.h> define this macros.
// It's easier to assume 8-bit bytes than to get CHAR_BIT.

// fd_set for select and pselect.
type fd_set = struct{ F__fds_bits [16]int64 } /* select.h:70:5 */

// Maximum number of file descriptors in `fd_set'.

// Sometimes the fd_set member is assumed to have this type.
type fd_mask = int64 /* select.h:77:19 */

// Define some inlines helping to catch common problems.

type blksize_t = int64 /* types.h:185:21 */

// Types from the Large File Support interface.
type blkcnt_t = int64    /* types.h:205:22 */ // Type to count number of disk blocks.
type fsblkcnt_t = uint64 /* types.h:209:24 */ // Type to count file system blocks.
type fsfilcnt_t = uint64 /* types.h:213:24 */ // Type to count file system inodes.

// Now add the thread types.
// Declaration of common pthread types for all architectures.
//    Copyright (C) 2017-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// For internal mutex and condition variable definitions.
// Common threading primitives definitions for both POSIX and C11.
//    Copyright (C) 2017-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// Arch-specific definitions.  Each architecture must define the following
//    macros to define the expected sizes of pthread data types:
//
//    __SIZEOF_PTHREAD_ATTR_T        - size of pthread_attr_t.
//    __SIZEOF_PTHREAD_MUTEX_T       - size of pthread_mutex_t.
//    __SIZEOF_PTHREAD_MUTEXATTR_T   - size of pthread_mutexattr_t.
//    __SIZEOF_PTHREAD_COND_T        - size of pthread_cond_t.
//    __SIZEOF_PTHREAD_CONDATTR_T    - size of pthread_condattr_t.
//    __SIZEOF_PTHREAD_RWLOCK_T      - size of pthread_rwlock_t.
//    __SIZEOF_PTHREAD_RWLOCKATTR_T  - size of pthread_rwlockattr_t.
//    __SIZEOF_PTHREAD_BARRIER_T     - size of pthread_barrier_t.
//    __SIZEOF_PTHREAD_BARRIERATTR_T - size of pthread_barrierattr_t.
//
//    The additional macro defines any constraint for the lock alignment
//    inside the thread structures:
//
//    __LOCK_ALIGNMENT - for internal lock/futex usage.
//
//    Same idea but for the once locking primitive:
//
//    __ONCE_ALIGNMENT - for pthread_once_t/once_flag definition.

// Copyright (C) 2002-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// Determine the wordsize from the preprocessor defines.

// Both x86-64 and x32 use the 64-bit system call interface.

// Common definition of pthread_mutex_t.

type __pthread_internal_list = struct {
	F__prev uintptr
	F__next uintptr
} /* thread-shared-types.h:49:9 */

type __pthread_internal_slist = struct{ F__next uintptr } /* thread-shared-types.h:55:9 */

// Arch-specific mutex definitions.  A generic implementation is provided
//    by sysdeps/nptl/bits/struct_mutex.h.  If required, an architecture
//    can override it by defining:
//
//    1. struct __pthread_mutex_s (used on both pthread_mutex_t and mtx_t
//       definition).  It should contains at least the internal members
//       defined in the generic version.
//
//    2. __LOCK_ALIGNMENT for any extra attribute for internal lock used with
//       atomic operations.
//
//    3. The macro __PTHREAD_MUTEX_INITIALIZER used for static initialization.
//       It should initialize the mutex internal flag.

// x86 internal mutex struct definitions.
//    Copyright (C) 2019-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <http://www.gnu.org/licenses/>.

type __pthread_mutex_s = struct {
	F__lock    int32
	F__count   uint32
	F__owner   int32
	F__nusers  uint32
	F__kind    int32
	F__spins   int16
	F__elision int16
	F__list    struct {
		F__prev uintptr
		F__next uintptr
	}
} /* struct_mutex.h:22:1 */

// Arch-sepecific read-write lock definitions.  A generic implementation is
//    provided by struct_rwlock.h.  If required, an architecture can override it
//    by defining:
//
//    1. struct __pthread_rwlock_arch_t (used on pthread_rwlock_t definition).
//       It should contain at least the internal members defined in the
//       generic version.
//
//    2. The macro __PTHREAD_RWLOCK_INITIALIZER used for static initialization.
//       It should initialize the rwlock internal type.

// x86 internal rwlock struct definitions.
//    Copyright (C) 2019-2020 Free Software Foundation, Inc.
//
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <http://www.gnu.org/licenses/>.

type __pthread_rwlock_arch_t = struct {
	F__readers       uint32
	F__writers       uint32
	F__wrphase_futex uint32
	F__writers_futex uint32
	F__pad3          uint32
	F__pad4          uint32
	F__cur_writer    int32
	F__shared        int32
	F__rwelision     int8
	F__pad1          [7]uint8
	F__pad2          uint64
	F__flags         uint32
	F__ccgo_pad1     [4]byte
} /* struct_rwlock.h:23:1 */

// Common definition of pthread_cond_t.

type __pthread_cond_s = struct {
	F__0            struct{ F__wseq uint64 }
	F__8            struct{ F__g1_start uint64 }
	F__g_refs       [2]uint32
	F__g_size       [2]uint32
	F__g1_orig_size uint32
	F__wrefs        uint32
	F__g_signals    [2]uint32
} /* thread-shared-types.h:92:1 */

// Thread identifiers.  The structure of the attribute type is not
//    exposed on purpose.
type pthread_t = uint64 /* pthreadtypes.h:27:27 */

// Data structures for mutex handling.  The structure of the attribute
//    type is not exposed on purpose.
type pthread_mutexattr_t = struct {
	F__ccgo_pad1 [0]uint32
	F__size      [4]int8
} /* pthreadtypes.h:36:3 */

// Data structure for condition variable handling.  The structure of
//    the attribute type is not exposed on purpose.
type pthread_condattr_t = struct {
	F__ccgo_pad1 [0]uint32
	F__size      [4]int8
} /* pthreadtypes.h:45:3 */

// Keys for thread-specific data
type pthread_key_t = uint32 /* pthreadtypes.h:49:22 */

// Once-only execution
type pthread_once_t = int32 /* pthreadtypes.h:53:30 */

type pthread_attr_t1 = struct {
	F__ccgo_pad1 [0]uint64
	F__size      [56]int8
} /* pthreadtypes.h:56:1 */

type pthread_attr_t = pthread_attr_t1 /* pthreadtypes.h:62:30 */

type pthread_mutex_t = struct{ F__data __pthread_mutex_s } /* pthreadtypes.h:72:3 */

type pthread_cond_t = struct{ F__data __pthread_cond_s } /* pthreadtypes.h:80:3 */

// Data structure for reader-writer lock variable handling.  The
//    structure of the attribute type is deliberately not exposed.
type pthread_rwlock_t = struct{ F__data __pthread_rwlock_arch_t } /* pthreadtypes.h:91:3 */

type pthread_rwlockattr_t = struct {
	F__ccgo_pad1 [0]uint64
	F__size      [8]int8
} /* pthreadtypes.h:97:3 */

// POSIX spinlock data type.
type pthread_spinlock_t = int32 /* pthreadtypes.h:103:22 */

// POSIX barriers data type.  The structure of the type is
//    deliberately not exposed.
type pthread_barrier_t = struct {
	F__ccgo_pad1 [0]uint64
	F__size      [32]int8
} /* pthreadtypes.h:112:3 */

type pthread_barrierattr_t = struct {
	F__ccgo_pad1 [0]uint32
	F__size      [4]int8
} /* pthreadtypes.h:118:3 */

// Reentrant versions of the `random' family of functions.
//    These functions all use the following data structure to contain
//    state, rather than global state variables.

type random_data = struct {
	Ffptr        uintptr
	Frptr        uintptr
	Fstate       uintptr
	Frand_type   int32
	Frand_deg    int32
	Frand_sep    int32
	F__ccgo_pad1 [4]byte
	Fend_ptr     uintptr
} /* stdlib.h:423:1 */

// Data structure for communication with thread safe versions.  This
//    type is to be regarded as opaque.  It's only exported because users
//    have to allocate objects of this type.
type drand48_data = struct {
	F__x     [3]uint16
	F__old_x [3]uint16
	F__c     uint16
	F__init  uint16
	F__a     uint64
} /* stdlib.h:490:1 */

// POSIX.1-2008 extended locale interface (see locale.h).
// Definition of locale_t.
//    Copyright (C) 2017-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// Definition of struct __locale_struct and __locale_t.
//    Copyright (C) 1997-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// POSIX.1-2008: the locale_t type, representing a locale context
//    (implementation-namespace version).  This type should be treated
//    as opaque by applications; some details are exposed for the sake of
//    efficiency in e.g. ctype functions.

type __locale_struct = struct {
	F__locales       [13]uintptr
	F__ctype_b       uintptr
	F__ctype_tolower uintptr
	F__ctype_toupper uintptr
	F__names         [13]uintptr
} /* __locale_t.h:28:1 */

type locale_t = uintptr /* locale_t.h:24:20 */

// When possible, define assert so that it does not add extra
//    parentheses around EXPR.  Otherwise, those added parentheses would
//    suppress warnings we'd expect to be detected by gcc's -Wparentheses.
// The first occurrence of EXPR is not evaluated due to the sizeof,
//    but will trigger any pedantic warnings masked by the __extension__
//    for the second occurrence.  The ternary operator is required to
//    support function pointers and bit fields in this context, and to
//    suppress the evaluation of variable length arrays.

// Version 2.4 and later of GCC define a magical variable `__PRETTY_FUNCTION__'
//    which contains the name of the function currently being defined.
//    This is broken in G++ before version 2.6.
//    C9x has a similar variable called __func__, but prefer the GCC one since
//    it demangles C++ function names.

// Copyright 1989 Network Computing Devices, Inc., Mountain View, California.
//
// Permission to use, copy, modify, and distribute this software and its
// documentation for any purpose and without fee is hereby granted, provided
// that the above copyright notice appear in all copies and that both that
// copyright notice and this permission notice appear in supporting
// documentation, and that the name of N.C.D. not be used in advertising or
// publicity pertaining to distribution of the software without specific,
// written prior permission.  N.C.D. makes no representations about the
// suitability of this software for any purpose.  It is provided "as is"
// without express or implied warranty.
//

//**********************************************************
//
// Copyright 1987, 1998  The Open Group
//
// Permission to use, copy, modify, distribute, and sell this software and its
// documentation for any purpose is hereby granted without fee, provided that
// the above copyright notice appear in all copies and that both that
// copyright notice and this permission notice appear in supporting
// documentation.
//
// 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
// OPEN GROUP 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.
//
// Except as contained in this notice, the name of The Open Group shall not be
// used in advertising or otherwise to promote the sale, use or other dealings
// in this Software without prior written authorization from The Open Group.
//
//
// Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
//
//                         All Rights Reserved
//
// Permission to use, copy, modify, and distribute this software and its
// documentation for any purpose and without fee is hereby granted,
// provided that the above copyright notice appear in all copies and that
// both that copyright notice and this permission notice appear in
// supporting documentation, and that the name of Digital not be
// used in advertising or publicity pertaining to distribution of the
// software without specific, written prior permission.
//
// DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
// ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
// DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
// ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
// WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
// ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
// SOFTWARE.
//
// *****************************************************************
//  Xmd.h: MACHINE DEPENDENT DECLARATIONS.

// Special per-machine configuration flags.

// Definition of macro used to set constants for size of network structures;
// machines with preprocessors that can't handle all of the sz_ symbols
// can define this macro to be sizeof(x) if and only if their compiler doesn't
// pad out structures (esp. the xTextElt structure which contains only two
// one-byte fields).  Network structures should always define sz_symbols.
//
// The sz_ prefix is used instead of something more descriptive so that the
// symbols are no more than 32 characters long (which causes problems for some
// compilers and preprocessors).
//
// The extra indirection is to get macro arguments to expand correctly before
// the concatenation, rather than afterward.

// Bitfield suffixes for the protocol structure elements, if you
// need them.  Note that bitfields are not guaranteed to be signed
// (or even unsigned) according to ANSI C.
type INT64 = int64 /* Xmd.h:97:14 */
type INT32 = int32 /* Xmd.h:98:13 */
type INT16 = int16 /* Xmd.h:102:15 */

type INT8 = int8 /* Xmd.h:104:24 */

type CARD64 = uint64 /* Xmd.h:107:23 */
type CARD32 = uint32 /* Xmd.h:108:22 */
type CARD16 = uint16 /* Xmd.h:113:24 */
type CARD8 = uint8   /* Xmd.h:114:24 */

type BITS32 = CARD32 /* Xmd.h:116:17 */
type BITS16 = CARD16 /* Xmd.h:117:17 */

type BYTE = CARD8 /* Xmd.h:119:16 */
type BOOL = CARD8 /* Xmd.h:120:16 */

// was definitions for sign-extending bitfields on architectures without
// native types smaller than 64-bit, now just backwards compatibility

// this version should leave result of type (t *), but that should only be
// used when not in MUSTCOPY

//
//
// Copyright 1989, 1991, 1998  The Open Group
//
// Permission to use, copy, modify, distribute, and sell this software and its
// documentation for any purpose is hereby granted without fee, provided that
// the above copyright notice appear in all copies and that both that
// copyright notice and this permission notice appear in supporting
// documentation.
//
// 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
// OPEN GROUP 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.
//
// Except as contained in this notice, the name of The Open Group shall not be
// used in advertising or otherwise to promote the sale, use or other dealings
// in this Software without prior written authorization from The Open Group.
//  *
//

// Definitions to make function prototypes manageable

// Function prototype configuration (see configure for more info)

// http://clang.llvm.org/docs/LanguageExtensions.html#has-attribute

// Added in X11R6.9, so available in any version of modular xproto

// Added in X11R6.9, so available in any version of modular xproto

// Branch prediction hints for individual conditionals
// requires xproto >= 7.0.9

// Bulk branch prediction hints via marking error path functions as "cold"
// requires xproto >= 7.0.25

// Added in X11R6.9, so available in any version of modular xproto

// requires xproto >= 7.0.30

// requires xproto >= 7.0.17

// Added in X11R6.9, so available in any version of modular xproto

// requires xproto >= 7.0.22 - since this uses either gcc or C99 variable
//    argument macros, must be only used inside #ifdef _X_NONNULL guards, as
//    many legacy X clients are compiled in C89 mode still.

// requires xproto >= 7.0.22

// C99 keyword "inline" or equivalent extensions in pre-C99 compilers
// requires xproto >= 7.0.9
//    (introduced in 7.0.8 but didn't support all compilers until 7.0.9)

// C99 keyword "restrict" or equivalent extensions in pre-C99 compilers
// requires xproto >= 7.0.21

// requires xproto >= 7.0.30

// IANA has assigned FF0X:0:0:0:0:0:0:12B as the permanently assigned
// multicast addresses for XDMCP, where X in the prefix may be replaced
// by any valid scope identifier, such as 1 for Node-Local, 2 for Link-Local,
// 5 for Site-Local, and so on.  We set the default here to the Link-Local
// version to most closely match the old IPv4 subnet broadcast behavior.
// Both xdm and X -query allow specifying a different address if a different
// scope is defined.

type xdmOpCode = uint32 /* Xdmcp.h:50:3 */

type xdmcp_states = uint32 /* Xdmcp.h:62:3 */

type CARD8Ptr = uintptr  /* Xdmcp.h:76:15 */
type CARD16Ptr = uintptr /* Xdmcp.h:77:16 */
type CARD32Ptr = uintptr /* Xdmcp.h:78:16 */

type _ARRAY8 = struct {
	Flength      CARD16
	F__ccgo_pad1 [6]byte
	Fdata        CARD8Ptr
} /* Xdmcp.h:80:9 */

type ARRAY8 = _ARRAY8    /* Xdmcp.h:83:3 */
type ARRAY8Ptr = uintptr /* Xdmcp.h:83:11 */

type _ARRAY16 = struct {
	Flength      CARD8
	F__ccgo_pad1 [7]byte
	Fdata        CARD16Ptr
} /* Xdmcp.h:85:9 */

type ARRAY16 = _ARRAY16   /* Xdmcp.h:88:3 */
type ARRAY16Ptr = uintptr /* Xdmcp.h:88:12 */

type _ARRAY32 = struct {
	Flength      CARD8
	F__ccgo_pad1 [7]byte
	Fdata        CARD32Ptr
} /* Xdmcp.h:90:9 */

type ARRAY32 = _ARRAY32   /* Xdmcp.h:93:3 */
type ARRAY32Ptr = uintptr /* Xdmcp.h:93:12 */

type _ARRAYofARRAY8 = struct {
	Flength      CARD8
	F__ccgo_pad1 [7]byte
	Fdata        ARRAY8Ptr
} /* Xdmcp.h:95:9 */

type ARRAYofARRAY8 = _ARRAYofARRAY8 /* Xdmcp.h:98:3 */
type ARRAYofARRAY8Ptr = uintptr     /* Xdmcp.h:98:18 */

type _XdmcpHeader = struct {
	Fversion CARD16
	Fopcode  CARD16
	Flength  CARD16
} /* Xdmcp.h:100:9 */

type XdmcpHeader = _XdmcpHeader /* Xdmcp.h:102:3 */
type XdmcpHeaderPtr = uintptr   /* Xdmcp.h:102:16 */

type _XdmcpBuffer = struct {
	Fdata        uintptr
	Fsize        int32
	Fpointer     int32
	Fcount       int32
	F__ccgo_pad1 [4]byte
} /* Xdmcp.h:104:9 */

type XdmcpBuffer = _XdmcpBuffer /* Xdmcp.h:109:3 */
type XdmcpBufferPtr = uintptr   /* Xdmcp.h:109:16 */

type _XdmAuthKey = struct{ Fdata [8]BYTE } /* Xdmcp.h:111:9 */

type XdmAuthKeyRec = _XdmAuthKey /* Xdmcp.h:113:3 */
type XdmAuthKeyPtr = uintptr     /* Xdmcp.h:113:18 */

// implementation-independent network address structure.
//    Equiv to sockaddr* for sockets.

type XdmcpNetaddr = uintptr /* Xdmcp.h:119:14 */

// Copyright (C) 1997-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

//	ISO C99: 7.8 Format conversion of integer types	<inttypes.h>

// Copyright (C) 1991-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// Get the type definitions.
// Copyright (C) 1997-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

//	ISO C99: 7.18 Integer types <stdint.h>

// Handle feature test macros at the start of a header.
//    Copyright (C) 2016-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// This header is internal to glibc and should not be included outside
//    of glibc headers.  Headers including it must define
//    __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION first.  This header
//    cannot have multiple include guards because ISO C feature test
//    macros depend on the definition of the macro when an affected
//    header is included, not when the first system header is
//    included.

// Copyright (C) 1991-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// ISO/IEC TR 24731-2:2010 defines the __STDC_WANT_LIB_EXT2__
//    macro.

// ISO/IEC TS 18661-1:2014 defines the __STDC_WANT_IEC_60559_BFP_EXT__
//    macro.  Most but not all symbols enabled by that macro in TS
//    18661-1 are enabled unconditionally in C2X; the symbols in Annex F
//    still require that macro in C2X.

// ISO/IEC TS 18661-4:2015 defines the
//    __STDC_WANT_IEC_60559_FUNCS_EXT__ macro.  Other than the reduction
//    functions, the symbols from this TS are enabled unconditionally in
//    C2X.

// ISO/IEC TS 18661-3:2015 defines the
//    __STDC_WANT_IEC_60559_TYPES_EXT__ macro.
// bits/types.h -- definitions of __*_t types underlying *_t types.
//    Copyright (C) 2002-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// Never include this file directly; use <sys/types.h> instead.

// wchar_t type related definitions.
//    Copyright (C) 2000-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// The fallback definitions, for when __WCHAR_MAX__ or __WCHAR_MIN__
//    are not defined, give the right value and type as long as both int
//    and wchar_t are 32-bit types.  Adding L'\0' to a constant value
//    ensures that the type is correct; it is necessary to use (L'\0' +
//    0) rather than just L'\0' so that the type in C++ is the promoted
//    version of wchar_t rather than the distinct wchar_t type itself.
//    Because wchar_t in preprocessor #if expressions is treated as
//    intmax_t or uintmax_t, the expression (L'\0' - 1) would have the
//    wrong value for WCHAR_MAX in such expressions and so cannot be used
//    to define __WCHAR_MAX in the unsigned case.

// Determine the wordsize from the preprocessor defines.

// Both x86-64 and x32 use the 64-bit system call interface.

// Exact integral types.

// Signed.
// Define intN_t types.
//    Copyright (C) 2017-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// Unsigned.
// Define uintN_t types.
//    Copyright (C) 2017-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// bits/types.h -- definitions of __*_t types underlying *_t types.
//    Copyright (C) 2002-2020 Free Software Foundation, Inc.
//    This file is part of the GNU C Library.
//
//    The GNU C Library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    The GNU C Library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with the GNU C Library; if not, see
//    <https://www.gnu.org/licenses/>.

// Never include this file directly; use <sys/types.h> instead.

type uint8_t = uint8   /* stdint-uintn.h:24:19 */
type uint16_t = uint16 /* stdint-uintn.h:25:20 */
type uint32_t = uint32 /* stdint-uintn.h:26:20 */
type uint64_t = uint64 /* stdint-uintn.h:27:20 */

// Small types.

// Signed.
type int_least8_t = int8   /* stdint.h:43:24 */
type int_least16_t = int16 /* stdint.h:44:25 */
type int_least32_t = int32 /* stdint.h:45:25 */
type int_least64_t = int64 /* stdint.h:46:25 */

// Unsigned.
type uint_least8_t = uint8   /* stdint.h:49:25 */
type uint_least16_t = uint16 /* stdint.h:50:26 */
type uint_least32_t = uint32 /* stdint.h:51:26 */
type uint_least64_t = uint64 /* stdint.h:52:26 */

// Fast types.

// Signed.
type int_fast8_t = int8   /* stdint.h:58:22 */
type int_fast16_t = int64 /* stdint.h:60:19 */
type int_fast32_t = int64 /* stdint.h:61:19 */
type int_fast64_t = int64 /* stdint.h:62:19 */

// Unsigned.
type uint_fast8_t = uint8   /* stdint.h:71:24 */
type uint_fast16_t = uint64 /* stdint.h:73:27 */
type uint_fast32_t = uint64 /* stdint.h:74:27 */
type uint_fast64_t = uint64 /* stdint.h:75:27 */

// Types for `void *' pointers.
type intptr_t = int64   /* stdint.h:87:19 */
type uintptr_t = uint64 /* stdint.h:90:27 */

// Largest integral types.
type intmax_t = int64   /* stdint.h:101:21 */
type uintmax_t = uint64 /* stdint.h:102:22 */

// Macros for printing format specifiers.

// Decimal notation.

// Octal notation.

// Unsigned integers.

// lowercase hexadecimal notation.

// UPPERCASE hexadecimal notation.

// Macros for printing `intmax_t' and `uintmax_t'.

// Macros for printing `intptr_t' and `uintptr_t'.

// Macros for scanning format specifiers.

// Signed decimal notation.

// Signed decimal notation.

// Unsigned decimal notation.

// Octal notation.

// Hexadecimal notation.

// Macros for scanning `intmax_t' and `uintmax_t'.

// Macros for scaning `intptr_t' and `uintptr_t'.

// We have to define the `uintmax_t' type using `ldiv_t'.
type imaxdiv_t = struct {
	Fquot int64
	Frem  int64
} /* inttypes.h:275:5 */

// Test what happens if you try to allocate an array with too many entries

func TestAllocOversizeArrays(tls *libc.TLS) { /* Array.c:49:1: */
	bp := tls.Alloc(384)
	defer tls.Free(384)

	{
		*(*ARRAY8)(unsafe.Pointer(bp + 256 /* newArray */)) = ARRAY8{Flength: libc.Uint16FromInt32(-1), Fdata: libc.UintptrFromInt32(-1)}
		var result int32
		libc.Xprintf(tls, ts /* "Checking XdmcpAl..." */, libc.VaList(bp, ts+30 /* "ARRAY8" */, ((65535)+1)))
		result = xdmcp.XXdmcpAllocARRAY8(tls, bp+256 /* &newArray */, ((65535) + 1))
		if result == 0 {
		} else {
			libc.X__assert_fail(tls, ts+37 /* "result == 0" */, ts+49 /* "Array.c" */, uint32(51), uintptr(unsafe.Pointer(&__func__)))
		}
		if int32((*ARRAY8)(unsafe.Pointer(bp+256 /* &newArray */)).Flength) == 0 {
		} else {
			libc.X__assert_fail(tls, ts+57 /* "newArray.length ..." */, ts+49 /* "Array.c" */, uint32(51), uintptr(unsafe.Pointer(&__func__)))
		}
		if (*ARRAY8)(unsafe.Pointer(bp+256 /* &newArray */)).Fdata == (uintptr(0)) {
		} else {
			libc.X__assert_fail(tls, ts+78 /* "newArray.data ==..." */, ts+49 /* "Array.c" */, uint32(51), uintptr(unsafe.Pointer(&__func__)))
		}
		libc.Xprintf(tls, ts+107 /* "Checking XdmcpRe..." */, libc.VaList(bp+16, ts+30 /* "ARRAY8" */, ((65535)+1)))
		result = xdmcp.XXdmcpReallocARRAY8(tls, bp+256 /* &newArray */, ((65535) + 1))
		if result == 0 {
		} else {
			libc.X__assert_fail(tls, ts+37 /* "result == 0" */, ts+49 /* "Array.c" */, uint32(51), uintptr(unsafe.Pointer(&__func__)))
		}
		if int32((*ARRAY8)(unsafe.Pointer(bp+256 /* &newArray */)).Flength) == 0 {
		} else {
			libc.X__assert_fail(tls, ts+57 /* "newArray.length ..." */, ts+49 /* "Array.c" */, uint32(51), uintptr(unsafe.Pointer(&__func__)))
		}
		if (*ARRAY8)(unsafe.Pointer(bp+256 /* &newArray */)).Fdata == (uintptr(0)) {
		} else {
			libc.X__assert_fail(tls, ts+78 /* "newArray.data ==..." */, ts+49 /* "Array.c" */, uint32(51), uintptr(unsafe.Pointer(&__func__)))
		}
		xdmcp.XXdmcpDisposeARRAY8(tls, bp+256 /* &newArray */)
	}

	{
		*(*ARRAY16)(unsafe.Pointer(bp + 272 /* newArray */)) = ARRAY16{Flength: libc.Uint8FromInt32(-1), Fdata: libc.UintptrFromInt32(-1)}
		var result int32
		libc.Xprintf(tls, ts /* "Checking XdmcpAl..." */, libc.VaList(bp+32, ts+139 /* "ARRAY16" */, ((255)+1)))
		result = xdmcp.XXdmcpAllocARRAY16(tls, bp+272 /* &newArray */, ((255) + 1))
		if result == 0 {
		} else {
			libc.X__assert_fail(tls, ts+37 /* "result == 0" */, ts+49 /* "Array.c" */, uint32(52), uintptr(unsafe.Pointer(&__func__)))
		}
		if int32((*ARRAY16)(unsafe.Pointer(bp+272 /* &newArray */)).Flength) == 0 {
		} else {
			libc.X__assert_fail(tls, ts+57 /* "newArray.length ..." */, ts+49 /* "Array.c" */, uint32(52), uintptr(unsafe.Pointer(&__func__)))
		}
		if (*ARRAY16)(unsafe.Pointer(bp+272 /* &newArray */)).Fdata == (uintptr(0)) {
		} else {
			libc.X__assert_fail(tls, ts+78 /* "newArray.data ==..." */, ts+49 /* "Array.c" */, uint32(52), uintptr(unsafe.Pointer(&__func__)))
		}
		libc.Xprintf(tls, ts+107 /* "Checking XdmcpRe..." */, libc.VaList(bp+48, ts+139 /* "ARRAY16" */, ((255)+1)))
		result = xdmcp.XXdmcpReallocARRAY16(tls, bp+272 /* &newArray */, ((255) + 1))
		if result == 0 {
		} else {
			libc.X__assert_fail(tls, ts+37 /* "result == 0" */, ts+49 /* "Array.c" */, uint32(52), uintptr(unsafe.Pointer(&__func__)))
		}
		if int32((*ARRAY16)(unsafe.Pointer(bp+272 /* &newArray */)).Flength) == 0 {
		} else {
			libc.X__assert_fail(tls, ts+57 /* "newArray.length ..." */, ts+49 /* "Array.c" */, uint32(52), uintptr(unsafe.Pointer(&__func__)))
		}
		if (*ARRAY16)(unsafe.Pointer(bp+272 /* &newArray */)).Fdata == (uintptr(0)) {
		} else {
			libc.X__assert_fail(tls, ts+78 /* "newArray.data ==..." */, ts+49 /* "Array.c" */, uint32(52), uintptr(unsafe.Pointer(&__func__)))
		}
		xdmcp.XXdmcpDisposeARRAY16(tls, bp+272 /* &newArray */)
	}

	{
		*(*ARRAY32)(unsafe.Pointer(bp + 288 /* newArray */)) = ARRAY32{Flength: libc.Uint8FromInt32(-1), Fdata: libc.UintptrFromInt32(-1)}
		var result int32
		libc.Xprintf(tls, ts /* "Checking XdmcpAl..." */, libc.VaList(bp+64, ts+147 /* "ARRAY32" */, ((255)+1)))
		result = xdmcp.XXdmcpAllocARRAY32(tls, bp+288 /* &newArray */, ((255) + 1))
		if result == 0 {
		} else {
			libc.X__assert_fail(tls, ts+37 /* "result == 0" */, ts+49 /* "Array.c" */, uint32(53), uintptr(unsafe.Pointer(&__func__)))
		}
		if int32((*ARRAY32)(unsafe.Pointer(bp+288 /* &newArray */)).Flength) == 0 {
		} else {
			libc.X__assert_fail(tls, ts+57 /* "newArray.length ..." */, ts+49 /* "Array.c" */, uint32(53), uintptr(unsafe.Pointer(&__func__)))
		}
		if (*ARRAY32)(unsafe.Pointer(bp+288 /* &newArray */)).Fdata == (uintptr(0)) {
		} else {
			libc.X__assert_fail(tls, ts+78 /* "newArray.data ==..." */, ts+49 /* "Array.c" */, uint32(53), uintptr(unsafe.Pointer(&__func__)))
		}
		libc.Xprintf(tls, ts+107 /* "Checking XdmcpRe..." */, libc.VaList(bp+80, ts+147 /* "ARRAY32" */, ((255)+1)))
		result = xdmcp.XXdmcpReallocARRAY32(tls, bp+288 /* &newArray */, ((255) + 1))
		if result == 0 {
		} else {
			libc.X__assert_fail(tls, ts+37 /* "result == 0" */, ts+49 /* "Array.c" */, uint32(53), uintptr(unsafe.Pointer(&__func__)))
		}
		if int32((*ARRAY32)(unsafe.Pointer(bp+288 /* &newArray */)).Flength) == 0 {
		} else {
			libc.X__assert_fail(tls, ts+57 /* "newArray.length ..." */, ts+49 /* "Array.c" */, uint32(53), uintptr(unsafe.Pointer(&__func__)))
		}
		if (*ARRAY32)(unsafe.Pointer(bp+288 /* &newArray */)).Fdata == (uintptr(0)) {
		} else {
			libc.X__assert_fail(tls, ts+78 /* "newArray.data ==..." */, ts+49 /* "Array.c" */, uint32(53), uintptr(unsafe.Pointer(&__func__)))
		}
		xdmcp.XXdmcpDisposeARRAY32(tls, bp+288 /* &newArray */)
	}

	{
		*(*ARRAYofARRAY8)(unsafe.Pointer(bp + 304 /* newArray */)) = ARRAYofARRAY8{Flength: libc.Uint8FromInt32(-1), Fdata: libc.UintptrFromInt32(-1)}
		var result int32
		libc.Xprintf(tls, ts /* "Checking XdmcpAl..." */, libc.VaList(bp+96, ts+155 /* "ARRAYofARRAY8" */, ((255)+1)))
		result = xdmcp.XXdmcpAllocARRAYofARRAY8(tls, bp+304 /* &newArray */, ((255) + 1))
		if result == 0 {
		} else {
			libc.X__assert_fail(tls, ts+37 /* "result == 0" */, ts+49 /* "Array.c" */, uint32(54), uintptr(unsafe.Pointer(&__func__)))
		}
		if int32((*ARRAYofARRAY8)(unsafe.Pointer(bp+304 /* &newArray */)).Flength) == 0 {
		} else {
			libc.X__assert_fail(tls, ts+57 /* "newArray.length ..." */, ts+49 /* "Array.c" */, uint32(54), uintptr(unsafe.Pointer(&__func__)))
		}
		if (*ARRAYofARRAY8)(unsafe.Pointer(bp+304 /* &newArray */)).Fdata == (uintptr(0)) {
		} else {
			libc.X__assert_fail(tls, ts+78 /* "newArray.data ==..." */, ts+49 /* "Array.c" */, uint32(54), uintptr(unsafe.Pointer(&__func__)))
		}
		libc.Xprintf(tls, ts+107 /* "Checking XdmcpRe..." */, libc.VaList(bp+112, ts+155 /* "ARRAYofARRAY8" */, ((255)+1)))
		result = xdmcp.XXdmcpReallocARRAYofARRAY8(tls, bp+304 /* &newArray */, ((255) + 1))
		if result == 0 {
		} else {
			libc.X__assert_fail(tls, ts+37 /* "result == 0" */, ts+49 /* "Array.c" */, uint32(54), uintptr(unsafe.Pointer(&__func__)))
		}
		if int32((*ARRAYofARRAY8)(unsafe.Pointer(bp+304 /* &newArray */)).Flength) == 0 {
		} else {
			libc.X__assert_fail(tls, ts+57 /* "newArray.length ..." */, ts+49 /* "Array.c" */, uint32(54), uintptr(unsafe.Pointer(&__func__)))
		}
		if (*ARRAYofARRAY8)(unsafe.Pointer(bp+304 /* &newArray */)).Fdata == (uintptr(0)) {
		} else {
			libc.X__assert_fail(tls, ts+78 /* "newArray.data ==..." */, ts+49 /* "Array.c" */, uint32(54), uintptr(unsafe.Pointer(&__func__)))
		}
		xdmcp.XXdmcpDisposeARRAYofARRAY8(tls, bp+304 /* &newArray */)
	}

	{
		*(*ARRAY8)(unsafe.Pointer(bp + 320 /* newArray */)) = ARRAY8{Flength: libc.Uint16FromInt32(-1), Fdata: libc.UintptrFromInt32(-1)}
		var result int32
		libc.Xprintf(tls, ts /* "Checking XdmcpAl..." */, libc.VaList(bp+128, ts+30 /* "ARRAY8" */, -1))
		result = xdmcp.XXdmcpAllocARRAY8(tls, bp+320 /* &newArray */, -1)
		if result == 0 {
		} else {
			libc.X__assert_fail(tls, ts+37 /* "result == 0" */, ts+49 /* "Array.c" */, uint32(55), uintptr(unsafe.Pointer(&__func__)))
		}
		if int32((*ARRAY8)(unsafe.Pointer(bp+320 /* &newArray */)).Flength) == 0 {
		} else {
			libc.X__assert_fail(tls, ts+57 /* "newArray.length ..." */, ts+49 /* "Array.c" */, uint32(55), uintptr(unsafe.Pointer(&__func__)))
		}
		if (*ARRAY8)(unsafe.Pointer(bp+320 /* &newArray */)).Fdata == (uintptr(0)) {
		} else {
			libc.X__assert_fail(tls, ts+78 /* "newArray.data ==..." */, ts+49 /* "Array.c" */, uint32(55), uintptr(unsafe.Pointer(&__func__)))
		}
		libc.Xprintf(tls, ts+107 /* "Checking XdmcpRe..." */, libc.VaList(bp+144, ts+30 /* "ARRAY8" */, -1))
		result = xdmcp.XXdmcpReallocARRAY8(tls, bp+320 /* &newArray */, -1)
		if result == 0 {
		} else {
			libc.X__assert_fail(tls, ts+37 /* "result == 0" */, ts+49 /* "Array.c" */, uint32(55), uintptr(unsafe.Pointer(&__func__)))
		}
		if int32((*ARRAY8)(unsafe.Pointer(bp+320 /* &newArray */)).Flength) == 0 {
		} else {
			libc.X__assert_fail(tls, ts+57 /* "newArray.length ..." */, ts+49 /* "Array.c" */, uint32(55), uintptr(unsafe.Pointer(&__func__)))
		}
		if (*ARRAY8)(unsafe.Pointer(bp+320 /* &newArray */)).Fdata == (uintptr(0)) {
		} else {
			libc.X__assert_fail(tls, ts+78 /* "newArray.data ==..." */, ts+49 /* "Array.c" */, uint32(55), uintptr(unsafe.Pointer(&__func__)))
		}
		xdmcp.XXdmcpDisposeARRAY8(tls, bp+320 /* &newArray */)
	}

	{
		*(*ARRAY16)(unsafe.Pointer(bp + 336 /* newArray */)) = ARRAY16{Flength: libc.Uint8FromInt32(-1), Fdata: libc.UintptrFromInt32(-1)}
		var result int32
		libc.Xprintf(tls, ts /* "Checking XdmcpAl..." */, libc.VaList(bp+160, ts+139 /* "ARRAY16" */, -1))
		result = xdmcp.XXdmcpAllocARRAY16(tls, bp+336 /* &newArray */, -1)
		if result == 0 {
		} else {
			libc.X__assert_fail(tls, ts+37 /* "result == 0" */, ts+49 /* "Array.c" */, uint32(56), uintptr(unsafe.Pointer(&__func__)))
		}
		if int32((*ARRAY16)(unsafe.Pointer(bp+336 /* &newArray */)).Flength) == 0 {
		} else {
			libc.X__assert_fail(tls, ts+57 /* "newArray.length ..." */, ts+49 /* "Array.c" */, uint32(56), uintptr(unsafe.Pointer(&__func__)))
		}
		if (*ARRAY16)(unsafe.Pointer(bp+336 /* &newArray */)).Fdata == (uintptr(0)) {
		} else {
			libc.X__assert_fail(tls, ts+78 /* "newArray.data ==..." */, ts+49 /* "Array.c" */, uint32(56), uintptr(unsafe.Pointer(&__func__)))
		}
		libc.Xprintf(tls, ts+107 /* "Checking XdmcpRe..." */, libc.VaList(bp+176, ts+139 /* "ARRAY16" */, -1))
		result = xdmcp.XXdmcpReallocARRAY16(tls, bp+336 /* &newArray */, -1)
		if result == 0 {
		} else {
			libc.X__assert_fail(tls, ts+37 /* "result == 0" */, ts+49 /* "Array.c" */, uint32(56), uintptr(unsafe.Pointer(&__func__)))
		}
		if int32((*ARRAY16)(unsafe.Pointer(bp+336 /* &newArray */)).Flength) == 0 {
		} else {
			libc.X__assert_fail(tls, ts+57 /* "newArray.length ..." */, ts+49 /* "Array.c" */, uint32(56), uintptr(unsafe.Pointer(&__func__)))
		}
		if (*ARRAY16)(unsafe.Pointer(bp+336 /* &newArray */)).Fdata == (uintptr(0)) {
		} else {
			libc.X__assert_fail(tls, ts+78 /* "newArray.data ==..." */, ts+49 /* "Array.c" */, uint32(56), uintptr(unsafe.Pointer(&__func__)))
		}
		xdmcp.XXdmcpDisposeARRAY16(tls, bp+336 /* &newArray */)
	}

	{
		*(*ARRAY32)(unsafe.Pointer(bp + 352 /* newArray */)) = ARRAY32{Flength: libc.Uint8FromInt32(-1), Fdata: libc.UintptrFromInt32(-1)}
		var result int32
		libc.Xprintf(tls, ts /* "Checking XdmcpAl..." */, libc.VaList(bp+192, ts+147 /* "ARRAY32" */, -1))
		result = xdmcp.XXdmcpAllocARRAY32(tls, bp+352 /* &newArray */, -1)
		if result == 0 {
		} else {
			libc.X__assert_fail(tls, ts+37 /* "result == 0" */, ts+49 /* "Array.c" */, uint32(57), uintptr(unsafe.Pointer(&__func__)))
		}
		if int32((*ARRAY32)(unsafe.Pointer(bp+352 /* &newArray */)).Flength) == 0 {
		} else {
			libc.X__assert_fail(tls, ts+57 /* "newArray.length ..." */, ts+49 /* "Array.c" */, uint32(57), uintptr(unsafe.Pointer(&__func__)))
		}
		if (*ARRAY32)(unsafe.Pointer(bp+352 /* &newArray */)).Fdata == (uintptr(0)) {
		} else {
			libc.X__assert_fail(tls, ts+78 /* "newArray.data ==..." */, ts+49 /* "Array.c" */, uint32(57), uintptr(unsafe.Pointer(&__func__)))
		}
		libc.Xprintf(tls, ts+107 /* "Checking XdmcpRe..." */, libc.VaList(bp+208, ts+147 /* "ARRAY32" */, -1))
		result = xdmcp.XXdmcpReallocARRAY32(tls, bp+352 /* &newArray */, -1)
		if result == 0 {
		} else {
			libc.X__assert_fail(tls, ts+37 /* "result == 0" */, ts+49 /* "Array.c" */, uint32(57), uintptr(unsafe.Pointer(&__func__)))
		}
		if int32((*ARRAY32)(unsafe.Pointer(bp+352 /* &newArray */)).Flength) == 0 {
		} else {
			libc.X__assert_fail(tls, ts+57 /* "newArray.length ..." */, ts+49 /* "Array.c" */, uint32(57), uintptr(unsafe.Pointer(&__func__)))
		}
		if (*ARRAY32)(unsafe.Pointer(bp+352 /* &newArray */)).Fdata == (uintptr(0)) {
		} else {
			libc.X__assert_fail(tls, ts+78 /* "newArray.data ==..." */, ts+49 /* "Array.c" */, uint32(57), uintptr(unsafe.Pointer(&__func__)))
		}
		xdmcp.XXdmcpDisposeARRAY32(tls, bp+352 /* &newArray */)
	}

	{
		*(*ARRAYofARRAY8)(unsafe.Pointer(bp + 368 /* newArray */)) = ARRAYofARRAY8{Flength: libc.Uint8FromInt32(-1), Fdata: libc.UintptrFromInt32(-1)}
		var result int32
		libc.Xprintf(tls, ts /* "Checking XdmcpAl..." */, libc.VaList(bp+224, ts+155 /* "ARRAYofARRAY8" */, -1))
		result = xdmcp.XXdmcpAllocARRAYofARRAY8(tls, bp+368 /* &newArray */, -1)
		if result == 0 {
		} else {
			libc.X__assert_fail(tls, ts+37 /* "result == 0" */, ts+49 /* "Array.c" */, uint32(58), uintptr(unsafe.Pointer(&__func__)))
		}
		if int32((*ARRAYofARRAY8)(unsafe.Pointer(bp+368 /* &newArray */)).Flength) == 0 {
		} else {
			libc.X__assert_fail(tls, ts+57 /* "newArray.length ..." */, ts+49 /* "Array.c" */, uint32(58), uintptr(unsafe.Pointer(&__func__)))
		}
		if (*ARRAYofARRAY8)(unsafe.Pointer(bp+368 /* &newArray */)).Fdata == (uintptr(0)) {
		} else {
			libc.X__assert_fail(tls, ts+78 /* "newArray.data ==..." */, ts+49 /* "Array.c" */, uint32(58), uintptr(unsafe.Pointer(&__func__)))
		}
		libc.Xprintf(tls, ts+107 /* "Checking XdmcpRe..." */, libc.VaList(bp+240, ts+155 /* "ARRAYofARRAY8" */, -1))
		result = xdmcp.XXdmcpReallocARRAYofARRAY8(tls, bp+368 /* &newArray */, -1)
		if result == 0 {
		} else {
			libc.X__assert_fail(tls, ts+37 /* "result == 0" */, ts+49 /* "Array.c" */, uint32(58), uintptr(unsafe.Pointer(&__func__)))
		}
		if int32((*ARRAYofARRAY8)(unsafe.Pointer(bp+368 /* &newArray */)).Flength) == 0 {
		} else {
			libc.X__assert_fail(tls, ts+57 /* "newArray.length ..." */, ts+49 /* "Array.c" */, uint32(58), uintptr(unsafe.Pointer(&__func__)))
		}
		if (*ARRAYofARRAY8)(unsafe.Pointer(bp+368 /* &newArray */)).Fdata == (uintptr(0)) {
		} else {
			libc.X__assert_fail(tls, ts+78 /* "newArray.data ==..." */, ts+49 /* "Array.c" */, uint32(58), uintptr(unsafe.Pointer(&__func__)))
		}
		xdmcp.XXdmcpDisposeARRAYofARRAY8(tls, bp+368 /* &newArray */)
	}

}

var __func__ = *(*[24]int8)(unsafe.Pointer(ts + 169 /* "TestAllocOversiz..." */)) /* Array.c:50:1 */

func TestZeroFillARRAYofARRAY8(tls *libc.TLS) { /* Array.c:62:1: */
	bp := tls.Alloc(16)
	defer tls.Free(16)

	// var aa ARRAYofARRAY8 at bp, 16

	var result int32
	var noise uintptr

	libc.Xprintf(tls, ts+193 /* "Checking XdmcpAl..." */, 0)
	// prefill memory with junk - hopefully next malloc will pick up some
	noise = libc.Xmalloc(tls, (uint64(32) * uint64(unsafe.Sizeof(ARRAY8{}))))
	libc.Xmemset(tls, noise, libc.Int32FromUint32(0xdeadbeef), (uint64(32) * uint64(unsafe.Sizeof(ARRAY8{}))))
	libc.Xfree(tls, noise)
	result = xdmcp.XXdmcpAllocARRAYofARRAY8(tls, bp /* &aa */, 32)
	if result == 1 {
	} else {
		libc.X__assert_fail(tls, ts+247 /* "result == 1" */, ts+49 /* "Array.c" */, uint32(74), uintptr(unsafe.Pointer(&__func__1)))
	}
	if int32((*ARRAYofARRAY8)(unsafe.Pointer(bp /* &aa */)).Flength) == 32 {
	} else {
		libc.X__assert_fail(tls, ts+259 /* "aa.length == 32" */, ts+49 /* "Array.c" */, uint32(75), uintptr(unsafe.Pointer(&__func__1)))
	}
	if (*_ARRAY8)(unsafe.Pointer((*ARRAYofARRAY8)(unsafe.Pointer(bp /* &aa */)).Fdata+4*16)).Fdata == (uintptr(0)) {
	} else {
		libc.X__assert_fail(tls, ts+275 /* "aa.data[4].data ..." */, ts+49 /* "Array.c" */, uint32(76), uintptr(unsafe.Pointer(&__func__1)))
	}
	libc.Xprintf(tls, ts+306 /* "Checking XdmcpRe..." */, 0)
	result = xdmcp.XXdmcpAllocARRAYofARRAY8(tls, bp /* &aa */, 48)
	if result == 1 {
	} else {
		libc.X__assert_fail(tls, ts+247 /* "result == 1" */, ts+49 /* "Array.c" */, uint32(79), uintptr(unsafe.Pointer(&__func__1)))
	}
	if int32((*ARRAYofARRAY8)(unsafe.Pointer(bp /* &aa */)).Flength) == 48 {
	} else {
		libc.X__assert_fail(tls, ts+362 /* "aa.length == 48" */, ts+49 /* "Array.c" */, uint32(80), uintptr(unsafe.Pointer(&__func__1)))
	}
	if (*_ARRAY8)(unsafe.Pointer((*ARRAYofARRAY8)(unsafe.Pointer(bp /* &aa */)).Fdata+40*16)).Fdata == (uintptr(0)) {
	} else {
		libc.X__assert_fail(tls, ts+378 /* "aa.data[40].data..." */, ts+49 /* "Array.c" */, uint32(81), uintptr(unsafe.Pointer(&__func__1)))
	}
	xdmcp.XXdmcpDisposeARRAYofARRAY8(tls, bp /* &aa */)
}

var __func__1 = *(*[26]int8)(unsafe.Pointer(ts + 410 /* "TestZeroFillARRA..." */)) /* Array.c:63:1 */

func main1(tls *libc.TLS, argc int32, argv uintptr) int32 { /* Array.c:86:1: */
	TestAllocOversizeArrays(tls)
	TestZeroFillARRAYofARRAY8(tls)

	libc.Xexit(tls, 0)
	return int32(0)
}

var ts1 = "Checking XdmcpAlloc%s(%d)...\n\x00ARRAY8\x00result == 0\x00Array.c\x00newArray.length == 0\x00newArray.data == ((void *)0)\x00Checking XdmcpRealloc%s(%d)...\n\x00ARRAY16\x00ARRAY32\x00ARRAYofARRAY8\x00TestAllocOversizeArrays\x00Checking XdmcpAllocARRAYofARRAY8 zero fills array...\n\x00result == 1\x00aa.length == 32\x00aa.data[4].data == ((void *)0)\x00Checking XdmcpReallocARRAYofARRAY8 zero fills array...\n\x00aa.length == 48\x00aa.data[40].data == ((void *)0)\x00TestZeroFillARRAYofARRAY8\x00"
var ts = (*reflect.StringHeader)(unsafe.Pointer(&ts1)).Data