modernc.org/z@v1.7.4/lib/z_linux_ppc64le.go (about)

     1  // Code generated by 'ccgo -export-defines "" -export-enums "" -export-externs X -export-fields F -export-structs "" -export-typedefs "" -o lib/z_linux_ppc64le.go -pkgname z -trace-translation-units /tmp/go-generate-526959028/cdb.json libz.a', DO NOT EDIT.
     2  
     3  package z
     4  
     5  import (
     6  	"math"
     7  	"reflect"
     8  	"sync/atomic"
     9  	"unsafe"
    10  
    11  	"modernc.org/libc"
    12  	"modernc.org/libc/sys/types"
    13  )
    14  
    15  var _ = math.Pi
    16  var _ reflect.Kind
    17  var _ atomic.Value
    18  var _ unsafe.Pointer
    19  var _ *libc.TLS
    20  var _ types.Size_t
    21  
    22  const (
    23  	AIO_PRIO_DELTA_MAX                   = 20                   // local_lim.h:78:1:
    24  	BASE                                 = 65521                // adler32.c:12:1:
    25  	BC_BASE_MAX                          = 99                   // posix2_lim.h:63:1:
    26  	BC_DIM_MAX                           = 2048                 // posix2_lim.h:66:1:
    27  	BC_SCALE_MAX                         = 99                   // posix2_lim.h:69:1:
    28  	BC_STRING_MAX                        = 1000                 // posix2_lim.h:72:1:
    29  	BIG_ENDIAN                           = 4321                 // endian.h:28:1:
    30  	BYTE_ORDER                           = 1234                 // endian.h:30:1:
    31  	CHARCLASS_NAME_MAX                   = 2048                 // posix2_lim.h:84:1:
    32  	CHAR_BIT                             = 8                    // limits.h:64:1:
    33  	CHAR_MAX                             = 255                  // limits.h:94:1:
    34  	CHAR_MIN                             = 0                    // limits.h:91:1:
    35  	COLL_WEIGHTS_MAX                     = 255                  // posix2_lim.h:75:1:
    36  	DEF_MEM_LEVEL                        = 8                    // zutil.h:66:1:
    37  	DEF_WBITS                            = 15                   // zutil.h:61:1:
    38  	DELAYTIMER_MAX                       = 2147483647           // local_lim.h:85:1:
    39  	DYN_TREES                            = 2                    // zutil.h:74:1:
    40  	EXIT_FAILURE                         = 1                    // stdlib.h:91:1:
    41  	EXIT_SUCCESS                         = 0                    // stdlib.h:92:1:
    42  	EXPR_NEST_MAX                        = 32                   // posix2_lim.h:78:1:
    43  	FAR                                  = 0                    // zconf.h:387:1:
    44  	FD_SETSIZE                           = 1024                 // select.h:73:1:
    45  	F_LOCK                               = 1                    // unistd.h:1074:1:
    46  	F_OK                                 = 0                    // unistd.h:284:1:
    47  	F_TEST                               = 3                    // unistd.h:1076:1:
    48  	F_TLOCK                              = 2                    // unistd.h:1075:1:
    49  	F_ULOCK                              = 0                    // unistd.h:1073:1:
    50  	HAVE_HIDDEN                          = 1                    // <defines>:2:1:
    51  	HAVE_MEMCPY                          = 0                    // zutil.h:218:1:
    52  	HOST_NAME_MAX                        = 64                   // local_lim.h:94:1:
    53  	INT_MAX                              = 2147483647           // limits.h:120:1:
    54  	INT_MIN                              = -2147483648          // limits.h:118:1:
    55  	LINE_MAX                             = 2048                 // posix2_lim.h:81:1:
    56  	LITTLE_ENDIAN                        = 1234                 // endian.h:27:1:
    57  	LLONG_MAX                            = 9223372036854775807  // limits.h:142:1:
    58  	LLONG_MIN                            = -9223372036854775808 // limits.h:140:1:
    59  	LOGIN_NAME_MAX                       = 256                  // local_lim.h:91:1:
    60  	LONG_MAX                             = 9223372036854775807  // limits.h:131:1:
    61  	LONG_MIN                             = -9223372036854775808 // limits.h:129:1:
    62  	L_INCR                               = 1                    // unistd.h:323:1:
    63  	L_SET                                = 0                    // unistd.h:322:1:
    64  	L_XTND                               = 2                    // unistd.h:324:1:
    65  	MAX_CANON                            = 255                  // limits.h:10:1:
    66  	MAX_INPUT                            = 255                  // limits.h:11:1:
    67  	MAX_MATCH                            = 258                  // zutil.h:78:1:
    68  	MAX_MEM_LEVEL                        = 9                    // zconf.h:260:1:
    69  	MAX_WBITS                            = 15                   // zconf.h:270:1:
    70  	MB_LEN_MAX                           = 16                   // limits.h:32:1:
    71  	MIN_MATCH                            = 3                    // zutil.h:77:1:
    72  	MQ_PRIO_MAX                          = 32768                // local_lim.h:97:1:
    73  	NAME_MAX                             = 255                  // limits.h:12:1:
    74  	NGROUPS_MAX                          = 65536                // limits.h:7:1:
    75  	NMAX                                 = 5552                 // adler32.c:13:1:
    76  	OS_CODE                              = 3                    // zutil.h:198:1:
    77  	PATH_MAX                             = 4096                 // limits.h:13:1:
    78  	PDP_ENDIAN                           = 3412                 // endian.h:29:1:
    79  	PIPE_BUF                             = 4096                 // limits.h:14:1:
    80  	PRESET_DICT                          = 0x20                 // zutil.h:81:1:
    81  	PTHREAD_DESTRUCTOR_ITERATIONS        = 4                    // local_lim.h:69:1:
    82  	PTHREAD_KEYS_MAX                     = 1024                 // local_lim.h:64:1:
    83  	PTHREAD_STACK_MIN                    = 131072               // local_lim.h:82:1:
    84  	RAND_MAX                             = 2147483647           // stdlib.h:86:1:
    85  	RE_DUP_MAX                           = 32767                // posix2_lim.h:88:1:
    86  	RTSIG_MAX                            = 32                   // limits.h:19:1:
    87  	R_OK                                 = 4                    // unistd.h:281:1:
    88  	SCHAR_MAX                            = 127                  // limits.h:75:1:
    89  	SCHAR_MIN                            = -128                 // limits.h:73:1:
    90  	SEEK_CUR                             = 1                    // unistd.h:312:1:
    91  	SEEK_END                             = 2                    // unistd.h:313:1:
    92  	SEEK_SET                             = 0                    // unistd.h:311:1:
    93  	SEM_VALUE_MAX                        = 2147483647           // local_lim.h:100:1:
    94  	SHRT_MAX                             = 32767                // limits.h:106:1:
    95  	SHRT_MIN                             = -32768               // limits.h:104:1:
    96  	SSIZE_MAX                            = 9223372036854775807  // posix1_lim.h:169:1:
    97  	STATIC_TREES                         = 1                    // zutil.h:73:1:
    98  	STDC                                 = 0                    // zconf.h:203:1:
    99  	STDC99                               = 0                    // zconf.h:207:1:
   100  	STDERR_FILENO                        = 2                    // unistd.h:212:1:
   101  	STDIN_FILENO                         = 0                    // unistd.h:210:1:
   102  	STDOUT_FILENO                        = 1                    // unistd.h:211:1:
   103  	STORED_BLOCK                         = 0                    // zutil.h:72:1:
   104  	TTY_NAME_MAX                         = 32                   // local_lim.h:88:1:
   105  	UCHAR_MAX                            = 255                  // limits.h:82:1:
   106  	UINT_MAX                             = 4294967295           // limits.h:124:1:
   107  	ULLONG_MAX                           = 18446744073709551615 // limits.h:146:1:
   108  	ULONG_MAX                            = 18446744073709551615 // limits.h:135:1:
   109  	USHRT_MAX                            = 65535                // limits.h:113:1:
   110  	WCONTINUED                           = 8                    // waitflags.h:32:1:
   111  	WEXITED                              = 4                    // waitflags.h:31:1:
   112  	WNOHANG                              = 1                    // waitflags.h:25:1:
   113  	WNOWAIT                              = 0x01000000           // waitflags.h:33:1:
   114  	WSTOPPED                             = 2                    // waitflags.h:30:1:
   115  	WUNTRACED                            = 2                    // waitflags.h:26:1:
   116  	W_OK                                 = 2                    // unistd.h:282:1:
   117  	XATTR_LIST_MAX                       = 65536                // limits.h:17:1:
   118  	XATTR_NAME_MAX                       = 255                  // limits.h:15:1:
   119  	XATTR_SIZE_MAX                       = 65536                // limits.h:16:1:
   120  	X_OK                                 = 1                    // unistd.h:283:1:
   121  	ZCONF_H                              = 0                    // zconf.h:9:1:
   122  	ZEXPORT                              = 0                    // zconf.h:380:1:
   123  	ZEXPORTVA                            = 0                    // zconf.h:383:1:
   124  	ZLIB_H                               = 0                    // zlib.h:32:1:
   125  	ZLIB_VERNUM                          = 0x12b0               // zlib.h:41:1:
   126  	ZLIB_VERSION                         = "1.2.11"             // zlib.h:40:1:
   127  	ZLIB_VER_MAJOR                       = 1                    // zlib.h:42:1:
   128  	ZLIB_VER_MINOR                       = 2                    // zlib.h:43:1:
   129  	ZLIB_VER_REVISION                    = 11                   // zlib.h:44:1:
   130  	ZLIB_VER_SUBREVISION                 = 0                    // zlib.h:45:1:
   131  	ZUTIL_H                              = 0                    // zutil.h:14:1:
   132  	Z_ASCII                              = 1                    // zlib.h:205:1:
   133  	Z_BEST_COMPRESSION                   = 9                    // zlib.h:192:1:
   134  	Z_BEST_SPEED                         = 1                    // zlib.h:191:1:
   135  	Z_BINARY                             = 0                    // zlib.h:203:1:
   136  	Z_BLOCK                              = 5                    // zlib.h:173:1:
   137  	Z_BUF_ERROR                          = -5                   // zlib.h:184:1:
   138  	Z_DATA_ERROR                         = -3                   // zlib.h:182:1:
   139  	Z_DEFAULT_COMPRESSION                = -1                   // zlib.h:193:1:
   140  	Z_DEFAULT_STRATEGY                   = 0                    // zlib.h:200:1:
   141  	Z_DEFLATED                           = 8                    // zlib.h:209:1:
   142  	Z_ERRNO                              = -1                   // zlib.h:180:1:
   143  	Z_FILTERED                           = 1                    // zlib.h:196:1:
   144  	Z_FINISH                             = 4                    // zlib.h:172:1:
   145  	Z_FIXED                              = 4                    // zlib.h:199:1:
   146  	Z_FULL_FLUSH                         = 3                    // zlib.h:171:1:
   147  	Z_HAVE_STDARG_H                      = 0                    // zconf.h:439:1:
   148  	Z_HAVE_UNISTD_H                      = 0                    // zconf.h:435:1:
   149  	Z_HUFFMAN_ONLY                       = 2                    // zlib.h:197:1:
   150  	Z_LARGE64                            = 0                    // zconf.h:490:1:
   151  	Z_LFS64                              = 0                    // zconf.h:486:1:
   152  	Z_MEM_ERROR                          = -4                   // zlib.h:183:1:
   153  	Z_NEED_DICT                          = 2                    // zlib.h:179:1:
   154  	Z_NO_COMPRESSION                     = 0                    // zlib.h:190:1:
   155  	Z_NO_FLUSH                           = 0                    // zlib.h:168:1:
   156  	Z_NULL                               = 0                    // zlib.h:212:1:
   157  	Z_OK                                 = 0                    // zlib.h:177:1:
   158  	Z_PARTIAL_FLUSH                      = 1                    // zlib.h:169:1:
   159  	Z_RLE                                = 3                    // zlib.h:198:1:
   160  	Z_STREAM_END                         = 1                    // zlib.h:178:1:
   161  	Z_STREAM_ERROR                       = -2                   // zlib.h:181:1:
   162  	Z_SYNC_FLUSH                         = 2                    // zlib.h:170:1:
   163  	Z_TEXT                               = 1                    // zlib.h:204:1:
   164  	Z_TREES                              = 6                    // zlib.h:174:1:
   165  	Z_UNKNOWN                            = 2                    // zlib.h:206:1:
   166  	Z_VERSION_ERROR                      = -6                   // zlib.h:185:1:
   167  	Z_WANT64                             = 0                    // zconf.h:494:1:
   168  	X_ALLOCA_H                           = 1                    // alloca.h:19:1:
   169  	X_ANSI_STDARG_H_                     = 0                    // stdarg.h:32:1:
   170  	X_ANSI_STDDEF_H                      = 0                    // stddef.h:42:1:
   171  	X_ARCH_PPC                           = 1                    // <predefined>:198:1:
   172  	X_ARCH_PPC64                         = 1                    // <predefined>:402:1:
   173  	X_ARCH_PPCGR                         = 1                    // <predefined>:15:1:
   174  	X_ARCH_PPCSQ                         = 1                    // <predefined>:43:1:
   175  	X_ARCH_PWR4                          = 1                    // <predefined>:381:1:
   176  	X_ARCH_PWR5                          = 1                    // <predefined>:90:1:
   177  	X_ARCH_PWR5X                         = 1                    // <predefined>:137:1:
   178  	X_ARCH_PWR6                          = 1                    // <predefined>:91:1:
   179  	X_ARCH_PWR7                          = 1                    // <predefined>:92:1:
   180  	X_ARCH_PWR8                          = 1                    // <predefined>:93:1:
   181  	X_ATFILE_SOURCE                      = 1                    // features.h:342:1:
   182  	X_BITS_BYTESWAP_H                    = 1                    // byteswap.h:24:1:
   183  	X_BITS_ENDIANNESS_H                  = 1                    // endianness.h:2:1:
   184  	X_BITS_ENDIAN_H                      = 1                    // endian.h:20:1:
   185  	X_BITS_FLOATN_COMMON_H               = 0                    // floatn-common.h:21:1:
   186  	X_BITS_FLOATN_H                      = 0                    // floatn.h:20:1:
   187  	X_BITS_POSIX1_LIM_H                  = 1                    // posix1_lim.h:25:1:
   188  	X_BITS_POSIX2_LIM_H                  = 1                    // posix2_lim.h:23:1:
   189  	X_BITS_POSIX_OPT_H                   = 1                    // posix_opt.h:20:1:
   190  	X_BITS_PTHREADTYPES_ARCH_H           = 1                    // pthreadtypes-arch.h:21:1:
   191  	X_BITS_PTHREADTYPES_COMMON_H         = 1                    // pthreadtypes.h:20:1:
   192  	X_BITS_STDINT_INTN_H                 = 1                    // stdint-intn.h:20:1:
   193  	X_BITS_TIME64_H                      = 1                    // time64.h:24:1:
   194  	X_BITS_TYPESIZES_H                   = 1                    // typesizes.h:24:1:
   195  	X_BITS_TYPES_H                       = 1                    // types.h:24:1:
   196  	X_BITS_TYPES_LOCALE_T_H              = 1                    // locale_t.h:20:1:
   197  	X_BITS_TYPES___LOCALE_T_H            = 1                    // __locale_t.h:21:1:
   198  	X_BITS_UINTN_IDENTITY_H              = 1                    // uintn-identity.h:24:1:
   199  	X_BSD_PTRDIFF_T_                     = 0                    // stddef.h:136:1:
   200  	X_BSD_SIZE_T_                        = 0                    // stddef.h:189:1:
   201  	X_BSD_SIZE_T_DEFINED_                = 0                    // stddef.h:192:1:
   202  	X_CALL_ELF                           = 2                    // <predefined>:415:1:
   203  	X_CALL_LINUX                         = 1                    // <predefined>:123:1:
   204  	X_DEFAULT_SOURCE                     = 1                    // features.h:227:1:
   205  	X_ENDIAN_H                           = 1                    // endian.h:19:1:
   206  	X_FEATURES_H                         = 1                    // features.h:19:1:
   207  	X_FILE_OFFSET_BITS                   = 64                   // <builtin>:25:1:
   208  	X_GCC_LIMITS_H_                      = 0                    // limits.h:30:1:
   209  	X_GCC_MAX_ALIGN_T                    = 0                    // stddef.h:411:1:
   210  	X_GCC_PTRDIFF_T                      = 0                    // stddef.h:138:1:
   211  	X_GCC_SIZE_T                         = 0                    // stddef.h:195:1:
   212  	X_GCC_WCHAR_T                        = 0                    // stddef.h:273:1:
   213  	X_GETOPT_CORE_H                      = 1                    // getopt_core.h:21:1:
   214  	X_GETOPT_POSIX_H                     = 1                    // getopt_posix.h:21:1:
   215  	X_LARGEFILE64_SOURCE                 = 1                    // <defines>:1:1:
   216  	X_LFS64_ASYNCHRONOUS_IO              = 1                    // posix_opt.h:117:1:
   217  	X_LFS64_LARGEFILE                    = 1                    // posix_opt.h:121:1:
   218  	X_LFS64_STDIO                        = 1                    // posix_opt.h:122:1:
   219  	X_LFS_ASYNCHRONOUS_IO                = 1                    // posix_opt.h:112:1:
   220  	X_LFS_LARGEFILE                      = 1                    // posix_opt.h:120:1:
   221  	X_LIBC_LIMITS_H_                     = 1                    // limits.h:23:1:
   222  	X_LIMITS_H___                        = 0                    // limits.h:60:1:
   223  	X_LINUX_LIMITS_H                     = 0                    // limits.h:3:1:
   224  	X_LITTLE_ENDIAN                      = 1                    // <predefined>:37:1:
   225  	X_LP64                               = 1                    // <predefined>:335:1:
   226  	X_POSIX2_BC_BASE_MAX                 = 99                   // posix2_lim.h:27:1:
   227  	X_POSIX2_BC_DIM_MAX                  = 2048                 // posix2_lim.h:30:1:
   228  	X_POSIX2_BC_SCALE_MAX                = 99                   // posix2_lim.h:33:1:
   229  	X_POSIX2_BC_STRING_MAX               = 1000                 // posix2_lim.h:36:1:
   230  	X_POSIX2_CHARCLASS_NAME_MAX          = 14                   // posix2_lim.h:55:1:
   231  	X_POSIX2_CHAR_TERM                   = 200809               // posix_opt.h:179:1:
   232  	X_POSIX2_COLL_WEIGHTS_MAX            = 2                    // posix2_lim.h:40:1:
   233  	X_POSIX2_C_BIND                      = 200809               // unistd.h:74:1:
   234  	X_POSIX2_C_DEV                       = 200809               // unistd.h:78:1:
   235  	X_POSIX2_C_VERSION                   = 200809               // unistd.h:70:1:
   236  	X_POSIX2_EXPR_NEST_MAX               = 32                   // posix2_lim.h:44:1:
   237  	X_POSIX2_LINE_MAX                    = 2048                 // posix2_lim.h:47:1:
   238  	X_POSIX2_LOCALEDEF                   = 200809               // unistd.h:86:1:
   239  	X_POSIX2_RE_DUP_MAX                  = 255                  // posix2_lim.h:51:1:
   240  	X_POSIX2_SW_DEV                      = 200809               // unistd.h:82:1:
   241  	X_POSIX2_VERSION                     = 200809               // unistd.h:67:1:
   242  	X_POSIX_ADVISORY_INFO                = 200809               // posix_opt.h:170:1:
   243  	X_POSIX_AIO_LISTIO_MAX               = 2                    // posix1_lim.h:32:1:
   244  	X_POSIX_AIO_MAX                      = 1                    // posix1_lim.h:35:1:
   245  	X_POSIX_ARG_MAX                      = 4096                 // posix1_lim.h:38:1:
   246  	X_POSIX_ASYNCHRONOUS_IO              = 200809               // posix_opt.h:109:1:
   247  	X_POSIX_ASYNC_IO                     = 1                    // posix_opt.h:110:1:
   248  	X_POSIX_BARRIERS                     = 200809               // posix_opt.h:155:1:
   249  	X_POSIX_CHILD_MAX                    = 25                   // posix1_lim.h:42:1:
   250  	X_POSIX_CHOWN_RESTRICTED             = 0                    // posix_opt.h:53:1:
   251  	X_POSIX_CLOCKRES_MIN                 = 20000000             // posix1_lim.h:157:1:
   252  	X_POSIX_CLOCK_SELECTION              = 200809               // posix_opt.h:167:1:
   253  	X_POSIX_CPUTIME                      = 0                    // posix_opt.h:128:1:
   254  	X_POSIX_C_SOURCE                     = 200809               // features.h:281:1:
   255  	X_POSIX_DELAYTIMER_MAX               = 32                   // posix1_lim.h:48:1:
   256  	X_POSIX_FSYNC                        = 200809               // posix_opt.h:38:1:
   257  	X_POSIX_HOST_NAME_MAX                = 255                  // posix1_lim.h:52:1:
   258  	X_POSIX_IPV6                         = 200809               // posix_opt.h:173:1:
   259  	X_POSIX_JOB_CONTROL                  = 1                    // posix_opt.h:23:1:
   260  	X_POSIX_LINK_MAX                     = 8                    // posix1_lim.h:55:1:
   261  	X_POSIX_LOGIN_NAME_MAX               = 9                    // posix1_lim.h:58:1:
   262  	X_POSIX_MAPPED_FILES                 = 200809               // posix_opt.h:41:1:
   263  	X_POSIX_MAX_CANON                    = 255                  // posix1_lim.h:61:1:
   264  	X_POSIX_MAX_INPUT                    = 255                  // posix1_lim.h:65:1:
   265  	X_POSIX_MEMLOCK                      = 200809               // posix_opt.h:44:1:
   266  	X_POSIX_MEMLOCK_RANGE                = 200809               // posix_opt.h:47:1:
   267  	X_POSIX_MEMORY_PROTECTION            = 200809               // posix_opt.h:50:1:
   268  	X_POSIX_MESSAGE_PASSING              = 200809               // posix_opt.h:158:1:
   269  	X_POSIX_MONOTONIC_CLOCK              = 0                    // posix_opt.h:164:1:
   270  	X_POSIX_MQ_OPEN_MAX                  = 8                    // posix1_lim.h:68:1:
   271  	X_POSIX_MQ_PRIO_MAX                  = 32                   // posix1_lim.h:71:1:
   272  	X_POSIX_NAME_MAX                     = 14                   // posix1_lim.h:74:1:
   273  	X_POSIX_NGROUPS_MAX                  = 8                    // posix1_lim.h:78:1:
   274  	X_POSIX_NO_TRUNC                     = 1                    // posix_opt.h:60:1:
   275  	X_POSIX_OPEN_MAX                     = 20                   // posix1_lim.h:85:1:
   276  	X_POSIX_PATH_MAX                     = 256                  // posix1_lim.h:97:1:
   277  	X_POSIX_PIPE_BUF                     = 512                  // posix1_lim.h:100:1:
   278  	X_POSIX_PRIORITIZED_IO               = 200809               // posix_opt.h:114:1:
   279  	X_POSIX_PRIORITY_SCHEDULING          = 200809               // posix_opt.h:32:1:
   280  	X_POSIX_RAW_SOCKETS                  = 200809               // posix_opt.h:176:1:
   281  	X_POSIX_READER_WRITER_LOCKS          = 200809               // posix_opt.h:137:1:
   282  	X_POSIX_REALTIME_SIGNALS             = 200809               // posix_opt.h:106:1:
   283  	X_POSIX_REENTRANT_FUNCTIONS          = 1                    // posix_opt.h:75:1:
   284  	X_POSIX_REGEXP                       = 1                    // posix_opt.h:134:1:
   285  	X_POSIX_RE_DUP_MAX                   = 255                  // posix1_lim.h:104:1:
   286  	X_POSIX_RTSIG_MAX                    = 8                    // posix1_lim.h:107:1:
   287  	X_POSIX_SAVED_IDS                    = 1                    // posix_opt.h:26:1:
   288  	X_POSIX_SEMAPHORES                   = 200809               // posix_opt.h:103:1:
   289  	X_POSIX_SEM_NSEMS_MAX                = 256                  // posix1_lim.h:110:1:
   290  	X_POSIX_SEM_VALUE_MAX                = 32767                // posix1_lim.h:113:1:
   291  	X_POSIX_SHARED_MEMORY_OBJECTS        = 200809               // posix_opt.h:125:1:
   292  	X_POSIX_SHELL                        = 1                    // posix_opt.h:140:1:
   293  	X_POSIX_SIGQUEUE_MAX                 = 32                   // posix1_lim.h:116:1:
   294  	X_POSIX_SOURCE                       = 1                    // features.h:279:1:
   295  	X_POSIX_SPAWN                        = 200809               // posix_opt.h:149:1:
   296  	X_POSIX_SPIN_LOCKS                   = 200809               // posix_opt.h:146:1:
   297  	X_POSIX_SPORADIC_SERVER              = -1                   // posix_opt.h:182:1:
   298  	X_POSIX_SSIZE_MAX                    = 32767                // posix1_lim.h:119:1:
   299  	X_POSIX_STREAM_MAX                   = 8                    // posix1_lim.h:122:1:
   300  	X_POSIX_SYMLINK_MAX                  = 255                  // posix1_lim.h:125:1:
   301  	X_POSIX_SYMLOOP_MAX                  = 8                    // posix1_lim.h:129:1:
   302  	X_POSIX_SYNCHRONIZED_IO              = 200809               // posix_opt.h:35:1:
   303  	X_POSIX_THREADS                      = 200809               // posix_opt.h:72:1:
   304  	X_POSIX_THREAD_ATTR_STACKADDR        = 200809               // posix_opt.h:85:1:
   305  	X_POSIX_THREAD_ATTR_STACKSIZE        = 200809               // posix_opt.h:82:1:
   306  	X_POSIX_THREAD_CPUTIME               = 0                    // posix_opt.h:131:1:
   307  	X_POSIX_THREAD_DESTRUCTOR_ITERATIONS = 4                    // local_lim.h:67:1:
   308  	X_POSIX_THREAD_KEYS_MAX              = 128                  // local_lim.h:62:1:
   309  	X_POSIX_THREAD_PRIORITY_SCHEDULING   = 200809               // posix_opt.h:79:1:
   310  	X_POSIX_THREAD_PRIO_INHERIT          = 200809               // posix_opt.h:88:1:
   311  	X_POSIX_THREAD_PRIO_PROTECT          = 200809               // posix_opt.h:92:1:
   312  	X_POSIX_THREAD_PROCESS_SHARED        = 200809               // posix_opt.h:161:1:
   313  	X_POSIX_THREAD_ROBUST_PRIO_INHERIT   = 200809               // posix_opt.h:96:1:
   314  	X_POSIX_THREAD_ROBUST_PRIO_PROTECT   = -1                   // posix_opt.h:99:1:
   315  	X_POSIX_THREAD_SAFE_FUNCTIONS        = 200809               // posix_opt.h:76:1:
   316  	X_POSIX_THREAD_SPORADIC_SERVER       = -1                   // posix_opt.h:183:1:
   317  	X_POSIX_THREAD_THREADS_MAX           = 64                   // local_lim.h:72:1:
   318  	X_POSIX_TIMEOUTS                     = 200809               // posix_opt.h:143:1:
   319  	X_POSIX_TIMERS                       = 200809               // posix_opt.h:152:1:
   320  	X_POSIX_TIMER_MAX                    = 32                   // posix1_lim.h:132:1:
   321  	X_POSIX_TRACE                        = -1                   // posix_opt.h:186:1:
   322  	X_POSIX_TRACE_EVENT_FILTER           = -1                   // posix_opt.h:187:1:
   323  	X_POSIX_TRACE_INHERIT                = -1                   // posix_opt.h:188:1:
   324  	X_POSIX_TRACE_LOG                    = -1                   // posix_opt.h:189:1:
   325  	X_POSIX_TTY_NAME_MAX                 = 9                    // posix1_lim.h:135:1:
   326  	X_POSIX_TYPED_MEMORY_OBJECTS         = -1                   // posix_opt.h:192:1:
   327  	X_POSIX_TZNAME_MAX                   = 6                    // posix1_lim.h:139:1:
   328  	X_POSIX_V6_LP64_OFF64                = 1                    // environments.h:62:1:
   329  	X_POSIX_V6_LPBIG_OFFBIG              = -1                   // environments.h:57:1:
   330  	X_POSIX_V7_LP64_OFF64                = 1                    // environments.h:61:1:
   331  	X_POSIX_V7_LPBIG_OFFBIG              = -1                   // environments.h:56:1:
   332  	X_POSIX_VDISABLE                     = 0                    // posix_opt.h:57:1:
   333  	X_POSIX_VERSION                      = 200809               // unistd.h:34:1:
   334  	X_PTRDIFF_T                          = 0                    // stddef.h:131:1:
   335  	X_PTRDIFF_T_                         = 0                    // stddef.h:135:1:
   336  	X_PTRDIFF_T_DECLARED                 = 0                    // stddef.h:139:1:
   337  	X_RWLOCK_INTERNAL_H                  = 0                    // struct_rwlock.h:21:1:
   338  	X_SIZET_                             = 0                    // stddef.h:196:1:
   339  	X_SIZE_T                             = 0                    // stddef.h:183:1:
   340  	X_SIZE_T_                            = 0                    // stddef.h:188:1:
   341  	X_SIZE_T_DECLARED                    = 0                    // stddef.h:193:1:
   342  	X_SIZE_T_DEFINED                     = 0                    // stddef.h:191:1:
   343  	X_SIZE_T_DEFINED_                    = 0                    // stddef.h:190:1:
   344  	X_STDARG_H                           = 0                    // stdarg.h:31:1:
   345  	X_STDC_PREDEF_H                      = 1                    // <predefined>:203:1:
   346  	X_STDDEF_H                           = 0                    // stddef.h:39:1:
   347  	X_STDDEF_H_                          = 0                    // stddef.h:40:1:
   348  	X_STDLIB_H                           = 1                    // stdlib.h:35:1:
   349  	X_STRINGS_H                          = 1                    // strings.h:19:1:
   350  	X_STRING_H                           = 1                    // string.h:23:1:
   351  	X_STRUCT_TIMESPEC                    = 1                    // struct_timespec.h:3:1:
   352  	X_SYS_CDEFS_H                        = 1                    // cdefs.h:19:1:
   353  	X_SYS_SELECT_H                       = 1                    // select.h:22:1:
   354  	X_SYS_SIZE_T_H                       = 0                    // stddef.h:184:1:
   355  	X_SYS_TYPES_H                        = 1                    // types.h:23:1:
   356  	X_THREAD_MUTEX_INTERNAL_H            = 1                    // struct_mutex.h:20:1:
   357  	X_THREAD_SHARED_TYPES_H              = 1                    // thread-shared-types.h:20:1:
   358  	X_T_PTRDIFF                          = 0                    // stddef.h:133:1:
   359  	X_T_PTRDIFF_                         = 0                    // stddef.h:132:1:
   360  	X_T_SIZE                             = 0                    // stddef.h:186:1:
   361  	X_T_SIZE_                            = 0                    // stddef.h:185:1:
   362  	X_T_WCHAR                            = 0                    // stddef.h:264:1:
   363  	X_T_WCHAR_                           = 0                    // stddef.h:263:1:
   364  	X_UNISTD_H                           = 1                    // unistd.h:23:1:
   365  	X_VA_LIST                            = 0                    // stdarg.h:108:1:
   366  	X_VA_LIST_                           = 0                    // stdarg.h:105:1:
   367  	X_VA_LIST_DEFINED                    = 0                    // stdarg.h:111:1:
   368  	X_VA_LIST_T_H                        = 0                    // stdarg.h:114:1:
   369  	X_WCHAR_T                            = 0                    // stddef.h:262:1:
   370  	X_WCHAR_T_                           = 0                    // stddef.h:266:1:
   371  	X_WCHAR_T_DECLARED                   = 0                    // stddef.h:274:1:
   372  	X_WCHAR_T_DEFINED                    = 0                    // stddef.h:269:1:
   373  	X_WCHAR_T_DEFINED_                   = 0                    // stddef.h:268:1:
   374  	X_WCHAR_T_H                          = 0                    // stddef.h:270:1:
   375  	X_XBS5_LP64_OFF64                    = 1                    // environments.h:63:1:
   376  	X_XBS5_LPBIG_OFFBIG                  = -1                   // environments.h:58:1:
   377  	X_XOPEN_ENH_I18N                     = 1                    // unistd.h:112:1:
   378  	X_XOPEN_LEGACY                       = 1                    // unistd.h:115:1:
   379  	X_XOPEN_REALTIME                     = 1                    // posix_opt.h:63:1:
   380  	X_XOPEN_REALTIME_THREADS             = 1                    // posix_opt.h:66:1:
   381  	X_XOPEN_SHM                          = 1                    // posix_opt.h:69:1:
   382  	X_XOPEN_UNIX                         = 1                    // unistd.h:108:1:
   383  	X_XOPEN_VERSION                      = 700                  // unistd.h:90:1:
   384  	X_XOPEN_XCU_VERSION                  = 4                    // unistd.h:100:1:
   385  	X_XOPEN_XPG2                         = 1                    // unistd.h:103:1:
   386  	X_XOPEN_XPG3                         = 1                    // unistd.h:104:1:
   387  	X_XOPEN_XPG4                         = 1                    // unistd.h:105:1:
   388  	Linux                                = 1                    // <predefined>:263:1:
   389  	Unix                                 = 1                    // <predefined>:222:1:
   390  	Z_const                              = 0                    // zconf.h:237:1:
   391  	BYFOUR                               = 0                    // crc32.c:35:1:
   392  	GF2_DIM                              = 32                   // crc32.c:341:1:
   393  	TBLS                                 = 8                    // crc32.c:42:1:
   394  	BL_CODES                             = 19                   // deflate.h:42:1:
   395  	BUSY_STATE                           = 113                  // deflate.h:62:1:
   396  	Buf_size                             = 16                   // deflate.h:51:1:
   397  	COMMENT_STATE                        = 91                   // deflate.h:60:1:
   398  	DEFLATE_H                            = 0                    // deflate.h:14:1:
   399  	D_CODES                              = 30                   // deflate.h:39:1:
   400  	EXTRA_STATE                          = 69                   // deflate.h:58:1:
   401  	FINISH_STATE                         = 666                  // deflate.h:63:1:
   402  	GZIP                                 = 0                    // deflate.h:23:1:
   403  	GZIP_STATE                           = 57                   // deflate.h:56:1:
   404  	HCRC_STATE                           = 103                  // deflate.h:61:1:
   405  	HEAP_SIZE                            = 573                  // deflate.h:45:1:
   406  	INIT_STATE                           = 42                   // deflate.h:54:1:
   407  	LENGTH_CODES                         = 29                   // deflate.h:30:1:
   408  	LITERALS                             = 256                  // deflate.h:33:1:
   409  	L_CODES                              = 286                  // deflate.h:36:1:
   410  	MAX_BITS                             = 15                   // deflate.h:48:1:
   411  	MAX_STORED                           = 65535                // deflate.c:1623:1:
   412  	MIN_LOOKAHEAD                        = 262                  // deflate.h:284:1:
   413  	NAME_STATE                           = 73                   // deflate.h:59:1:
   414  	NIL                                  = 0                    // deflate.c:107:1:
   415  	TOO_FAR                              = 4096                 // deflate.c:111:1:
   416  	WIN_INIT                             = 258                  // deflate.h:294:1:
   417  	AT_EACCESS                           = 0x200                // fcntl-linux.h:388:1:
   418  	AT_FDCWD                             = -100                 // fcntl-linux.h:371:1:
   419  	AT_REMOVEDIR                         = 0x200                // fcntl-linux.h:375:1:
   420  	AT_SYMLINK_FOLLOW                    = 0x400                // fcntl-linux.h:377:1:
   421  	AT_SYMLINK_NOFOLLOW                  = 0x100                // fcntl-linux.h:374:1:
   422  	BUFSIZ                               = 8192                 // stdio.h:99:1:
   423  	COPY1                                = 1                    // gzguts.h:166:1:
   424  	E2BIG                                = 7                    // errno-base.h:11:1:
   425  	EACCES                               = 13                   // errno-base.h:17:1:
   426  	EADDRINUSE                           = 98                   // errno.h:81:1:
   427  	EADDRNOTAVAIL                        = 99                   // errno.h:82:1:
   428  	EADV                                 = 68                   // errno.h:51:1:
   429  	EAFNOSUPPORT                         = 97                   // errno.h:80:1:
   430  	EAGAIN                               = 11                   // errno-base.h:15:1:
   431  	EALREADY                             = 114                  // errno.h:97:1:
   432  	EBADE                                = 52                   // errno.h:33:1:
   433  	EBADF                                = 9                    // errno-base.h:13:1:
   434  	EBADFD                               = 77                   // errno.h:60:1:
   435  	EBADMSG                              = 74                   // errno.h:57:1:
   436  	EBADR                                = 53                   // errno.h:34:1:
   437  	EBADRQC                              = 56                   // errno.h:37:1:
   438  	EBADSLT                              = 57                   // errno.h:38:1:
   439  	EBFONT                               = 59                   // errno.h:42:1:
   440  	EBUSY                                = 16                   // errno-base.h:20:1:
   441  	ECANCELED                            = 125                  // errno.h:109:1:
   442  	ECHILD                               = 10                   // errno-base.h:14:1:
   443  	ECHRNG                               = 44                   // errno.h:25:1:
   444  	ECOMM                                = 70                   // errno.h:53:1:
   445  	ECONNABORTED                         = 103                  // errno.h:86:1:
   446  	ECONNREFUSED                         = 111                  // errno.h:94:1:
   447  	ECONNRESET                           = 104                  // errno.h:87:1:
   448  	EDEADLK                              = 35                   // errno.h:7:1:
   449  	EDEADLOCK                            = 58                   // errno.h:9:1:
   450  	EDESTADDRREQ                         = 89                   // errno.h:72:1:
   451  	EDOM                                 = 33                   // errno-base.h:37:1:
   452  	EDOTDOT                              = 73                   // errno.h:56:1:
   453  	EDQUOT                               = 122                  // errno.h:105:1:
   454  	EEXIST                               = 17                   // errno-base.h:21:1:
   455  	EFAULT                               = 14                   // errno-base.h:18:1:
   456  	EFBIG                                = 27                   // errno-base.h:31:1:
   457  	EHOSTDOWN                            = 112                  // errno.h:95:1:
   458  	EHOSTUNREACH                         = 113                  // errno.h:96:1:
   459  	EHWPOISON                            = 133                  // errno.h:121:1:
   460  	EIDRM                                = 43                   // errno.h:24:1:
   461  	EILSEQ                               = 84                   // errno.h:67:1:
   462  	EINPROGRESS                          = 115                  // errno.h:98:1:
   463  	EINTR                                = 4                    // errno-base.h:8:1:
   464  	EINVAL                               = 22                   // errno-base.h:26:1:
   465  	EIO                                  = 5                    // errno-base.h:9:1:
   466  	EISCONN                              = 106                  // errno.h:89:1:
   467  	EISDIR                               = 21                   // errno-base.h:25:1:
   468  	EISNAM                               = 120                  // errno.h:103:1:
   469  	EKEYEXPIRED                          = 127                  // errno.h:111:1:
   470  	EKEYREJECTED                         = 129                  // errno.h:113:1:
   471  	EKEYREVOKED                          = 128                  // errno.h:112:1:
   472  	EL2HLT                               = 51                   // errno.h:32:1:
   473  	EL2NSYNC                             = 45                   // errno.h:26:1:
   474  	EL3HLT                               = 46                   // errno.h:27:1:
   475  	EL3RST                               = 47                   // errno.h:28:1:
   476  	ELIBACC                              = 79                   // errno.h:62:1:
   477  	ELIBBAD                              = 80                   // errno.h:63:1:
   478  	ELIBEXEC                             = 83                   // errno.h:66:1:
   479  	ELIBMAX                              = 82                   // errno.h:65:1:
   480  	ELIBSCN                              = 81                   // errno.h:64:1:
   481  	ELNRNG                               = 48                   // errno.h:29:1:
   482  	ELOOP                                = 40                   // errno.h:21:1:
   483  	EMEDIUMTYPE                          = 124                  // errno.h:108:1:
   484  	EMFILE                               = 24                   // errno-base.h:28:1:
   485  	EMLINK                               = 31                   // errno-base.h:35:1:
   486  	EMSGSIZE                             = 90                   // errno.h:73:1:
   487  	EMULTIHOP                            = 72                   // errno.h:55:1:
   488  	ENAMETOOLONG                         = 36                   // errno.h:8:1:
   489  	ENAVAIL                              = 119                  // errno.h:102:1:
   490  	ENETDOWN                             = 100                  // errno.h:83:1:
   491  	ENETRESET                            = 102                  // errno.h:85:1:
   492  	ENETUNREACH                          = 101                  // errno.h:84:1:
   493  	ENFILE                               = 23                   // errno-base.h:27:1:
   494  	ENOANO                               = 55                   // errno.h:36:1:
   495  	ENOBUFS                              = 105                  // errno.h:88:1:
   496  	ENOCSI                               = 50                   // errno.h:31:1:
   497  	ENODATA                              = 61                   // errno.h:44:1:
   498  	ENODEV                               = 19                   // errno-base.h:23:1:
   499  	ENOENT                               = 2                    // errno-base.h:6:1:
   500  	ENOEXEC                              = 8                    // errno-base.h:12:1:
   501  	ENOKEY                               = 126                  // errno.h:110:1:
   502  	ENOLCK                               = 37                   // errno.h:9:1:
   503  	ENOLINK                              = 67                   // errno.h:50:1:
   504  	ENOMEDIUM                            = 123                  // errno.h:107:1:
   505  	ENOMEM                               = 12                   // errno-base.h:16:1:
   506  	ENOMSG                               = 42                   // errno.h:23:1:
   507  	ENONET                               = 64                   // errno.h:47:1:
   508  	ENOPKG                               = 65                   // errno.h:48:1:
   509  	ENOPROTOOPT                          = 92                   // errno.h:75:1:
   510  	ENOSPC                               = 28                   // errno-base.h:32:1:
   511  	ENOSR                                = 63                   // errno.h:46:1:
   512  	ENOSTR                               = 60                   // errno.h:43:1:
   513  	ENOSYS                               = 38                   // errno.h:18:1:
   514  	ENOTBLK                              = 15                   // errno-base.h:19:1:
   515  	ENOTCONN                             = 107                  // errno.h:90:1:
   516  	ENOTDIR                              = 20                   // errno-base.h:24:1:
   517  	ENOTEMPTY                            = 39                   // errno.h:20:1:
   518  	ENOTNAM                              = 118                  // errno.h:101:1:
   519  	ENOTRECOVERABLE                      = 131                  // errno.h:117:1:
   520  	ENOTSOCK                             = 88                   // errno.h:71:1:
   521  	ENOTSUP                              = 95                   // errno.h:30:1:
   522  	ENOTTY                               = 25                   // errno-base.h:29:1:
   523  	ENOTUNIQ                             = 76                   // errno.h:59:1:
   524  	ENXIO                                = 6                    // errno-base.h:10:1:
   525  	EOF                                  = -1                   // stdio.h:104:1:
   526  	EOPNOTSUPP                           = 95                   // errno.h:78:1:
   527  	EOVERFLOW                            = 75                   // errno.h:58:1:
   528  	EOWNERDEAD                           = 130                  // errno.h:116:1:
   529  	EPERM                                = 1                    // errno-base.h:5:1:
   530  	EPFNOSUPPORT                         = 96                   // errno.h:79:1:
   531  	EPIPE                                = 32                   // errno-base.h:36:1:
   532  	EPROTO                               = 71                   // errno.h:54:1:
   533  	EPROTONOSUPPORT                      = 93                   // errno.h:76:1:
   534  	EPROTOTYPE                           = 91                   // errno.h:74:1:
   535  	ERANGE                               = 34                   // errno-base.h:38:1:
   536  	EREMCHG                              = 78                   // errno.h:61:1:
   537  	EREMOTE                              = 66                   // errno.h:49:1:
   538  	EREMOTEIO                            = 121                  // errno.h:104:1:
   539  	ERESTART                             = 85                   // errno.h:68:1:
   540  	ERFKILL                              = 132                  // errno.h:119:1:
   541  	EROFS                                = 30                   // errno-base.h:34:1:
   542  	ESHUTDOWN                            = 108                  // errno.h:91:1:
   543  	ESOCKTNOSUPPORT                      = 94                   // errno.h:77:1:
   544  	ESPIPE                               = 29                   // errno-base.h:33:1:
   545  	ESRCH                                = 3                    // errno-base.h:7:1:
   546  	ESRMNT                               = 69                   // errno.h:52:1:
   547  	ESTALE                               = 116                  // errno.h:99:1:
   548  	ESTRPIPE                             = 86                   // errno.h:69:1:
   549  	ETIME                                = 62                   // errno.h:45:1:
   550  	ETIMEDOUT                            = 110                  // errno.h:93:1:
   551  	ETOOMANYREFS                         = 109                  // errno.h:92:1:
   552  	ETXTBSY                              = 26                   // errno-base.h:30:1:
   553  	EUCLEAN                              = 117                  // errno.h:100:1:
   554  	EUNATCH                              = 49                   // errno.h:30:1:
   555  	EUSERS                               = 87                   // errno.h:70:1:
   556  	EWOULDBLOCK                          = 11                   // errno.h:22:1:
   557  	EXDEV                                = 18                   // errno-base.h:22:1:
   558  	EXFULL                               = 54                   // errno.h:35:1:
   559  	FAPPEND                              = 1024                 // fcntl-linux.h:304:1:
   560  	FASYNC                               = 8192                 // fcntl-linux.h:306:1:
   561  	FD_CLOEXEC                           = 1                    // fcntl-linux.h:219:1:
   562  	FFSYNC                               = 1052672              // fcntl-linux.h:305:1:
   563  	FILENAME_MAX                         = 4096                 // stdio_lim.h:27:1:
   564  	FNDELAY                              = 2048                 // fcntl-linux.h:308:1:
   565  	FNONBLOCK                            = 2048                 // fcntl-linux.h:307:1:
   566  	FOPEN_MAX                            = 16                   // stdio_lim.h:37:1:
   567  	F_DUPFD                              = 0                    // fcntl-linux.h:167:1:
   568  	F_DUPFD_CLOEXEC                      = 1030                 // fcntl-linux.h:214:1:
   569  	F_EXLCK                              = 4                    // fcntl-linux.h:231:1:
   570  	F_GETFD                              = 1                    // fcntl-linux.h:168:1:
   571  	F_GETFL                              = 3                    // fcntl-linux.h:170:1:
   572  	F_GETLK                              = 5                    // fcntl-linux.h:105:1:
   573  	F_GETLK64                            = 12                   // fcntl-linux.h:115:1:
   574  	F_GETOWN                             = 9                    // fcntl-linux.h:180:1:
   575  	F_RDLCK                              = 0                    // fcntl-linux.h:223:1:
   576  	F_SETFD                              = 2                    // fcntl-linux.h:169:1:
   577  	F_SETFL                              = 4                    // fcntl-linux.h:171:1:
   578  	F_SETLK                              = 6                    // fcntl-linux.h:106:1:
   579  	F_SETLK64                            = 13                   // fcntl-linux.h:116:1:
   580  	F_SETLKW                             = 7                    // fcntl-linux.h:107:1:
   581  	F_SETLKW64                           = 14                   // fcntl-linux.h:117:1:
   582  	F_SETOWN                             = 8                    // fcntl-linux.h:179:1:
   583  	F_SHLCK                              = 8                    // fcntl-linux.h:232:1:
   584  	F_UNLCK                              = 2                    // fcntl-linux.h:225:1:
   585  	F_WRLCK                              = 1                    // fcntl-linux.h:224:1:
   586  	GZBUFSIZE                            = 8192                 // gzguts.h:156:1:
   587  	GZ_APPEND                            = 1                    // gzguts.h:162:1:
   588  	GZ_NONE                              = 0                    // gzguts.h:159:1:
   589  	GZ_READ                              = 7247                 // gzguts.h:160:1:
   590  	GZ_WRITE                             = 31153                // gzguts.h:161:1:
   591  	HAVE_VSNPRINTF                       = 0                    // gzguts.h:59:1:
   592  	LOCK_EX                              = 2                    // fcntl-linux.h:238:1:
   593  	LOCK_NB                              = 4                    // fcntl-linux.h:239:1:
   594  	LOCK_SH                              = 1                    // fcntl-linux.h:237:1:
   595  	LOCK_UN                              = 8                    // fcntl-linux.h:241:1:
   596  	LOOK                                 = 0                    // gzguts.h:165:1:
   597  	L_ctermid                            = 9                    // stdio_lim.h:30:1:
   598  	L_tmpnam                             = 20                   // stdio_lim.h:25:1:
   599  	O_ACCMODE                            = 0003                 // fcntl-linux.h:42:1:
   600  	O_APPEND                             = 02000                // fcntl-linux.h:59:1:
   601  	O_ASYNC                              = 020000               // fcntl-linux.h:72:1:
   602  	O_CLOEXEC                            = 524288               // fcntl-linux.h:144:1:
   603  	O_CREAT                              = 0100                 // fcntl-linux.h:47:1:
   604  	O_DIRECTORY                          = 16384                // fcntl-linux.h:142:1:
   605  	O_DSYNC                              = 4096                 // fcntl-linux.h:158:1:
   606  	O_EXCL                               = 0200                 // fcntl-linux.h:50:1:
   607  	O_FSYNC                              = 1052672              // fcntl-linux.h:70:1:
   608  	O_LARGEFILE                          = 0                    // fcntl-linux.h:138:1:
   609  	O_NDELAY                             = 2048                 // fcntl-linux.h:65:1:
   610  	O_NOCTTY                             = 0400                 // fcntl-linux.h:53:1:
   611  	O_NOFOLLOW                           = 32768                // fcntl-linux.h:143:1:
   612  	O_NONBLOCK                           = 04000                // fcntl-linux.h:62:1:
   613  	O_RDONLY                             = 00                   // fcntl-linux.h:43:1:
   614  	O_RDWR                               = 02                   // fcntl-linux.h:45:1:
   615  	O_RSYNC                              = 1052672              // fcntl-linux.h:162:1:
   616  	O_SYNC                               = 04010000             // fcntl-linux.h:68:1:
   617  	O_TRUNC                              = 01000                // fcntl-linux.h:56:1:
   618  	O_WRONLY                             = 01                   // fcntl-linux.h:44:1:
   619  	POSIX_FADV_DONTNEED                  = 4                    // fcntl-linux.h:321:1:
   620  	POSIX_FADV_NOREUSE                   = 5                    // fcntl-linux.h:322:1:
   621  	POSIX_FADV_NORMAL                    = 0                    // fcntl-linux.h:317:1:
   622  	POSIX_FADV_RANDOM                    = 1                    // fcntl-linux.h:318:1:
   623  	POSIX_FADV_SEQUENTIAL                = 2                    // fcntl-linux.h:319:1:
   624  	POSIX_FADV_WILLNEED                  = 3                    // fcntl-linux.h:320:1:
   625  	P_tmpdir                             = "/tmp"               // stdio.h:120:1:
   626  	S_IFBLK                              = 24576                // fcntl.h:83:1:
   627  	S_IFCHR                              = 8192                 // fcntl.h:82:1:
   628  	S_IFDIR                              = 16384                // fcntl.h:81:1:
   629  	S_IFIFO                              = 4096                 // fcntl.h:86:1:
   630  	S_IFLNK                              = 40960                // fcntl.h:89:1:
   631  	S_IFMT                               = 61440                // fcntl.h:80:1:
   632  	S_IFREG                              = 32768                // fcntl.h:84:1:
   633  	S_IFSOCK                             = 49152                // fcntl.h:92:1:
   634  	S_IRGRP                              = 32                   // fcntl.h:111:1:
   635  	S_IROTH                              = 4                    // fcntl.h:117:1:
   636  	S_IRUSR                              = 256                  // fcntl.h:105:1:
   637  	S_IRWXG                              = 56                   // fcntl.h:115:1:
   638  	S_IRWXO                              = 7                    // fcntl.h:121:1:
   639  	S_IRWXU                              = 448                  // fcntl.h:109:1:
   640  	S_ISGID                              = 1024                 // fcntl.h:98:1:
   641  	S_ISUID                              = 2048                 // fcntl.h:97:1:
   642  	S_ISVTX                              = 512                  // fcntl.h:102:1:
   643  	S_IWGRP                              = 16                   // fcntl.h:112:1:
   644  	S_IWOTH                              = 2                    // fcntl.h:118:1:
   645  	S_IWUSR                              = 128                  // fcntl.h:106:1:
   646  	S_IXGRP                              = 8                    // fcntl.h:113:1:
   647  	S_IXOTH                              = 1                    // fcntl.h:119:1:
   648  	S_IXUSR                              = 64                   // fcntl.h:107:1:
   649  	TMP_MAX                              = 238328               // stdio_lim.h:26:1:
   650  	UTIME_NOW                            = 1073741823           // stat.h:271:1:
   651  	UTIME_OMIT                           = 1073741822           // stat.h:272:1:
   652  	X_ASM_GENERIC_ERRNO_BASE_H           = 0                    // errno-base.h:3:1:
   653  	X_ASM_GENERIC_ERRNO_H                = 0                    // errno.h:3:1:
   654  	X_ASM_POWERPC_ERRNO_H                = 0                    // errno.h:3:1:
   655  	X_BITS_ERRNO_H                       = 1                    // errno.h:20:1:
   656  	X_BITS_STAT_H                        = 1                    // stat.h:23:1:
   657  	X_BITS_STDIO_LIM_H                   = 1                    // stdio_lim.h:19:1:
   658  	X_ERRNO_H                            = 1                    // errno.h:23:1:
   659  	X_FCNTL_H                            = 1                    // fcntl.h:23:1:
   660  	X_IOFBF                              = 0                    // stdio.h:93:1:
   661  	X_IOLBF                              = 1                    // stdio.h:94:1:
   662  	X_IONBF                              = 2                    // stdio.h:95:1:
   663  	X_IO_EOF_SEEN                        = 0x0010               // struct_FILE.h:111:1:
   664  	X_IO_ERR_SEEN                        = 0x0020               // struct_FILE.h:114:1:
   665  	X_IO_USER_LOCK                       = 0x8000               // struct_FILE.h:117:1:
   666  	X_LARGEFILE_SOURCE                   = 1                    // gzguts.h:8:1:
   667  	X_MKNOD_VER                          = 1                    // stat.h:41:1:
   668  	X_MKNOD_VER_LINUX                    = 1                    // stat.h:39:1:
   669  	X_MKNOD_VER_SVR4                     = 2                    // stat.h:40:1:
   670  	X_STATBUF_ST_BLKSIZE                 = 0                    // stat.h:237:1:
   671  	X_STATBUF_ST_NSEC                    = 0                    // stat.h:240:1:
   672  	X_STATBUF_ST_RDEV                    = 0                    // stat.h:238:1:
   673  	X_STAT_VER                           = 1                    // stat.h:35:1:
   674  	X_STAT_VER_KERNEL                    = 1                    // stat.h:29:1:
   675  	X_STAT_VER_LINUX                     = 3                    // stat.h:31:1:
   676  	X_STAT_VER_LINUX_OLD                 = 1                    // stat.h:28:1:
   677  	X_STAT_VER_SVR4                      = 2                    // stat.h:30:1:
   678  	X_STDIO_H                            = 1                    // stdio.h:24:1:
   679  	ENOUGH                               = 1444                 // inftrees.h:51:1:
   680  	ENOUGH_DISTS                         = 592                  // inftrees.h:50:1:
   681  	ENOUGH_LENS                          = 852                  // inftrees.h:49:1:
   682  	GUNZIP                               = 0                    // inflate.h:16:1:
   683  	MAXBITS                              = 15                   // inftrees.c:9:1:
   684  	DIST_CODE_LEN                        = 512                  // trees.c:81:1:
   685  	END_BLOCK                            = 256                  // trees.c:50:1:
   686  	MAX_BL_BITS                          = 7                    // trees.c:47:1:
   687  	REPZ_11_138                          = 18                   // trees.c:59:1:
   688  	REPZ_3_10                            = 17                   // trees.c:56:1:
   689  	REP_3_6                              = 16                   // trees.c:53:1:
   690  	SMALLEST                             = 1                    // trees.c:422:1:
   691  )
   692  
   693  // Get the `_PC_*' symbols for the NAME argument to `pathconf' and `fpathconf';
   694  //    the `_SC_*' symbols for the NAME argument to `sysconf';
   695  //    and the `_CS_*' symbols for the NAME argument to `confstr'.
   696  // `sysconf', `pathconf', and `confstr' NAME values.  Generic version.
   697  //    Copyright (C) 1993-2020 Free Software Foundation, Inc.
   698  //    This file is part of the GNU C Library.
   699  //
   700  //    The GNU C Library is free software; you can redistribute it and/or
   701  //    modify it under the terms of the GNU Lesser General Public
   702  //    License as published by the Free Software Foundation; either
   703  //    version 2.1 of the License, or (at your option) any later version.
   704  //
   705  //    The GNU C Library is distributed in the hope that it will be useful,
   706  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
   707  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   708  //    Lesser General Public License for more details.
   709  //
   710  //    You should have received a copy of the GNU Lesser General Public
   711  //    License along with the GNU C Library; if not, see
   712  //    <https://www.gnu.org/licenses/>.
   713  
   714  // Values for the NAME argument to `pathconf' and `fpathconf'.
   715  const ( /* confname.h:24:1: */
   716  	X_PC_LINK_MAX           = 0
   717  	X_PC_MAX_CANON          = 1
   718  	X_PC_MAX_INPUT          = 2
   719  	X_PC_NAME_MAX           = 3
   720  	X_PC_PATH_MAX           = 4
   721  	X_PC_PIPE_BUF           = 5
   722  	X_PC_CHOWN_RESTRICTED   = 6
   723  	X_PC_NO_TRUNC           = 7
   724  	X_PC_VDISABLE           = 8
   725  	X_PC_SYNC_IO            = 9
   726  	X_PC_ASYNC_IO           = 10
   727  	X_PC_PRIO_IO            = 11
   728  	X_PC_SOCK_MAXBUF        = 12
   729  	X_PC_FILESIZEBITS       = 13
   730  	X_PC_REC_INCR_XFER_SIZE = 14
   731  	X_PC_REC_MAX_XFER_SIZE  = 15
   732  	X_PC_REC_MIN_XFER_SIZE  = 16
   733  	X_PC_REC_XFER_ALIGN     = 17
   734  	X_PC_ALLOC_SIZE_MIN     = 18
   735  	X_PC_SYMLINK_MAX        = 19
   736  	X_PC_2_SYMLINKS         = 20
   737  )
   738  
   739  // Values for the NAME argument to `confstr'.
   740  const ( /* confname.h:533:1: */
   741  	X_CS_PATH = 0 // The default search path.
   742  
   743  	X_CS_V6_WIDTH_RESTRICTED_ENVS = 1
   744  
   745  	X_CS_GNU_LIBC_VERSION       = 2
   746  	X_CS_GNU_LIBPTHREAD_VERSION = 3
   747  
   748  	X_CS_V5_WIDTH_RESTRICTED_ENVS = 4
   749  
   750  	X_CS_V7_WIDTH_RESTRICTED_ENVS = 5
   751  
   752  	X_CS_LFS_CFLAGS      = 1000
   753  	X_CS_LFS_LDFLAGS     = 1001
   754  	X_CS_LFS_LIBS        = 1002
   755  	X_CS_LFS_LINTFLAGS   = 1003
   756  	X_CS_LFS64_CFLAGS    = 1004
   757  	X_CS_LFS64_LDFLAGS   = 1005
   758  	X_CS_LFS64_LIBS      = 1006
   759  	X_CS_LFS64_LINTFLAGS = 1007
   760  
   761  	X_CS_XBS5_ILP32_OFF32_CFLAGS     = 1100
   762  	X_CS_XBS5_ILP32_OFF32_LDFLAGS    = 1101
   763  	X_CS_XBS5_ILP32_OFF32_LIBS       = 1102
   764  	X_CS_XBS5_ILP32_OFF32_LINTFLAGS  = 1103
   765  	X_CS_XBS5_ILP32_OFFBIG_CFLAGS    = 1104
   766  	X_CS_XBS5_ILP32_OFFBIG_LDFLAGS   = 1105
   767  	X_CS_XBS5_ILP32_OFFBIG_LIBS      = 1106
   768  	X_CS_XBS5_ILP32_OFFBIG_LINTFLAGS = 1107
   769  	X_CS_XBS5_LP64_OFF64_CFLAGS      = 1108
   770  	X_CS_XBS5_LP64_OFF64_LDFLAGS     = 1109
   771  	X_CS_XBS5_LP64_OFF64_LIBS        = 1110
   772  	X_CS_XBS5_LP64_OFF64_LINTFLAGS   = 1111
   773  	X_CS_XBS5_LPBIG_OFFBIG_CFLAGS    = 1112
   774  	X_CS_XBS5_LPBIG_OFFBIG_LDFLAGS   = 1113
   775  	X_CS_XBS5_LPBIG_OFFBIG_LIBS      = 1114
   776  	X_CS_XBS5_LPBIG_OFFBIG_LINTFLAGS = 1115
   777  
   778  	X_CS_POSIX_V6_ILP32_OFF32_CFLAGS     = 1116
   779  	X_CS_POSIX_V6_ILP32_OFF32_LDFLAGS    = 1117
   780  	X_CS_POSIX_V6_ILP32_OFF32_LIBS       = 1118
   781  	X_CS_POSIX_V6_ILP32_OFF32_LINTFLAGS  = 1119
   782  	X_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS    = 1120
   783  	X_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS   = 1121
   784  	X_CS_POSIX_V6_ILP32_OFFBIG_LIBS      = 1122
   785  	X_CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS = 1123
   786  	X_CS_POSIX_V6_LP64_OFF64_CFLAGS      = 1124
   787  	X_CS_POSIX_V6_LP64_OFF64_LDFLAGS     = 1125
   788  	X_CS_POSIX_V6_LP64_OFF64_LIBS        = 1126
   789  	X_CS_POSIX_V6_LP64_OFF64_LINTFLAGS   = 1127
   790  	X_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS    = 1128
   791  	X_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS   = 1129
   792  	X_CS_POSIX_V6_LPBIG_OFFBIG_LIBS      = 1130
   793  	X_CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS = 1131
   794  
   795  	X_CS_POSIX_V7_ILP32_OFF32_CFLAGS     = 1132
   796  	X_CS_POSIX_V7_ILP32_OFF32_LDFLAGS    = 1133
   797  	X_CS_POSIX_V7_ILP32_OFF32_LIBS       = 1134
   798  	X_CS_POSIX_V7_ILP32_OFF32_LINTFLAGS  = 1135
   799  	X_CS_POSIX_V7_ILP32_OFFBIG_CFLAGS    = 1136
   800  	X_CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS   = 1137
   801  	X_CS_POSIX_V7_ILP32_OFFBIG_LIBS      = 1138
   802  	X_CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS = 1139
   803  	X_CS_POSIX_V7_LP64_OFF64_CFLAGS      = 1140
   804  	X_CS_POSIX_V7_LP64_OFF64_LDFLAGS     = 1141
   805  	X_CS_POSIX_V7_LP64_OFF64_LIBS        = 1142
   806  	X_CS_POSIX_V7_LP64_OFF64_LINTFLAGS   = 1143
   807  	X_CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS    = 1144
   808  	X_CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS   = 1145
   809  	X_CS_POSIX_V7_LPBIG_OFFBIG_LIBS      = 1146
   810  	X_CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS = 1147
   811  
   812  	X_CS_V6_ENV = 1148
   813  	X_CS_V7_ENV = 1149
   814  )
   815  
   816  // Values for the argument to `sysconf'.
   817  const ( /* confname.h:71:1: */
   818  	X_SC_ARG_MAX               = 0
   819  	X_SC_CHILD_MAX             = 1
   820  	X_SC_CLK_TCK               = 2
   821  	X_SC_NGROUPS_MAX           = 3
   822  	X_SC_OPEN_MAX              = 4
   823  	X_SC_STREAM_MAX            = 5
   824  	X_SC_TZNAME_MAX            = 6
   825  	X_SC_JOB_CONTROL           = 7
   826  	X_SC_SAVED_IDS             = 8
   827  	X_SC_REALTIME_SIGNALS      = 9
   828  	X_SC_PRIORITY_SCHEDULING   = 10
   829  	X_SC_TIMERS                = 11
   830  	X_SC_ASYNCHRONOUS_IO       = 12
   831  	X_SC_PRIORITIZED_IO        = 13
   832  	X_SC_SYNCHRONIZED_IO       = 14
   833  	X_SC_FSYNC                 = 15
   834  	X_SC_MAPPED_FILES          = 16
   835  	X_SC_MEMLOCK               = 17
   836  	X_SC_MEMLOCK_RANGE         = 18
   837  	X_SC_MEMORY_PROTECTION     = 19
   838  	X_SC_MESSAGE_PASSING       = 20
   839  	X_SC_SEMAPHORES            = 21
   840  	X_SC_SHARED_MEMORY_OBJECTS = 22
   841  	X_SC_AIO_LISTIO_MAX        = 23
   842  	X_SC_AIO_MAX               = 24
   843  	X_SC_AIO_PRIO_DELTA_MAX    = 25
   844  	X_SC_DELAYTIMER_MAX        = 26
   845  	X_SC_MQ_OPEN_MAX           = 27
   846  	X_SC_MQ_PRIO_MAX           = 28
   847  	X_SC_VERSION               = 29
   848  	X_SC_PAGESIZE              = 30
   849  	X_SC_RTSIG_MAX             = 31
   850  	X_SC_SEM_NSEMS_MAX         = 32
   851  	X_SC_SEM_VALUE_MAX         = 33
   852  	X_SC_SIGQUEUE_MAX          = 34
   853  	X_SC_TIMER_MAX             = 35
   854  
   855  	// Values for the argument to `sysconf'
   856  	//        corresponding to _POSIX2_* symbols.
   857  	X_SC_BC_BASE_MAX        = 36
   858  	X_SC_BC_DIM_MAX         = 37
   859  	X_SC_BC_SCALE_MAX       = 38
   860  	X_SC_BC_STRING_MAX      = 39
   861  	X_SC_COLL_WEIGHTS_MAX   = 40
   862  	X_SC_EQUIV_CLASS_MAX    = 41
   863  	X_SC_EXPR_NEST_MAX      = 42
   864  	X_SC_LINE_MAX           = 43
   865  	X_SC_RE_DUP_MAX         = 44
   866  	X_SC_CHARCLASS_NAME_MAX = 45
   867  
   868  	X_SC_2_VERSION   = 46
   869  	X_SC_2_C_BIND    = 47
   870  	X_SC_2_C_DEV     = 48
   871  	X_SC_2_FORT_DEV  = 49
   872  	X_SC_2_FORT_RUN  = 50
   873  	X_SC_2_SW_DEV    = 51
   874  	X_SC_2_LOCALEDEF = 52
   875  
   876  	X_SC_PII                 = 53
   877  	X_SC_PII_XTI             = 54
   878  	X_SC_PII_SOCKET          = 55
   879  	X_SC_PII_INTERNET        = 56
   880  	X_SC_PII_OSI             = 57
   881  	X_SC_POLL                = 58
   882  	X_SC_SELECT              = 59
   883  	X_SC_UIO_MAXIOV          = 60
   884  	X_SC_IOV_MAX             = 60
   885  	X_SC_PII_INTERNET_STREAM = 61
   886  	X_SC_PII_INTERNET_DGRAM  = 62
   887  	X_SC_PII_OSI_COTS        = 63
   888  	X_SC_PII_OSI_CLTS        = 64
   889  	X_SC_PII_OSI_M           = 65
   890  	X_SC_T_IOV_MAX           = 66
   891  
   892  	// Values according to POSIX 1003.1c (POSIX threads).
   893  	X_SC_THREADS                      = 67
   894  	X_SC_THREAD_SAFE_FUNCTIONS        = 68
   895  	X_SC_GETGR_R_SIZE_MAX             = 69
   896  	X_SC_GETPW_R_SIZE_MAX             = 70
   897  	X_SC_LOGIN_NAME_MAX               = 71
   898  	X_SC_TTY_NAME_MAX                 = 72
   899  	X_SC_THREAD_DESTRUCTOR_ITERATIONS = 73
   900  	X_SC_THREAD_KEYS_MAX              = 74
   901  	X_SC_THREAD_STACK_MIN             = 75
   902  	X_SC_THREAD_THREADS_MAX           = 76
   903  	X_SC_THREAD_ATTR_STACKADDR        = 77
   904  	X_SC_THREAD_ATTR_STACKSIZE        = 78
   905  	X_SC_THREAD_PRIORITY_SCHEDULING   = 79
   906  	X_SC_THREAD_PRIO_INHERIT          = 80
   907  	X_SC_THREAD_PRIO_PROTECT          = 81
   908  	X_SC_THREAD_PROCESS_SHARED        = 82
   909  
   910  	X_SC_NPROCESSORS_CONF = 83
   911  	X_SC_NPROCESSORS_ONLN = 84
   912  	X_SC_PHYS_PAGES       = 85
   913  	X_SC_AVPHYS_PAGES     = 86
   914  	X_SC_ATEXIT_MAX       = 87
   915  	X_SC_PASS_MAX         = 88
   916  
   917  	X_SC_XOPEN_VERSION     = 89
   918  	X_SC_XOPEN_XCU_VERSION = 90
   919  	X_SC_XOPEN_UNIX        = 91
   920  	X_SC_XOPEN_CRYPT       = 92
   921  	X_SC_XOPEN_ENH_I18N    = 93
   922  	X_SC_XOPEN_SHM         = 94
   923  
   924  	X_SC_2_CHAR_TERM = 95
   925  	X_SC_2_C_VERSION = 96
   926  	X_SC_2_UPE       = 97
   927  
   928  	X_SC_XOPEN_XPG2 = 98
   929  	X_SC_XOPEN_XPG3 = 99
   930  	X_SC_XOPEN_XPG4 = 100
   931  
   932  	X_SC_CHAR_BIT   = 101
   933  	X_SC_CHAR_MAX   = 102
   934  	X_SC_CHAR_MIN   = 103
   935  	X_SC_INT_MAX    = 104
   936  	X_SC_INT_MIN    = 105
   937  	X_SC_LONG_BIT   = 106
   938  	X_SC_WORD_BIT   = 107
   939  	X_SC_MB_LEN_MAX = 108
   940  	X_SC_NZERO      = 109
   941  	X_SC_SSIZE_MAX  = 110
   942  	X_SC_SCHAR_MAX  = 111
   943  	X_SC_SCHAR_MIN  = 112
   944  	X_SC_SHRT_MAX   = 113
   945  	X_SC_SHRT_MIN   = 114
   946  	X_SC_UCHAR_MAX  = 115
   947  	X_SC_UINT_MAX   = 116
   948  	X_SC_ULONG_MAX  = 117
   949  	X_SC_USHRT_MAX  = 118
   950  
   951  	X_SC_NL_ARGMAX  = 119
   952  	X_SC_NL_LANGMAX = 120
   953  	X_SC_NL_MSGMAX  = 121
   954  	X_SC_NL_NMAX    = 122
   955  	X_SC_NL_SETMAX  = 123
   956  	X_SC_NL_TEXTMAX = 124
   957  
   958  	X_SC_XBS5_ILP32_OFF32  = 125
   959  	X_SC_XBS5_ILP32_OFFBIG = 126
   960  	X_SC_XBS5_LP64_OFF64   = 127
   961  	X_SC_XBS5_LPBIG_OFFBIG = 128
   962  
   963  	X_SC_XOPEN_LEGACY           = 129
   964  	X_SC_XOPEN_REALTIME         = 130
   965  	X_SC_XOPEN_REALTIME_THREADS = 131
   966  
   967  	X_SC_ADVISORY_INFO          = 132
   968  	X_SC_BARRIERS               = 133
   969  	X_SC_BASE                   = 134
   970  	X_SC_C_LANG_SUPPORT         = 135
   971  	X_SC_C_LANG_SUPPORT_R       = 136
   972  	X_SC_CLOCK_SELECTION        = 137
   973  	X_SC_CPUTIME                = 138
   974  	X_SC_THREAD_CPUTIME         = 139
   975  	X_SC_DEVICE_IO              = 140
   976  	X_SC_DEVICE_SPECIFIC        = 141
   977  	X_SC_DEVICE_SPECIFIC_R      = 142
   978  	X_SC_FD_MGMT                = 143
   979  	X_SC_FIFO                   = 144
   980  	X_SC_PIPE                   = 145
   981  	X_SC_FILE_ATTRIBUTES        = 146
   982  	X_SC_FILE_LOCKING           = 147
   983  	X_SC_FILE_SYSTEM            = 148
   984  	X_SC_MONOTONIC_CLOCK        = 149
   985  	X_SC_MULTI_PROCESS          = 150
   986  	X_SC_SINGLE_PROCESS         = 151
   987  	X_SC_NETWORKING             = 152
   988  	X_SC_READER_WRITER_LOCKS    = 153
   989  	X_SC_SPIN_LOCKS             = 154
   990  	X_SC_REGEXP                 = 155
   991  	X_SC_REGEX_VERSION          = 156
   992  	X_SC_SHELL                  = 157
   993  	X_SC_SIGNALS                = 158
   994  	X_SC_SPAWN                  = 159
   995  	X_SC_SPORADIC_SERVER        = 160
   996  	X_SC_THREAD_SPORADIC_SERVER = 161
   997  	X_SC_SYSTEM_DATABASE        = 162
   998  	X_SC_SYSTEM_DATABASE_R      = 163
   999  	X_SC_TIMEOUTS               = 164
  1000  	X_SC_TYPED_MEMORY_OBJECTS   = 165
  1001  	X_SC_USER_GROUPS            = 166
  1002  	X_SC_USER_GROUPS_R          = 167
  1003  	X_SC_2_PBS                  = 168
  1004  	X_SC_2_PBS_ACCOUNTING       = 169
  1005  	X_SC_2_PBS_LOCATE           = 170
  1006  	X_SC_2_PBS_MESSAGE          = 171
  1007  	X_SC_2_PBS_TRACK            = 172
  1008  	X_SC_SYMLOOP_MAX            = 173
  1009  	X_SC_STREAMS                = 174
  1010  	X_SC_2_PBS_CHECKPOINT       = 175
  1011  
  1012  	X_SC_V6_ILP32_OFF32  = 176
  1013  	X_SC_V6_ILP32_OFFBIG = 177
  1014  	X_SC_V6_LP64_OFF64   = 178
  1015  	X_SC_V6_LPBIG_OFFBIG = 179
  1016  
  1017  	X_SC_HOST_NAME_MAX      = 180
  1018  	X_SC_TRACE              = 181
  1019  	X_SC_TRACE_EVENT_FILTER = 182
  1020  	X_SC_TRACE_INHERIT      = 183
  1021  	X_SC_TRACE_LOG          = 184
  1022  
  1023  	X_SC_LEVEL1_ICACHE_SIZE     = 185
  1024  	X_SC_LEVEL1_ICACHE_ASSOC    = 186
  1025  	X_SC_LEVEL1_ICACHE_LINESIZE = 187
  1026  	X_SC_LEVEL1_DCACHE_SIZE     = 188
  1027  	X_SC_LEVEL1_DCACHE_ASSOC    = 189
  1028  	X_SC_LEVEL1_DCACHE_LINESIZE = 190
  1029  	X_SC_LEVEL2_CACHE_SIZE      = 191
  1030  	X_SC_LEVEL2_CACHE_ASSOC     = 192
  1031  	X_SC_LEVEL2_CACHE_LINESIZE  = 193
  1032  	X_SC_LEVEL3_CACHE_SIZE      = 194
  1033  	X_SC_LEVEL3_CACHE_ASSOC     = 195
  1034  	X_SC_LEVEL3_CACHE_LINESIZE  = 196
  1035  	X_SC_LEVEL4_CACHE_SIZE      = 197
  1036  	X_SC_LEVEL4_CACHE_ASSOC     = 198
  1037  	X_SC_LEVEL4_CACHE_LINESIZE  = 199
  1038  	// Leave room here, maybe we need a few more cache levels some day.
  1039  
  1040  	X_SC_IPV6        = 235
  1041  	X_SC_RAW_SOCKETS = 236
  1042  
  1043  	X_SC_V7_ILP32_OFF32  = 237
  1044  	X_SC_V7_ILP32_OFFBIG = 238
  1045  	X_SC_V7_LP64_OFF64   = 239
  1046  	X_SC_V7_LPBIG_OFFBIG = 240
  1047  
  1048  	X_SC_SS_REPL_MAX = 241
  1049  
  1050  	X_SC_TRACE_EVENT_NAME_MAX = 242
  1051  	X_SC_TRACE_NAME_MAX       = 243
  1052  	X_SC_TRACE_SYS_MAX        = 244
  1053  	X_SC_TRACE_USER_EVENT_MAX = 245
  1054  
  1055  	X_SC_XOPEN_STREAMS = 246
  1056  
  1057  	X_SC_THREAD_ROBUST_PRIO_INHERIT = 247
  1058  	X_SC_THREAD_ROBUST_PRIO_PROTECT = 248
  1059  )
  1060  
  1061  // Copyright (C) 1991-2020 Free Software Foundation, Inc.
  1062  //    This file is part of the GNU C Library.
  1063  //
  1064  //    The GNU C Library is free software; you can redistribute it and/or
  1065  //    modify it under the terms of the GNU Lesser General Public
  1066  //    License as published by the Free Software Foundation; either
  1067  //    version 2.1 of the License, or (at your option) any later version.
  1068  //
  1069  //    The GNU C Library is distributed in the hope that it will be useful,
  1070  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  1071  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  1072  //    Lesser General Public License for more details.
  1073  //
  1074  //    You should have received a copy of the GNU Lesser General Public
  1075  //    License along with the GNU C Library; if not, see
  1076  //    <https://www.gnu.org/licenses/>.
  1077  
  1078  //	ISO C99 Standard: 7.20 General utilities	<stdlib.h>
  1079  
  1080  // Handle feature test macros at the start of a header.
  1081  //    Copyright (C) 2016-2020 Free Software Foundation, Inc.
  1082  //    This file is part of the GNU C Library.
  1083  //
  1084  //    The GNU C Library is free software; you can redistribute it and/or
  1085  //    modify it under the terms of the GNU Lesser General Public
  1086  //    License as published by the Free Software Foundation; either
  1087  //    version 2.1 of the License, or (at your option) any later version.
  1088  //
  1089  //    The GNU C Library is distributed in the hope that it will be useful,
  1090  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  1091  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  1092  //    Lesser General Public License for more details.
  1093  //
  1094  //    You should have received a copy of the GNU Lesser General Public
  1095  //    License along with the GNU C Library; if not, see
  1096  //    <https://www.gnu.org/licenses/>.
  1097  
  1098  // This header is internal to glibc and should not be included outside
  1099  //    of glibc headers.  Headers including it must define
  1100  //    __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION first.  This header
  1101  //    cannot have multiple include guards because ISO C feature test
  1102  //    macros depend on the definition of the macro when an affected
  1103  //    header is included, not when the first system header is
  1104  //    included.
  1105  
  1106  // Copyright (C) 1991-2020 Free Software Foundation, Inc.
  1107  //    This file is part of the GNU C Library.
  1108  //
  1109  //    The GNU C Library is free software; you can redistribute it and/or
  1110  //    modify it under the terms of the GNU Lesser General Public
  1111  //    License as published by the Free Software Foundation; either
  1112  //    version 2.1 of the License, or (at your option) any later version.
  1113  //
  1114  //    The GNU C Library is distributed in the hope that it will be useful,
  1115  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  1116  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  1117  //    Lesser General Public License for more details.
  1118  //
  1119  //    You should have received a copy of the GNU Lesser General Public
  1120  //    License along with the GNU C Library; if not, see
  1121  //    <https://www.gnu.org/licenses/>.
  1122  
  1123  // ISO/IEC TR 24731-2:2010 defines the __STDC_WANT_LIB_EXT2__
  1124  //    macro.
  1125  
  1126  // ISO/IEC TS 18661-1:2014 defines the __STDC_WANT_IEC_60559_BFP_EXT__
  1127  //    macro.  Most but not all symbols enabled by that macro in TS
  1128  //    18661-1 are enabled unconditionally in C2X; the symbols in Annex F
  1129  //    still require that macro in C2X.
  1130  
  1131  // ISO/IEC TS 18661-4:2015 defines the
  1132  //    __STDC_WANT_IEC_60559_FUNCS_EXT__ macro.  Other than the reduction
  1133  //    functions, the symbols from this TS are enabled unconditionally in
  1134  //    C2X.
  1135  
  1136  // ISO/IEC TS 18661-3:2015 defines the
  1137  //    __STDC_WANT_IEC_60559_TYPES_EXT__ macro.
  1138  
  1139  // Get size_t, wchar_t and NULL from <stddef.h>.
  1140  // Copyright (C) 1989-2020 Free Software Foundation, Inc.
  1141  //
  1142  // This file is part of GCC.
  1143  //
  1144  // GCC is free software; you can redistribute it and/or modify
  1145  // it under the terms of the GNU General Public License as published by
  1146  // the Free Software Foundation; either version 3, or (at your option)
  1147  // any later version.
  1148  //
  1149  // GCC is distributed in the hope that it will be useful,
  1150  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  1151  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  1152  // GNU General Public License for more details.
  1153  //
  1154  // Under Section 7 of GPL version 3, you are granted additional
  1155  // permissions described in the GCC Runtime Library Exception, version
  1156  // 3.1, as published by the Free Software Foundation.
  1157  //
  1158  // You should have received a copy of the GNU General Public License and
  1159  // a copy of the GCC Runtime Library Exception along with this program;
  1160  // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  1161  // <http://www.gnu.org/licenses/>.
  1162  
  1163  // ISO C Standard:  7.17  Common definitions  <stddef.h>
  1164  
  1165  // Any one of these symbols __need_* means that GNU libc
  1166  //    wants us just to define one data type.  So don't define
  1167  //    the symbols that indicate this file's entire job has been done.
  1168  
  1169  // This avoids lossage on SunOS but only if stdtypes.h comes first.
  1170  //    There's no way to win with the other order!  Sun lossage.
  1171  
  1172  // Sequent's header files use _PTRDIFF_T_ in some conflicting way.
  1173  //    Just ignore it.
  1174  
  1175  // On VxWorks, <type/vxTypesBase.h> may have defined macros like
  1176  //    _TYPE_size_t which will typedef size_t.  fixincludes patched the
  1177  //    vxTypesBase.h so that this macro is only defined if _GCC_SIZE_T is
  1178  //    not defined, and so that defining this macro defines _GCC_SIZE_T.
  1179  //    If we find that the macros are still defined at this point, we must
  1180  //    invoke them so that the type is defined as expected.
  1181  
  1182  // In case nobody has defined these types, but we aren't running under
  1183  //    GCC 2.00, make sure that __PTRDIFF_TYPE__, __SIZE_TYPE__, and
  1184  //    __WCHAR_TYPE__ have reasonable values.  This can happen if the
  1185  //    parts of GCC is compiled by an older compiler, that actually
  1186  //    include gstddef.h, such as collect2.
  1187  
  1188  // Signed type of difference of two pointers.
  1189  
  1190  // Define this type if we are doing the whole job,
  1191  //    or if we want this type in particular.
  1192  
  1193  // If this symbol has done its job, get rid of it.
  1194  
  1195  // Unsigned type of `sizeof' something.
  1196  
  1197  // Define this type if we are doing the whole job,
  1198  //    or if we want this type in particular.
  1199  
  1200  // Wide character type.
  1201  //    Locale-writers should change this as necessary to
  1202  //    be big enough to hold unique values not between 0 and 127,
  1203  //    and not (wchar_t) -1, for each defined multibyte character.
  1204  
  1205  // Define this type if we are doing the whole job,
  1206  //    or if we want this type in particular.
  1207  
  1208  // A null pointer constant.
  1209  
  1210  // Offset of member MEMBER in a struct of type TYPE.
  1211  
  1212  // XPG requires a few symbols from <sys/wait.h> being defined.
  1213  // Definitions of flag bits for `waitpid' et al.
  1214  //    Copyright (C) 1992-2020 Free Software Foundation, Inc.
  1215  //    This file is part of the GNU C Library.
  1216  //
  1217  //    The GNU C Library is free software; you can redistribute it and/or
  1218  //    modify it under the terms of the GNU Lesser General Public
  1219  //    License as published by the Free Software Foundation; either
  1220  //    version 2.1 of the License, or (at your option) any later version.
  1221  //
  1222  //    The GNU C Library is distributed in the hope that it will be useful,
  1223  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  1224  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  1225  //    Lesser General Public License for more details.
  1226  //
  1227  //    You should have received a copy of the GNU Lesser General Public
  1228  //    License along with the GNU C Library; if not, see
  1229  //    <https://www.gnu.org/licenses/>.
  1230  
  1231  // Bits in the third argument to `waitpid'.
  1232  
  1233  // Bits in the fourth argument to `waitid'.
  1234  
  1235  // The following values are used by the `waitid' function.
  1236  
  1237  // The Linux kernel defines these bare, rather than an enum,
  1238  //    which causes a conflict if the include order is reversed.
  1239  
  1240  const ( /* waitflags.h:52:1: */
  1241  	P_ALL  = 0 // Wait for any child.
  1242  	P_PID  = 1 // Wait for specified process.
  1243  	P_PGID = 2
  1244  )
  1245  
  1246  //
  1247  //   If you use the zlib library in a product, an acknowledgment is welcome
  1248  //   in the documentation of your product. If for some reason you cannot
  1249  //   include such an acknowledgment, I would appreciate that you keep this
  1250  //   copyright string in the executable of your product.
  1251  //
  1252  
  1253  // ===========================================================================
  1254  //  Function prototypes.
  1255  const ( /* deflate.c:66:1: */
  1256  	Need_more      = 0 // block not completed, need more input or more output
  1257  	Block_done     = 1 // block flush performed
  1258  	Finish_started = 2 // finish started, need only more output at next deflate
  1259  	Finish_done    = 3
  1260  )
  1261  
  1262  // inflate.h -- internal inflate state definition
  1263  // Copyright (C) 1995-2016 Mark Adler
  1264  // For conditions of distribution and use, see copyright notice in zlib.h
  1265  
  1266  // WARNING: this file should *not* be used by applications. It is
  1267  //    part of the implementation of the compression library and is
  1268  //    subject to change. Applications should only use zlib.h.
  1269  //
  1270  
  1271  // define NO_GZIP when compiling if you want to disable gzip header and
  1272  //    trailer decoding by inflate().  NO_GZIP would be used to avoid linking in
  1273  //    the crc code when it is not needed.  For shared libraries, gzip decoding
  1274  //    should be left enabled.
  1275  
  1276  // Possible inflate modes between inflate() calls
  1277  const ( /* inflate.h:20:1: */
  1278  	HEAD     = 16180 // i: waiting for magic header
  1279  	FLAGS    = 16181 // i: waiting for method and flags (gzip)
  1280  	TIME     = 16182 // i: waiting for modification time (gzip)
  1281  	OS       = 16183 // i: waiting for extra flags and operating system (gzip)
  1282  	EXLEN    = 16184 // i: waiting for extra length (gzip)
  1283  	EXTRA    = 16185 // i: waiting for extra bytes (gzip)
  1284  	NAME     = 16186 // i: waiting for end of file name (gzip)
  1285  	COMMENT  = 16187 // i: waiting for end of comment (gzip)
  1286  	HCRC     = 16188 // i: waiting for header crc (gzip)
  1287  	DICTID   = 16189 // i: waiting for dictionary check value
  1288  	DICT     = 16190 // waiting for inflateSetDictionary() call
  1289  	TYPE     = 16191 // i: waiting for type bits, including last-flag bit
  1290  	TYPEDO   = 16192 // i: same, but skip check to exit inflate on new block
  1291  	STORED   = 16193 // i: waiting for stored size (length and complement)
  1292  	COPY_    = 16194 // i/o: same as COPY below, but only first time in
  1293  	COPY     = 16195 // i/o: waiting for input or output to copy stored block
  1294  	TABLE    = 16196 // i: waiting for dynamic block table lengths
  1295  	LENLENS  = 16197 // i: waiting for code length code lengths
  1296  	CODELENS = 16198 // i: waiting for length/lit and distance code lengths
  1297  	LEN_     = 16199 // i: same as LEN below, but only first time in
  1298  	LEN      = 16200 // i: waiting for length/lit/eob code
  1299  	LENEXT   = 16201 // i: waiting for length extra bits
  1300  	DIST     = 16202 // i: waiting for distance code
  1301  	DISTEXT  = 16203 // i: waiting for distance extra bits
  1302  	MATCH    = 16204 // o: waiting for output space to copy string
  1303  	LIT      = 16205 // o: waiting for output space to write literal
  1304  	CHECK    = 16206 // i: waiting for 32-bit check value
  1305  	LENGTH   = 16207 // i: waiting for 32-bit length (gzip)
  1306  	DONE     = 16208 // finished check, done -- remain here until reset
  1307  	BAD      = 16209 // got a data error -- remain here until reset
  1308  	MEM      = 16210 // got an inflate() memory error -- remain here until reset
  1309  	SYNC     = 16211
  1310  )
  1311  
  1312  // op values as set by inflate_table():
  1313  //     00000000 - literal
  1314  //     0000tttt - table link, tttt != 0 is the number of table index bits
  1315  //     0001eeee - length or distance, eeee is the number of extra bits
  1316  //     01100000 - end of block
  1317  //     01000000 - invalid code
  1318  //
  1319  
  1320  // Maximum size of the dynamic table.  The maximum number of code structures is
  1321  //    1444, which is the sum of 852 for literal/length codes and 592 for distance
  1322  //    codes.  These values were found by exhaustive searches using the program
  1323  //    examples/enough.c found in the zlib distribtution.  The arguments to that
  1324  //    program are the number of symbols, the initial root table size, and the
  1325  //    maximum bit length of a code.  "enough 286 9 15" for literal/length codes
  1326  //    returns returns 852, and "enough 30 6 15" for distance codes returns 592.
  1327  //    The initial root table size (9 or 6) is found in the fifth argument of the
  1328  //    inflate_table() calls in inflate.c and infback.c.  If the root table size is
  1329  //    changed, then these maximum sizes would be need to be recalculated and
  1330  //    updated.
  1331  
  1332  // Type of code to build for inflate_table()
  1333  const ( /* inftrees.h:54:1: */
  1334  	CODES = 0
  1335  	LENS  = 1
  1336  	DISTS = 2
  1337  )
  1338  
  1339  type Ptrdiff_t = int64 /* <builtin>:3:26 */
  1340  
  1341  type Size_t = uint64 /* <builtin>:9:23 */
  1342  
  1343  type Wchar_t = int32 /* <builtin>:15:24 */
  1344  
  1345  type X__int128_t = struct {
  1346  	Flo int64
  1347  	Fhi int64
  1348  } /* <builtin>:21:43 */ // must match modernc.org/mathutil.Int128
  1349  type X__uint128_t = struct {
  1350  	Flo uint64
  1351  	Fhi uint64
  1352  } /* <builtin>:22:44 */ // must match modernc.org/mathutil.Int128
  1353  
  1354  type X__builtin_va_list = uintptr /* <builtin>:46:14 */
  1355  type X__ieee128 = float64         /* <builtin>:47:21 */
  1356  
  1357  // A null pointer constant.
  1358  
  1359  // Offset of member MEMBER in a struct of type TYPE.
  1360  
  1361  // Type whose alignment is supported in every context and is at least
  1362  //    as great as that of any standard type not using alignment
  1363  //    specifiers.
  1364  type Max_align_t = struct {
  1365  	F__max_align_ll int64
  1366  	F__max_align_ld float64
  1367  } /* stddef.h:426:3 */
  1368  
  1369  type Z_size_t = Size_t /* zconf.h:248:21 */
  1370  
  1371  // Maximum value for memLevel in deflateInit2
  1372  
  1373  // Maximum value for windowBits in deflateInit2 and inflateInit2.
  1374  // WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
  1375  // created by gzip. (Files created by minigzip can still be extracted by
  1376  // gzip.)
  1377  
  1378  // The memory requirements for deflate are (in bytes):
  1379  //             (1 << (windowBits+2)) +  (1 << (memLevel+9))
  1380  //  that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
  1381  //  plus a few kilobytes for small objects. For example, if you want to reduce
  1382  //  the default memory requirements from 256K to 128K, compile with
  1383  //      make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
  1384  //  Of course this will generally degrade compression (there's no free lunch).
  1385  //
  1386  //    The memory requirements for inflate are (in bytes) 1 << windowBits
  1387  //  that is, 32K for windowBits=15 (default value) plus about 7 kilobytes
  1388  //  for small objects.
  1389  
  1390  // Type declarations
  1391  
  1392  // The following definitions for FAR are needed only for MSDOS mixed
  1393  // model programming (small or medium model with some far allocations).
  1394  // This was tested only with MSC; for other MSDOS compilers you may have
  1395  // to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
  1396  // just define FAR to be empty.
  1397  
  1398  type Byte = uint8   /* zconf.h:391:24 */ // 8 bits
  1399  type UInt = uint32  /* zconf.h:393:24 */ // 16 bits or more
  1400  type ULong = uint64 /* zconf.h:394:24 */ // 32 bits or more
  1401  
  1402  type Bytef = Byte   /* zconf.h:400:22 */
  1403  type Charf = uint8  /* zconf.h:402:19 */
  1404  type Intf = int32   /* zconf.h:403:19 */
  1405  type UIntf = UInt   /* zconf.h:404:19 */
  1406  type ULongf = ULong /* zconf.h:405:19 */
  1407  
  1408  type Voidpc = uintptr /* zconf.h:408:23 */
  1409  type Voidpf = uintptr /* zconf.h:409:23 */
  1410  type Voidp = uintptr  /* zconf.h:410:23 */
  1411  
  1412  // Copyright (C) 1992-2020 Free Software Foundation, Inc.
  1413  //
  1414  // This file is part of GCC.
  1415  //
  1416  // GCC is free software; you can redistribute it and/or modify it under
  1417  // the terms of the GNU General Public License as published by the Free
  1418  // Software Foundation; either version 3, or (at your option) any later
  1419  // version.
  1420  //
  1421  // GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  1422  // WARRANTY; without even the implied warranty of MERCHANTABILITY or
  1423  // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  1424  // for more details.
  1425  //
  1426  // Under Section 7 of GPL version 3, you are granted additional
  1427  // permissions described in the GCC Runtime Library Exception, version
  1428  // 3.1, as published by the Free Software Foundation.
  1429  //
  1430  // You should have received a copy of the GNU General Public License and
  1431  // a copy of the GCC Runtime Library Exception along with this program;
  1432  // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  1433  // <http://www.gnu.org/licenses/>.
  1434  
  1435  // This administrivia gets added to the beginning of limits.h
  1436  //    if the system has its own version of limits.h.
  1437  
  1438  // We use _GCC_LIMITS_H_ because we want this not to match
  1439  //    any macros that the system's limits.h uses for its own purposes.
  1440  
  1441  // Use "..." so that we find syslimits.h only in this same directory.
  1442  // syslimits.h stands for the system's own limits.h file.
  1443  //    If we can use it ok unmodified, then we install this text.
  1444  //    If fixincludes fixes it, then the fixed version is installed
  1445  //    instead of this text.
  1446  
  1447  // Copyright (C) 1991-2020 Free Software Foundation, Inc.
  1448  //    This file is part of the GNU C Library.
  1449  //
  1450  //    The GNU C Library is free software; you can redistribute it and/or
  1451  //    modify it under the terms of the GNU Lesser General Public
  1452  //    License as published by the Free Software Foundation; either
  1453  //    version 2.1 of the License, or (at your option) any later version.
  1454  //
  1455  //    The GNU C Library is distributed in the hope that it will be useful,
  1456  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  1457  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  1458  //    Lesser General Public License for more details.
  1459  //
  1460  //    You should have received a copy of the GNU Lesser General Public
  1461  //    License along with the GNU C Library; if not, see
  1462  //    <https://www.gnu.org/licenses/>.
  1463  
  1464  //	ISO C99 Standard: 7.10/5.2.4.2.1 Sizes of integer types	<limits.h>
  1465  
  1466  // Handle feature test macros at the start of a header.
  1467  //    Copyright (C) 2016-2020 Free Software Foundation, Inc.
  1468  //    This file is part of the GNU C Library.
  1469  //
  1470  //    The GNU C Library is free software; you can redistribute it and/or
  1471  //    modify it under the terms of the GNU Lesser General Public
  1472  //    License as published by the Free Software Foundation; either
  1473  //    version 2.1 of the License, or (at your option) any later version.
  1474  //
  1475  //    The GNU C Library is distributed in the hope that it will be useful,
  1476  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  1477  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  1478  //    Lesser General Public License for more details.
  1479  //
  1480  //    You should have received a copy of the GNU Lesser General Public
  1481  //    License along with the GNU C Library; if not, see
  1482  //    <https://www.gnu.org/licenses/>.
  1483  
  1484  // This header is internal to glibc and should not be included outside
  1485  //    of glibc headers.  Headers including it must define
  1486  //    __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION first.  This header
  1487  //    cannot have multiple include guards because ISO C feature test
  1488  //    macros depend on the definition of the macro when an affected
  1489  //    header is included, not when the first system header is
  1490  //    included.
  1491  
  1492  // Copyright (C) 1991-2020 Free Software Foundation, Inc.
  1493  //    This file is part of the GNU C Library.
  1494  //
  1495  //    The GNU C Library is free software; you can redistribute it and/or
  1496  //    modify it under the terms of the GNU Lesser General Public
  1497  //    License as published by the Free Software Foundation; either
  1498  //    version 2.1 of the License, or (at your option) any later version.
  1499  //
  1500  //    The GNU C Library is distributed in the hope that it will be useful,
  1501  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  1502  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  1503  //    Lesser General Public License for more details.
  1504  //
  1505  //    You should have received a copy of the GNU Lesser General Public
  1506  //    License along with the GNU C Library; if not, see
  1507  //    <https://www.gnu.org/licenses/>.
  1508  
  1509  // These are defined by the user (or the compiler)
  1510  //    to specify the desired environment:
  1511  //
  1512  //    __STRICT_ANSI__	ISO Standard C.
  1513  //    _ISOC99_SOURCE	Extensions to ISO C89 from ISO C99.
  1514  //    _ISOC11_SOURCE	Extensions to ISO C99 from ISO C11.
  1515  //    _ISOC2X_SOURCE	Extensions to ISO C99 from ISO C2X.
  1516  //    __STDC_WANT_LIB_EXT2__
  1517  // 			Extensions to ISO C99 from TR 27431-2:2010.
  1518  //    __STDC_WANT_IEC_60559_BFP_EXT__
  1519  // 			Extensions to ISO C11 from TS 18661-1:2014.
  1520  //    __STDC_WANT_IEC_60559_FUNCS_EXT__
  1521  // 			Extensions to ISO C11 from TS 18661-4:2015.
  1522  //    __STDC_WANT_IEC_60559_TYPES_EXT__
  1523  // 			Extensions to ISO C11 from TS 18661-3:2015.
  1524  //
  1525  //    _POSIX_SOURCE	IEEE Std 1003.1.
  1526  //    _POSIX_C_SOURCE	If ==1, like _POSIX_SOURCE; if >=2 add IEEE Std 1003.2;
  1527  // 			if >=199309L, add IEEE Std 1003.1b-1993;
  1528  // 			if >=199506L, add IEEE Std 1003.1c-1995;
  1529  // 			if >=200112L, all of IEEE 1003.1-2004
  1530  // 			if >=200809L, all of IEEE 1003.1-2008
  1531  //    _XOPEN_SOURCE	Includes POSIX and XPG things.  Set to 500 if
  1532  // 			Single Unix conformance is wanted, to 600 for the
  1533  // 			sixth revision, to 700 for the seventh revision.
  1534  //    _XOPEN_SOURCE_EXTENDED XPG things and X/Open Unix extensions.
  1535  //    _LARGEFILE_SOURCE	Some more functions for correct standard I/O.
  1536  //    _LARGEFILE64_SOURCE	Additional functionality from LFS for large files.
  1537  //    _FILE_OFFSET_BITS=N	Select default filesystem interface.
  1538  //    _ATFILE_SOURCE	Additional *at interfaces.
  1539  //    _GNU_SOURCE		All of the above, plus GNU extensions.
  1540  //    _DEFAULT_SOURCE	The default set of features (taking precedence over
  1541  // 			__STRICT_ANSI__).
  1542  //
  1543  //    _FORTIFY_SOURCE	Add security hardening to many library functions.
  1544  // 			Set to 1 or 2; 2 performs stricter checks than 1.
  1545  //
  1546  //    _REENTRANT, _THREAD_SAFE
  1547  // 			Obsolete; equivalent to _POSIX_C_SOURCE=199506L.
  1548  //
  1549  //    The `-ansi' switch to the GNU C compiler, and standards conformance
  1550  //    options such as `-std=c99', define __STRICT_ANSI__.  If none of
  1551  //    these are defined, or if _DEFAULT_SOURCE is defined, the default is
  1552  //    to have _POSIX_SOURCE set to one and _POSIX_C_SOURCE set to
  1553  //    200809L, as well as enabling miscellaneous functions from BSD and
  1554  //    SVID.  If more than one of these are defined, they accumulate.  For
  1555  //    example __STRICT_ANSI__, _POSIX_SOURCE and _POSIX_C_SOURCE together
  1556  //    give you ISO C, 1003.1, and 1003.2, but nothing else.
  1557  //
  1558  //    These are defined by this file and are used by the
  1559  //    header files to decide what to declare or define:
  1560  //
  1561  //    __GLIBC_USE (F)	Define things from feature set F.  This is defined
  1562  // 			to 1 or 0; the subsequent macros are either defined
  1563  // 			or undefined, and those tests should be moved to
  1564  // 			__GLIBC_USE.
  1565  //    __USE_ISOC11		Define ISO C11 things.
  1566  //    __USE_ISOC99		Define ISO C99 things.
  1567  //    __USE_ISOC95		Define ISO C90 AMD1 (C95) things.
  1568  //    __USE_ISOCXX11	Define ISO C++11 things.
  1569  //    __USE_POSIX		Define IEEE Std 1003.1 things.
  1570  //    __USE_POSIX2		Define IEEE Std 1003.2 things.
  1571  //    __USE_POSIX199309	Define IEEE Std 1003.1, and .1b things.
  1572  //    __USE_POSIX199506	Define IEEE Std 1003.1, .1b, .1c and .1i things.
  1573  //    __USE_XOPEN		Define XPG things.
  1574  //    __USE_XOPEN_EXTENDED	Define X/Open Unix things.
  1575  //    __USE_UNIX98		Define Single Unix V2 things.
  1576  //    __USE_XOPEN2K        Define XPG6 things.
  1577  //    __USE_XOPEN2KXSI     Define XPG6 XSI things.
  1578  //    __USE_XOPEN2K8       Define XPG7 things.
  1579  //    __USE_XOPEN2K8XSI    Define XPG7 XSI things.
  1580  //    __USE_LARGEFILE	Define correct standard I/O things.
  1581  //    __USE_LARGEFILE64	Define LFS things with separate names.
  1582  //    __USE_FILE_OFFSET64	Define 64bit interface as default.
  1583  //    __USE_MISC		Define things from 4.3BSD or System V Unix.
  1584  //    __USE_ATFILE		Define *at interfaces and AT_* constants for them.
  1585  //    __USE_GNU		Define GNU extensions.
  1586  //    __USE_FORTIFY_LEVEL	Additional security measures used, according to level.
  1587  //
  1588  //    The macros `__GNU_LIBRARY__', `__GLIBC__', and `__GLIBC_MINOR__' are
  1589  //    defined by this file unconditionally.  `__GNU_LIBRARY__' is provided
  1590  //    only for compatibility.  All new code should use the other symbols
  1591  //    to test for features.
  1592  //
  1593  //    All macros listed above as possibly being defined by this file are
  1594  //    explicitly undefined if they are not explicitly defined.
  1595  //    Feature-test macros that are not defined by the user or compiler
  1596  //    but are implied by the other feature-test macros defined (or by the
  1597  //    lack of any definitions) are defined by the file.
  1598  //
  1599  //    ISO C feature test macros depend on the definition of the macro
  1600  //    when an affected header is included, not when the first system
  1601  //    header is included, and so they are handled in
  1602  //    <bits/libc-header-start.h>, which does not have a multiple include
  1603  //    guard.  Feature test macros that can be handled from the first
  1604  //    system header included are handled here.
  1605  
  1606  // Undefine everything, so we get a clean slate.
  1607  
  1608  // Suppress kernel-name space pollution unless user expressedly asks
  1609  //    for it.
  1610  
  1611  // Convenience macro to test the version of gcc.
  1612  //    Use like this:
  1613  //    #if __GNUC_PREREQ (2,8)
  1614  //    ... code requiring gcc 2.8 or later ...
  1615  //    #endif
  1616  //    Note: only works for GCC 2.0 and later, because __GNUC_MINOR__ was
  1617  //    added in 2.0.
  1618  
  1619  // Similarly for clang.  Features added to GCC after version 4.2 may
  1620  //    or may not also be available in clang, and clang's definitions of
  1621  //    __GNUC(_MINOR)__ are fixed at 4 and 2 respectively.  Not all such
  1622  //    features can be queried via __has_extension/__has_feature.
  1623  
  1624  // Whether to use feature set F.
  1625  
  1626  // _BSD_SOURCE and _SVID_SOURCE are deprecated aliases for
  1627  //    _DEFAULT_SOURCE.  If _DEFAULT_SOURCE is present we do not
  1628  //    issue a warning; the expectation is that the source is being
  1629  //    transitioned to use the new macro.
  1630  
  1631  // If _GNU_SOURCE was defined by the user, turn on all the other features.
  1632  
  1633  // If nothing (other than _GNU_SOURCE and _DEFAULT_SOURCE) is defined,
  1634  //    define _DEFAULT_SOURCE.
  1635  
  1636  // This is to enable the ISO C2X extension.
  1637  
  1638  // This is to enable the ISO C11 extension.
  1639  
  1640  // This is to enable the ISO C99 extension.
  1641  
  1642  // This is to enable the ISO C90 Amendment 1:1995 extension.
  1643  
  1644  // If none of the ANSI/POSIX macros are defined, or if _DEFAULT_SOURCE
  1645  //    is defined, use POSIX.1-2008 (or another version depending on
  1646  //    _XOPEN_SOURCE).
  1647  
  1648  // Some C libraries once required _REENTRANT and/or _THREAD_SAFE to be
  1649  //    defined in all multithreaded code.  GNU libc has not required this
  1650  //    for many years.  We now treat them as compatibility synonyms for
  1651  //    _POSIX_C_SOURCE=199506L, which is the earliest level of POSIX with
  1652  //    comprehensive support for multithreaded code.  Using them never
  1653  //    lowers the selected level of POSIX conformance, only raises it.
  1654  
  1655  // The function 'gets' existed in C89, but is impossible to use
  1656  //    safely.  It has been removed from ISO C11 and ISO C++14.  Note: for
  1657  //    compatibility with various implementations of <cstdio>, this test
  1658  //    must consider only the value of __cplusplus when compiling C++.
  1659  
  1660  // GNU formerly extended the scanf functions with modified format
  1661  //    specifiers %as, %aS, and %a[...] that allocate a buffer for the
  1662  //    input using malloc.  This extension conflicts with ISO C99, which
  1663  //    defines %a as a standalone format specifier that reads a floating-
  1664  //    point number; moreover, POSIX.1-2008 provides the same feature
  1665  //    using the modifier letter 'm' instead (%ms, %mS, %m[...]).
  1666  //
  1667  //    We now follow C99 unless GNU extensions are active and the compiler
  1668  //    is specifically in C89 or C++98 mode (strict or not).  For
  1669  //    instance, with GCC, -std=gnu11 will have C99-compliant scanf with
  1670  //    or without -D_GNU_SOURCE, but -std=c89 -D_GNU_SOURCE will have the
  1671  //    old extension.
  1672  
  1673  // Get definitions of __STDC_* predefined macros, if the compiler has
  1674  //    not preincluded this header automatically.
  1675  // Copyright (C) 1991-2020 Free Software Foundation, Inc.
  1676  //    This file is part of the GNU C Library.
  1677  //
  1678  //    The GNU C Library is free software; you can redistribute it and/or
  1679  //    modify it under the terms of the GNU Lesser General Public
  1680  //    License as published by the Free Software Foundation; either
  1681  //    version 2.1 of the License, or (at your option) any later version.
  1682  //
  1683  //    The GNU C Library is distributed in the hope that it will be useful,
  1684  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  1685  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  1686  //    Lesser General Public License for more details.
  1687  //
  1688  //    You should have received a copy of the GNU Lesser General Public
  1689  //    License along with the GNU C Library; if not, see
  1690  //    <https://www.gnu.org/licenses/>.
  1691  
  1692  // This macro indicates that the installed library is the GNU C Library.
  1693  //    For historic reasons the value now is 6 and this will stay from now
  1694  //    on.  The use of this variable is deprecated.  Use __GLIBC__ and
  1695  //    __GLIBC_MINOR__ now (see below) when you want to test for a specific
  1696  //    GNU C library version and use the values in <gnu/lib-names.h> to get
  1697  //    the sonames of the shared libraries.
  1698  
  1699  // Major and minor version number of the GNU C library package.  Use
  1700  //    these macros to test for features in specific releases.
  1701  
  1702  // This is here only because every header file already includes this one.
  1703  // Copyright (C) 1992-2020 Free Software Foundation, Inc.
  1704  //    This file is part of the GNU C Library.
  1705  //
  1706  //    The GNU C Library is free software; you can redistribute it and/or
  1707  //    modify it under the terms of the GNU Lesser General Public
  1708  //    License as published by the Free Software Foundation; either
  1709  //    version 2.1 of the License, or (at your option) any later version.
  1710  //
  1711  //    The GNU C Library is distributed in the hope that it will be useful,
  1712  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  1713  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  1714  //    Lesser General Public License for more details.
  1715  //
  1716  //    You should have received a copy of the GNU Lesser General Public
  1717  //    License along with the GNU C Library; if not, see
  1718  //    <https://www.gnu.org/licenses/>.
  1719  
  1720  // We are almost always included from features.h.
  1721  
  1722  // The GNU libc does not support any K&R compilers or the traditional mode
  1723  //    of ISO C compilers anymore.  Check for some of the combinations not
  1724  //    anymore supported.
  1725  
  1726  // Some user header file might have defined this before.
  1727  
  1728  // All functions, except those with callbacks or those that
  1729  //    synchronize memory, are leaf functions.
  1730  
  1731  // GCC can always grok prototypes.  For C++ programs we add throw()
  1732  //    to help it optimize the function calls.  But this works only with
  1733  //    gcc 2.8.x and egcs.  For gcc 3.2 and up we even mark C functions
  1734  //    as non-throwing using a function attribute since programs can use
  1735  //    the -fexceptions options for C code as well.
  1736  
  1737  // Compilers that are not clang may object to
  1738  //        #if defined __clang__ && __has_extension(...)
  1739  //    even though they do not need to evaluate the right-hand side of the &&.
  1740  
  1741  // These two macros are not used in glibc anymore.  They are kept here
  1742  //    only because some other projects expect the macros to be defined.
  1743  
  1744  // For these things, GCC behaves the ANSI way normally,
  1745  //    and the non-ANSI way under -traditional.
  1746  
  1747  // This is not a typedef so `const __ptr_t' does the right thing.
  1748  
  1749  // C++ needs to know that types and declarations are C, not C++.
  1750  
  1751  // Fortify support.
  1752  
  1753  // Support for flexible arrays.
  1754  //    Headers that should use flexible arrays only if they're "real"
  1755  //    (e.g. only if they won't affect sizeof()) should test
  1756  //    #if __glibc_c99_flexarr_available.
  1757  
  1758  // __asm__ ("xyz") is used throughout the headers to rename functions
  1759  //    at the assembly language level.  This is wrapped by the __REDIRECT
  1760  //    macro, in order to support compilers that can do this some other
  1761  //    way.  When compilers don't support asm-names at all, we have to do
  1762  //    preprocessor tricks instead (which don't have exactly the right
  1763  //    semantics, but it's the best we can do).
  1764  //
  1765  //    Example:
  1766  //    int __REDIRECT(setpgrp, (__pid_t pid, __pid_t pgrp), setpgid);
  1767  
  1768  //
  1769  // #elif __SOME_OTHER_COMPILER__
  1770  //
  1771  // # define __REDIRECT(name, proto, alias) name proto; 	_Pragma("let " #name " = " #alias)
  1772  
  1773  // GCC has various useful declarations that can be made with the
  1774  //    `__attribute__' syntax.  All of the ways we use this do fine if
  1775  //    they are omitted for compilers that don't understand it.
  1776  
  1777  // At some point during the gcc 2.96 development the `malloc' attribute
  1778  //    for functions was introduced.  We don't want to use it unconditionally
  1779  //    (although this would be possible) since it generates warnings.
  1780  
  1781  // Tell the compiler which arguments to an allocation function
  1782  //    indicate the size of the allocation.
  1783  
  1784  // At some point during the gcc 2.96 development the `pure' attribute
  1785  //    for functions was introduced.  We don't want to use it unconditionally
  1786  //    (although this would be possible) since it generates warnings.
  1787  
  1788  // This declaration tells the compiler that the value is constant.
  1789  
  1790  // At some point during the gcc 3.1 development the `used' attribute
  1791  //    for functions was introduced.  We don't want to use it unconditionally
  1792  //    (although this would be possible) since it generates warnings.
  1793  
  1794  // Since version 3.2, gcc allows marking deprecated functions.
  1795  
  1796  // Since version 4.5, gcc also allows one to specify the message printed
  1797  //    when a deprecated function is used.  clang claims to be gcc 4.2, but
  1798  //    may also support this feature.
  1799  
  1800  // At some point during the gcc 2.8 development the `format_arg' attribute
  1801  //    for functions was introduced.  We don't want to use it unconditionally
  1802  //    (although this would be possible) since it generates warnings.
  1803  //    If several `format_arg' attributes are given for the same function, in
  1804  //    gcc-3.0 and older, all but the last one are ignored.  In newer gccs,
  1805  //    all designated arguments are considered.
  1806  
  1807  // At some point during the gcc 2.97 development the `strfmon' format
  1808  //    attribute for functions was introduced.  We don't want to use it
  1809  //    unconditionally (although this would be possible) since it
  1810  //    generates warnings.
  1811  
  1812  // The nonull function attribute allows to mark pointer parameters which
  1813  //    must not be NULL.
  1814  
  1815  // If fortification mode, we warn about unused results of certain
  1816  //    function calls which can lead to problems.
  1817  
  1818  // Forces a function to be always inlined.
  1819  // The Linux kernel defines __always_inline in stddef.h (283d7573), and
  1820  //    it conflicts with this definition.  Therefore undefine it first to
  1821  //    allow either header to be included first.
  1822  
  1823  // Associate error messages with the source location of the call site rather
  1824  //    than with the source location inside the function.
  1825  
  1826  // GCC 4.3 and above with -std=c99 or -std=gnu99 implements ISO C99
  1827  //    inline semantics, unless -fgnu89-inline is used.  Using __GNUC_STDC_INLINE__
  1828  //    or __GNUC_GNU_INLINE is not a good enough check for gcc because gcc versions
  1829  //    older than 4.3 may define these macros and still not guarantee GNU inlining
  1830  //    semantics.
  1831  //
  1832  //    clang++ identifies itself as gcc-4.2, but has support for GNU inlining
  1833  //    semantics, that can be checked for by using the __GNUC_STDC_INLINE_ and
  1834  //    __GNUC_GNU_INLINE__ macro definitions.
  1835  
  1836  // GCC 4.3 and above allow passing all anonymous arguments of an
  1837  //    __extern_always_inline function to some other vararg function.
  1838  
  1839  // It is possible to compile containing GCC extensions even if GCC is
  1840  //    run in pedantic mode if the uses are carefully marked using the
  1841  //    `__extension__' keyword.  But this is not generally available before
  1842  //    version 2.8.
  1843  
  1844  // __restrict is known in EGCS 1.2 and above.
  1845  
  1846  // ISO C99 also allows to declare arrays as non-overlapping.  The syntax is
  1847  //      array_name[restrict]
  1848  //    GCC 3.1 supports this.
  1849  
  1850  // Describes a char array whose address can safely be passed as the first
  1851  //    argument to strncpy and strncat, as the char array is not necessarily
  1852  //    a NUL-terminated string.
  1853  
  1854  // Undefine (also defined in libc-symbols.h).
  1855  // Copies attributes from the declaration or type referenced by
  1856  //    the argument.
  1857  
  1858  // Determine the wordsize from the preprocessor defines.
  1859  
  1860  // Properties of long double type.  ldbl-opt version.
  1861  //    Copyright (C) 2016-2020 Free Software Foundation, Inc.
  1862  //    This file is part of the GNU C Library.
  1863  //
  1864  //    The GNU C Library is free software; you can redistribute it and/or
  1865  //    modify it under the terms of the GNU Lesser General Public
  1866  //    License  published by the Free Software Foundation; either
  1867  //    version 2.1 of the License, or (at your option) any later version.
  1868  //
  1869  //    The GNU C Library is distributed in the hope that it will be useful,
  1870  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  1871  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  1872  //    Lesser General Public License for more details.
  1873  //
  1874  //    You should have received a copy of the GNU Lesser General Public
  1875  //    License along with the GNU C Library; if not, see
  1876  //    <https://www.gnu.org/licenses/>.
  1877  
  1878  // __glibc_macro_warning (MESSAGE) issues warning MESSAGE.  This is
  1879  //    intended for use in preprocessor macros.
  1880  //
  1881  //    Note: MESSAGE must be a _single_ string; concatenation of string
  1882  //    literals is not supported.
  1883  
  1884  // Generic selection (ISO C11) is a C-only feature, available in GCC
  1885  //    since version 4.9.  Previous versions do not provide generic
  1886  //    selection, even though they might set __STDC_VERSION__ to 201112L,
  1887  //    when in -std=c11 mode.  Thus, we must check for !defined __GNUC__
  1888  //    when testing __STDC_VERSION__ for generic selection support.
  1889  //    On the other hand, Clang also defines __GNUC__, so a clang-specific
  1890  //    check is required to enable the use of generic selection.
  1891  
  1892  // If we don't have __REDIRECT, prototypes will be missing if
  1893  //    __USE_FILE_OFFSET64 but not __USE_LARGEFILE[64].
  1894  
  1895  // Decide whether we can define 'extern inline' functions in headers.
  1896  
  1897  // This is here only because every header file already includes this one.
  1898  //    Get the definitions of all the appropriate `__stub_FUNCTION' symbols.
  1899  //    <gnu/stubs.h> contains `#define __stub_FUNCTION' when FUNCTION is a stub
  1900  //    that will always return failure (and set errno to ENOSYS).
  1901  // This file is automatically generated.
  1902  //    This file selects the right generated file of `__stub_FUNCTION' macros
  1903  //    based on the architecture being compiled for.
  1904  
  1905  // Determine the wordsize from the preprocessor defines.
  1906  
  1907  // This file is automatically generated.
  1908  //    It defines a symbol `__stub_FUNCTION' for each function
  1909  //    in the C library which is a stub, meaning it will fail
  1910  //    every time called, usually setting errno to ENOSYS.
  1911  
  1912  // ISO/IEC TR 24731-2:2010 defines the __STDC_WANT_LIB_EXT2__
  1913  //    macro.
  1914  
  1915  // ISO/IEC TS 18661-1:2014 defines the __STDC_WANT_IEC_60559_BFP_EXT__
  1916  //    macro.  Most but not all symbols enabled by that macro in TS
  1917  //    18661-1 are enabled unconditionally in C2X; the symbols in Annex F
  1918  //    still require that macro in C2X.
  1919  
  1920  // ISO/IEC TS 18661-4:2015 defines the
  1921  //    __STDC_WANT_IEC_60559_FUNCS_EXT__ macro.  Other than the reduction
  1922  //    functions, the symbols from this TS are enabled unconditionally in
  1923  //    C2X.
  1924  
  1925  // ISO/IEC TS 18661-3:2015 defines the
  1926  //    __STDC_WANT_IEC_60559_TYPES_EXT__ macro.
  1927  
  1928  // Maximum length of any multibyte character in any locale.
  1929  //    We define this value here since the gcc header does not define
  1930  //    the correct value.
  1931  
  1932  // If we are not using GNU CC we have to define all the symbols ourself.
  1933  //    Otherwise use gcc's definitions (see below).
  1934  
  1935  // Get the compiler's limits.h, which defines almost all the ISO constants.
  1936  //
  1937  //     We put this #include_next outside the double inclusion check because
  1938  //     it should be possible to include this file more than once and still get
  1939  //     the definitions from gcc's header.
  1940  
  1941  // The <limits.h> files in some gcc versions don't define LLONG_MIN,
  1942  //    LLONG_MAX, and ULLONG_MAX.  Instead only the values gcc defined for
  1943  //    ages are available.
  1944  
  1945  // The integer width macros are not defined by GCC's <limits.h> before
  1946  //    GCC 7, or if _GNU_SOURCE rather than
  1947  //    __STDC_WANT_IEC_60559_BFP_EXT__ is used to enable this feature.
  1948  
  1949  // POSIX adds things to <limits.h>.
  1950  // Copyright (C) 1991-2020 Free Software Foundation, Inc.
  1951  //    This file is part of the GNU C Library.
  1952  //
  1953  //    The GNU C Library is free software; you can redistribute it and/or
  1954  //    modify it under the terms of the GNU Lesser General Public
  1955  //    License as published by the Free Software Foundation; either
  1956  //    version 2.1 of the License, or (at your option) any later version.
  1957  //
  1958  //    The GNU C Library is distributed in the hope that it will be useful,
  1959  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  1960  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  1961  //    Lesser General Public License for more details.
  1962  //
  1963  //    You should have received a copy of the GNU Lesser General Public
  1964  //    License along with the GNU C Library; if not, see
  1965  //    <https://www.gnu.org/licenses/>.
  1966  
  1967  //	POSIX Standard: 2.9.2 Minimum Values	Added to <limits.h>
  1968  //
  1969  //	Never include this file directly; use <limits.h> instead.
  1970  
  1971  // Determine the wordsize from the preprocessor defines.
  1972  
  1973  // These are the standard-mandated minimum values.
  1974  
  1975  // Minimum number of operations in one list I/O call.
  1976  
  1977  // Minimal number of outstanding asynchronous I/O operations.
  1978  
  1979  // Maximum length of arguments to `execve', including environment.
  1980  
  1981  // Maximum simultaneous processes per real user ID.
  1982  
  1983  // Minimal number of timer expiration overruns.
  1984  
  1985  // Maximum length of a host name (not including the terminating null)
  1986  //    as returned from the GETHOSTNAME function.
  1987  
  1988  // Maximum link count of a file.
  1989  
  1990  // Maximum length of login name.
  1991  
  1992  // Number of bytes in a terminal canonical input queue.
  1993  
  1994  // Number of bytes for which space will be
  1995  //    available in a terminal input queue.
  1996  
  1997  // Maximum number of message queues open for a process.
  1998  
  1999  // Maximum number of supported message priorities.
  2000  
  2001  // Number of bytes in a filename.
  2002  
  2003  // Number of simultaneous supplementary group IDs per process.
  2004  
  2005  // Number of files one process can have open at once.
  2006  
  2007  // Number of bytes in a pathname.
  2008  
  2009  // Number of bytes than can be written atomically to a pipe.
  2010  
  2011  // The number of repeated occurrences of a BRE permitted by the
  2012  //    REGEXEC and REGCOMP functions when using the interval notation.
  2013  
  2014  // Minimal number of realtime signals reserved for the application.
  2015  
  2016  // Number of semaphores a process can have.
  2017  
  2018  // Maximal value of a semaphore.
  2019  
  2020  // Number of pending realtime signals.
  2021  
  2022  // Largest value of a `ssize_t'.
  2023  
  2024  // Number of streams a process can have open at once.
  2025  
  2026  // The number of bytes in a symbolic link.
  2027  
  2028  // The number of symbolic links that can be traversed in the
  2029  //    resolution of a pathname in the absence of a loop.
  2030  
  2031  // Number of timer for a process.
  2032  
  2033  // Maximum number of characters in a tty name.
  2034  
  2035  // Maximum length of a timezone name (element of `tzname').
  2036  
  2037  // Maximum clock resolution in nanoseconds.
  2038  
  2039  // Get the implementation-specific values for the above.
  2040  // Minimum guaranteed maximum values for system limits.  Linux/PPC version.
  2041  //    Copyright (C) 1993-2020 Free Software Foundation, Inc.
  2042  //    This file is part of the GNU C Library.
  2043  //
  2044  //    The GNU C Library is free software; you can redistribute it and/or
  2045  //    modify it under the terms of the GNU Lesser General Public License as
  2046  //    published by the Free Software Foundation; either version 2.1 of the
  2047  //    License, or (at your option) any later version.
  2048  //
  2049  //    The GNU C Library is distributed in the hope that it will be useful,
  2050  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  2051  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  2052  //    Lesser General Public License for more details.
  2053  //
  2054  //    You should have received a copy of the GNU Lesser General Public
  2055  //    License along with the GNU C Library; see the file COPYING.LIB.  If
  2056  //    not, see <https://www.gnu.org/licenses/>.
  2057  
  2058  // The kernel header pollutes the namespace with the NR_OPEN symbol
  2059  //    and defines LINK_MAX although filesystems have different maxima.  A
  2060  //    similar thing is true for OPEN_MAX: the limit can be changed at
  2061  //    runtime and therefore the macro must not be defined.  Remove this
  2062  //    after including the header if necessary.
  2063  
  2064  // The kernel sources contain a file with all the needed information.
  2065  // SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note
  2066  
  2067  // Have to remove NR_OPEN?
  2068  // Have to remove LINK_MAX?
  2069  // Have to remove OPEN_MAX?
  2070  // Have to remove ARG_MAX?
  2071  
  2072  // The number of data keys per process.
  2073  // This is the value this implementation supports.
  2074  
  2075  // Controlling the iterations of destructors for thread-specific data.
  2076  // Number of iterations this implementation does.
  2077  
  2078  // The number of threads per process.
  2079  // We have no predefined limit on the number of threads.
  2080  
  2081  // Maximum amount by which a process can descrease its asynchronous I/O
  2082  //    priority level.
  2083  
  2084  // Minimum size for a thread.  At least two pages for systems with 64k
  2085  //    pages.
  2086  
  2087  // Maximum number of timer expiration overruns.
  2088  
  2089  // Maximum tty name length.
  2090  
  2091  // Maximum login name length.  This is arbitrary.
  2092  
  2093  // Maximum host name length.
  2094  
  2095  // Maximum message queue priority level.
  2096  
  2097  // Maximum value the semaphore can have.
  2098  
  2099  // ssize_t is not formally required to be the signed type
  2100  //    corresponding to size_t, but it is for all configurations supported
  2101  //    by glibc.
  2102  
  2103  // This value is a guaranteed minimum maximum.
  2104  //    The current maximum can be got from `sysconf'.
  2105  
  2106  // Copyright (C) 1991-2020 Free Software Foundation, Inc.
  2107  //    This file is part of the GNU C Library.
  2108  //
  2109  //    The GNU C Library is free software; you can redistribute it and/or
  2110  //    modify it under the terms of the GNU Lesser General Public
  2111  //    License as published by the Free Software Foundation; either
  2112  //    version 2.1 of the License, or (at your option) any later version.
  2113  //
  2114  //    The GNU C Library is distributed in the hope that it will be useful,
  2115  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  2116  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  2117  //    Lesser General Public License for more details.
  2118  //
  2119  //    You should have received a copy of the GNU Lesser General Public
  2120  //    License along with the GNU C Library; if not, see
  2121  //    <https://www.gnu.org/licenses/>.
  2122  
  2123  // Never include this file directly; include <limits.h> instead.
  2124  
  2125  // The maximum `ibase' and `obase' values allowed by the `bc' utility.
  2126  
  2127  // The maximum number of elements allowed in an array by the `bc' utility.
  2128  
  2129  // The maximum `scale' value allowed by the `bc' utility.
  2130  
  2131  // The maximum length of a string constant accepted by the `bc' utility.
  2132  
  2133  // The maximum number of weights that can be assigned to an entry of
  2134  //    the LC_COLLATE `order' keyword in the locale definition file.
  2135  
  2136  // The maximum number of expressions that can be nested
  2137  //    within parentheses by the `expr' utility.
  2138  
  2139  // The maximum length, in bytes, of an input line.
  2140  
  2141  // The maximum number of repeated occurrences of a regular expression
  2142  //    permitted when using the interval notation `\{M,N\}'.
  2143  
  2144  // The maximum number of bytes in a character class name.  We have no
  2145  //    fixed limit, 2048 is a high number.
  2146  
  2147  // These values are implementation-specific,
  2148  //    and may vary within the implementation.
  2149  //    Their precise values can be obtained from sysconf.
  2150  
  2151  // This value is defined like this in regex.h.
  2152  
  2153  // Copyright (C) 1991-2020 Free Software Foundation, Inc.
  2154  //
  2155  // This file is part of GCC.
  2156  //
  2157  // GCC is free software; you can redistribute it and/or modify it under
  2158  // the terms of the GNU General Public License as published by the Free
  2159  // Software Foundation; either version 3, or (at your option) any later
  2160  // version.
  2161  //
  2162  // GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  2163  // WARRANTY; without even the implied warranty of MERCHANTABILITY or
  2164  // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  2165  // for more details.
  2166  //
  2167  // Under Section 7 of GPL version 3, you are granted additional
  2168  // permissions described in the GCC Runtime Library Exception, version
  2169  // 3.1, as published by the Free Software Foundation.
  2170  //
  2171  // You should have received a copy of the GNU General Public License and
  2172  // a copy of the GCC Runtime Library Exception along with this program;
  2173  // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  2174  // <http://www.gnu.org/licenses/>.
  2175  
  2176  // Number of bits in a `char'.
  2177  
  2178  // Maximum length of a multibyte character.
  2179  
  2180  // Minimum and maximum values a `signed char' can hold.
  2181  
  2182  // Maximum value an `unsigned char' can hold.  (Minimum is 0).
  2183  
  2184  // Minimum and maximum values a `char' can hold.
  2185  
  2186  // Minimum and maximum values a `signed short int' can hold.
  2187  
  2188  // Maximum value an `unsigned short int' can hold.  (Minimum is 0).
  2189  
  2190  // Minimum and maximum values a `signed int' can hold.
  2191  
  2192  // Maximum value an `unsigned int' can hold.  (Minimum is 0).
  2193  
  2194  // Minimum and maximum values a `signed long int' can hold.
  2195  //    (Same as `int').
  2196  
  2197  // Maximum value an `unsigned long int' can hold.  (Minimum is 0).
  2198  
  2199  // Minimum and maximum values a `signed long long int' can hold.
  2200  
  2201  // Maximum value an `unsigned long long int' can hold.  (Minimum is 0).
  2202  
  2203  // This administrivia gets added to the end of limits.h
  2204  //    if the system has its own version of limits.h.
  2205  
  2206  type Z_crc_t = uint32 /* zconf.h:429:17 */
  2207  
  2208  // Copyright (C) 1991-2020 Free Software Foundation, Inc.
  2209  //    This file is part of the GNU C Library.
  2210  //
  2211  //    The GNU C Library is free software; you can redistribute it and/or
  2212  //    modify it under the terms of the GNU Lesser General Public
  2213  //    License as published by the Free Software Foundation; either
  2214  //    version 2.1 of the License, or (at your option) any later version.
  2215  //
  2216  //    The GNU C Library is distributed in the hope that it will be useful,
  2217  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  2218  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  2219  //    Lesser General Public License for more details.
  2220  //
  2221  //    You should have received a copy of the GNU Lesser General Public
  2222  //    License along with the GNU C Library; if not, see
  2223  //    <https://www.gnu.org/licenses/>.
  2224  
  2225  //	POSIX Standard: 2.6 Primitive System Data Types	<sys/types.h>
  2226  
  2227  // Copyright (C) 1991-2020 Free Software Foundation, Inc.
  2228  //    This file is part of the GNU C Library.
  2229  //
  2230  //    The GNU C Library is free software; you can redistribute it and/or
  2231  //    modify it under the terms of the GNU Lesser General Public
  2232  //    License as published by the Free Software Foundation; either
  2233  //    version 2.1 of the License, or (at your option) any later version.
  2234  //
  2235  //    The GNU C Library is distributed in the hope that it will be useful,
  2236  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  2237  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  2238  //    Lesser General Public License for more details.
  2239  //
  2240  //    You should have received a copy of the GNU Lesser General Public
  2241  //    License along with the GNU C Library; if not, see
  2242  //    <https://www.gnu.org/licenses/>.
  2243  
  2244  // bits/types.h -- definitions of __*_t types underlying *_t types.
  2245  //    Copyright (C) 2002-2020 Free Software Foundation, Inc.
  2246  //    This file is part of the GNU C Library.
  2247  //
  2248  //    The GNU C Library is free software; you can redistribute it and/or
  2249  //    modify it under the terms of the GNU Lesser General Public
  2250  //    License as published by the Free Software Foundation; either
  2251  //    version 2.1 of the License, or (at your option) any later version.
  2252  //
  2253  //    The GNU C Library is distributed in the hope that it will be useful,
  2254  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  2255  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  2256  //    Lesser General Public License for more details.
  2257  //
  2258  //    You should have received a copy of the GNU Lesser General Public
  2259  //    License along with the GNU C Library; if not, see
  2260  //    <https://www.gnu.org/licenses/>.
  2261  
  2262  // Never include this file directly; use <sys/types.h> instead.
  2263  
  2264  // Copyright (C) 1991-2020 Free Software Foundation, Inc.
  2265  //    This file is part of the GNU C Library.
  2266  //
  2267  //    The GNU C Library is free software; you can redistribute it and/or
  2268  //    modify it under the terms of the GNU Lesser General Public
  2269  //    License as published by the Free Software Foundation; either
  2270  //    version 2.1 of the License, or (at your option) any later version.
  2271  //
  2272  //    The GNU C Library is distributed in the hope that it will be useful,
  2273  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  2274  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  2275  //    Lesser General Public License for more details.
  2276  //
  2277  //    You should have received a copy of the GNU Lesser General Public
  2278  //    License along with the GNU C Library; if not, see
  2279  //    <https://www.gnu.org/licenses/>.
  2280  
  2281  // Determine the wordsize from the preprocessor defines.
  2282  
  2283  // Bit size of the time_t type at glibc build time, general case.
  2284  //    Copyright (C) 2018-2020 Free Software Foundation, Inc.
  2285  //    This file is part of the GNU C Library.
  2286  //
  2287  //    The GNU C Library is free software; you can redistribute it and/or
  2288  //    modify it under the terms of the GNU Lesser General Public
  2289  //    License as published by the Free Software Foundation; either
  2290  //    version 2.1 of the License, or (at your option) any later version.
  2291  //
  2292  //    The GNU C Library is distributed in the hope that it will be useful,
  2293  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  2294  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  2295  //    Lesser General Public License for more details.
  2296  //
  2297  //    You should have received a copy of the GNU Lesser General Public
  2298  //    License along with the GNU C Library; if not, see
  2299  //    <https://www.gnu.org/licenses/>.
  2300  
  2301  // Determine the wordsize from the preprocessor defines.
  2302  
  2303  // Size in bits of the 'time_t' type of the default ABI.
  2304  
  2305  // Convenience types.
  2306  type X__u_char = uint8   /* types.h:31:23 */
  2307  type X__u_short = uint16 /* types.h:32:28 */
  2308  type X__u_int = uint32   /* types.h:33:22 */
  2309  type X__u_long = uint64  /* types.h:34:27 */
  2310  
  2311  // Fixed-size types, underlying types depend on word size and compiler.
  2312  type X__int8_t = int8     /* types.h:37:21 */
  2313  type X__uint8_t = uint8   /* types.h:38:23 */
  2314  type X__int16_t = int16   /* types.h:39:26 */
  2315  type X__uint16_t = uint16 /* types.h:40:28 */
  2316  type X__int32_t = int32   /* types.h:41:20 */
  2317  type X__uint32_t = uint32 /* types.h:42:22 */
  2318  type X__int64_t = int64   /* types.h:44:25 */
  2319  type X__uint64_t = uint64 /* types.h:45:27 */
  2320  
  2321  // Smallest types with at least a given width.
  2322  type X__int_least8_t = X__int8_t     /* types.h:52:18 */
  2323  type X__uint_least8_t = X__uint8_t   /* types.h:53:19 */
  2324  type X__int_least16_t = X__int16_t   /* types.h:54:19 */
  2325  type X__uint_least16_t = X__uint16_t /* types.h:55:20 */
  2326  type X__int_least32_t = X__int32_t   /* types.h:56:19 */
  2327  type X__uint_least32_t = X__uint32_t /* types.h:57:20 */
  2328  type X__int_least64_t = X__int64_t   /* types.h:58:19 */
  2329  type X__uint_least64_t = X__uint64_t /* types.h:59:20 */
  2330  
  2331  // quad_t is also 64 bits.
  2332  type X__quad_t = int64    /* types.h:63:18 */
  2333  type X__u_quad_t = uint64 /* types.h:64:27 */
  2334  
  2335  // Largest integral types.
  2336  type X__intmax_t = int64   /* types.h:72:18 */
  2337  type X__uintmax_t = uint64 /* types.h:73:27 */
  2338  
  2339  // The machine-dependent file <bits/typesizes.h> defines __*_T_TYPE
  2340  //    macros for each of the OS types we define below.  The definitions
  2341  //    of those macros must use the following macros for underlying types.
  2342  //    We define __S<SIZE>_TYPE and __U<SIZE>_TYPE for the signed and unsigned
  2343  //    variants of each of the following integer types on this machine.
  2344  //
  2345  // 	16		-- "natural" 16-bit type (always short)
  2346  // 	32		-- "natural" 32-bit type (always int)
  2347  // 	64		-- "natural" 64-bit type (long or long long)
  2348  // 	LONG32		-- 32-bit type, traditionally long
  2349  // 	QUAD		-- 64-bit type, traditionally long long
  2350  // 	WORD		-- natural type of __WORDSIZE bits (int or long)
  2351  // 	LONGWORD	-- type of __WORDSIZE bits, traditionally long
  2352  //
  2353  //    We distinguish WORD/LONGWORD, 32/LONG32, and 64/QUAD so that the
  2354  //    conventional uses of `long' or `long long' type modifiers match the
  2355  //    types we define, even when a less-adorned type would be the same size.
  2356  //    This matters for (somewhat) portably writing printf/scanf formats for
  2357  //    these types, where using the appropriate l or ll format modifiers can
  2358  //    make the typedefs and the formats match up across all GNU platforms.  If
  2359  //    we used `long' when it's 64 bits where `long long' is expected, then the
  2360  //    compiler would warn about the formats not matching the argument types,
  2361  //    and the programmer changing them to shut up the compiler would break the
  2362  //    program's portability.
  2363  //
  2364  //    Here we assume what is presently the case in all the GCC configurations
  2365  //    we support: long long is always 64 bits, long is always word/address size,
  2366  //    and int is always 32 bits.
  2367  
  2368  // No need to mark the typedef with __extension__.
  2369  // bits/typesizes.h -- underlying types for *_t.  Generic version.
  2370  //    Copyright (C) 2002-2020 Free Software Foundation, Inc.
  2371  //    This file is part of the GNU C Library.
  2372  //
  2373  //    The GNU C Library is free software; you can redistribute it and/or
  2374  //    modify it under the terms of the GNU Lesser General Public
  2375  //    License as published by the Free Software Foundation; either
  2376  //    version 2.1 of the License, or (at your option) any later version.
  2377  //
  2378  //    The GNU C Library is distributed in the hope that it will be useful,
  2379  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  2380  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  2381  //    Lesser General Public License for more details.
  2382  //
  2383  //    You should have received a copy of the GNU Lesser General Public
  2384  //    License along with the GNU C Library; if not, see
  2385  //    <https://www.gnu.org/licenses/>.
  2386  
  2387  // See <bits/types.h> for the meaning of these macros.  This file exists so
  2388  //    that <bits/types.h> need not vary across different GNU platforms.
  2389  
  2390  // Tell the libc code that off_t and off64_t are actually the same type
  2391  //    for all ABI purposes, even if possibly expressed as different base types
  2392  //    for C type-checking purposes.
  2393  
  2394  // Same for ino_t and ino64_t.
  2395  
  2396  // And for rlim_t and rlim64_t.
  2397  
  2398  // And for fsblkcnt_t, fsblkcnt64_t, fsfilcnt_t and fsfilcnt64_t.
  2399  
  2400  // Number of descriptors that can fit in an `fd_set'.
  2401  
  2402  // bits/time64.h -- underlying types for __time64_t.  Generic version.
  2403  //    Copyright (C) 2018-2020 Free Software Foundation, Inc.
  2404  //    This file is part of the GNU C Library.
  2405  //
  2406  //    The GNU C Library is free software; you can redistribute it and/or
  2407  //    modify it under the terms of the GNU Lesser General Public
  2408  //    License as published by the Free Software Foundation; either
  2409  //    version 2.1 of the License, or (at your option) any later version.
  2410  //
  2411  //    The GNU C Library is distributed in the hope that it will be useful,
  2412  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  2413  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  2414  //    Lesser General Public License for more details.
  2415  //
  2416  //    You should have received a copy of the GNU Lesser General Public
  2417  //    License along with the GNU C Library; if not, see
  2418  //    <https://www.gnu.org/licenses/>.
  2419  
  2420  // Define __TIME64_T_TYPE so that it is always a 64-bit type.
  2421  
  2422  // If we already have 64-bit time type then use it.
  2423  
  2424  type X__dev_t = uint64                     /* types.h:145:25 */ // Type of device numbers.
  2425  type X__uid_t = uint32                     /* types.h:146:25 */ // Type of user identifications.
  2426  type X__gid_t = uint32                     /* types.h:147:25 */ // Type of group identifications.
  2427  type X__ino_t = uint64                     /* types.h:148:25 */ // Type of file serial numbers.
  2428  type X__ino64_t = uint64                   /* types.h:149:27 */ // Type of file serial numbers (LFS).
  2429  type X__mode_t = uint32                    /* types.h:150:26 */ // Type of file attribute bitmasks.
  2430  type X__nlink_t = uint64                   /* types.h:151:27 */ // Type of file link counts.
  2431  type X__off_t = int64                      /* types.h:152:25 */ // Type of file sizes and offsets.
  2432  type X__off64_t = int64                    /* types.h:153:27 */ // Type of file sizes and offsets (LFS).
  2433  type X__pid_t = int32                      /* types.h:154:25 */ // Type of process identifications.
  2434  type X__fsid_t = struct{ F__val [2]int32 } /* types.h:155:26 */ // Type of file system IDs.
  2435  type X__clock_t = int64                    /* types.h:156:27 */ // Type of CPU usage counts.
  2436  type X__rlim_t = uint64                    /* types.h:157:26 */ // Type for resource measurement.
  2437  type X__rlim64_t = uint64                  /* types.h:158:28 */ // Type for resource measurement (LFS).
  2438  type X__id_t = uint32                      /* types.h:159:24 */ // General type for IDs.
  2439  type X__time_t = int64                     /* types.h:160:26 */ // Seconds since the Epoch.
  2440  type X__useconds_t = uint32                /* types.h:161:30 */ // Count of microseconds.
  2441  type X__suseconds_t = int64                /* types.h:162:31 */ // Signed count of microseconds.
  2442  
  2443  type X__daddr_t = int32 /* types.h:164:27 */ // The type of a disk address.
  2444  type X__key_t = int32   /* types.h:165:25 */ // Type of an IPC key.
  2445  
  2446  // Clock ID used in clock and timer functions.
  2447  type X__clockid_t = int32 /* types.h:168:29 */
  2448  
  2449  // Timer ID returned by `timer_create'.
  2450  type X__timer_t = uintptr /* types.h:171:12 */
  2451  
  2452  // Type to represent block size.
  2453  type X__blksize_t = int64 /* types.h:174:29 */
  2454  
  2455  // Types from the Large File Support interface.
  2456  
  2457  // Type to count number of disk blocks.
  2458  type X__blkcnt_t = int64   /* types.h:179:28 */
  2459  type X__blkcnt64_t = int64 /* types.h:180:30 */
  2460  
  2461  // Type to count file system blocks.
  2462  type X__fsblkcnt_t = uint64   /* types.h:183:30 */
  2463  type X__fsblkcnt64_t = uint64 /* types.h:184:32 */
  2464  
  2465  // Type to count file system nodes.
  2466  type X__fsfilcnt_t = uint64   /* types.h:187:30 */
  2467  type X__fsfilcnt64_t = uint64 /* types.h:188:32 */
  2468  
  2469  // Type of miscellaneous file system fields.
  2470  type X__fsword_t = int64 /* types.h:191:28 */
  2471  
  2472  type X__ssize_t = int64 /* types.h:193:27 */ // Type of a byte count, or error.
  2473  
  2474  // Signed long type used in system calls.
  2475  type X__syscall_slong_t = int64 /* types.h:196:33 */
  2476  // Unsigned long type used in system calls.
  2477  type X__syscall_ulong_t = uint64 /* types.h:198:33 */
  2478  
  2479  // These few don't really vary by system, they always correspond
  2480  //    to one of the other defined types.
  2481  type X__loff_t = X__off64_t /* types.h:202:19 */ // Type of file sizes and offsets (LFS).
  2482  type X__caddr_t = uintptr   /* types.h:203:14 */
  2483  
  2484  // Duplicates info from stdint.h but this is used in unistd.h.
  2485  type X__intptr_t = int64 /* types.h:206:25 */
  2486  
  2487  // Duplicate info from sys/socket.h.
  2488  type X__socklen_t = uint32 /* types.h:209:23 */
  2489  
  2490  // C99: An integer type that can be accessed as an atomic entity,
  2491  //    even in the presence of asynchronous interrupts.
  2492  //    It is not currently necessary for this to be machine-specific.
  2493  type X__sig_atomic_t = int32 /* types.h:214:13 */
  2494  
  2495  // Seconds since the Epoch, visible to user code when time_t is too
  2496  //    narrow only for consistency with the old way of widening too-narrow
  2497  //    types.  User code should never use __time64_t.
  2498  
  2499  type U_char = X__u_char     /* types.h:33:18 */
  2500  type U_short = X__u_short   /* types.h:34:19 */
  2501  type U_int = X__u_int       /* types.h:35:17 */
  2502  type U_long = X__u_long     /* types.h:36:18 */
  2503  type Quad_t = X__quad_t     /* types.h:37:18 */
  2504  type U_quad_t = X__u_quad_t /* types.h:38:20 */
  2505  type Fsid_t = X__fsid_t     /* types.h:39:18 */
  2506  type Loff_t = X__loff_t     /* types.h:42:18 */
  2507  
  2508  type Ino_t = X__ino64_t   /* types.h:49:19 */
  2509  type Ino64_t = X__ino64_t /* types.h:54:19 */
  2510  
  2511  type Dev_t = X__dev_t /* types.h:59:17 */
  2512  
  2513  type Gid_t = X__gid_t /* types.h:64:17 */
  2514  
  2515  type Mode_t = X__mode_t /* types.h:69:18 */
  2516  
  2517  type Nlink_t = X__nlink_t /* types.h:74:19 */
  2518  
  2519  type Uid_t = X__uid_t /* types.h:79:17 */
  2520  
  2521  type Off_t = X__off64_t   /* types.h:87:19 */
  2522  type Off64_t = X__off64_t /* types.h:92:19 */
  2523  
  2524  type Pid_t = X__pid_t /* types.h:97:17 */
  2525  
  2526  type Id_t = X__id_t /* types.h:103:16 */
  2527  
  2528  type Ssize_t = X__ssize_t /* types.h:108:19 */
  2529  
  2530  type Daddr_t = X__daddr_t /* types.h:114:19 */
  2531  type Caddr_t = X__caddr_t /* types.h:115:19 */
  2532  
  2533  type Key_t = X__key_t /* types.h:121:17 */
  2534  
  2535  // bits/types.h -- definitions of __*_t types underlying *_t types.
  2536  //    Copyright (C) 2002-2020 Free Software Foundation, Inc.
  2537  //    This file is part of the GNU C Library.
  2538  //
  2539  //    The GNU C Library is free software; you can redistribute it and/or
  2540  //    modify it under the terms of the GNU Lesser General Public
  2541  //    License as published by the Free Software Foundation; either
  2542  //    version 2.1 of the License, or (at your option) any later version.
  2543  //
  2544  //    The GNU C Library is distributed in the hope that it will be useful,
  2545  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  2546  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  2547  //    Lesser General Public License for more details.
  2548  //
  2549  //    You should have received a copy of the GNU Lesser General Public
  2550  //    License along with the GNU C Library; if not, see
  2551  //    <https://www.gnu.org/licenses/>.
  2552  
  2553  // Never include this file directly; use <sys/types.h> instead.
  2554  
  2555  // Returned by `clock'.
  2556  type Clock_t = X__clock_t /* clock_t.h:7:19 */
  2557  
  2558  // bits/types.h -- definitions of __*_t types underlying *_t types.
  2559  //    Copyright (C) 2002-2020 Free Software Foundation, Inc.
  2560  //    This file is part of the GNU C Library.
  2561  //
  2562  //    The GNU C Library is free software; you can redistribute it and/or
  2563  //    modify it under the terms of the GNU Lesser General Public
  2564  //    License as published by the Free Software Foundation; either
  2565  //    version 2.1 of the License, or (at your option) any later version.
  2566  //
  2567  //    The GNU C Library is distributed in the hope that it will be useful,
  2568  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  2569  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  2570  //    Lesser General Public License for more details.
  2571  //
  2572  //    You should have received a copy of the GNU Lesser General Public
  2573  //    License along with the GNU C Library; if not, see
  2574  //    <https://www.gnu.org/licenses/>.
  2575  
  2576  // Never include this file directly; use <sys/types.h> instead.
  2577  
  2578  // Clock ID used in clock and timer functions.
  2579  type Clockid_t = X__clockid_t /* clockid_t.h:7:21 */
  2580  
  2581  // bits/types.h -- definitions of __*_t types underlying *_t types.
  2582  //    Copyright (C) 2002-2020 Free Software Foundation, Inc.
  2583  //    This file is part of the GNU C Library.
  2584  //
  2585  //    The GNU C Library is free software; you can redistribute it and/or
  2586  //    modify it under the terms of the GNU Lesser General Public
  2587  //    License as published by the Free Software Foundation; either
  2588  //    version 2.1 of the License, or (at your option) any later version.
  2589  //
  2590  //    The GNU C Library is distributed in the hope that it will be useful,
  2591  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  2592  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  2593  //    Lesser General Public License for more details.
  2594  //
  2595  //    You should have received a copy of the GNU Lesser General Public
  2596  //    License along with the GNU C Library; if not, see
  2597  //    <https://www.gnu.org/licenses/>.
  2598  
  2599  // Never include this file directly; use <sys/types.h> instead.
  2600  
  2601  // Returned by `time'.
  2602  type Time_t = X__time_t /* time_t.h:7:18 */
  2603  
  2604  // bits/types.h -- definitions of __*_t types underlying *_t types.
  2605  //    Copyright (C) 2002-2020 Free Software Foundation, Inc.
  2606  //    This file is part of the GNU C Library.
  2607  //
  2608  //    The GNU C Library is free software; you can redistribute it and/or
  2609  //    modify it under the terms of the GNU Lesser General Public
  2610  //    License as published by the Free Software Foundation; either
  2611  //    version 2.1 of the License, or (at your option) any later version.
  2612  //
  2613  //    The GNU C Library is distributed in the hope that it will be useful,
  2614  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  2615  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  2616  //    Lesser General Public License for more details.
  2617  //
  2618  //    You should have received a copy of the GNU Lesser General Public
  2619  //    License along with the GNU C Library; if not, see
  2620  //    <https://www.gnu.org/licenses/>.
  2621  
  2622  // Never include this file directly; use <sys/types.h> instead.
  2623  
  2624  // Timer ID returned by `timer_create'.
  2625  type Timer_t = X__timer_t /* timer_t.h:7:19 */
  2626  
  2627  // Copyright (C) 1989-2020 Free Software Foundation, Inc.
  2628  //
  2629  // This file is part of GCC.
  2630  //
  2631  // GCC is free software; you can redistribute it and/or modify
  2632  // it under the terms of the GNU General Public License as published by
  2633  // the Free Software Foundation; either version 3, or (at your option)
  2634  // any later version.
  2635  //
  2636  // GCC is distributed in the hope that it will be useful,
  2637  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  2638  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  2639  // GNU General Public License for more details.
  2640  //
  2641  // Under Section 7 of GPL version 3, you are granted additional
  2642  // permissions described in the GCC Runtime Library Exception, version
  2643  // 3.1, as published by the Free Software Foundation.
  2644  //
  2645  // You should have received a copy of the GNU General Public License and
  2646  // a copy of the GCC Runtime Library Exception along with this program;
  2647  // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  2648  // <http://www.gnu.org/licenses/>.
  2649  
  2650  // ISO C Standard:  7.17  Common definitions  <stddef.h>
  2651  
  2652  // Any one of these symbols __need_* means that GNU libc
  2653  //    wants us just to define one data type.  So don't define
  2654  //    the symbols that indicate this file's entire job has been done.
  2655  
  2656  // This avoids lossage on SunOS but only if stdtypes.h comes first.
  2657  //    There's no way to win with the other order!  Sun lossage.
  2658  
  2659  // Sequent's header files use _PTRDIFF_T_ in some conflicting way.
  2660  //    Just ignore it.
  2661  
  2662  // On VxWorks, <type/vxTypesBase.h> may have defined macros like
  2663  //    _TYPE_size_t which will typedef size_t.  fixincludes patched the
  2664  //    vxTypesBase.h so that this macro is only defined if _GCC_SIZE_T is
  2665  //    not defined, and so that defining this macro defines _GCC_SIZE_T.
  2666  //    If we find that the macros are still defined at this point, we must
  2667  //    invoke them so that the type is defined as expected.
  2668  
  2669  // In case nobody has defined these types, but we aren't running under
  2670  //    GCC 2.00, make sure that __PTRDIFF_TYPE__, __SIZE_TYPE__, and
  2671  //    __WCHAR_TYPE__ have reasonable values.  This can happen if the
  2672  //    parts of GCC is compiled by an older compiler, that actually
  2673  //    include gstddef.h, such as collect2.
  2674  
  2675  // Signed type of difference of two pointers.
  2676  
  2677  // Define this type if we are doing the whole job,
  2678  //    or if we want this type in particular.
  2679  
  2680  // If this symbol has done its job, get rid of it.
  2681  
  2682  // Unsigned type of `sizeof' something.
  2683  
  2684  // Define this type if we are doing the whole job,
  2685  //    or if we want this type in particular.
  2686  
  2687  // Wide character type.
  2688  //    Locale-writers should change this as necessary to
  2689  //    be big enough to hold unique values not between 0 and 127,
  2690  //    and not (wchar_t) -1, for each defined multibyte character.
  2691  
  2692  // Define this type if we are doing the whole job,
  2693  //    or if we want this type in particular.
  2694  
  2695  // A null pointer constant.
  2696  
  2697  // Offset of member MEMBER in a struct of type TYPE.
  2698  
  2699  // Old compatibility names for C types.
  2700  type Ulong = uint64  /* types.h:148:27 */
  2701  type Ushort = uint16 /* types.h:149:28 */
  2702  type Uint = uint32   /* types.h:150:22 */
  2703  
  2704  // These size-specific names are used by some of the inet code.
  2705  
  2706  // Define intN_t types.
  2707  //    Copyright (C) 2017-2020 Free Software Foundation, Inc.
  2708  //    This file is part of the GNU C Library.
  2709  //
  2710  //    The GNU C Library is free software; you can redistribute it and/or
  2711  //    modify it under the terms of the GNU Lesser General Public
  2712  //    License as published by the Free Software Foundation; either
  2713  //    version 2.1 of the License, or (at your option) any later version.
  2714  //
  2715  //    The GNU C Library is distributed in the hope that it will be useful,
  2716  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  2717  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  2718  //    Lesser General Public License for more details.
  2719  //
  2720  //    You should have received a copy of the GNU Lesser General Public
  2721  //    License along with the GNU C Library; if not, see
  2722  //    <https://www.gnu.org/licenses/>.
  2723  
  2724  // bits/types.h -- definitions of __*_t types underlying *_t types.
  2725  //    Copyright (C) 2002-2020 Free Software Foundation, Inc.
  2726  //    This file is part of the GNU C Library.
  2727  //
  2728  //    The GNU C Library is free software; you can redistribute it and/or
  2729  //    modify it under the terms of the GNU Lesser General Public
  2730  //    License as published by the Free Software Foundation; either
  2731  //    version 2.1 of the License, or (at your option) any later version.
  2732  //
  2733  //    The GNU C Library is distributed in the hope that it will be useful,
  2734  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  2735  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  2736  //    Lesser General Public License for more details.
  2737  //
  2738  //    You should have received a copy of the GNU Lesser General Public
  2739  //    License along with the GNU C Library; if not, see
  2740  //    <https://www.gnu.org/licenses/>.
  2741  
  2742  // Never include this file directly; use <sys/types.h> instead.
  2743  
  2744  type Int8_t = X__int8_t   /* stdint-intn.h:24:18 */
  2745  type Int16_t = X__int16_t /* stdint-intn.h:25:19 */
  2746  type Int32_t = X__int32_t /* stdint-intn.h:26:19 */
  2747  type Int64_t = X__int64_t /* stdint-intn.h:27:19 */
  2748  
  2749  // These were defined by ISO C without the first `_'.
  2750  type U_int8_t = X__uint8_t   /* types.h:158:19 */
  2751  type U_int16_t = X__uint16_t /* types.h:159:20 */
  2752  type U_int32_t = X__uint32_t /* types.h:160:20 */
  2753  type U_int64_t = X__uint64_t /* types.h:161:20 */
  2754  
  2755  type Register_t = int32 /* types.h:164:13 */
  2756  
  2757  // It also defines `fd_set' and the FD_* macros for `select'.
  2758  // `fd_set' type and related macros, and `select'/`pselect' declarations.
  2759  //    Copyright (C) 1996-2020 Free Software Foundation, Inc.
  2760  //    This file is part of the GNU C Library.
  2761  //
  2762  //    The GNU C Library is free software; you can redistribute it and/or
  2763  //    modify it under the terms of the GNU Lesser General Public
  2764  //    License as published by the Free Software Foundation; either
  2765  //    version 2.1 of the License, or (at your option) any later version.
  2766  //
  2767  //    The GNU C Library is distributed in the hope that it will be useful,
  2768  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  2769  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  2770  //    Lesser General Public License for more details.
  2771  //
  2772  //    You should have received a copy of the GNU Lesser General Public
  2773  //    License along with the GNU C Library; if not, see
  2774  //    <https://www.gnu.org/licenses/>.
  2775  
  2776  //	POSIX 1003.1g: 6.2 Select from File Descriptor Sets <sys/select.h>
  2777  
  2778  // Copyright (C) 1991-2020 Free Software Foundation, Inc.
  2779  //    This file is part of the GNU C Library.
  2780  //
  2781  //    The GNU C Library is free software; you can redistribute it and/or
  2782  //    modify it under the terms of the GNU Lesser General Public
  2783  //    License as published by the Free Software Foundation; either
  2784  //    version 2.1 of the License, or (at your option) any later version.
  2785  //
  2786  //    The GNU C Library is distributed in the hope that it will be useful,
  2787  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  2788  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  2789  //    Lesser General Public License for more details.
  2790  //
  2791  //    You should have received a copy of the GNU Lesser General Public
  2792  //    License along with the GNU C Library; if not, see
  2793  //    <https://www.gnu.org/licenses/>.
  2794  
  2795  // Get definition of needed basic types.
  2796  // bits/types.h -- definitions of __*_t types underlying *_t types.
  2797  //    Copyright (C) 2002-2020 Free Software Foundation, Inc.
  2798  //    This file is part of the GNU C Library.
  2799  //
  2800  //    The GNU C Library is free software; you can redistribute it and/or
  2801  //    modify it under the terms of the GNU Lesser General Public
  2802  //    License as published by the Free Software Foundation; either
  2803  //    version 2.1 of the License, or (at your option) any later version.
  2804  //
  2805  //    The GNU C Library is distributed in the hope that it will be useful,
  2806  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  2807  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  2808  //    Lesser General Public License for more details.
  2809  //
  2810  //    You should have received a copy of the GNU Lesser General Public
  2811  //    License along with the GNU C Library; if not, see
  2812  //    <https://www.gnu.org/licenses/>.
  2813  
  2814  // Never include this file directly; use <sys/types.h> instead.
  2815  
  2816  // Get __FD_* definitions.
  2817  // Copyright (C) 1997-2020 Free Software Foundation, Inc.
  2818  //    This file is part of the GNU C Library.
  2819  //
  2820  //    The GNU C Library is free software; you can redistribute it and/or
  2821  //    modify it under the terms of the GNU Lesser General Public
  2822  //    License as published by the Free Software Foundation; either
  2823  //    version 2.1 of the License, or (at your option) any later version.
  2824  //
  2825  //    The GNU C Library is distributed in the hope that it will be useful,
  2826  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  2827  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  2828  //    Lesser General Public License for more details.
  2829  //
  2830  //    You should have received a copy of the GNU Lesser General Public
  2831  //    License along with the GNU C Library; if not, see
  2832  //    <https://www.gnu.org/licenses/>.
  2833  
  2834  // We don't use `memset' because this would require a prototype and
  2835  //    the array isn't too big.
  2836  
  2837  // Get sigset_t.
  2838  
  2839  type X__sigset_t = struct{ F__val [16]uint64 } /* __sigset_t.h:8:3 */
  2840  
  2841  // A set of signals to be blocked, unblocked, or waited for.
  2842  type Sigset_t = X__sigset_t /* sigset_t.h:7:20 */
  2843  
  2844  // Get definition of timer specification structures.
  2845  
  2846  // bits/types.h -- definitions of __*_t types underlying *_t types.
  2847  //    Copyright (C) 2002-2020 Free Software Foundation, Inc.
  2848  //    This file is part of the GNU C Library.
  2849  //
  2850  //    The GNU C Library is free software; you can redistribute it and/or
  2851  //    modify it under the terms of the GNU Lesser General Public
  2852  //    License as published by the Free Software Foundation; either
  2853  //    version 2.1 of the License, or (at your option) any later version.
  2854  //
  2855  //    The GNU C Library is distributed in the hope that it will be useful,
  2856  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  2857  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  2858  //    Lesser General Public License for more details.
  2859  //
  2860  //    You should have received a copy of the GNU Lesser General Public
  2861  //    License along with the GNU C Library; if not, see
  2862  //    <https://www.gnu.org/licenses/>.
  2863  
  2864  // Never include this file directly; use <sys/types.h> instead.
  2865  
  2866  // A time value that is accurate to the nearest
  2867  //    microsecond but also has a range of years.
  2868  type Timeval = struct {
  2869  	Ftv_sec  X__time_t
  2870  	Ftv_usec X__suseconds_t
  2871  } /* struct_timeval.h:8:1 */
  2872  
  2873  // NB: Include guard matches what <linux/time.h> uses.
  2874  
  2875  // bits/types.h -- definitions of __*_t types underlying *_t types.
  2876  //    Copyright (C) 2002-2020 Free Software Foundation, Inc.
  2877  //    This file is part of the GNU C Library.
  2878  //
  2879  //    The GNU C Library is free software; you can redistribute it and/or
  2880  //    modify it under the terms of the GNU Lesser General Public
  2881  //    License as published by the Free Software Foundation; either
  2882  //    version 2.1 of the License, or (at your option) any later version.
  2883  //
  2884  //    The GNU C Library is distributed in the hope that it will be useful,
  2885  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  2886  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  2887  //    Lesser General Public License for more details.
  2888  //
  2889  //    You should have received a copy of the GNU Lesser General Public
  2890  //    License along with the GNU C Library; if not, see
  2891  //    <https://www.gnu.org/licenses/>.
  2892  
  2893  // Never include this file directly; use <sys/types.h> instead.
  2894  
  2895  // Endian macros for string.h functions
  2896  //    Copyright (C) 1992-2020 Free Software Foundation, Inc.
  2897  //    This file is part of the GNU C Library.
  2898  //
  2899  //    The GNU C Library is free software; you can redistribute it and/or
  2900  //    modify it under the terms of the GNU Lesser General Public
  2901  //    License as published by the Free Software Foundation; either
  2902  //    version 2.1 of the License, or (at your option) any later version.
  2903  //
  2904  //    The GNU C Library is distributed in the hope that it will be useful,
  2905  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  2906  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  2907  //    Lesser General Public License for more details.
  2908  //
  2909  //    You should have received a copy of the GNU Lesser General Public
  2910  //    License along with the GNU C Library; if not, see
  2911  //    <http://www.gnu.org/licenses/>.
  2912  
  2913  // POSIX.1b structure for a time value.  This is like a `struct timeval' but
  2914  //    has nanoseconds instead of microseconds.
  2915  type Timespec = struct {
  2916  	Ftv_sec  X__time_t
  2917  	Ftv_nsec X__syscall_slong_t
  2918  } /* struct_timespec.h:10:1 */
  2919  
  2920  type Suseconds_t = X__suseconds_t /* select.h:43:23 */
  2921  
  2922  // The fd_set member is required to be an array of longs.
  2923  type X__fd_mask = int64 /* select.h:49:18 */
  2924  
  2925  // Some versions of <linux/posix_types.h> define this macros.
  2926  // It's easier to assume 8-bit bytes than to get CHAR_BIT.
  2927  
  2928  // fd_set for select and pselect.
  2929  type Fd_set = struct{ F__fds_bits [16]X__fd_mask } /* select.h:70:5 */
  2930  
  2931  // Maximum number of file descriptors in `fd_set'.
  2932  
  2933  // Sometimes the fd_set member is assumed to have this type.
  2934  type Fd_mask = X__fd_mask /* select.h:77:19 */
  2935  
  2936  // Define some inlines helping to catch common problems.
  2937  
  2938  type Blksize_t = X__blksize_t /* types.h:185:21 */
  2939  
  2940  // Types from the Large File Support interface.
  2941  type Blkcnt_t = X__blkcnt64_t     /* types.h:205:22 */ // Type to count number of disk blocks.
  2942  type Fsblkcnt_t = X__fsblkcnt64_t /* types.h:209:24 */ // Type to count file system blocks.
  2943  type Fsfilcnt_t = X__fsfilcnt64_t /* types.h:213:24 */ // Type to count file system inodes.
  2944  
  2945  type Blkcnt64_t = X__blkcnt64_t     /* types.h:219:22 */ // Type to count number of disk blocks.
  2946  type Fsblkcnt64_t = X__fsblkcnt64_t /* types.h:220:24 */ // Type to count file system blocks.
  2947  type Fsfilcnt64_t = X__fsfilcnt64_t /* types.h:221:24 */ // Type to count file system inodes.
  2948  
  2949  // Now add the thread types.
  2950  // Declaration of common pthread types for all architectures.
  2951  //    Copyright (C) 2017-2020 Free Software Foundation, Inc.
  2952  //    This file is part of the GNU C Library.
  2953  //
  2954  //    The GNU C Library is free software; you can redistribute it and/or
  2955  //    modify it under the terms of the GNU Lesser General Public
  2956  //    License as published by the Free Software Foundation; either
  2957  //    version 2.1 of the License, or (at your option) any later version.
  2958  //
  2959  //    The GNU C Library is distributed in the hope that it will be useful,
  2960  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  2961  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  2962  //    Lesser General Public License for more details.
  2963  //
  2964  //    You should have received a copy of the GNU Lesser General Public
  2965  //    License along with the GNU C Library; if not, see
  2966  //    <https://www.gnu.org/licenses/>.
  2967  
  2968  // For internal mutex and condition variable definitions.
  2969  // Common threading primitives definitions for both POSIX and C11.
  2970  //    Copyright (C) 2017-2020 Free Software Foundation, Inc.
  2971  //    This file is part of the GNU C Library.
  2972  //
  2973  //    The GNU C Library is free software; you can redistribute it and/or
  2974  //    modify it under the terms of the GNU Lesser General Public
  2975  //    License as published by the Free Software Foundation; either
  2976  //    version 2.1 of the License, or (at your option) any later version.
  2977  //
  2978  //    The GNU C Library is distributed in the hope that it will be useful,
  2979  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  2980  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  2981  //    Lesser General Public License for more details.
  2982  //
  2983  //    You should have received a copy of the GNU Lesser General Public
  2984  //    License along with the GNU C Library; if not, see
  2985  //    <https://www.gnu.org/licenses/>.
  2986  
  2987  // Arch-specific definitions.  Each architecture must define the following
  2988  //    macros to define the expected sizes of pthread data types:
  2989  //
  2990  //    __SIZEOF_PTHREAD_ATTR_T        - size of pthread_attr_t.
  2991  //    __SIZEOF_PTHREAD_MUTEX_T       - size of pthread_mutex_t.
  2992  //    __SIZEOF_PTHREAD_MUTEXATTR_T   - size of pthread_mutexattr_t.
  2993  //    __SIZEOF_PTHREAD_COND_T        - size of pthread_cond_t.
  2994  //    __SIZEOF_PTHREAD_CONDATTR_T    - size of pthread_condattr_t.
  2995  //    __SIZEOF_PTHREAD_RWLOCK_T      - size of pthread_rwlock_t.
  2996  //    __SIZEOF_PTHREAD_RWLOCKATTR_T  - size of pthread_rwlockattr_t.
  2997  //    __SIZEOF_PTHREAD_BARRIER_T     - size of pthread_barrier_t.
  2998  //    __SIZEOF_PTHREAD_BARRIERATTR_T - size of pthread_barrierattr_t.
  2999  //
  3000  //    The additional macro defines any constraint for the lock alignment
  3001  //    inside the thread structures:
  3002  //
  3003  //    __LOCK_ALIGNMENT - for internal lock/futex usage.
  3004  //
  3005  //    Same idea but for the once locking primitive:
  3006  //
  3007  //    __ONCE_ALIGNMENT - for pthread_once_t/once_flag definition.
  3008  
  3009  // Machine-specific pthread type layouts.  Generic version.
  3010  //    Copyright (C) 2019-2020 Free Software Foundation, Inc.
  3011  //
  3012  //    This file is part of the GNU C Library.
  3013  //
  3014  //    The GNU C Library is free software; you can redistribute it and/or
  3015  //    modify it under the terms of the GNU Lesser General Public
  3016  //    License as published by the Free Software Foundation; either
  3017  //    version 2.1 of the License, or (at your option) any later version.
  3018  //
  3019  //    The GNU C Library is distributed in the hope that it will be useful,
  3020  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  3021  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  3022  //    Lesser General Public License for more details.
  3023  //
  3024  //    You should have received a copy of the GNU Lesser General Public
  3025  //    License along with the GNU C Library; if not, see
  3026  //    <http://www.gnu.org/licenses/>.
  3027  
  3028  // Determine the wordsize from the preprocessor defines.
  3029  
  3030  // Common definition of pthread_mutex_t.
  3031  
  3032  type X__pthread_internal_list = struct {
  3033  	F__prev uintptr
  3034  	F__next uintptr
  3035  } /* thread-shared-types.h:49:9 */
  3036  
  3037  // Type to count file system inodes.
  3038  
  3039  // Now add the thread types.
  3040  // Declaration of common pthread types for all architectures.
  3041  //    Copyright (C) 2017-2020 Free Software Foundation, Inc.
  3042  //    This file is part of the GNU C Library.
  3043  //
  3044  //    The GNU C Library is free software; you can redistribute it and/or
  3045  //    modify it under the terms of the GNU Lesser General Public
  3046  //    License as published by the Free Software Foundation; either
  3047  //    version 2.1 of the License, or (at your option) any later version.
  3048  //
  3049  //    The GNU C Library is distributed in the hope that it will be useful,
  3050  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  3051  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  3052  //    Lesser General Public License for more details.
  3053  //
  3054  //    You should have received a copy of the GNU Lesser General Public
  3055  //    License along with the GNU C Library; if not, see
  3056  //    <https://www.gnu.org/licenses/>.
  3057  
  3058  // For internal mutex and condition variable definitions.
  3059  // Common threading primitives definitions for both POSIX and C11.
  3060  //    Copyright (C) 2017-2020 Free Software Foundation, Inc.
  3061  //    This file is part of the GNU C Library.
  3062  //
  3063  //    The GNU C Library is free software; you can redistribute it and/or
  3064  //    modify it under the terms of the GNU Lesser General Public
  3065  //    License as published by the Free Software Foundation; either
  3066  //    version 2.1 of the License, or (at your option) any later version.
  3067  //
  3068  //    The GNU C Library is distributed in the hope that it will be useful,
  3069  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  3070  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  3071  //    Lesser General Public License for more details.
  3072  //
  3073  //    You should have received a copy of the GNU Lesser General Public
  3074  //    License along with the GNU C Library; if not, see
  3075  //    <https://www.gnu.org/licenses/>.
  3076  
  3077  // Arch-specific definitions.  Each architecture must define the following
  3078  //    macros to define the expected sizes of pthread data types:
  3079  //
  3080  //    __SIZEOF_PTHREAD_ATTR_T        - size of pthread_attr_t.
  3081  //    __SIZEOF_PTHREAD_MUTEX_T       - size of pthread_mutex_t.
  3082  //    __SIZEOF_PTHREAD_MUTEXATTR_T   - size of pthread_mutexattr_t.
  3083  //    __SIZEOF_PTHREAD_COND_T        - size of pthread_cond_t.
  3084  //    __SIZEOF_PTHREAD_CONDATTR_T    - size of pthread_condattr_t.
  3085  //    __SIZEOF_PTHREAD_RWLOCK_T      - size of pthread_rwlock_t.
  3086  //    __SIZEOF_PTHREAD_RWLOCKATTR_T  - size of pthread_rwlockattr_t.
  3087  //    __SIZEOF_PTHREAD_BARRIER_T     - size of pthread_barrier_t.
  3088  //    __SIZEOF_PTHREAD_BARRIERATTR_T - size of pthread_barrierattr_t.
  3089  //
  3090  //    The additional macro defines any constraint for the lock alignment
  3091  //    inside the thread structures:
  3092  //
  3093  //    __LOCK_ALIGNMENT - for internal lock/futex usage.
  3094  //
  3095  //    Same idea but for the once locking primitive:
  3096  //
  3097  //    __ONCE_ALIGNMENT - for pthread_once_t/once_flag definition.
  3098  
  3099  // Machine-specific pthread type layouts.  Generic version.
  3100  //    Copyright (C) 2019-2020 Free Software Foundation, Inc.
  3101  //
  3102  //    This file is part of the GNU C Library.
  3103  //
  3104  //    The GNU C Library is free software; you can redistribute it and/or
  3105  //    modify it under the terms of the GNU Lesser General Public
  3106  //    License as published by the Free Software Foundation; either
  3107  //    version 2.1 of the License, or (at your option) any later version.
  3108  //
  3109  //    The GNU C Library is distributed in the hope that it will be useful,
  3110  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  3111  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  3112  //    Lesser General Public License for more details.
  3113  //
  3114  //    You should have received a copy of the GNU Lesser General Public
  3115  //    License along with the GNU C Library; if not, see
  3116  //    <http://www.gnu.org/licenses/>.
  3117  
  3118  // Determine the wordsize from the preprocessor defines.
  3119  
  3120  // Common definition of pthread_mutex_t.
  3121  
  3122  type X__pthread_list_t = X__pthread_internal_list /* thread-shared-types.h:53:3 */
  3123  
  3124  type X__pthread_internal_slist = struct{ F__next uintptr } /* thread-shared-types.h:55:9 */
  3125  
  3126  type X__pthread_slist_t = X__pthread_internal_slist /* thread-shared-types.h:58:3 */
  3127  
  3128  // Arch-specific mutex definitions.  A generic implementation is provided
  3129  //    by sysdeps/nptl/bits/struct_mutex.h.  If required, an architecture
  3130  //    can override it by defining:
  3131  //
  3132  //    1. struct __pthread_mutex_s (used on both pthread_mutex_t and mtx_t
  3133  //       definition).  It should contains at least the internal members
  3134  //       defined in the generic version.
  3135  //
  3136  //    2. __LOCK_ALIGNMENT for any extra attribute for internal lock used with
  3137  //       atomic operations.
  3138  //
  3139  //    3. The macro __PTHREAD_MUTEX_INITIALIZER used for static initialization.
  3140  //       It should initialize the mutex internal flag.
  3141  
  3142  // PowerPC internal mutex struct definitions.
  3143  //    Copyright (C) 2019-2020 Free Software Foundation, Inc.
  3144  //    This file is part of the GNU C Library.
  3145  //
  3146  //    The GNU C Library is free software; you can redistribute it and/or
  3147  //    modify it under the terms of the GNU Lesser General Public
  3148  //    License as published by the Free Software Foundation; either
  3149  //    version 2.1 of the License, or (at your option) any later version.
  3150  //
  3151  //    The GNU C Library is distributed in the hope that it will be useful,
  3152  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  3153  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  3154  //    Lesser General Public License for more details.
  3155  //
  3156  //    You should have received a copy of the GNU Lesser General Public
  3157  //    License along with the GNU C Library; if not, see
  3158  //    <http://www.gnu.org/licenses/>.
  3159  
  3160  type X__pthread_mutex_s = struct {
  3161  	F__lock    int32
  3162  	F__count   uint32
  3163  	F__owner   int32
  3164  	F__nusers  uint32
  3165  	F__kind    int32
  3166  	F__spins   int16
  3167  	F__elision int16
  3168  	F__list    X__pthread_list_t
  3169  } /* struct_mutex.h:22:1 */
  3170  
  3171  // Arch-sepecific read-write lock definitions.  A generic implementation is
  3172  //    provided by struct_rwlock.h.  If required, an architecture can override it
  3173  //    by defining:
  3174  //
  3175  //    1. struct __pthread_rwlock_arch_t (used on pthread_rwlock_t definition).
  3176  //       It should contain at least the internal members defined in the
  3177  //       generic version.
  3178  //
  3179  //    2. The macro __PTHREAD_RWLOCK_INITIALIZER used for static initialization.
  3180  //       It should initialize the rwlock internal type.
  3181  
  3182  // PowerPC internal rwlock struct definitions.
  3183  //    Copyright (C) 2019-2020 Free Software Foundation, Inc.
  3184  //
  3185  //    This file is part of the GNU C Library.
  3186  //
  3187  //    The GNU C Library is free software; you can redistribute it and/or
  3188  //    modify it under the terms of the GNU Lesser General Public
  3189  //    License as published by the Free Software Foundation; either
  3190  //    version 2.1 of the License, or (at your option) any later version.
  3191  //
  3192  //    The GNU C Library is distributed in the hope that it will be useful,
  3193  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  3194  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  3195  //    Lesser General Public License for more details.
  3196  //
  3197  //    You should have received a copy of the GNU Lesser General Public
  3198  //    License along with the GNU C Library; if not, see
  3199  //    <http://www.gnu.org/licenses/>.
  3200  
  3201  type X__pthread_rwlock_arch_t = struct {
  3202  	F__readers       uint32
  3203  	F__writers       uint32
  3204  	F__wrphase_futex uint32
  3205  	F__writers_futex uint32
  3206  	F__pad3          uint32
  3207  	F__pad4          uint32
  3208  	F__cur_writer    int32
  3209  	F__shared        int32
  3210  	F__rwelision     uint8
  3211  	F__pad1          [7]uint8
  3212  	F__pad2          uint64
  3213  	F__flags         uint32
  3214  	F__ccgo_pad1     [4]byte
  3215  } /* struct_rwlock.h:23:1 */
  3216  
  3217  // Common definition of pthread_cond_t.
  3218  
  3219  type X__pthread_cond_s = struct {
  3220  	F__0            struct{ F__wseq uint64 }
  3221  	F__8            struct{ F__g1_start uint64 }
  3222  	F__g_refs       [2]uint32
  3223  	F__g_size       [2]uint32
  3224  	F__g1_orig_size uint32
  3225  	F__wrefs        uint32
  3226  	F__g_signals    [2]uint32
  3227  } /* thread-shared-types.h:92:1 */
  3228  
  3229  // Thread identifiers.  The structure of the attribute type is not
  3230  //    exposed on purpose.
  3231  type Pthread_t = uint64 /* pthreadtypes.h:27:27 */
  3232  
  3233  // Data structures for mutex handling.  The structure of the attribute
  3234  //    type is not exposed on purpose.
  3235  type Pthread_mutexattr_t = struct {
  3236  	F__ccgo_pad1 [0]uint32
  3237  	F__size      [4]uint8
  3238  } /* pthreadtypes.h:36:3 */
  3239  
  3240  // Data structure for condition variable handling.  The structure of
  3241  //    the attribute type is not exposed on purpose.
  3242  type Pthread_condattr_t = struct {
  3243  	F__ccgo_pad1 [0]uint32
  3244  	F__size      [4]uint8
  3245  } /* pthreadtypes.h:45:3 */
  3246  
  3247  // Keys for thread-specific data
  3248  type Pthread_key_t = uint32 /* pthreadtypes.h:49:22 */
  3249  
  3250  // Once-only execution
  3251  type Pthread_once_t = int32 /* pthreadtypes.h:53:30 */
  3252  
  3253  type Pthread_attr_t1 = struct {
  3254  	F__ccgo_pad1 [0]uint64
  3255  	F__size      [56]uint8
  3256  } /* pthreadtypes.h:56:1 */
  3257  
  3258  type Pthread_attr_t = Pthread_attr_t1 /* pthreadtypes.h:62:30 */
  3259  
  3260  type Pthread_mutex_t = struct{ F__data X__pthread_mutex_s } /* pthreadtypes.h:72:3 */
  3261  
  3262  type Pthread_cond_t = struct{ F__data X__pthread_cond_s } /* pthreadtypes.h:80:3 */
  3263  
  3264  // Data structure for reader-writer lock variable handling.  The
  3265  //    structure of the attribute type is deliberately not exposed.
  3266  type Pthread_rwlock_t = struct{ F__data X__pthread_rwlock_arch_t } /* pthreadtypes.h:91:3 */
  3267  
  3268  type Pthread_rwlockattr_t = struct {
  3269  	F__ccgo_pad1 [0]uint64
  3270  	F__size      [8]uint8
  3271  } /* pthreadtypes.h:97:3 */
  3272  
  3273  // POSIX spinlock data type.
  3274  type Pthread_spinlock_t = int32 /* pthreadtypes.h:103:22 */
  3275  
  3276  // POSIX barriers data type.  The structure of the type is
  3277  //    deliberately not exposed.
  3278  type Pthread_barrier_t = struct {
  3279  	F__ccgo_pad1 [0]uint64
  3280  	F__size      [32]uint8
  3281  } /* pthreadtypes.h:112:3 */
  3282  
  3283  type Pthread_barrierattr_t = struct {
  3284  	F__ccgo_pad1 [0]uint32
  3285  	F__size      [4]uint8
  3286  } /* pthreadtypes.h:118:3 */
  3287  
  3288  // Copyright (C) 1989-2020 Free Software Foundation, Inc.
  3289  //
  3290  // This file is part of GCC.
  3291  //
  3292  // GCC is free software; you can redistribute it and/or modify
  3293  // it under the terms of the GNU General Public License as published by
  3294  // the Free Software Foundation; either version 3, or (at your option)
  3295  // any later version.
  3296  //
  3297  // GCC is distributed in the hope that it will be useful,
  3298  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  3299  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  3300  // GNU General Public License for more details.
  3301  //
  3302  // Under Section 7 of GPL version 3, you are granted additional
  3303  // permissions described in the GCC Runtime Library Exception, version
  3304  // 3.1, as published by the Free Software Foundation.
  3305  //
  3306  // You should have received a copy of the GNU General Public License and
  3307  // a copy of the GCC Runtime Library Exception along with this program;
  3308  // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  3309  // <http://www.gnu.org/licenses/>.
  3310  
  3311  // ISO C Standard:  7.15  Variable arguments  <stdarg.h>
  3312  
  3313  // Define __gnuc_va_list.
  3314  
  3315  type X__gnuc_va_list = X__builtin_va_list /* stdarg.h:40:27 */
  3316  
  3317  // Define the standard macros for the user,
  3318  //    if this invocation was from the user program.
  3319  
  3320  // Define va_list, if desired, from __gnuc_va_list.
  3321  // We deliberately do not define va_list when called from
  3322  //    stdio.h, because ANSI C says that stdio.h is not supposed to define
  3323  //    va_list.  stdio.h needs to have access to that data type,
  3324  //    but must not use that name.  It should use the name __gnuc_va_list,
  3325  //    which is safe because it is reserved for the implementation.
  3326  
  3327  // The macro _VA_LIST_ is the same thing used by this file in Ultrix.
  3328  //    But on BSD NET2 we must not test or define or undef it.
  3329  //    (Note that the comments in NET 2's ansi.h
  3330  //    are incorrect for _VA_LIST_--see stdio.h!)
  3331  // The macro _VA_LIST_DEFINED is used in Windows NT 3.5
  3332  // The macro _VA_LIST is used in SCO Unix 3.2.
  3333  // The macro _VA_LIST_T_H is used in the Bull dpx2
  3334  // The macro __va_list__ is used by BeOS.
  3335  type Va_list = X__gnuc_va_list /* stdarg.h:99:24 */
  3336  
  3337  // a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
  3338  // "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even
  3339  // though the former does not conform to the LFS document), but considering
  3340  // both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
  3341  // equivalently requesting no 64-bit operations
  3342  
  3343  // Copyright (C) 1991-2020 Free Software Foundation, Inc.
  3344  //    This file is part of the GNU C Library.
  3345  //
  3346  //    The GNU C Library is free software; you can redistribute it and/or
  3347  //    modify it under the terms of the GNU Lesser General Public
  3348  //    License as published by the Free Software Foundation; either
  3349  //    version 2.1 of the License, or (at your option) any later version.
  3350  //
  3351  //    The GNU C Library is distributed in the hope that it will be useful,
  3352  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  3353  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  3354  //    Lesser General Public License for more details.
  3355  //
  3356  //    You should have received a copy of the GNU Lesser General Public
  3357  //    License along with the GNU C Library; if not, see
  3358  //    <https://www.gnu.org/licenses/>.
  3359  
  3360  //	POSIX Standard: 2.10 Symbolic Constants		<unistd.h>
  3361  
  3362  // Copyright (C) 1991-2020 Free Software Foundation, Inc.
  3363  //    This file is part of the GNU C Library.
  3364  //
  3365  //    The GNU C Library is free software; you can redistribute it and/or
  3366  //    modify it under the terms of the GNU Lesser General Public
  3367  //    License as published by the Free Software Foundation; either
  3368  //    version 2.1 of the License, or (at your option) any later version.
  3369  //
  3370  //    The GNU C Library is distributed in the hope that it will be useful,
  3371  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  3372  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  3373  //    Lesser General Public License for more details.
  3374  //
  3375  //    You should have received a copy of the GNU Lesser General Public
  3376  //    License along with the GNU C Library; if not, see
  3377  //    <https://www.gnu.org/licenses/>.
  3378  
  3379  // These may be used to determine what facilities are present at compile time.
  3380  //    Their values can be obtained at run time from `sysconf'.
  3381  
  3382  // POSIX Standard approved as ISO/IEC 9945-1 as of September 2008.
  3383  
  3384  // These are not #ifdef __USE_POSIX2 because they are
  3385  //    in the theoretically application-owned namespace.
  3386  
  3387  // The utilities on GNU systems also correspond to this version.
  3388  
  3389  // The utilities on GNU systems also correspond to this version.
  3390  
  3391  // This symbol was required until the 2001 edition of POSIX.
  3392  
  3393  // If defined, the implementation supports the
  3394  //    C Language Bindings Option.
  3395  
  3396  // If defined, the implementation supports the
  3397  //    C Language Development Utilities Option.
  3398  
  3399  // If defined, the implementation supports the
  3400  //    Software Development Utilities Option.
  3401  
  3402  // If defined, the implementation supports the
  3403  //    creation of locales with the localedef utility.
  3404  
  3405  // X/Open version number to which the library conforms.  It is selectable.
  3406  
  3407  // Commands and utilities from XPG4 are available.
  3408  
  3409  // We are compatible with the old published standards as well.
  3410  
  3411  // The X/Open Unix extensions are available.
  3412  
  3413  // The enhanced internationalization capabilities according to XPG4.2
  3414  //    are present.
  3415  
  3416  // The legacy interfaces are also available.
  3417  
  3418  // Get values of POSIX options:
  3419  //
  3420  //    If these symbols are defined, the corresponding features are
  3421  //    always available.  If not, they may be available sometimes.
  3422  //    The current values can be obtained with `sysconf'.
  3423  //
  3424  //    _POSIX_JOB_CONTROL		Job control is supported.
  3425  //    _POSIX_SAVED_IDS		Processes have a saved set-user-ID
  3426  // 				and a saved set-group-ID.
  3427  //    _POSIX_REALTIME_SIGNALS	Real-time, queued signals are supported.
  3428  //    _POSIX_PRIORITY_SCHEDULING	Priority scheduling is supported.
  3429  //    _POSIX_TIMERS		POSIX.4 clocks and timers are supported.
  3430  //    _POSIX_ASYNCHRONOUS_IO	Asynchronous I/O is supported.
  3431  //    _POSIX_PRIORITIZED_IO	Prioritized asynchronous I/O is supported.
  3432  //    _POSIX_SYNCHRONIZED_IO	Synchronizing file data is supported.
  3433  //    _POSIX_FSYNC			The fsync function is present.
  3434  //    _POSIX_MAPPED_FILES		Mapping of files to memory is supported.
  3435  //    _POSIX_MEMLOCK		Locking of all memory is supported.
  3436  //    _POSIX_MEMLOCK_RANGE		Locking of ranges of memory is supported.
  3437  //    _POSIX_MEMORY_PROTECTION	Setting of memory protections is supported.
  3438  //    _POSIX_MESSAGE_PASSING	POSIX.4 message queues are supported.
  3439  //    _POSIX_SEMAPHORES		POSIX.4 counting semaphores are supported.
  3440  //    _POSIX_SHARED_MEMORY_OBJECTS	POSIX.4 shared memory objects are supported.
  3441  //    _POSIX_THREADS		POSIX.1c pthreads are supported.
  3442  //    _POSIX_THREAD_ATTR_STACKADDR	Thread stack address attribute option supported.
  3443  //    _POSIX_THREAD_ATTR_STACKSIZE	Thread stack size attribute option supported.
  3444  //    _POSIX_THREAD_SAFE_FUNCTIONS	Thread-safe functions are supported.
  3445  //    _POSIX_THREAD_PRIORITY_SCHEDULING
  3446  // 				POSIX.1c thread execution scheduling supported.
  3447  //    _POSIX_THREAD_PRIO_INHERIT	Thread priority inheritance option supported.
  3448  //    _POSIX_THREAD_PRIO_PROTECT	Thread priority protection option supported.
  3449  //    _POSIX_THREAD_PROCESS_SHARED	Process-shared synchronization supported.
  3450  //    _POSIX_PII			Protocol-independent interfaces are supported.
  3451  //    _POSIX_PII_XTI		XTI protocol-indep. interfaces are supported.
  3452  //    _POSIX_PII_SOCKET		Socket protocol-indep. interfaces are supported.
  3453  //    _POSIX_PII_INTERNET		Internet family of protocols supported.
  3454  //    _POSIX_PII_INTERNET_STREAM	Connection-mode Internet protocol supported.
  3455  //    _POSIX_PII_INTERNET_DGRAM	Connectionless Internet protocol supported.
  3456  //    _POSIX_PII_OSI		ISO/OSI family of protocols supported.
  3457  //    _POSIX_PII_OSI_COTS		Connection-mode ISO/OSI service supported.
  3458  //    _POSIX_PII_OSI_CLTS		Connectionless ISO/OSI service supported.
  3459  //    _POSIX_POLL			Implementation supports `poll' function.
  3460  //    _POSIX_SELECT		Implementation supports `select' and `pselect'.
  3461  //
  3462  //    _XOPEN_REALTIME		X/Open realtime support is available.
  3463  //    _XOPEN_REALTIME_THREADS	X/Open realtime thread support is available.
  3464  //    _XOPEN_SHM			Shared memory interface according to XPG4.2.
  3465  //
  3466  //    _XBS5_ILP32_OFF32		Implementation provides environment with 32-bit
  3467  // 				int, long, pointer, and off_t types.
  3468  //    _XBS5_ILP32_OFFBIG		Implementation provides environment with 32-bit
  3469  // 				int, long, and pointer and off_t with at least
  3470  // 				64 bits.
  3471  //    _XBS5_LP64_OFF64		Implementation provides environment with 32-bit
  3472  // 				int, and 64-bit long, pointer, and off_t types.
  3473  //    _XBS5_LPBIG_OFFBIG		Implementation provides environment with at
  3474  // 				least 32 bits int and long, pointer, and off_t
  3475  // 				with at least 64 bits.
  3476  //
  3477  //    If any of these symbols is defined as -1, the corresponding option is not
  3478  //    true for any file.  If any is defined as other than -1, the corresponding
  3479  //    option is true for all files.  If a symbol is not defined at all, the value
  3480  //    for a specific file can be obtained from `pathconf' and `fpathconf'.
  3481  //
  3482  //    _POSIX_CHOWN_RESTRICTED	Only the super user can use `chown' to change
  3483  // 				the owner of a file.  `chown' can only be used
  3484  // 				to change the group ID of a file to a group of
  3485  // 				which the calling process is a member.
  3486  //    _POSIX_NO_TRUNC		Pathname components longer than
  3487  // 				NAME_MAX generate an error.
  3488  //    _POSIX_VDISABLE		If defined, if the value of an element of the
  3489  // 				`c_cc' member of `struct termios' is
  3490  // 				_POSIX_VDISABLE, no character will have the
  3491  // 				effect associated with that element.
  3492  //    _POSIX_SYNC_IO		Synchronous I/O may be performed.
  3493  //    _POSIX_ASYNC_IO		Asynchronous I/O may be performed.
  3494  //    _POSIX_PRIO_IO		Prioritized Asynchronous I/O may be performed.
  3495  //
  3496  //    Support for the Large File Support interface is not generally available.
  3497  //    If it is available the following constants are defined to one.
  3498  //    _LFS64_LARGEFILE		Low-level I/O supports large files.
  3499  //    _LFS64_STDIO			Standard I/O supports large files.
  3500  //
  3501  
  3502  // Define POSIX options for Linux.
  3503  //    Copyright (C) 1996-2020 Free Software Foundation, Inc.
  3504  //    This file is part of the GNU C Library.
  3505  //
  3506  //    The GNU C Library is free software; you can redistribute it and/or
  3507  //    modify it under the terms of the GNU Lesser General Public License as
  3508  //    published by the Free Software Foundation; either version 2.1 of the
  3509  //    License, or (at your option) any later version.
  3510  //
  3511  //    The GNU C Library is distributed in the hope that it will be useful,
  3512  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  3513  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  3514  //    Lesser General Public License for more details.
  3515  //
  3516  //    You should have received a copy of the GNU Lesser General Public
  3517  //    License along with the GNU C Library; see the file COPYING.LIB.  If
  3518  //    not, see <https://www.gnu.org/licenses/>.
  3519  
  3520  // Job control is supported.
  3521  
  3522  // Processes have a saved set-user-ID and a saved set-group-ID.
  3523  
  3524  // Priority scheduling is not supported with the correct semantics,
  3525  //    but GNU/Linux applications expect that the corresponding interfaces
  3526  //    are available, even though the semantics do not meet the POSIX
  3527  //    requirements.  See glibc bug 14829.
  3528  
  3529  // Synchronizing file data is supported.
  3530  
  3531  // The fsync function is present.
  3532  
  3533  // Mapping of files to memory is supported.
  3534  
  3535  // Locking of all memory is supported.
  3536  
  3537  // Locking of ranges of memory is supported.
  3538  
  3539  // Setting of memory protections is supported.
  3540  
  3541  // Some filesystems allow all users to change file ownership.
  3542  
  3543  // `c_cc' member of 'struct termios' structure can be disabled by
  3544  //    using the value _POSIX_VDISABLE.
  3545  
  3546  // Filenames are not silently truncated.
  3547  
  3548  // X/Open realtime support is available.
  3549  
  3550  // X/Open thread realtime support is available.
  3551  
  3552  // XPG4.2 shared memory is supported.
  3553  
  3554  // Tell we have POSIX threads.
  3555  
  3556  // We have the reentrant functions described in POSIX.
  3557  
  3558  // We provide priority scheduling for threads.
  3559  
  3560  // We support user-defined stack sizes.
  3561  
  3562  // We support user-defined stacks.
  3563  
  3564  // We support priority inheritence.
  3565  
  3566  // We support priority protection, though only for non-robust
  3567  //    mutexes.
  3568  
  3569  // We support priority inheritence for robust mutexes.
  3570  
  3571  // We do not support priority protection for robust mutexes.
  3572  
  3573  // We support POSIX.1b semaphores.
  3574  
  3575  // Real-time signals are supported.
  3576  
  3577  // We support asynchronous I/O.
  3578  // Alternative name for Unix98.
  3579  // Support for prioritization is also available.
  3580  
  3581  // The LFS support in asynchronous I/O is also available.
  3582  
  3583  // The rest of the LFS is also available.
  3584  
  3585  // POSIX shared memory objects are implemented.
  3586  
  3587  // CPU-time clocks support needs to be checked at runtime.
  3588  
  3589  // Clock support in threads must be also checked at runtime.
  3590  
  3591  // GNU libc provides regular expression handling.
  3592  
  3593  // Reader/Writer locks are available.
  3594  
  3595  // We have a POSIX shell.
  3596  
  3597  // We support the Timeouts option.
  3598  
  3599  // We support spinlocks.
  3600  
  3601  // The `spawn' function family is supported.
  3602  
  3603  // We have POSIX timers.
  3604  
  3605  // The barrier functions are available.
  3606  
  3607  // POSIX message queues are available.
  3608  
  3609  // Thread process-shared synchronization is supported.
  3610  
  3611  // The monotonic clock might be available.
  3612  
  3613  // The clock selection interfaces are available.
  3614  
  3615  // Advisory information interfaces are available.
  3616  
  3617  // IPv6 support is available.
  3618  
  3619  // Raw socket support is available.
  3620  
  3621  // We have at least one terminal.
  3622  
  3623  // Neither process nor thread sporadic server interfaces is available.
  3624  
  3625  // trace.h is not available.
  3626  
  3627  // Typed memory objects are not available.
  3628  
  3629  // Get the environment definitions from Unix98.
  3630  // Copyright (C) 1999-2020 Free Software Foundation, Inc.
  3631  //    This file is part of the GNU C Library.
  3632  //
  3633  //    The GNU C Library is free software; you can redistribute it and/or
  3634  //    modify it under the terms of the GNU Lesser General Public
  3635  //    License as published by the Free Software Foundation; either
  3636  //    version 2.1 of the License, or (at your option) any later version.
  3637  //
  3638  //    The GNU C Library is distributed in the hope that it will be useful,
  3639  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  3640  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  3641  //    Lesser General Public License for more details.
  3642  //
  3643  //    You should have received a copy of the GNU Lesser General Public
  3644  //    License along with the GNU C Library; if not, see
  3645  //    <https://www.gnu.org/licenses/>.
  3646  
  3647  // Determine the wordsize from the preprocessor defines.
  3648  
  3649  // This header should define the following symbols under the described
  3650  //    situations.  A value `1' means that the model is always supported,
  3651  //    `-1' means it is never supported.  Undefined means it cannot be
  3652  //    statically decided.
  3653  //
  3654  //    _POSIX_V7_ILP32_OFF32   32bit int, long, pointers, and off_t type
  3655  //    _POSIX_V7_ILP32_OFFBIG  32bit int, long, and pointers and larger off_t type
  3656  //
  3657  //    _POSIX_V7_LP64_OFF32	   64bit long and pointers and 32bit off_t type
  3658  //    _POSIX_V7_LPBIG_OFFBIG  64bit long and pointers and large off_t type
  3659  //
  3660  //    The macros _POSIX_V6_ILP32_OFF32, _POSIX_V6_ILP32_OFFBIG,
  3661  //    _POSIX_V6_LP64_OFF32, _POSIX_V6_LPBIG_OFFBIG, _XBS5_ILP32_OFF32,
  3662  //    _XBS5_ILP32_OFFBIG, _XBS5_LP64_OFF32, and _XBS5_LPBIG_OFFBIG were
  3663  //    used in previous versions of the Unix standard and are available
  3664  //    only for compatibility.
  3665  
  3666  // Environments with 32-bit wide pointers are optionally provided.
  3667  //    Therefore following macros aren't defined:
  3668  //    # undef _POSIX_V7_ILP32_OFF32
  3669  //    # undef _POSIX_V7_ILP32_OFFBIG
  3670  //    # undef _POSIX_V6_ILP32_OFF32
  3671  //    # undef _POSIX_V6_ILP32_OFFBIG
  3672  //    # undef _XBS5_ILP32_OFF32
  3673  //    # undef _XBS5_ILP32_OFFBIG
  3674  //    and users need to check at runtime.
  3675  
  3676  // We also have no use (for now) for an environment with bigger pointers
  3677  //    and offsets.
  3678  
  3679  // By default we have 64-bit wide `long int', pointers and `off_t'.
  3680  
  3681  // Standard file descriptors.
  3682  
  3683  // All functions that are not declared anywhere else.
  3684  
  3685  // bits/types.h -- definitions of __*_t types underlying *_t types.
  3686  //    Copyright (C) 2002-2020 Free Software Foundation, Inc.
  3687  //    This file is part of the GNU C Library.
  3688  //
  3689  //    The GNU C Library is free software; you can redistribute it and/or
  3690  //    modify it under the terms of the GNU Lesser General Public
  3691  //    License as published by the Free Software Foundation; either
  3692  //    version 2.1 of the License, or (at your option) any later version.
  3693  //
  3694  //    The GNU C Library is distributed in the hope that it will be useful,
  3695  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  3696  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  3697  //    Lesser General Public License for more details.
  3698  //
  3699  //    You should have received a copy of the GNU Lesser General Public
  3700  //    License along with the GNU C Library; if not, see
  3701  //    <https://www.gnu.org/licenses/>.
  3702  
  3703  // Never include this file directly; use <sys/types.h> instead.
  3704  
  3705  // Copyright (C) 1989-2020 Free Software Foundation, Inc.
  3706  //
  3707  // This file is part of GCC.
  3708  //
  3709  // GCC is free software; you can redistribute it and/or modify
  3710  // it under the terms of the GNU General Public License as published by
  3711  // the Free Software Foundation; either version 3, or (at your option)
  3712  // any later version.
  3713  //
  3714  // GCC is distributed in the hope that it will be useful,
  3715  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  3716  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  3717  // GNU General Public License for more details.
  3718  //
  3719  // Under Section 7 of GPL version 3, you are granted additional
  3720  // permissions described in the GCC Runtime Library Exception, version
  3721  // 3.1, as published by the Free Software Foundation.
  3722  //
  3723  // You should have received a copy of the GNU General Public License and
  3724  // a copy of the GCC Runtime Library Exception along with this program;
  3725  // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  3726  // <http://www.gnu.org/licenses/>.
  3727  
  3728  // ISO C Standard:  7.17  Common definitions  <stddef.h>
  3729  
  3730  // Any one of these symbols __need_* means that GNU libc
  3731  //    wants us just to define one data type.  So don't define
  3732  //    the symbols that indicate this file's entire job has been done.
  3733  
  3734  // This avoids lossage on SunOS but only if stdtypes.h comes first.
  3735  //    There's no way to win with the other order!  Sun lossage.
  3736  
  3737  // Sequent's header files use _PTRDIFF_T_ in some conflicting way.
  3738  //    Just ignore it.
  3739  
  3740  // On VxWorks, <type/vxTypesBase.h> may have defined macros like
  3741  //    _TYPE_size_t which will typedef size_t.  fixincludes patched the
  3742  //    vxTypesBase.h so that this macro is only defined if _GCC_SIZE_T is
  3743  //    not defined, and so that defining this macro defines _GCC_SIZE_T.
  3744  //    If we find that the macros are still defined at this point, we must
  3745  //    invoke them so that the type is defined as expected.
  3746  
  3747  // In case nobody has defined these types, but we aren't running under
  3748  //    GCC 2.00, make sure that __PTRDIFF_TYPE__, __SIZE_TYPE__, and
  3749  //    __WCHAR_TYPE__ have reasonable values.  This can happen if the
  3750  //    parts of GCC is compiled by an older compiler, that actually
  3751  //    include gstddef.h, such as collect2.
  3752  
  3753  // Signed type of difference of two pointers.
  3754  
  3755  // Define this type if we are doing the whole job,
  3756  //    or if we want this type in particular.
  3757  
  3758  // If this symbol has done its job, get rid of it.
  3759  
  3760  // Unsigned type of `sizeof' something.
  3761  
  3762  // Define this type if we are doing the whole job,
  3763  //    or if we want this type in particular.
  3764  
  3765  // Wide character type.
  3766  //    Locale-writers should change this as necessary to
  3767  //    be big enough to hold unique values not between 0 and 127,
  3768  //    and not (wchar_t) -1, for each defined multibyte character.
  3769  
  3770  // Define this type if we are doing the whole job,
  3771  //    or if we want this type in particular.
  3772  
  3773  // A null pointer constant.
  3774  
  3775  // Offset of member MEMBER in a struct of type TYPE.
  3776  
  3777  // The Single Unix specification says that some more types are
  3778  //    available here.
  3779  
  3780  type Useconds_t = X__useconds_t /* unistd.h:255:22 */
  3781  
  3782  type Intptr_t = X__intptr_t /* unistd.h:267:20 */
  3783  
  3784  type Socklen_t = X__socklen_t /* unistd.h:274:21 */
  3785  
  3786  // Define some macros helping to catch buffer overflows.
  3787  
  3788  // System-specific extensions.
  3789  // System-specific extensions of <unistd.h>, Linux version.
  3790  //    Copyright (C) 2019-2020 Free Software Foundation, Inc.
  3791  //    This file is part of the GNU C Library.
  3792  //
  3793  //    The GNU C Library is free software; you can redistribute it and/or
  3794  //    modify it under the terms of the GNU Lesser General Public
  3795  //    License as published by the Free Software Foundation; either
  3796  //    version 2.1 of the License, or (at your option) any later version.
  3797  //
  3798  //    The GNU C Library is distributed in the hope that it will be useful,
  3799  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  3800  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  3801  //    Lesser General Public License for more details.
  3802  //
  3803  //    You should have received a copy of the GNU Lesser General Public
  3804  //    License along with the GNU C Library; if not, see
  3805  //    <https://www.gnu.org/licenses/>.
  3806  
  3807  // MVS linker does not support external names larger than 8 bytes
  3808  
  3809  //
  3810  //     The 'zlib' compression library provides in-memory compression and
  3811  //   decompression functions, including integrity checks of the uncompressed data.
  3812  //   This version of the library supports only one compression method (deflation)
  3813  //   but other algorithms will be added later and will have the same stream
  3814  //   interface.
  3815  //
  3816  //     Compression can be done in a single step if the buffers are large enough,
  3817  //   or can be done by repeated calls of the compression function.  In the latter
  3818  //   case, the application must provide more input and/or consume the output
  3819  //   (providing more output space) before each call.
  3820  //
  3821  //     The compressed data format used by default by the in-memory functions is
  3822  //   the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped
  3823  //   around a deflate stream, which is itself documented in RFC 1951.
  3824  //
  3825  //     The library also supports reading and writing files in gzip (.gz) format
  3826  //   with an interface similar to that of stdio using the functions that start
  3827  //   with "gz".  The gzip format is different from the zlib format.  gzip is a
  3828  //   gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
  3829  //
  3830  //     This library can optionally read and write gzip and raw deflate streams in
  3831  //   memory as well.
  3832  //
  3833  //     The zlib format was designed to be compact and fast for use in memory
  3834  //   and on communications channels.  The gzip format was designed for single-
  3835  //   file compression on file systems, has a larger header than zlib to maintain
  3836  //   directory information, and uses a different, slower check method than zlib.
  3837  //
  3838  //     The library does not install any signal handler.  The decoder checks
  3839  //   the consistency of the compressed data, so the library should never crash
  3840  //   even in the case of corrupted input.
  3841  
  3842  type Alloc_func = uintptr /* zlib.h:81:16 */
  3843  type Free_func = uintptr  /* zlib.h:82:16 */
  3844  
  3845  type Internal_state = struct {
  3846  	Fstrm             Z_streamp
  3847  	Fstatus           int32
  3848  	F__ccgo_pad1      [4]byte
  3849  	Fpending_buf      uintptr
  3850  	Fpending_buf_size Ulg
  3851  	Fpending_out      uintptr
  3852  	Fpending          Ulg
  3853  	Fwrap             int32
  3854  	F__ccgo_pad2      [4]byte
  3855  	Fgzhead           Gz_headerp
  3856  	Fgzindex          Ulg
  3857  	Fmethod           Byte
  3858  	F__ccgo_pad3      [3]byte
  3859  	Flast_flush       int32
  3860  	Fw_size           UInt
  3861  	Fw_bits           UInt
  3862  	Fw_mask           UInt
  3863  	F__ccgo_pad4      [4]byte
  3864  	Fwindow           uintptr
  3865  	Fwindow_size      Ulg
  3866  	Fprev             uintptr
  3867  	Fhead             uintptr
  3868  	Fins_h            UInt
  3869  	Fhash_size        UInt
  3870  	Fhash_bits        UInt
  3871  	Fhash_mask        UInt
  3872  	Fhash_shift       UInt
  3873  	F__ccgo_pad5      [4]byte
  3874  	Fblock_start      int64
  3875  	Fmatch_length     UInt
  3876  	Fprev_match       IPos
  3877  	Fmatch_available  int32
  3878  	Fstrstart         UInt
  3879  	Fmatch_start      UInt
  3880  	Flookahead        UInt
  3881  	Fprev_length      UInt
  3882  	Fmax_chain_length UInt
  3883  	Fmax_lazy_match   UInt
  3884  	Flevel            int32
  3885  	Fstrategy         int32
  3886  	Fgood_match       UInt
  3887  	Fnice_match       int32
  3888  	Fdyn_ltree        [573]struct {
  3889  		Ffc struct{ Ffreq Ush }
  3890  		Fdl struct{ Fdad Ush }
  3891  	}
  3892  	Fdyn_dtree [61]struct {
  3893  		Ffc struct{ Ffreq Ush }
  3894  		Fdl struct{ Fdad Ush }
  3895  	}
  3896  	Fbl_tree [39]struct {
  3897  		Ffc struct{ Ffreq Ush }
  3898  		Fdl struct{ Fdad Ush }
  3899  	}
  3900  	Fl_desc struct {
  3901  		Fdyn_tree    uintptr
  3902  		Fmax_code    int32
  3903  		F__ccgo_pad1 [4]byte
  3904  		Fstat_desc   uintptr
  3905  	}
  3906  	Fd_desc struct {
  3907  		Fdyn_tree    uintptr
  3908  		Fmax_code    int32
  3909  		F__ccgo_pad1 [4]byte
  3910  		Fstat_desc   uintptr
  3911  	}
  3912  	Fbl_desc struct {
  3913  		Fdyn_tree    uintptr
  3914  		Fmax_code    int32
  3915  		F__ccgo_pad1 [4]byte
  3916  		Fstat_desc   uintptr
  3917  	}
  3918  	Fbl_count    [16]Ush
  3919  	Fheap        [573]int32
  3920  	Fheap_len    int32
  3921  	Fheap_max    int32
  3922  	Fdepth       [573]Uch
  3923  	F__ccgo_pad6 [7]byte
  3924  	Fl_buf       uintptr
  3925  	Flit_bufsize UInt
  3926  	Flast_lit    UInt
  3927  	Fd_buf       uintptr
  3928  	Fopt_len     Ulg
  3929  	Fstatic_len  Ulg
  3930  	Fmatches     UInt
  3931  	Finsert      UInt
  3932  	Fbi_buf      Ush
  3933  	F__ccgo_pad7 [2]byte
  3934  	Fbi_valid    int32
  3935  	Fhigh_water  Ulg
  3936  } /* zlib.h:84:1 */
  3937  
  3938  type Z_stream_s = struct {
  3939  	Fnext_in     uintptr
  3940  	Favail_in    UInt
  3941  	F__ccgo_pad1 [4]byte
  3942  	Ftotal_in    ULong
  3943  	Fnext_out    uintptr
  3944  	Favail_out   UInt
  3945  	F__ccgo_pad2 [4]byte
  3946  	Ftotal_out   ULong
  3947  	Fmsg         uintptr
  3948  	Fstate       uintptr
  3949  	Fzalloc      Alloc_func
  3950  	Fzfree       Free_func
  3951  	Fopaque      Voidpf
  3952  	Fdata_type   int32
  3953  	F__ccgo_pad3 [4]byte
  3954  	Fadler       ULong
  3955  	Freserved    ULong
  3956  } /* zlib.h:86:9 */
  3957  
  3958  type Z_stream = Z_stream_s /* zlib.h:106:3 */
  3959  
  3960  type Z_streamp = uintptr /* zlib.h:108:22 */
  3961  
  3962  //
  3963  //      gzip header information passed to and from zlib routines.  See RFC 1952
  3964  //   for more details on the meanings of these fields.
  3965  type Gz_header_s = struct {
  3966  	Ftext        int32
  3967  	F__ccgo_pad1 [4]byte
  3968  	Ftime        ULong
  3969  	Fxflags      int32
  3970  	Fos          int32
  3971  	Fextra       uintptr
  3972  	Fextra_len   UInt
  3973  	Fextra_max   UInt
  3974  	Fname        uintptr
  3975  	Fname_max    UInt
  3976  	F__ccgo_pad2 [4]byte
  3977  	Fcomment     uintptr
  3978  	Fcomm_max    UInt
  3979  	Fhcrc        int32
  3980  	Fdone        int32
  3981  	F__ccgo_pad3 [4]byte
  3982  } /* zlib.h:114:9 */
  3983  
  3984  //
  3985  //      gzip header information passed to and from zlib routines.  See RFC 1952
  3986  //   for more details on the meanings of these fields.
  3987  type Gz_header = Gz_header_s /* zlib.h:129:3 */
  3988  
  3989  type Gz_headerp = uintptr /* zlib.h:131:23 */
  3990  //
  3991  //      inflateGetHeader() requests that gzip header information be stored in the
  3992  //    provided gz_header structure.  inflateGetHeader() may be called after
  3993  //    inflateInit2() or inflateReset(), and before the first call of inflate().
  3994  //    As inflate() processes the gzip stream, head->done is zero until the header
  3995  //    is completed, at which time head->done is set to one.  If a zlib stream is
  3996  //    being decoded, then head->done is set to -1 to indicate that there will be
  3997  //    no gzip header information forthcoming.  Note that Z_BLOCK or Z_TREES can be
  3998  //    used to force inflate() to return immediately after header processing is
  3999  //    complete and before any actual data is decompressed.
  4000  //
  4001  //      The text, time, xflags, and os fields are filled in with the gzip header
  4002  //    contents.  hcrc is set to true if there is a header CRC.  (The header CRC
  4003  //    was valid if done is set to one.) If extra is not Z_NULL, then extra_max
  4004  //    contains the maximum number of bytes to write to extra.  Once done is true,
  4005  //    extra_len contains the actual extra field length, and extra contains the
  4006  //    extra field, or that field truncated if extra_max is less than extra_len.
  4007  //    If name is not Z_NULL, then up to name_max characters are written there,
  4008  //    terminated with a zero unless the length is greater than name_max.  If
  4009  //    comment is not Z_NULL, then up to comm_max characters are written there,
  4010  //    terminated with a zero unless the length is greater than comm_max.  When any
  4011  //    of extra, name, or comment are not Z_NULL and the respective field is not
  4012  //    present in the header, then that field is set to Z_NULL to signal its
  4013  //    absence.  This allows the use of deflateSetHeader() with the returned
  4014  //    structure to duplicate the header.  However if those fields are set to
  4015  //    allocated memory, then the application will need to save those pointers
  4016  //    elsewhere so that they can be eventually freed.
  4017  //
  4018  //      If inflateGetHeader is not used, then the header information is simply
  4019  //    discarded.  The header is always checked for validity, including the header
  4020  //    CRC if present.  inflateReset() will reset the process to discard the header
  4021  //    information.  The application would need to call inflateGetHeader() again to
  4022  //    retrieve the header from the next gzip stream.
  4023  //
  4024  //      inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
  4025  //    stream state was inconsistent.
  4026  
  4027  //
  4028  // ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits,
  4029  //                                         unsigned char FAR *window));
  4030  //
  4031  //      Initialize the internal stream state for decompression using inflateBack()
  4032  //    calls.  The fields zalloc, zfree and opaque in strm must be initialized
  4033  //    before the call.  If zalloc and zfree are Z_NULL, then the default library-
  4034  //    derived memory allocation routines are used.  windowBits is the base two
  4035  //    logarithm of the window size, in the range 8..15.  window is a caller
  4036  //    supplied buffer of that size.  Except for special applications where it is
  4037  //    assured that deflate was used with small window sizes, windowBits must be 15
  4038  //    and a 32K byte window must be supplied to be able to decompress general
  4039  //    deflate streams.
  4040  //
  4041  //      See inflateBack() for the usage of these routines.
  4042  //
  4043  //      inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of
  4044  //    the parameters are invalid, Z_MEM_ERROR if the internal state could not be
  4045  //    allocated, or Z_VERSION_ERROR if the version of the library does not match
  4046  //    the version of the header file.
  4047  
  4048  type In_func = uintptr  /* zlib.h:1092:18 */
  4049  type Out_func = uintptr /* zlib.h:1094:13 */
  4050  //
  4051  //      Same as uncompress, except that sourceLen is a pointer, where the
  4052  //    length of the source is *sourceLen.  On return, *sourceLen is the number of
  4053  //    source bytes consumed.
  4054  
  4055  // gzip file access functions
  4056  
  4057  //
  4058  //      This library supports reading and writing files in gzip (.gz) format with
  4059  //    an interface similar to that of stdio, using the functions that start with
  4060  //    "gz".  The gzip format is different from the zlib format.  gzip is a gzip
  4061  //    wrapper, documented in RFC 1952, wrapped around a deflate stream.
  4062  
  4063  type GzFile_s = struct {
  4064  	Fhave        uint32
  4065  	F__ccgo_pad1 [4]byte
  4066  	Fnext        uintptr
  4067  	Fpos         Off64_t
  4068  } /* zlib.h:1300:9 */
  4069  
  4070  //
  4071  //      Same as uncompress, except that sourceLen is a pointer, where the
  4072  //    length of the source is *sourceLen.  On return, *sourceLen is the number of
  4073  //    source bytes consumed.
  4074  
  4075  // gzip file access functions
  4076  
  4077  //
  4078  //      This library supports reading and writing files in gzip (.gz) format with
  4079  //    an interface similar to that of stdio, using the functions that start with
  4080  //    "gz".  The gzip format is different from the zlib format.  gzip is a gzip
  4081  //    wrapper, documented in RFC 1952, wrapped around a deflate stream.
  4082  
  4083  type GzFile = uintptr /* zlib.h:1300:25 */
  4084  
  4085  // POSIX.1-2008 extended locale interface (see locale.h).
  4086  // Definition of locale_t.
  4087  //    Copyright (C) 2017-2020 Free Software Foundation, Inc.
  4088  //    This file is part of the GNU C Library.
  4089  //
  4090  //    The GNU C Library is free software; you can redistribute it and/or
  4091  //    modify it under the terms of the GNU Lesser General Public
  4092  //    License as published by the Free Software Foundation; either
  4093  //    version 2.1 of the License, or (at your option) any later version.
  4094  //
  4095  //    The GNU C Library is distributed in the hope that it will be useful,
  4096  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  4097  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  4098  //    Lesser General Public License for more details.
  4099  //
  4100  //    You should have received a copy of the GNU Lesser General Public
  4101  //    License along with the GNU C Library; if not, see
  4102  //    <https://www.gnu.org/licenses/>.
  4103  
  4104  // Definition of struct __locale_struct and __locale_t.
  4105  //    Copyright (C) 1997-2020 Free Software Foundation, Inc.
  4106  //    This file is part of the GNU C Library.
  4107  //    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
  4108  //
  4109  //    The GNU C Library is free software; you can redistribute it and/or
  4110  //    modify it under the terms of the GNU Lesser General Public
  4111  //    License as published by the Free Software Foundation; either
  4112  //    version 2.1 of the License, or (at your option) any later version.
  4113  //
  4114  //    The GNU C Library is distributed in the hope that it will be useful,
  4115  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  4116  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  4117  //    Lesser General Public License for more details.
  4118  //
  4119  //    You should have received a copy of the GNU Lesser General Public
  4120  //    License along with the GNU C Library; if not, see
  4121  //    <https://www.gnu.org/licenses/>.
  4122  
  4123  // POSIX.1-2008: the locale_t type, representing a locale context
  4124  //    (implementation-namespace version).  This type should be treated
  4125  //    as opaque by applications; some details are exposed for the sake of
  4126  //    efficiency in e.g. ctype functions.
  4127  
  4128  type X__locale_struct = struct {
  4129  	F__locales       [13]uintptr
  4130  	F__ctype_b       uintptr
  4131  	F__ctype_tolower uintptr
  4132  	F__ctype_toupper uintptr
  4133  	F__names         [13]uintptr
  4134  } /* __locale_t.h:28:1 */
  4135  
  4136  type X__locale_t = uintptr /* __locale_t.h:42:32 */
  4137  
  4138  type Locale_t = X__locale_t /* locale_t.h:24:20 */
  4139  
  4140  // Copyright (C) 1991-2020 Free Software Foundation, Inc.
  4141  //    This file is part of the GNU C Library.
  4142  //
  4143  //    The GNU C Library is free software; you can redistribute it and/or
  4144  //    modify it under the terms of the GNU Lesser General Public
  4145  //    License as published by the Free Software Foundation; either
  4146  //    version 2.1 of the License, or (at your option) any later version.
  4147  //
  4148  //    The GNU C Library is distributed in the hope that it will be useful,
  4149  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  4150  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  4151  //    Lesser General Public License for more details.
  4152  //
  4153  //    You should have received a copy of the GNU Lesser General Public
  4154  //    License along with the GNU C Library; if not, see
  4155  //    <https://www.gnu.org/licenses/>.
  4156  
  4157  //	ISO C99 Standard: 7.20 General utilities	<stdlib.h>
  4158  
  4159  // Handle feature test macros at the start of a header.
  4160  //    Copyright (C) 2016-2020 Free Software Foundation, Inc.
  4161  //    This file is part of the GNU C Library.
  4162  //
  4163  //    The GNU C Library is free software; you can redistribute it and/or
  4164  //    modify it under the terms of the GNU Lesser General Public
  4165  //    License as published by the Free Software Foundation; either
  4166  //    version 2.1 of the License, or (at your option) any later version.
  4167  //
  4168  //    The GNU C Library is distributed in the hope that it will be useful,
  4169  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  4170  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  4171  //    Lesser General Public License for more details.
  4172  //
  4173  //    You should have received a copy of the GNU Lesser General Public
  4174  //    License along with the GNU C Library; if not, see
  4175  //    <https://www.gnu.org/licenses/>.
  4176  
  4177  // This header is internal to glibc and should not be included outside
  4178  //    of glibc headers.  Headers including it must define
  4179  //    __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION first.  This header
  4180  //    cannot have multiple include guards because ISO C feature test
  4181  //    macros depend on the definition of the macro when an affected
  4182  //    header is included, not when the first system header is
  4183  //    included.
  4184  
  4185  // Copyright (C) 1991-2020 Free Software Foundation, Inc.
  4186  //    This file is part of the GNU C Library.
  4187  //
  4188  //    The GNU C Library is free software; you can redistribute it and/or
  4189  //    modify it under the terms of the GNU Lesser General Public
  4190  //    License as published by the Free Software Foundation; either
  4191  //    version 2.1 of the License, or (at your option) any later version.
  4192  //
  4193  //    The GNU C Library is distributed in the hope that it will be useful,
  4194  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  4195  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  4196  //    Lesser General Public License for more details.
  4197  //
  4198  //    You should have received a copy of the GNU Lesser General Public
  4199  //    License along with the GNU C Library; if not, see
  4200  //    <https://www.gnu.org/licenses/>.
  4201  
  4202  // ISO/IEC TR 24731-2:2010 defines the __STDC_WANT_LIB_EXT2__
  4203  //    macro.
  4204  
  4205  // ISO/IEC TS 18661-1:2014 defines the __STDC_WANT_IEC_60559_BFP_EXT__
  4206  //    macro.  Most but not all symbols enabled by that macro in TS
  4207  //    18661-1 are enabled unconditionally in C2X; the symbols in Annex F
  4208  //    still require that macro in C2X.
  4209  
  4210  // ISO/IEC TS 18661-4:2015 defines the
  4211  //    __STDC_WANT_IEC_60559_FUNCS_EXT__ macro.  Other than the reduction
  4212  //    functions, the symbols from this TS are enabled unconditionally in
  4213  //    C2X.
  4214  
  4215  // ISO/IEC TS 18661-3:2015 defines the
  4216  //    __STDC_WANT_IEC_60559_TYPES_EXT__ macro.
  4217  
  4218  // Get size_t, wchar_t and NULL from <stddef.h>.
  4219  // Copyright (C) 1989-2020 Free Software Foundation, Inc.
  4220  //
  4221  // This file is part of GCC.
  4222  //
  4223  // GCC is free software; you can redistribute it and/or modify
  4224  // it under the terms of the GNU General Public License as published by
  4225  // the Free Software Foundation; either version 3, or (at your option)
  4226  // any later version.
  4227  //
  4228  // GCC is distributed in the hope that it will be useful,
  4229  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  4230  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  4231  // GNU General Public License for more details.
  4232  //
  4233  // Under Section 7 of GPL version 3, you are granted additional
  4234  // permissions described in the GCC Runtime Library Exception, version
  4235  // 3.1, as published by the Free Software Foundation.
  4236  //
  4237  // You should have received a copy of the GNU General Public License and
  4238  // a copy of the GCC Runtime Library Exception along with this program;
  4239  // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  4240  // <http://www.gnu.org/licenses/>.
  4241  
  4242  // ISO C Standard:  7.17  Common definitions  <stddef.h>
  4243  
  4244  // Any one of these symbols __need_* means that GNU libc
  4245  //    wants us just to define one data type.  So don't define
  4246  //    the symbols that indicate this file's entire job has been done.
  4247  
  4248  // This avoids lossage on SunOS but only if stdtypes.h comes first.
  4249  //    There's no way to win with the other order!  Sun lossage.
  4250  
  4251  // Sequent's header files use _PTRDIFF_T_ in some conflicting way.
  4252  //    Just ignore it.
  4253  
  4254  // On VxWorks, <type/vxTypesBase.h> may have defined macros like
  4255  //    _TYPE_size_t which will typedef size_t.  fixincludes patched the
  4256  //    vxTypesBase.h so that this macro is only defined if _GCC_SIZE_T is
  4257  //    not defined, and so that defining this macro defines _GCC_SIZE_T.
  4258  //    If we find that the macros are still defined at this point, we must
  4259  //    invoke them so that the type is defined as expected.
  4260  
  4261  // In case nobody has defined these types, but we aren't running under
  4262  //    GCC 2.00, make sure that __PTRDIFF_TYPE__, __SIZE_TYPE__, and
  4263  //    __WCHAR_TYPE__ have reasonable values.  This can happen if the
  4264  //    parts of GCC is compiled by an older compiler, that actually
  4265  //    include gstddef.h, such as collect2.
  4266  
  4267  // Signed type of difference of two pointers.
  4268  
  4269  // Define this type if we are doing the whole job,
  4270  //    or if we want this type in particular.
  4271  
  4272  // If this symbol has done its job, get rid of it.
  4273  
  4274  // Unsigned type of `sizeof' something.
  4275  
  4276  // Define this type if we are doing the whole job,
  4277  //    or if we want this type in particular.
  4278  
  4279  // Wide character type.
  4280  //    Locale-writers should change this as necessary to
  4281  //    be big enough to hold unique values not between 0 and 127,
  4282  //    and not (wchar_t) -1, for each defined multibyte character.
  4283  
  4284  // Define this type if we are doing the whole job,
  4285  //    or if we want this type in particular.
  4286  
  4287  // A null pointer constant.
  4288  
  4289  // Offset of member MEMBER in a struct of type TYPE.
  4290  
  4291  // XPG requires a few symbols from <sys/wait.h> being defined.
  4292  // Definitions of flag bits for `waitpid' et al.
  4293  //    Copyright (C) 1992-2020 Free Software Foundation, Inc.
  4294  //    This file is part of the GNU C Library.
  4295  //
  4296  //    The GNU C Library is free software; you can redistribute it and/or
  4297  //    modify it under the terms of the GNU Lesser General Public
  4298  //    License as published by the Free Software Foundation; either
  4299  //    version 2.1 of the License, or (at your option) any later version.
  4300  //
  4301  //    The GNU C Library is distributed in the hope that it will be useful,
  4302  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  4303  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  4304  //    Lesser General Public License for more details.
  4305  //
  4306  //    You should have received a copy of the GNU Lesser General Public
  4307  //    License along with the GNU C Library; if not, see
  4308  //    <https://www.gnu.org/licenses/>.
  4309  
  4310  // Bits in the third argument to `waitpid'.
  4311  
  4312  // Bits in the fourth argument to `waitid'.
  4313  
  4314  // The following values are used by the `waitid' function.
  4315  
  4316  // The Linux kernel defines these bare, rather than an enum,
  4317  //    which causes a conflict if the include order is reversed.
  4318  
  4319  type Idtype_t = uint32 /* waitflags.h:57:3 */
  4320  // Definitions of status bits for `wait' et al.
  4321  //    Copyright (C) 1992-2020 Free Software Foundation, Inc.
  4322  //    This file is part of the GNU C Library.
  4323  //
  4324  //    The GNU C Library is free software; you can redistribute it and/or
  4325  //    modify it under the terms of the GNU Lesser General Public
  4326  //    License as published by the Free Software Foundation; either
  4327  //    version 2.1 of the License, or (at your option) any later version.
  4328  //
  4329  //    The GNU C Library is distributed in the hope that it will be useful,
  4330  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  4331  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  4332  //    Lesser General Public License for more details.
  4333  //
  4334  //    You should have received a copy of the GNU Lesser General Public
  4335  //    License along with the GNU C Library; if not, see
  4336  //    <https://www.gnu.org/licenses/>.
  4337  
  4338  // Everything extant so far uses these same bits.
  4339  
  4340  // If WIFEXITED(STATUS), the low-order 8 bits of the status.
  4341  
  4342  // If WIFSIGNALED(STATUS), the terminating signal.
  4343  
  4344  // If WIFSTOPPED(STATUS), the signal that stopped the child.
  4345  
  4346  // Nonzero if STATUS indicates normal termination.
  4347  
  4348  // Nonzero if STATUS indicates termination by a signal.
  4349  
  4350  // Nonzero if STATUS indicates the child is stopped.
  4351  
  4352  // Nonzero if STATUS indicates the child continued after a stop.  We only
  4353  //    define this if <bits/waitflags.h> provides the WCONTINUED flag bit.
  4354  
  4355  // Nonzero if STATUS indicates the child dumped core.
  4356  
  4357  // Macros for constructing status values.
  4358  
  4359  // Define the macros <sys/wait.h> also would define this way.
  4360  
  4361  // _FloatN API tests for enablement.
  4362  // Macros to control TS 18661-3 glibc features on powerpc.
  4363  //    Copyright (C) 2017-2020 Free Software Foundation, Inc.
  4364  //    This file is part of the GNU C Library.
  4365  //
  4366  //    The GNU C Library is free software; you can redistribute it and/or
  4367  //    modify it under the terms of the GNU Lesser General Public
  4368  //    License as published by the Free Software Foundation; either
  4369  //    version 2.1 of the License, or (at your option) any later version.
  4370  //
  4371  //    The GNU C Library is distributed in the hope that it will be useful,
  4372  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  4373  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  4374  //    Lesser General Public License for more details.
  4375  //
  4376  //    You should have received a copy of the GNU Lesser General Public
  4377  //    License along with the GNU C Library; if not, see
  4378  //    <https://www.gnu.org/licenses/>.
  4379  
  4380  // Copyright (C) 1991-2020 Free Software Foundation, Inc.
  4381  //    This file is part of the GNU C Library.
  4382  //
  4383  //    The GNU C Library is free software; you can redistribute it and/or
  4384  //    modify it under the terms of the GNU Lesser General Public
  4385  //    License as published by the Free Software Foundation; either
  4386  //    version 2.1 of the License, or (at your option) any later version.
  4387  //
  4388  //    The GNU C Library is distributed in the hope that it will be useful,
  4389  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  4390  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  4391  //    Lesser General Public License for more details.
  4392  //
  4393  //    You should have received a copy of the GNU Lesser General Public
  4394  //    License along with the GNU C Library; if not, see
  4395  //    <https://www.gnu.org/licenses/>.
  4396  
  4397  // Properties of long double type.  ldbl-opt version.
  4398  //    Copyright (C) 2016-2020 Free Software Foundation, Inc.
  4399  //    This file is part of the GNU C Library.
  4400  //
  4401  //    The GNU C Library is free software; you can redistribute it and/or
  4402  //    modify it under the terms of the GNU Lesser General Public
  4403  //    License  published by the Free Software Foundation; either
  4404  //    version 2.1 of the License, or (at your option) any later version.
  4405  //
  4406  //    The GNU C Library is distributed in the hope that it will be useful,
  4407  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  4408  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  4409  //    Lesser General Public License for more details.
  4410  //
  4411  //    You should have received a copy of the GNU Lesser General Public
  4412  //    License along with the GNU C Library; if not, see
  4413  //    <https://www.gnu.org/licenses/>.
  4414  
  4415  // Defined to 1 if the current compiler invocation provides a
  4416  //    floating-point type with the IEEE 754 binary128 format, and this glibc
  4417  //    includes corresponding *f128 interfaces for it.
  4418  
  4419  // Defined to 1 if __HAVE_FLOAT128 is 1 and the type is ABI-distinct
  4420  //    from the default float, double and long double types in this glibc, i.e.
  4421  //    calls to the binary128 functions go to *f128 symbols instead of *l.
  4422  
  4423  // Defined to 1 if the current compiler invocation provides a
  4424  //    floating-point type with the right format for _Float64x, and this
  4425  //    glibc includes corresponding *f64x interfaces for it.
  4426  
  4427  // Defined to 1 if __HAVE_FLOAT64X is 1 and _Float64x has the format
  4428  //    of long double.  Otherwise, if __HAVE_FLOAT64X is 1, _Float64x has
  4429  //    the format of _Float128, which must be different from that of long
  4430  //    double.
  4431  
  4432  // Defined to concatenate the literal suffix to be used with _Float128
  4433  //    types, if __HAVE_FLOAT128 is 1.
  4434  
  4435  // Defined to a complex binary128 type if __HAVE_FLOAT128 is 1.
  4436  
  4437  // The remaining of this file provides support for older compilers.
  4438  // Builtin __builtin_huge_valf128 doesn't exist before GCC 7.0.
  4439  
  4440  // The following builtins (suffixed with 'q') are available in GCC >= 6.2,
  4441  //    which is the minimum version required for float128 support on powerpc64le.
  4442  //    Since GCC 7.0 the builtins suffixed with f128 are also available, then
  4443  //    there is no need to redefined them.
  4444  
  4445  // In math/math.h, __MATH_TG will expand signbit to __builtin_signbit*,
  4446  //    e.g.: __builtin_signbitf128, before GCC 6.  However, there has never
  4447  //    been a __builtin_signbitf128 in GCC and the type-generic builtin is
  4448  //    only available since GCC 6.
  4449  
  4450  // Macros to control TS 18661-3 glibc features where the same
  4451  //    definitions are appropriate for all platforms.
  4452  //    Copyright (C) 2017-2020 Free Software Foundation, Inc.
  4453  //    This file is part of the GNU C Library.
  4454  //
  4455  //    The GNU C Library is free software; you can redistribute it and/or
  4456  //    modify it under the terms of the GNU Lesser General Public
  4457  //    License as published by the Free Software Foundation; either
  4458  //    version 2.1 of the License, or (at your option) any later version.
  4459  //
  4460  //    The GNU C Library is distributed in the hope that it will be useful,
  4461  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  4462  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  4463  //    Lesser General Public License for more details.
  4464  //
  4465  //    You should have received a copy of the GNU Lesser General Public
  4466  //    License along with the GNU C Library; if not, see
  4467  //    <https://www.gnu.org/licenses/>.
  4468  
  4469  // Copyright (C) 1991-2020 Free Software Foundation, Inc.
  4470  //    This file is part of the GNU C Library.
  4471  //
  4472  //    The GNU C Library is free software; you can redistribute it and/or
  4473  //    modify it under the terms of the GNU Lesser General Public
  4474  //    License as published by the Free Software Foundation; either
  4475  //    version 2.1 of the License, or (at your option) any later version.
  4476  //
  4477  //    The GNU C Library is distributed in the hope that it will be useful,
  4478  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  4479  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  4480  //    Lesser General Public License for more details.
  4481  //
  4482  //    You should have received a copy of the GNU Lesser General Public
  4483  //    License along with the GNU C Library; if not, see
  4484  //    <https://www.gnu.org/licenses/>.
  4485  
  4486  // Properties of long double type.  ldbl-opt version.
  4487  //    Copyright (C) 2016-2020 Free Software Foundation, Inc.
  4488  //    This file is part of the GNU C Library.
  4489  //
  4490  //    The GNU C Library is free software; you can redistribute it and/or
  4491  //    modify it under the terms of the GNU Lesser General Public
  4492  //    License  published by the Free Software Foundation; either
  4493  //    version 2.1 of the License, or (at your option) any later version.
  4494  //
  4495  //    The GNU C Library is distributed in the hope that it will be useful,
  4496  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  4497  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  4498  //    Lesser General Public License for more details.
  4499  //
  4500  //    You should have received a copy of the GNU Lesser General Public
  4501  //    License along with the GNU C Library; if not, see
  4502  //    <https://www.gnu.org/licenses/>.
  4503  
  4504  // This header should be included at the bottom of each bits/floatn.h.
  4505  //    It defines the following macros for each _FloatN and _FloatNx type,
  4506  //    where the same definitions, or definitions based only on the macros
  4507  //    in bits/floatn.h, are appropriate for all glibc configurations.
  4508  
  4509  // Defined to 1 if the current compiler invocation provides a
  4510  //    floating-point type with the right format for this type, and this
  4511  //    glibc includes corresponding *fN or *fNx interfaces for it.
  4512  
  4513  // Defined to 1 if the corresponding __HAVE_<type> macro is 1 and the
  4514  //    type is the first with its format in the sequence of (the default
  4515  //    choices for) float, double, long double, _Float16, _Float32,
  4516  //    _Float64, _Float128, _Float32x, _Float64x, _Float128x for this
  4517  //    glibc; that is, if functions present once per floating-point format
  4518  //    rather than once per type are present for this type.
  4519  //
  4520  //    All configurations supported by glibc have _Float32 the same format
  4521  //    as float, _Float64 and _Float32x the same format as double, the
  4522  //    _Float64x the same format as either long double or _Float128.  No
  4523  //    configurations support _Float128x or, as of GCC 7, have compiler
  4524  //    support for a type meeting the requirements for _Float128x.
  4525  
  4526  // Defined to 1 if the corresponding _FloatN type is not binary compatible
  4527  //    with the corresponding ISO C type in the current compilation unit as
  4528  //    opposed to __HAVE_DISTINCT_FLOATN, which indicates the default types built
  4529  //    in glibc.
  4530  
  4531  // Defined to 1 if any _FloatN or _FloatNx types that are not
  4532  //    ABI-distinct are however distinct types at the C language level (so
  4533  //    for the purposes of __builtin_types_compatible_p and _Generic).
  4534  
  4535  // Defined to concatenate the literal suffix to be used with _FloatN
  4536  //    or _FloatNx types, if __HAVE_<type> is 1.  The corresponding
  4537  //    literal suffixes exist since GCC 7, for C only.
  4538  
  4539  // Defined to a complex type if __HAVE_<type> is 1.
  4540  
  4541  // The remaining of this file provides support for older compilers.
  4542  
  4543  // If double, long double and _Float64 all have the same set of
  4544  //    values, TS 18661-3 requires the usual arithmetic conversions on
  4545  //    long double and _Float64 to produce _Float64.  For this to be the
  4546  //    case when building with a compiler without a distinct _Float64
  4547  //    type, _Float64 must be a typedef for long double, not for
  4548  //    double.
  4549  
  4550  // Returned by `div'.
  4551  type Div_t = struct {
  4552  	Fquot int32
  4553  	Frem  int32
  4554  } /* stdlib.h:62:5 */
  4555  
  4556  // Returned by `ldiv'.
  4557  type Ldiv_t = struct {
  4558  	Fquot int64
  4559  	Frem  int64
  4560  } /* stdlib.h:70:5 */
  4561  
  4562  // Returned by `lldiv'.
  4563  type Lldiv_t = struct {
  4564  	Fquot int64
  4565  	Frem  int64
  4566  } /* stdlib.h:80:5 */
  4567  
  4568  // Reentrant versions of the `random' family of functions.
  4569  //    These functions all use the following data structure to contain
  4570  //    state, rather than global state variables.
  4571  
  4572  type Random_data = struct {
  4573  	Ffptr        uintptr
  4574  	Frptr        uintptr
  4575  	Fstate       uintptr
  4576  	Frand_type   int32
  4577  	Frand_deg    int32
  4578  	Frand_sep    int32
  4579  	F__ccgo_pad1 [4]byte
  4580  	Fend_ptr     uintptr
  4581  } /* stdlib.h:423:1 */
  4582  
  4583  // Data structure for communication with thread safe versions.  This
  4584  //    type is to be regarded as opaque.  It's only exported because users
  4585  //    have to allocate objects of this type.
  4586  type Drand48_data = struct {
  4587  	F__x     [3]uint16
  4588  	F__old_x [3]uint16
  4589  	F__c     uint16
  4590  	F__init  uint16
  4591  	F__a     uint64
  4592  } /* stdlib.h:490:1 */
  4593  
  4594  // Shorthand for type of comparison functions.
  4595  type X__compar_fn_t = uintptr /* stdlib.h:808:13 */
  4596  
  4597  // Floating-point inline functions for stdlib.h.
  4598  //    Copyright (C) 2012-2020 Free Software Foundation, Inc.
  4599  //    This file is part of the GNU C Library.
  4600  //
  4601  //    The GNU C Library is free software; you can redistribute it and/or
  4602  //    modify it under the terms of the GNU Lesser General Public
  4603  //    License as published by the Free Software Foundation; either
  4604  //    version 2.1 of the License, or (at your option) any later version.
  4605  //
  4606  //    The GNU C Library is distributed in the hope that it will be useful,
  4607  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  4608  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  4609  //    Lesser General Public License for more details.
  4610  //
  4611  //    You should have received a copy of the GNU Lesser General Public
  4612  //    License along with the GNU C Library; if not, see
  4613  //    <https://www.gnu.org/licenses/>.
  4614  
  4615  // Define some macros helping to catch buffer overflows.
  4616  
  4617  // since "static" is used to mean two completely different things in C, we
  4618  //    define "local" for the non-static meaning of "static", for readability
  4619  //    (compile with -Dlocal if your debugger can't find static symbols)
  4620  
  4621  type Uch = uint8  /* zutil.h:43:24 */
  4622  type Uchf = Uch   /* zutil.h:44:17 */
  4623  type Ush = uint16 /* zutil.h:45:24 */
  4624  type Ushf = Ush   /* zutil.h:46:17 */
  4625  type Ulg = uint64 /* zutil.h:47:24 */
  4626  
  4627  // NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1
  4628  
  4629  // use NO_DIVIDE if your processor does not do division in hardware --
  4630  //    try it both ways to see which is faster
  4631  
  4632  // =========================================================================
  4633  func Xadler32_z(tls *libc.TLS, adler ULong, buf uintptr, len Z_size_t) ULong { /* adler32.c:63:15: */
  4634  	var sum2 uint64
  4635  	var n uint32
  4636  
  4637  	// split Adler-32 into component sums
  4638  	sum2 = adler >> 16 & uint64(0xffff)
  4639  	adler = adler & uint64(0xffff)
  4640  
  4641  	// in case user likes doing a byte at a time, keep it fast
  4642  	if len == uint64(1) {
  4643  		adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf)))
  4644  		if adler >= uint64(BASE) {
  4645  			adler = adler - uint64(BASE)
  4646  		}
  4647  		sum2 = sum2 + adler
  4648  		if sum2 >= uint64(BASE) {
  4649  			sum2 = sum2 - uint64(BASE)
  4650  		}
  4651  		return adler | sum2<<16
  4652  	}
  4653  
  4654  	// initial Adler-32 value (deferred check for len == 1 speed)
  4655  	if buf == uintptr(Z_NULL) {
  4656  		return uint64(1)
  4657  	}
  4658  
  4659  	// in case short lengths are provided, keep it somewhat fast
  4660  	if len < uint64(16) {
  4661  		for libc.PostDecUint64(&len, 1) != 0 {
  4662  			adler = adler + ULong(*(*Bytef)(unsafe.Pointer(libc.PostIncUintptr(&buf, 1))))
  4663  			sum2 = sum2 + adler
  4664  		}
  4665  		if adler >= uint64(BASE) {
  4666  			adler = adler - uint64(BASE)
  4667  		}
  4668  		sum2 = sum2 % uint64(BASE) // only added so many BASE's
  4669  		return adler | sum2<<16
  4670  	}
  4671  
  4672  	// do length NMAX blocks -- requires just one modulo operation
  4673  	for len >= uint64(NMAX) {
  4674  		len = len - uint64(NMAX)
  4675  		n = uint32(NMAX / 16) // NMAX is divisible by 16
  4676  		for __ccgo := true; __ccgo; __ccgo = libc.PreDecUint32(&n, 1) != 0 {
  4677  			{
  4678  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf)))
  4679  				sum2 = sum2 + adler
  4680  			}
  4681  			{
  4682  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 1)))
  4683  				sum2 = sum2 + adler
  4684  			}
  4685  
  4686  			{
  4687  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 2)))
  4688  				sum2 = sum2 + adler
  4689  			}
  4690  			{
  4691  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 3)))
  4692  				sum2 = sum2 + adler
  4693  			}
  4694  
  4695  			{
  4696  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 4)))
  4697  				sum2 = sum2 + adler
  4698  			}
  4699  			{
  4700  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 5)))
  4701  				sum2 = sum2 + adler
  4702  			}
  4703  
  4704  			{
  4705  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 6)))
  4706  				sum2 = sum2 + adler
  4707  			}
  4708  			{
  4709  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 7)))
  4710  				sum2 = sum2 + adler
  4711  			}
  4712  
  4713  			{
  4714  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 8)))
  4715  				sum2 = sum2 + adler
  4716  			}
  4717  			{
  4718  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 9)))
  4719  				sum2 = sum2 + adler
  4720  			}
  4721  
  4722  			{
  4723  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 10)))
  4724  				sum2 = sum2 + adler
  4725  			}
  4726  			{
  4727  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 11)))
  4728  				sum2 = sum2 + adler
  4729  			}
  4730  
  4731  			{
  4732  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 12)))
  4733  				sum2 = sum2 + adler
  4734  			}
  4735  			{
  4736  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 13)))
  4737  				sum2 = sum2 + adler
  4738  			}
  4739  
  4740  			{
  4741  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 14)))
  4742  				sum2 = sum2 + adler
  4743  			}
  4744  			{
  4745  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 15)))
  4746  				sum2 = sum2 + adler
  4747  			}
  4748  
  4749  			// 16 sums unrolled
  4750  			buf += uintptr(16)
  4751  		}
  4752  		adler = adler % uint64(BASE)
  4753  		sum2 = sum2 % uint64(BASE)
  4754  	}
  4755  
  4756  	// do remaining bytes (less than NMAX, still just one modulo)
  4757  	if len != 0 { // avoid modulos if none remaining
  4758  		for len >= uint64(16) {
  4759  			len = len - uint64(16)
  4760  			{
  4761  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf)))
  4762  				sum2 = sum2 + adler
  4763  			}
  4764  			{
  4765  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 1)))
  4766  				sum2 = sum2 + adler
  4767  			}
  4768  
  4769  			{
  4770  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 2)))
  4771  				sum2 = sum2 + adler
  4772  			}
  4773  			{
  4774  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 3)))
  4775  				sum2 = sum2 + adler
  4776  			}
  4777  
  4778  			{
  4779  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 4)))
  4780  				sum2 = sum2 + adler
  4781  			}
  4782  			{
  4783  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 5)))
  4784  				sum2 = sum2 + adler
  4785  			}
  4786  
  4787  			{
  4788  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 6)))
  4789  				sum2 = sum2 + adler
  4790  			}
  4791  			{
  4792  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 7)))
  4793  				sum2 = sum2 + adler
  4794  			}
  4795  
  4796  			{
  4797  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 8)))
  4798  				sum2 = sum2 + adler
  4799  			}
  4800  			{
  4801  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 9)))
  4802  				sum2 = sum2 + adler
  4803  			}
  4804  
  4805  			{
  4806  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 10)))
  4807  				sum2 = sum2 + adler
  4808  			}
  4809  			{
  4810  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 11)))
  4811  				sum2 = sum2 + adler
  4812  			}
  4813  
  4814  			{
  4815  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 12)))
  4816  				sum2 = sum2 + adler
  4817  			}
  4818  			{
  4819  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 13)))
  4820  				sum2 = sum2 + adler
  4821  			}
  4822  
  4823  			{
  4824  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 14)))
  4825  				sum2 = sum2 + adler
  4826  			}
  4827  			{
  4828  				adler = adler + ULong(*(*Bytef)(unsafe.Pointer(buf + 15)))
  4829  				sum2 = sum2 + adler
  4830  			}
  4831  
  4832  			buf += uintptr(16)
  4833  		}
  4834  		for libc.PostDecUint64(&len, 1) != 0 {
  4835  			adler = adler + ULong(*(*Bytef)(unsafe.Pointer(libc.PostIncUintptr(&buf, 1))))
  4836  			sum2 = sum2 + adler
  4837  		}
  4838  		adler = adler % uint64(BASE)
  4839  		sum2 = sum2 % uint64(BASE)
  4840  	}
  4841  
  4842  	// return recombined sums
  4843  	return adler | sum2<<16
  4844  }
  4845  
  4846  // =========================================================================
  4847  func Xadler32(tls *libc.TLS, adler ULong, buf uintptr, len UInt) ULong { /* adler32.c:134:15: */
  4848  	return Xadler32_z(tls, adler, buf, uint64(len))
  4849  }
  4850  
  4851  // =========================================================================
  4852  func adler32_combine_(tls *libc.TLS, adler1 ULong, adler2 ULong, len2 Off64_t) ULong { /* adler32.c:143:13: */
  4853  	var sum1 uint64
  4854  	var sum2 uint64
  4855  	var rem uint32
  4856  
  4857  	// for negative len, return invalid adler32 as a clue for debugging
  4858  	if len2 < int64(0) {
  4859  		return 0xffffffff
  4860  	}
  4861  
  4862  	// the derivation of this formula is left as an exercise for the reader
  4863  	len2 = len2 % int64(BASE) // assumes len2 >= 0
  4864  	rem = uint32(len2)
  4865  	sum1 = adler1 & uint64(0xffff)
  4866  	sum2 = uint64(rem) * sum1
  4867  	sum2 = sum2 % uint64(BASE)
  4868  	sum1 = sum1 + (adler2&uint64(0xffff) + uint64(BASE) - uint64(1))
  4869  	sum2 = sum2 + (adler1>>16&uint64(0xffff) + adler2>>16&uint64(0xffff) + uint64(BASE) - ULong(rem))
  4870  	if sum1 >= uint64(BASE) {
  4871  		sum1 = sum1 - uint64(BASE)
  4872  	}
  4873  	if sum1 >= uint64(BASE) {
  4874  		sum1 = sum1 - uint64(BASE)
  4875  	}
  4876  	if sum2 >= uint64(uint64(BASE))<<1 {
  4877  		sum2 = sum2 - uint64(uint64(BASE))<<1
  4878  	}
  4879  	if sum2 >= uint64(BASE) {
  4880  		sum2 = sum2 - uint64(BASE)
  4881  	}
  4882  	return sum1 | sum2<<16
  4883  }
  4884  
  4885  // =========================================================================
  4886  func Xadler32_combine(tls *libc.TLS, adler1 ULong, adler2 ULong, len2 Off_t) ULong { /* adler32.c:172:15: */
  4887  	return adler32_combine_(tls, adler1, adler2, len2)
  4888  }
  4889  
  4890  func Xadler32_combine64(tls *libc.TLS, adler1 ULong, adler2 ULong, len2 Off64_t) ULong { /* adler32.c:180:15: */
  4891  	return adler32_combine_(tls, adler1, adler2, len2)
  4892  }
  4893  
  4894  // ===========================================================================
  4895  //      Compresses the source buffer into the destination buffer. The level
  4896  //    parameter has the same meaning as in deflateInit.  sourceLen is the byte
  4897  //    length of the source buffer. Upon entry, destLen is the total size of the
  4898  //    destination buffer, which must be at least 0.1% larger than sourceLen plus
  4899  //    12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
  4900  //
  4901  //      compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
  4902  //    memory, Z_BUF_ERROR if there was not enough room in the output buffer,
  4903  //    Z_STREAM_ERROR if the level parameter is invalid.
  4904  func Xcompress2(tls *libc.TLS, dest uintptr, destLen uintptr, source uintptr, sourceLen ULong, level int32) int32 { /* compress.c:22:13: */
  4905  	bp := tls.Alloc(112)
  4906  	defer tls.Free(112)
  4907  
  4908  	// var stream Z_stream at bp, 112
  4909  
  4910  	var err int32
  4911  	var max UInt = libc.Uint32(libc.Uint32FromInt32(-1))
  4912  	var left ULong
  4913  
  4914  	left = *(*ULongf)(unsafe.Pointer(destLen))
  4915  	*(*ULongf)(unsafe.Pointer(destLen)) = uint64(0)
  4916  
  4917  	(*Z_stream)(unsafe.Pointer(bp /* &stream */)).Fzalloc = uintptr(0)
  4918  	(*Z_stream)(unsafe.Pointer(bp /* &stream */)).Fzfree = uintptr(0)
  4919  	(*Z_stream)(unsafe.Pointer(bp /* &stream */)).Fopaque = uintptr(0)
  4920  
  4921  	err = XdeflateInit_(tls, bp, level, ts, int32(unsafe.Sizeof(Z_stream{})))
  4922  	if err != Z_OK {
  4923  		return err
  4924  	}
  4925  
  4926  	(*Z_stream)(unsafe.Pointer(bp /* &stream */)).Fnext_out = dest
  4927  	(*Z_stream)(unsafe.Pointer(bp /* &stream */)).Favail_out = UInt(0)
  4928  	(*Z_stream)(unsafe.Pointer(bp /* &stream */)).Fnext_in = source
  4929  	(*Z_stream)(unsafe.Pointer(bp /* &stream */)).Favail_in = UInt(0)
  4930  
  4931  	for __ccgo := true; __ccgo; __ccgo = err == Z_OK {
  4932  		if (*Z_stream)(unsafe.Pointer(bp)).Favail_out == UInt(0) {
  4933  			(*Z_stream)(unsafe.Pointer(bp /* &stream */)).Favail_out = func() uint32 {
  4934  				if left > ULong(max) {
  4935  					return max
  4936  				}
  4937  				return UInt(left)
  4938  			}()
  4939  			left = left - ULong((*Z_stream)(unsafe.Pointer(bp)).Favail_out)
  4940  		}
  4941  		if (*Z_stream)(unsafe.Pointer(bp)).Favail_in == UInt(0) {
  4942  			(*Z_stream)(unsafe.Pointer(bp /* &stream */)).Favail_in = func() uint32 {
  4943  				if sourceLen > ULong(max) {
  4944  					return max
  4945  				}
  4946  				return UInt(sourceLen)
  4947  			}()
  4948  			sourceLen = sourceLen - ULong((*Z_stream)(unsafe.Pointer(bp)).Favail_in)
  4949  		}
  4950  		err = Xdeflate(tls, bp, func() int32 {
  4951  			if sourceLen != 0 {
  4952  				return Z_NO_FLUSH
  4953  			}
  4954  			return Z_FINISH
  4955  		}())
  4956  	}
  4957  
  4958  	*(*ULongf)(unsafe.Pointer(destLen)) = (*Z_stream)(unsafe.Pointer(bp /* &stream */)).Ftotal_out
  4959  	XdeflateEnd(tls, bp)
  4960  	if err == Z_STREAM_END {
  4961  		return Z_OK
  4962  	}
  4963  	return err
  4964  }
  4965  
  4966  // ===========================================================================
  4967  func Xcompress(tls *libc.TLS, dest uintptr, destLen uintptr, source uintptr, sourceLen ULong) int32 { /* compress.c:68:13: */
  4968  	return Xcompress2(tls, dest, destLen, source, sourceLen, -1)
  4969  }
  4970  
  4971  // ===========================================================================
  4972  //      If the default memLevel or windowBits for deflateInit() is changed, then
  4973  //    this function needs to be updated.
  4974  //
  4975  func XcompressBound(tls *libc.TLS, sourceLen ULong) ULong { /* compress.c:81:15: */
  4976  	return sourceLen + sourceLen>>12 + sourceLen>>14 + sourceLen>>25 + uint64(13)
  4977  }
  4978  
  4979  // ========================================================================
  4980  // Tables of CRC-32s of all single-byte values, made by make_crc_table().
  4981  // crc32.h -- tables for rapid CRC calculation
  4982  // Generated automatically by crc32.c
  4983  
  4984  var crc_table = [8][256]Z_crc_t{
  4985  	{
  4986  		uint32(0x00000000), uint32(0x77073096), uint32(0xee0e612c), uint32(0x990951ba), uint32(0x076dc419),
  4987  		uint32(0x706af48f), uint32(0xe963a535), uint32(0x9e6495a3), uint32(0x0edb8832), uint32(0x79dcb8a4),
  4988  		uint32(0xe0d5e91e), uint32(0x97d2d988), uint32(0x09b64c2b), uint32(0x7eb17cbd), uint32(0xe7b82d07),
  4989  		uint32(0x90bf1d91), uint32(0x1db71064), uint32(0x6ab020f2), uint32(0xf3b97148), uint32(0x84be41de),
  4990  		uint32(0x1adad47d), uint32(0x6ddde4eb), uint32(0xf4d4b551), uint32(0x83d385c7), uint32(0x136c9856),
  4991  		uint32(0x646ba8c0), uint32(0xfd62f97a), uint32(0x8a65c9ec), uint32(0x14015c4f), uint32(0x63066cd9),
  4992  		uint32(0xfa0f3d63), uint32(0x8d080df5), uint32(0x3b6e20c8), uint32(0x4c69105e), uint32(0xd56041e4),
  4993  		uint32(0xa2677172), uint32(0x3c03e4d1), uint32(0x4b04d447), uint32(0xd20d85fd), uint32(0xa50ab56b),
  4994  		uint32(0x35b5a8fa), uint32(0x42b2986c), uint32(0xdbbbc9d6), uint32(0xacbcf940), uint32(0x32d86ce3),
  4995  		uint32(0x45df5c75), uint32(0xdcd60dcf), uint32(0xabd13d59), uint32(0x26d930ac), uint32(0x51de003a),
  4996  		uint32(0xc8d75180), uint32(0xbfd06116), uint32(0x21b4f4b5), uint32(0x56b3c423), uint32(0xcfba9599),
  4997  		uint32(0xb8bda50f), uint32(0x2802b89e), uint32(0x5f058808), uint32(0xc60cd9b2), uint32(0xb10be924),
  4998  		uint32(0x2f6f7c87), uint32(0x58684c11), uint32(0xc1611dab), uint32(0xb6662d3d), uint32(0x76dc4190),
  4999  		uint32(0x01db7106), uint32(0x98d220bc), uint32(0xefd5102a), uint32(0x71b18589), uint32(0x06b6b51f),
  5000  		uint32(0x9fbfe4a5), uint32(0xe8b8d433), uint32(0x7807c9a2), uint32(0x0f00f934), uint32(0x9609a88e),
  5001  		uint32(0xe10e9818), uint32(0x7f6a0dbb), uint32(0x086d3d2d), uint32(0x91646c97), uint32(0xe6635c01),
  5002  		uint32(0x6b6b51f4), uint32(0x1c6c6162), uint32(0x856530d8), uint32(0xf262004e), uint32(0x6c0695ed),
  5003  		uint32(0x1b01a57b), uint32(0x8208f4c1), uint32(0xf50fc457), uint32(0x65b0d9c6), uint32(0x12b7e950),
  5004  		uint32(0x8bbeb8ea), uint32(0xfcb9887c), uint32(0x62dd1ddf), uint32(0x15da2d49), uint32(0x8cd37cf3),
  5005  		uint32(0xfbd44c65), uint32(0x4db26158), uint32(0x3ab551ce), uint32(0xa3bc0074), uint32(0xd4bb30e2),
  5006  		uint32(0x4adfa541), uint32(0x3dd895d7), uint32(0xa4d1c46d), uint32(0xd3d6f4fb), uint32(0x4369e96a),
  5007  		uint32(0x346ed9fc), uint32(0xad678846), uint32(0xda60b8d0), uint32(0x44042d73), uint32(0x33031de5),
  5008  		uint32(0xaa0a4c5f), uint32(0xdd0d7cc9), uint32(0x5005713c), uint32(0x270241aa), uint32(0xbe0b1010),
  5009  		uint32(0xc90c2086), uint32(0x5768b525), uint32(0x206f85b3), uint32(0xb966d409), uint32(0xce61e49f),
  5010  		uint32(0x5edef90e), uint32(0x29d9c998), uint32(0xb0d09822), uint32(0xc7d7a8b4), uint32(0x59b33d17),
  5011  		uint32(0x2eb40d81), uint32(0xb7bd5c3b), uint32(0xc0ba6cad), uint32(0xedb88320), uint32(0x9abfb3b6),
  5012  		uint32(0x03b6e20c), uint32(0x74b1d29a), uint32(0xead54739), uint32(0x9dd277af), uint32(0x04db2615),
  5013  		uint32(0x73dc1683), uint32(0xe3630b12), uint32(0x94643b84), uint32(0x0d6d6a3e), uint32(0x7a6a5aa8),
  5014  		uint32(0xe40ecf0b), uint32(0x9309ff9d), uint32(0x0a00ae27), uint32(0x7d079eb1), uint32(0xf00f9344),
  5015  		uint32(0x8708a3d2), uint32(0x1e01f268), uint32(0x6906c2fe), uint32(0xf762575d), uint32(0x806567cb),
  5016  		uint32(0x196c3671), uint32(0x6e6b06e7), uint32(0xfed41b76), uint32(0x89d32be0), uint32(0x10da7a5a),
  5017  		uint32(0x67dd4acc), uint32(0xf9b9df6f), uint32(0x8ebeeff9), uint32(0x17b7be43), uint32(0x60b08ed5),
  5018  		uint32(0xd6d6a3e8), uint32(0xa1d1937e), uint32(0x38d8c2c4), uint32(0x4fdff252), uint32(0xd1bb67f1),
  5019  		uint32(0xa6bc5767), uint32(0x3fb506dd), uint32(0x48b2364b), uint32(0xd80d2bda), uint32(0xaf0a1b4c),
  5020  		uint32(0x36034af6), uint32(0x41047a60), uint32(0xdf60efc3), uint32(0xa867df55), uint32(0x316e8eef),
  5021  		uint32(0x4669be79), uint32(0xcb61b38c), uint32(0xbc66831a), uint32(0x256fd2a0), uint32(0x5268e236),
  5022  		uint32(0xcc0c7795), uint32(0xbb0b4703), uint32(0x220216b9), uint32(0x5505262f), uint32(0xc5ba3bbe),
  5023  		uint32(0xb2bd0b28), uint32(0x2bb45a92), uint32(0x5cb36a04), uint32(0xc2d7ffa7), uint32(0xb5d0cf31),
  5024  		uint32(0x2cd99e8b), uint32(0x5bdeae1d), uint32(0x9b64c2b0), uint32(0xec63f226), uint32(0x756aa39c),
  5025  		uint32(0x026d930a), uint32(0x9c0906a9), uint32(0xeb0e363f), uint32(0x72076785), uint32(0x05005713),
  5026  		uint32(0x95bf4a82), uint32(0xe2b87a14), uint32(0x7bb12bae), uint32(0x0cb61b38), uint32(0x92d28e9b),
  5027  		uint32(0xe5d5be0d), uint32(0x7cdcefb7), uint32(0x0bdbdf21), uint32(0x86d3d2d4), uint32(0xf1d4e242),
  5028  		uint32(0x68ddb3f8), uint32(0x1fda836e), uint32(0x81be16cd), uint32(0xf6b9265b), uint32(0x6fb077e1),
  5029  		uint32(0x18b74777), uint32(0x88085ae6), uint32(0xff0f6a70), uint32(0x66063bca), uint32(0x11010b5c),
  5030  		uint32(0x8f659eff), uint32(0xf862ae69), uint32(0x616bffd3), uint32(0x166ccf45), uint32(0xa00ae278),
  5031  		uint32(0xd70dd2ee), uint32(0x4e048354), uint32(0x3903b3c2), uint32(0xa7672661), uint32(0xd06016f7),
  5032  		uint32(0x4969474d), uint32(0x3e6e77db), uint32(0xaed16a4a), uint32(0xd9d65adc), uint32(0x40df0b66),
  5033  		uint32(0x37d83bf0), uint32(0xa9bcae53), uint32(0xdebb9ec5), uint32(0x47b2cf7f), uint32(0x30b5ffe9),
  5034  		uint32(0xbdbdf21c), uint32(0xcabac28a), uint32(0x53b39330), uint32(0x24b4a3a6), uint32(0xbad03605),
  5035  		uint32(0xcdd70693), uint32(0x54de5729), uint32(0x23d967bf), uint32(0xb3667a2e), uint32(0xc4614ab8),
  5036  		uint32(0x5d681b02), uint32(0x2a6f2b94), uint32(0xb40bbe37), uint32(0xc30c8ea1), uint32(0x5a05df1b),
  5037  		uint32(0x2d02ef8d),
  5038  	},
  5039  	{
  5040  		uint32(0x00000000), uint32(0x191b3141), uint32(0x32366282), uint32(0x2b2d53c3), uint32(0x646cc504),
  5041  		uint32(0x7d77f445), uint32(0x565aa786), uint32(0x4f4196c7), uint32(0xc8d98a08), uint32(0xd1c2bb49),
  5042  		uint32(0xfaefe88a), uint32(0xe3f4d9cb), uint32(0xacb54f0c), uint32(0xb5ae7e4d), uint32(0x9e832d8e),
  5043  		uint32(0x87981ccf), uint32(0x4ac21251), uint32(0x53d92310), uint32(0x78f470d3), uint32(0x61ef4192),
  5044  		uint32(0x2eaed755), uint32(0x37b5e614), uint32(0x1c98b5d7), uint32(0x05838496), uint32(0x821b9859),
  5045  		uint32(0x9b00a918), uint32(0xb02dfadb), uint32(0xa936cb9a), uint32(0xe6775d5d), uint32(0xff6c6c1c),
  5046  		uint32(0xd4413fdf), uint32(0xcd5a0e9e), uint32(0x958424a2), uint32(0x8c9f15e3), uint32(0xa7b24620),
  5047  		uint32(0xbea97761), uint32(0xf1e8e1a6), uint32(0xe8f3d0e7), uint32(0xc3de8324), uint32(0xdac5b265),
  5048  		uint32(0x5d5daeaa), uint32(0x44469feb), uint32(0x6f6bcc28), uint32(0x7670fd69), uint32(0x39316bae),
  5049  		uint32(0x202a5aef), uint32(0x0b07092c), uint32(0x121c386d), uint32(0xdf4636f3), uint32(0xc65d07b2),
  5050  		uint32(0xed705471), uint32(0xf46b6530), uint32(0xbb2af3f7), uint32(0xa231c2b6), uint32(0x891c9175),
  5051  		uint32(0x9007a034), uint32(0x179fbcfb), uint32(0x0e848dba), uint32(0x25a9de79), uint32(0x3cb2ef38),
  5052  		uint32(0x73f379ff), uint32(0x6ae848be), uint32(0x41c51b7d), uint32(0x58de2a3c), uint32(0xf0794f05),
  5053  		uint32(0xe9627e44), uint32(0xc24f2d87), uint32(0xdb541cc6), uint32(0x94158a01), uint32(0x8d0ebb40),
  5054  		uint32(0xa623e883), uint32(0xbf38d9c2), uint32(0x38a0c50d), uint32(0x21bbf44c), uint32(0x0a96a78f),
  5055  		uint32(0x138d96ce), uint32(0x5ccc0009), uint32(0x45d73148), uint32(0x6efa628b), uint32(0x77e153ca),
  5056  		uint32(0xbabb5d54), uint32(0xa3a06c15), uint32(0x888d3fd6), uint32(0x91960e97), uint32(0xded79850),
  5057  		uint32(0xc7cca911), uint32(0xece1fad2), uint32(0xf5facb93), uint32(0x7262d75c), uint32(0x6b79e61d),
  5058  		uint32(0x4054b5de), uint32(0x594f849f), uint32(0x160e1258), uint32(0x0f152319), uint32(0x243870da),
  5059  		uint32(0x3d23419b), uint32(0x65fd6ba7), uint32(0x7ce65ae6), uint32(0x57cb0925), uint32(0x4ed03864),
  5060  		uint32(0x0191aea3), uint32(0x188a9fe2), uint32(0x33a7cc21), uint32(0x2abcfd60), uint32(0xad24e1af),
  5061  		uint32(0xb43fd0ee), uint32(0x9f12832d), uint32(0x8609b26c), uint32(0xc94824ab), uint32(0xd05315ea),
  5062  		uint32(0xfb7e4629), uint32(0xe2657768), uint32(0x2f3f79f6), uint32(0x362448b7), uint32(0x1d091b74),
  5063  		uint32(0x04122a35), uint32(0x4b53bcf2), uint32(0x52488db3), uint32(0x7965de70), uint32(0x607eef31),
  5064  		uint32(0xe7e6f3fe), uint32(0xfefdc2bf), uint32(0xd5d0917c), uint32(0xcccba03d), uint32(0x838a36fa),
  5065  		uint32(0x9a9107bb), uint32(0xb1bc5478), uint32(0xa8a76539), uint32(0x3b83984b), uint32(0x2298a90a),
  5066  		uint32(0x09b5fac9), uint32(0x10aecb88), uint32(0x5fef5d4f), uint32(0x46f46c0e), uint32(0x6dd93fcd),
  5067  		uint32(0x74c20e8c), uint32(0xf35a1243), uint32(0xea412302), uint32(0xc16c70c1), uint32(0xd8774180),
  5068  		uint32(0x9736d747), uint32(0x8e2de606), uint32(0xa500b5c5), uint32(0xbc1b8484), uint32(0x71418a1a),
  5069  		uint32(0x685abb5b), uint32(0x4377e898), uint32(0x5a6cd9d9), uint32(0x152d4f1e), uint32(0x0c367e5f),
  5070  		uint32(0x271b2d9c), uint32(0x3e001cdd), uint32(0xb9980012), uint32(0xa0833153), uint32(0x8bae6290),
  5071  		uint32(0x92b553d1), uint32(0xddf4c516), uint32(0xc4eff457), uint32(0xefc2a794), uint32(0xf6d996d5),
  5072  		uint32(0xae07bce9), uint32(0xb71c8da8), uint32(0x9c31de6b), uint32(0x852aef2a), uint32(0xca6b79ed),
  5073  		uint32(0xd37048ac), uint32(0xf85d1b6f), uint32(0xe1462a2e), uint32(0x66de36e1), uint32(0x7fc507a0),
  5074  		uint32(0x54e85463), uint32(0x4df36522), uint32(0x02b2f3e5), uint32(0x1ba9c2a4), uint32(0x30849167),
  5075  		uint32(0x299fa026), uint32(0xe4c5aeb8), uint32(0xfdde9ff9), uint32(0xd6f3cc3a), uint32(0xcfe8fd7b),
  5076  		uint32(0x80a96bbc), uint32(0x99b25afd), uint32(0xb29f093e), uint32(0xab84387f), uint32(0x2c1c24b0),
  5077  		uint32(0x350715f1), uint32(0x1e2a4632), uint32(0x07317773), uint32(0x4870e1b4), uint32(0x516bd0f5),
  5078  		uint32(0x7a468336), uint32(0x635db277), uint32(0xcbfad74e), uint32(0xd2e1e60f), uint32(0xf9ccb5cc),
  5079  		uint32(0xe0d7848d), uint32(0xaf96124a), uint32(0xb68d230b), uint32(0x9da070c8), uint32(0x84bb4189),
  5080  		uint32(0x03235d46), uint32(0x1a386c07), uint32(0x31153fc4), uint32(0x280e0e85), uint32(0x674f9842),
  5081  		uint32(0x7e54a903), uint32(0x5579fac0), uint32(0x4c62cb81), uint32(0x8138c51f), uint32(0x9823f45e),
  5082  		uint32(0xb30ea79d), uint32(0xaa1596dc), uint32(0xe554001b), uint32(0xfc4f315a), uint32(0xd7626299),
  5083  		uint32(0xce7953d8), uint32(0x49e14f17), uint32(0x50fa7e56), uint32(0x7bd72d95), uint32(0x62cc1cd4),
  5084  		uint32(0x2d8d8a13), uint32(0x3496bb52), uint32(0x1fbbe891), uint32(0x06a0d9d0), uint32(0x5e7ef3ec),
  5085  		uint32(0x4765c2ad), uint32(0x6c48916e), uint32(0x7553a02f), uint32(0x3a1236e8), uint32(0x230907a9),
  5086  		uint32(0x0824546a), uint32(0x113f652b), uint32(0x96a779e4), uint32(0x8fbc48a5), uint32(0xa4911b66),
  5087  		uint32(0xbd8a2a27), uint32(0xf2cbbce0), uint32(0xebd08da1), uint32(0xc0fdde62), uint32(0xd9e6ef23),
  5088  		uint32(0x14bce1bd), uint32(0x0da7d0fc), uint32(0x268a833f), uint32(0x3f91b27e), uint32(0x70d024b9),
  5089  		uint32(0x69cb15f8), uint32(0x42e6463b), uint32(0x5bfd777a), uint32(0xdc656bb5), uint32(0xc57e5af4),
  5090  		uint32(0xee530937), uint32(0xf7483876), uint32(0xb809aeb1), uint32(0xa1129ff0), uint32(0x8a3fcc33),
  5091  		uint32(0x9324fd72),
  5092  	},
  5093  	{
  5094  		uint32(0x00000000), uint32(0x01c26a37), uint32(0x0384d46e), uint32(0x0246be59), uint32(0x0709a8dc),
  5095  		uint32(0x06cbc2eb), uint32(0x048d7cb2), uint32(0x054f1685), uint32(0x0e1351b8), uint32(0x0fd13b8f),
  5096  		uint32(0x0d9785d6), uint32(0x0c55efe1), uint32(0x091af964), uint32(0x08d89353), uint32(0x0a9e2d0a),
  5097  		uint32(0x0b5c473d), uint32(0x1c26a370), uint32(0x1de4c947), uint32(0x1fa2771e), uint32(0x1e601d29),
  5098  		uint32(0x1b2f0bac), uint32(0x1aed619b), uint32(0x18abdfc2), uint32(0x1969b5f5), uint32(0x1235f2c8),
  5099  		uint32(0x13f798ff), uint32(0x11b126a6), uint32(0x10734c91), uint32(0x153c5a14), uint32(0x14fe3023),
  5100  		uint32(0x16b88e7a), uint32(0x177ae44d), uint32(0x384d46e0), uint32(0x398f2cd7), uint32(0x3bc9928e),
  5101  		uint32(0x3a0bf8b9), uint32(0x3f44ee3c), uint32(0x3e86840b), uint32(0x3cc03a52), uint32(0x3d025065),
  5102  		uint32(0x365e1758), uint32(0x379c7d6f), uint32(0x35dac336), uint32(0x3418a901), uint32(0x3157bf84),
  5103  		uint32(0x3095d5b3), uint32(0x32d36bea), uint32(0x331101dd), uint32(0x246be590), uint32(0x25a98fa7),
  5104  		uint32(0x27ef31fe), uint32(0x262d5bc9), uint32(0x23624d4c), uint32(0x22a0277b), uint32(0x20e69922),
  5105  		uint32(0x2124f315), uint32(0x2a78b428), uint32(0x2bbade1f), uint32(0x29fc6046), uint32(0x283e0a71),
  5106  		uint32(0x2d711cf4), uint32(0x2cb376c3), uint32(0x2ef5c89a), uint32(0x2f37a2ad), uint32(0x709a8dc0),
  5107  		uint32(0x7158e7f7), uint32(0x731e59ae), uint32(0x72dc3399), uint32(0x7793251c), uint32(0x76514f2b),
  5108  		uint32(0x7417f172), uint32(0x75d59b45), uint32(0x7e89dc78), uint32(0x7f4bb64f), uint32(0x7d0d0816),
  5109  		uint32(0x7ccf6221), uint32(0x798074a4), uint32(0x78421e93), uint32(0x7a04a0ca), uint32(0x7bc6cafd),
  5110  		uint32(0x6cbc2eb0), uint32(0x6d7e4487), uint32(0x6f38fade), uint32(0x6efa90e9), uint32(0x6bb5866c),
  5111  		uint32(0x6a77ec5b), uint32(0x68315202), uint32(0x69f33835), uint32(0x62af7f08), uint32(0x636d153f),
  5112  		uint32(0x612bab66), uint32(0x60e9c151), uint32(0x65a6d7d4), uint32(0x6464bde3), uint32(0x662203ba),
  5113  		uint32(0x67e0698d), uint32(0x48d7cb20), uint32(0x4915a117), uint32(0x4b531f4e), uint32(0x4a917579),
  5114  		uint32(0x4fde63fc), uint32(0x4e1c09cb), uint32(0x4c5ab792), uint32(0x4d98dda5), uint32(0x46c49a98),
  5115  		uint32(0x4706f0af), uint32(0x45404ef6), uint32(0x448224c1), uint32(0x41cd3244), uint32(0x400f5873),
  5116  		uint32(0x4249e62a), uint32(0x438b8c1d), uint32(0x54f16850), uint32(0x55330267), uint32(0x5775bc3e),
  5117  		uint32(0x56b7d609), uint32(0x53f8c08c), uint32(0x523aaabb), uint32(0x507c14e2), uint32(0x51be7ed5),
  5118  		uint32(0x5ae239e8), uint32(0x5b2053df), uint32(0x5966ed86), uint32(0x58a487b1), uint32(0x5deb9134),
  5119  		uint32(0x5c29fb03), uint32(0x5e6f455a), uint32(0x5fad2f6d), uint32(0xe1351b80), uint32(0xe0f771b7),
  5120  		uint32(0xe2b1cfee), uint32(0xe373a5d9), uint32(0xe63cb35c), uint32(0xe7fed96b), uint32(0xe5b86732),
  5121  		uint32(0xe47a0d05), uint32(0xef264a38), uint32(0xeee4200f), uint32(0xeca29e56), uint32(0xed60f461),
  5122  		uint32(0xe82fe2e4), uint32(0xe9ed88d3), uint32(0xebab368a), uint32(0xea695cbd), uint32(0xfd13b8f0),
  5123  		uint32(0xfcd1d2c7), uint32(0xfe976c9e), uint32(0xff5506a9), uint32(0xfa1a102c), uint32(0xfbd87a1b),
  5124  		uint32(0xf99ec442), uint32(0xf85cae75), uint32(0xf300e948), uint32(0xf2c2837f), uint32(0xf0843d26),
  5125  		uint32(0xf1465711), uint32(0xf4094194), uint32(0xf5cb2ba3), uint32(0xf78d95fa), uint32(0xf64fffcd),
  5126  		uint32(0xd9785d60), uint32(0xd8ba3757), uint32(0xdafc890e), uint32(0xdb3ee339), uint32(0xde71f5bc),
  5127  		uint32(0xdfb39f8b), uint32(0xddf521d2), uint32(0xdc374be5), uint32(0xd76b0cd8), uint32(0xd6a966ef),
  5128  		uint32(0xd4efd8b6), uint32(0xd52db281), uint32(0xd062a404), uint32(0xd1a0ce33), uint32(0xd3e6706a),
  5129  		uint32(0xd2241a5d), uint32(0xc55efe10), uint32(0xc49c9427), uint32(0xc6da2a7e), uint32(0xc7184049),
  5130  		uint32(0xc25756cc), uint32(0xc3953cfb), uint32(0xc1d382a2), uint32(0xc011e895), uint32(0xcb4dafa8),
  5131  		uint32(0xca8fc59f), uint32(0xc8c97bc6), uint32(0xc90b11f1), uint32(0xcc440774), uint32(0xcd866d43),
  5132  		uint32(0xcfc0d31a), uint32(0xce02b92d), uint32(0x91af9640), uint32(0x906dfc77), uint32(0x922b422e),
  5133  		uint32(0x93e92819), uint32(0x96a63e9c), uint32(0x976454ab), uint32(0x9522eaf2), uint32(0x94e080c5),
  5134  		uint32(0x9fbcc7f8), uint32(0x9e7eadcf), uint32(0x9c381396), uint32(0x9dfa79a1), uint32(0x98b56f24),
  5135  		uint32(0x99770513), uint32(0x9b31bb4a), uint32(0x9af3d17d), uint32(0x8d893530), uint32(0x8c4b5f07),
  5136  		uint32(0x8e0de15e), uint32(0x8fcf8b69), uint32(0x8a809dec), uint32(0x8b42f7db), uint32(0x89044982),
  5137  		uint32(0x88c623b5), uint32(0x839a6488), uint32(0x82580ebf), uint32(0x801eb0e6), uint32(0x81dcdad1),
  5138  		uint32(0x8493cc54), uint32(0x8551a663), uint32(0x8717183a), uint32(0x86d5720d), uint32(0xa9e2d0a0),
  5139  		uint32(0xa820ba97), uint32(0xaa6604ce), uint32(0xaba46ef9), uint32(0xaeeb787c), uint32(0xaf29124b),
  5140  		uint32(0xad6fac12), uint32(0xacadc625), uint32(0xa7f18118), uint32(0xa633eb2f), uint32(0xa4755576),
  5141  		uint32(0xa5b73f41), uint32(0xa0f829c4), uint32(0xa13a43f3), uint32(0xa37cfdaa), uint32(0xa2be979d),
  5142  		uint32(0xb5c473d0), uint32(0xb40619e7), uint32(0xb640a7be), uint32(0xb782cd89), uint32(0xb2cddb0c),
  5143  		uint32(0xb30fb13b), uint32(0xb1490f62), uint32(0xb08b6555), uint32(0xbbd72268), uint32(0xba15485f),
  5144  		uint32(0xb853f606), uint32(0xb9919c31), uint32(0xbcde8ab4), uint32(0xbd1ce083), uint32(0xbf5a5eda),
  5145  		uint32(0xbe9834ed),
  5146  	},
  5147  	{
  5148  		uint32(0x00000000), uint32(0xb8bc6765), uint32(0xaa09c88b), uint32(0x12b5afee), uint32(0x8f629757),
  5149  		uint32(0x37def032), uint32(0x256b5fdc), uint32(0x9dd738b9), uint32(0xc5b428ef), uint32(0x7d084f8a),
  5150  		uint32(0x6fbde064), uint32(0xd7018701), uint32(0x4ad6bfb8), uint32(0xf26ad8dd), uint32(0xe0df7733),
  5151  		uint32(0x58631056), uint32(0x5019579f), uint32(0xe8a530fa), uint32(0xfa109f14), uint32(0x42acf871),
  5152  		uint32(0xdf7bc0c8), uint32(0x67c7a7ad), uint32(0x75720843), uint32(0xcdce6f26), uint32(0x95ad7f70),
  5153  		uint32(0x2d111815), uint32(0x3fa4b7fb), uint32(0x8718d09e), uint32(0x1acfe827), uint32(0xa2738f42),
  5154  		uint32(0xb0c620ac), uint32(0x087a47c9), uint32(0xa032af3e), uint32(0x188ec85b), uint32(0x0a3b67b5),
  5155  		uint32(0xb28700d0), uint32(0x2f503869), uint32(0x97ec5f0c), uint32(0x8559f0e2), uint32(0x3de59787),
  5156  		uint32(0x658687d1), uint32(0xdd3ae0b4), uint32(0xcf8f4f5a), uint32(0x7733283f), uint32(0xeae41086),
  5157  		uint32(0x525877e3), uint32(0x40edd80d), uint32(0xf851bf68), uint32(0xf02bf8a1), uint32(0x48979fc4),
  5158  		uint32(0x5a22302a), uint32(0xe29e574f), uint32(0x7f496ff6), uint32(0xc7f50893), uint32(0xd540a77d),
  5159  		uint32(0x6dfcc018), uint32(0x359fd04e), uint32(0x8d23b72b), uint32(0x9f9618c5), uint32(0x272a7fa0),
  5160  		uint32(0xbafd4719), uint32(0x0241207c), uint32(0x10f48f92), uint32(0xa848e8f7), uint32(0x9b14583d),
  5161  		uint32(0x23a83f58), uint32(0x311d90b6), uint32(0x89a1f7d3), uint32(0x1476cf6a), uint32(0xaccaa80f),
  5162  		uint32(0xbe7f07e1), uint32(0x06c36084), uint32(0x5ea070d2), uint32(0xe61c17b7), uint32(0xf4a9b859),
  5163  		uint32(0x4c15df3c), uint32(0xd1c2e785), uint32(0x697e80e0), uint32(0x7bcb2f0e), uint32(0xc377486b),
  5164  		uint32(0xcb0d0fa2), uint32(0x73b168c7), uint32(0x6104c729), uint32(0xd9b8a04c), uint32(0x446f98f5),
  5165  		uint32(0xfcd3ff90), uint32(0xee66507e), uint32(0x56da371b), uint32(0x0eb9274d), uint32(0xb6054028),
  5166  		uint32(0xa4b0efc6), uint32(0x1c0c88a3), uint32(0x81dbb01a), uint32(0x3967d77f), uint32(0x2bd27891),
  5167  		uint32(0x936e1ff4), uint32(0x3b26f703), uint32(0x839a9066), uint32(0x912f3f88), uint32(0x299358ed),
  5168  		uint32(0xb4446054), uint32(0x0cf80731), uint32(0x1e4da8df), uint32(0xa6f1cfba), uint32(0xfe92dfec),
  5169  		uint32(0x462eb889), uint32(0x549b1767), uint32(0xec277002), uint32(0x71f048bb), uint32(0xc94c2fde),
  5170  		uint32(0xdbf98030), uint32(0x6345e755), uint32(0x6b3fa09c), uint32(0xd383c7f9), uint32(0xc1366817),
  5171  		uint32(0x798a0f72), uint32(0xe45d37cb), uint32(0x5ce150ae), uint32(0x4e54ff40), uint32(0xf6e89825),
  5172  		uint32(0xae8b8873), uint32(0x1637ef16), uint32(0x048240f8), uint32(0xbc3e279d), uint32(0x21e91f24),
  5173  		uint32(0x99557841), uint32(0x8be0d7af), uint32(0x335cb0ca), uint32(0xed59b63b), uint32(0x55e5d15e),
  5174  		uint32(0x47507eb0), uint32(0xffec19d5), uint32(0x623b216c), uint32(0xda874609), uint32(0xc832e9e7),
  5175  		uint32(0x708e8e82), uint32(0x28ed9ed4), uint32(0x9051f9b1), uint32(0x82e4565f), uint32(0x3a58313a),
  5176  		uint32(0xa78f0983), uint32(0x1f336ee6), uint32(0x0d86c108), uint32(0xb53aa66d), uint32(0xbd40e1a4),
  5177  		uint32(0x05fc86c1), uint32(0x1749292f), uint32(0xaff54e4a), uint32(0x322276f3), uint32(0x8a9e1196),
  5178  		uint32(0x982bbe78), uint32(0x2097d91d), uint32(0x78f4c94b), uint32(0xc048ae2e), uint32(0xd2fd01c0),
  5179  		uint32(0x6a4166a5), uint32(0xf7965e1c), uint32(0x4f2a3979), uint32(0x5d9f9697), uint32(0xe523f1f2),
  5180  		uint32(0x4d6b1905), uint32(0xf5d77e60), uint32(0xe762d18e), uint32(0x5fdeb6eb), uint32(0xc2098e52),
  5181  		uint32(0x7ab5e937), uint32(0x680046d9), uint32(0xd0bc21bc), uint32(0x88df31ea), uint32(0x3063568f),
  5182  		uint32(0x22d6f961), uint32(0x9a6a9e04), uint32(0x07bda6bd), uint32(0xbf01c1d8), uint32(0xadb46e36),
  5183  		uint32(0x15080953), uint32(0x1d724e9a), uint32(0xa5ce29ff), uint32(0xb77b8611), uint32(0x0fc7e174),
  5184  		uint32(0x9210d9cd), uint32(0x2aacbea8), uint32(0x38191146), uint32(0x80a57623), uint32(0xd8c66675),
  5185  		uint32(0x607a0110), uint32(0x72cfaefe), uint32(0xca73c99b), uint32(0x57a4f122), uint32(0xef189647),
  5186  		uint32(0xfdad39a9), uint32(0x45115ecc), uint32(0x764dee06), uint32(0xcef18963), uint32(0xdc44268d),
  5187  		uint32(0x64f841e8), uint32(0xf92f7951), uint32(0x41931e34), uint32(0x5326b1da), uint32(0xeb9ad6bf),
  5188  		uint32(0xb3f9c6e9), uint32(0x0b45a18c), uint32(0x19f00e62), uint32(0xa14c6907), uint32(0x3c9b51be),
  5189  		uint32(0x842736db), uint32(0x96929935), uint32(0x2e2efe50), uint32(0x2654b999), uint32(0x9ee8defc),
  5190  		uint32(0x8c5d7112), uint32(0x34e11677), uint32(0xa9362ece), uint32(0x118a49ab), uint32(0x033fe645),
  5191  		uint32(0xbb838120), uint32(0xe3e09176), uint32(0x5b5cf613), uint32(0x49e959fd), uint32(0xf1553e98),
  5192  		uint32(0x6c820621), uint32(0xd43e6144), uint32(0xc68bceaa), uint32(0x7e37a9cf), uint32(0xd67f4138),
  5193  		uint32(0x6ec3265d), uint32(0x7c7689b3), uint32(0xc4caeed6), uint32(0x591dd66f), uint32(0xe1a1b10a),
  5194  		uint32(0xf3141ee4), uint32(0x4ba87981), uint32(0x13cb69d7), uint32(0xab770eb2), uint32(0xb9c2a15c),
  5195  		uint32(0x017ec639), uint32(0x9ca9fe80), uint32(0x241599e5), uint32(0x36a0360b), uint32(0x8e1c516e),
  5196  		uint32(0x866616a7), uint32(0x3eda71c2), uint32(0x2c6fde2c), uint32(0x94d3b949), uint32(0x090481f0),
  5197  		uint32(0xb1b8e695), uint32(0xa30d497b), uint32(0x1bb12e1e), uint32(0x43d23e48), uint32(0xfb6e592d),
  5198  		uint32(0xe9dbf6c3), uint32(0x516791a6), uint32(0xccb0a91f), uint32(0x740cce7a), uint32(0x66b96194),
  5199  		uint32(0xde0506f1),
  5200  	},
  5201  	{
  5202  		uint32(0x00000000), uint32(0x96300777), uint32(0x2c610eee), uint32(0xba510999), uint32(0x19c46d07),
  5203  		uint32(0x8ff46a70), uint32(0x35a563e9), uint32(0xa395649e), uint32(0x3288db0e), uint32(0xa4b8dc79),
  5204  		uint32(0x1ee9d5e0), uint32(0x88d9d297), uint32(0x2b4cb609), uint32(0xbd7cb17e), uint32(0x072db8e7),
  5205  		uint32(0x911dbf90), uint32(0x6410b71d), uint32(0xf220b06a), uint32(0x4871b9f3), uint32(0xde41be84),
  5206  		uint32(0x7dd4da1a), uint32(0xebe4dd6d), uint32(0x51b5d4f4), uint32(0xc785d383), uint32(0x56986c13),
  5207  		uint32(0xc0a86b64), uint32(0x7af962fd), uint32(0xecc9658a), uint32(0x4f5c0114), uint32(0xd96c0663),
  5208  		uint32(0x633d0ffa), uint32(0xf50d088d), uint32(0xc8206e3b), uint32(0x5e10694c), uint32(0xe44160d5),
  5209  		uint32(0x727167a2), uint32(0xd1e4033c), uint32(0x47d4044b), uint32(0xfd850dd2), uint32(0x6bb50aa5),
  5210  		uint32(0xfaa8b535), uint32(0x6c98b242), uint32(0xd6c9bbdb), uint32(0x40f9bcac), uint32(0xe36cd832),
  5211  		uint32(0x755cdf45), uint32(0xcf0dd6dc), uint32(0x593dd1ab), uint32(0xac30d926), uint32(0x3a00de51),
  5212  		uint32(0x8051d7c8), uint32(0x1661d0bf), uint32(0xb5f4b421), uint32(0x23c4b356), uint32(0x9995bacf),
  5213  		uint32(0x0fa5bdb8), uint32(0x9eb80228), uint32(0x0888055f), uint32(0xb2d90cc6), uint32(0x24e90bb1),
  5214  		uint32(0x877c6f2f), uint32(0x114c6858), uint32(0xab1d61c1), uint32(0x3d2d66b6), uint32(0x9041dc76),
  5215  		uint32(0x0671db01), uint32(0xbc20d298), uint32(0x2a10d5ef), uint32(0x8985b171), uint32(0x1fb5b606),
  5216  		uint32(0xa5e4bf9f), uint32(0x33d4b8e8), uint32(0xa2c90778), uint32(0x34f9000f), uint32(0x8ea80996),
  5217  		uint32(0x18980ee1), uint32(0xbb0d6a7f), uint32(0x2d3d6d08), uint32(0x976c6491), uint32(0x015c63e6),
  5218  		uint32(0xf4516b6b), uint32(0x62616c1c), uint32(0xd8306585), uint32(0x4e0062f2), uint32(0xed95066c),
  5219  		uint32(0x7ba5011b), uint32(0xc1f40882), uint32(0x57c40ff5), uint32(0xc6d9b065), uint32(0x50e9b712),
  5220  		uint32(0xeab8be8b), uint32(0x7c88b9fc), uint32(0xdf1ddd62), uint32(0x492dda15), uint32(0xf37cd38c),
  5221  		uint32(0x654cd4fb), uint32(0x5861b24d), uint32(0xce51b53a), uint32(0x7400bca3), uint32(0xe230bbd4),
  5222  		uint32(0x41a5df4a), uint32(0xd795d83d), uint32(0x6dc4d1a4), uint32(0xfbf4d6d3), uint32(0x6ae96943),
  5223  		uint32(0xfcd96e34), uint32(0x468867ad), uint32(0xd0b860da), uint32(0x732d0444), uint32(0xe51d0333),
  5224  		uint32(0x5f4c0aaa), uint32(0xc97c0ddd), uint32(0x3c710550), uint32(0xaa410227), uint32(0x10100bbe),
  5225  		uint32(0x86200cc9), uint32(0x25b56857), uint32(0xb3856f20), uint32(0x09d466b9), uint32(0x9fe461ce),
  5226  		uint32(0x0ef9de5e), uint32(0x98c9d929), uint32(0x2298d0b0), uint32(0xb4a8d7c7), uint32(0x173db359),
  5227  		uint32(0x810db42e), uint32(0x3b5cbdb7), uint32(0xad6cbac0), uint32(0x2083b8ed), uint32(0xb6b3bf9a),
  5228  		uint32(0x0ce2b603), uint32(0x9ad2b174), uint32(0x3947d5ea), uint32(0xaf77d29d), uint32(0x1526db04),
  5229  		uint32(0x8316dc73), uint32(0x120b63e3), uint32(0x843b6494), uint32(0x3e6a6d0d), uint32(0xa85a6a7a),
  5230  		uint32(0x0bcf0ee4), uint32(0x9dff0993), uint32(0x27ae000a), uint32(0xb19e077d), uint32(0x44930ff0),
  5231  		uint32(0xd2a30887), uint32(0x68f2011e), uint32(0xfec20669), uint32(0x5d5762f7), uint32(0xcb676580),
  5232  		uint32(0x71366c19), uint32(0xe7066b6e), uint32(0x761bd4fe), uint32(0xe02bd389), uint32(0x5a7ada10),
  5233  		uint32(0xcc4add67), uint32(0x6fdfb9f9), uint32(0xf9efbe8e), uint32(0x43beb717), uint32(0xd58eb060),
  5234  		uint32(0xe8a3d6d6), uint32(0x7e93d1a1), uint32(0xc4c2d838), uint32(0x52f2df4f), uint32(0xf167bbd1),
  5235  		uint32(0x6757bca6), uint32(0xdd06b53f), uint32(0x4b36b248), uint32(0xda2b0dd8), uint32(0x4c1b0aaf),
  5236  		uint32(0xf64a0336), uint32(0x607a0441), uint32(0xc3ef60df), uint32(0x55df67a8), uint32(0xef8e6e31),
  5237  		uint32(0x79be6946), uint32(0x8cb361cb), uint32(0x1a8366bc), uint32(0xa0d26f25), uint32(0x36e26852),
  5238  		uint32(0x95770ccc), uint32(0x03470bbb), uint32(0xb9160222), uint32(0x2f260555), uint32(0xbe3bbac5),
  5239  		uint32(0x280bbdb2), uint32(0x925ab42b), uint32(0x046ab35c), uint32(0xa7ffd7c2), uint32(0x31cfd0b5),
  5240  		uint32(0x8b9ed92c), uint32(0x1daede5b), uint32(0xb0c2649b), uint32(0x26f263ec), uint32(0x9ca36a75),
  5241  		uint32(0x0a936d02), uint32(0xa906099c), uint32(0x3f360eeb), uint32(0x85670772), uint32(0x13570005),
  5242  		uint32(0x824abf95), uint32(0x147ab8e2), uint32(0xae2bb17b), uint32(0x381bb60c), uint32(0x9b8ed292),
  5243  		uint32(0x0dbed5e5), uint32(0xb7efdc7c), uint32(0x21dfdb0b), uint32(0xd4d2d386), uint32(0x42e2d4f1),
  5244  		uint32(0xf8b3dd68), uint32(0x6e83da1f), uint32(0xcd16be81), uint32(0x5b26b9f6), uint32(0xe177b06f),
  5245  		uint32(0x7747b718), uint32(0xe65a0888), uint32(0x706a0fff), uint32(0xca3b0666), uint32(0x5c0b0111),
  5246  		uint32(0xff9e658f), uint32(0x69ae62f8), uint32(0xd3ff6b61), uint32(0x45cf6c16), uint32(0x78e20aa0),
  5247  		uint32(0xeed20dd7), uint32(0x5483044e), uint32(0xc2b30339), uint32(0x612667a7), uint32(0xf71660d0),
  5248  		uint32(0x4d476949), uint32(0xdb776e3e), uint32(0x4a6ad1ae), uint32(0xdc5ad6d9), uint32(0x660bdf40),
  5249  		uint32(0xf03bd837), uint32(0x53aebca9), uint32(0xc59ebbde), uint32(0x7fcfb247), uint32(0xe9ffb530),
  5250  		uint32(0x1cf2bdbd), uint32(0x8ac2baca), uint32(0x3093b353), uint32(0xa6a3b424), uint32(0x0536d0ba),
  5251  		uint32(0x9306d7cd), uint32(0x2957de54), uint32(0xbf67d923), uint32(0x2e7a66b3), uint32(0xb84a61c4),
  5252  		uint32(0x021b685d), uint32(0x942b6f2a), uint32(0x37be0bb4), uint32(0xa18e0cc3), uint32(0x1bdf055a),
  5253  		uint32(0x8def022d),
  5254  	},
  5255  	{
  5256  		uint32(0x00000000), uint32(0x41311b19), uint32(0x82623632), uint32(0xc3532d2b), uint32(0x04c56c64),
  5257  		uint32(0x45f4777d), uint32(0x86a75a56), uint32(0xc796414f), uint32(0x088ad9c8), uint32(0x49bbc2d1),
  5258  		uint32(0x8ae8effa), uint32(0xcbd9f4e3), uint32(0x0c4fb5ac), uint32(0x4d7eaeb5), uint32(0x8e2d839e),
  5259  		uint32(0xcf1c9887), uint32(0x5112c24a), uint32(0x1023d953), uint32(0xd370f478), uint32(0x9241ef61),
  5260  		uint32(0x55d7ae2e), uint32(0x14e6b537), uint32(0xd7b5981c), uint32(0x96848305), uint32(0x59981b82),
  5261  		uint32(0x18a9009b), uint32(0xdbfa2db0), uint32(0x9acb36a9), uint32(0x5d5d77e6), uint32(0x1c6c6cff),
  5262  		uint32(0xdf3f41d4), uint32(0x9e0e5acd), uint32(0xa2248495), uint32(0xe3159f8c), uint32(0x2046b2a7),
  5263  		uint32(0x6177a9be), uint32(0xa6e1e8f1), uint32(0xe7d0f3e8), uint32(0x2483dec3), uint32(0x65b2c5da),
  5264  		uint32(0xaaae5d5d), uint32(0xeb9f4644), uint32(0x28cc6b6f), uint32(0x69fd7076), uint32(0xae6b3139),
  5265  		uint32(0xef5a2a20), uint32(0x2c09070b), uint32(0x6d381c12), uint32(0xf33646df), uint32(0xb2075dc6),
  5266  		uint32(0x715470ed), uint32(0x30656bf4), uint32(0xf7f32abb), uint32(0xb6c231a2), uint32(0x75911c89),
  5267  		uint32(0x34a00790), uint32(0xfbbc9f17), uint32(0xba8d840e), uint32(0x79dea925), uint32(0x38efb23c),
  5268  		uint32(0xff79f373), uint32(0xbe48e86a), uint32(0x7d1bc541), uint32(0x3c2ade58), uint32(0x054f79f0),
  5269  		uint32(0x447e62e9), uint32(0x872d4fc2), uint32(0xc61c54db), uint32(0x018a1594), uint32(0x40bb0e8d),
  5270  		uint32(0x83e823a6), uint32(0xc2d938bf), uint32(0x0dc5a038), uint32(0x4cf4bb21), uint32(0x8fa7960a),
  5271  		uint32(0xce968d13), uint32(0x0900cc5c), uint32(0x4831d745), uint32(0x8b62fa6e), uint32(0xca53e177),
  5272  		uint32(0x545dbbba), uint32(0x156ca0a3), uint32(0xd63f8d88), uint32(0x970e9691), uint32(0x5098d7de),
  5273  		uint32(0x11a9ccc7), uint32(0xd2fae1ec), uint32(0x93cbfaf5), uint32(0x5cd76272), uint32(0x1de6796b),
  5274  		uint32(0xdeb55440), uint32(0x9f844f59), uint32(0x58120e16), uint32(0x1923150f), uint32(0xda703824),
  5275  		uint32(0x9b41233d), uint32(0xa76bfd65), uint32(0xe65ae67c), uint32(0x2509cb57), uint32(0x6438d04e),
  5276  		uint32(0xa3ae9101), uint32(0xe29f8a18), uint32(0x21cca733), uint32(0x60fdbc2a), uint32(0xafe124ad),
  5277  		uint32(0xeed03fb4), uint32(0x2d83129f), uint32(0x6cb20986), uint32(0xab2448c9), uint32(0xea1553d0),
  5278  		uint32(0x29467efb), uint32(0x687765e2), uint32(0xf6793f2f), uint32(0xb7482436), uint32(0x741b091d),
  5279  		uint32(0x352a1204), uint32(0xf2bc534b), uint32(0xb38d4852), uint32(0x70de6579), uint32(0x31ef7e60),
  5280  		uint32(0xfef3e6e7), uint32(0xbfc2fdfe), uint32(0x7c91d0d5), uint32(0x3da0cbcc), uint32(0xfa368a83),
  5281  		uint32(0xbb07919a), uint32(0x7854bcb1), uint32(0x3965a7a8), uint32(0x4b98833b), uint32(0x0aa99822),
  5282  		uint32(0xc9fab509), uint32(0x88cbae10), uint32(0x4f5def5f), uint32(0x0e6cf446), uint32(0xcd3fd96d),
  5283  		uint32(0x8c0ec274), uint32(0x43125af3), uint32(0x022341ea), uint32(0xc1706cc1), uint32(0x804177d8),
  5284  		uint32(0x47d73697), uint32(0x06e62d8e), uint32(0xc5b500a5), uint32(0x84841bbc), uint32(0x1a8a4171),
  5285  		uint32(0x5bbb5a68), uint32(0x98e87743), uint32(0xd9d96c5a), uint32(0x1e4f2d15), uint32(0x5f7e360c),
  5286  		uint32(0x9c2d1b27), uint32(0xdd1c003e), uint32(0x120098b9), uint32(0x533183a0), uint32(0x9062ae8b),
  5287  		uint32(0xd153b592), uint32(0x16c5f4dd), uint32(0x57f4efc4), uint32(0x94a7c2ef), uint32(0xd596d9f6),
  5288  		uint32(0xe9bc07ae), uint32(0xa88d1cb7), uint32(0x6bde319c), uint32(0x2aef2a85), uint32(0xed796bca),
  5289  		uint32(0xac4870d3), uint32(0x6f1b5df8), uint32(0x2e2a46e1), uint32(0xe136de66), uint32(0xa007c57f),
  5290  		uint32(0x6354e854), uint32(0x2265f34d), uint32(0xe5f3b202), uint32(0xa4c2a91b), uint32(0x67918430),
  5291  		uint32(0x26a09f29), uint32(0xb8aec5e4), uint32(0xf99fdefd), uint32(0x3accf3d6), uint32(0x7bfde8cf),
  5292  		uint32(0xbc6ba980), uint32(0xfd5ab299), uint32(0x3e099fb2), uint32(0x7f3884ab), uint32(0xb0241c2c),
  5293  		uint32(0xf1150735), uint32(0x32462a1e), uint32(0x73773107), uint32(0xb4e17048), uint32(0xf5d06b51),
  5294  		uint32(0x3683467a), uint32(0x77b25d63), uint32(0x4ed7facb), uint32(0x0fe6e1d2), uint32(0xccb5ccf9),
  5295  		uint32(0x8d84d7e0), uint32(0x4a1296af), uint32(0x0b238db6), uint32(0xc870a09d), uint32(0x8941bb84),
  5296  		uint32(0x465d2303), uint32(0x076c381a), uint32(0xc43f1531), uint32(0x850e0e28), uint32(0x42984f67),
  5297  		uint32(0x03a9547e), uint32(0xc0fa7955), uint32(0x81cb624c), uint32(0x1fc53881), uint32(0x5ef42398),
  5298  		uint32(0x9da70eb3), uint32(0xdc9615aa), uint32(0x1b0054e5), uint32(0x5a314ffc), uint32(0x996262d7),
  5299  		uint32(0xd85379ce), uint32(0x174fe149), uint32(0x567efa50), uint32(0x952dd77b), uint32(0xd41ccc62),
  5300  		uint32(0x138a8d2d), uint32(0x52bb9634), uint32(0x91e8bb1f), uint32(0xd0d9a006), uint32(0xecf37e5e),
  5301  		uint32(0xadc26547), uint32(0x6e91486c), uint32(0x2fa05375), uint32(0xe836123a), uint32(0xa9070923),
  5302  		uint32(0x6a542408), uint32(0x2b653f11), uint32(0xe479a796), uint32(0xa548bc8f), uint32(0x661b91a4),
  5303  		uint32(0x272a8abd), uint32(0xe0bccbf2), uint32(0xa18dd0eb), uint32(0x62defdc0), uint32(0x23efe6d9),
  5304  		uint32(0xbde1bc14), uint32(0xfcd0a70d), uint32(0x3f838a26), uint32(0x7eb2913f), uint32(0xb924d070),
  5305  		uint32(0xf815cb69), uint32(0x3b46e642), uint32(0x7a77fd5b), uint32(0xb56b65dc), uint32(0xf45a7ec5),
  5306  		uint32(0x370953ee), uint32(0x763848f7), uint32(0xb1ae09b8), uint32(0xf09f12a1), uint32(0x33cc3f8a),
  5307  		uint32(0x72fd2493),
  5308  	},
  5309  	{
  5310  		uint32(0x00000000), uint32(0x376ac201), uint32(0x6ed48403), uint32(0x59be4602), uint32(0xdca80907),
  5311  		uint32(0xebc2cb06), uint32(0xb27c8d04), uint32(0x85164f05), uint32(0xb851130e), uint32(0x8f3bd10f),
  5312  		uint32(0xd685970d), uint32(0xe1ef550c), uint32(0x64f91a09), uint32(0x5393d808), uint32(0x0a2d9e0a),
  5313  		uint32(0x3d475c0b), uint32(0x70a3261c), uint32(0x47c9e41d), uint32(0x1e77a21f), uint32(0x291d601e),
  5314  		uint32(0xac0b2f1b), uint32(0x9b61ed1a), uint32(0xc2dfab18), uint32(0xf5b56919), uint32(0xc8f23512),
  5315  		uint32(0xff98f713), uint32(0xa626b111), uint32(0x914c7310), uint32(0x145a3c15), uint32(0x2330fe14),
  5316  		uint32(0x7a8eb816), uint32(0x4de47a17), uint32(0xe0464d38), uint32(0xd72c8f39), uint32(0x8e92c93b),
  5317  		uint32(0xb9f80b3a), uint32(0x3cee443f), uint32(0x0b84863e), uint32(0x523ac03c), uint32(0x6550023d),
  5318  		uint32(0x58175e36), uint32(0x6f7d9c37), uint32(0x36c3da35), uint32(0x01a91834), uint32(0x84bf5731),
  5319  		uint32(0xb3d59530), uint32(0xea6bd332), uint32(0xdd011133), uint32(0x90e56b24), uint32(0xa78fa925),
  5320  		uint32(0xfe31ef27), uint32(0xc95b2d26), uint32(0x4c4d6223), uint32(0x7b27a022), uint32(0x2299e620),
  5321  		uint32(0x15f32421), uint32(0x28b4782a), uint32(0x1fdeba2b), uint32(0x4660fc29), uint32(0x710a3e28),
  5322  		uint32(0xf41c712d), uint32(0xc376b32c), uint32(0x9ac8f52e), uint32(0xada2372f), uint32(0xc08d9a70),
  5323  		uint32(0xf7e75871), uint32(0xae591e73), uint32(0x9933dc72), uint32(0x1c259377), uint32(0x2b4f5176),
  5324  		uint32(0x72f11774), uint32(0x459bd575), uint32(0x78dc897e), uint32(0x4fb64b7f), uint32(0x16080d7d),
  5325  		uint32(0x2162cf7c), uint32(0xa4748079), uint32(0x931e4278), uint32(0xcaa0047a), uint32(0xfdcac67b),
  5326  		uint32(0xb02ebc6c), uint32(0x87447e6d), uint32(0xdefa386f), uint32(0xe990fa6e), uint32(0x6c86b56b),
  5327  		uint32(0x5bec776a), uint32(0x02523168), uint32(0x3538f369), uint32(0x087faf62), uint32(0x3f156d63),
  5328  		uint32(0x66ab2b61), uint32(0x51c1e960), uint32(0xd4d7a665), uint32(0xe3bd6464), uint32(0xba032266),
  5329  		uint32(0x8d69e067), uint32(0x20cbd748), uint32(0x17a11549), uint32(0x4e1f534b), uint32(0x7975914a),
  5330  		uint32(0xfc63de4f), uint32(0xcb091c4e), uint32(0x92b75a4c), uint32(0xa5dd984d), uint32(0x989ac446),
  5331  		uint32(0xaff00647), uint32(0xf64e4045), uint32(0xc1248244), uint32(0x4432cd41), uint32(0x73580f40),
  5332  		uint32(0x2ae64942), uint32(0x1d8c8b43), uint32(0x5068f154), uint32(0x67023355), uint32(0x3ebc7557),
  5333  		uint32(0x09d6b756), uint32(0x8cc0f853), uint32(0xbbaa3a52), uint32(0xe2147c50), uint32(0xd57ebe51),
  5334  		uint32(0xe839e25a), uint32(0xdf53205b), uint32(0x86ed6659), uint32(0xb187a458), uint32(0x3491eb5d),
  5335  		uint32(0x03fb295c), uint32(0x5a456f5e), uint32(0x6d2fad5f), uint32(0x801b35e1), uint32(0xb771f7e0),
  5336  		uint32(0xeecfb1e2), uint32(0xd9a573e3), uint32(0x5cb33ce6), uint32(0x6bd9fee7), uint32(0x3267b8e5),
  5337  		uint32(0x050d7ae4), uint32(0x384a26ef), uint32(0x0f20e4ee), uint32(0x569ea2ec), uint32(0x61f460ed),
  5338  		uint32(0xe4e22fe8), uint32(0xd388ede9), uint32(0x8a36abeb), uint32(0xbd5c69ea), uint32(0xf0b813fd),
  5339  		uint32(0xc7d2d1fc), uint32(0x9e6c97fe), uint32(0xa90655ff), uint32(0x2c101afa), uint32(0x1b7ad8fb),
  5340  		uint32(0x42c49ef9), uint32(0x75ae5cf8), uint32(0x48e900f3), uint32(0x7f83c2f2), uint32(0x263d84f0),
  5341  		uint32(0x115746f1), uint32(0x944109f4), uint32(0xa32bcbf5), uint32(0xfa958df7), uint32(0xcdff4ff6),
  5342  		uint32(0x605d78d9), uint32(0x5737bad8), uint32(0x0e89fcda), uint32(0x39e33edb), uint32(0xbcf571de),
  5343  		uint32(0x8b9fb3df), uint32(0xd221f5dd), uint32(0xe54b37dc), uint32(0xd80c6bd7), uint32(0xef66a9d6),
  5344  		uint32(0xb6d8efd4), uint32(0x81b22dd5), uint32(0x04a462d0), uint32(0x33cea0d1), uint32(0x6a70e6d3),
  5345  		uint32(0x5d1a24d2), uint32(0x10fe5ec5), uint32(0x27949cc4), uint32(0x7e2adac6), uint32(0x494018c7),
  5346  		uint32(0xcc5657c2), uint32(0xfb3c95c3), uint32(0xa282d3c1), uint32(0x95e811c0), uint32(0xa8af4dcb),
  5347  		uint32(0x9fc58fca), uint32(0xc67bc9c8), uint32(0xf1110bc9), uint32(0x740744cc), uint32(0x436d86cd),
  5348  		uint32(0x1ad3c0cf), uint32(0x2db902ce), uint32(0x4096af91), uint32(0x77fc6d90), uint32(0x2e422b92),
  5349  		uint32(0x1928e993), uint32(0x9c3ea696), uint32(0xab546497), uint32(0xf2ea2295), uint32(0xc580e094),
  5350  		uint32(0xf8c7bc9f), uint32(0xcfad7e9e), uint32(0x9613389c), uint32(0xa179fa9d), uint32(0x246fb598),
  5351  		uint32(0x13057799), uint32(0x4abb319b), uint32(0x7dd1f39a), uint32(0x3035898d), uint32(0x075f4b8c),
  5352  		uint32(0x5ee10d8e), uint32(0x698bcf8f), uint32(0xec9d808a), uint32(0xdbf7428b), uint32(0x82490489),
  5353  		uint32(0xb523c688), uint32(0x88649a83), uint32(0xbf0e5882), uint32(0xe6b01e80), uint32(0xd1dadc81),
  5354  		uint32(0x54cc9384), uint32(0x63a65185), uint32(0x3a181787), uint32(0x0d72d586), uint32(0xa0d0e2a9),
  5355  		uint32(0x97ba20a8), uint32(0xce0466aa), uint32(0xf96ea4ab), uint32(0x7c78ebae), uint32(0x4b1229af),
  5356  		uint32(0x12ac6fad), uint32(0x25c6adac), uint32(0x1881f1a7), uint32(0x2feb33a6), uint32(0x765575a4),
  5357  		uint32(0x413fb7a5), uint32(0xc429f8a0), uint32(0xf3433aa1), uint32(0xaafd7ca3), uint32(0x9d97bea2),
  5358  		uint32(0xd073c4b5), uint32(0xe71906b4), uint32(0xbea740b6), uint32(0x89cd82b7), uint32(0x0cdbcdb2),
  5359  		uint32(0x3bb10fb3), uint32(0x620f49b1), uint32(0x55658bb0), uint32(0x6822d7bb), uint32(0x5f4815ba),
  5360  		uint32(0x06f653b8), uint32(0x319c91b9), uint32(0xb48adebc), uint32(0x83e01cbd), uint32(0xda5e5abf),
  5361  		uint32(0xed3498be),
  5362  	},
  5363  	{
  5364  		uint32(0x00000000), uint32(0x6567bcb8), uint32(0x8bc809aa), uint32(0xeeafb512), uint32(0x5797628f),
  5365  		uint32(0x32f0de37), uint32(0xdc5f6b25), uint32(0xb938d79d), uint32(0xef28b4c5), uint32(0x8a4f087d),
  5366  		uint32(0x64e0bd6f), uint32(0x018701d7), uint32(0xb8bfd64a), uint32(0xddd86af2), uint32(0x3377dfe0),
  5367  		uint32(0x56106358), uint32(0x9f571950), uint32(0xfa30a5e8), uint32(0x149f10fa), uint32(0x71f8ac42),
  5368  		uint32(0xc8c07bdf), uint32(0xada7c767), uint32(0x43087275), uint32(0x266fcecd), uint32(0x707fad95),
  5369  		uint32(0x1518112d), uint32(0xfbb7a43f), uint32(0x9ed01887), uint32(0x27e8cf1a), uint32(0x428f73a2),
  5370  		uint32(0xac20c6b0), uint32(0xc9477a08), uint32(0x3eaf32a0), uint32(0x5bc88e18), uint32(0xb5673b0a),
  5371  		uint32(0xd00087b2), uint32(0x6938502f), uint32(0x0c5fec97), uint32(0xe2f05985), uint32(0x8797e53d),
  5372  		uint32(0xd1878665), uint32(0xb4e03add), uint32(0x5a4f8fcf), uint32(0x3f283377), uint32(0x8610e4ea),
  5373  		uint32(0xe3775852), uint32(0x0dd8ed40), uint32(0x68bf51f8), uint32(0xa1f82bf0), uint32(0xc49f9748),
  5374  		uint32(0x2a30225a), uint32(0x4f579ee2), uint32(0xf66f497f), uint32(0x9308f5c7), uint32(0x7da740d5),
  5375  		uint32(0x18c0fc6d), uint32(0x4ed09f35), uint32(0x2bb7238d), uint32(0xc518969f), uint32(0xa07f2a27),
  5376  		uint32(0x1947fdba), uint32(0x7c204102), uint32(0x928ff410), uint32(0xf7e848a8), uint32(0x3d58149b),
  5377  		uint32(0x583fa823), uint32(0xb6901d31), uint32(0xd3f7a189), uint32(0x6acf7614), uint32(0x0fa8caac),
  5378  		uint32(0xe1077fbe), uint32(0x8460c306), uint32(0xd270a05e), uint32(0xb7171ce6), uint32(0x59b8a9f4),
  5379  		uint32(0x3cdf154c), uint32(0x85e7c2d1), uint32(0xe0807e69), uint32(0x0e2fcb7b), uint32(0x6b4877c3),
  5380  		uint32(0xa20f0dcb), uint32(0xc768b173), uint32(0x29c70461), uint32(0x4ca0b8d9), uint32(0xf5986f44),
  5381  		uint32(0x90ffd3fc), uint32(0x7e5066ee), uint32(0x1b37da56), uint32(0x4d27b90e), uint32(0x284005b6),
  5382  		uint32(0xc6efb0a4), uint32(0xa3880c1c), uint32(0x1ab0db81), uint32(0x7fd76739), uint32(0x9178d22b),
  5383  		uint32(0xf41f6e93), uint32(0x03f7263b), uint32(0x66909a83), uint32(0x883f2f91), uint32(0xed589329),
  5384  		uint32(0x546044b4), uint32(0x3107f80c), uint32(0xdfa84d1e), uint32(0xbacff1a6), uint32(0xecdf92fe),
  5385  		uint32(0x89b82e46), uint32(0x67179b54), uint32(0x027027ec), uint32(0xbb48f071), uint32(0xde2f4cc9),
  5386  		uint32(0x3080f9db), uint32(0x55e74563), uint32(0x9ca03f6b), uint32(0xf9c783d3), uint32(0x176836c1),
  5387  		uint32(0x720f8a79), uint32(0xcb375de4), uint32(0xae50e15c), uint32(0x40ff544e), uint32(0x2598e8f6),
  5388  		uint32(0x73888bae), uint32(0x16ef3716), uint32(0xf8408204), uint32(0x9d273ebc), uint32(0x241fe921),
  5389  		uint32(0x41785599), uint32(0xafd7e08b), uint32(0xcab05c33), uint32(0x3bb659ed), uint32(0x5ed1e555),
  5390  		uint32(0xb07e5047), uint32(0xd519ecff), uint32(0x6c213b62), uint32(0x094687da), uint32(0xe7e932c8),
  5391  		uint32(0x828e8e70), uint32(0xd49eed28), uint32(0xb1f95190), uint32(0x5f56e482), uint32(0x3a31583a),
  5392  		uint32(0x83098fa7), uint32(0xe66e331f), uint32(0x08c1860d), uint32(0x6da63ab5), uint32(0xa4e140bd),
  5393  		uint32(0xc186fc05), uint32(0x2f294917), uint32(0x4a4ef5af), uint32(0xf3762232), uint32(0x96119e8a),
  5394  		uint32(0x78be2b98), uint32(0x1dd99720), uint32(0x4bc9f478), uint32(0x2eae48c0), uint32(0xc001fdd2),
  5395  		uint32(0xa566416a), uint32(0x1c5e96f7), uint32(0x79392a4f), uint32(0x97969f5d), uint32(0xf2f123e5),
  5396  		uint32(0x05196b4d), uint32(0x607ed7f5), uint32(0x8ed162e7), uint32(0xebb6de5f), uint32(0x528e09c2),
  5397  		uint32(0x37e9b57a), uint32(0xd9460068), uint32(0xbc21bcd0), uint32(0xea31df88), uint32(0x8f566330),
  5398  		uint32(0x61f9d622), uint32(0x049e6a9a), uint32(0xbda6bd07), uint32(0xd8c101bf), uint32(0x366eb4ad),
  5399  		uint32(0x53090815), uint32(0x9a4e721d), uint32(0xff29cea5), uint32(0x11867bb7), uint32(0x74e1c70f),
  5400  		uint32(0xcdd91092), uint32(0xa8beac2a), uint32(0x46111938), uint32(0x2376a580), uint32(0x7566c6d8),
  5401  		uint32(0x10017a60), uint32(0xfeaecf72), uint32(0x9bc973ca), uint32(0x22f1a457), uint32(0x479618ef),
  5402  		uint32(0xa939adfd), uint32(0xcc5e1145), uint32(0x06ee4d76), uint32(0x6389f1ce), uint32(0x8d2644dc),
  5403  		uint32(0xe841f864), uint32(0x51792ff9), uint32(0x341e9341), uint32(0xdab12653), uint32(0xbfd69aeb),
  5404  		uint32(0xe9c6f9b3), uint32(0x8ca1450b), uint32(0x620ef019), uint32(0x07694ca1), uint32(0xbe519b3c),
  5405  		uint32(0xdb362784), uint32(0x35999296), uint32(0x50fe2e2e), uint32(0x99b95426), uint32(0xfcdee89e),
  5406  		uint32(0x12715d8c), uint32(0x7716e134), uint32(0xce2e36a9), uint32(0xab498a11), uint32(0x45e63f03),
  5407  		uint32(0x208183bb), uint32(0x7691e0e3), uint32(0x13f65c5b), uint32(0xfd59e949), uint32(0x983e55f1),
  5408  		uint32(0x2106826c), uint32(0x44613ed4), uint32(0xaace8bc6), uint32(0xcfa9377e), uint32(0x38417fd6),
  5409  		uint32(0x5d26c36e), uint32(0xb389767c), uint32(0xd6eecac4), uint32(0x6fd61d59), uint32(0x0ab1a1e1),
  5410  		uint32(0xe41e14f3), uint32(0x8179a84b), uint32(0xd769cb13), uint32(0xb20e77ab), uint32(0x5ca1c2b9),
  5411  		uint32(0x39c67e01), uint32(0x80fea99c), uint32(0xe5991524), uint32(0x0b36a036), uint32(0x6e511c8e),
  5412  		uint32(0xa7166686), uint32(0xc271da3e), uint32(0x2cde6f2c), uint32(0x49b9d394), uint32(0xf0810409),
  5413  		uint32(0x95e6b8b1), uint32(0x7b490da3), uint32(0x1e2eb11b), uint32(0x483ed243), uint32(0x2d596efb),
  5414  		uint32(0xc3f6dbe9), uint32(0xa6916751), uint32(0x1fa9b0cc), uint32(0x7ace0c74), uint32(0x9461b966),
  5415  		uint32(0xf10605de),
  5416  	},
  5417  } /* crc32.h:5:25 */
  5418  
  5419  // =========================================================================
  5420  // This function can be used by asm versions of crc32()
  5421  func Xget_crc_table(tls *libc.TLS) uintptr { /* crc32.c:188:19: */
  5422  	return uintptr(uintptr(unsafe.Pointer(&crc_table)))
  5423  }
  5424  
  5425  // =========================================================================
  5426  
  5427  // =========================================================================
  5428  func Xcrc32_z(tls *libc.TLS, crc uint64, buf uintptr, len Z_size_t) uint64 { /* crc32.c:202:23: */
  5429  	bp := tls.Alloc(4)
  5430  	defer tls.Free(4)
  5431  
  5432  	if buf == uintptr(Z_NULL) {
  5433  		return 0
  5434  	}
  5435  
  5436  	if uint64(unsafe.Sizeof(uintptr(0))) == uint64(unsafe.Sizeof(Ptrdiff_t(0))) {
  5437  		// var endian Z_crc_t at bp, 4
  5438  
  5439  		*(*Z_crc_t)(unsafe.Pointer(bp /* endian */)) = Z_crc_t(1)
  5440  		if *(*uint8)(unsafe.Pointer(bp)) != 0 {
  5441  			return crc32_little(tls, crc, buf, len)
  5442  		} else {
  5443  			return crc32_big(tls, crc, buf, len)
  5444  		}
  5445  	}
  5446  	crc = crc ^ 0xffffffff
  5447  	for len >= uint64(8) {
  5448  		crc = uint64(*(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + uintptr((int32(crc)^int32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&buf, 1)))))&0xff)*4))) ^ crc>>8
  5449  		crc = uint64(*(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + uintptr((int32(crc)^int32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&buf, 1)))))&0xff)*4))) ^ crc>>8
  5450  		crc = uint64(*(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + uintptr((int32(crc)^int32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&buf, 1)))))&0xff)*4))) ^ crc>>8
  5451  		crc = uint64(*(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + uintptr((int32(crc)^int32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&buf, 1)))))&0xff)*4))) ^ crc>>8
  5452  		crc = uint64(*(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + uintptr((int32(crc)^int32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&buf, 1)))))&0xff)*4))) ^ crc>>8
  5453  		crc = uint64(*(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + uintptr((int32(crc)^int32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&buf, 1)))))&0xff)*4))) ^ crc>>8
  5454  		crc = uint64(*(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + uintptr((int32(crc)^int32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&buf, 1)))))&0xff)*4))) ^ crc>>8
  5455  		crc = uint64(*(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + uintptr((int32(crc)^int32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&buf, 1)))))&0xff)*4))) ^ crc>>8
  5456  		len = len - uint64(8)
  5457  	}
  5458  	if len != 0 {
  5459  		for __ccgo := true; __ccgo; __ccgo = libc.PreDecUint64(&len, 1) != 0 {
  5460  			crc = uint64(*(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + uintptr((int32(crc)^int32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&buf, 1)))))&0xff)*4))) ^ crc>>8
  5461  		}
  5462  	}
  5463  	return crc ^ 0xffffffff
  5464  }
  5465  
  5466  // =========================================================================
  5467  func Xcrc32(tls *libc.TLS, crc uint64, buf uintptr, len UInt) uint64 { /* crc32.c:237:23: */
  5468  	return Xcrc32_z(tls, crc, buf, uint64(len))
  5469  }
  5470  
  5471  //
  5472  //    This BYFOUR code accesses the passed unsigned char * buffer with a 32-bit
  5473  //    integer pointer type. This violates the strict aliasing rule, where a
  5474  //    compiler can assume, for optimization purposes, that two pointers to
  5475  //    fundamentally different types won't ever point to the same memory. This can
  5476  //    manifest as a problem only if one of the pointers is written to. This code
  5477  //    only reads from those pointers. So long as this code remains isolated in
  5478  //    this compilation unit, there won't be a problem. For this reason, this code
  5479  //    should not be copied and pasted into a compilation unit in which other code
  5480  //    writes to the buffer that is passed to these routines.
  5481  //
  5482  
  5483  // =========================================================================
  5484  
  5485  // =========================================================================
  5486  func crc32_little(tls *libc.TLS, crc uint64, buf uintptr, len Z_size_t) uint64 { /* crc32.c:266:21: */
  5487  	var c Z_crc_t
  5488  	var buf4 uintptr
  5489  
  5490  	c = Z_crc_t(crc)
  5491  	c = ^c
  5492  	for len != 0 && Ptrdiff_t(buf)&int64(3) != 0 {
  5493  		c = *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + uintptr((c^Z_crc_t(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&buf, 1)))))&Z_crc_t(0xff))*4)) ^ c>>8
  5494  		len--
  5495  	}
  5496  
  5497  	buf4 = buf
  5498  	for len >= uint64(32) {
  5499  		c = c ^ *(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))
  5500  		c = *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 3*1024 + uintptr(c&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 2*1024 + uintptr(c>>8&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 1*1024 + uintptr(c>>16&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + uintptr(c>>24)*4))
  5501  		c = c ^ *(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))
  5502  		c = *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 3*1024 + uintptr(c&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 2*1024 + uintptr(c>>8&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 1*1024 + uintptr(c>>16&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + uintptr(c>>24)*4))
  5503  		c = c ^ *(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))
  5504  		c = *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 3*1024 + uintptr(c&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 2*1024 + uintptr(c>>8&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 1*1024 + uintptr(c>>16&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + uintptr(c>>24)*4))
  5505  		c = c ^ *(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))
  5506  		c = *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 3*1024 + uintptr(c&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 2*1024 + uintptr(c>>8&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 1*1024 + uintptr(c>>16&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + uintptr(c>>24)*4))
  5507  		c = c ^ *(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))
  5508  		c = *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 3*1024 + uintptr(c&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 2*1024 + uintptr(c>>8&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 1*1024 + uintptr(c>>16&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + uintptr(c>>24)*4))
  5509  		c = c ^ *(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))
  5510  		c = *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 3*1024 + uintptr(c&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 2*1024 + uintptr(c>>8&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 1*1024 + uintptr(c>>16&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + uintptr(c>>24)*4))
  5511  		c = c ^ *(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))
  5512  		c = *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 3*1024 + uintptr(c&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 2*1024 + uintptr(c>>8&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 1*1024 + uintptr(c>>16&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + uintptr(c>>24)*4))
  5513  		c = c ^ *(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))
  5514  		c = *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 3*1024 + uintptr(c&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 2*1024 + uintptr(c>>8&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 1*1024 + uintptr(c>>16&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + uintptr(c>>24)*4))
  5515  		len = len - uint64(32)
  5516  	}
  5517  	for len >= uint64(4) {
  5518  		c = c ^ *(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))
  5519  		c = *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 3*1024 + uintptr(c&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 2*1024 + uintptr(c>>8&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 1*1024 + uintptr(c>>16&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + uintptr(c>>24)*4))
  5520  		len = len - uint64(4)
  5521  	}
  5522  	buf = buf4
  5523  
  5524  	if len != 0 {
  5525  		for __ccgo := true; __ccgo; __ccgo = libc.PreDecUint64(&len, 1) != 0 {
  5526  			c = *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + uintptr((c^Z_crc_t(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&buf, 1)))))&Z_crc_t(0xff))*4)) ^ c>>8
  5527  		}
  5528  	}
  5529  	c = ^c
  5530  	return uint64(c)
  5531  }
  5532  
  5533  // =========================================================================
  5534  
  5535  // =========================================================================
  5536  func crc32_big(tls *libc.TLS, crc uint64, buf uintptr, len Z_size_t) uint64 { /* crc32.c:306:21: */
  5537  	var c Z_crc_t
  5538  	var buf4 uintptr
  5539  
  5540  	c = Z_crc_t(crc)>>24&Z_crc_t(0xff) + Z_crc_t(crc)>>8&Z_crc_t(0xff00) + Z_crc_t(crc)&Z_crc_t(0xff00)<<8 + Z_crc_t(crc)&Z_crc_t(0xff)<<24
  5541  	c = ^c
  5542  	for len != 0 && Ptrdiff_t(buf)&int64(3) != 0 {
  5543  		c = *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 4*1024 + uintptr(c>>24^Z_crc_t(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&buf, 1)))))*4)) ^ c<<8
  5544  		len--
  5545  	}
  5546  
  5547  	buf4 = buf
  5548  	for len >= uint64(32) {
  5549  		c = c ^ *(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))
  5550  		c = *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 4*1024 + uintptr(c&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 5*1024 + uintptr(c>>8&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 6*1024 + uintptr(c>>16&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 7*1024 + uintptr(c>>24)*4))
  5551  		c = c ^ *(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))
  5552  		c = *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 4*1024 + uintptr(c&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 5*1024 + uintptr(c>>8&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 6*1024 + uintptr(c>>16&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 7*1024 + uintptr(c>>24)*4))
  5553  		c = c ^ *(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))
  5554  		c = *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 4*1024 + uintptr(c&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 5*1024 + uintptr(c>>8&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 6*1024 + uintptr(c>>16&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 7*1024 + uintptr(c>>24)*4))
  5555  		c = c ^ *(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))
  5556  		c = *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 4*1024 + uintptr(c&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 5*1024 + uintptr(c>>8&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 6*1024 + uintptr(c>>16&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 7*1024 + uintptr(c>>24)*4))
  5557  		c = c ^ *(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))
  5558  		c = *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 4*1024 + uintptr(c&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 5*1024 + uintptr(c>>8&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 6*1024 + uintptr(c>>16&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 7*1024 + uintptr(c>>24)*4))
  5559  		c = c ^ *(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))
  5560  		c = *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 4*1024 + uintptr(c&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 5*1024 + uintptr(c>>8&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 6*1024 + uintptr(c>>16&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 7*1024 + uintptr(c>>24)*4))
  5561  		c = c ^ *(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))
  5562  		c = *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 4*1024 + uintptr(c&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 5*1024 + uintptr(c>>8&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 6*1024 + uintptr(c>>16&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 7*1024 + uintptr(c>>24)*4))
  5563  		c = c ^ *(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))
  5564  		c = *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 4*1024 + uintptr(c&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 5*1024 + uintptr(c>>8&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 6*1024 + uintptr(c>>16&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 7*1024 + uintptr(c>>24)*4))
  5565  		len = len - uint64(32)
  5566  	}
  5567  	for len >= uint64(4) {
  5568  		c = c ^ *(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))
  5569  		c = *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 4*1024 + uintptr(c&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 5*1024 + uintptr(c>>8&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 6*1024 + uintptr(c>>16&Z_crc_t(0xff))*4)) ^ *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 7*1024 + uintptr(c>>24)*4))
  5570  		len = len - uint64(4)
  5571  	}
  5572  	buf = buf4
  5573  
  5574  	if len != 0 {
  5575  		for __ccgo := true; __ccgo; __ccgo = libc.PreDecUint64(&len, 1) != 0 {
  5576  			c = *(*Z_crc_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&crc_table)) + 4*1024 + uintptr(c>>24^Z_crc_t(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&buf, 1)))))*4)) ^ c<<8
  5577  		}
  5578  	}
  5579  	c = ^c
  5580  	return uint64(c>>24&Z_crc_t(0xff) + c>>8&Z_crc_t(0xff00) + c&Z_crc_t(0xff00)<<8 + c&Z_crc_t(0xff)<<24)
  5581  }
  5582  
  5583  // =========================================================================
  5584  func gf2_matrix_times(tls *libc.TLS, mat uintptr, vec uint64) uint64 { /* crc32.c:344:21: */
  5585  	var sum uint64
  5586  
  5587  	sum = uint64(0)
  5588  	for vec != 0 {
  5589  		if vec&uint64(1) != 0 {
  5590  			sum = sum ^ *(*uint64)(unsafe.Pointer(mat))
  5591  		}
  5592  		vec >>= 1
  5593  		mat += 8
  5594  	}
  5595  	return sum
  5596  }
  5597  
  5598  // =========================================================================
  5599  func gf2_matrix_square(tls *libc.TLS, square uintptr, mat uintptr) { /* crc32.c:361:12: */
  5600  	var n int32
  5601  
  5602  	for n = 0; n < GF2_DIM; n++ {
  5603  		*(*uint64)(unsafe.Pointer(square + uintptr(n)*8)) = gf2_matrix_times(tls, mat, *(*uint64)(unsafe.Pointer(mat + uintptr(n)*8)))
  5604  	}
  5605  }
  5606  
  5607  // =========================================================================
  5608  func crc32_combine_(tls *libc.TLS, crc1 ULong, crc2 ULong, len2 Off64_t) ULong { /* crc32.c:372:13: */
  5609  	bp := tls.Alloc(512)
  5610  	defer tls.Free(512)
  5611  
  5612  	var n int32
  5613  	var row uint64
  5614  	// var even [32]uint64 at bp+256, 256
  5615  	// even-power-of-two zeros operator
  5616  	// var odd [32]uint64 at bp, 256
  5617  	// odd-power-of-two zeros operator
  5618  
  5619  	// degenerate case (also disallow negative lengths)
  5620  	if len2 <= int64(0) {
  5621  		return crc1
  5622  	}
  5623  
  5624  	// put operator for one zero bit in odd
  5625  	*(*uint64)(unsafe.Pointer(bp)) = 0xedb88320 // CRC-32 polynomial
  5626  	row = uint64(1)
  5627  	for n = 1; n < GF2_DIM; n++ {
  5628  		*(*uint64)(unsafe.Pointer(bp + uintptr(n)*8)) = row
  5629  		row <<= 1
  5630  	}
  5631  
  5632  	// put operator for two zero bits in even
  5633  	gf2_matrix_square(tls, bp+256, bp)
  5634  
  5635  	// put operator for four zero bits in odd
  5636  	gf2_matrix_square(tls, bp, bp+256)
  5637  
  5638  	// apply len2 zeros to crc1 (first square will put the operator for one
  5639  	//        zero byte, eight zero bits, in even)
  5640  	for __ccgo := true; __ccgo; __ccgo = len2 != int64(0) {
  5641  		// apply zeros operator for this bit of len2
  5642  		gf2_matrix_square(tls, bp+256, bp)
  5643  		if len2&int64(1) != 0 {
  5644  			crc1 = gf2_matrix_times(tls, bp+256, crc1)
  5645  		}
  5646  		len2 >>= 1
  5647  
  5648  		// if no more bits set, then done
  5649  		if len2 == int64(0) {
  5650  			break
  5651  		}
  5652  
  5653  		// another iteration of the loop with odd and even swapped
  5654  		gf2_matrix_square(tls, bp, bp+256)
  5655  		if len2&int64(1) != 0 {
  5656  			crc1 = gf2_matrix_times(tls, bp, crc1)
  5657  		}
  5658  		len2 >>= 1
  5659  
  5660  		// if no more bits set, then done
  5661  	}
  5662  
  5663  	// return combined crc
  5664  	crc1 = crc1 ^ crc2
  5665  	return crc1
  5666  }
  5667  
  5668  // =========================================================================
  5669  func Xcrc32_combine(tls *libc.TLS, crc1 ULong, crc2 ULong, len2 Off_t) ULong { /* crc32.c:428:15: */
  5670  	return crc32_combine_(tls, crc1, crc2, len2)
  5671  }
  5672  
  5673  func Xcrc32_combine64(tls *libc.TLS, crc1 ULong, crc2 ULong, len2 Off64_t) ULong { /* crc32.c:436:15: */
  5674  	return crc32_combine_(tls, crc1, crc2, len2)
  5675  }
  5676  
  5677  // Reverse the bytes in a 32-bit value
  5678  
  5679  // define NO_GZIP when compiling if you want to disable gzip header and
  5680  //    trailer creation by deflate().  NO_GZIP would be used to avoid linking in
  5681  //    the crc code when it is not needed.  For shared libraries, gzip encoding
  5682  //    should be left enabled.
  5683  
  5684  // ===========================================================================
  5685  // Internal compression state.
  5686  
  5687  // number of length codes, not counting the special END_BLOCK code
  5688  
  5689  // number of literal bytes 0..255
  5690  
  5691  // number of Literal or Length codes, including the END_BLOCK code
  5692  
  5693  // number of distance codes
  5694  
  5695  // number of codes used to transfer the bit lengths
  5696  
  5697  // maximum heap size
  5698  
  5699  // All codes must not exceed MAX_BITS bits
  5700  
  5701  // size of bit buffer in bi_buf
  5702  
  5703  // Stream status
  5704  
  5705  // Data structure describing a single value and its code string.
  5706  type Ct_data_s = struct {
  5707  	Ffc struct{ Ffreq Ush }
  5708  	Fdl struct{ Fdad Ush }
  5709  } /* zlib.h:84:1 */
  5710  
  5711  // Reverse the bytes in a 32-bit value
  5712  
  5713  // define NO_GZIP when compiling if you want to disable gzip header and
  5714  //    trailer creation by deflate().  NO_GZIP would be used to avoid linking in
  5715  //    the crc code when it is not needed.  For shared libraries, gzip encoding
  5716  //    should be left enabled.
  5717  
  5718  // ===========================================================================
  5719  // Internal compression state.
  5720  
  5721  // number of length codes, not counting the special END_BLOCK code
  5722  
  5723  // number of literal bytes 0..255
  5724  
  5725  // number of Literal or Length codes, including the END_BLOCK code
  5726  
  5727  // number of distance codes
  5728  
  5729  // number of codes used to transfer the bit lengths
  5730  
  5731  // maximum heap size
  5732  
  5733  // All codes must not exceed MAX_BITS bits
  5734  
  5735  // size of bit buffer in bi_buf
  5736  
  5737  // Stream status
  5738  
  5739  // Data structure describing a single value and its code string.
  5740  type Ct_data = Ct_data_s /* deflate.h:77:7 */
  5741  
  5742  type Static_tree_desc_s = struct {
  5743  	Fstatic_tree uintptr
  5744  	Fextra_bits  uintptr
  5745  	Fextra_base  int32
  5746  	Felems       int32
  5747  	Fmax_length  int32
  5748  	F__ccgo_pad1 [4]byte
  5749  } /* deflate.h:84:9 */
  5750  
  5751  type Tree_desc_s = struct {
  5752  	Fdyn_tree    uintptr
  5753  	Fmax_code    int32
  5754  	F__ccgo_pad1 [4]byte
  5755  	Fstat_desc   uintptr
  5756  } /* zlib.h:84:1 */
  5757  
  5758  type Tree_desc = Tree_desc_s /* deflate.h:90:7 */
  5759  
  5760  type Pos = Ush     /* deflate.h:92:13 */
  5761  type Posf = Pos    /* deflate.h:93:17 */
  5762  type IPos = uint32 /* deflate.h:94:18 */
  5763  
  5764  // A Pos is an index in the character window. We use short instead of int to
  5765  // save space in the various tables. IPos is used only for parameter passing.
  5766  
  5767  type Deflate_state = Internal_state /* deflate.h:276:7 */
  5768  
  5769  var Xdeflate_copyright = *(*[69]uint8)(unsafe.Pointer(ts + 7)) /* deflate.c:54:12 */
  5770  //
  5771  //   If you use the zlib library in a product, an acknowledgment is welcome
  5772  //   in the documentation of your product. If for some reason you cannot
  5773  //   include such an acknowledgment, I would appreciate that you keep this
  5774  //   copyright string in the executable of your product.
  5775  //
  5776  
  5777  // ===========================================================================
  5778  //  Function prototypes.
  5779  type Block_state = uint32 /* deflate.c:71:3 */
  5780  
  5781  type Compress_func = uintptr /* deflate.c:73:21 */
  5782  
  5783  // ===========================================================================
  5784  // Local data
  5785  
  5786  // Tail of hash chains
  5787  
  5788  // Matches of length 3 are discarded if their distance exceeds TOO_FAR
  5789  
  5790  // Values for max_lazy_match, good_match and max_chain_length, depending on
  5791  // the desired pack level (0..9). The values given below have been tuned to
  5792  // exclude worst case performance for pathological files. Better values may be
  5793  // found for specific files.
  5794  type Config_s = struct {
  5795  	Fgood_length Ush
  5796  	Fmax_lazy    Ush
  5797  	Fnice_length Ush
  5798  	Fmax_chain   Ush
  5799  	Ffunc        Compress_func
  5800  } /* deflate.c:120:9 */
  5801  
  5802  // ===========================================================================
  5803  // Local data
  5804  
  5805  // Tail of hash chains
  5806  
  5807  // Matches of length 3 are discarded if their distance exceeds TOO_FAR
  5808  
  5809  // Values for max_lazy_match, good_match and max_chain_length, depending on
  5810  // the desired pack level (0..9). The values given below have been tuned to
  5811  // exclude worst case performance for pathological files. Better values may be
  5812  // found for specific files.
  5813  type Config = Config_s /* deflate.c:126:3 */
  5814  
  5815  var configuration_table = [10]Config{
  5816  	//      good lazy nice chain
  5817  	/* 0 */ {Ffunc: 0}, // store only
  5818  	/* 1 */ {Fgood_length: Ush(4), Fmax_lazy: Ush(4), Fnice_length: Ush(8), Fmax_chain: Ush(4), Ffunc: 0}, // max speed, no lazy matches
  5819  	/* 2 */ {Fgood_length: Ush(4), Fmax_lazy: Ush(5), Fnice_length: Ush(16), Fmax_chain: Ush(8), Ffunc: 0},
  5820  	/* 3 */ {Fgood_length: Ush(4), Fmax_lazy: Ush(6), Fnice_length: Ush(32), Fmax_chain: Ush(32), Ffunc: 0},
  5821  
  5822  	/* 4 */ {Fgood_length: Ush(4), Fmax_lazy: Ush(4), Fnice_length: Ush(16), Fmax_chain: Ush(16), Ffunc: 0}, // lazy matches
  5823  	/* 5 */ {Fgood_length: Ush(8), Fmax_lazy: Ush(16), Fnice_length: Ush(32), Fmax_chain: Ush(32), Ffunc: 0},
  5824  	/* 6 */ {Fgood_length: Ush(8), Fmax_lazy: Ush(16), Fnice_length: Ush(128), Fmax_chain: Ush(128), Ffunc: 0},
  5825  	/* 7 */ {Fgood_length: Ush(8), Fmax_lazy: Ush(32), Fnice_length: Ush(128), Fmax_chain: Ush(256), Ffunc: 0},
  5826  	/* 8 */ {Fgood_length: Ush(32), Fmax_lazy: Ush(128), Fnice_length: Ush(258), Fmax_chain: Ush(1024), Ffunc: 0},
  5827  	/* 9 */ {Fgood_length: Ush(32), Fmax_lazy: Ush(258), Fnice_length: Ush(258), Fmax_chain: Ush(4096), Ffunc: 0}} /* deflate.c:134:20 */
  5828  
  5829  // max compression
  5830  
  5831  // Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
  5832  // For deflate_fast() (levels <= 3) good is ignored and lazy has a different
  5833  // meaning.
  5834  
  5835  // rank Z_BLOCK between Z_NO_FLUSH and Z_PARTIAL_FLUSH
  5836  
  5837  // ===========================================================================
  5838  // Update a hash value with the given input byte
  5839  // IN  assertion: all calls to UPDATE_HASH are made with consecutive input
  5840  //    characters, so that a running hash key can be computed from the previous
  5841  //    key instead of complete recalculation each time.
  5842  
  5843  // ===========================================================================
  5844  // Insert string str in the dictionary and set match_head to the previous head
  5845  // of the hash chain (the most recent string with same hash key). Return
  5846  // the previous length of the hash chain.
  5847  // If this file is compiled with -DFASTEST, the compression level is forced
  5848  // to 1, and no hash chains are maintained.
  5849  // IN  assertion: all calls to INSERT_STRING are made with consecutive input
  5850  //    characters and the first MIN_MATCH bytes of str are valid (except for
  5851  //    the last MIN_MATCH-1 bytes of the input file).
  5852  
  5853  // ===========================================================================
  5854  // Initialize the hash table (avoiding 64K overflow for 16 bit systems).
  5855  // prev[] will be initialized on the fly.
  5856  
  5857  // ===========================================================================
  5858  // Slide the hash table when sliding the window down (could be avoided with 32
  5859  // bit values at the expense of memory usage). We slide even when level == 0 to
  5860  // keep the hash table consistent if we switch back to level > 0 later.
  5861  func slide_hash(tls *libc.TLS, s uintptr) { /* deflate.c:201:12: */
  5862  	var n uint32
  5863  	var m uint32
  5864  	var p uintptr
  5865  	var wsize UInt = (*Deflate_state)(unsafe.Pointer(s)).Fw_size
  5866  
  5867  	n = (*Deflate_state)(unsafe.Pointer(s)).Fhash_size
  5868  	p = (*Deflate_state)(unsafe.Pointer(s)).Fhead + uintptr(n)*2
  5869  	for __ccgo := true; __ccgo; __ccgo = libc.PreDecUint32(&n, 1) != 0 {
  5870  		m = uint32(*(*Posf)(unsafe.Pointer(libc.PreDecUintptr(&p, 2))))
  5871  		*(*Posf)(unsafe.Pointer(p)) = func() uint16 {
  5872  			if m >= wsize {
  5873  				return uint16(m - wsize)
  5874  			}
  5875  			return uint16(NIL)
  5876  		}()
  5877  	}
  5878  	n = wsize
  5879  	p = (*Deflate_state)(unsafe.Pointer(s)).Fprev + uintptr(n)*2
  5880  	for __ccgo1 := true; __ccgo1; __ccgo1 = libc.PreDecUint32(&n, 1) != 0 {
  5881  		m = uint32(*(*Posf)(unsafe.Pointer(libc.PreDecUintptr(&p, 2))))
  5882  		*(*Posf)(unsafe.Pointer(p)) = func() uint16 {
  5883  			if m >= wsize {
  5884  				return uint16(m - wsize)
  5885  			}
  5886  			return uint16(NIL)
  5887  		}()
  5888  		// If n is not on any hash chain, prev[n] is garbage but
  5889  		// its value will never be used.
  5890  	}
  5891  }
  5892  
  5893  // =========================================================================
  5894  func XdeflateInit_(tls *libc.TLS, strm Z_streamp, level int32, version uintptr, stream_size int32) int32 { /* deflate.c:228:13: */
  5895  	return XdeflateInit2_(tls, strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,
  5896  		Z_DEFAULT_STRATEGY, version, stream_size)
  5897  	// To do: ignore strm->next_in if we use it as window
  5898  }
  5899  
  5900  // =========================================================================
  5901  func XdeflateInit2_(tls *libc.TLS, strm Z_streamp, level int32, method int32, windowBits int32, memLevel int32, strategy int32, version uintptr, stream_size int32) int32 { /* deflate.c:240:13: */
  5902  	var s uintptr
  5903  	var wrap int32 = 1
  5904  	var overlay uintptr
  5905  	// We overlay pending_buf and d_buf+l_buf. This works since the average
  5906  	// output size for (length,distance) codes is <= 24 bits.
  5907  
  5908  	if version == uintptr(Z_NULL) || int32(*(*uint8)(unsafe.Pointer(version))) != int32(my_version[0]) || uint64(stream_size) != uint64(unsafe.Sizeof(Z_stream{})) {
  5909  		return -6
  5910  	}
  5911  	if strm == uintptr(Z_NULL) {
  5912  		return -2
  5913  	}
  5914  
  5915  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = uintptr(Z_NULL)
  5916  	if (*Z_stream)(unsafe.Pointer(strm)).Fzalloc == uintptr(0) {
  5917  		(*Z_stream)(unsafe.Pointer(strm)).Fzalloc = *(*uintptr)(unsafe.Pointer(&struct {
  5918  			f func(*libc.TLS, Voidpf, uint32, uint32) Voidpf
  5919  		}{Xzcalloc}))
  5920  		(*Z_stream)(unsafe.Pointer(strm)).Fopaque = uintptr(0)
  5921  	}
  5922  	if (*Z_stream)(unsafe.Pointer(strm)).Fzfree == uintptr(0) {
  5923  		(*Z_stream)(unsafe.Pointer(strm)).Fzfree = *(*uintptr)(unsafe.Pointer(&struct {
  5924  			f func(*libc.TLS, Voidpf, Voidpf)
  5925  		}{Xzcfree}))
  5926  	}
  5927  
  5928  	if level == -1 {
  5929  		level = 6
  5930  	}
  5931  
  5932  	if windowBits < 0 { // suppress zlib wrapper
  5933  		wrap = 0
  5934  		windowBits = -windowBits
  5935  	} else if windowBits > 15 {
  5936  		wrap = 2 // write gzip wrapper instead
  5937  		windowBits = windowBits - 16
  5938  	}
  5939  	if memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED || windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED || windowBits == 8 && wrap != 1 {
  5940  		return -2
  5941  	}
  5942  	if windowBits == 8 {
  5943  		windowBits = 9
  5944  	} // until 256-byte window bug fixed
  5945  	s = (*struct {
  5946  		f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf
  5947  	})(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer(strm)).Fzalloc})).f(tls, (*Z_stream)(unsafe.Pointer(strm)).Fopaque, uint32(1), uint32(unsafe.Sizeof(Deflate_state{})))
  5948  	if s == uintptr(Z_NULL) {
  5949  		return -4
  5950  	}
  5951  	(*Z_stream)(unsafe.Pointer(strm)).Fstate = s
  5952  	(*Deflate_state)(unsafe.Pointer(s)).Fstrm = strm
  5953  	(*Deflate_state)(unsafe.Pointer(s)).Fstatus = INIT_STATE // to pass state test in deflateReset()
  5954  
  5955  	(*Deflate_state)(unsafe.Pointer(s)).Fwrap = wrap
  5956  	(*Deflate_state)(unsafe.Pointer(s)).Fgzhead = Gz_headerp(Z_NULL)
  5957  	(*Deflate_state)(unsafe.Pointer(s)).Fw_bits = UInt(windowBits)
  5958  	(*Deflate_state)(unsafe.Pointer(s)).Fw_size = UInt(int32(1) << (*Deflate_state)(unsafe.Pointer(s)).Fw_bits)
  5959  	(*Deflate_state)(unsafe.Pointer(s)).Fw_mask = (*Deflate_state)(unsafe.Pointer(s)).Fw_size - UInt(1)
  5960  
  5961  	(*Deflate_state)(unsafe.Pointer(s)).Fhash_bits = UInt(memLevel) + UInt(7)
  5962  	(*Deflate_state)(unsafe.Pointer(s)).Fhash_size = UInt(int32(1) << (*Deflate_state)(unsafe.Pointer(s)).Fhash_bits)
  5963  	(*Deflate_state)(unsafe.Pointer(s)).Fhash_mask = (*Deflate_state)(unsafe.Pointer(s)).Fhash_size - UInt(1)
  5964  	(*Deflate_state)(unsafe.Pointer(s)).Fhash_shift = ((*Deflate_state)(unsafe.Pointer(s)).Fhash_bits + UInt(MIN_MATCH) - UInt(1)) / UInt(MIN_MATCH)
  5965  
  5966  	(*Deflate_state)(unsafe.Pointer(s)).Fwindow = (*struct {
  5967  		f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf
  5968  	})(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer(strm)).Fzalloc})).f(tls, (*Z_stream)(unsafe.Pointer(strm)).Fopaque, (*Deflate_state)(unsafe.Pointer(s)).Fw_size, uint32(uint64(2)*uint64(unsafe.Sizeof(Byte(0)))))
  5969  	(*Deflate_state)(unsafe.Pointer(s)).Fprev = (*struct {
  5970  		f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf
  5971  	})(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer(strm)).Fzalloc})).f(tls, (*Z_stream)(unsafe.Pointer(strm)).Fopaque, (*Deflate_state)(unsafe.Pointer(s)).Fw_size, uint32(unsafe.Sizeof(Pos(0))))
  5972  	(*Deflate_state)(unsafe.Pointer(s)).Fhead = (*struct {
  5973  		f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf
  5974  	})(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer(strm)).Fzalloc})).f(tls, (*Z_stream)(unsafe.Pointer(strm)).Fopaque, (*Deflate_state)(unsafe.Pointer(s)).Fhash_size, uint32(unsafe.Sizeof(Pos(0))))
  5975  
  5976  	(*Deflate_state)(unsafe.Pointer(s)).Fhigh_water = uint64(0) // nothing written to s->window yet
  5977  
  5978  	(*Deflate_state)(unsafe.Pointer(s)).Flit_bufsize = UInt(int32(1) << (memLevel + 6)) // 16K elements by default
  5979  
  5980  	overlay = (*struct {
  5981  		f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf
  5982  	})(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer(strm)).Fzalloc})).f(tls, (*Z_stream)(unsafe.Pointer(strm)).Fopaque, (*Deflate_state)(unsafe.Pointer(s)).Flit_bufsize, uint32(uint64(unsafe.Sizeof(Ush(0)))+uint64(2)))
  5983  	(*Deflate_state)(unsafe.Pointer(s)).Fpending_buf = overlay
  5984  	(*Deflate_state)(unsafe.Pointer(s)).Fpending_buf_size = Ulg((*Deflate_state)(unsafe.Pointer(s)).Flit_bufsize) * (uint64(unsafe.Sizeof(Ush(0))) + uint64(2))
  5985  
  5986  	if (*Deflate_state)(unsafe.Pointer(s)).Fwindow == uintptr(Z_NULL) || (*Deflate_state)(unsafe.Pointer(s)).Fprev == uintptr(Z_NULL) || (*Deflate_state)(unsafe.Pointer(s)).Fhead == uintptr(Z_NULL) || (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf == uintptr(Z_NULL) {
  5987  		(*Deflate_state)(unsafe.Pointer(s)).Fstatus = FINISH_STATE
  5988  		(*Z_stream)(unsafe.Pointer(strm)).Fmsg = Xz_errmsg[Z_NEED_DICT - -4]
  5989  		XdeflateEnd(tls, strm)
  5990  		return -4
  5991  	}
  5992  	(*Deflate_state)(unsafe.Pointer(s)).Fd_buf = overlay + uintptr(uint64((*Deflate_state)(unsafe.Pointer(s)).Flit_bufsize)/uint64(unsafe.Sizeof(Ush(0))))*2
  5993  	(*Deflate_state)(unsafe.Pointer(s)).Fl_buf = (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr((uint64(1)+uint64(unsafe.Sizeof(Ush(0))))*uint64((*Deflate_state)(unsafe.Pointer(s)).Flit_bufsize))
  5994  
  5995  	(*Deflate_state)(unsafe.Pointer(s)).Flevel = level
  5996  	(*Deflate_state)(unsafe.Pointer(s)).Fstrategy = strategy
  5997  	(*Deflate_state)(unsafe.Pointer(s)).Fmethod = Byte(method)
  5998  
  5999  	return XdeflateReset(tls, strm)
  6000  }
  6001  
  6002  var my_version = *(*[7]uint8)(unsafe.Pointer(ts)) /* deflate.c:253:23 */
  6003  
  6004  // =========================================================================
  6005  // Check for a valid deflate stream state. Return 0 if ok, 1 if not.
  6006  func deflateStateCheck(tls *libc.TLS, strm Z_streamp) int32 { /* deflate.c:353:11: */
  6007  	var s uintptr
  6008  	if strm == uintptr(Z_NULL) || (*Z_stream)(unsafe.Pointer(strm)).Fzalloc == uintptr(0) || (*Z_stream)(unsafe.Pointer(strm)).Fzfree == uintptr(0) {
  6009  		return 1
  6010  	}
  6011  	s = (*Z_stream)(unsafe.Pointer(strm)).Fstate
  6012  	if s == uintptr(Z_NULL) || (*Deflate_state)(unsafe.Pointer(s)).Fstrm != strm || (*Deflate_state)(unsafe.Pointer(s)).Fstatus != INIT_STATE && (*Deflate_state)(unsafe.Pointer(s)).Fstatus != GZIP_STATE && (*Deflate_state)(unsafe.Pointer(s)).Fstatus != EXTRA_STATE && (*Deflate_state)(unsafe.Pointer(s)).Fstatus != NAME_STATE && (*Deflate_state)(unsafe.Pointer(s)).Fstatus != COMMENT_STATE && (*Deflate_state)(unsafe.Pointer(s)).Fstatus != HCRC_STATE && (*Deflate_state)(unsafe.Pointer(s)).Fstatus != BUSY_STATE && (*Deflate_state)(unsafe.Pointer(s)).Fstatus != FINISH_STATE {
  6013  		return 1
  6014  	}
  6015  	return 0
  6016  }
  6017  
  6018  // =========================================================================
  6019  func XdeflateSetDictionary(tls *libc.TLS, strm Z_streamp, dictionary uintptr, dictLength UInt) int32 { /* deflate.c:376:13: */
  6020  	var s uintptr
  6021  	var str UInt
  6022  	var n UInt
  6023  	var wrap int32
  6024  	var avail uint32
  6025  	var next uintptr
  6026  
  6027  	if deflateStateCheck(tls, strm) != 0 || dictionary == uintptr(Z_NULL) {
  6028  		return -2
  6029  	}
  6030  	s = (*Z_stream)(unsafe.Pointer(strm)).Fstate
  6031  	wrap = (*Deflate_state)(unsafe.Pointer(s)).Fwrap
  6032  	if wrap == 2 || wrap == 1 && (*Deflate_state)(unsafe.Pointer(s)).Fstatus != INIT_STATE || (*Deflate_state)(unsafe.Pointer(s)).Flookahead != 0 {
  6033  		return -2
  6034  	}
  6035  
  6036  	// when using zlib wrappers, compute Adler-32 for provided dictionary
  6037  	if wrap == 1 {
  6038  		(*Z_stream)(unsafe.Pointer(strm)).Fadler = Xadler32(tls, (*Z_stream)(unsafe.Pointer(strm)).Fadler, dictionary, dictLength)
  6039  	}
  6040  	(*Deflate_state)(unsafe.Pointer(s)).Fwrap = 0 // avoid computing Adler-32 in read_buf
  6041  
  6042  	// if dictionary would fill window, just replace the history
  6043  	if dictLength >= (*Deflate_state)(unsafe.Pointer(s)).Fw_size {
  6044  		if wrap == 0 { // already empty otherwise
  6045  			*(*Posf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fhead + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fhash_size-UInt(1))*2)) = Posf(NIL)
  6046  			libc.Xmemset(tls, (*Deflate_state)(unsafe.Pointer(s)).Fhead, 0, uint64((*Deflate_state)(unsafe.Pointer(s)).Fhash_size-UInt(1))*uint64(unsafe.Sizeof(Posf(0))))
  6047  
  6048  			(*Deflate_state)(unsafe.Pointer(s)).Fstrstart = UInt(0)
  6049  			(*Deflate_state)(unsafe.Pointer(s)).Fblock_start = 0
  6050  			(*Deflate_state)(unsafe.Pointer(s)).Finsert = UInt(0)
  6051  		}
  6052  		dictionary += uintptr(dictLength - (*Deflate_state)(unsafe.Pointer(s)).Fw_size) // use the tail
  6053  		dictLength = (*Deflate_state)(unsafe.Pointer(s)).Fw_size
  6054  	}
  6055  
  6056  	// insert dictionary into window and hash
  6057  	avail = (*Z_stream)(unsafe.Pointer(strm)).Favail_in
  6058  	next = (*Z_stream)(unsafe.Pointer(strm)).Fnext_in
  6059  	(*Z_stream)(unsafe.Pointer(strm)).Favail_in = dictLength
  6060  	(*Z_stream)(unsafe.Pointer(strm)).Fnext_in = dictionary
  6061  	fill_window(tls, s)
  6062  	for (*Deflate_state)(unsafe.Pointer(s)).Flookahead >= UInt(MIN_MATCH) {
  6063  		str = (*Deflate_state)(unsafe.Pointer(s)).Fstrstart
  6064  		n = (*Deflate_state)(unsafe.Pointer(s)).Flookahead - UInt(MIN_MATCH-1)
  6065  		for __ccgo := true; __ccgo; __ccgo = libc.PreDecUint32(&n, 1) != 0 {
  6066  			(*Deflate_state)(unsafe.Pointer(s)).Fins_h = ((*Deflate_state)(unsafe.Pointer(s)).Fins_h<<(*Deflate_state)(unsafe.Pointer(s)).Fhash_shift ^ UInt(*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(str+UInt(MIN_MATCH)-UInt(1)))))) & (*Deflate_state)(unsafe.Pointer(s)).Fhash_mask
  6067  			*(*Posf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fprev + uintptr(str&(*Deflate_state)(unsafe.Pointer(s)).Fw_mask)*2)) = *(*Posf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fhead + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fins_h)*2))
  6068  			*(*Posf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fhead + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fins_h)*2)) = Pos(str)
  6069  			str++
  6070  		}
  6071  		(*Deflate_state)(unsafe.Pointer(s)).Fstrstart = str
  6072  		(*Deflate_state)(unsafe.Pointer(s)).Flookahead = UInt(MIN_MATCH - 1)
  6073  		fill_window(tls, s)
  6074  	}
  6075  	*(*UInt)(unsafe.Pointer(s + 172)) += (*Deflate_state)(unsafe.Pointer(s)).Flookahead
  6076  	(*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)
  6077  	(*Deflate_state)(unsafe.Pointer(s)).Finsert = (*Deflate_state)(unsafe.Pointer(s)).Flookahead
  6078  	(*Deflate_state)(unsafe.Pointer(s)).Flookahead = UInt(0)
  6079  	(*Deflate_state)(unsafe.Pointer(s)).Fmatch_length = libc.AssignPtrUint32(s+184, UInt(MIN_MATCH-1))
  6080  	(*Deflate_state)(unsafe.Pointer(s)).Fmatch_available = 0
  6081  	(*Z_stream)(unsafe.Pointer(strm)).Fnext_in = next
  6082  	(*Z_stream)(unsafe.Pointer(strm)).Favail_in = avail
  6083  	(*Deflate_state)(unsafe.Pointer(s)).Fwrap = wrap
  6084  	return Z_OK
  6085  }
  6086  
  6087  // =========================================================================
  6088  func XdeflateGetDictionary(tls *libc.TLS, strm Z_streamp, dictionary uintptr, dictLength uintptr) int32 { /* deflate.c:445:13: */
  6089  	var s uintptr
  6090  	var len UInt
  6091  
  6092  	if deflateStateCheck(tls, strm) != 0 {
  6093  		return -2
  6094  	}
  6095  	s = (*Z_stream)(unsafe.Pointer(strm)).Fstate
  6096  	len = (*Deflate_state)(unsafe.Pointer(s)).Fstrstart + (*Deflate_state)(unsafe.Pointer(s)).Flookahead
  6097  	if len > (*Deflate_state)(unsafe.Pointer(s)).Fw_size {
  6098  		len = (*Deflate_state)(unsafe.Pointer(s)).Fw_size
  6099  	}
  6100  	if dictionary != uintptr(Z_NULL) && len != 0 {
  6101  		libc.Xmemcpy(tls, dictionary, (*Deflate_state)(unsafe.Pointer(s)).Fwindow+uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)+uintptr((*Deflate_state)(unsafe.Pointer(s)).Flookahead)-uintptr(len), uint64(len))
  6102  	}
  6103  	if dictLength != uintptr(Z_NULL) {
  6104  		*(*UInt)(unsafe.Pointer(dictLength)) = len
  6105  	}
  6106  	return Z_OK
  6107  }
  6108  
  6109  // =========================================================================
  6110  func XdeflateResetKeep(tls *libc.TLS, strm Z_streamp) int32 { /* deflate.c:467:13: */
  6111  	var s uintptr
  6112  
  6113  	if deflateStateCheck(tls, strm) != 0 {
  6114  		return -2
  6115  	}
  6116  
  6117  	(*Z_stream)(unsafe.Pointer(strm)).Ftotal_in = libc.AssignPtrUint64(strm+40, uint64(0))
  6118  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = uintptr(Z_NULL) // use zfree if we ever allocate msg dynamically
  6119  	(*Z_stream)(unsafe.Pointer(strm)).Fdata_type = Z_UNKNOWN
  6120  
  6121  	s = (*Z_stream)(unsafe.Pointer(strm)).Fstate
  6122  	(*Deflate_state)(unsafe.Pointer(s)).Fpending = uint64(0)
  6123  	(*Deflate_state)(unsafe.Pointer(s)).Fpending_out = (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf
  6124  
  6125  	if (*Deflate_state)(unsafe.Pointer(s)).Fwrap < 0 {
  6126  		(*Deflate_state)(unsafe.Pointer(s)).Fwrap = -(*Deflate_state)(unsafe.Pointer(s)).Fwrap // was made negative by deflate(..., Z_FINISH);
  6127  	}
  6128  	(*Deflate_state)(unsafe.Pointer(s)).Fstatus = func() int32 {
  6129  		if (*Deflate_state)(unsafe.Pointer(s)).Fwrap == 2 {
  6130  			return GZIP_STATE
  6131  		}
  6132  		return func() int32 {
  6133  			if (*Deflate_state)(unsafe.Pointer(s)).Fwrap != 0 {
  6134  				return INIT_STATE
  6135  			}
  6136  			return BUSY_STATE
  6137  		}()
  6138  	}()
  6139  	(*Z_stream)(unsafe.Pointer(strm)).Fadler = func() uint64 {
  6140  		if (*Deflate_state)(unsafe.Pointer(s)).Fwrap == 2 {
  6141  			return Xcrc32(tls, uint64(0), uintptr(Z_NULL), uint32(0))
  6142  		}
  6143  		return Xadler32(tls, uint64(0), uintptr(Z_NULL), uint32(0))
  6144  	}()
  6145  	(*Deflate_state)(unsafe.Pointer(s)).Flast_flush = Z_NO_FLUSH
  6146  
  6147  	X_tr_init(tls, s)
  6148  
  6149  	return Z_OK
  6150  }
  6151  
  6152  // =========================================================================
  6153  func XdeflateReset(tls *libc.TLS, strm Z_streamp) int32 { /* deflate.c:505:13: */
  6154  	var ret int32
  6155  
  6156  	ret = XdeflateResetKeep(tls, strm)
  6157  	if ret == Z_OK {
  6158  		lm_init(tls, (*Z_stream)(unsafe.Pointer(strm)).Fstate)
  6159  	}
  6160  	return ret
  6161  }
  6162  
  6163  // =========================================================================
  6164  func XdeflateSetHeader(tls *libc.TLS, strm Z_streamp, head Gz_headerp) int32 { /* deflate.c:517:13: */
  6165  	if deflateStateCheck(tls, strm) != 0 || (*Internal_state)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fstate)).Fwrap != 2 {
  6166  		return -2
  6167  	}
  6168  	(*Internal_state)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fstate)).Fgzhead = head
  6169  	return Z_OK
  6170  }
  6171  
  6172  // =========================================================================
  6173  func XdeflatePending(tls *libc.TLS, strm Z_streamp, pending uintptr, bits uintptr) int32 { /* deflate.c:528:13: */
  6174  	if deflateStateCheck(tls, strm) != 0 {
  6175  		return -2
  6176  	}
  6177  	if pending != uintptr(Z_NULL) {
  6178  		*(*uint32)(unsafe.Pointer(pending)) = uint32((*Internal_state)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fstate)).Fpending)
  6179  	}
  6180  	if bits != uintptr(Z_NULL) {
  6181  		*(*int32)(unsafe.Pointer(bits)) = (*Internal_state)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fstate)).Fbi_valid
  6182  	}
  6183  	return Z_OK
  6184  }
  6185  
  6186  // =========================================================================
  6187  func XdeflatePrime(tls *libc.TLS, strm Z_streamp, bits int32, value int32) int32 { /* deflate.c:542:13: */
  6188  	var s uintptr
  6189  	var put int32
  6190  
  6191  	if deflateStateCheck(tls, strm) != 0 {
  6192  		return -2
  6193  	}
  6194  	s = (*Z_stream)(unsafe.Pointer(strm)).Fstate
  6195  	if (*Deflate_state)(unsafe.Pointer(s)).Fd_buf < (*Deflate_state)(unsafe.Pointer(s)).Fpending_out+uintptr(int32(Buf_size+7)>>3) {
  6196  		return -5
  6197  	}
  6198  	for __ccgo := true; __ccgo; __ccgo = bits != 0 {
  6199  		put = Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid
  6200  		if put > bits {
  6201  			put = bits
  6202  		}
  6203  		*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(value & (int32(1)<<put - 1) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)))
  6204  		*(*int32)(unsafe.Pointer(s + 5940)) += put
  6205  		X_tr_flush_bits(tls, s)
  6206  		value >>= put
  6207  		bits = bits - put
  6208  	}
  6209  	return Z_OK
  6210  }
  6211  
  6212  // =========================================================================
  6213  func XdeflateParams(tls *libc.TLS, strm Z_streamp, level int32, strategy int32) int32 { /* deflate.c:568:13: */
  6214  	var s uintptr
  6215  	var func1 Compress_func
  6216  
  6217  	if deflateStateCheck(tls, strm) != 0 {
  6218  		return -2
  6219  	}
  6220  	s = (*Z_stream)(unsafe.Pointer(strm)).Fstate
  6221  
  6222  	if level == -1 {
  6223  		level = 6
  6224  	}
  6225  	if level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED {
  6226  		return -2
  6227  	}
  6228  	func1 = configuration_table[(*Deflate_state)(unsafe.Pointer(s)).Flevel].Ffunc
  6229  
  6230  	if (strategy != (*Deflate_state)(unsafe.Pointer(s)).Fstrategy || func1 != configuration_table[level].Ffunc) && (*Deflate_state)(unsafe.Pointer(s)).Fhigh_water != 0 {
  6231  		// Flush the last buffer:
  6232  		var err int32 = Xdeflate(tls, strm, Z_BLOCK)
  6233  		if err == -2 {
  6234  			return err
  6235  		}
  6236  		if (*Z_stream)(unsafe.Pointer(strm)).Favail_out == UInt(0) {
  6237  			return -5
  6238  		}
  6239  	}
  6240  	if (*Deflate_state)(unsafe.Pointer(s)).Flevel != level {
  6241  		if (*Deflate_state)(unsafe.Pointer(s)).Flevel == 0 && (*Deflate_state)(unsafe.Pointer(s)).Fmatches != UInt(0) {
  6242  			if (*Deflate_state)(unsafe.Pointer(s)).Fmatches == UInt(1) {
  6243  				slide_hash(tls, s)
  6244  			} else {
  6245  				*(*Posf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fhead + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fhash_size-UInt(1))*2)) = Posf(NIL)
  6246  			}
  6247  			libc.Xmemset(tls, (*Deflate_state)(unsafe.Pointer(s)).Fhead, 0, uint64((*Deflate_state)(unsafe.Pointer(s)).Fhash_size-UInt(1))*uint64(unsafe.Sizeof(Posf(0))))
  6248  
  6249  			(*Deflate_state)(unsafe.Pointer(s)).Fmatches = UInt(0)
  6250  		}
  6251  		(*Deflate_state)(unsafe.Pointer(s)).Flevel = level
  6252  		(*Deflate_state)(unsafe.Pointer(s)).Fmax_lazy_match = UInt(configuration_table[level].Fmax_lazy)
  6253  		(*Deflate_state)(unsafe.Pointer(s)).Fgood_match = UInt(configuration_table[level].Fgood_length)
  6254  		(*Deflate_state)(unsafe.Pointer(s)).Fnice_match = int32(configuration_table[level].Fnice_length)
  6255  		(*Deflate_state)(unsafe.Pointer(s)).Fmax_chain_length = UInt(configuration_table[level].Fmax_chain)
  6256  	}
  6257  	(*Deflate_state)(unsafe.Pointer(s)).Fstrategy = strategy
  6258  	return Z_OK
  6259  }
  6260  
  6261  // =========================================================================
  6262  func XdeflateTune(tls *libc.TLS, strm Z_streamp, good_length int32, max_lazy int32, nice_length int32, max_chain int32) int32 { /* deflate.c:617:13: */
  6263  	var s uintptr
  6264  
  6265  	if deflateStateCheck(tls, strm) != 0 {
  6266  		return -2
  6267  	}
  6268  	s = (*Z_stream)(unsafe.Pointer(strm)).Fstate
  6269  	(*Deflate_state)(unsafe.Pointer(s)).Fgood_match = UInt(good_length)
  6270  	(*Deflate_state)(unsafe.Pointer(s)).Fmax_lazy_match = UInt(max_lazy)
  6271  	(*Deflate_state)(unsafe.Pointer(s)).Fnice_match = nice_length
  6272  	(*Deflate_state)(unsafe.Pointer(s)).Fmax_chain_length = UInt(max_chain)
  6273  	return Z_OK
  6274  }
  6275  
  6276  // =========================================================================
  6277  // For the default windowBits of 15 and memLevel of 8, this function returns
  6278  // a close to exact, as well as small, upper bound on the compressed size.
  6279  // They are coded as constants here for a reason--if the #define's are
  6280  // changed, then this function needs to be changed as well.  The return
  6281  // value for 15 and 8 only works for those exact settings.
  6282  //
  6283  // For any setting other than those defaults for windowBits and memLevel,
  6284  // the value returned is a conservative worst case for the maximum expansion
  6285  // resulting from using fixed blocks instead of stored blocks, which deflate
  6286  // can emit on compressed data for some combinations of the parameters.
  6287  //
  6288  // This function could be more sophisticated to provide closer upper bounds for
  6289  // every combination of windowBits and memLevel.  But even the conservative
  6290  // upper bound of about 14% expansion does not seem onerous for output buffer
  6291  // allocation.
  6292  func XdeflateBound(tls *libc.TLS, strm Z_streamp, sourceLen ULong) ULong { /* deflate.c:652:15: */
  6293  	var s uintptr
  6294  	var complen ULong
  6295  	var wraplen ULong
  6296  
  6297  	// conservative upper bound for compressed data
  6298  	complen = sourceLen + (sourceLen+uint64(7))>>3 + (sourceLen+uint64(63))>>6 + uint64(5)
  6299  
  6300  	// if can't get parameters, return conservative bound plus zlib wrapper
  6301  	if deflateStateCheck(tls, strm) != 0 {
  6302  		return complen + uint64(6)
  6303  	}
  6304  
  6305  	// compute wrapper length
  6306  	s = (*Z_stream)(unsafe.Pointer(strm)).Fstate
  6307  	switch (*Deflate_state)(unsafe.Pointer(s)).Fwrap {
  6308  	case 0: // raw deflate
  6309  		wraplen = uint64(0)
  6310  		break
  6311  	case 1: // zlib wrapper
  6312  		wraplen = ULong(6 + func() int32 {
  6313  			if (*Deflate_state)(unsafe.Pointer(s)).Fstrstart != 0 {
  6314  				return 4
  6315  			}
  6316  			return 0
  6317  		}())
  6318  		break
  6319  	case 2: // gzip wrapper
  6320  		wraplen = uint64(18)
  6321  		if (*Deflate_state)(unsafe.Pointer(s)).Fgzhead != uintptr(Z_NULL) { // user-supplied gzip header
  6322  			var str uintptr
  6323  			if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fextra != uintptr(Z_NULL) {
  6324  				wraplen = wraplen + ULong(UInt(2)+(*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fextra_len)
  6325  			}
  6326  			str = (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fname
  6327  			if str != uintptr(Z_NULL) {
  6328  				for __ccgo := true; __ccgo; __ccgo = *(*Bytef)(unsafe.Pointer(libc.PostIncUintptr(&str, 1))) != 0 {
  6329  					wraplen++
  6330  				}
  6331  			}
  6332  			str = (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fcomment
  6333  			if str != uintptr(Z_NULL) {
  6334  				for __ccgo1 := true; __ccgo1; __ccgo1 = *(*Bytef)(unsafe.Pointer(libc.PostIncUintptr(&str, 1))) != 0 {
  6335  					wraplen++
  6336  				}
  6337  			}
  6338  			if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fhcrc != 0 {
  6339  				wraplen = wraplen + uint64(2)
  6340  			}
  6341  		}
  6342  		break
  6343  	default: // for compiler happiness
  6344  		wraplen = uint64(6)
  6345  	}
  6346  
  6347  	// if not default parameters, return conservative bound
  6348  	if (*Deflate_state)(unsafe.Pointer(s)).Fw_bits != UInt(15) || (*Deflate_state)(unsafe.Pointer(s)).Fhash_bits != UInt(8+7) {
  6349  		return complen + wraplen
  6350  	}
  6351  
  6352  	// default settings: return tight bound for that case
  6353  	return sourceLen + sourceLen>>12 + sourceLen>>14 + sourceLen>>25 + uint64(13) - uint64(6) + wraplen
  6354  }
  6355  
  6356  // =========================================================================
  6357  // Put a short in the pending buffer. The 16-bit value is put in MSB order.
  6358  // IN assertion: the stream state is correct and there is enough room in
  6359  // pending_buf.
  6360  func putShortMSB(tls *libc.TLS, s uintptr, b UInt) { /* deflate.c:716:12: */
  6361  	{
  6362  		*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Byte(b >> 8)
  6363  	}
  6364  
  6365  	{
  6366  		*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Byte(b & UInt(0xff))
  6367  	}
  6368  
  6369  }
  6370  
  6371  // =========================================================================
  6372  // Flush as much pending output as possible. All deflate() output, except for
  6373  // some deflate_stored() output, goes through this function so some
  6374  // applications may wish to modify it to avoid allocating a large
  6375  // strm->next_out buffer and copying into it. (See also read_buf()).
  6376  func flush_pending(tls *libc.TLS, strm Z_streamp) { /* deflate.c:730:12: */
  6377  	var len uint32
  6378  	var s uintptr = (*Z_stream)(unsafe.Pointer(strm)).Fstate
  6379  
  6380  	X_tr_flush_bits(tls, s)
  6381  	len = uint32((*Deflate_state)(unsafe.Pointer(s)).Fpending)
  6382  	if len > (*Z_stream)(unsafe.Pointer(strm)).Favail_out {
  6383  		len = (*Z_stream)(unsafe.Pointer(strm)).Favail_out
  6384  	}
  6385  	if len == uint32(0) {
  6386  		return
  6387  	}
  6388  
  6389  	libc.Xmemcpy(tls, (*Z_stream)(unsafe.Pointer(strm)).Fnext_out, (*Deflate_state)(unsafe.Pointer(s)).Fpending_out, uint64(len))
  6390  	*(*uintptr)(unsafe.Pointer(strm + 24)) += uintptr(len)
  6391  	*(*uintptr)(unsafe.Pointer(s + 32)) += uintptr(len)
  6392  	*(*ULong)(unsafe.Pointer(strm + 40)) += ULong(len)
  6393  	*(*UInt)(unsafe.Pointer(strm + 32)) -= len
  6394  	*(*Ulg)(unsafe.Pointer(s + 40)) -= Ulg(len)
  6395  	if (*Deflate_state)(unsafe.Pointer(s)).Fpending == uint64(0) {
  6396  		(*Deflate_state)(unsafe.Pointer(s)).Fpending_out = (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf
  6397  	}
  6398  }
  6399  
  6400  // ===========================================================================
  6401  // Update the header CRC with the bytes s->pending_buf[beg..s->pending - 1].
  6402  
  6403  // =========================================================================
  6404  func Xdeflate(tls *libc.TLS, strm Z_streamp, flush int32) int32 { /* deflate.c:763:13: */
  6405  	var old_flush int32 // value of flush param for previous deflate call
  6406  	var s uintptr
  6407  
  6408  	if deflateStateCheck(tls, strm) != 0 || flush > Z_BLOCK || flush < 0 {
  6409  		return -2
  6410  	}
  6411  	s = (*Z_stream)(unsafe.Pointer(strm)).Fstate
  6412  
  6413  	if (*Z_stream)(unsafe.Pointer(strm)).Fnext_out == uintptr(Z_NULL) || (*Z_stream)(unsafe.Pointer(strm)).Favail_in != UInt(0) && (*Z_stream)(unsafe.Pointer(strm)).Fnext_in == uintptr(Z_NULL) || (*Deflate_state)(unsafe.Pointer(s)).Fstatus == FINISH_STATE && flush != Z_FINISH {
  6414  		return func() int32 { (*Z_stream)(unsafe.Pointer(strm)).Fmsg = Xz_errmsg[Z_NEED_DICT - -2]; return -2 }()
  6415  	}
  6416  	if (*Z_stream)(unsafe.Pointer(strm)).Favail_out == UInt(0) {
  6417  		return func() int32 { (*Z_stream)(unsafe.Pointer(strm)).Fmsg = Xz_errmsg[Z_NEED_DICT - -5]; return -5 }()
  6418  	}
  6419  
  6420  	old_flush = (*Deflate_state)(unsafe.Pointer(s)).Flast_flush
  6421  	(*Deflate_state)(unsafe.Pointer(s)).Flast_flush = flush
  6422  
  6423  	// Flush as much pending output as possible
  6424  	if (*Deflate_state)(unsafe.Pointer(s)).Fpending != uint64(0) {
  6425  		flush_pending(tls, strm)
  6426  		if (*Z_stream)(unsafe.Pointer(strm)).Favail_out == UInt(0) {
  6427  			// Since avail_out is 0, deflate will be called again with
  6428  			// more output space, but possibly with both pending and
  6429  			// avail_in equal to zero. There won't be anything to do,
  6430  			// but this is not an error situation so make sure we
  6431  			// return OK instead of BUF_ERROR at next call of deflate:
  6432  			(*Deflate_state)(unsafe.Pointer(s)).Flast_flush = -1
  6433  			return Z_OK
  6434  		}
  6435  
  6436  		// Make sure there is something to do and avoid duplicate consecutive
  6437  		// flushes. For repeated and useless calls with Z_FINISH, we keep
  6438  		// returning Z_STREAM_END instead of Z_BUF_ERROR.
  6439  	} else if (*Z_stream)(unsafe.Pointer(strm)).Favail_in == UInt(0) && flush*2-func() int32 {
  6440  		if flush > 4 {
  6441  			return 9
  6442  		}
  6443  		return 0
  6444  	}() <= old_flush*2-func() int32 {
  6445  		if old_flush > 4 {
  6446  			return 9
  6447  		}
  6448  		return 0
  6449  	}() && flush != Z_FINISH {
  6450  		return func() int32 { (*Z_stream)(unsafe.Pointer(strm)).Fmsg = Xz_errmsg[Z_NEED_DICT - -5]; return -5 }()
  6451  	}
  6452  
  6453  	// User must not provide more input after the first FINISH:
  6454  	if (*Deflate_state)(unsafe.Pointer(s)).Fstatus == FINISH_STATE && (*Z_stream)(unsafe.Pointer(strm)).Favail_in != UInt(0) {
  6455  		return func() int32 { (*Z_stream)(unsafe.Pointer(strm)).Fmsg = Xz_errmsg[Z_NEED_DICT - -5]; return -5 }()
  6456  	}
  6457  
  6458  	// Write the header
  6459  	if (*Deflate_state)(unsafe.Pointer(s)).Fstatus == INIT_STATE {
  6460  		// zlib header
  6461  		var header UInt = (UInt(Z_DEFLATED) + ((*Deflate_state)(unsafe.Pointer(s)).Fw_bits-UInt(8))<<4) << 8
  6462  		var level_flags UInt
  6463  
  6464  		if (*Deflate_state)(unsafe.Pointer(s)).Fstrategy >= Z_HUFFMAN_ONLY || (*Deflate_state)(unsafe.Pointer(s)).Flevel < 2 {
  6465  			level_flags = UInt(0)
  6466  		} else if (*Deflate_state)(unsafe.Pointer(s)).Flevel < 6 {
  6467  			level_flags = UInt(1)
  6468  		} else if (*Deflate_state)(unsafe.Pointer(s)).Flevel == 6 {
  6469  			level_flags = UInt(2)
  6470  		} else {
  6471  			level_flags = UInt(3)
  6472  		}
  6473  		header = header | level_flags<<6
  6474  		if (*Deflate_state)(unsafe.Pointer(s)).Fstrstart != UInt(0) {
  6475  			header = header | UInt(PRESET_DICT)
  6476  		}
  6477  		header = header + (UInt(31) - header%UInt(31))
  6478  
  6479  		putShortMSB(tls, s, header)
  6480  
  6481  		// Save the adler32 of the preset dictionary:
  6482  		if (*Deflate_state)(unsafe.Pointer(s)).Fstrstart != UInt(0) {
  6483  			putShortMSB(tls, s, UInt((*Z_stream)(unsafe.Pointer(strm)).Fadler>>16))
  6484  			putShortMSB(tls, s, UInt((*Z_stream)(unsafe.Pointer(strm)).Fadler&uint64(0xffff)))
  6485  		}
  6486  		(*Z_stream)(unsafe.Pointer(strm)).Fadler = Xadler32(tls, uint64(0), uintptr(Z_NULL), uint32(0))
  6487  		(*Deflate_state)(unsafe.Pointer(s)).Fstatus = BUSY_STATE
  6488  
  6489  		// Compression must start with an empty pending buffer
  6490  		flush_pending(tls, strm)
  6491  		if (*Deflate_state)(unsafe.Pointer(s)).Fpending != uint64(0) {
  6492  			(*Deflate_state)(unsafe.Pointer(s)).Flast_flush = -1
  6493  			return Z_OK
  6494  		}
  6495  	}
  6496  	if (*Deflate_state)(unsafe.Pointer(s)).Fstatus == GZIP_STATE {
  6497  		// gzip header
  6498  		(*Z_stream)(unsafe.Pointer(strm)).Fadler = Xcrc32(tls, uint64(0), uintptr(Z_NULL), uint32(0))
  6499  		{
  6500  			*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Bytef(31)
  6501  		}
  6502  
  6503  		{
  6504  			*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Bytef(139)
  6505  		}
  6506  
  6507  		{
  6508  			*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Bytef(8)
  6509  		}
  6510  
  6511  		if (*Deflate_state)(unsafe.Pointer(s)).Fgzhead == uintptr(Z_NULL) {
  6512  			{
  6513  				*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Bytef(0)
  6514  			}
  6515  
  6516  			{
  6517  				*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Bytef(0)
  6518  			}
  6519  
  6520  			{
  6521  				*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Bytef(0)
  6522  			}
  6523  
  6524  			{
  6525  				*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Bytef(0)
  6526  			}
  6527  
  6528  			{
  6529  				*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Bytef(0)
  6530  			}
  6531  
  6532  			{
  6533  				*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = func() uint8 {
  6534  					if (*Deflate_state)(unsafe.Pointer(s)).Flevel == 9 {
  6535  						return uint8(2)
  6536  					}
  6537  					return func() uint8 {
  6538  						if (*Deflate_state)(unsafe.Pointer(s)).Fstrategy >= Z_HUFFMAN_ONLY || (*Deflate_state)(unsafe.Pointer(s)).Flevel < 2 {
  6539  							return uint8(4)
  6540  						}
  6541  						return uint8(0)
  6542  					}()
  6543  				}()
  6544  			}
  6545  
  6546  			{
  6547  				*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Bytef(OS_CODE)
  6548  			}
  6549  
  6550  			(*Deflate_state)(unsafe.Pointer(s)).Fstatus = BUSY_STATE
  6551  
  6552  			// Compression must start with an empty pending buffer
  6553  			flush_pending(tls, strm)
  6554  			if (*Deflate_state)(unsafe.Pointer(s)).Fpending != uint64(0) {
  6555  				(*Deflate_state)(unsafe.Pointer(s)).Flast_flush = -1
  6556  				return Z_OK
  6557  			}
  6558  		} else {
  6559  			{
  6560  				*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Bytef(func() int32 {
  6561  					if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Ftext != 0 {
  6562  						return 1
  6563  					}
  6564  					return 0
  6565  				}() + func() int32 {
  6566  					if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fhcrc != 0 {
  6567  						return 2
  6568  					}
  6569  					return 0
  6570  				}() + func() int32 {
  6571  					if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fextra == uintptr(Z_NULL) {
  6572  						return 0
  6573  					}
  6574  					return 4
  6575  				}() + func() int32 {
  6576  					if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fname == uintptr(Z_NULL) {
  6577  						return 0
  6578  					}
  6579  					return 8
  6580  				}() + func() int32 {
  6581  					if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fcomment == uintptr(Z_NULL) {
  6582  						return 0
  6583  					}
  6584  					return 16
  6585  				}())
  6586  			}
  6587  
  6588  			{
  6589  				*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Byte((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Ftime & uint64(0xff))
  6590  			}
  6591  
  6592  			{
  6593  				*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Byte((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Ftime >> 8 & uint64(0xff))
  6594  			}
  6595  
  6596  			{
  6597  				*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Byte((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Ftime >> 16 & uint64(0xff))
  6598  			}
  6599  
  6600  			{
  6601  				*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Byte((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Ftime >> 24 & uint64(0xff))
  6602  			}
  6603  
  6604  			{
  6605  				*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = func() uint8 {
  6606  					if (*Deflate_state)(unsafe.Pointer(s)).Flevel == 9 {
  6607  						return uint8(2)
  6608  					}
  6609  					return func() uint8 {
  6610  						if (*Deflate_state)(unsafe.Pointer(s)).Fstrategy >= Z_HUFFMAN_ONLY || (*Deflate_state)(unsafe.Pointer(s)).Flevel < 2 {
  6611  							return uint8(4)
  6612  						}
  6613  						return uint8(0)
  6614  					}()
  6615  				}()
  6616  			}
  6617  
  6618  			{
  6619  				*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Bytef((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fos & 0xff)
  6620  			}
  6621  
  6622  			if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fextra != uintptr(Z_NULL) {
  6623  				{
  6624  					*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Bytef((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fextra_len & UInt(0xff))
  6625  				}
  6626  
  6627  				{
  6628  					*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Bytef((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fextra_len >> 8 & UInt(0xff))
  6629  				}
  6630  
  6631  			}
  6632  			if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fhcrc != 0 {
  6633  				(*Z_stream)(unsafe.Pointer(strm)).Fadler = Xcrc32(tls, (*Z_stream)(unsafe.Pointer(strm)).Fadler, (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf,
  6634  					uint32((*Deflate_state)(unsafe.Pointer(s)).Fpending))
  6635  			}
  6636  			(*Deflate_state)(unsafe.Pointer(s)).Fgzindex = uint64(0)
  6637  			(*Deflate_state)(unsafe.Pointer(s)).Fstatus = EXTRA_STATE
  6638  		}
  6639  	}
  6640  	if (*Deflate_state)(unsafe.Pointer(s)).Fstatus == EXTRA_STATE {
  6641  		if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fextra != uintptr(Z_NULL) {
  6642  			var beg Ulg = (*Deflate_state)(unsafe.Pointer(s)).Fpending // start of bytes to update crc
  6643  			var left UInt = UInt(Ulg((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fextra_len&UInt(0xffff)) - (*Deflate_state)(unsafe.Pointer(s)).Fgzindex)
  6644  			for (*Deflate_state)(unsafe.Pointer(s)).Fpending+Ulg(left) > (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf_size {
  6645  				var copy UInt = UInt((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fpending)
  6646  				libc.Xmemcpy(tls, (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf+uintptr((*Deflate_state)(unsafe.Pointer(s)).Fpending),
  6647  					(*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fextra+uintptr((*Deflate_state)(unsafe.Pointer(s)).Fgzindex), uint64(copy))
  6648  				(*Deflate_state)(unsafe.Pointer(s)).Fpending = (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf_size
  6649  				for __ccgo := true; __ccgo; __ccgo = 0 != 0 {
  6650  					if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fhcrc != 0 && (*Deflate_state)(unsafe.Pointer(s)).Fpending > beg {
  6651  						(*Z_stream)(unsafe.Pointer(strm)).Fadler = Xcrc32(tls, (*Z_stream)(unsafe.Pointer(strm)).Fadler, (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf+uintptr(beg), uint32((*Deflate_state)(unsafe.Pointer(s)).Fpending-beg))
  6652  					}
  6653  				}
  6654  				*(*Ulg)(unsafe.Pointer(s + 64)) += Ulg(copy)
  6655  				flush_pending(tls, strm)
  6656  				if (*Deflate_state)(unsafe.Pointer(s)).Fpending != uint64(0) {
  6657  					(*Deflate_state)(unsafe.Pointer(s)).Flast_flush = -1
  6658  					return Z_OK
  6659  				}
  6660  				beg = uint64(0)
  6661  				left = left - copy
  6662  			}
  6663  			libc.Xmemcpy(tls, (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf+uintptr((*Deflate_state)(unsafe.Pointer(s)).Fpending),
  6664  				(*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fextra+uintptr((*Deflate_state)(unsafe.Pointer(s)).Fgzindex), uint64(left))
  6665  			*(*Ulg)(unsafe.Pointer(s + 40)) += Ulg(left)
  6666  			for __ccgo1 := true; __ccgo1; __ccgo1 = 0 != 0 {
  6667  				if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fhcrc != 0 && (*Deflate_state)(unsafe.Pointer(s)).Fpending > beg {
  6668  					(*Z_stream)(unsafe.Pointer(strm)).Fadler = Xcrc32(tls, (*Z_stream)(unsafe.Pointer(strm)).Fadler, (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf+uintptr(beg), uint32((*Deflate_state)(unsafe.Pointer(s)).Fpending-beg))
  6669  				}
  6670  			}
  6671  			(*Deflate_state)(unsafe.Pointer(s)).Fgzindex = uint64(0)
  6672  		}
  6673  		(*Deflate_state)(unsafe.Pointer(s)).Fstatus = NAME_STATE
  6674  	}
  6675  	if (*Deflate_state)(unsafe.Pointer(s)).Fstatus == NAME_STATE {
  6676  		if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fname != uintptr(Z_NULL) {
  6677  			var beg Ulg = (*Deflate_state)(unsafe.Pointer(s)).Fpending // start of bytes to update crc
  6678  			var val int32
  6679  			for __ccgo2 := true; __ccgo2; __ccgo2 = val != 0 {
  6680  				if (*Deflate_state)(unsafe.Pointer(s)).Fpending == (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf_size {
  6681  					for __ccgo3 := true; __ccgo3; __ccgo3 = 0 != 0 {
  6682  						if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fhcrc != 0 && (*Deflate_state)(unsafe.Pointer(s)).Fpending > beg {
  6683  							(*Z_stream)(unsafe.Pointer(strm)).Fadler = Xcrc32(tls, (*Z_stream)(unsafe.Pointer(strm)).Fadler, (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf+uintptr(beg), uint32((*Deflate_state)(unsafe.Pointer(s)).Fpending-beg))
  6684  						}
  6685  					}
  6686  					flush_pending(tls, strm)
  6687  					if (*Deflate_state)(unsafe.Pointer(s)).Fpending != uint64(0) {
  6688  						(*Deflate_state)(unsafe.Pointer(s)).Flast_flush = -1
  6689  						return Z_OK
  6690  					}
  6691  					beg = uint64(0)
  6692  				}
  6693  				val = int32(*(*Bytef)(unsafe.Pointer((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fname + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fgzindex, 1)))))
  6694  				{
  6695  					*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Bytef(val)
  6696  				}
  6697  
  6698  			}
  6699  			for __ccgo4 := true; __ccgo4; __ccgo4 = 0 != 0 {
  6700  				if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fhcrc != 0 && (*Deflate_state)(unsafe.Pointer(s)).Fpending > beg {
  6701  					(*Z_stream)(unsafe.Pointer(strm)).Fadler = Xcrc32(tls, (*Z_stream)(unsafe.Pointer(strm)).Fadler, (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf+uintptr(beg), uint32((*Deflate_state)(unsafe.Pointer(s)).Fpending-beg))
  6702  				}
  6703  			}
  6704  			(*Deflate_state)(unsafe.Pointer(s)).Fgzindex = uint64(0)
  6705  		}
  6706  		(*Deflate_state)(unsafe.Pointer(s)).Fstatus = COMMENT_STATE
  6707  	}
  6708  	if (*Deflate_state)(unsafe.Pointer(s)).Fstatus == COMMENT_STATE {
  6709  		if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fcomment != uintptr(Z_NULL) {
  6710  			var beg Ulg = (*Deflate_state)(unsafe.Pointer(s)).Fpending // start of bytes to update crc
  6711  			var val int32
  6712  			for __ccgo5 := true; __ccgo5; __ccgo5 = val != 0 {
  6713  				if (*Deflate_state)(unsafe.Pointer(s)).Fpending == (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf_size {
  6714  					for __ccgo6 := true; __ccgo6; __ccgo6 = 0 != 0 {
  6715  						if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fhcrc != 0 && (*Deflate_state)(unsafe.Pointer(s)).Fpending > beg {
  6716  							(*Z_stream)(unsafe.Pointer(strm)).Fadler = Xcrc32(tls, (*Z_stream)(unsafe.Pointer(strm)).Fadler, (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf+uintptr(beg), uint32((*Deflate_state)(unsafe.Pointer(s)).Fpending-beg))
  6717  						}
  6718  					}
  6719  					flush_pending(tls, strm)
  6720  					if (*Deflate_state)(unsafe.Pointer(s)).Fpending != uint64(0) {
  6721  						(*Deflate_state)(unsafe.Pointer(s)).Flast_flush = -1
  6722  						return Z_OK
  6723  					}
  6724  					beg = uint64(0)
  6725  				}
  6726  				val = int32(*(*Bytef)(unsafe.Pointer((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fcomment + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fgzindex, 1)))))
  6727  				{
  6728  					*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Bytef(val)
  6729  				}
  6730  
  6731  			}
  6732  			for __ccgo7 := true; __ccgo7; __ccgo7 = 0 != 0 {
  6733  				if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fhcrc != 0 && (*Deflate_state)(unsafe.Pointer(s)).Fpending > beg {
  6734  					(*Z_stream)(unsafe.Pointer(strm)).Fadler = Xcrc32(tls, (*Z_stream)(unsafe.Pointer(strm)).Fadler, (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf+uintptr(beg), uint32((*Deflate_state)(unsafe.Pointer(s)).Fpending-beg))
  6735  				}
  6736  			}
  6737  		}
  6738  		(*Deflate_state)(unsafe.Pointer(s)).Fstatus = HCRC_STATE
  6739  	}
  6740  	if (*Deflate_state)(unsafe.Pointer(s)).Fstatus == HCRC_STATE {
  6741  		if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fhcrc != 0 {
  6742  			if (*Deflate_state)(unsafe.Pointer(s)).Fpending+uint64(2) > (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf_size {
  6743  				flush_pending(tls, strm)
  6744  				if (*Deflate_state)(unsafe.Pointer(s)).Fpending != uint64(0) {
  6745  					(*Deflate_state)(unsafe.Pointer(s)).Flast_flush = -1
  6746  					return Z_OK
  6747  				}
  6748  			}
  6749  			{
  6750  				*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Byte((*Z_stream)(unsafe.Pointer(strm)).Fadler & uint64(0xff))
  6751  			}
  6752  
  6753  			{
  6754  				*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Byte((*Z_stream)(unsafe.Pointer(strm)).Fadler >> 8 & uint64(0xff))
  6755  			}
  6756  
  6757  			(*Z_stream)(unsafe.Pointer(strm)).Fadler = Xcrc32(tls, uint64(0), uintptr(Z_NULL), uint32(0))
  6758  		}
  6759  		(*Deflate_state)(unsafe.Pointer(s)).Fstatus = BUSY_STATE
  6760  
  6761  		// Compression must start with an empty pending buffer
  6762  		flush_pending(tls, strm)
  6763  		if (*Deflate_state)(unsafe.Pointer(s)).Fpending != uint64(0) {
  6764  			(*Deflate_state)(unsafe.Pointer(s)).Flast_flush = -1
  6765  			return Z_OK
  6766  		}
  6767  	}
  6768  
  6769  	// Start a new block or continue the current one.
  6770  	if (*Z_stream)(unsafe.Pointer(strm)).Favail_in != UInt(0) || (*Deflate_state)(unsafe.Pointer(s)).Flookahead != UInt(0) || flush != Z_NO_FLUSH && (*Deflate_state)(unsafe.Pointer(s)).Fstatus != FINISH_STATE {
  6771  		var bstate Block_state
  6772  
  6773  		if (*Deflate_state)(unsafe.Pointer(s)).Flevel == 0 {
  6774  			bstate = deflate_stored(tls, s, flush)
  6775  		} else {
  6776  			if (*Deflate_state)(unsafe.Pointer(s)).Fstrategy == Z_HUFFMAN_ONLY {
  6777  				bstate = deflate_huff(tls, s, flush)
  6778  			} else {
  6779  				if (*Deflate_state)(unsafe.Pointer(s)).Fstrategy == Z_RLE {
  6780  					bstate = deflate_rle(tls, s, flush)
  6781  				} else {
  6782  					bstate = (*struct {
  6783  						f func(*libc.TLS, uintptr, int32) Block_state
  6784  					})(unsafe.Pointer(&struct{ uintptr }{configuration_table[(*Deflate_state)(unsafe.Pointer(s)).Flevel].Ffunc})).f(tls, s, flush)
  6785  				}
  6786  			}
  6787  		}
  6788  
  6789  		if bstate == Finish_started || bstate == Finish_done {
  6790  			(*Deflate_state)(unsafe.Pointer(s)).Fstatus = FINISH_STATE
  6791  		}
  6792  		if bstate == Need_more || bstate == Finish_started {
  6793  			if (*Z_stream)(unsafe.Pointer(strm)).Favail_out == UInt(0) {
  6794  				(*Deflate_state)(unsafe.Pointer(s)).Flast_flush = -1 // avoid BUF_ERROR next call, see above
  6795  			}
  6796  			return Z_OK
  6797  			// If flush != Z_NO_FLUSH && avail_out == 0, the next call
  6798  			// of deflate should use the same flush parameter to make sure
  6799  			// that the flush is complete. So we don't have to output an
  6800  			// empty block here, this will be done at next call. This also
  6801  			// ensures that for a very small output buffer, we emit at most
  6802  			// one empty block.
  6803  		}
  6804  		if bstate == Block_done {
  6805  			if flush == Z_PARTIAL_FLUSH {
  6806  				X_tr_align(tls, s)
  6807  			} else if flush != Z_BLOCK { // FULL_FLUSH or SYNC_FLUSH
  6808  				X_tr_stored_block(tls, s, uintptr(0), uint64(0), 0)
  6809  				// For a full flush, this empty block will be recognized
  6810  				// as a special marker by inflate_sync().
  6811  				if flush == Z_FULL_FLUSH {
  6812  					*(*Posf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fhead + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fhash_size-UInt(1))*2)) = Posf(NIL)
  6813  					libc.Xmemset(tls, (*Deflate_state)(unsafe.Pointer(s)).Fhead, 0, uint64((*Deflate_state)(unsafe.Pointer(s)).Fhash_size-UInt(1))*uint64(unsafe.Sizeof(Posf(0))))
  6814  					// forget history
  6815  					if (*Deflate_state)(unsafe.Pointer(s)).Flookahead == UInt(0) {
  6816  						(*Deflate_state)(unsafe.Pointer(s)).Fstrstart = UInt(0)
  6817  						(*Deflate_state)(unsafe.Pointer(s)).Fblock_start = 0
  6818  						(*Deflate_state)(unsafe.Pointer(s)).Finsert = UInt(0)
  6819  					}
  6820  				}
  6821  			}
  6822  			flush_pending(tls, strm)
  6823  			if (*Z_stream)(unsafe.Pointer(strm)).Favail_out == UInt(0) {
  6824  				(*Deflate_state)(unsafe.Pointer(s)).Flast_flush = -1 // avoid BUF_ERROR at next call, see above
  6825  				return Z_OK
  6826  			}
  6827  		}
  6828  	}
  6829  
  6830  	if flush != Z_FINISH {
  6831  		return Z_OK
  6832  	}
  6833  	if (*Deflate_state)(unsafe.Pointer(s)).Fwrap <= 0 {
  6834  		return Z_STREAM_END
  6835  	}
  6836  
  6837  	// Write the trailer
  6838  	if (*Deflate_state)(unsafe.Pointer(s)).Fwrap == 2 {
  6839  		{
  6840  			*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Byte((*Z_stream)(unsafe.Pointer(strm)).Fadler & uint64(0xff))
  6841  		}
  6842  
  6843  		{
  6844  			*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Byte((*Z_stream)(unsafe.Pointer(strm)).Fadler >> 8 & uint64(0xff))
  6845  		}
  6846  
  6847  		{
  6848  			*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Byte((*Z_stream)(unsafe.Pointer(strm)).Fadler >> 16 & uint64(0xff))
  6849  		}
  6850  
  6851  		{
  6852  			*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Byte((*Z_stream)(unsafe.Pointer(strm)).Fadler >> 24 & uint64(0xff))
  6853  		}
  6854  
  6855  		{
  6856  			*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Byte((*Z_stream)(unsafe.Pointer(strm)).Ftotal_in & uint64(0xff))
  6857  		}
  6858  
  6859  		{
  6860  			*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Byte((*Z_stream)(unsafe.Pointer(strm)).Ftotal_in >> 8 & uint64(0xff))
  6861  		}
  6862  
  6863  		{
  6864  			*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Byte((*Z_stream)(unsafe.Pointer(strm)).Ftotal_in >> 16 & uint64(0xff))
  6865  		}
  6866  
  6867  		{
  6868  			*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Byte((*Z_stream)(unsafe.Pointer(strm)).Ftotal_in >> 24 & uint64(0xff))
  6869  		}
  6870  
  6871  	} else {
  6872  		putShortMSB(tls, s, UInt((*Z_stream)(unsafe.Pointer(strm)).Fadler>>16))
  6873  		putShortMSB(tls, s, UInt((*Z_stream)(unsafe.Pointer(strm)).Fadler&uint64(0xffff)))
  6874  	}
  6875  	flush_pending(tls, strm)
  6876  	// If avail_out is zero, the application will call deflate again
  6877  	// to flush the rest.
  6878  	if (*Deflate_state)(unsafe.Pointer(s)).Fwrap > 0 {
  6879  		(*Deflate_state)(unsafe.Pointer(s)).Fwrap = -(*Deflate_state)(unsafe.Pointer(s)).Fwrap
  6880  	} // write the trailer only once!
  6881  	if (*Deflate_state)(unsafe.Pointer(s)).Fpending != uint64(0) {
  6882  		return Z_OK
  6883  	}
  6884  	return Z_STREAM_END
  6885  }
  6886  
  6887  // =========================================================================
  6888  func XdeflateEnd(tls *libc.TLS, strm Z_streamp) int32 { /* deflate.c:1076:13: */
  6889  	var status int32
  6890  
  6891  	if deflateStateCheck(tls, strm) != 0 {
  6892  		return -2
  6893  	}
  6894  
  6895  	status = (*Internal_state)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fstate)).Fstatus
  6896  
  6897  	/* Deallocate in reverse order of allocations: */
  6898  	{
  6899  		if (*Internal_state)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fstate)).Fpending_buf != 0 {
  6900  			(*struct {
  6901  				f func(*libc.TLS, Voidpf, Voidpf)
  6902  			})(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer(strm)).Fzfree})).f(tls, (*Z_stream)(unsafe.Pointer(strm)).Fopaque, (*Internal_state)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fstate)).Fpending_buf)
  6903  		}
  6904  	}
  6905  
  6906  	{
  6907  		if (*Internal_state)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fstate)).Fhead != 0 {
  6908  			(*struct {
  6909  				f func(*libc.TLS, Voidpf, Voidpf)
  6910  			})(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer(strm)).Fzfree})).f(tls, (*Z_stream)(unsafe.Pointer(strm)).Fopaque, (*Internal_state)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fstate)).Fhead)
  6911  		}
  6912  	}
  6913  
  6914  	{
  6915  		if (*Internal_state)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fstate)).Fprev != 0 {
  6916  			(*struct {
  6917  				f func(*libc.TLS, Voidpf, Voidpf)
  6918  			})(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer(strm)).Fzfree})).f(tls, (*Z_stream)(unsafe.Pointer(strm)).Fopaque, (*Internal_state)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fstate)).Fprev)
  6919  		}
  6920  	}
  6921  
  6922  	{
  6923  		if (*Internal_state)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fstate)).Fwindow != 0 {
  6924  			(*struct {
  6925  				f func(*libc.TLS, Voidpf, Voidpf)
  6926  			})(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer(strm)).Fzfree})).f(tls, (*Z_stream)(unsafe.Pointer(strm)).Fopaque, (*Internal_state)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fstate)).Fwindow)
  6927  		}
  6928  	}
  6929  
  6930  	(*struct {
  6931  		f func(*libc.TLS, Voidpf, Voidpf)
  6932  	})(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer(strm)).Fzfree})).f(tls, (*Z_stream)(unsafe.Pointer(strm)).Fopaque, (*Z_stream)(unsafe.Pointer(strm)).Fstate)
  6933  	(*Z_stream)(unsafe.Pointer(strm)).Fstate = uintptr(Z_NULL)
  6934  
  6935  	if status == BUSY_STATE {
  6936  		return -3
  6937  	}
  6938  	return Z_OK
  6939  }
  6940  
  6941  // =========================================================================
  6942  // Copy the source state to the destination state.
  6943  // To simplify the source, this is not supported for 16-bit MSDOS (which
  6944  // doesn't have enough memory anyway to duplicate compression states).
  6945  func XdeflateCopy(tls *libc.TLS, dest Z_streamp, source Z_streamp) int32 { /* deflate.c:1102:13: */
  6946  	var ds uintptr
  6947  	var ss uintptr
  6948  	var overlay uintptr
  6949  
  6950  	if deflateStateCheck(tls, source) != 0 || dest == uintptr(Z_NULL) {
  6951  		return -2
  6952  	}
  6953  
  6954  	ss = (*Z_stream)(unsafe.Pointer(source)).Fstate
  6955  
  6956  	libc.Xmemcpy(tls, dest, source, uint64(unsafe.Sizeof(Z_stream{})))
  6957  
  6958  	ds = (*struct {
  6959  		f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf
  6960  	})(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer(dest)).Fzalloc})).f(tls, (*Z_stream)(unsafe.Pointer(dest)).Fopaque, uint32(1), uint32(unsafe.Sizeof(Deflate_state{})))
  6961  	if ds == uintptr(Z_NULL) {
  6962  		return -4
  6963  	}
  6964  	(*Z_stream)(unsafe.Pointer(dest)).Fstate = ds
  6965  	libc.Xmemcpy(tls, ds, ss, uint64(unsafe.Sizeof(Deflate_state{})))
  6966  	(*Deflate_state)(unsafe.Pointer(ds)).Fstrm = dest
  6967  
  6968  	(*Deflate_state)(unsafe.Pointer(ds)).Fwindow = (*struct {
  6969  		f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf
  6970  	})(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer(dest)).Fzalloc})).f(tls, (*Z_stream)(unsafe.Pointer(dest)).Fopaque, (*Deflate_state)(unsafe.Pointer(ds)).Fw_size, uint32(uint64(2)*uint64(unsafe.Sizeof(Byte(0)))))
  6971  	(*Deflate_state)(unsafe.Pointer(ds)).Fprev = (*struct {
  6972  		f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf
  6973  	})(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer(dest)).Fzalloc})).f(tls, (*Z_stream)(unsafe.Pointer(dest)).Fopaque, (*Deflate_state)(unsafe.Pointer(ds)).Fw_size, uint32(unsafe.Sizeof(Pos(0))))
  6974  	(*Deflate_state)(unsafe.Pointer(ds)).Fhead = (*struct {
  6975  		f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf
  6976  	})(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer(dest)).Fzalloc})).f(tls, (*Z_stream)(unsafe.Pointer(dest)).Fopaque, (*Deflate_state)(unsafe.Pointer(ds)).Fhash_size, uint32(unsafe.Sizeof(Pos(0))))
  6977  	overlay = (*struct {
  6978  		f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf
  6979  	})(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer(dest)).Fzalloc})).f(tls, (*Z_stream)(unsafe.Pointer(dest)).Fopaque, (*Deflate_state)(unsafe.Pointer(ds)).Flit_bufsize, uint32(uint64(unsafe.Sizeof(Ush(0)))+uint64(2)))
  6980  	(*Deflate_state)(unsafe.Pointer(ds)).Fpending_buf = overlay
  6981  
  6982  	if (*Deflate_state)(unsafe.Pointer(ds)).Fwindow == uintptr(Z_NULL) || (*Deflate_state)(unsafe.Pointer(ds)).Fprev == uintptr(Z_NULL) || (*Deflate_state)(unsafe.Pointer(ds)).Fhead == uintptr(Z_NULL) || (*Deflate_state)(unsafe.Pointer(ds)).Fpending_buf == uintptr(Z_NULL) {
  6983  		XdeflateEnd(tls, dest)
  6984  		return -4
  6985  	}
  6986  	// following zmemcpy do not work for 16-bit MSDOS
  6987  	libc.Xmemcpy(tls, (*Deflate_state)(unsafe.Pointer(ds)).Fwindow, (*Deflate_state)(unsafe.Pointer(ss)).Fwindow, uint64((*Deflate_state)(unsafe.Pointer(ds)).Fw_size*UInt(2))*uint64(unsafe.Sizeof(Byte(0))))
  6988  	libc.Xmemcpy(tls, (*Deflate_state)(unsafe.Pointer(ds)).Fprev, (*Deflate_state)(unsafe.Pointer(ss)).Fprev, uint64((*Deflate_state)(unsafe.Pointer(ds)).Fw_size)*uint64(unsafe.Sizeof(Pos(0))))
  6989  	libc.Xmemcpy(tls, (*Deflate_state)(unsafe.Pointer(ds)).Fhead, (*Deflate_state)(unsafe.Pointer(ss)).Fhead, uint64((*Deflate_state)(unsafe.Pointer(ds)).Fhash_size)*uint64(unsafe.Sizeof(Pos(0))))
  6990  	libc.Xmemcpy(tls, (*Deflate_state)(unsafe.Pointer(ds)).Fpending_buf, (*Deflate_state)(unsafe.Pointer(ss)).Fpending_buf, uint64(UInt((*Deflate_state)(unsafe.Pointer(ds)).Fpending_buf_size)))
  6991  
  6992  	(*Deflate_state)(unsafe.Pointer(ds)).Fpending_out = (*Deflate_state)(unsafe.Pointer(ds)).Fpending_buf + uintptr((int64((*Deflate_state)(unsafe.Pointer(ss)).Fpending_out)-int64((*Deflate_state)(unsafe.Pointer(ss)).Fpending_buf))/1)
  6993  	(*Deflate_state)(unsafe.Pointer(ds)).Fd_buf = overlay + uintptr(uint64((*Deflate_state)(unsafe.Pointer(ds)).Flit_bufsize)/uint64(unsafe.Sizeof(Ush(0))))*2
  6994  	(*Deflate_state)(unsafe.Pointer(ds)).Fl_buf = (*Deflate_state)(unsafe.Pointer(ds)).Fpending_buf + uintptr((uint64(1)+uint64(unsafe.Sizeof(Ush(0))))*uint64((*Deflate_state)(unsafe.Pointer(ds)).Flit_bufsize))
  6995  
  6996  	(*Deflate_state)(unsafe.Pointer(ds)).Fl_desc.Fdyn_tree = ds + 212   /* &.dyn_ltree */
  6997  	(*Deflate_state)(unsafe.Pointer(ds)).Fd_desc.Fdyn_tree = ds + 2504  /* &.dyn_dtree */
  6998  	(*Deflate_state)(unsafe.Pointer(ds)).Fbl_desc.Fdyn_tree = ds + 2748 /* &.bl_tree */
  6999  
  7000  	return Z_OK
  7001  }
  7002  
  7003  // ===========================================================================
  7004  // Read a new buffer from the current input stream, update the adler32
  7005  // and total number of bytes read.  All deflate() input goes through
  7006  // this function so some applications may wish to modify it to avoid
  7007  // allocating a large strm->next_in buffer and copying from it.
  7008  // (See also flush_pending()).
  7009  func read_buf(tls *libc.TLS, strm Z_streamp, buf uintptr, size uint32) uint32 { /* deflate.c:1164:16: */
  7010  	var len uint32 = (*Z_stream)(unsafe.Pointer(strm)).Favail_in
  7011  
  7012  	if len > size {
  7013  		len = size
  7014  	}
  7015  	if len == uint32(0) {
  7016  		return uint32(0)
  7017  	}
  7018  
  7019  	*(*UInt)(unsafe.Pointer(strm + 8)) -= len
  7020  
  7021  	libc.Xmemcpy(tls, buf, (*Z_stream)(unsafe.Pointer(strm)).Fnext_in, uint64(len))
  7022  	if (*Internal_state)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fstate)).Fwrap == 1 {
  7023  		(*Z_stream)(unsafe.Pointer(strm)).Fadler = Xadler32(tls, (*Z_stream)(unsafe.Pointer(strm)).Fadler, buf, len)
  7024  	} else if (*Internal_state)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fstate)).Fwrap == 2 {
  7025  		(*Z_stream)(unsafe.Pointer(strm)).Fadler = Xcrc32(tls, (*Z_stream)(unsafe.Pointer(strm)).Fadler, buf, len)
  7026  	}
  7027  	*(*uintptr)(unsafe.Pointer(strm)) += uintptr(len)
  7028  	*(*ULong)(unsafe.Pointer(strm + 16)) += ULong(len)
  7029  
  7030  	return len
  7031  }
  7032  
  7033  // ===========================================================================
  7034  // Initialize the "longest match" routines for a new zlib stream
  7035  func lm_init(tls *libc.TLS, s uintptr) { /* deflate.c:1194:12: */
  7036  	(*Deflate_state)(unsafe.Pointer(s)).Fwindow_size = uint64(2) * Ulg((*Deflate_state)(unsafe.Pointer(s)).Fw_size)
  7037  
  7038  	*(*Posf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fhead + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fhash_size-UInt(1))*2)) = Posf(NIL)
  7039  	libc.Xmemset(tls, (*Deflate_state)(unsafe.Pointer(s)).Fhead, 0, uint64((*Deflate_state)(unsafe.Pointer(s)).Fhash_size-UInt(1))*uint64(unsafe.Sizeof(Posf(0))))
  7040  
  7041  	// Set the default configuration parameters:
  7042  	(*Deflate_state)(unsafe.Pointer(s)).Fmax_lazy_match = UInt(configuration_table[(*Deflate_state)(unsafe.Pointer(s)).Flevel].Fmax_lazy)
  7043  	(*Deflate_state)(unsafe.Pointer(s)).Fgood_match = UInt(configuration_table[(*Deflate_state)(unsafe.Pointer(s)).Flevel].Fgood_length)
  7044  	(*Deflate_state)(unsafe.Pointer(s)).Fnice_match = int32(configuration_table[(*Deflate_state)(unsafe.Pointer(s)).Flevel].Fnice_length)
  7045  	(*Deflate_state)(unsafe.Pointer(s)).Fmax_chain_length = UInt(configuration_table[(*Deflate_state)(unsafe.Pointer(s)).Flevel].Fmax_chain)
  7046  
  7047  	(*Deflate_state)(unsafe.Pointer(s)).Fstrstart = UInt(0)
  7048  	(*Deflate_state)(unsafe.Pointer(s)).Fblock_start = 0
  7049  	(*Deflate_state)(unsafe.Pointer(s)).Flookahead = UInt(0)
  7050  	(*Deflate_state)(unsafe.Pointer(s)).Finsert = UInt(0)
  7051  	(*Deflate_state)(unsafe.Pointer(s)).Fmatch_length = libc.AssignPtrUint32(s+184, UInt(MIN_MATCH-1))
  7052  	(*Deflate_state)(unsafe.Pointer(s)).Fmatch_available = 0
  7053  	(*Deflate_state)(unsafe.Pointer(s)).Fins_h = UInt(0)
  7054  }
  7055  
  7056  // ===========================================================================
  7057  // Set match_start to the longest match starting at the given string and
  7058  // return its length. Matches shorter or equal to prev_length are discarded,
  7059  // in which case the result is equal to prev_length and match_start is
  7060  // garbage.
  7061  // IN assertions: cur_match is the head of the hash chain for the current
  7062  //   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
  7063  // OUT assertion: the match length is not greater than s->lookahead.
  7064  // For 80x86 and 680x0, an optimized version will be provided in match.asm or
  7065  // match.S. The code will be functionally equivalent.
  7066  func longest_match(tls *libc.TLS, s uintptr, cur_match IPos) UInt { /* deflate.c:1236:12: */
  7067  	var chain_length uint32 = (*Deflate_state)(unsafe.Pointer(s)).Fmax_chain_length                                         // max hash chain length
  7068  	var scan uintptr = (*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) // current string
  7069  	var match uintptr                                                                                                       // matched string
  7070  	var len int32                                                                                                           // length of current match
  7071  	var best_len int32 = int32((*Deflate_state)(unsafe.Pointer(s)).Fprev_length)                                            // best match length so far
  7072  	var nice_match int32 = (*Deflate_state)(unsafe.Pointer(s)).Fnice_match                                                  // stop if match long enough
  7073  	var limit IPos
  7074  	if (*Deflate_state)(unsafe.Pointer(s)).Fstrstart > (*Deflate_state)(unsafe.Pointer(s)).Fw_size-UInt(MAX_MATCH+MIN_MATCH+1) {
  7075  		limit = (*Deflate_state)(unsafe.Pointer(s)).Fstrstart - ((*Deflate_state)(unsafe.Pointer(s)).Fw_size - UInt(MAX_MATCH+MIN_MATCH+1))
  7076  	} else {
  7077  		limit = uint32(NIL)
  7078  	}
  7079  	// Stop when cur_match becomes <= limit. To simplify the code,
  7080  	// we prevent matches with the string of window index 0.
  7081  	var prev uintptr = (*Deflate_state)(unsafe.Pointer(s)).Fprev
  7082  	var wmask UInt = (*Deflate_state)(unsafe.Pointer(s)).Fw_mask
  7083  
  7084  	var strend uintptr = (*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) + uintptr(MAX_MATCH)
  7085  	var scan_end1 Byte = *(*Bytef)(unsafe.Pointer(scan + uintptr(best_len-1)))
  7086  	var scan_end Byte = *(*Bytef)(unsafe.Pointer(scan + uintptr(best_len)))
  7087  
  7088  	// The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
  7089  	// It is easy to get rid of this optimization if necessary.
  7090  
  7091  	// Do not waste too much time if we already have a good match:
  7092  	if (*Deflate_state)(unsafe.Pointer(s)).Fprev_length >= (*Deflate_state)(unsafe.Pointer(s)).Fgood_match {
  7093  		chain_length >>= 2
  7094  	}
  7095  	// Do not look for matches beyond the end of the input. This is necessary
  7096  	// to make deflate deterministic.
  7097  	if UInt(nice_match) > (*Deflate_state)(unsafe.Pointer(s)).Flookahead {
  7098  		nice_match = int32((*Deflate_state)(unsafe.Pointer(s)).Flookahead)
  7099  	}
  7100  
  7101  	for __ccgo := true; __ccgo; __ccgo = libc.AssignUint32(&cur_match, IPos(*(*Posf)(unsafe.Pointer(prev + uintptr(cur_match&wmask)*2)))) > limit &&
  7102  		libc.PreDecUint32(&chain_length, 1) != uint32(0) {
  7103  
  7104  		match = (*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(cur_match)
  7105  
  7106  		// Skip to next match if the match length cannot increase
  7107  		// or if the match length is less than 2.  Note that the checks below
  7108  		// for insufficient lookahead only occur occasionally for performance
  7109  		// reasons.  Therefore uninitialized memory will be accessed, and
  7110  		// conditional jumps will be made that depend on those values.
  7111  		// However the length of the match is limited to the lookahead, so
  7112  		// the output of deflate is not affected by the uninitialized values.
  7113  
  7114  		if int32(*(*Bytef)(unsafe.Pointer(match + uintptr(best_len)))) != int32(scan_end) || int32(*(*Bytef)(unsafe.Pointer(match + uintptr(best_len-1)))) != int32(scan_end1) || int32(*(*Bytef)(unsafe.Pointer(match))) != int32(*(*Bytef)(unsafe.Pointer(scan))) || int32(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&match, 1)))) != int32(*(*Bytef)(unsafe.Pointer(scan + 1))) {
  7115  			continue
  7116  		}
  7117  
  7118  		// The check at best_len-1 can be removed because it will be made
  7119  		// again later. (This heuristic is not always a win.)
  7120  		// It is not necessary to compare scan[2] and match[2] since they
  7121  		// are always equal when the other bytes match, given that
  7122  		// the hash keys are equal and that HASH_BITS >= 8.
  7123  		scan += uintptr(2)
  7124  		match++
  7125  
  7126  		// We check for insufficient lookahead only every 8th comparison;
  7127  		// the 256th check will be made at strstart+258.
  7128  		for __ccgo1 := true; __ccgo1; __ccgo1 = int32(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&scan, 1)))) == int32(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&match, 1)))) && int32(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&scan, 1)))) == int32(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&match, 1)))) && int32(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&scan, 1)))) == int32(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&match, 1)))) && int32(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&scan, 1)))) == int32(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&match, 1)))) && int32(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&scan, 1)))) == int32(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&match, 1)))) && int32(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&scan, 1)))) == int32(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&match, 1)))) && int32(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&scan, 1)))) == int32(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&match, 1)))) && int32(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&scan, 1)))) == int32(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&match, 1)))) && scan < strend {
  7129  		}
  7130  
  7131  		len = MAX_MATCH - int32((int64(strend)-int64(scan))/1)
  7132  		scan = strend - uintptr(MAX_MATCH)
  7133  
  7134  		if len > best_len {
  7135  			(*Deflate_state)(unsafe.Pointer(s)).Fmatch_start = cur_match
  7136  			best_len = len
  7137  			if len >= nice_match {
  7138  				break
  7139  			}
  7140  			scan_end1 = *(*Bytef)(unsafe.Pointer(scan + uintptr(best_len-1)))
  7141  			scan_end = *(*Bytef)(unsafe.Pointer(scan + uintptr(best_len)))
  7142  		}
  7143  	}
  7144  
  7145  	if UInt(best_len) <= (*Deflate_state)(unsafe.Pointer(s)).Flookahead {
  7146  		return UInt(best_len)
  7147  	}
  7148  	return (*Deflate_state)(unsafe.Pointer(s)).Flookahead
  7149  }
  7150  
  7151  // ===========================================================================
  7152  // Fill the window when the lookahead becomes insufficient.
  7153  // Updates strstart and lookahead.
  7154  //
  7155  // IN assertion: lookahead < MIN_LOOKAHEAD
  7156  // OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
  7157  //    At least one byte has been read, or avail_in == 0; reads are
  7158  //    performed for at least two bytes (required for the zip translate_eol
  7159  //    option -- not supported here).
  7160  func fill_window(tls *libc.TLS, s uintptr) { /* deflate.c:1482:12: */
  7161  	var n uint32
  7162  	var more uint32 // Amount of free space at the end of the window.
  7163  	var wsize UInt = (*Deflate_state)(unsafe.Pointer(s)).Fw_size
  7164  
  7165  	for __ccgo := true; __ccgo; __ccgo = (*Deflate_state)(unsafe.Pointer(s)).Flookahead < UInt(MAX_MATCH+MIN_MATCH+1) && (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_in != UInt(0) {
  7166  		more = uint32((*Deflate_state)(unsafe.Pointer(s)).Fwindow_size - Ulg((*Deflate_state)(unsafe.Pointer(s)).Flookahead) - Ulg((*Deflate_state)(unsafe.Pointer(s)).Fstrstart))
  7167  
  7168  		// Deal with !@#$% 64K limit:
  7169  		if uint64(unsafe.Sizeof(int32(0))) <= uint64(2) {
  7170  			if more == uint32(0) && (*Deflate_state)(unsafe.Pointer(s)).Fstrstart == UInt(0) && (*Deflate_state)(unsafe.Pointer(s)).Flookahead == UInt(0) {
  7171  				more = wsize
  7172  
  7173  			} else if more == libc.Uint32(libc.Uint32FromInt32(-1)) {
  7174  				// Very unlikely, but possible on 16 bit machine if
  7175  				// strstart == 0 && lookahead == 1 (input done a byte at time)
  7176  				more--
  7177  			}
  7178  		}
  7179  
  7180  		// If the window is almost full and there is insufficient lookahead,
  7181  		// move the upper half to the lower one to make room in the upper half.
  7182  		if (*Deflate_state)(unsafe.Pointer(s)).Fstrstart >= wsize+((*Deflate_state)(unsafe.Pointer(s)).Fw_size-UInt(MAX_MATCH+MIN_MATCH+1)) {
  7183  
  7184  			libc.Xmemcpy(tls, (*Deflate_state)(unsafe.Pointer(s)).Fwindow, (*Deflate_state)(unsafe.Pointer(s)).Fwindow+uintptr(wsize), uint64(wsize-more))
  7185  			*(*UInt)(unsafe.Pointer(s + 176)) -= wsize
  7186  			*(*UInt)(unsafe.Pointer(s + 172)) -= wsize // we now have strstart >= MAX_DIST
  7187  			*(*int64)(unsafe.Pointer(s + 152)) -= int64(wsize)
  7188  			slide_hash(tls, s)
  7189  			more = more + wsize
  7190  		}
  7191  		if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_in == UInt(0) {
  7192  			break
  7193  		}
  7194  
  7195  		// If there was no sliding:
  7196  		//    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
  7197  		//    more == window_size - lookahead - strstart
  7198  		// => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
  7199  		// => more >= window_size - 2*WSIZE + 2
  7200  		// In the BIG_MEM or MMAP case (not yet supported),
  7201  		//   window_size == input_size + MIN_LOOKAHEAD  &&
  7202  		//   strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
  7203  		// Otherwise, window_size == 2*WSIZE so more >= 2.
  7204  		// If there was sliding, more >= WSIZE. So in all cases, more >= 2.
  7205  
  7206  		n = read_buf(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm, (*Deflate_state)(unsafe.Pointer(s)).Fwindow+uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)+uintptr((*Deflate_state)(unsafe.Pointer(s)).Flookahead), more)
  7207  		*(*UInt)(unsafe.Pointer(s + 180)) += n
  7208  
  7209  		// Initialize the hash value now that we have some input:
  7210  		if (*Deflate_state)(unsafe.Pointer(s)).Flookahead+(*Deflate_state)(unsafe.Pointer(s)).Finsert >= UInt(MIN_MATCH) {
  7211  			var str UInt = (*Deflate_state)(unsafe.Pointer(s)).Fstrstart - (*Deflate_state)(unsafe.Pointer(s)).Finsert
  7212  			(*Deflate_state)(unsafe.Pointer(s)).Fins_h = UInt(*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(str))))
  7213  			(*Deflate_state)(unsafe.Pointer(s)).Fins_h = ((*Deflate_state)(unsafe.Pointer(s)).Fins_h<<(*Deflate_state)(unsafe.Pointer(s)).Fhash_shift ^ UInt(*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(str+UInt(1)))))) & (*Deflate_state)(unsafe.Pointer(s)).Fhash_mask
  7214  			for (*Deflate_state)(unsafe.Pointer(s)).Finsert != 0 {
  7215  				(*Deflate_state)(unsafe.Pointer(s)).Fins_h = ((*Deflate_state)(unsafe.Pointer(s)).Fins_h<<(*Deflate_state)(unsafe.Pointer(s)).Fhash_shift ^ UInt(*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(str+UInt(MIN_MATCH)-UInt(1)))))) & (*Deflate_state)(unsafe.Pointer(s)).Fhash_mask
  7216  				*(*Posf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fprev + uintptr(str&(*Deflate_state)(unsafe.Pointer(s)).Fw_mask)*2)) = *(*Posf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fhead + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fins_h)*2))
  7217  				*(*Posf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fhead + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fins_h)*2)) = Pos(str)
  7218  				str++
  7219  				(*Deflate_state)(unsafe.Pointer(s)).Finsert--
  7220  				if (*Deflate_state)(unsafe.Pointer(s)).Flookahead+(*Deflate_state)(unsafe.Pointer(s)).Finsert < UInt(MIN_MATCH) {
  7221  					break
  7222  				}
  7223  			}
  7224  		}
  7225  		// If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
  7226  		// but this is not important since only literal bytes will be emitted.
  7227  
  7228  	}
  7229  
  7230  	// If the WIN_INIT bytes after the end of the current data have never been
  7231  	// written, then zero those bytes in order to avoid memory check reports of
  7232  	// the use of uninitialized (or uninitialised as Julian writes) bytes by
  7233  	// the longest match routines.  Update the high water mark for the next
  7234  	// time through here.  WIN_INIT is set to MAX_MATCH since the longest match
  7235  	// routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.
  7236  	if (*Deflate_state)(unsafe.Pointer(s)).Fhigh_water < (*Deflate_state)(unsafe.Pointer(s)).Fwindow_size {
  7237  		var curr Ulg = Ulg((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) + Ulg((*Deflate_state)(unsafe.Pointer(s)).Flookahead)
  7238  		var init1 Ulg
  7239  
  7240  		if (*Deflate_state)(unsafe.Pointer(s)).Fhigh_water < curr {
  7241  			// Previous high water mark below current data -- zero WIN_INIT
  7242  			// bytes or up to end of window, whichever is less.
  7243  			init1 = (*Deflate_state)(unsafe.Pointer(s)).Fwindow_size - curr
  7244  			if init1 > uint64(MAX_MATCH) {
  7245  				init1 = uint64(MAX_MATCH)
  7246  			}
  7247  			libc.Xmemset(tls, (*Deflate_state)(unsafe.Pointer(s)).Fwindow+uintptr(curr), 0, uint64(uint32(init1)))
  7248  			(*Deflate_state)(unsafe.Pointer(s)).Fhigh_water = curr + init1
  7249  		} else if (*Deflate_state)(unsafe.Pointer(s)).Fhigh_water < curr+uint64(MAX_MATCH) {
  7250  			// High water mark at or above current data, but below current data
  7251  			// plus WIN_INIT -- zero out to current data plus WIN_INIT, or up
  7252  			// to end of window, whichever is less.
  7253  			init1 = curr + uint64(MAX_MATCH) - (*Deflate_state)(unsafe.Pointer(s)).Fhigh_water
  7254  			if init1 > (*Deflate_state)(unsafe.Pointer(s)).Fwindow_size-(*Deflate_state)(unsafe.Pointer(s)).Fhigh_water {
  7255  				init1 = (*Deflate_state)(unsafe.Pointer(s)).Fwindow_size - (*Deflate_state)(unsafe.Pointer(s)).Fhigh_water
  7256  			}
  7257  			libc.Xmemset(tls, (*Deflate_state)(unsafe.Pointer(s)).Fwindow+uintptr((*Deflate_state)(unsafe.Pointer(s)).Fhigh_water), 0, uint64(uint32(init1)))
  7258  			*(*Ulg)(unsafe.Pointer(s + 5944)) += init1
  7259  		}
  7260  	}
  7261  
  7262  }
  7263  
  7264  // ===========================================================================
  7265  // Flush the current block, with given end-of-file flag.
  7266  // IN assertion: strstart is set to the end of the current match.
  7267  
  7268  // Same but force premature exit if necessary.
  7269  
  7270  // Maximum stored block length in deflate format (not including header).
  7271  
  7272  // Minimum of a and b.
  7273  
  7274  // ===========================================================================
  7275  // Copy without compression as much as possible from the input stream, return
  7276  // the current block state.
  7277  //
  7278  // In case deflateParams() is used to later switch to a non-zero compression
  7279  // level, s->matches (otherwise unused when storing) keeps track of the number
  7280  // of hash table slides to perform. If s->matches is 1, then one hash table
  7281  // slide will be done when switching. If s->matches is 2, the maximum value
  7282  // allowed here, then the hash table will be cleared, since two or more slides
  7283  // is the same as a clear.
  7284  //
  7285  // deflate_stored() is written to minimize the number of times an input byte is
  7286  // copied. It is most efficient with large input and output buffers, which
  7287  // maximizes the opportunites to have a single copy from next_in to next_out.
  7288  func deflate_stored(tls *libc.TLS, s uintptr, flush int32) Block_state { /* deflate.c:1643:19: */
  7289  	// Smallest worthy block size when not flushing or finishing. By default
  7290  	// this is 32K. This can be as small as 507 bytes for memLevel == 1. For
  7291  	// large input and output buffers, the stored block size will be larger.
  7292  	var min_block uint32 = func() uint32 {
  7293  		if (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf_size-uint64(5) > Ulg((*Deflate_state)(unsafe.Pointer(s)).Fw_size) {
  7294  			return (*Deflate_state)(unsafe.Pointer(s)).Fw_size
  7295  		}
  7296  		return uint32((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf_size - uint64(5))
  7297  	}()
  7298  
  7299  	// Copy as many min_block or larger stored blocks directly to next_out as
  7300  	// possible. If flushing, copy the remaining available input to next_out as
  7301  	// stored blocks, if there is enough space.
  7302  	var len uint32
  7303  	var left uint32
  7304  	var have uint32
  7305  	var last uint32 = uint32(0)
  7306  	var used uint32 = (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_in
  7307  	for __ccgo := true; __ccgo; __ccgo = last == uint32(0) {
  7308  		// Set len to the maximum size block that we can copy directly with the
  7309  		// available input data and output space. Set left to how much of that
  7310  		// would be copied from what's left in the window.
  7311  		len = uint32(MAX_STORED)                                                                      // maximum deflate stored block length
  7312  		have = uint32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_valid + 42) >> 3)                      // number of header bytes
  7313  		if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out < have { // need room for header
  7314  			break
  7315  		}
  7316  		// maximum stored block length that will fit in avail_out:
  7317  		have = (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out - have
  7318  		left = uint32(int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) - (*Deflate_state)(unsafe.Pointer(s)).Fblock_start) // bytes left in window
  7319  		if Ulg(len) > Ulg(left)+Ulg((*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_in) {
  7320  			len = left + (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_in
  7321  		} // limit len to the input
  7322  		if len > have {
  7323  			len = have
  7324  		} // limit len to the output
  7325  
  7326  		// If the stored block would be less than min_block in length, or if
  7327  		// unable to copy all of the available input when flushing, then try
  7328  		// copying to the window and the pending buffer instead. Also don't
  7329  		// write an empty block when flushing -- deflate() does that.
  7330  		if len < min_block && (len == uint32(0) && flush != Z_FINISH || flush == Z_NO_FLUSH || len != left+(*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_in) {
  7331  			break
  7332  		}
  7333  
  7334  		// Make a dummy stored block in pending to get the header bytes,
  7335  		// including any pending bits. This also updates the debugging counts.
  7336  		if flush == Z_FINISH && len == left+(*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_in {
  7337  			last = uint32(1)
  7338  		} else {
  7339  			last = uint32(0)
  7340  		}
  7341  		X_tr_stored_block(tls, s, uintptr(0), uint64(0), int32(last))
  7342  
  7343  		// Replace the lengths in the dummy stored block with len.
  7344  		*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fpending-uint64(4)))) = Bytef(len)
  7345  		*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fpending-uint64(3)))) = Bytef(len >> 8)
  7346  		*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fpending-uint64(2)))) = Bytef(^len)
  7347  		*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fpending-uint64(1)))) = Bytef(^len >> 8)
  7348  
  7349  		// Write the stored block header bytes.
  7350  		flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm)
  7351  
  7352  		// Copy uncompressed bytes from the window to next_out.
  7353  		if left != 0 {
  7354  			if left > len {
  7355  				left = len
  7356  			}
  7357  			libc.Xmemcpy(tls, (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Fnext_out, (*Deflate_state)(unsafe.Pointer(s)).Fwindow+uintptr((*Deflate_state)(unsafe.Pointer(s)).Fblock_start), uint64(left))
  7358  			*(*uintptr)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm + 24)) += uintptr(left)
  7359  			*(*UInt)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm + 32)) -= left
  7360  			*(*ULong)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm + 40)) += ULong(left)
  7361  			*(*int64)(unsafe.Pointer(s + 152)) += int64(left)
  7362  			len = len - left
  7363  		}
  7364  
  7365  		// Copy uncompressed bytes directly from next_in to next_out, updating
  7366  		// the check value.
  7367  		if len != 0 {
  7368  			read_buf(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm, (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Fnext_out, len)
  7369  			*(*uintptr)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm + 24)) += uintptr(len)
  7370  			*(*UInt)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm + 32)) -= len
  7371  			*(*ULong)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm + 40)) += ULong(len)
  7372  		}
  7373  	}
  7374  
  7375  	// Update the sliding window with the last s->w_size bytes of the copied
  7376  	// data, or append all of the copied data to the existing window if less
  7377  	// than s->w_size bytes were copied. Also update the number of bytes to
  7378  	// insert in the hash tables, in the event that deflateParams() switches to
  7379  	// a non-zero compression level.
  7380  	used = used - (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_in // number of input bytes directly copied
  7381  	if used != 0 {
  7382  		// If any input was used, then no unused input remains in the window,
  7383  		// therefore s->block_start == s->strstart.
  7384  		if used >= (*Deflate_state)(unsafe.Pointer(s)).Fw_size { // supplant the previous history
  7385  			(*Deflate_state)(unsafe.Pointer(s)).Fmatches = UInt(2) // clear hash
  7386  			libc.Xmemcpy(tls, (*Deflate_state)(unsafe.Pointer(s)).Fwindow, (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Fnext_in-uintptr((*Deflate_state)(unsafe.Pointer(s)).Fw_size), uint64((*Deflate_state)(unsafe.Pointer(s)).Fw_size))
  7387  			(*Deflate_state)(unsafe.Pointer(s)).Fstrstart = (*Deflate_state)(unsafe.Pointer(s)).Fw_size
  7388  		} else {
  7389  			if (*Deflate_state)(unsafe.Pointer(s)).Fwindow_size-Ulg((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) <= Ulg(used) {
  7390  				// Slide the window down.
  7391  				*(*UInt)(unsafe.Pointer(s + 172)) -= (*Deflate_state)(unsafe.Pointer(s)).Fw_size
  7392  				libc.Xmemcpy(tls, (*Deflate_state)(unsafe.Pointer(s)).Fwindow, (*Deflate_state)(unsafe.Pointer(s)).Fwindow+uintptr((*Deflate_state)(unsafe.Pointer(s)).Fw_size), uint64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart))
  7393  				if (*Deflate_state)(unsafe.Pointer(s)).Fmatches < UInt(2) {
  7394  					(*Deflate_state)(unsafe.Pointer(s)).Fmatches++
  7395  				} // add a pending slide_hash()
  7396  			}
  7397  			libc.Xmemcpy(tls, (*Deflate_state)(unsafe.Pointer(s)).Fwindow+uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart), (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Fnext_in-uintptr(used), uint64(used))
  7398  			*(*UInt)(unsafe.Pointer(s + 172)) += used
  7399  		}
  7400  		(*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)
  7401  		*(*UInt)(unsafe.Pointer(s + 5932)) += func() uint32 {
  7402  			if used > (*Deflate_state)(unsafe.Pointer(s)).Fw_size-(*Deflate_state)(unsafe.Pointer(s)).Finsert {
  7403  				return (*Deflate_state)(unsafe.Pointer(s)).Fw_size - (*Deflate_state)(unsafe.Pointer(s)).Finsert
  7404  			}
  7405  			return used
  7406  		}()
  7407  	}
  7408  	if (*Deflate_state)(unsafe.Pointer(s)).Fhigh_water < Ulg((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) {
  7409  		(*Deflate_state)(unsafe.Pointer(s)).Fhigh_water = Ulg((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)
  7410  	}
  7411  
  7412  	// If the last block was written to next_out, then done.
  7413  	if last != 0 {
  7414  		return Finish_done
  7415  	}
  7416  
  7417  	// If flushing and all input has been consumed, then done.
  7418  	if flush != Z_NO_FLUSH && flush != Z_FINISH && (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_in == UInt(0) && int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) == (*Deflate_state)(unsafe.Pointer(s)).Fblock_start {
  7419  		return Block_done
  7420  	}
  7421  
  7422  	// Fill the window with any remaining input.
  7423  	have = uint32((*Deflate_state)(unsafe.Pointer(s)).Fwindow_size - Ulg((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) - uint64(1))
  7424  	if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_in > have && (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= int64((*Deflate_state)(unsafe.Pointer(s)).Fw_size) {
  7425  		// Slide the window down.
  7426  		*(*int64)(unsafe.Pointer(s + 152)) -= int64((*Deflate_state)(unsafe.Pointer(s)).Fw_size)
  7427  		*(*UInt)(unsafe.Pointer(s + 172)) -= (*Deflate_state)(unsafe.Pointer(s)).Fw_size
  7428  		libc.Xmemcpy(tls, (*Deflate_state)(unsafe.Pointer(s)).Fwindow, (*Deflate_state)(unsafe.Pointer(s)).Fwindow+uintptr((*Deflate_state)(unsafe.Pointer(s)).Fw_size), uint64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart))
  7429  		if (*Deflate_state)(unsafe.Pointer(s)).Fmatches < UInt(2) {
  7430  			(*Deflate_state)(unsafe.Pointer(s)).Fmatches++
  7431  		} // add a pending slide_hash()
  7432  		have = have + (*Deflate_state)(unsafe.Pointer(s)).Fw_size // more space now
  7433  	}
  7434  	if have > (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_in {
  7435  		have = (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_in
  7436  	}
  7437  	if have != 0 {
  7438  		read_buf(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm, (*Deflate_state)(unsafe.Pointer(s)).Fwindow+uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart), have)
  7439  		*(*UInt)(unsafe.Pointer(s + 172)) += have
  7440  	}
  7441  	if (*Deflate_state)(unsafe.Pointer(s)).Fhigh_water < Ulg((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) {
  7442  		(*Deflate_state)(unsafe.Pointer(s)).Fhigh_water = Ulg((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)
  7443  	}
  7444  
  7445  	// There was not enough avail_out to write a complete worthy or flushed
  7446  	// stored block to next_out. Write a stored block to pending instead, if we
  7447  	// have enough input for a worthy block, or if flushing and there is enough
  7448  	// room for the remaining input as a stored block in the pending buffer.
  7449  	have = uint32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_valid + 42) >> 3) // number of header bytes
  7450  	// maximum stored block length that will fit in pending:
  7451  	have = func() uint32 {
  7452  		if (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf_size-Ulg(have) > uint64(MAX_STORED) {
  7453  			return uint32(MAX_STORED)
  7454  		}
  7455  		return uint32((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf_size - Ulg(have))
  7456  	}()
  7457  	min_block = func() uint32 {
  7458  		if have > (*Deflate_state)(unsafe.Pointer(s)).Fw_size {
  7459  			return (*Deflate_state)(unsafe.Pointer(s)).Fw_size
  7460  		}
  7461  		return have
  7462  	}()
  7463  	left = uint32(int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) - (*Deflate_state)(unsafe.Pointer(s)).Fblock_start)
  7464  	if left >= min_block || (left != 0 || flush == Z_FINISH) && flush != Z_NO_FLUSH && (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_in == UInt(0) && left <= have {
  7465  		len = func() uint32 {
  7466  			if left > have {
  7467  				return have
  7468  			}
  7469  			return left
  7470  		}()
  7471  		if flush == Z_FINISH && (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_in == UInt(0) && len == left {
  7472  			last = uint32(1)
  7473  		} else {
  7474  			last = uint32(0)
  7475  		}
  7476  		X_tr_stored_block(tls, s, (*Deflate_state)(unsafe.Pointer(s)).Fwindow+uintptr((*Deflate_state)(unsafe.Pointer(s)).Fblock_start), uint64(len), int32(last))
  7477  		*(*int64)(unsafe.Pointer(s + 152)) += int64(len)
  7478  		flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm)
  7479  	}
  7480  
  7481  	// We've done all we can with the available input and output.
  7482  	if last != 0 {
  7483  		return Finish_started
  7484  	}
  7485  	return Need_more
  7486  }
  7487  
  7488  // ===========================================================================
  7489  // Compress as much as possible from the input stream, return the current
  7490  // block state.
  7491  // This function does not perform lazy evaluation of matches and inserts
  7492  // new strings in the dictionary only for unmatched strings or for short
  7493  // matches. It is used only for the fast compression options.
  7494  func deflate_fast(tls *libc.TLS, s uintptr, flush int32) Block_state { /* deflate.c:1824:19: */
  7495  	var hash_head IPos // head of the hash chain
  7496  	var bflush int32   // set if current block must be flushed
  7497  
  7498  	for {
  7499  		// Make sure that we always have enough lookahead, except
  7500  		// at the end of the input file. We need MAX_MATCH bytes
  7501  		// for the next match, plus MIN_MATCH bytes to insert the
  7502  		// string following the next match.
  7503  		if (*Deflate_state)(unsafe.Pointer(s)).Flookahead < UInt(MAX_MATCH+MIN_MATCH+1) {
  7504  			fill_window(tls, s)
  7505  			if (*Deflate_state)(unsafe.Pointer(s)).Flookahead < UInt(MAX_MATCH+MIN_MATCH+1) && flush == Z_NO_FLUSH {
  7506  				return Need_more
  7507  			}
  7508  			if (*Deflate_state)(unsafe.Pointer(s)).Flookahead == UInt(0) {
  7509  				break
  7510  			} // flush the current block
  7511  		}
  7512  
  7513  		// Insert the string window[strstart .. strstart+2] in the
  7514  		// dictionary, and set hash_head to the head of the hash chain:
  7515  		hash_head = IPos(NIL)
  7516  		if (*Deflate_state)(unsafe.Pointer(s)).Flookahead >= UInt(MIN_MATCH) {
  7517  			(*Deflate_state)(unsafe.Pointer(s)).Fins_h = ((*Deflate_state)(unsafe.Pointer(s)).Fins_h<<(*Deflate_state)(unsafe.Pointer(s)).Fhash_shift ^ UInt(*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart+UInt(MIN_MATCH-1)))))) & (*Deflate_state)(unsafe.Pointer(s)).Fhash_mask
  7518  			hash_head = IPos(libc.AssignPtrUint16((*Deflate_state)(unsafe.Pointer(s)).Fprev+uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart&(*Deflate_state)(unsafe.Pointer(s)).Fw_mask)*2, *(*Posf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fhead + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fins_h)*2))))
  7519  			*(*Posf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fhead + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fins_h)*2)) = Pos((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)
  7520  		}
  7521  
  7522  		// Find the longest match, discarding those <= prev_length.
  7523  		// At this point we have always match_length < MIN_MATCH
  7524  		if hash_head != IPos(NIL) && (*Deflate_state)(unsafe.Pointer(s)).Fstrstart-hash_head <= (*Deflate_state)(unsafe.Pointer(s)).Fw_size-UInt(MAX_MATCH+MIN_MATCH+1) {
  7525  			// To simplify the code, we prevent matches with the string
  7526  			// of window index 0 (in particular we have to avoid a match
  7527  			// of the string with itself at the start of the input file).
  7528  			(*Deflate_state)(unsafe.Pointer(s)).Fmatch_length = longest_match(tls, s, hash_head)
  7529  			// longest_match() sets match_start
  7530  		}
  7531  		if (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length >= UInt(MIN_MATCH) {
  7532  
  7533  			{
  7534  				var len Uch = Uch((*Deflate_state)(unsafe.Pointer(s)).Fmatch_length - UInt(MIN_MATCH))
  7535  				var dist Ush = Ush((*Deflate_state)(unsafe.Pointer(s)).Fstrstart - (*Deflate_state)(unsafe.Pointer(s)).Fmatch_start)
  7536  				*(*Ushf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fd_buf + uintptr((*Deflate_state)(unsafe.Pointer(s)).Flast_lit)*2)) = dist
  7537  				*(*Uchf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fl_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Flast_lit, 1)))) = len
  7538  				dist--
  7539  				*(*Ush)(unsafe.Pointer(s + 212 + uintptr(int32(X_length_code[len])+LITERALS+1)*4))++
  7540  				*(*Ush)(unsafe.Pointer(s + 2504 + uintptr(func() int32 {
  7541  					if int32(dist) < 256 {
  7542  						return int32(X_dist_code[dist])
  7543  					}
  7544  					return int32(X_dist_code[256+int32(dist)>>7])
  7545  				}())*4))++
  7546  				bflush = libc.Bool32((*Deflate_state)(unsafe.Pointer(s)).Flast_lit == (*Deflate_state)(unsafe.Pointer(s)).Flit_bufsize-UInt(1))
  7547  			}
  7548  
  7549  			*(*UInt)(unsafe.Pointer(s + 180)) -= (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length
  7550  
  7551  			// Insert new strings in the hash table only if the match length
  7552  			// is not too large. This saves time but degrades compression.
  7553  			if (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length <= (*Deflate_state)(unsafe.Pointer(s)).Fmax_lazy_match && (*Deflate_state)(unsafe.Pointer(s)).Flookahead >= UInt(MIN_MATCH) {
  7554  				(*Deflate_state)(unsafe.Pointer(s)).Fmatch_length-- // string at strstart already in table
  7555  				for __ccgo := true; __ccgo; __ccgo = libc.PreDecUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fmatch_length, 1) != UInt(0) {
  7556  					(*Deflate_state)(unsafe.Pointer(s)).Fstrstart++
  7557  					(*Deflate_state)(unsafe.Pointer(s)).Fins_h = ((*Deflate_state)(unsafe.Pointer(s)).Fins_h<<(*Deflate_state)(unsafe.Pointer(s)).Fhash_shift ^ UInt(*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart+UInt(MIN_MATCH-1)))))) & (*Deflate_state)(unsafe.Pointer(s)).Fhash_mask
  7558  					hash_head = IPos(libc.AssignPtrUint16((*Deflate_state)(unsafe.Pointer(s)).Fprev+uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart&(*Deflate_state)(unsafe.Pointer(s)).Fw_mask)*2, *(*Posf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fhead + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fins_h)*2))))
  7559  					*(*Posf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fhead + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fins_h)*2)) = Pos((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)
  7560  					// strstart never exceeds WSIZE-MAX_MATCH, so there are
  7561  					// always MIN_MATCH bytes ahead.
  7562  				}
  7563  				(*Deflate_state)(unsafe.Pointer(s)).Fstrstart++
  7564  			} else {
  7565  				*(*UInt)(unsafe.Pointer(s + 172)) += (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length
  7566  				(*Deflate_state)(unsafe.Pointer(s)).Fmatch_length = UInt(0)
  7567  				(*Deflate_state)(unsafe.Pointer(s)).Fins_h = UInt(*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart))))
  7568  				(*Deflate_state)(unsafe.Pointer(s)).Fins_h = ((*Deflate_state)(unsafe.Pointer(s)).Fins_h<<(*Deflate_state)(unsafe.Pointer(s)).Fhash_shift ^ UInt(*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart+UInt(1)))))) & (*Deflate_state)(unsafe.Pointer(s)).Fhash_mask
  7569  				// If lookahead < MIN_MATCH, ins_h is garbage, but it does not
  7570  				// matter since it will be recomputed at next deflate call.
  7571  			}
  7572  		} else {
  7573  			// No match, output a literal byte
  7574  
  7575  			{
  7576  				var cc Uch = *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)))
  7577  				*(*Ushf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fd_buf + uintptr((*Deflate_state)(unsafe.Pointer(s)).Flast_lit)*2)) = Ushf(0)
  7578  				*(*Uchf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fl_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Flast_lit, 1)))) = cc
  7579  				*(*Ush)(unsafe.Pointer(s + 212 + uintptr(cc)*4))++
  7580  				bflush = libc.Bool32((*Deflate_state)(unsafe.Pointer(s)).Flast_lit == (*Deflate_state)(unsafe.Pointer(s)).Flit_bufsize-UInt(1))
  7581  			}
  7582  
  7583  			(*Deflate_state)(unsafe.Pointer(s)).Flookahead--
  7584  			(*Deflate_state)(unsafe.Pointer(s)).Fstrstart++
  7585  		}
  7586  		if bflush != 0 {
  7587  			{
  7588  				X_tr_flush_block(tls, s, func() uintptr {
  7589  					if (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= 0 {
  7590  						return (*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))
  7591  					}
  7592  					return uintptr(Z_NULL)
  7593  				}(), Ulg(int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)-(*Deflate_state)(unsafe.Pointer(s)).Fblock_start), 0)
  7594  				(*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)
  7595  				flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm)
  7596  			}
  7597  			if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out == UInt(0) {
  7598  				if 0 != 0 {
  7599  					return Finish_started
  7600  				}
  7601  				return Need_more
  7602  			}
  7603  		}
  7604  
  7605  	}
  7606  	(*Deflate_state)(unsafe.Pointer(s)).Finsert = func() uint32 {
  7607  		if (*Deflate_state)(unsafe.Pointer(s)).Fstrstart < UInt(MIN_MATCH-1) {
  7608  			return (*Deflate_state)(unsafe.Pointer(s)).Fstrstart
  7609  		}
  7610  		return uint32(MIN_MATCH - 1)
  7611  	}()
  7612  	if flush == Z_FINISH {
  7613  		{
  7614  			{
  7615  				X_tr_flush_block(tls, s, func() uintptr {
  7616  					if (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= 0 {
  7617  						return (*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))
  7618  					}
  7619  					return uintptr(Z_NULL)
  7620  				}(), Ulg(int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)-(*Deflate_state)(unsafe.Pointer(s)).Fblock_start), 1)
  7621  				(*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)
  7622  				flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm)
  7623  			}
  7624  			if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out == UInt(0) {
  7625  				if 1 != 0 {
  7626  					return Finish_started
  7627  				}
  7628  				return Need_more
  7629  			}
  7630  		}
  7631  
  7632  		return Finish_done
  7633  	}
  7634  	if (*Deflate_state)(unsafe.Pointer(s)).Flast_lit != 0 {
  7635  		{
  7636  			X_tr_flush_block(tls, s, func() uintptr {
  7637  				if (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= 0 {
  7638  					return (*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))
  7639  				}
  7640  				return uintptr(Z_NULL)
  7641  			}(), Ulg(int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)-(*Deflate_state)(unsafe.Pointer(s)).Fblock_start), 0)
  7642  			(*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)
  7643  			flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm)
  7644  		}
  7645  		if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out == UInt(0) {
  7646  			if 0 != 0 {
  7647  				return Finish_started
  7648  			}
  7649  			return Need_more
  7650  		}
  7651  	}
  7652  
  7653  	return Block_done
  7654  }
  7655  
  7656  // ===========================================================================
  7657  // Same as above, but achieves better compression. We use a lazy
  7658  // evaluation for matches: a match is finally adopted only if there is
  7659  // no better match at the next window position.
  7660  func deflate_slow(tls *libc.TLS, s uintptr, flush int32) Block_state { /* deflate.c:1926:19: */
  7661  	var hash_head IPos // head of hash chain
  7662  	var bflush int32   // set if current block must be flushed
  7663  
  7664  	// Process the input block.
  7665  	for {
  7666  		// Make sure that we always have enough lookahead, except
  7667  		// at the end of the input file. We need MAX_MATCH bytes
  7668  		// for the next match, plus MIN_MATCH bytes to insert the
  7669  		// string following the next match.
  7670  		if (*Deflate_state)(unsafe.Pointer(s)).Flookahead < UInt(MAX_MATCH+MIN_MATCH+1) {
  7671  			fill_window(tls, s)
  7672  			if (*Deflate_state)(unsafe.Pointer(s)).Flookahead < UInt(MAX_MATCH+MIN_MATCH+1) && flush == Z_NO_FLUSH {
  7673  				return Need_more
  7674  			}
  7675  			if (*Deflate_state)(unsafe.Pointer(s)).Flookahead == UInt(0) {
  7676  				break
  7677  			} // flush the current block
  7678  		}
  7679  
  7680  		// Insert the string window[strstart .. strstart+2] in the
  7681  		// dictionary, and set hash_head to the head of the hash chain:
  7682  		hash_head = IPos(NIL)
  7683  		if (*Deflate_state)(unsafe.Pointer(s)).Flookahead >= UInt(MIN_MATCH) {
  7684  			(*Deflate_state)(unsafe.Pointer(s)).Fins_h = ((*Deflate_state)(unsafe.Pointer(s)).Fins_h<<(*Deflate_state)(unsafe.Pointer(s)).Fhash_shift ^ UInt(*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart+UInt(MIN_MATCH-1)))))) & (*Deflate_state)(unsafe.Pointer(s)).Fhash_mask
  7685  			hash_head = IPos(libc.AssignPtrUint16((*Deflate_state)(unsafe.Pointer(s)).Fprev+uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart&(*Deflate_state)(unsafe.Pointer(s)).Fw_mask)*2, *(*Posf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fhead + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fins_h)*2))))
  7686  			*(*Posf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fhead + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fins_h)*2)) = Pos((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)
  7687  		}
  7688  
  7689  		// Find the longest match, discarding those <= prev_length.
  7690  		(*Deflate_state)(unsafe.Pointer(s)).Fprev_length = (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length
  7691  		(*Deflate_state)(unsafe.Pointer(s)).Fprev_match = (*Deflate_state)(unsafe.Pointer(s)).Fmatch_start
  7692  		(*Deflate_state)(unsafe.Pointer(s)).Fmatch_length = UInt(MIN_MATCH - 1)
  7693  
  7694  		if hash_head != IPos(NIL) && (*Deflate_state)(unsafe.Pointer(s)).Fprev_length < (*Deflate_state)(unsafe.Pointer(s)).Fmax_lazy_match && (*Deflate_state)(unsafe.Pointer(s)).Fstrstart-hash_head <= (*Deflate_state)(unsafe.Pointer(s)).Fw_size-UInt(MAX_MATCH+MIN_MATCH+1) {
  7695  			// To simplify the code, we prevent matches with the string
  7696  			// of window index 0 (in particular we have to avoid a match
  7697  			// of the string with itself at the start of the input file).
  7698  			(*Deflate_state)(unsafe.Pointer(s)).Fmatch_length = longest_match(tls, s, hash_head)
  7699  			// longest_match() sets match_start
  7700  
  7701  			if (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length <= UInt(5) && ((*Deflate_state)(unsafe.Pointer(s)).Fstrategy == Z_FILTERED ||
  7702  				(*Deflate_state)(unsafe.Pointer(s)).Fmatch_length == UInt(MIN_MATCH) && (*Deflate_state)(unsafe.Pointer(s)).Fstrstart-(*Deflate_state)(unsafe.Pointer(s)).Fmatch_start > UInt(TOO_FAR)) {
  7703  
  7704  				// If prev_match is also MIN_MATCH, match_start is garbage
  7705  				// but we will ignore the current match anyway.
  7706  				(*Deflate_state)(unsafe.Pointer(s)).Fmatch_length = UInt(MIN_MATCH - 1)
  7707  			}
  7708  		}
  7709  		// If there was a match at the previous step and the current
  7710  		// match is not better, output the previous match:
  7711  		if (*Deflate_state)(unsafe.Pointer(s)).Fprev_length >= UInt(MIN_MATCH) && (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length <= (*Deflate_state)(unsafe.Pointer(s)).Fprev_length {
  7712  			var max_insert UInt = (*Deflate_state)(unsafe.Pointer(s)).Fstrstart + (*Deflate_state)(unsafe.Pointer(s)).Flookahead - UInt(MIN_MATCH)
  7713  			// Do not insert strings in hash table beyond this.
  7714  
  7715  			{
  7716  				var len Uch = Uch((*Deflate_state)(unsafe.Pointer(s)).Fprev_length - UInt(MIN_MATCH))
  7717  				var dist Ush = Ush((*Deflate_state)(unsafe.Pointer(s)).Fstrstart - UInt(1) - (*Deflate_state)(unsafe.Pointer(s)).Fprev_match)
  7718  				*(*Ushf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fd_buf + uintptr((*Deflate_state)(unsafe.Pointer(s)).Flast_lit)*2)) = dist
  7719  				*(*Uchf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fl_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Flast_lit, 1)))) = len
  7720  				dist--
  7721  				*(*Ush)(unsafe.Pointer(s + 212 + uintptr(int32(X_length_code[len])+LITERALS+1)*4))++
  7722  				*(*Ush)(unsafe.Pointer(s + 2504 + uintptr(func() int32 {
  7723  					if int32(dist) < 256 {
  7724  						return int32(X_dist_code[dist])
  7725  					}
  7726  					return int32(X_dist_code[256+int32(dist)>>7])
  7727  				}())*4))++
  7728  				bflush = libc.Bool32((*Deflate_state)(unsafe.Pointer(s)).Flast_lit == (*Deflate_state)(unsafe.Pointer(s)).Flit_bufsize-UInt(1))
  7729  			}
  7730  
  7731  			// Insert in hash table all strings up to the end of the match.
  7732  			// strstart-1 and strstart are already inserted. If there is not
  7733  			// enough lookahead, the last two strings are not inserted in
  7734  			// the hash table.
  7735  			*(*UInt)(unsafe.Pointer(s + 180)) -= (*Deflate_state)(unsafe.Pointer(s)).Fprev_length - UInt(1)
  7736  			*(*UInt)(unsafe.Pointer(s + 184)) -= UInt(2)
  7737  			for __ccgo := true; __ccgo; __ccgo = libc.PreDecUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fprev_length, 1) != UInt(0) {
  7738  				if libc.PreIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fstrstart, 1) <= max_insert {
  7739  					(*Deflate_state)(unsafe.Pointer(s)).Fins_h = ((*Deflate_state)(unsafe.Pointer(s)).Fins_h<<(*Deflate_state)(unsafe.Pointer(s)).Fhash_shift ^ UInt(*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart+UInt(MIN_MATCH-1)))))) & (*Deflate_state)(unsafe.Pointer(s)).Fhash_mask
  7740  					hash_head = IPos(libc.AssignPtrUint16((*Deflate_state)(unsafe.Pointer(s)).Fprev+uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart&(*Deflate_state)(unsafe.Pointer(s)).Fw_mask)*2, *(*Posf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fhead + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fins_h)*2))))
  7741  					*(*Posf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fhead + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fins_h)*2)) = Pos((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)
  7742  				}
  7743  			}
  7744  			(*Deflate_state)(unsafe.Pointer(s)).Fmatch_available = 0
  7745  			(*Deflate_state)(unsafe.Pointer(s)).Fmatch_length = UInt(MIN_MATCH - 1)
  7746  			(*Deflate_state)(unsafe.Pointer(s)).Fstrstart++
  7747  
  7748  			if bflush != 0 {
  7749  				{
  7750  					X_tr_flush_block(tls, s, func() uintptr {
  7751  						if (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= 0 {
  7752  							return (*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))
  7753  						}
  7754  						return uintptr(Z_NULL)
  7755  					}(), Ulg(int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)-(*Deflate_state)(unsafe.Pointer(s)).Fblock_start), 0)
  7756  					(*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)
  7757  					flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm)
  7758  				}
  7759  				if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out == UInt(0) {
  7760  					if 0 != 0 {
  7761  						return Finish_started
  7762  					}
  7763  					return Need_more
  7764  				}
  7765  			}
  7766  
  7767  		} else if (*Deflate_state)(unsafe.Pointer(s)).Fmatch_available != 0 {
  7768  			// If there was no match at the previous position, output a
  7769  			// single literal. If there was a match but the current match
  7770  			// is longer, truncate the previous match to a single literal.
  7771  
  7772  			{
  7773  				var cc Uch = *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart-UInt(1))))
  7774  				*(*Ushf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fd_buf + uintptr((*Deflate_state)(unsafe.Pointer(s)).Flast_lit)*2)) = Ushf(0)
  7775  				*(*Uchf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fl_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Flast_lit, 1)))) = cc
  7776  				*(*Ush)(unsafe.Pointer(s + 212 + uintptr(cc)*4))++
  7777  				bflush = libc.Bool32((*Deflate_state)(unsafe.Pointer(s)).Flast_lit == (*Deflate_state)(unsafe.Pointer(s)).Flit_bufsize-UInt(1))
  7778  			}
  7779  
  7780  			if bflush != 0 {
  7781  				{
  7782  					X_tr_flush_block(tls, s, func() uintptr {
  7783  						if (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= 0 {
  7784  							return (*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))
  7785  						}
  7786  						return uintptr(Z_NULL)
  7787  					}(), Ulg(int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)-(*Deflate_state)(unsafe.Pointer(s)).Fblock_start), 0)
  7788  					(*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)
  7789  					flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm)
  7790  				}
  7791  
  7792  			}
  7793  			(*Deflate_state)(unsafe.Pointer(s)).Fstrstart++
  7794  			(*Deflate_state)(unsafe.Pointer(s)).Flookahead--
  7795  			if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out == UInt(0) {
  7796  				return Need_more
  7797  			}
  7798  		} else {
  7799  			// There is no previous match to compare with, wait for
  7800  			// the next step to decide.
  7801  			(*Deflate_state)(unsafe.Pointer(s)).Fmatch_available = 1
  7802  			(*Deflate_state)(unsafe.Pointer(s)).Fstrstart++
  7803  			(*Deflate_state)(unsafe.Pointer(s)).Flookahead--
  7804  		}
  7805  	}
  7806  
  7807  	if (*Deflate_state)(unsafe.Pointer(s)).Fmatch_available != 0 {
  7808  
  7809  		{
  7810  			var cc Uch = *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart-UInt(1))))
  7811  			*(*Ushf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fd_buf + uintptr((*Deflate_state)(unsafe.Pointer(s)).Flast_lit)*2)) = Ushf(0)
  7812  			*(*Uchf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fl_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Flast_lit, 1)))) = cc
  7813  			*(*Ush)(unsafe.Pointer(s + 212 + uintptr(cc)*4))++
  7814  			bflush = libc.Bool32((*Deflate_state)(unsafe.Pointer(s)).Flast_lit == (*Deflate_state)(unsafe.Pointer(s)).Flit_bufsize-UInt(1))
  7815  		}
  7816  
  7817  		(*Deflate_state)(unsafe.Pointer(s)).Fmatch_available = 0
  7818  	}
  7819  	(*Deflate_state)(unsafe.Pointer(s)).Finsert = func() uint32 {
  7820  		if (*Deflate_state)(unsafe.Pointer(s)).Fstrstart < UInt(MIN_MATCH-1) {
  7821  			return (*Deflate_state)(unsafe.Pointer(s)).Fstrstart
  7822  		}
  7823  		return uint32(MIN_MATCH - 1)
  7824  	}()
  7825  	if flush == Z_FINISH {
  7826  		{
  7827  			{
  7828  				X_tr_flush_block(tls, s, func() uintptr {
  7829  					if (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= 0 {
  7830  						return (*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))
  7831  					}
  7832  					return uintptr(Z_NULL)
  7833  				}(), Ulg(int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)-(*Deflate_state)(unsafe.Pointer(s)).Fblock_start), 1)
  7834  				(*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)
  7835  				flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm)
  7836  			}
  7837  			if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out == UInt(0) {
  7838  				if 1 != 0 {
  7839  					return Finish_started
  7840  				}
  7841  				return Need_more
  7842  			}
  7843  		}
  7844  
  7845  		return Finish_done
  7846  	}
  7847  	if (*Deflate_state)(unsafe.Pointer(s)).Flast_lit != 0 {
  7848  		{
  7849  			X_tr_flush_block(tls, s, func() uintptr {
  7850  				if (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= 0 {
  7851  					return (*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))
  7852  				}
  7853  				return uintptr(Z_NULL)
  7854  			}(), Ulg(int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)-(*Deflate_state)(unsafe.Pointer(s)).Fblock_start), 0)
  7855  			(*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)
  7856  			flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm)
  7857  		}
  7858  		if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out == UInt(0) {
  7859  			if 0 != 0 {
  7860  				return Finish_started
  7861  			}
  7862  			return Need_more
  7863  		}
  7864  	}
  7865  
  7866  	return Block_done
  7867  }
  7868  
  7869  // ===========================================================================
  7870  // For Z_RLE, simply look for runs of bytes, generate matches only of distance
  7871  // one.  Do not maintain a hash table.  (It will be regenerated if this run of
  7872  // deflate switches away from Z_RLE.)
  7873  func deflate_rle(tls *libc.TLS, s uintptr, flush int32) Block_state { /* deflate.c:2057:19: */
  7874  	var bflush int32 // set if current block must be flushed
  7875  	var prev UInt    // byte at distance one to match
  7876  	var scan uintptr
  7877  	var strend uintptr // scan goes up to strend for length of run
  7878  
  7879  	for {
  7880  		// Make sure that we always have enough lookahead, except
  7881  		// at the end of the input file. We need MAX_MATCH bytes
  7882  		// for the longest run, plus one for the unrolled loop.
  7883  		if (*Deflate_state)(unsafe.Pointer(s)).Flookahead <= UInt(MAX_MATCH) {
  7884  			fill_window(tls, s)
  7885  			if (*Deflate_state)(unsafe.Pointer(s)).Flookahead <= UInt(MAX_MATCH) && flush == Z_NO_FLUSH {
  7886  				return Need_more
  7887  			}
  7888  			if (*Deflate_state)(unsafe.Pointer(s)).Flookahead == UInt(0) {
  7889  				break
  7890  			} // flush the current block
  7891  		}
  7892  
  7893  		// See how many times the previous byte repeats
  7894  		(*Deflate_state)(unsafe.Pointer(s)).Fmatch_length = UInt(0)
  7895  		if (*Deflate_state)(unsafe.Pointer(s)).Flookahead >= UInt(MIN_MATCH) && (*Deflate_state)(unsafe.Pointer(s)).Fstrstart > UInt(0) {
  7896  			scan = (*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) - uintptr(1)
  7897  			prev = UInt(*(*Bytef)(unsafe.Pointer(scan)))
  7898  			if prev == UInt(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&scan, 1)))) && prev == UInt(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&scan, 1)))) && prev == UInt(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&scan, 1)))) {
  7899  				strend = (*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) + uintptr(MAX_MATCH)
  7900  				for __ccgo := true; __ccgo; __ccgo = prev == UInt(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&scan, 1)))) && prev == UInt(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&scan, 1)))) && prev == UInt(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&scan, 1)))) && prev == UInt(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&scan, 1)))) && prev == UInt(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&scan, 1)))) && prev == UInt(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&scan, 1)))) && prev == UInt(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&scan, 1)))) && prev == UInt(*(*Bytef)(unsafe.Pointer(libc.PreIncUintptr(&scan, 1)))) && scan < strend {
  7901  				}
  7902  				(*Deflate_state)(unsafe.Pointer(s)).Fmatch_length = UInt(MAX_MATCH) - UInt((int64(strend)-int64(scan))/1)
  7903  				if (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length > (*Deflate_state)(unsafe.Pointer(s)).Flookahead {
  7904  					(*Deflate_state)(unsafe.Pointer(s)).Fmatch_length = (*Deflate_state)(unsafe.Pointer(s)).Flookahead
  7905  				}
  7906  			}
  7907  
  7908  		}
  7909  
  7910  		// Emit match if have run of MIN_MATCH or longer, else emit literal
  7911  		if (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length >= UInt(MIN_MATCH) {
  7912  
  7913  			{
  7914  				var len Uch = Uch((*Deflate_state)(unsafe.Pointer(s)).Fmatch_length - UInt(MIN_MATCH))
  7915  				var dist Ush = Ush(1)
  7916  				*(*Ushf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fd_buf + uintptr((*Deflate_state)(unsafe.Pointer(s)).Flast_lit)*2)) = dist
  7917  				*(*Uchf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fl_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Flast_lit, 1)))) = len
  7918  				dist--
  7919  				*(*Ush)(unsafe.Pointer(s + 212 + uintptr(int32(X_length_code[len])+LITERALS+1)*4))++
  7920  				*(*Ush)(unsafe.Pointer(s + 2504 + uintptr(func() int32 {
  7921  					if int32(dist) < 256 {
  7922  						return int32(X_dist_code[dist])
  7923  					}
  7924  					return int32(X_dist_code[256+int32(dist)>>7])
  7925  				}())*4))++
  7926  				bflush = libc.Bool32((*Deflate_state)(unsafe.Pointer(s)).Flast_lit == (*Deflate_state)(unsafe.Pointer(s)).Flit_bufsize-UInt(1))
  7927  			}
  7928  
  7929  			*(*UInt)(unsafe.Pointer(s + 180)) -= (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length
  7930  			*(*UInt)(unsafe.Pointer(s + 172)) += (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length
  7931  			(*Deflate_state)(unsafe.Pointer(s)).Fmatch_length = UInt(0)
  7932  		} else {
  7933  			// No match, output a literal byte
  7934  
  7935  			{
  7936  				var cc Uch = *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)))
  7937  				*(*Ushf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fd_buf + uintptr((*Deflate_state)(unsafe.Pointer(s)).Flast_lit)*2)) = Ushf(0)
  7938  				*(*Uchf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fl_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Flast_lit, 1)))) = cc
  7939  				*(*Ush)(unsafe.Pointer(s + 212 + uintptr(cc)*4))++
  7940  				bflush = libc.Bool32((*Deflate_state)(unsafe.Pointer(s)).Flast_lit == (*Deflate_state)(unsafe.Pointer(s)).Flit_bufsize-UInt(1))
  7941  			}
  7942  
  7943  			(*Deflate_state)(unsafe.Pointer(s)).Flookahead--
  7944  			(*Deflate_state)(unsafe.Pointer(s)).Fstrstart++
  7945  		}
  7946  		if bflush != 0 {
  7947  			{
  7948  				X_tr_flush_block(tls, s, func() uintptr {
  7949  					if (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= 0 {
  7950  						return (*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))
  7951  					}
  7952  					return uintptr(Z_NULL)
  7953  				}(), Ulg(int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)-(*Deflate_state)(unsafe.Pointer(s)).Fblock_start), 0)
  7954  				(*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)
  7955  				flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm)
  7956  			}
  7957  			if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out == UInt(0) {
  7958  				if 0 != 0 {
  7959  					return Finish_started
  7960  				}
  7961  				return Need_more
  7962  			}
  7963  		}
  7964  
  7965  	}
  7966  	(*Deflate_state)(unsafe.Pointer(s)).Finsert = UInt(0)
  7967  	if flush == Z_FINISH {
  7968  		{
  7969  			{
  7970  				X_tr_flush_block(tls, s, func() uintptr {
  7971  					if (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= 0 {
  7972  						return (*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))
  7973  					}
  7974  					return uintptr(Z_NULL)
  7975  				}(), Ulg(int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)-(*Deflate_state)(unsafe.Pointer(s)).Fblock_start), 1)
  7976  				(*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)
  7977  				flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm)
  7978  			}
  7979  			if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out == UInt(0) {
  7980  				if 1 != 0 {
  7981  					return Finish_started
  7982  				}
  7983  				return Need_more
  7984  			}
  7985  		}
  7986  
  7987  		return Finish_done
  7988  	}
  7989  	if (*Deflate_state)(unsafe.Pointer(s)).Flast_lit != 0 {
  7990  		{
  7991  			X_tr_flush_block(tls, s, func() uintptr {
  7992  				if (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= 0 {
  7993  					return (*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))
  7994  				}
  7995  				return uintptr(Z_NULL)
  7996  			}(), Ulg(int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)-(*Deflate_state)(unsafe.Pointer(s)).Fblock_start), 0)
  7997  			(*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)
  7998  			flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm)
  7999  		}
  8000  		if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out == UInt(0) {
  8001  			if 0 != 0 {
  8002  				return Finish_started
  8003  			}
  8004  			return Need_more
  8005  		}
  8006  	}
  8007  
  8008  	return Block_done
  8009  }
  8010  
  8011  // ===========================================================================
  8012  // For Z_HUFFMAN_ONLY, do not look for matches.  Do not maintain a hash table.
  8013  // (It will be regenerated if this run of deflate switches away from Huffman.)
  8014  func deflate_huff(tls *libc.TLS, s uintptr, flush int32) Block_state { /* deflate.c:2130:19: */
  8015  	var bflush int32 // set if current block must be flushed
  8016  
  8017  	for {
  8018  		// Make sure that we have a literal to write.
  8019  		if (*Deflate_state)(unsafe.Pointer(s)).Flookahead == UInt(0) {
  8020  			fill_window(tls, s)
  8021  			if (*Deflate_state)(unsafe.Pointer(s)).Flookahead == UInt(0) {
  8022  				if flush == Z_NO_FLUSH {
  8023  					return Need_more
  8024  				}
  8025  				break // flush the current block
  8026  			}
  8027  		}
  8028  
  8029  		// Output a literal byte
  8030  		(*Deflate_state)(unsafe.Pointer(s)).Fmatch_length = UInt(0)
  8031  
  8032  		{
  8033  			var cc Uch = *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)))
  8034  			*(*Ushf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fd_buf + uintptr((*Deflate_state)(unsafe.Pointer(s)).Flast_lit)*2)) = Ushf(0)
  8035  			*(*Uchf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fl_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Flast_lit, 1)))) = cc
  8036  			*(*Ush)(unsafe.Pointer(s + 212 + uintptr(cc)*4))++
  8037  			bflush = libc.Bool32((*Deflate_state)(unsafe.Pointer(s)).Flast_lit == (*Deflate_state)(unsafe.Pointer(s)).Flit_bufsize-UInt(1))
  8038  		}
  8039  
  8040  		(*Deflate_state)(unsafe.Pointer(s)).Flookahead--
  8041  		(*Deflate_state)(unsafe.Pointer(s)).Fstrstart++
  8042  		if bflush != 0 {
  8043  			{
  8044  				X_tr_flush_block(tls, s, func() uintptr {
  8045  					if (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= 0 {
  8046  						return (*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))
  8047  					}
  8048  					return uintptr(Z_NULL)
  8049  				}(), Ulg(int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)-(*Deflate_state)(unsafe.Pointer(s)).Fblock_start), 0)
  8050  				(*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)
  8051  				flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm)
  8052  			}
  8053  			if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out == UInt(0) {
  8054  				if 0 != 0 {
  8055  					return Finish_started
  8056  				}
  8057  				return Need_more
  8058  			}
  8059  		}
  8060  
  8061  	}
  8062  	(*Deflate_state)(unsafe.Pointer(s)).Finsert = UInt(0)
  8063  	if flush == Z_FINISH {
  8064  		{
  8065  			{
  8066  				X_tr_flush_block(tls, s, func() uintptr {
  8067  					if (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= 0 {
  8068  						return (*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))
  8069  					}
  8070  					return uintptr(Z_NULL)
  8071  				}(), Ulg(int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)-(*Deflate_state)(unsafe.Pointer(s)).Fblock_start), 1)
  8072  				(*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)
  8073  				flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm)
  8074  			}
  8075  			if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out == UInt(0) {
  8076  				if 1 != 0 {
  8077  					return Finish_started
  8078  				}
  8079  				return Need_more
  8080  			}
  8081  		}
  8082  
  8083  		return Finish_done
  8084  	}
  8085  	if (*Deflate_state)(unsafe.Pointer(s)).Flast_lit != 0 {
  8086  		{
  8087  			X_tr_flush_block(tls, s, func() uintptr {
  8088  				if (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= 0 {
  8089  					return (*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))
  8090  				}
  8091  				return uintptr(Z_NULL)
  8092  			}(), Ulg(int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)-(*Deflate_state)(unsafe.Pointer(s)).Fblock_start), 0)
  8093  			(*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int64((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)
  8094  			flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm)
  8095  		}
  8096  		if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out == UInt(0) {
  8097  			if 0 != 0 {
  8098  				return Finish_started
  8099  			}
  8100  			return Need_more
  8101  		}
  8102  	}
  8103  
  8104  	return Block_done
  8105  }
  8106  
  8107  // Seconds since the Epoch, visible to user code when time_t is too
  8108  //    narrow only for consistency with the old way of widening too-narrow
  8109  //    types.  User code should never use __time64_t.
  8110  
  8111  // bits/types.h -- definitions of __*_t types underlying *_t types.
  8112  //    Copyright (C) 2002-2020 Free Software Foundation, Inc.
  8113  //    This file is part of the GNU C Library.
  8114  //
  8115  //    The GNU C Library is free software; you can redistribute it and/or
  8116  //    modify it under the terms of the GNU Lesser General Public
  8117  //    License as published by the Free Software Foundation; either
  8118  //    version 2.1 of the License, or (at your option) any later version.
  8119  //
  8120  //    The GNU C Library is distributed in the hope that it will be useful,
  8121  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8122  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  8123  //    Lesser General Public License for more details.
  8124  //
  8125  //    You should have received a copy of the GNU Lesser General Public
  8126  //    License along with the GNU C Library; if not, see
  8127  //    <https://www.gnu.org/licenses/>.
  8128  
  8129  // Never include this file directly; use <sys/types.h> instead.
  8130  
  8131  // Integral type unchanged by default argument promotions that can
  8132  //    hold any value corresponding to members of the extended character
  8133  //    set, as well as at least one value that does not correspond to any
  8134  //    member of the extended character set.
  8135  
  8136  // Conversion state information.
  8137  type X__mbstate_t = struct {
  8138  	F__count int32
  8139  	F__value struct{ F__wch uint32 }
  8140  } /* __mbstate_t.h:21:3 */
  8141  
  8142  // The tag name of this struct is _G_fpos_t to preserve historic
  8143  //    C++ mangled names for functions taking fpos_t arguments.
  8144  //    That name should not be used in new code.
  8145  type X_G_fpos_t = struct {
  8146  	F__pos   X__off_t
  8147  	F__state X__mbstate_t
  8148  } /* __fpos_t.h:10:9 */
  8149  
  8150  // The tag name of this struct is _G_fpos_t to preserve historic
  8151  //    C++ mangled names for functions taking fpos_t arguments.
  8152  //    That name should not be used in new code.
  8153  type X__fpos_t = X_G_fpos_t /* __fpos_t.h:14:3 */
  8154  
  8155  // bits/types.h -- definitions of __*_t types underlying *_t types.
  8156  //    Copyright (C) 2002-2020 Free Software Foundation, Inc.
  8157  //    This file is part of the GNU C Library.
  8158  //
  8159  //    The GNU C Library is free software; you can redistribute it and/or
  8160  //    modify it under the terms of the GNU Lesser General Public
  8161  //    License as published by the Free Software Foundation; either
  8162  //    version 2.1 of the License, or (at your option) any later version.
  8163  //
  8164  //    The GNU C Library is distributed in the hope that it will be useful,
  8165  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8166  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  8167  //    Lesser General Public License for more details.
  8168  //
  8169  //    You should have received a copy of the GNU Lesser General Public
  8170  //    License along with the GNU C Library; if not, see
  8171  //    <https://www.gnu.org/licenses/>.
  8172  
  8173  // Never include this file directly; use <sys/types.h> instead.
  8174  
  8175  // The tag name of this struct is _G_fpos64_t to preserve historic
  8176  //    C++ mangled names for functions taking fpos_t and/or fpos64_t
  8177  //    arguments.  That name should not be used in new code.
  8178  type X_G_fpos64_t = struct {
  8179  	F__pos   X__off64_t
  8180  	F__state X__mbstate_t
  8181  } /* __fpos64_t.h:10:9 */
  8182  
  8183  // bits/types.h -- definitions of __*_t types underlying *_t types.
  8184  //    Copyright (C) 2002-2020 Free Software Foundation, Inc.
  8185  //    This file is part of the GNU C Library.
  8186  //
  8187  //    The GNU C Library is free software; you can redistribute it and/or
  8188  //    modify it under the terms of the GNU Lesser General Public
  8189  //    License as published by the Free Software Foundation; either
  8190  //    version 2.1 of the License, or (at your option) any later version.
  8191  //
  8192  //    The GNU C Library is distributed in the hope that it will be useful,
  8193  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8194  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  8195  //    Lesser General Public License for more details.
  8196  //
  8197  //    You should have received a copy of the GNU Lesser General Public
  8198  //    License along with the GNU C Library; if not, see
  8199  //    <https://www.gnu.org/licenses/>.
  8200  
  8201  // Never include this file directly; use <sys/types.h> instead.
  8202  
  8203  // The tag name of this struct is _G_fpos64_t to preserve historic
  8204  //    C++ mangled names for functions taking fpos_t and/or fpos64_t
  8205  //    arguments.  That name should not be used in new code.
  8206  type X__fpos64_t = X_G_fpos64_t /* __fpos64_t.h:14:3 */
  8207  
  8208  type X_IO_FILE = struct {
  8209  	F_flags          int32
  8210  	F__ccgo_pad1     [4]byte
  8211  	F_IO_read_ptr    uintptr
  8212  	F_IO_read_end    uintptr
  8213  	F_IO_read_base   uintptr
  8214  	F_IO_write_base  uintptr
  8215  	F_IO_write_ptr   uintptr
  8216  	F_IO_write_end   uintptr
  8217  	F_IO_buf_base    uintptr
  8218  	F_IO_buf_end     uintptr
  8219  	F_IO_save_base   uintptr
  8220  	F_IO_backup_base uintptr
  8221  	F_IO_save_end    uintptr
  8222  	F_markers        uintptr
  8223  	F_chain          uintptr
  8224  	F_fileno         int32
  8225  	F_flags2         int32
  8226  	F_old_offset     X__off_t
  8227  	F_cur_column     uint16
  8228  	F_vtable_offset  int8
  8229  	F_shortbuf       [1]uint8
  8230  	F__ccgo_pad2     [4]byte
  8231  	F_lock           uintptr
  8232  	F_offset         X__off64_t
  8233  	F_codecvt        uintptr
  8234  	F_wide_data      uintptr
  8235  	F_freeres_list   uintptr
  8236  	F_freeres_buf    uintptr
  8237  	F__pad5          Size_t
  8238  	F_mode           int32
  8239  	F_unused2        [20]uint8
  8240  } /* __FILE.h:4:1 */
  8241  
  8242  type X__FILE = X_IO_FILE /* __FILE.h:5:25 */
  8243  
  8244  // The opaque type of streams.  This is the definition used elsewhere.
  8245  type FILE = X_IO_FILE /* FILE.h:7:25 */
  8246  
  8247  // The type of the second argument to `fgetpos' and `fsetpos'.
  8248  type Fpos_t = X__fpos_t     /* stdio.h:84:18 */
  8249  type Fpos64_t = X__fpos64_t /* stdio.h:89:20 */
  8250  
  8251  // Floating-point inline functions for stdlib.h.
  8252  //    Copyright (C) 2012-2020 Free Software Foundation, Inc.
  8253  //    This file is part of the GNU C Library.
  8254  //
  8255  //    The GNU C Library is free software; you can redistribute it and/or
  8256  //    modify it under the terms of the GNU Lesser General Public
  8257  //    License as published by the Free Software Foundation; either
  8258  //    version 2.1 of the License, or (at your option) any later version.
  8259  //
  8260  //    The GNU C Library is distributed in the hope that it will be useful,
  8261  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8262  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  8263  //    Lesser General Public License for more details.
  8264  //
  8265  //    You should have received a copy of the GNU Lesser General Public
  8266  //    License along with the GNU C Library; if not, see
  8267  //    <https://www.gnu.org/licenses/>.
  8268  
  8269  // Define some macros helping to catch buffer overflows.
  8270  
  8271  // Copyright (C) 1992-2020 Free Software Foundation, Inc.
  8272  //
  8273  // This file is part of GCC.
  8274  //
  8275  // GCC is free software; you can redistribute it and/or modify it under
  8276  // the terms of the GNU General Public License as published by the Free
  8277  // Software Foundation; either version 3, or (at your option) any later
  8278  // version.
  8279  //
  8280  // GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  8281  // WARRANTY; without even the implied warranty of MERCHANTABILITY or
  8282  // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  8283  // for more details.
  8284  //
  8285  // Under Section 7 of GPL version 3, you are granted additional
  8286  // permissions described in the GCC Runtime Library Exception, version
  8287  // 3.1, as published by the Free Software Foundation.
  8288  //
  8289  // You should have received a copy of the GNU General Public License and
  8290  // a copy of the GCC Runtime Library Exception along with this program;
  8291  // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  8292  // <http://www.gnu.org/licenses/>.
  8293  
  8294  // This administrivia gets added to the beginning of limits.h
  8295  //    if the system has its own version of limits.h.
  8296  
  8297  // We use _GCC_LIMITS_H_ because we want this not to match
  8298  //    any macros that the system's limits.h uses for its own purposes.
  8299  
  8300  // Copyright (C) 1991-2020 Free Software Foundation, Inc.
  8301  //    This file is part of the GNU C Library.
  8302  //
  8303  //    The GNU C Library is free software; you can redistribute it and/or
  8304  //    modify it under the terms of the GNU Lesser General Public
  8305  //    License as published by the Free Software Foundation; either
  8306  //    version 2.1 of the License, or (at your option) any later version.
  8307  //
  8308  //    The GNU C Library is distributed in the hope that it will be useful,
  8309  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8310  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  8311  //    Lesser General Public License for more details.
  8312  //
  8313  //    You should have received a copy of the GNU Lesser General Public
  8314  //    License along with the GNU C Library; if not, see
  8315  //    <https://www.gnu.org/licenses/>.
  8316  
  8317  //	POSIX Standard: 6.5 File Control Operations	<fcntl.h>
  8318  
  8319  // Copyright (C) 1991-2020 Free Software Foundation, Inc.
  8320  //    This file is part of the GNU C Library.
  8321  //
  8322  //    The GNU C Library is free software; you can redistribute it and/or
  8323  //    modify it under the terms of the GNU Lesser General Public
  8324  //    License as published by the Free Software Foundation; either
  8325  //    version 2.1 of the License, or (at your option) any later version.
  8326  //
  8327  //    The GNU C Library is distributed in the hope that it will be useful,
  8328  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8329  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  8330  //    Lesser General Public License for more details.
  8331  //
  8332  //    You should have received a copy of the GNU Lesser General Public
  8333  //    License along with the GNU C Library; if not, see
  8334  //    <https://www.gnu.org/licenses/>.
  8335  
  8336  // This must be early so <bits/fcntl.h> can define types winningly.
  8337  
  8338  // Get __mode_t, __dev_t and __off_t  .
  8339  // bits/types.h -- definitions of __*_t types underlying *_t types.
  8340  //    Copyright (C) 2002-2020 Free Software Foundation, Inc.
  8341  //    This file is part of the GNU C Library.
  8342  //
  8343  //    The GNU C Library is free software; you can redistribute it and/or
  8344  //    modify it under the terms of the GNU Lesser General Public
  8345  //    License as published by the Free Software Foundation; either
  8346  //    version 2.1 of the License, or (at your option) any later version.
  8347  //
  8348  //    The GNU C Library is distributed in the hope that it will be useful,
  8349  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8350  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  8351  //    Lesser General Public License for more details.
  8352  //
  8353  //    You should have received a copy of the GNU Lesser General Public
  8354  //    License along with the GNU C Library; if not, see
  8355  //    <https://www.gnu.org/licenses/>.
  8356  
  8357  // Never include this file directly; use <sys/types.h> instead.
  8358  
  8359  // Get the definitions of O_*, F_*, FD_*: all the
  8360  //    numbers and flag bits for `open', `fcntl', et al.
  8361  // O_*, F_*, FD_* bit values for Linux/PowerPC.
  8362  //    Copyright (C) 1995-2020 Free Software Foundation, Inc.
  8363  //    This file is part of the GNU C Library.
  8364  //
  8365  //    The GNU C Library is free software; you can redistribute it and/or
  8366  //    modify it under the terms of the GNU Lesser General Public
  8367  //    License as published by the Free Software Foundation; either
  8368  //    version 2.1 of the License, or (at your option) any later version.
  8369  //
  8370  //    The GNU C Library is distributed in the hope that it will be useful,
  8371  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8372  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  8373  //    Lesser General Public License for more details.
  8374  //
  8375  //    You should have received a copy of the GNU Lesser General Public
  8376  //    License along with the GNU C Library; if not, see
  8377  //    <https://www.gnu.org/licenses/>.
  8378  
  8379  // Determine the wordsize from the preprocessor defines.
  8380  
  8381  // Not necessary, files are always with 64bit off_t.
  8382  
  8383  type Flock = struct {
  8384  	Fl_type      int16
  8385  	Fl_whence    int16
  8386  	F__ccgo_pad1 [4]byte
  8387  	Fl_start     X__off_t
  8388  	Fl_len       X__off_t
  8389  	Fl_pid       X__pid_t
  8390  	F__ccgo_pad2 [4]byte
  8391  } /* fcntl.h:36:1 */
  8392  
  8393  type Flock64 = struct {
  8394  	Fl_type      int16
  8395  	Fl_whence    int16
  8396  	F__ccgo_pad1 [4]byte
  8397  	Fl_start     X__off64_t
  8398  	Fl_len       X__off64_t
  8399  	Fl_pid       X__pid_t
  8400  	F__ccgo_pad2 [4]byte
  8401  } /* fcntl.h:51:1 */
  8402  
  8403  // Include generic Linux declarations.
  8404  // O_*, F_*, FD_* bit values for Linux.
  8405  //    Copyright (C) 2001-2020 Free Software Foundation, Inc.
  8406  //    This file is part of the GNU C Library.
  8407  //
  8408  //    The GNU C Library is free software; you can redistribute it and/or
  8409  //    modify it under the terms of the GNU Lesser General Public
  8410  //    License as published by the Free Software Foundation; either
  8411  //    version 2.1 of the License, or (at your option) any later version.
  8412  //
  8413  //    The GNU C Library is distributed in the hope that it will be useful,
  8414  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8415  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  8416  //    Lesser General Public License for more details.
  8417  //
  8418  //    You should have received a copy of the GNU Lesser General Public
  8419  //    License along with the GNU C Library; if not, see
  8420  //    <https://www.gnu.org/licenses/>.
  8421  
  8422  // This file contains shared definitions between Linux architectures
  8423  //    and is included by <bits/fcntl.h> to declare them.  The various
  8424  //    #ifndef cases allow the architecture specific file to define those
  8425  //    values with different values.
  8426  //
  8427  //    A minimal <bits/fcntl.h> contains just:
  8428  //
  8429  //    struct flock {...}
  8430  //    #ifdef __USE_LARGEFILE64
  8431  //    struct flock64 {...}
  8432  //    #endif
  8433  //    #include <bits/fcntl-linux.h>
  8434  
  8435  // open/fcntl.
  8436  
  8437  // open file description locks.
  8438  //
  8439  //    Usually record locks held by a process are released on *any* close and are
  8440  //    not inherited across a fork.
  8441  //
  8442  //    These cmd values will set locks that conflict with process-associated record
  8443  //    locks, but are "owned" by the opened file description, not the process.
  8444  //    This means that they are inherited across fork or clone with CLONE_FILES
  8445  //    like BSD (flock) locks, and they are only released automatically when the
  8446  //    last reference to the the file description against which they were acquired
  8447  //    is put.
  8448  
  8449  // For now, Linux has no separate synchronicity options for read
  8450  //    operations.  We define O_RSYNC therefore as the same as O_SYNC
  8451  //    since this is a superset.
  8452  
  8453  // Values for the second argument to `fcntl'.
  8454  
  8455  // For F_[GET|SET]FD.
  8456  
  8457  // For posix fcntl() and `l_type' field of a `struct flock' for lockf().
  8458  
  8459  // For old implementation of BSD flock.
  8460  
  8461  // Operations for BSD flock, also used by the kernel implementation.
  8462  
  8463  // Define some more compatibility macros to be backward compatible with
  8464  //    BSD systems which did not managed to hide these kernel macros.
  8465  
  8466  // Advise to `posix_fadvise'.
  8467  
  8468  // Values for `*at' functions.
  8469  
  8470  // Detect if open needs mode as a third argument (or for openat as a fourth
  8471  //    argument).
  8472  
  8473  // POSIX.1-2001 specifies that these types are defined by <fcntl.h>.
  8474  //    Earlier POSIX standards permitted any type ending in `_t' to be defined
  8475  //    by any POSIX header, so we don't conditionalize the definitions here.
  8476  
  8477  // For XPG all symbols from <sys/stat.h> should also be available.
  8478  // NB: Include guard matches what <linux/time.h> uses.
  8479  // Copyright (C) 1992-2020 Free Software Foundation, Inc.
  8480  //    This file is part of the GNU C Library.
  8481  //
  8482  //    The GNU C Library is free software; you can redistribute it and/or
  8483  //    modify it under the terms of the GNU Lesser General Public
  8484  //    License as published by the Free Software Foundation; either
  8485  //    version 2.1 of the License, or (at your option) any later version.
  8486  //
  8487  //    The GNU C Library is distributed in the hope that it will be useful,
  8488  //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8489  //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  8490  //    Lesser General Public License for more details.
  8491  //
  8492  //    You should have received a copy of the GNU Lesser General Public
  8493  //    License along with the GNU C Library; if not, see
  8494  //    <https://www.gnu.org/licenses/>.
  8495  
  8496  // Determine the wordsize from the preprocessor defines.
  8497  
  8498  // Versions of the `struct stat' data structure.
  8499  
  8500  // Versions of the `xmknod' interface.
  8501  
  8502  type Stat = struct {
  8503  	Fst_dev     X__dev_t
  8504  	Fst_ino     X__ino_t
  8505  	Fst_nlink   X__nlink_t
  8506  	Fst_mode    X__mode_t
  8507  	Fst_uid     X__uid_t
  8508  	Fst_gid     X__gid_t
  8509  	F__pad2     int32
  8510  	Fst_rdev    X__dev_t
  8511  	Fst_size    X__off_t
  8512  	Fst_blksize X__blksize_t
  8513  	Fst_blocks  X__blkcnt_t
  8514  	Fst_atim    struct {
  8515  		Ftv_sec  X__time_t
  8516  		Ftv_nsec X__syscall_slong_t
  8517  	}
  8518  	Fst_mtim struct {
  8519  		Ftv_sec  X__time_t
  8520  		Ftv_nsec X__syscall_slong_t
  8521  	}
  8522  	Fst_ctim struct {
  8523  		Ftv_sec  X__time_t
  8524  		Ftv_nsec X__syscall_slong_t
  8525  	}
  8526  	F__glibc_reserved4 uint64
  8527  	F__glibc_reserved5 uint64
  8528  	F__glibc_reserved6 uint64
  8529  } /* stat.h:141:1 */
  8530  
  8531  type Stat64 = struct {
  8532  	Fst_dev     X__dev_t
  8533  	Fst_ino     X__ino64_t
  8534  	Fst_nlink   X__nlink_t
  8535  	Fst_mode    X__mode_t
  8536  	Fst_uid     X__uid_t
  8537  	Fst_gid     X__gid_t
  8538  	F__pad2     int32
  8539  	Fst_rdev    X__dev_t
  8540  	Fst_size    X__off64_t
  8541  	Fst_blksize X__blksize_t
  8542  	Fst_blocks  X__blkcnt64_t
  8543  	Fst_atim    struct {
  8544  		Ftv_sec  X__time_t
  8545  		Ftv_nsec X__syscall_slong_t
  8546  	}
  8547  	Fst_mtim struct {
  8548  		Ftv_sec  X__time_t
  8549  		Ftv_nsec X__syscall_slong_t
  8550  	}
  8551  	Fst_ctim struct {
  8552  		Ftv_sec  X__time_t
  8553  		Ftv_nsec X__syscall_slong_t
  8554  	}
  8555  	F__glibc_reserved4 uint64
  8556  	F__glibc_reserved5 uint64
  8557  	F__glibc_reserved6 uint64
  8558  } /* stat.h:194:1 */
  8559  
  8560  // provide prototypes for these when building zlib without LFS
  8561  
  8562  // default memLevel
  8563  
  8564  // default i/o buffer size -- double this for output when reading (this and
  8565  //    twice this must be able to fit in an unsigned type)
  8566  
  8567  // gzip modes, also provide a little integrity check on the passed structure
  8568  
  8569  // values for gz_state how
  8570  
  8571  // internal gzip file state data structure
  8572  type Gz_state = struct {
  8573  	Fx        GzFile_s
  8574  	Fmode     int32
  8575  	Ffd       int32
  8576  	Fpath     uintptr
  8577  	Fsize     uint32
  8578  	Fwant     uint32
  8579  	Fin       uintptr
  8580  	Fout      uintptr
  8581  	Fdirect   int32
  8582  	Fhow      int32
  8583  	Fstart    Off64_t
  8584  	Feof      int32
  8585  	Fpast     int32
  8586  	Flevel    int32
  8587  	Fstrategy int32
  8588  	Fskip     Off64_t
  8589  	Fseek     int32
  8590  	Ferr      int32
  8591  	Fmsg      uintptr
  8592  	Fstrm     Z_stream
  8593  }                        /* gzguts.h:201:3 */
  8594  type Gz_statep = uintptr /* gzguts.h:202:22 */
  8595  
  8596  // GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t
  8597  //    value -- needed when comparing unsigned to z_off64_t, which is signed
  8598  //    (possible z_off64_t types off_t, off64_t, and long are all signed)
  8599  
  8600  // gzclose() is in a separate file so that it is linked in only if it is used.
  8601  //    That way the other gzclose functions can be used instead to avoid linking in
  8602  //    unneeded compression or decompression routines.
  8603  func Xgzclose(tls *libc.TLS, file GzFile) int32 { /* gzclose.c:11:13: */
  8604  	var state Gz_statep
  8605  
  8606  	if file == uintptr(0) {
  8607  		return -2
  8608  	}
  8609  	state = file
  8610  
  8611  	if (*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_READ {
  8612  		return Xgzclose_r(tls, file)
  8613  	}
  8614  	return Xgzclose_w(tls, file)
  8615  }
  8616  
  8617  // Reset gzip file state
  8618  func gz_reset(tls *libc.TLS, state Gz_statep) { /* gzlib.c:75:12: */
  8619  	(*Gz_state)(unsafe.Pointer(state)).Fx.Fhave = uint32(0)  // no output data available
  8620  	if (*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_READ { // for reading ...
  8621  		(*Gz_state)(unsafe.Pointer(state)).Feof = 0    // not at end of file
  8622  		(*Gz_state)(unsafe.Pointer(state)).Fpast = 0   // have not read past end yet
  8623  		(*Gz_state)(unsafe.Pointer(state)).Fhow = LOOK // look for gzip header
  8624  	}
  8625  	(*Gz_state)(unsafe.Pointer(state)).Fseek = 0                 // no seek request pending
  8626  	Xgz_error(tls, state, Z_OK, uintptr(0))                      // clear error
  8627  	(*Gz_state)(unsafe.Pointer(state)).Fx.Fpos = int64(0)        // no uncompressed data yet
  8628  	(*Gz_state)(unsafe.Pointer(state)).Fstrm.Favail_in = UInt(0) // no input data yet
  8629  }
  8630  
  8631  // Open a gzip file either by name or file descriptor.
  8632  func gz_open(tls *libc.TLS, path uintptr, fd int32, mode uintptr) GzFile { /* gzlib.c:91:14: */
  8633  	bp := tls.Alloc(16)
  8634  	defer tls.Free(16)
  8635  
  8636  	var state Gz_statep
  8637  	var len Z_size_t
  8638  	var oflag int32
  8639  	var cloexec int32 = 0
  8640  	var exclusive int32 = 0
  8641  
  8642  	// check input
  8643  	if path == uintptr(0) {
  8644  		return uintptr(0)
  8645  	}
  8646  
  8647  	// allocate gzFile structure to return
  8648  	state = libc.Xmalloc(tls, uint64(unsafe.Sizeof(Gz_state{})))
  8649  	if state == uintptr(0) {
  8650  		return uintptr(0)
  8651  	}
  8652  	(*Gz_state)(unsafe.Pointer(state)).Fsize = uint32(0)         // no buffers allocated yet
  8653  	(*Gz_state)(unsafe.Pointer(state)).Fwant = uint32(GZBUFSIZE) // requested buffer size
  8654  	(*Gz_state)(unsafe.Pointer(state)).Fmsg = uintptr(0)         // no error message yet
  8655  
  8656  	// interpret mode
  8657  	(*Gz_state)(unsafe.Pointer(state)).Fmode = GZ_NONE
  8658  	(*Gz_state)(unsafe.Pointer(state)).Flevel = -1
  8659  	(*Gz_state)(unsafe.Pointer(state)).Fstrategy = Z_DEFAULT_STRATEGY
  8660  	(*Gz_state)(unsafe.Pointer(state)).Fdirect = 0
  8661  	for *(*uint8)(unsafe.Pointer(mode)) != 0 {
  8662  		if int32(*(*uint8)(unsafe.Pointer(mode))) >= '0' && int32(*(*uint8)(unsafe.Pointer(mode))) <= '9' {
  8663  			(*Gz_state)(unsafe.Pointer(state)).Flevel = int32(*(*uint8)(unsafe.Pointer(mode))) - '0'
  8664  		} else {
  8665  			switch int32(*(*uint8)(unsafe.Pointer(mode))) {
  8666  			case 'r':
  8667  				(*Gz_state)(unsafe.Pointer(state)).Fmode = GZ_READ
  8668  				break
  8669  				fallthrough
  8670  			case 'w':
  8671  				(*Gz_state)(unsafe.Pointer(state)).Fmode = GZ_WRITE
  8672  				break
  8673  				fallthrough
  8674  			case 'a':
  8675  				(*Gz_state)(unsafe.Pointer(state)).Fmode = GZ_APPEND
  8676  				break
  8677  				fallthrough
  8678  			case '+': // can't read and write at the same time
  8679  				libc.Xfree(tls, state)
  8680  				return uintptr(0)
  8681  				fallthrough
  8682  			case 'b': // ignore -- will request binary anyway
  8683  				break
  8684  				fallthrough
  8685  			case 'e':
  8686  				cloexec = 1
  8687  				break
  8688  				fallthrough
  8689  			case 'x':
  8690  				exclusive = 1
  8691  				break
  8692  				fallthrough
  8693  			case 'f':
  8694  				(*Gz_state)(unsafe.Pointer(state)).Fstrategy = Z_FILTERED
  8695  				break
  8696  				fallthrough
  8697  			case 'h':
  8698  				(*Gz_state)(unsafe.Pointer(state)).Fstrategy = Z_HUFFMAN_ONLY
  8699  				break
  8700  				fallthrough
  8701  			case 'R':
  8702  				(*Gz_state)(unsafe.Pointer(state)).Fstrategy = Z_RLE
  8703  				break
  8704  				fallthrough
  8705  			case 'F':
  8706  				(*Gz_state)(unsafe.Pointer(state)).Fstrategy = Z_FIXED
  8707  				break
  8708  				fallthrough
  8709  			case 'T':
  8710  				(*Gz_state)(unsafe.Pointer(state)).Fdirect = 1
  8711  				break
  8712  				fallthrough
  8713  			default: // could consider as an error, but just ignore
  8714  
  8715  			}
  8716  		}
  8717  		mode++
  8718  	}
  8719  
  8720  	// must provide an "r", "w", or "a"
  8721  	if (*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_NONE {
  8722  		libc.Xfree(tls, state)
  8723  		return uintptr(0)
  8724  	}
  8725  
  8726  	// can't force transparent read
  8727  	if (*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_READ {
  8728  		if (*Gz_state)(unsafe.Pointer(state)).Fdirect != 0 {
  8729  			libc.Xfree(tls, state)
  8730  			return uintptr(0)
  8731  		}
  8732  		(*Gz_state)(unsafe.Pointer(state)).Fdirect = 1 // for empty file
  8733  	}
  8734  
  8735  	// save the path name for error messages
  8736  	len = libc.Xstrlen(tls, path)
  8737  	(*Gz_state)(unsafe.Pointer(state)).Fpath = libc.Xmalloc(tls, len+uint64(1))
  8738  	if (*Gz_state)(unsafe.Pointer(state)).Fpath == uintptr(0) {
  8739  		libc.Xfree(tls, state)
  8740  		return uintptr(0)
  8741  	}
  8742  	libc.Xsnprintf(tls, (*Gz_state)(unsafe.Pointer(state)).Fpath, len+uint64(1), ts+76, libc.VaList(bp, path))
  8743  
  8744  	// compute the flags for open()
  8745  	oflag = 0 | func() int32 {
  8746  		if cloexec != 0 {
  8747  			return 02000000
  8748  		}
  8749  		return 0
  8750  	}() | func() int32 {
  8751  		if (*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_READ {
  8752  			return O_RDONLY
  8753  		}
  8754  		return O_WRONLY | O_CREAT | func() int32 {
  8755  			if exclusive != 0 {
  8756  				return O_EXCL
  8757  			}
  8758  			return 0
  8759  		}() | func() int32 {
  8760  			if (*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_WRITE {
  8761  				return O_TRUNC
  8762  			}
  8763  			return O_APPEND
  8764  		}()
  8765  	}()
  8766  
  8767  	// open the file with the appropriate flags (or just use fd)
  8768  	(*Gz_state)(unsafe.Pointer(state)).Ffd = func() int32 {
  8769  		if fd > -1 {
  8770  			return fd
  8771  		}
  8772  		return libc.Xopen(tls, path, oflag, libc.VaList(bp+8, 0666))
  8773  	}()
  8774  	if (*Gz_state)(unsafe.Pointer(state)).Ffd == -1 {
  8775  		libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fpath)
  8776  		libc.Xfree(tls, state)
  8777  		return uintptr(0)
  8778  	}
  8779  	if (*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_APPEND {
  8780  		libc.Xlseek64(tls, (*Gz_state)(unsafe.Pointer(state)).Ffd, int64(0), SEEK_END) // so gzoffset() is correct
  8781  		(*Gz_state)(unsafe.Pointer(state)).Fmode = GZ_WRITE                            // simplify later checks
  8782  	}
  8783  
  8784  	// save the current position for rewinding (only if reading)
  8785  	if (*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_READ {
  8786  		(*Gz_state)(unsafe.Pointer(state)).Fstart = libc.Xlseek64(tls, (*Gz_state)(unsafe.Pointer(state)).Ffd, int64(0), SEEK_CUR)
  8787  		if (*Gz_state)(unsafe.Pointer(state)).Fstart == int64(-1) {
  8788  			(*Gz_state)(unsafe.Pointer(state)).Fstart = int64(0)
  8789  		}
  8790  	}
  8791  
  8792  	// initialize stream
  8793  	gz_reset(tls, state)
  8794  
  8795  	// return stream
  8796  	return state
  8797  }
  8798  
  8799  // -- see zlib.h --
  8800  func Xgzopen(tls *libc.TLS, path uintptr, mode uintptr) GzFile { /* gzlib.c:270:16: */
  8801  	return gz_open(tls, path, -1, mode)
  8802  }
  8803  
  8804  // -- see zlib.h --
  8805  func Xgzopen64(tls *libc.TLS, path uintptr, mode uintptr) GzFile { /* gzlib.c:278:16: */
  8806  	return gz_open(tls, path, -1, mode)
  8807  }
  8808  
  8809  // -- see zlib.h --
  8810  func Xgzdopen(tls *libc.TLS, fd int32, mode uintptr) GzFile { /* gzlib.c:286:16: */
  8811  	bp := tls.Alloc(8)
  8812  	defer tls.Free(8)
  8813  
  8814  	var path uintptr // identifier for error messages
  8815  	var gz GzFile
  8816  
  8817  	if fd == -1 || libc.AssignUintptr(&path, libc.Xmalloc(tls, uint64(7)+uint64(3)*uint64(unsafe.Sizeof(int32(0))))) == uintptr(0) {
  8818  		return uintptr(0)
  8819  	}
  8820  	libc.Xsnprintf(tls, path, uint64(7)+uint64(3)*uint64(unsafe.Sizeof(int32(0))), ts+79, libc.VaList(bp, fd))
  8821  	gz = gz_open(tls, path, fd, mode)
  8822  	libc.Xfree(tls, path)
  8823  	return gz
  8824  }
  8825  
  8826  // -- see zlib.h --
  8827  
  8828  // -- see zlib.h --
  8829  func Xgzbuffer(tls *libc.TLS, file GzFile, size uint32) int32 { /* gzlib.c:316:13: */
  8830  	var state Gz_statep
  8831  
  8832  	// get internal structure and check integrity
  8833  	if file == uintptr(0) {
  8834  		return -1
  8835  	}
  8836  	state = file
  8837  	if (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ && (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE {
  8838  		return -1
  8839  	}
  8840  
  8841  	// make sure we haven't already allocated memory
  8842  	if (*Gz_state)(unsafe.Pointer(state)).Fsize != uint32(0) {
  8843  		return -1
  8844  	}
  8845  
  8846  	// check and set requested size
  8847  	if size<<1 < size {
  8848  		return -1
  8849  	} // need to be able to double it
  8850  	if size < uint32(2) {
  8851  		size = uint32(2)
  8852  	} // need two bytes to check magic header
  8853  	(*Gz_state)(unsafe.Pointer(state)).Fwant = size
  8854  	return 0
  8855  }
  8856  
  8857  // -- see zlib.h --
  8858  func Xgzrewind(tls *libc.TLS, file GzFile) int32 { /* gzlib.c:343:13: */
  8859  	var state Gz_statep
  8860  
  8861  	// get internal structure
  8862  	if file == uintptr(0) {
  8863  		return -1
  8864  	}
  8865  	state = file
  8866  
  8867  	// check that we're reading and that there's no error
  8868  	if (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ || (*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK && (*Gz_state)(unsafe.Pointer(state)).Ferr != -5 {
  8869  		return -1
  8870  	}
  8871  
  8872  	// back up and start over
  8873  	if libc.Xlseek64(tls, (*Gz_state)(unsafe.Pointer(state)).Ffd, (*Gz_state)(unsafe.Pointer(state)).Fstart, SEEK_SET) == int64(-1) {
  8874  		return -1
  8875  	}
  8876  	gz_reset(tls, state)
  8877  	return 0
  8878  }
  8879  
  8880  // -- see zlib.h --
  8881  func Xgzseek64(tls *libc.TLS, file GzFile, offset Off64_t, whence int32) Off64_t { /* gzlib.c:366:19: */
  8882  	var n uint32
  8883  	var ret Off64_t
  8884  	var state Gz_statep
  8885  
  8886  	// get internal structure and check integrity
  8887  	if file == uintptr(0) {
  8888  		return int64(-1)
  8889  	}
  8890  	state = file
  8891  	if (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ && (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE {
  8892  		return int64(-1)
  8893  	}
  8894  
  8895  	// check that there's no error
  8896  	if (*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK && (*Gz_state)(unsafe.Pointer(state)).Ferr != -5 {
  8897  		return int64(-1)
  8898  	}
  8899  
  8900  	// can only seek from start or relative to current position
  8901  	if whence != SEEK_SET && whence != SEEK_CUR {
  8902  		return int64(-1)
  8903  	}
  8904  
  8905  	// normalize offset to a SEEK_CUR specification
  8906  	if whence == SEEK_SET {
  8907  		offset = offset - (*Gz_state)(unsafe.Pointer(state)).Fx.Fpos
  8908  	} else if (*Gz_state)(unsafe.Pointer(state)).Fseek != 0 {
  8909  		offset = offset + (*Gz_state)(unsafe.Pointer(state)).Fskip
  8910  	}
  8911  	(*Gz_state)(unsafe.Pointer(state)).Fseek = 0
  8912  
  8913  	// if within raw area while reading, just go there
  8914  	if (*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_READ && (*Gz_state)(unsafe.Pointer(state)).Fhow == COPY1 && (*Gz_state)(unsafe.Pointer(state)).Fx.Fpos+offset >= int64(0) {
  8915  		ret = libc.Xlseek64(tls, (*Gz_state)(unsafe.Pointer(state)).Ffd, offset-Off64_t((*Gz_state)(unsafe.Pointer(state)).Fx.Fhave), SEEK_CUR)
  8916  		if ret == int64(-1) {
  8917  			return int64(-1)
  8918  		}
  8919  		(*Gz_state)(unsafe.Pointer(state)).Fx.Fhave = uint32(0)
  8920  		(*Gz_state)(unsafe.Pointer(state)).Feof = 0
  8921  		(*Gz_state)(unsafe.Pointer(state)).Fpast = 0
  8922  		(*Gz_state)(unsafe.Pointer(state)).Fseek = 0
  8923  		Xgz_error(tls, state, Z_OK, uintptr(0))
  8924  		(*Gz_state)(unsafe.Pointer(state)).Fstrm.Favail_in = UInt(0)
  8925  		*(*Off64_t)(unsafe.Pointer(state + 16)) += offset
  8926  		return (*Gz_state)(unsafe.Pointer(state)).Fx.Fpos
  8927  	}
  8928  
  8929  	// calculate skip amount, rewinding if needed for back seek when reading
  8930  	if offset < int64(0) {
  8931  		if (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ { // writing -- can't go backwards
  8932  			return int64(-1)
  8933  		}
  8934  		offset = offset + (*Gz_state)(unsafe.Pointer(state)).Fx.Fpos
  8935  		if offset < int64(0) { // before start of file!
  8936  			return int64(-1)
  8937  		}
  8938  		if Xgzrewind(tls, file) == -1 { // rewind, then skip to offset
  8939  			return int64(-1)
  8940  		}
  8941  	}
  8942  
  8943  	// if reading, skip what's in output buffer (one less gzgetc() check)
  8944  	if (*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_READ {
  8945  		if uint64(unsafe.Sizeof(int32(0))) == uint64(unsafe.Sizeof(Off64_t(0))) && (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave > uint32(0x7fffffff) || Off64_t((*Gz_state)(unsafe.Pointer(state)).Fx.Fhave) > offset {
  8946  			n = uint32(offset)
  8947  		} else {
  8948  			n = (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave
  8949  		}
  8950  		*(*uint32)(unsafe.Pointer(state)) -= n
  8951  		*(*uintptr)(unsafe.Pointer(state + 8)) += uintptr(n)
  8952  		*(*Off64_t)(unsafe.Pointer(state + 16)) += Off64_t(n)
  8953  		offset = offset - Off64_t(n)
  8954  	}
  8955  
  8956  	// request skip (if not zero)
  8957  	if offset != 0 {
  8958  		(*Gz_state)(unsafe.Pointer(state)).Fseek = 1
  8959  		(*Gz_state)(unsafe.Pointer(state)).Fskip = offset
  8960  	}
  8961  	return (*Gz_state)(unsafe.Pointer(state)).Fx.Fpos + offset
  8962  }
  8963  
  8964  // -- see zlib.h --
  8965  func Xgzseek(tls *libc.TLS, file GzFile, offset Off_t, whence int32) Off_t { /* gzlib.c:443:17: */
  8966  	var ret Off64_t
  8967  
  8968  	ret = Xgzseek64(tls, file, offset, whence)
  8969  	if ret == ret {
  8970  		return ret
  8971  	}
  8972  	return int64(-1)
  8973  }
  8974  
  8975  // -- see zlib.h --
  8976  func Xgztell64(tls *libc.TLS, file GzFile) Off64_t { /* gzlib.c:455:19: */
  8977  	var state Gz_statep
  8978  
  8979  	// get internal structure and check integrity
  8980  	if file == uintptr(0) {
  8981  		return int64(-1)
  8982  	}
  8983  	state = file
  8984  	if (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ && (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE {
  8985  		return int64(-1)
  8986  	}
  8987  
  8988  	// return position
  8989  	return (*Gz_state)(unsafe.Pointer(state)).Fx.Fpos + func() int64 {
  8990  		if (*Gz_state)(unsafe.Pointer(state)).Fseek != 0 {
  8991  			return (*Gz_state)(unsafe.Pointer(state)).Fskip
  8992  		}
  8993  		return int64(0)
  8994  	}()
  8995  }
  8996  
  8997  // -- see zlib.h --
  8998  func Xgztell(tls *libc.TLS, file GzFile) Off_t { /* gzlib.c:472:17: */
  8999  	var ret Off64_t
  9000  
  9001  	ret = Xgztell64(tls, file)
  9002  	if ret == ret {
  9003  		return ret
  9004  	}
  9005  	return int64(-1)
  9006  }
  9007  
  9008  // -- see zlib.h --
  9009  func Xgzoffset64(tls *libc.TLS, file GzFile) Off64_t { /* gzlib.c:482:19: */
  9010  	var offset Off64_t
  9011  	var state Gz_statep
  9012  
  9013  	// get internal structure and check integrity
  9014  	if file == uintptr(0) {
  9015  		return int64(-1)
  9016  	}
  9017  	state = file
  9018  	if (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ && (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE {
  9019  		return int64(-1)
  9020  	}
  9021  
  9022  	// compute and return effective offset in file
  9023  	offset = libc.Xlseek64(tls, (*Gz_state)(unsafe.Pointer(state)).Ffd, int64(0), SEEK_CUR)
  9024  	if offset == int64(-1) {
  9025  		return int64(-1)
  9026  	}
  9027  	if (*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_READ { // reading
  9028  		offset = offset - Off64_t((*Gz_state)(unsafe.Pointer(state)).Fstrm.Favail_in)
  9029  	} // don't count buffered input
  9030  	return offset
  9031  }
  9032  
  9033  // -- see zlib.h --
  9034  func Xgzoffset(tls *libc.TLS, file GzFile) Off_t { /* gzlib.c:505:17: */
  9035  	var ret Off64_t
  9036  
  9037  	ret = Xgzoffset64(tls, file)
  9038  	if ret == ret {
  9039  		return ret
  9040  	}
  9041  	return int64(-1)
  9042  }
  9043  
  9044  // -- see zlib.h --
  9045  func Xgzeof(tls *libc.TLS, file GzFile) int32 { /* gzlib.c:515:13: */
  9046  	var state Gz_statep
  9047  
  9048  	// get internal structure and check integrity
  9049  	if file == uintptr(0) {
  9050  		return 0
  9051  	}
  9052  	state = file
  9053  	if (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ && (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE {
  9054  		return 0
  9055  	}
  9056  
  9057  	// return end-of-file state
  9058  	if (*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_READ {
  9059  		return (*Gz_state)(unsafe.Pointer(state)).Fpast
  9060  	}
  9061  	return 0
  9062  }
  9063  
  9064  // -- see zlib.h --
  9065  func Xgzerror(tls *libc.TLS, file GzFile, errnum uintptr) uintptr { /* gzlib.c:532:12: */
  9066  	var state Gz_statep
  9067  
  9068  	// get internal structure and check integrity
  9069  	if file == uintptr(0) {
  9070  		return uintptr(0)
  9071  	}
  9072  	state = file
  9073  	if (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ && (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE {
  9074  		return uintptr(0)
  9075  	}
  9076  
  9077  	// return error information
  9078  	if errnum != uintptr(0) {
  9079  		*(*int32)(unsafe.Pointer(errnum)) = (*Gz_state)(unsafe.Pointer(state)).Ferr
  9080  	}
  9081  	if (*Gz_state)(unsafe.Pointer(state)).Ferr == -4 {
  9082  		return ts + 87 /* "out of memory" */
  9083  	}
  9084  	return func() uintptr {
  9085  		if (*Gz_state)(unsafe.Pointer(state)).Fmsg == uintptr(0) {
  9086  			return ts + 101
  9087  		}
  9088  		return (*Gz_state)(unsafe.Pointer(state)).Fmsg
  9089  	}()
  9090  }
  9091  
  9092  // -- see zlib.h --
  9093  func Xgzclearerr(tls *libc.TLS, file GzFile) { /* gzlib.c:553:14: */
  9094  	var state Gz_statep
  9095  
  9096  	// get internal structure and check integrity
  9097  	if file == uintptr(0) {
  9098  		return
  9099  	}
  9100  	state = file
  9101  	if (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ && (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE {
  9102  		return
  9103  	}
  9104  
  9105  	// clear error and end-of-file
  9106  	if (*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_READ {
  9107  		(*Gz_state)(unsafe.Pointer(state)).Feof = 0
  9108  		(*Gz_state)(unsafe.Pointer(state)).Fpast = 0
  9109  	}
  9110  	Xgz_error(tls, state, Z_OK, uintptr(0))
  9111  }
  9112  
  9113  // Create an error message in allocated memory and set state->err and
  9114  //    state->msg accordingly.  Free any previous error message already there.  Do
  9115  //    not try to free or allocate space if the error is Z_MEM_ERROR (out of
  9116  //    memory).  Simply save the error message as a static string.  If there is an
  9117  //    allocation failure constructing the error message, then convert the error to
  9118  //    out of memory.
  9119  func Xgz_error(tls *libc.TLS, state Gz_statep, err int32, msg uintptr) { /* gzlib.c:579:20: */
  9120  	bp := tls.Alloc(24)
  9121  	defer tls.Free(24)
  9122  
  9123  	// free previously allocated message and clear
  9124  	if (*Gz_state)(unsafe.Pointer(state)).Fmsg != uintptr(0) {
  9125  		if (*Gz_state)(unsafe.Pointer(state)).Ferr != -4 {
  9126  			libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fmsg)
  9127  		}
  9128  		(*Gz_state)(unsafe.Pointer(state)).Fmsg = uintptr(0)
  9129  	}
  9130  
  9131  	// if fatal, set state->x.have to 0 so that the gzgetc() macro fails
  9132  	if err != Z_OK && err != -5 {
  9133  		(*Gz_state)(unsafe.Pointer(state)).Fx.Fhave = uint32(0)
  9134  	}
  9135  
  9136  	// set error code, and if no message, then done
  9137  	(*Gz_state)(unsafe.Pointer(state)).Ferr = err
  9138  	if msg == uintptr(0) {
  9139  		return
  9140  	}
  9141  
  9142  	// for an out of memory error, return literal string when requested
  9143  	if err == -4 {
  9144  		return
  9145  	}
  9146  
  9147  	// construct error message with path
  9148  	if libc.AssignPtrUintptr(state+112, libc.Xmalloc(tls, libc.Xstrlen(tls, (*Gz_state)(unsafe.Pointer(state)).Fpath)+libc.Xstrlen(tls, msg)+uint64(3))) == uintptr(0) {
  9149  		(*Gz_state)(unsafe.Pointer(state)).Ferr = -4
  9150  		return
  9151  	}
  9152  	libc.Xsnprintf(tls, (*Gz_state)(unsafe.Pointer(state)).Fmsg, libc.Xstrlen(tls, (*Gz_state)(unsafe.Pointer(state)).Fpath)+libc.Xstrlen(tls, msg)+uint64(3),
  9153  		ts+102, libc.VaList(bp, (*Gz_state)(unsafe.Pointer(state)).Fpath, ts+109, msg))
  9154  }
  9155  
  9156  // Use read() to load a buffer -- return -1 on error, otherwise 0.  Read from
  9157  //    state->fd, and update state->eof, state->err, and state->msg as appropriate.
  9158  //    This function needs to loop on read(), since read() is not guaranteed to
  9159  //    read the number of bytes requested, depending on the type of descriptor.
  9160  func gz_load(tls *libc.TLS, state Gz_statep, buf uintptr, len uint32, have uintptr) int32 { /* gzread.c:21:11: */
  9161  	var ret int32
  9162  	var get uint32
  9163  	var max uint32 = uint32(libc.Uint32(libc.Uint32FromInt32(-1)))>>2 + uint32(1)
  9164  
  9165  	*(*uint32)(unsafe.Pointer(have)) = uint32(0)
  9166  	for __ccgo := true; __ccgo; __ccgo = *(*uint32)(unsafe.Pointer(have)) < len {
  9167  		get = len - *(*uint32)(unsafe.Pointer(have))
  9168  		if get > max {
  9169  			get = max
  9170  		}
  9171  		ret = int32(libc.Xread(tls, (*Gz_state)(unsafe.Pointer(state)).Ffd, buf+uintptr(*(*uint32)(unsafe.Pointer(have))), uint64(get)))
  9172  		if ret <= 0 {
  9173  			break
  9174  		}
  9175  		*(*uint32)(unsafe.Pointer(have)) += uint32(ret)
  9176  	}
  9177  	if ret < 0 {
  9178  		Xgz_error(tls, state, -1, libc.Xstrerror(tls, *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))))
  9179  		return -1
  9180  	}
  9181  	if ret == 0 {
  9182  		(*Gz_state)(unsafe.Pointer(state)).Feof = 1
  9183  	}
  9184  	return 0
  9185  }
  9186  
  9187  // Load up input buffer and set eof flag if last data loaded -- return -1 on
  9188  //    error, 0 otherwise.  Note that the eof flag is set when the end of the input
  9189  //    file is reached, even though there may be unused data in the buffer.  Once
  9190  //    that data has been used, no more attempts will be made to read the file.
  9191  //    If strm->avail_in != 0, then the current data is moved to the beginning of
  9192  //    the input buffer, and then the remainder of the buffer is loaded with the
  9193  //    available data from the input file.
  9194  func gz_avail(tls *libc.TLS, state Gz_statep) int32 { /* gzread.c:56:11: */
  9195  	bp := tls.Alloc(4)
  9196  	defer tls.Free(4)
  9197  
  9198  	// var got uint32 at bp, 4
  9199  
  9200  	var strm Z_streamp = state + 120
  9201  
  9202  	if (*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK && (*Gz_state)(unsafe.Pointer(state)).Ferr != -5 {
  9203  		return -1
  9204  	}
  9205  	if (*Gz_state)(unsafe.Pointer(state)).Feof == 0 {
  9206  		if (*Z_stream)(unsafe.Pointer(strm)).Favail_in != 0 { // copy what's there to the start
  9207  			var p uintptr = (*Gz_state)(unsafe.Pointer(state)).Fin
  9208  			var q uintptr = (*Z_stream)(unsafe.Pointer(strm)).Fnext_in
  9209  			var n uint32 = (*Z_stream)(unsafe.Pointer(strm)).Favail_in
  9210  			for __ccgo := true; __ccgo; __ccgo = libc.PreDecUint32(&n, 1) != 0 {
  9211  				*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&p, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&q, 1)))
  9212  			}
  9213  		}
  9214  		if gz_load(tls, state, (*Gz_state)(unsafe.Pointer(state)).Fin+uintptr((*Z_stream)(unsafe.Pointer(strm)).Favail_in),
  9215  			(*Gz_state)(unsafe.Pointer(state)).Fsize-(*Z_stream)(unsafe.Pointer(strm)).Favail_in, bp) == -1 {
  9216  			return -1
  9217  		}
  9218  		*(*UInt)(unsafe.Pointer(strm + 8)) += *(*uint32)(unsafe.Pointer(bp))
  9219  		(*Z_stream)(unsafe.Pointer(strm)).Fnext_in = (*Gz_state)(unsafe.Pointer(state)).Fin
  9220  	}
  9221  	return 0
  9222  }
  9223  
  9224  // Look for gzip header, set up for inflate or copy.  state->x.have must be 0.
  9225  //    If this is the first time in, allocate required memory.  state->how will be
  9226  //    left unchanged if there is no more input data available, will be set to COPY
  9227  //    if there is no gzip header and direct copying will be performed, or it will
  9228  //    be set to GZIP for decompression.  If direct copying, then leftover input
  9229  //    data from the input buffer will be copied to the output buffer.  In that
  9230  //    case, all further file reads will be directly to either the output buffer or
  9231  //    a user buffer.  If decompressing, the inflate state will be initialized.
  9232  //    gz_look() will return 0 on success or -1 on failure.
  9233  func gz_look(tls *libc.TLS, state Gz_statep) int32 { /* gzread.c:91:11: */
  9234  	var strm Z_streamp = state + 120
  9235  
  9236  	// allocate read buffers and inflate memory
  9237  	if (*Gz_state)(unsafe.Pointer(state)).Fsize == uint32(0) {
  9238  		// allocate buffers
  9239  		(*Gz_state)(unsafe.Pointer(state)).Fin = libc.Xmalloc(tls, uint64((*Gz_state)(unsafe.Pointer(state)).Fwant))
  9240  		(*Gz_state)(unsafe.Pointer(state)).Fout = libc.Xmalloc(tls, uint64((*Gz_state)(unsafe.Pointer(state)).Fwant<<1))
  9241  		if (*Gz_state)(unsafe.Pointer(state)).Fin == uintptr(0) || (*Gz_state)(unsafe.Pointer(state)).Fout == uintptr(0) {
  9242  			libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fout)
  9243  			libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fin)
  9244  			Xgz_error(tls, state, -4, ts+87)
  9245  			return -1
  9246  		}
  9247  		(*Gz_state)(unsafe.Pointer(state)).Fsize = (*Gz_state)(unsafe.Pointer(state)).Fwant
  9248  
  9249  		// allocate inflate memory
  9250  		(*Gz_state)(unsafe.Pointer(state)).Fstrm.Fzalloc = Alloc_func(Z_NULL)
  9251  		(*Gz_state)(unsafe.Pointer(state)).Fstrm.Fzfree = Free_func(Z_NULL)
  9252  		(*Gz_state)(unsafe.Pointer(state)).Fstrm.Fopaque = Voidpf(Z_NULL)
  9253  		(*Gz_state)(unsafe.Pointer(state)).Fstrm.Favail_in = UInt(0)
  9254  		(*Gz_state)(unsafe.Pointer(state)).Fstrm.Fnext_in = uintptr(Z_NULL)
  9255  		if XinflateInit2_(tls, state+120, 15+16, ts, int32(unsafe.Sizeof(Z_stream{}))) != Z_OK { // gunzip
  9256  			libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fout)
  9257  			libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fin)
  9258  			(*Gz_state)(unsafe.Pointer(state)).Fsize = uint32(0)
  9259  			Xgz_error(tls, state, -4, ts+87)
  9260  			return -1
  9261  		}
  9262  	}
  9263  
  9264  	// get at least the magic bytes in the input buffer
  9265  	if (*Z_stream)(unsafe.Pointer(strm)).Favail_in < UInt(2) {
  9266  		if gz_avail(tls, state) == -1 {
  9267  			return -1
  9268  		}
  9269  		if (*Z_stream)(unsafe.Pointer(strm)).Favail_in == UInt(0) {
  9270  			return 0
  9271  		}
  9272  	}
  9273  
  9274  	// look for gzip magic bytes -- if there, do gzip decoding (note: there is
  9275  	//        a logical dilemma here when considering the case of a partially written
  9276  	//        gzip file, to wit, if a single 31 byte is written, then we cannot tell
  9277  	//        whether this is a single-byte file, or just a partially written gzip
  9278  	//        file -- for here we assume that if a gzip file is being written, then
  9279  	//        the header will be written in a single operation, so that reading a
  9280  	//        single byte is sufficient indication that it is not a gzip file)
  9281  	if (*Z_stream)(unsafe.Pointer(strm)).Favail_in > UInt(1) && int32(*(*Bytef)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fnext_in))) == 31 && int32(*(*Bytef)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fnext_in + 1))) == 139 {
  9282  		XinflateReset(tls, strm)
  9283  		(*Gz_state)(unsafe.Pointer(state)).Fhow = /* GZIP */ 2
  9284  		(*Gz_state)(unsafe.Pointer(state)).Fdirect = 0
  9285  		return 0
  9286  	}
  9287  
  9288  	// no gzip header -- if we were decoding gzip before, then this is trailing
  9289  	//        garbage.  Ignore the trailing garbage and finish.
  9290  	if (*Gz_state)(unsafe.Pointer(state)).Fdirect == 0 {
  9291  		(*Z_stream)(unsafe.Pointer(strm)).Favail_in = UInt(0)
  9292  		(*Gz_state)(unsafe.Pointer(state)).Feof = 1
  9293  		(*Gz_state)(unsafe.Pointer(state)).Fx.Fhave = uint32(0)
  9294  		return 0
  9295  	}
  9296  
  9297  	// doing raw i/o, copy any leftover input to output -- this assumes that
  9298  	//        the output buffer is larger than the input buffer, which also assures
  9299  	//        space for gzungetc()
  9300  	(*Gz_state)(unsafe.Pointer(state)).Fx.Fnext = (*Gz_state)(unsafe.Pointer(state)).Fout
  9301  	if (*Z_stream)(unsafe.Pointer(strm)).Favail_in != 0 {
  9302  		libc.Xmemcpy(tls, (*Gz_state)(unsafe.Pointer(state)).Fx.Fnext, (*Z_stream)(unsafe.Pointer(strm)).Fnext_in, uint64((*Z_stream)(unsafe.Pointer(strm)).Favail_in))
  9303  		(*Gz_state)(unsafe.Pointer(state)).Fx.Fhave = (*Z_stream)(unsafe.Pointer(strm)).Favail_in
  9304  		(*Z_stream)(unsafe.Pointer(strm)).Favail_in = UInt(0)
  9305  	}
  9306  	(*Gz_state)(unsafe.Pointer(state)).Fhow = COPY1
  9307  	(*Gz_state)(unsafe.Pointer(state)).Fdirect = 1
  9308  	return 0
  9309  }
  9310  
  9311  // Decompress from input to the provided next_out and avail_out in the state.
  9312  //    On return, state->x.have and state->x.next point to the just decompressed
  9313  //    data.  If the gzip stream completes, state->how is reset to LOOK to look for
  9314  //    the next gzip stream or raw data, once state->x.have is depleted.  Returns 0
  9315  //    on success, -1 on failure.
  9316  func gz_decomp(tls *libc.TLS, state Gz_statep) int32 { /* gzread.c:175:11: */
  9317  	var ret int32 = Z_OK
  9318  	var had uint32
  9319  	var strm Z_streamp = state + 120
  9320  
  9321  	// fill output buffer up to end of deflate stream
  9322  	had = (*Z_stream)(unsafe.Pointer(strm)).Favail_out
  9323  	for __ccgo := true; __ccgo; __ccgo = (*Z_stream)(unsafe.Pointer(strm)).Favail_out != 0 && ret != Z_STREAM_END {
  9324  		// get more input for inflate()
  9325  		if (*Z_stream)(unsafe.Pointer(strm)).Favail_in == UInt(0) && gz_avail(tls, state) == -1 {
  9326  			return -1
  9327  		}
  9328  		if (*Z_stream)(unsafe.Pointer(strm)).Favail_in == UInt(0) {
  9329  			Xgz_error(tls, state, -5, ts+112)
  9330  			break
  9331  		}
  9332  
  9333  		// decompress and handle errors
  9334  		ret = Xinflate(tls, strm, Z_NO_FLUSH)
  9335  		if ret == -2 || ret == Z_NEED_DICT {
  9336  			Xgz_error(tls, state, -2,
  9337  				ts+135)
  9338  			return -1
  9339  		}
  9340  		if ret == -4 {
  9341  			Xgz_error(tls, state, -4, ts+87)
  9342  			return -1
  9343  		}
  9344  		if ret == -3 { // deflate stream invalid
  9345  			Xgz_error(tls, state, -3,
  9346  				func() uintptr {
  9347  					if (*Z_stream)(unsafe.Pointer(strm)).Fmsg == uintptr(0) {
  9348  						return ts + 174 /* "compressed data ..." */
  9349  					}
  9350  					return (*Z_stream)(unsafe.Pointer(strm)).Fmsg
  9351  				}())
  9352  			return -1
  9353  		}
  9354  	}
  9355  
  9356  	// update available output
  9357  	(*Gz_state)(unsafe.Pointer(state)).Fx.Fhave = had - (*Z_stream)(unsafe.Pointer(strm)).Favail_out
  9358  	(*Gz_state)(unsafe.Pointer(state)).Fx.Fnext = (*Z_stream)(unsafe.Pointer(strm)).Fnext_out - uintptr((*Gz_state)(unsafe.Pointer(state)).Fx.Fhave)
  9359  
  9360  	// if the gzip stream completed successfully, look for another
  9361  	if ret == Z_STREAM_END {
  9362  		(*Gz_state)(unsafe.Pointer(state)).Fhow = LOOK
  9363  	}
  9364  
  9365  	// good decompression
  9366  	return 0
  9367  }
  9368  
  9369  // Fetch data and put it in the output buffer.  Assumes state->x.have is 0.
  9370  //    Data is either copied from the input file or decompressed from the input
  9371  //    file depending on state->how.  If state->how is LOOK, then a gzip header is
  9372  //    looked for to determine whether to copy or decompress.  Returns -1 on error,
  9373  //    otherwise 0.  gz_fetch() will leave state->how as COPY or GZIP unless the
  9374  //    end of the input file has been reached and all data has been processed.
  9375  func gz_fetch(tls *libc.TLS, state Gz_statep) int32 { /* gzread.c:229:11: */
  9376  	var strm Z_streamp = state + 120
  9377  
  9378  	for __ccgo := true; __ccgo; __ccgo = (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave == uint32(0) && (!((*Gz_state)(unsafe.Pointer(state)).Feof != 0) || (*Z_stream)(unsafe.Pointer(strm)).Favail_in != 0) {
  9379  		switch (*Gz_state)(unsafe.Pointer(state)).Fhow {
  9380  		case LOOK: // -> LOOK, COPY (only if never GZIP), or GZIP
  9381  			if gz_look(tls, state) == -1 {
  9382  				return -1
  9383  			}
  9384  			if (*Gz_state)(unsafe.Pointer(state)).Fhow == LOOK {
  9385  				return 0
  9386  			}
  9387  			break
  9388  		case COPY1: // -> COPY
  9389  			if gz_load(tls, state, (*Gz_state)(unsafe.Pointer(state)).Fout, (*Gz_state)(unsafe.Pointer(state)).Fsize<<1, state) ==
  9390  				-1 {
  9391  				return -1
  9392  			}
  9393  			(*Gz_state)(unsafe.Pointer(state)).Fx.Fnext = (*Gz_state)(unsafe.Pointer(state)).Fout
  9394  			return 0
  9395  		case /* GZIP */ 2: // -> GZIP or LOOK (if end of gzip stream)
  9396  			(*Z_stream)(unsafe.Pointer(strm)).Favail_out = (*Gz_state)(unsafe.Pointer(state)).Fsize << 1
  9397  			(*Z_stream)(unsafe.Pointer(strm)).Fnext_out = (*Gz_state)(unsafe.Pointer(state)).Fout
  9398  			if gz_decomp(tls, state) == -1 {
  9399  				return -1
  9400  			}
  9401  		}
  9402  	}
  9403  	return 0
  9404  }
  9405  
  9406  // Skip len uncompressed bytes of output.  Return -1 on error, 0 on success.
  9407  func gz_skip(tls *libc.TLS, state Gz_statep, len Off64_t) int32 { /* gzread.c:259:11: */
  9408  	var n uint32
  9409  
  9410  	// skip over len bytes or reach end-of-file, whichever comes first
  9411  	for len != 0 {
  9412  		// skip over whatever is in output buffer
  9413  		if (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave != 0 {
  9414  			if uint64(unsafe.Sizeof(int32(0))) == uint64(unsafe.Sizeof(Off64_t(0))) && (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave > uint32(0x7fffffff) || Off64_t((*Gz_state)(unsafe.Pointer(state)).Fx.Fhave) > len {
  9415  				n = uint32(len)
  9416  			} else {
  9417  				n = (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave
  9418  			}
  9419  			*(*uint32)(unsafe.Pointer(state)) -= n
  9420  			*(*uintptr)(unsafe.Pointer(state + 8)) += uintptr(n)
  9421  			*(*Off64_t)(unsafe.Pointer(state + 16)) += Off64_t(n)
  9422  			len = len - Off64_t(n)
  9423  		} else if (*Gz_state)(unsafe.Pointer(state)).Feof != 0 && (*Gz_state)(unsafe.Pointer(state)).Fstrm.Favail_in == UInt(0) {
  9424  			break
  9425  		} else {
  9426  			// get more output, looking for header if required
  9427  			if gz_fetch(tls, state) == -1 {
  9428  				return -1
  9429  			}
  9430  		}
  9431  	}
  9432  	return 0
  9433  }
  9434  
  9435  // Read len bytes into buf from file, or less than len up to the end of the
  9436  //    input.  Return the number of bytes read.  If zero is returned, either the
  9437  //    end of file was reached, or there was an error.  state->err must be
  9438  //    consulted in that case to determine which.
  9439  func gz_read(tls *libc.TLS, state Gz_statep, buf Voidp, len Z_size_t) Z_size_t { /* gzread.c:294:16: */
  9440  	bp := tls.Alloc(4)
  9441  	defer tls.Free(4)
  9442  
  9443  	var got Z_size_t
  9444  	// var n uint32 at bp, 4
  9445  
  9446  	// if len is zero, avoid unnecessary operations
  9447  	if len == uint64(0) {
  9448  		return uint64(0)
  9449  	}
  9450  
  9451  	// process a skip request
  9452  	if (*Gz_state)(unsafe.Pointer(state)).Fseek != 0 {
  9453  		(*Gz_state)(unsafe.Pointer(state)).Fseek = 0
  9454  		if gz_skip(tls, state, (*Gz_state)(unsafe.Pointer(state)).Fskip) == -1 {
  9455  			return uint64(0)
  9456  		}
  9457  	}
  9458  
  9459  	// get len bytes to buf, or less than len if at the end
  9460  	got = uint64(0)
  9461  	for __ccgo := true; __ccgo; __ccgo = len != 0 {
  9462  		// set n to the maximum amount of len that fits in an unsigned int
  9463  		*(*uint32)(unsafe.Pointer(bp /* n */)) = libc.Uint32FromInt32(-1)
  9464  		if Z_size_t(*(*uint32)(unsafe.Pointer(bp))) > len {
  9465  			*(*uint32)(unsafe.Pointer(bp /* n */)) = uint32(len)
  9466  		}
  9467  
  9468  		// first just try copying data from the output buffer
  9469  		if (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave != 0 {
  9470  			if (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave < *(*uint32)(unsafe.Pointer(bp)) {
  9471  				*(*uint32)(unsafe.Pointer(bp /* n */)) = (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave
  9472  			}
  9473  			libc.Xmemcpy(tls, buf, (*Gz_state)(unsafe.Pointer(state)).Fx.Fnext, uint64(*(*uint32)(unsafe.Pointer(bp /* n */))))
  9474  			*(*uintptr)(unsafe.Pointer(state + 8)) += uintptr(*(*uint32)(unsafe.Pointer(bp)))
  9475  			*(*uint32)(unsafe.Pointer(state)) -= *(*uint32)(unsafe.Pointer(bp))
  9476  		} else if (*Gz_state)(unsafe.Pointer(state)).Feof != 0 && (*Gz_state)(unsafe.Pointer(state)).Fstrm.Favail_in == UInt(0) {
  9477  			(*Gz_state)(unsafe.Pointer(state)).Fpast = 1 // tried to read past end
  9478  			break
  9479  		} else if (*Gz_state)(unsafe.Pointer(state)).Fhow == LOOK || *(*uint32)(unsafe.Pointer(bp)) < (*Gz_state)(unsafe.Pointer(state)).Fsize<<1 {
  9480  			// get more output, looking for header if required
  9481  			if gz_fetch(tls, state) == -1 {
  9482  				return uint64(0)
  9483  			}
  9484  			continue // no progress yet -- go back to copy above
  9485  			// the copy above assures that we will leave with space in the
  9486  			//                output buffer, allowing at least one gzungetc() to succeed
  9487  		} else if (*Gz_state)(unsafe.Pointer(state)).Fhow == COPY1 { // read directly
  9488  			if gz_load(tls, state, buf, *(*uint32)(unsafe.Pointer(bp)), bp) == -1 {
  9489  				return uint64(0)
  9490  			}
  9491  		} else { // state->how == GZIP
  9492  			(*Gz_state)(unsafe.Pointer(state)).Fstrm.Favail_out = *(*uint32)(unsafe.Pointer(bp /* n */))
  9493  			(*Gz_state)(unsafe.Pointer(state)).Fstrm.Fnext_out = buf
  9494  			if gz_decomp(tls, state) == -1 {
  9495  				return uint64(0)
  9496  			}
  9497  			*(*uint32)(unsafe.Pointer(bp /* n */)) = (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave
  9498  			(*Gz_state)(unsafe.Pointer(state)).Fx.Fhave = uint32(0)
  9499  		}
  9500  
  9501  		// update progress
  9502  		len = len - Z_size_t(*(*uint32)(unsafe.Pointer(bp)))
  9503  		buf = buf + uintptr(*(*uint32)(unsafe.Pointer(bp)))
  9504  		got = got + Z_size_t(*(*uint32)(unsafe.Pointer(bp)))
  9505  		*(*Off64_t)(unsafe.Pointer(state + 16)) += Off64_t(*(*uint32)(unsafe.Pointer(bp)))
  9506  	}
  9507  
  9508  	// return number of bytes read into user buffer
  9509  	return got
  9510  }
  9511  
  9512  // -- see zlib.h --
  9513  func Xgzread(tls *libc.TLS, file GzFile, buf Voidp, len uint32) int32 { /* gzread.c:375:13: */
  9514  	var state Gz_statep
  9515  
  9516  	// get internal structure
  9517  	if file == uintptr(0) {
  9518  		return -1
  9519  	}
  9520  	state = file
  9521  
  9522  	// check that we're reading and that there's no (serious) error
  9523  	if (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ || (*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK && (*Gz_state)(unsafe.Pointer(state)).Ferr != -5 {
  9524  		return -1
  9525  	}
  9526  
  9527  	// since an int is returned, make sure len fits in one, otherwise return
  9528  	//        with an error (this avoids a flaw in the interface)
  9529  	if int32(len) < 0 {
  9530  		Xgz_error(tls, state, -2, ts+196)
  9531  		return -1
  9532  	}
  9533  
  9534  	// read len or fewer bytes to buf
  9535  	len = uint32(gz_read(tls, state, buf, uint64(len)))
  9536  
  9537  	// check for an error
  9538  	if len == uint32(0) && (*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK && (*Gz_state)(unsafe.Pointer(state)).Ferr != -5 {
  9539  		return -1
  9540  	}
  9541  
  9542  	// return the number of bytes read (this is assured to fit in an int)
  9543  	return int32(len)
  9544  }
  9545  
  9546  // -- see zlib.h --
  9547  func Xgzfread(tls *libc.TLS, buf Voidp, size Z_size_t, nitems Z_size_t, file GzFile) Z_size_t { /* gzread.c:411:18: */
  9548  	var len Z_size_t
  9549  	var state Gz_statep
  9550  
  9551  	// get internal structure
  9552  	if file == uintptr(0) {
  9553  		return uint64(0)
  9554  	}
  9555  	state = file
  9556  
  9557  	// check that we're reading and that there's no (serious) error
  9558  	if (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ || (*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK && (*Gz_state)(unsafe.Pointer(state)).Ferr != -5 {
  9559  		return uint64(0)
  9560  	}
  9561  
  9562  	// compute bytes to read -- error on overflow
  9563  	len = nitems * size
  9564  	if size != 0 && len/size != nitems {
  9565  		Xgz_error(tls, state, -2, ts+227)
  9566  		return uint64(0)
  9567  	}
  9568  
  9569  	// read len or fewer bytes to buf, return the number of full items read
  9570  	if len != 0 {
  9571  		return gz_read(tls, state, buf, len) / size
  9572  	}
  9573  	return uint64(0)
  9574  }
  9575  
  9576  // -- see zlib.h --
  9577  func Xgzgetc(tls *libc.TLS, file GzFile) int32 { /* gzread.c:447:13: */
  9578  	bp := tls.Alloc(1)
  9579  	defer tls.Free(1)
  9580  
  9581  	var ret int32
  9582  	// var buf [1]uint8 at bp, 1
  9583  
  9584  	var state Gz_statep
  9585  
  9586  	// get internal structure
  9587  	if file == uintptr(0) {
  9588  		return -1
  9589  	}
  9590  	state = file
  9591  
  9592  	// check that we're reading and that there's no (serious) error
  9593  	if (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ || (*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK && (*Gz_state)(unsafe.Pointer(state)).Ferr != -5 {
  9594  		return -1
  9595  	}
  9596  
  9597  	// try output buffer (no need to check for skip request)
  9598  	if (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave != 0 {
  9599  		(*Gz_state)(unsafe.Pointer(state)).Fx.Fhave--
  9600  		(*Gz_state)(unsafe.Pointer(state)).Fx.Fpos++
  9601  		return int32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&(*Gz_state)(unsafe.Pointer(state)).Fx.Fnext, 1))))
  9602  	}
  9603  
  9604  	// nothing there -- try gz_read()
  9605  	ret = int32(gz_read(tls, state, bp, uint64(1)))
  9606  	if ret < 1 {
  9607  		return -1
  9608  	}
  9609  	return int32(*(*uint8)(unsafe.Pointer(bp)))
  9610  }
  9611  
  9612  func Xgzgetc_(tls *libc.TLS, file GzFile) int32 { /* gzread.c:476:13: */
  9613  	return Xgzgetc(tls, file)
  9614  }
  9615  
  9616  // -- see zlib.h --
  9617  func Xgzungetc(tls *libc.TLS, c int32, file GzFile) int32 { /* gzread.c:483:13: */
  9618  	var state Gz_statep
  9619  
  9620  	// get internal structure
  9621  	if file == uintptr(0) {
  9622  		return -1
  9623  	}
  9624  	state = file
  9625  
  9626  	// check that we're reading and that there's no (serious) error
  9627  	if (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ || (*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK && (*Gz_state)(unsafe.Pointer(state)).Ferr != -5 {
  9628  		return -1
  9629  	}
  9630  
  9631  	// process a skip request
  9632  	if (*Gz_state)(unsafe.Pointer(state)).Fseek != 0 {
  9633  		(*Gz_state)(unsafe.Pointer(state)).Fseek = 0
  9634  		if gz_skip(tls, state, (*Gz_state)(unsafe.Pointer(state)).Fskip) == -1 {
  9635  			return -1
  9636  		}
  9637  	}
  9638  
  9639  	// can't push EOF
  9640  	if c < 0 {
  9641  		return -1
  9642  	}
  9643  
  9644  	// if output buffer empty, put byte at end (allows more pushing)
  9645  	if (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave == uint32(0) {
  9646  		(*Gz_state)(unsafe.Pointer(state)).Fx.Fhave = uint32(1)
  9647  		(*Gz_state)(unsafe.Pointer(state)).Fx.Fnext = (*Gz_state)(unsafe.Pointer(state)).Fout + uintptr((*Gz_state)(unsafe.Pointer(state)).Fsize<<1) - uintptr(1)
  9648  		*(*uint8)(unsafe.Pointer((*Gz_state)(unsafe.Pointer(state)).Fx.Fnext)) = uint8(c)
  9649  		(*Gz_state)(unsafe.Pointer(state)).Fx.Fpos--
  9650  		(*Gz_state)(unsafe.Pointer(state)).Fpast = 0
  9651  		return c
  9652  	}
  9653  
  9654  	// if no room, give up (must have already done a gzungetc())
  9655  	if (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave == (*Gz_state)(unsafe.Pointer(state)).Fsize<<1 {
  9656  		Xgz_error(tls, state, -3, ts+260)
  9657  		return -1
  9658  	}
  9659  
  9660  	// slide output data if needed and insert byte before existing data
  9661  	if (*Gz_state)(unsafe.Pointer(state)).Fx.Fnext == (*Gz_state)(unsafe.Pointer(state)).Fout {
  9662  		var src uintptr = (*Gz_state)(unsafe.Pointer(state)).Fout + uintptr((*Gz_state)(unsafe.Pointer(state)).Fx.Fhave)
  9663  		var dest uintptr = (*Gz_state)(unsafe.Pointer(state)).Fout + uintptr((*Gz_state)(unsafe.Pointer(state)).Fsize<<1)
  9664  		for src > (*Gz_state)(unsafe.Pointer(state)).Fout {
  9665  			*(*uint8)(unsafe.Pointer(libc.PreDecUintptr(&dest, 1))) = *(*uint8)(unsafe.Pointer(libc.PreDecUintptr(&src, 1)))
  9666  		}
  9667  		(*Gz_state)(unsafe.Pointer(state)).Fx.Fnext = dest
  9668  	}
  9669  	(*Gz_state)(unsafe.Pointer(state)).Fx.Fhave++
  9670  	(*Gz_state)(unsafe.Pointer(state)).Fx.Fnext--
  9671  	*(*uint8)(unsafe.Pointer((*Gz_state)(unsafe.Pointer(state)).Fx.Fnext)) = uint8(c)
  9672  	(*Gz_state)(unsafe.Pointer(state)).Fx.Fpos--
  9673  	(*Gz_state)(unsafe.Pointer(state)).Fpast = 0
  9674  	return c
  9675  }
  9676  
  9677  // -- see zlib.h --
  9678  func Xgzgets(tls *libc.TLS, file GzFile, buf uintptr, len int32) uintptr { /* gzread.c:543:6: */
  9679  	var left uint32
  9680  	var n uint32
  9681  	var str uintptr
  9682  	var eol uintptr
  9683  	var state Gz_statep
  9684  
  9685  	// check parameters and get internal structure
  9686  	if file == uintptr(0) || buf == uintptr(0) || len < 1 {
  9687  		return uintptr(0)
  9688  	}
  9689  	state = file
  9690  
  9691  	// check that we're reading and that there's no (serious) error
  9692  	if (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ || (*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK && (*Gz_state)(unsafe.Pointer(state)).Ferr != -5 {
  9693  		return uintptr(0)
  9694  	}
  9695  
  9696  	// process a skip request
  9697  	if (*Gz_state)(unsafe.Pointer(state)).Fseek != 0 {
  9698  		(*Gz_state)(unsafe.Pointer(state)).Fseek = 0
  9699  		if gz_skip(tls, state, (*Gz_state)(unsafe.Pointer(state)).Fskip) == -1 {
  9700  			return uintptr(0)
  9701  		}
  9702  	}
  9703  
  9704  	// copy output bytes up to new line or len - 1, whichever comes first --
  9705  	//        append a terminating zero to the string (we don't check for a zero in
  9706  	//        the contents, let the user worry about that)
  9707  	str = buf
  9708  	left = uint32(len) - uint32(1)
  9709  	if left != 0 {
  9710  		for __ccgo := true; __ccgo; __ccgo = left != 0 && eol == uintptr(0) {
  9711  			// assure that something is in the output buffer
  9712  			if (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave == uint32(0) && gz_fetch(tls, state) == -1 {
  9713  				return uintptr(0)
  9714  			} // error
  9715  			if (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave == uint32(0) { // end of file
  9716  				(*Gz_state)(unsafe.Pointer(state)).Fpast = 1 // read past end
  9717  				break                                        // return what we have
  9718  			}
  9719  
  9720  			// look for end-of-line in current output buffer
  9721  			if (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave > left {
  9722  				n = left
  9723  			} else {
  9724  				n = (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave
  9725  			}
  9726  			eol = libc.Xmemchr(tls, (*Gz_state)(unsafe.Pointer(state)).Fx.Fnext, '\n', uint64(n))
  9727  			if eol != uintptr(0) {
  9728  				n = uint32((int64(eol)-int64((*Gz_state)(unsafe.Pointer(state)).Fx.Fnext))/1) + uint32(1)
  9729  			}
  9730  
  9731  			// copy through end-of-line, or remainder if not found
  9732  			libc.Xmemcpy(tls, buf, (*Gz_state)(unsafe.Pointer(state)).Fx.Fnext, uint64(n))
  9733  			*(*uint32)(unsafe.Pointer(state)) -= n
  9734  			*(*uintptr)(unsafe.Pointer(state + 8)) += uintptr(n)
  9735  			*(*Off64_t)(unsafe.Pointer(state + 16)) += Off64_t(n)
  9736  			left = left - n
  9737  			buf += uintptr(n)
  9738  		}
  9739  	}
  9740  
  9741  	// return terminated string, or if nothing, end of file
  9742  	if buf == str {
  9743  		return uintptr(0)
  9744  	}
  9745  	*(*uint8)(unsafe.Pointer(buf)) = uint8(0)
  9746  	return str
  9747  }
  9748  
  9749  // -- see zlib.h --
  9750  func Xgzdirect(tls *libc.TLS, file GzFile) int32 { /* gzread.c:607:13: */
  9751  	var state Gz_statep
  9752  
  9753  	// get internal structure
  9754  	if file == uintptr(0) {
  9755  		return 0
  9756  	}
  9757  	state = file
  9758  
  9759  	// if the state is not known, but we can find out, then do so (this is
  9760  	//        mainly for right after a gzopen() or gzdopen())
  9761  	if (*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_READ && (*Gz_state)(unsafe.Pointer(state)).Fhow == LOOK && (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave == uint32(0) {
  9762  		gz_look(tls, state)
  9763  	}
  9764  
  9765  	// return 1 if transparent, 0 if processing a gzip stream
  9766  	return (*Gz_state)(unsafe.Pointer(state)).Fdirect
  9767  }
  9768  
  9769  // -- see zlib.h --
  9770  func Xgzclose_r(tls *libc.TLS, file GzFile) int32 { /* gzread.c:627:13: */
  9771  	var ret int32
  9772  	var err int32
  9773  	var state Gz_statep
  9774  
  9775  	// get internal structure
  9776  	if file == uintptr(0) {
  9777  		return -2
  9778  	}
  9779  	state = file
  9780  
  9781  	// check that we're reading
  9782  	if (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ {
  9783  		return -2
  9784  	}
  9785  
  9786  	// free memory and close file
  9787  	if (*Gz_state)(unsafe.Pointer(state)).Fsize != 0 {
  9788  		XinflateEnd(tls, state+120)
  9789  		libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fout)
  9790  		libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fin)
  9791  	}
  9792  	if (*Gz_state)(unsafe.Pointer(state)).Ferr == -5 {
  9793  		err = -5
  9794  	} else {
  9795  		err = Z_OK
  9796  	}
  9797  	Xgz_error(tls, state, Z_OK, uintptr(0))
  9798  	libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fpath)
  9799  	ret = libc.Xclose(tls, (*Gz_state)(unsafe.Pointer(state)).Ffd)
  9800  	libc.Xfree(tls, state)
  9801  	if ret != 0 {
  9802  		return -1
  9803  	}
  9804  	return err
  9805  }
  9806  
  9807  // Initialize state for writing a gzip file.  Mark initialization by setting
  9808  //    state->size to non-zero.  Return -1 on a memory allocation failure, or 0 on
  9809  //    success.
  9810  func gz_init(tls *libc.TLS, state Gz_statep) int32 { /* gzwrite.c:17:11: */
  9811  	var ret int32
  9812  	var strm Z_streamp = state + 120
  9813  
  9814  	// allocate input buffer (double size for gzprintf)
  9815  	(*Gz_state)(unsafe.Pointer(state)).Fin = libc.Xmalloc(tls, uint64((*Gz_state)(unsafe.Pointer(state)).Fwant<<1))
  9816  	if (*Gz_state)(unsafe.Pointer(state)).Fin == uintptr(0) {
  9817  		Xgz_error(tls, state, -4, ts+87)
  9818  		return -1
  9819  	}
  9820  
  9821  	// only need output buffer and deflate state if compressing
  9822  	if !((*Gz_state)(unsafe.Pointer(state)).Fdirect != 0) {
  9823  		// allocate output buffer
  9824  		(*Gz_state)(unsafe.Pointer(state)).Fout = libc.Xmalloc(tls, uint64((*Gz_state)(unsafe.Pointer(state)).Fwant))
  9825  		if (*Gz_state)(unsafe.Pointer(state)).Fout == uintptr(0) {
  9826  			libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fin)
  9827  			Xgz_error(tls, state, -4, ts+87)
  9828  			return -1
  9829  		}
  9830  
  9831  		// allocate deflate memory, set up for gzip compression
  9832  		(*Z_stream)(unsafe.Pointer(strm)).Fzalloc = Alloc_func(Z_NULL)
  9833  		(*Z_stream)(unsafe.Pointer(strm)).Fzfree = Free_func(Z_NULL)
  9834  		(*Z_stream)(unsafe.Pointer(strm)).Fopaque = Voidpf(Z_NULL)
  9835  		ret = XdeflateInit2_(tls, strm, (*Gz_state)(unsafe.Pointer(state)).Flevel, Z_DEFLATED, MAX_WBITS+16, DEF_MEM_LEVEL, (*Gz_state)(unsafe.Pointer(state)).Fstrategy, ts, int32(unsafe.Sizeof(Z_stream{})))
  9836  		if ret != Z_OK {
  9837  			libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fout)
  9838  			libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fin)
  9839  			Xgz_error(tls, state, -4, ts+87)
  9840  			return -1
  9841  		}
  9842  		(*Z_stream)(unsafe.Pointer(strm)).Fnext_in = uintptr(0)
  9843  	}
  9844  
  9845  	// mark state as initialized
  9846  	(*Gz_state)(unsafe.Pointer(state)).Fsize = (*Gz_state)(unsafe.Pointer(state)).Fwant
  9847  
  9848  	// initialize write buffer if compressing
  9849  	if !((*Gz_state)(unsafe.Pointer(state)).Fdirect != 0) {
  9850  		(*Z_stream)(unsafe.Pointer(strm)).Favail_out = (*Gz_state)(unsafe.Pointer(state)).Fsize
  9851  		(*Z_stream)(unsafe.Pointer(strm)).Fnext_out = (*Gz_state)(unsafe.Pointer(state)).Fout
  9852  		(*Gz_state)(unsafe.Pointer(state)).Fx.Fnext = (*Z_stream)(unsafe.Pointer(strm)).Fnext_out
  9853  	}
  9854  	return 0
  9855  }
  9856  
  9857  // Compress whatever is at avail_in and next_in and write to the output file.
  9858  //    Return -1 if there is an error writing to the output file or if gz_init()
  9859  //    fails to allocate memory, otherwise 0.  flush is assumed to be a valid
  9860  //    deflate() flush value.  If flush is Z_FINISH, then the deflate() state is
  9861  //    reset to start a new gzip stream.  If gz->direct is true, then simply write
  9862  //    to the output file without compressing, and ignore flush.
  9863  func gz_comp(tls *libc.TLS, state Gz_statep, flush int32) int32 { /* gzwrite.c:73:11: */
  9864  	var ret int32
  9865  	var writ int32
  9866  	var have uint32
  9867  	var put uint32
  9868  	var max uint32 = uint32(libc.Uint32(libc.Uint32FromInt32(-1)))>>2 + uint32(1)
  9869  	var strm Z_streamp = state + 120
  9870  
  9871  	// allocate memory if this is the first time through
  9872  	if (*Gz_state)(unsafe.Pointer(state)).Fsize == uint32(0) && gz_init(tls, state) == -1 {
  9873  		return -1
  9874  	}
  9875  
  9876  	// write directly if requested
  9877  	if (*Gz_state)(unsafe.Pointer(state)).Fdirect != 0 {
  9878  		for (*Z_stream)(unsafe.Pointer(strm)).Favail_in != 0 {
  9879  			if (*Z_stream)(unsafe.Pointer(strm)).Favail_in > max {
  9880  				put = max
  9881  			} else {
  9882  				put = (*Z_stream)(unsafe.Pointer(strm)).Favail_in
  9883  			}
  9884  			writ = int32(libc.Xwrite(tls, (*Gz_state)(unsafe.Pointer(state)).Ffd, (*Z_stream)(unsafe.Pointer(strm)).Fnext_in, uint64(put)))
  9885  			if writ < 0 {
  9886  				Xgz_error(tls, state, -1, libc.Xstrerror(tls, *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))))
  9887  				return -1
  9888  			}
  9889  			*(*UInt)(unsafe.Pointer(strm + 8)) -= uint32(writ)
  9890  			*(*uintptr)(unsafe.Pointer(strm)) += uintptr(writ)
  9891  		}
  9892  		return 0
  9893  	}
  9894  
  9895  	// run deflate() on provided input until it produces no more output
  9896  	ret = Z_OK
  9897  	for __ccgo := true; __ccgo; __ccgo = have != 0 {
  9898  		// write out current buffer contents if full, or if flushing, but if
  9899  		//            doing Z_FINISH then don't write until we get to Z_STREAM_END
  9900  		if (*Z_stream)(unsafe.Pointer(strm)).Favail_out == UInt(0) || flush != Z_NO_FLUSH && (flush != Z_FINISH || ret == Z_STREAM_END) {
  9901  			for (*Z_stream)(unsafe.Pointer(strm)).Fnext_out > (*Gz_state)(unsafe.Pointer(state)).Fx.Fnext {
  9902  				if (int64((*Z_stream)(unsafe.Pointer(strm)).Fnext_out)-int64((*Gz_state)(unsafe.Pointer(state)).Fx.Fnext))/1 > int64(int32(max)) {
  9903  					put = max
  9904  				} else {
  9905  					put = uint32((int64((*Z_stream)(unsafe.Pointer(strm)).Fnext_out) - int64((*Gz_state)(unsafe.Pointer(state)).Fx.Fnext)) / 1)
  9906  				}
  9907  				writ = int32(libc.Xwrite(tls, (*Gz_state)(unsafe.Pointer(state)).Ffd, (*Gz_state)(unsafe.Pointer(state)).Fx.Fnext, uint64(put)))
  9908  				if writ < 0 {
  9909  					Xgz_error(tls, state, -1, libc.Xstrerror(tls, *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))))
  9910  					return -1
  9911  				}
  9912  				*(*uintptr)(unsafe.Pointer(state + 8)) += uintptr(writ)
  9913  			}
  9914  			if (*Z_stream)(unsafe.Pointer(strm)).Favail_out == UInt(0) {
  9915  				(*Z_stream)(unsafe.Pointer(strm)).Favail_out = (*Gz_state)(unsafe.Pointer(state)).Fsize
  9916  				(*Z_stream)(unsafe.Pointer(strm)).Fnext_out = (*Gz_state)(unsafe.Pointer(state)).Fout
  9917  				(*Gz_state)(unsafe.Pointer(state)).Fx.Fnext = (*Gz_state)(unsafe.Pointer(state)).Fout
  9918  			}
  9919  		}
  9920  
  9921  		// compress
  9922  		have = (*Z_stream)(unsafe.Pointer(strm)).Favail_out
  9923  		ret = Xdeflate(tls, strm, flush)
  9924  		if ret == -2 {
  9925  			Xgz_error(tls, state, -2,
  9926  				ts+291)
  9927  			return -1
  9928  		}
  9929  		have = have - (*Z_stream)(unsafe.Pointer(strm)).Favail_out
  9930  	}
  9931  
  9932  	// if that completed a deflate stream, allow another to start
  9933  	if flush == Z_FINISH {
  9934  		XdeflateReset(tls, strm)
  9935  	}
  9936  
  9937  	// all done, no errors
  9938  	return 0
  9939  }
  9940  
  9941  // Compress len zeros to output.  Return -1 on a write error or memory
  9942  //    allocation failure by gz_comp(), or 0 on success.
  9943  func gz_zero(tls *libc.TLS, state Gz_statep, len Off64_t) int32 { /* gzwrite.c:145:11: */
  9944  	var first int32
  9945  	var n uint32
  9946  	var strm Z_streamp = state + 120
  9947  
  9948  	// consume whatever's left in the input buffer
  9949  	if (*Z_stream)(unsafe.Pointer(strm)).Favail_in != 0 && gz_comp(tls, state, Z_NO_FLUSH) == -1 {
  9950  		return -1
  9951  	}
  9952  
  9953  	// compress len zeros (len guaranteed > 0)
  9954  	first = 1
  9955  	for len != 0 {
  9956  		if uint64(unsafe.Sizeof(int32(0))) == uint64(unsafe.Sizeof(Off64_t(0))) && (*Gz_state)(unsafe.Pointer(state)).Fsize > uint32(0x7fffffff) || Off64_t((*Gz_state)(unsafe.Pointer(state)).Fsize) > len {
  9957  			n = uint32(len)
  9958  		} else {
  9959  			n = (*Gz_state)(unsafe.Pointer(state)).Fsize
  9960  		}
  9961  		if first != 0 {
  9962  			libc.Xmemset(tls, (*Gz_state)(unsafe.Pointer(state)).Fin, 0, uint64(n))
  9963  			first = 0
  9964  		}
  9965  		(*Z_stream)(unsafe.Pointer(strm)).Favail_in = n
  9966  		(*Z_stream)(unsafe.Pointer(strm)).Fnext_in = (*Gz_state)(unsafe.Pointer(state)).Fin
  9967  		*(*Off64_t)(unsafe.Pointer(state + 16)) += Off64_t(n)
  9968  		if gz_comp(tls, state, Z_NO_FLUSH) == -1 {
  9969  			return -1
  9970  		}
  9971  		len = len - Off64_t(n)
  9972  	}
  9973  	return 0
  9974  }
  9975  
  9976  // Write len bytes from buf to file.  Return the number of bytes written.  If
  9977  //    the returned value is less than len, then there was an error.
  9978  func gz_write(tls *libc.TLS, state Gz_statep, buf Voidpc, len Z_size_t) Z_size_t { /* gzwrite.c:178:16: */
  9979  	var put Z_size_t = len
  9980  
  9981  	// if len is zero, avoid unnecessary operations
  9982  	if len == uint64(0) {
  9983  		return uint64(0)
  9984  	}
  9985  
  9986  	// allocate memory if this is the first time through
  9987  	if (*Gz_state)(unsafe.Pointer(state)).Fsize == uint32(0) && gz_init(tls, state) == -1 {
  9988  		return uint64(0)
  9989  	}
  9990  
  9991  	// check for seek request
  9992  	if (*Gz_state)(unsafe.Pointer(state)).Fseek != 0 {
  9993  		(*Gz_state)(unsafe.Pointer(state)).Fseek = 0
  9994  		if gz_zero(tls, state, (*Gz_state)(unsafe.Pointer(state)).Fskip) == -1 {
  9995  			return uint64(0)
  9996  		}
  9997  	}
  9998  
  9999  	// for small len, copy to input buffer, otherwise compress directly
 10000  	if len < Z_size_t((*Gz_state)(unsafe.Pointer(state)).Fsize) {
 10001  		// copy to input buffer, compress when full
 10002  		for __ccgo := true; __ccgo; __ccgo = len != 0 {
 10003  			var have uint32
 10004  			var copy uint32
 10005  
 10006  			if (*Gz_state)(unsafe.Pointer(state)).Fstrm.Favail_in == UInt(0) {
 10007  				(*Gz_state)(unsafe.Pointer(state)).Fstrm.Fnext_in = (*Gz_state)(unsafe.Pointer(state)).Fin
 10008  			}
 10009  			have = uint32((int64((*Gz_state)(unsafe.Pointer(state)).Fstrm.Fnext_in+uintptr((*Gz_state)(unsafe.Pointer(state)).Fstrm.Favail_in)) - int64((*Gz_state)(unsafe.Pointer(state)).Fin)) / 1)
 10010  			copy = (*Gz_state)(unsafe.Pointer(state)).Fsize - have
 10011  			if Z_size_t(copy) > len {
 10012  				copy = uint32(len)
 10013  			}
 10014  			libc.Xmemcpy(tls, (*Gz_state)(unsafe.Pointer(state)).Fin+uintptr(have), buf, uint64(copy))
 10015  			*(*UInt)(unsafe.Pointer(state + 120 + 8)) += copy
 10016  			*(*Off64_t)(unsafe.Pointer(state + 16)) += Off64_t(copy)
 10017  			buf = buf + uintptr(copy)
 10018  			len = len - Z_size_t(copy)
 10019  			if len != 0 && gz_comp(tls, state, Z_NO_FLUSH) == -1 {
 10020  				return uint64(0)
 10021  			}
 10022  		}
 10023  	} else {
 10024  		// consume whatever's left in the input buffer
 10025  		if (*Gz_state)(unsafe.Pointer(state)).Fstrm.Favail_in != 0 && gz_comp(tls, state, Z_NO_FLUSH) == -1 {
 10026  			return uint64(0)
 10027  		}
 10028  
 10029  		// directly compress user buffer to file
 10030  		(*Gz_state)(unsafe.Pointer(state)).Fstrm.Fnext_in = buf
 10031  		for __ccgo1 := true; __ccgo1; __ccgo1 = len != 0 {
 10032  			var n uint32 = libc.Uint32(libc.Uint32FromInt32(-1))
 10033  			if Z_size_t(n) > len {
 10034  				n = uint32(len)
 10035  			}
 10036  			(*Gz_state)(unsafe.Pointer(state)).Fstrm.Favail_in = n
 10037  			*(*Off64_t)(unsafe.Pointer(state + 16)) += Off64_t(n)
 10038  			if gz_comp(tls, state, Z_NO_FLUSH) == -1 {
 10039  				return uint64(0)
 10040  			}
 10041  			len = len - Z_size_t(n)
 10042  		}
 10043  	}
 10044  
 10045  	// input was all buffered or compressed
 10046  	return put
 10047  }
 10048  
 10049  // -- see zlib.h --
 10050  func Xgzwrite(tls *libc.TLS, file GzFile, buf Voidpc, len uint32) int32 { /* gzwrite.c:246:13: */
 10051  	var state Gz_statep
 10052  
 10053  	// get internal structure
 10054  	if file == uintptr(0) {
 10055  		return 0
 10056  	}
 10057  	state = file
 10058  
 10059  	// check that we're writing and that there's no error
 10060  	if (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE || (*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK {
 10061  		return 0
 10062  	}
 10063  
 10064  	// since an int is returned, make sure len fits in one, otherwise return
 10065  	//        with an error (this avoids a flaw in the interface)
 10066  	if int32(len) < 0 {
 10067  		Xgz_error(tls, state, -3, ts+330)
 10068  		return 0
 10069  	}
 10070  
 10071  	// write len bytes from buf (the return value will fit in an int)
 10072  	return int32(gz_write(tls, state, buf, uint64(len)))
 10073  }
 10074  
 10075  // -- see zlib.h --
 10076  func Xgzfwrite(tls *libc.TLS, buf Voidpc, size Z_size_t, nitems Z_size_t, file GzFile) Z_size_t { /* gzwrite.c:274:18: */
 10077  	var len Z_size_t
 10078  	var state Gz_statep
 10079  
 10080  	// get internal structure
 10081  	if file == uintptr(0) {
 10082  		return uint64(0)
 10083  	}
 10084  	state = file
 10085  
 10086  	// check that we're writing and that there's no error
 10087  	if (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE || (*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK {
 10088  		return uint64(0)
 10089  	}
 10090  
 10091  	// compute bytes to read -- error on overflow
 10092  	len = nitems * size
 10093  	if size != 0 && len/size != nitems {
 10094  		Xgz_error(tls, state, -2, ts+227)
 10095  		return uint64(0)
 10096  	}
 10097  
 10098  	// write len bytes to buf, return the number of full items written
 10099  	if len != 0 {
 10100  		return gz_write(tls, state, buf, len) / size
 10101  	}
 10102  	return uint64(0)
 10103  }
 10104  
 10105  // -- see zlib.h --
 10106  func Xgzputc(tls *libc.TLS, file GzFile, c int32) int32 { /* gzwrite.c:304:13: */
 10107  	bp := tls.Alloc(1)
 10108  	defer tls.Free(1)
 10109  
 10110  	var have uint32
 10111  	// var buf [1]uint8 at bp, 1
 10112  
 10113  	var state Gz_statep
 10114  	var strm Z_streamp
 10115  
 10116  	// get internal structure
 10117  	if file == uintptr(0) {
 10118  		return -1
 10119  	}
 10120  	state = file
 10121  	strm = state + 120
 10122  
 10123  	// check that we're writing and that there's no error
 10124  	if (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE || (*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK {
 10125  		return -1
 10126  	}
 10127  
 10128  	// check for seek request
 10129  	if (*Gz_state)(unsafe.Pointer(state)).Fseek != 0 {
 10130  		(*Gz_state)(unsafe.Pointer(state)).Fseek = 0
 10131  		if gz_zero(tls, state, (*Gz_state)(unsafe.Pointer(state)).Fskip) == -1 {
 10132  			return -1
 10133  		}
 10134  	}
 10135  
 10136  	// try writing to input buffer for speed (state->size == 0 if buffer not
 10137  	//        initialized)
 10138  	if (*Gz_state)(unsafe.Pointer(state)).Fsize != 0 {
 10139  		if (*Z_stream)(unsafe.Pointer(strm)).Favail_in == UInt(0) {
 10140  			(*Z_stream)(unsafe.Pointer(strm)).Fnext_in = (*Gz_state)(unsafe.Pointer(state)).Fin
 10141  		}
 10142  		have = uint32((int64((*Z_stream)(unsafe.Pointer(strm)).Fnext_in+uintptr((*Z_stream)(unsafe.Pointer(strm)).Favail_in)) - int64((*Gz_state)(unsafe.Pointer(state)).Fin)) / 1)
 10143  		if have < (*Gz_state)(unsafe.Pointer(state)).Fsize {
 10144  			*(*uint8)(unsafe.Pointer((*Gz_state)(unsafe.Pointer(state)).Fin + uintptr(have))) = uint8(c)
 10145  			(*Z_stream)(unsafe.Pointer(strm)).Favail_in++
 10146  			(*Gz_state)(unsafe.Pointer(state)).Fx.Fpos++
 10147  			return c & 0xff
 10148  		}
 10149  	}
 10150  
 10151  	// no room in buffer or not initialized, use gz_write()
 10152  	*(*uint8)(unsafe.Pointer(bp)) = uint8(c)
 10153  	if gz_write(tls, state, bp, uint64(1)) != uint64(1) {
 10154  		return -1
 10155  	}
 10156  	return c & 0xff
 10157  }
 10158  
 10159  // -- see zlib.h --
 10160  func Xgzputs(tls *libc.TLS, file GzFile, str uintptr) int32 { /* gzwrite.c:352:13: */
 10161  	var ret int32
 10162  	var len Z_size_t
 10163  	var state Gz_statep
 10164  
 10165  	// get internal structure
 10166  	if file == uintptr(0) {
 10167  		return -1
 10168  	}
 10169  	state = file
 10170  
 10171  	// check that we're writing and that there's no error
 10172  	if (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE || (*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK {
 10173  		return -1
 10174  	}
 10175  
 10176  	// write string
 10177  	len = libc.Xstrlen(tls, str)
 10178  	ret = int32(gz_write(tls, state, str, len))
 10179  	if ret == 0 && len != uint64(0) {
 10180  		return -1
 10181  	}
 10182  	return ret
 10183  }
 10184  
 10185  // Copyright (C) 1989-2020 Free Software Foundation, Inc.
 10186  //
 10187  // This file is part of GCC.
 10188  //
 10189  // GCC is free software; you can redistribute it and/or modify
 10190  // it under the terms of the GNU General Public License as published by
 10191  // the Free Software Foundation; either version 3, or (at your option)
 10192  // any later version.
 10193  //
 10194  // GCC is distributed in the hope that it will be useful,
 10195  // but WITHOUT ANY WARRANTY; without even the implied warranty of
 10196  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 10197  // GNU General Public License for more details.
 10198  //
 10199  // Under Section 7 of GPL version 3, you are granted additional
 10200  // permissions described in the GCC Runtime Library Exception, version
 10201  // 3.1, as published by the Free Software Foundation.
 10202  //
 10203  // You should have received a copy of the GNU General Public License and
 10204  // a copy of the GCC Runtime Library Exception along with this program;
 10205  // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 10206  // <http://www.gnu.org/licenses/>.
 10207  
 10208  // ISO C Standard:  7.15  Variable arguments  <stdarg.h>
 10209  
 10210  // -- see zlib.h --
 10211  func Xgzvprintf(tls *libc.TLS, file GzFile, format uintptr, va Va_list) int32 { /* gzwrite.c:379:15: */
 10212  	var len int32
 10213  	var left uint32
 10214  	var next uintptr
 10215  	var state Gz_statep
 10216  	var strm Z_streamp
 10217  
 10218  	// get internal structure
 10219  	if file == uintptr(0) {
 10220  		return -2
 10221  	}
 10222  	state = file
 10223  	strm = state + 120
 10224  
 10225  	// check that we're writing and that there's no error
 10226  	if (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE || (*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK {
 10227  		return -2
 10228  	}
 10229  
 10230  	// make sure we have some buffer space
 10231  	if (*Gz_state)(unsafe.Pointer(state)).Fsize == uint32(0) && gz_init(tls, state) == -1 {
 10232  		return (*Gz_state)(unsafe.Pointer(state)).Ferr
 10233  	}
 10234  
 10235  	// check for seek request
 10236  	if (*Gz_state)(unsafe.Pointer(state)).Fseek != 0 {
 10237  		(*Gz_state)(unsafe.Pointer(state)).Fseek = 0
 10238  		if gz_zero(tls, state, (*Gz_state)(unsafe.Pointer(state)).Fskip) == -1 {
 10239  			return (*Gz_state)(unsafe.Pointer(state)).Ferr
 10240  		}
 10241  	}
 10242  
 10243  	// do the printf() into the input buffer, put length in len -- the input
 10244  	//        buffer is double-sized just for this function, so there is guaranteed to
 10245  	//        be state->size bytes available after the current contents
 10246  	if (*Z_stream)(unsafe.Pointer(strm)).Favail_in == UInt(0) {
 10247  		(*Z_stream)(unsafe.Pointer(strm)).Fnext_in = (*Gz_state)(unsafe.Pointer(state)).Fin
 10248  	}
 10249  	next = (*Gz_state)(unsafe.Pointer(state)).Fin + uintptr((int64((*Z_stream)(unsafe.Pointer(strm)).Fnext_in)-int64((*Gz_state)(unsafe.Pointer(state)).Fin))/1) + uintptr((*Z_stream)(unsafe.Pointer(strm)).Favail_in)
 10250  	*(*uint8)(unsafe.Pointer(next + uintptr((*Gz_state)(unsafe.Pointer(state)).Fsize-uint32(1)))) = uint8(0)
 10251  	len = libc.Xvsnprintf(tls, next, uint64((*Gz_state)(unsafe.Pointer(state)).Fsize), format, va)
 10252  
 10253  	// check that printf() results fit in buffer
 10254  	if len == 0 || uint32(len) >= (*Gz_state)(unsafe.Pointer(state)).Fsize || int32(*(*uint8)(unsafe.Pointer(next + uintptr((*Gz_state)(unsafe.Pointer(state)).Fsize-uint32(1))))) != 0 {
 10255  		return 0
 10256  	}
 10257  
 10258  	// update buffer and position, compress first half if past that
 10259  	*(*UInt)(unsafe.Pointer(strm + 8)) += uint32(len)
 10260  	*(*Off64_t)(unsafe.Pointer(state + 16)) += Off64_t(len)
 10261  	if (*Z_stream)(unsafe.Pointer(strm)).Favail_in >= (*Gz_state)(unsafe.Pointer(state)).Fsize {
 10262  		left = (*Z_stream)(unsafe.Pointer(strm)).Favail_in - (*Gz_state)(unsafe.Pointer(state)).Fsize
 10263  		(*Z_stream)(unsafe.Pointer(strm)).Favail_in = (*Gz_state)(unsafe.Pointer(state)).Fsize
 10264  		if gz_comp(tls, state, Z_NO_FLUSH) == -1 {
 10265  			return (*Gz_state)(unsafe.Pointer(state)).Ferr
 10266  		}
 10267  		libc.Xmemcpy(tls, (*Gz_state)(unsafe.Pointer(state)).Fin, (*Gz_state)(unsafe.Pointer(state)).Fin+uintptr((*Gz_state)(unsafe.Pointer(state)).Fsize), uint64(left))
 10268  		(*Z_stream)(unsafe.Pointer(strm)).Fnext_in = (*Gz_state)(unsafe.Pointer(state)).Fin
 10269  		(*Z_stream)(unsafe.Pointer(strm)).Favail_in = left
 10270  	}
 10271  	return len
 10272  }
 10273  
 10274  func Xgzprintf(tls *libc.TLS, file GzFile, format uintptr, va uintptr) int32 { /* gzwrite.c:451:15: */
 10275  	var va1 Va_list
 10276  	_ = va1
 10277  	var ret int32
 10278  
 10279  	va1 = va
 10280  	ret = Xgzvprintf(tls, file, format, va1)
 10281  	_ = va1
 10282  	return ret
 10283  }
 10284  
 10285  // -- see zlib.h --
 10286  func Xgzflush(tls *libc.TLS, file GzFile, flush int32) int32 { /* gzwrite.c:553:13: */
 10287  	var state Gz_statep
 10288  
 10289  	// get internal structure
 10290  	if file == uintptr(0) {
 10291  		return -2
 10292  	}
 10293  	state = file
 10294  
 10295  	// check that we're writing and that there's no error
 10296  	if (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE || (*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK {
 10297  		return -2
 10298  	}
 10299  
 10300  	// check flush parameter
 10301  	if flush < 0 || flush > Z_FINISH {
 10302  		return -2
 10303  	}
 10304  
 10305  	// check for seek request
 10306  	if (*Gz_state)(unsafe.Pointer(state)).Fseek != 0 {
 10307  		(*Gz_state)(unsafe.Pointer(state)).Fseek = 0
 10308  		if gz_zero(tls, state, (*Gz_state)(unsafe.Pointer(state)).Fskip) == -1 {
 10309  			return (*Gz_state)(unsafe.Pointer(state)).Ferr
 10310  		}
 10311  	}
 10312  
 10313  	// compress remaining data with requested flush
 10314  	gz_comp(tls, state, flush)
 10315  	return (*Gz_state)(unsafe.Pointer(state)).Ferr
 10316  }
 10317  
 10318  // -- see zlib.h --
 10319  func Xgzsetparams(tls *libc.TLS, file GzFile, level int32, strategy int32) int32 { /* gzwrite.c:585:13: */
 10320  	var state Gz_statep
 10321  	var strm Z_streamp
 10322  
 10323  	// get internal structure
 10324  	if file == uintptr(0) {
 10325  		return -2
 10326  	}
 10327  	state = file
 10328  	strm = state + 120
 10329  
 10330  	// check that we're writing and that there's no error
 10331  	if (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE || (*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK {
 10332  		return -2
 10333  	}
 10334  
 10335  	// if no change is requested, then do nothing
 10336  	if level == (*Gz_state)(unsafe.Pointer(state)).Flevel && strategy == (*Gz_state)(unsafe.Pointer(state)).Fstrategy {
 10337  		return Z_OK
 10338  	}
 10339  
 10340  	// check for seek request
 10341  	if (*Gz_state)(unsafe.Pointer(state)).Fseek != 0 {
 10342  		(*Gz_state)(unsafe.Pointer(state)).Fseek = 0
 10343  		if gz_zero(tls, state, (*Gz_state)(unsafe.Pointer(state)).Fskip) == -1 {
 10344  			return (*Gz_state)(unsafe.Pointer(state)).Ferr
 10345  		}
 10346  	}
 10347  
 10348  	// change compression parameters for subsequent input
 10349  	if (*Gz_state)(unsafe.Pointer(state)).Fsize != 0 {
 10350  		// flush previous input with previous parameters before changing
 10351  		if (*Z_stream)(unsafe.Pointer(strm)).Favail_in != 0 && gz_comp(tls, state, Z_BLOCK) == -1 {
 10352  			return (*Gz_state)(unsafe.Pointer(state)).Ferr
 10353  		}
 10354  		XdeflateParams(tls, strm, level, strategy)
 10355  	}
 10356  	(*Gz_state)(unsafe.Pointer(state)).Flevel = level
 10357  	(*Gz_state)(unsafe.Pointer(state)).Fstrategy = strategy
 10358  	return Z_OK
 10359  }
 10360  
 10361  // -- see zlib.h --
 10362  func Xgzclose_w(tls *libc.TLS, file GzFile) int32 { /* gzwrite.c:627:13: */
 10363  	var ret int32 = Z_OK
 10364  	var state Gz_statep
 10365  
 10366  	// get internal structure
 10367  	if file == uintptr(0) {
 10368  		return -2
 10369  	}
 10370  	state = file
 10371  
 10372  	// check that we're writing
 10373  	if (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE {
 10374  		return -2
 10375  	}
 10376  
 10377  	// check for seek request
 10378  	if (*Gz_state)(unsafe.Pointer(state)).Fseek != 0 {
 10379  		(*Gz_state)(unsafe.Pointer(state)).Fseek = 0
 10380  		if gz_zero(tls, state, (*Gz_state)(unsafe.Pointer(state)).Fskip) == -1 {
 10381  			ret = (*Gz_state)(unsafe.Pointer(state)).Ferr
 10382  		}
 10383  	}
 10384  
 10385  	// flush, free memory, and close file
 10386  	if gz_comp(tls, state, Z_FINISH) == -1 {
 10387  		ret = (*Gz_state)(unsafe.Pointer(state)).Ferr
 10388  	}
 10389  	if (*Gz_state)(unsafe.Pointer(state)).Fsize != 0 {
 10390  		if !((*Gz_state)(unsafe.Pointer(state)).Fdirect != 0) {
 10391  			XdeflateEnd(tls, state+120)
 10392  			libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fout)
 10393  		}
 10394  		libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fin)
 10395  	}
 10396  	Xgz_error(tls, state, Z_OK, uintptr(0))
 10397  	libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fpath)
 10398  	if libc.Xclose(tls, (*Gz_state)(unsafe.Pointer(state)).Ffd) == -1 {
 10399  		ret = -1
 10400  	}
 10401  	libc.Xfree(tls, state)
 10402  	return ret
 10403  }
 10404  
 10405  // Reverse the bytes in a 32-bit value
 10406  
 10407  // inftrees.h -- header to use inftrees.c
 10408  // Copyright (C) 1995-2005, 2010 Mark Adler
 10409  // For conditions of distribution and use, see copyright notice in zlib.h
 10410  
 10411  // WARNING: this file should *not* be used by applications. It is
 10412  //    part of the implementation of the compression library and is
 10413  //    subject to change. Applications should only use zlib.h.
 10414  //
 10415  
 10416  // Structure for decoding tables.  Each entry provides either the
 10417  //    information needed to do the operation requested by the code that
 10418  //    indexed that table entry, or it provides a pointer to another
 10419  //    table that indexes more bits of the code.  op indicates whether
 10420  //    the entry is a pointer to another table, a literal, a length or
 10421  //    distance, an end-of-block, or an invalid code.  For a table
 10422  //    pointer, the low four bits of op is the number of index bits of
 10423  //    that table.  For a length or distance, the low four bits of op
 10424  //    is the number of extra bits to get after the code.  bits is
 10425  //    the number of bits in this code or part of the code to drop off
 10426  //    of the bit buffer.  val is the actual byte to output in the case
 10427  //    of a literal, the base length or distance, or the offset from
 10428  //    the current table to the next table.  Each entry is four bytes.
 10429  type Code = struct {
 10430  	Fop   uint8
 10431  	Fbits uint8
 10432  	Fval  uint16
 10433  } /* inftrees.h:28:3 */
 10434  
 10435  // op values as set by inflate_table():
 10436  //     00000000 - literal
 10437  //     0000tttt - table link, tttt != 0 is the number of table index bits
 10438  //     0001eeee - length or distance, eeee is the number of extra bits
 10439  //     01100000 - end of block
 10440  //     01000000 - invalid code
 10441  //
 10442  
 10443  // Maximum size of the dynamic table.  The maximum number of code structures is
 10444  //    1444, which is the sum of 852 for literal/length codes and 592 for distance
 10445  //    codes.  These values were found by exhaustive searches using the program
 10446  //    examples/enough.c found in the zlib distribtution.  The arguments to that
 10447  //    program are the number of symbols, the initial root table size, and the
 10448  //    maximum bit length of a code.  "enough 286 9 15" for literal/length codes
 10449  //    returns returns 852, and "enough 30 6 15" for distance codes returns 592.
 10450  //    The initial root table size (9 or 6) is found in the fifth argument of the
 10451  //    inflate_table() calls in inflate.c and infback.c.  If the root table size is
 10452  //    changed, then these maximum sizes would be need to be recalculated and
 10453  //    updated.
 10454  
 10455  // Type of code to build for inflate_table()
 10456  type Codetype = uint32 /* inftrees.h:58:3 */
 10457  // inflate.h -- internal inflate state definition
 10458  // Copyright (C) 1995-2016 Mark Adler
 10459  // For conditions of distribution and use, see copyright notice in zlib.h
 10460  
 10461  // WARNING: this file should *not* be used by applications. It is
 10462  //    part of the implementation of the compression library and is
 10463  //    subject to change. Applications should only use zlib.h.
 10464  //
 10465  
 10466  // define NO_GZIP when compiling if you want to disable gzip header and
 10467  //    trailer decoding by inflate().  NO_GZIP would be used to avoid linking in
 10468  //    the crc code when it is not needed.  For shared libraries, gzip decoding
 10469  //    should be left enabled.
 10470  
 10471  // Possible inflate modes between inflate() calls
 10472  type Inflate_mode = uint32 /* inflate.h:53:3 */
 10473  
 10474  //
 10475  //     State transitions between above modes -
 10476  //
 10477  //     (most modes can go to BAD or MEM on error -- not shown for clarity)
 10478  //
 10479  //     Process header:
 10480  //         HEAD -> (gzip) or (zlib) or (raw)
 10481  //         (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME -> COMMENT ->
 10482  //                   HCRC -> TYPE
 10483  //         (zlib) -> DICTID or TYPE
 10484  //         DICTID -> DICT -> TYPE
 10485  //         (raw) -> TYPEDO
 10486  //     Read deflate blocks:
 10487  //             TYPE -> TYPEDO -> STORED or TABLE or LEN_ or CHECK
 10488  //             STORED -> COPY_ -> COPY -> TYPE
 10489  //             TABLE -> LENLENS -> CODELENS -> LEN_
 10490  //             LEN_ -> LEN
 10491  //     Read deflate codes in fixed or dynamic block:
 10492  //                 LEN -> LENEXT or LIT or TYPE
 10493  //                 LENEXT -> DIST -> DISTEXT -> MATCH -> LEN
 10494  //                 LIT -> LEN
 10495  //     Process trailer:
 10496  //         CHECK -> LENGTH -> DONE
 10497  //
 10498  
 10499  // State maintained between inflate() calls -- approximately 7K bytes, not
 10500  //    including the allocated sliding window, which is up to 32K bytes.
 10501  type Inflate_state = struct {
 10502  	Fstrm        Z_streamp
 10503  	Fmode        Inflate_mode
 10504  	Flast        int32
 10505  	Fwrap        int32
 10506  	Fhavedict    int32
 10507  	Fflags       int32
 10508  	Fdmax        uint32
 10509  	Fcheck       uint64
 10510  	Ftotal       uint64
 10511  	Fhead        Gz_headerp
 10512  	Fwbits       uint32
 10513  	Fwsize       uint32
 10514  	Fwhave       uint32
 10515  	Fwnext       uint32
 10516  	Fwindow      uintptr
 10517  	Fhold        uint64
 10518  	Fbits        uint32
 10519  	Flength      uint32
 10520  	Foffset      uint32
 10521  	Fextra       uint32
 10522  	Flencode     uintptr
 10523  	Fdistcode    uintptr
 10524  	Flenbits     uint32
 10525  	Fdistbits    uint32
 10526  	Fncode       uint32
 10527  	Fnlen        uint32
 10528  	Fndist       uint32
 10529  	Fhave        uint32
 10530  	Fnext        uintptr
 10531  	Flens        [320]uint16
 10532  	Fwork        [288]uint16
 10533  	Fcodes       [1444]Code
 10534  	Fsane        int32
 10535  	Fback        int32
 10536  	Fwas         uint32
 10537  	F__ccgo_pad1 [4]byte
 10538  } /* inflate.h:82:1 */
 10539  
 10540  //
 10541  //    strm provides memory allocation functions in zalloc and zfree, or
 10542  //    Z_NULL to use the library memory allocation functions.
 10543  //
 10544  //    windowBits is in the range 8..15, and window is a user-supplied
 10545  //    window and output buffer that is 2**windowBits bytes.
 10546  //
 10547  func XinflateBackInit_(tls *libc.TLS, strm Z_streamp, windowBits int32, window uintptr, version uintptr, stream_size int32) int32 { /* infback.c:28:13: */
 10548  	var state uintptr
 10549  
 10550  	if version == uintptr(Z_NULL) || int32(*(*uint8)(unsafe.Pointer(version))) != int32(*(*uint8)(unsafe.Pointer(ts))) || stream_size != int32(unsafe.Sizeof(Z_stream{})) {
 10551  		return -6
 10552  	}
 10553  	if strm == uintptr(Z_NULL) || window == uintptr(Z_NULL) || windowBits < 8 || windowBits > 15 {
 10554  		return -2
 10555  	}
 10556  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = uintptr(Z_NULL) // in case we return an error
 10557  	if (*Z_stream)(unsafe.Pointer(strm)).Fzalloc == uintptr(0) {
 10558  		(*Z_stream)(unsafe.Pointer(strm)).Fzalloc = *(*uintptr)(unsafe.Pointer(&struct {
 10559  			f func(*libc.TLS, Voidpf, uint32, uint32) Voidpf
 10560  		}{Xzcalloc}))
 10561  		(*Z_stream)(unsafe.Pointer(strm)).Fopaque = uintptr(0)
 10562  	}
 10563  	if (*Z_stream)(unsafe.Pointer(strm)).Fzfree == uintptr(0) {
 10564  		(*Z_stream)(unsafe.Pointer(strm)).Fzfree = *(*uintptr)(unsafe.Pointer(&struct {
 10565  			f func(*libc.TLS, Voidpf, Voidpf)
 10566  		}{Xzcfree}))
 10567  	}
 10568  	state = (*struct {
 10569  		f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf
 10570  	})(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer(strm)).Fzalloc})).f(tls, (*Z_stream)(unsafe.Pointer(strm)).Fopaque, uint32(1), uint32(unsafe.Sizeof(Inflate_state{})))
 10571  	if state == uintptr(Z_NULL) {
 10572  		return -4
 10573  	}
 10574  
 10575  	(*Z_stream)(unsafe.Pointer(strm)).Fstate = state
 10576  	(*Inflate_state)(unsafe.Pointer(state)).Fdmax = 32768
 10577  	(*Inflate_state)(unsafe.Pointer(state)).Fwbits = UInt(windowBits)
 10578  	(*Inflate_state)(unsafe.Pointer(state)).Fwsize = uint32(1) << windowBits
 10579  	(*Inflate_state)(unsafe.Pointer(state)).Fwindow = window
 10580  	(*Inflate_state)(unsafe.Pointer(state)).Fwnext = uint32(0)
 10581  	(*Inflate_state)(unsafe.Pointer(state)).Fwhave = uint32(0)
 10582  	return Z_OK
 10583  }
 10584  
 10585  //
 10586  //    Return state with length and distance decoding tables and index sizes set to
 10587  //    fixed code decoding.  Normally this returns fixed tables from inffixed.h.
 10588  //    If BUILDFIXED is defined, then instead this routine builds the tables the
 10589  //    first time it's called, and returns those tables the first time and
 10590  //    thereafter.  This reduces the size of the code by about 2K bytes, in
 10591  //    exchange for a little execution time.  However, BUILDFIXED should not be
 10592  //    used for threaded applications, since the rewriting of the tables and virgin
 10593  //    may not be thread-safe.
 10594  //
 10595  func fixedtables(tls *libc.TLS, state uintptr) { /* infback.c:82:12: */
 10596  	(*Inflate_state)(unsafe.Pointer(state)).Flencode = uintptr(unsafe.Pointer(&lenfix))
 10597  	(*Inflate_state)(unsafe.Pointer(state)).Flenbits = uint32(9)
 10598  	(*Inflate_state)(unsafe.Pointer(state)).Fdistcode = uintptr(unsafe.Pointer(&distfix))
 10599  	(*Inflate_state)(unsafe.Pointer(state)).Fdistbits = uint32(5)
 10600  }
 10601  
 10602  var lenfix = [512]Code{
 10603  	{Fop: uint8(96), Fbits: uint8(7)}, {Fbits: uint8(8), Fval: uint16(80)}, {Fbits: uint8(8), Fval: uint16(16)}, {Fop: uint8(20), Fbits: uint8(8), Fval: uint16(115)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(31)}, {Fbits: uint8(8), Fval: uint16(112)}, {Fbits: uint8(8), Fval: uint16(48)},
 10604  	{Fbits: uint8(9), Fval: uint16(192)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(10)}, {Fbits: uint8(8), Fval: uint16(96)}, {Fbits: uint8(8), Fval: uint16(32)}, {Fbits: uint8(9), Fval: uint16(160)}, {Fbits: uint8(8)}, {Fbits: uint8(8), Fval: uint16(128)},
 10605  	{Fbits: uint8(8), Fval: uint16(64)}, {Fbits: uint8(9), Fval: uint16(224)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(6)}, {Fbits: uint8(8), Fval: uint16(88)}, {Fbits: uint8(8), Fval: uint16(24)}, {Fbits: uint8(9), Fval: uint16(144)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(59)},
 10606  	{Fbits: uint8(8), Fval: uint16(120)}, {Fbits: uint8(8), Fval: uint16(56)}, {Fbits: uint8(9), Fval: uint16(208)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(17)}, {Fbits: uint8(8), Fval: uint16(104)}, {Fbits: uint8(8), Fval: uint16(40)}, {Fbits: uint8(9), Fval: uint16(176)},
 10607  	{Fbits: uint8(8), Fval: uint16(8)}, {Fbits: uint8(8), Fval: uint16(136)}, {Fbits: uint8(8), Fval: uint16(72)}, {Fbits: uint8(9), Fval: uint16(240)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(4)}, {Fbits: uint8(8), Fval: uint16(84)}, {Fbits: uint8(8), Fval: uint16(20)},
 10608  	{Fop: uint8(21), Fbits: uint8(8), Fval: uint16(227)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(43)}, {Fbits: uint8(8), Fval: uint16(116)}, {Fbits: uint8(8), Fval: uint16(52)}, {Fbits: uint8(9), Fval: uint16(200)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(13)}, {Fbits: uint8(8), Fval: uint16(100)},
 10609  	{Fbits: uint8(8), Fval: uint16(36)}, {Fbits: uint8(9), Fval: uint16(168)}, {Fbits: uint8(8), Fval: uint16(4)}, {Fbits: uint8(8), Fval: uint16(132)}, {Fbits: uint8(8), Fval: uint16(68)}, {Fbits: uint8(9), Fval: uint16(232)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(8)},
 10610  	{Fbits: uint8(8), Fval: uint16(92)}, {Fbits: uint8(8), Fval: uint16(28)}, {Fbits: uint8(9), Fval: uint16(152)}, {Fop: uint8(20), Fbits: uint8(7), Fval: uint16(83)}, {Fbits: uint8(8), Fval: uint16(124)}, {Fbits: uint8(8), Fval: uint16(60)}, {Fbits: uint8(9), Fval: uint16(216)},
 10611  	{Fop: uint8(18), Fbits: uint8(7), Fval: uint16(23)}, {Fbits: uint8(8), Fval: uint16(108)}, {Fbits: uint8(8), Fval: uint16(44)}, {Fbits: uint8(9), Fval: uint16(184)}, {Fbits: uint8(8), Fval: uint16(12)}, {Fbits: uint8(8), Fval: uint16(140)}, {Fbits: uint8(8), Fval: uint16(76)},
 10612  	{Fbits: uint8(9), Fval: uint16(248)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(3)}, {Fbits: uint8(8), Fval: uint16(82)}, {Fbits: uint8(8), Fval: uint16(18)}, {Fop: uint8(21), Fbits: uint8(8), Fval: uint16(163)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(35)}, {Fbits: uint8(8), Fval: uint16(114)},
 10613  	{Fbits: uint8(8), Fval: uint16(50)}, {Fbits: uint8(9), Fval: uint16(196)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(11)}, {Fbits: uint8(8), Fval: uint16(98)}, {Fbits: uint8(8), Fval: uint16(34)}, {Fbits: uint8(9), Fval: uint16(164)}, {Fbits: uint8(8), Fval: uint16(2)},
 10614  	{Fbits: uint8(8), Fval: uint16(130)}, {Fbits: uint8(8), Fval: uint16(66)}, {Fbits: uint8(9), Fval: uint16(228)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(7)}, {Fbits: uint8(8), Fval: uint16(90)}, {Fbits: uint8(8), Fval: uint16(26)}, {Fbits: uint8(9), Fval: uint16(148)},
 10615  	{Fop: uint8(20), Fbits: uint8(7), Fval: uint16(67)}, {Fbits: uint8(8), Fval: uint16(122)}, {Fbits: uint8(8), Fval: uint16(58)}, {Fbits: uint8(9), Fval: uint16(212)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(19)}, {Fbits: uint8(8), Fval: uint16(106)}, {Fbits: uint8(8), Fval: uint16(42)},
 10616  	{Fbits: uint8(9), Fval: uint16(180)}, {Fbits: uint8(8), Fval: uint16(10)}, {Fbits: uint8(8), Fval: uint16(138)}, {Fbits: uint8(8), Fval: uint16(74)}, {Fbits: uint8(9), Fval: uint16(244)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(5)}, {Fbits: uint8(8), Fval: uint16(86)},
 10617  	{Fbits: uint8(8), Fval: uint16(22)}, {Fop: uint8(64), Fbits: uint8(8)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(51)}, {Fbits: uint8(8), Fval: uint16(118)}, {Fbits: uint8(8), Fval: uint16(54)}, {Fbits: uint8(9), Fval: uint16(204)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(15)},
 10618  	{Fbits: uint8(8), Fval: uint16(102)}, {Fbits: uint8(8), Fval: uint16(38)}, {Fbits: uint8(9), Fval: uint16(172)}, {Fbits: uint8(8), Fval: uint16(6)}, {Fbits: uint8(8), Fval: uint16(134)}, {Fbits: uint8(8), Fval: uint16(70)}, {Fbits: uint8(9), Fval: uint16(236)},
 10619  	{Fop: uint8(16), Fbits: uint8(7), Fval: uint16(9)}, {Fbits: uint8(8), Fval: uint16(94)}, {Fbits: uint8(8), Fval: uint16(30)}, {Fbits: uint8(9), Fval: uint16(156)}, {Fop: uint8(20), Fbits: uint8(7), Fval: uint16(99)}, {Fbits: uint8(8), Fval: uint16(126)}, {Fbits: uint8(8), Fval: uint16(62)},
 10620  	{Fbits: uint8(9), Fval: uint16(220)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(27)}, {Fbits: uint8(8), Fval: uint16(110)}, {Fbits: uint8(8), Fval: uint16(46)}, {Fbits: uint8(9), Fval: uint16(188)}, {Fbits: uint8(8), Fval: uint16(14)}, {Fbits: uint8(8), Fval: uint16(142)},
 10621  	{Fbits: uint8(8), Fval: uint16(78)}, {Fbits: uint8(9), Fval: uint16(252)}, {Fop: uint8(96), Fbits: uint8(7)}, {Fbits: uint8(8), Fval: uint16(81)}, {Fbits: uint8(8), Fval: uint16(17)}, {Fop: uint8(21), Fbits: uint8(8), Fval: uint16(131)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(31)},
 10622  	{Fbits: uint8(8), Fval: uint16(113)}, {Fbits: uint8(8), Fval: uint16(49)}, {Fbits: uint8(9), Fval: uint16(194)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(10)}, {Fbits: uint8(8), Fval: uint16(97)}, {Fbits: uint8(8), Fval: uint16(33)}, {Fbits: uint8(9), Fval: uint16(162)},
 10623  	{Fbits: uint8(8), Fval: uint16(1)}, {Fbits: uint8(8), Fval: uint16(129)}, {Fbits: uint8(8), Fval: uint16(65)}, {Fbits: uint8(9), Fval: uint16(226)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(6)}, {Fbits: uint8(8), Fval: uint16(89)}, {Fbits: uint8(8), Fval: uint16(25)},
 10624  	{Fbits: uint8(9), Fval: uint16(146)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(59)}, {Fbits: uint8(8), Fval: uint16(121)}, {Fbits: uint8(8), Fval: uint16(57)}, {Fbits: uint8(9), Fval: uint16(210)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(17)}, {Fbits: uint8(8), Fval: uint16(105)},
 10625  	{Fbits: uint8(8), Fval: uint16(41)}, {Fbits: uint8(9), Fval: uint16(178)}, {Fbits: uint8(8), Fval: uint16(9)}, {Fbits: uint8(8), Fval: uint16(137)}, {Fbits: uint8(8), Fval: uint16(73)}, {Fbits: uint8(9), Fval: uint16(242)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(4)},
 10626  	{Fbits: uint8(8), Fval: uint16(85)}, {Fbits: uint8(8), Fval: uint16(21)}, {Fop: uint8(16), Fbits: uint8(8), Fval: uint16(258)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(43)}, {Fbits: uint8(8), Fval: uint16(117)}, {Fbits: uint8(8), Fval: uint16(53)}, {Fbits: uint8(9), Fval: uint16(202)},
 10627  	{Fop: uint8(17), Fbits: uint8(7), Fval: uint16(13)}, {Fbits: uint8(8), Fval: uint16(101)}, {Fbits: uint8(8), Fval: uint16(37)}, {Fbits: uint8(9), Fval: uint16(170)}, {Fbits: uint8(8), Fval: uint16(5)}, {Fbits: uint8(8), Fval: uint16(133)}, {Fbits: uint8(8), Fval: uint16(69)},
 10628  	{Fbits: uint8(9), Fval: uint16(234)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(8)}, {Fbits: uint8(8), Fval: uint16(93)}, {Fbits: uint8(8), Fval: uint16(29)}, {Fbits: uint8(9), Fval: uint16(154)}, {Fop: uint8(20), Fbits: uint8(7), Fval: uint16(83)}, {Fbits: uint8(8), Fval: uint16(125)},
 10629  	{Fbits: uint8(8), Fval: uint16(61)}, {Fbits: uint8(9), Fval: uint16(218)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(23)}, {Fbits: uint8(8), Fval: uint16(109)}, {Fbits: uint8(8), Fval: uint16(45)}, {Fbits: uint8(9), Fval: uint16(186)}, {Fbits: uint8(8), Fval: uint16(13)},
 10630  	{Fbits: uint8(8), Fval: uint16(141)}, {Fbits: uint8(8), Fval: uint16(77)}, {Fbits: uint8(9), Fval: uint16(250)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(3)}, {Fbits: uint8(8), Fval: uint16(83)}, {Fbits: uint8(8), Fval: uint16(19)}, {Fop: uint8(21), Fbits: uint8(8), Fval: uint16(195)},
 10631  	{Fop: uint8(19), Fbits: uint8(7), Fval: uint16(35)}, {Fbits: uint8(8), Fval: uint16(115)}, {Fbits: uint8(8), Fval: uint16(51)}, {Fbits: uint8(9), Fval: uint16(198)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(11)}, {Fbits: uint8(8), Fval: uint16(99)}, {Fbits: uint8(8), Fval: uint16(35)},
 10632  	{Fbits: uint8(9), Fval: uint16(166)}, {Fbits: uint8(8), Fval: uint16(3)}, {Fbits: uint8(8), Fval: uint16(131)}, {Fbits: uint8(8), Fval: uint16(67)}, {Fbits: uint8(9), Fval: uint16(230)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(7)}, {Fbits: uint8(8), Fval: uint16(91)},
 10633  	{Fbits: uint8(8), Fval: uint16(27)}, {Fbits: uint8(9), Fval: uint16(150)}, {Fop: uint8(20), Fbits: uint8(7), Fval: uint16(67)}, {Fbits: uint8(8), Fval: uint16(123)}, {Fbits: uint8(8), Fval: uint16(59)}, {Fbits: uint8(9), Fval: uint16(214)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(19)},
 10634  	{Fbits: uint8(8), Fval: uint16(107)}, {Fbits: uint8(8), Fval: uint16(43)}, {Fbits: uint8(9), Fval: uint16(182)}, {Fbits: uint8(8), Fval: uint16(11)}, {Fbits: uint8(8), Fval: uint16(139)}, {Fbits: uint8(8), Fval: uint16(75)}, {Fbits: uint8(9), Fval: uint16(246)},
 10635  	{Fop: uint8(16), Fbits: uint8(7), Fval: uint16(5)}, {Fbits: uint8(8), Fval: uint16(87)}, {Fbits: uint8(8), Fval: uint16(23)}, {Fop: uint8(64), Fbits: uint8(8)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(51)}, {Fbits: uint8(8), Fval: uint16(119)}, {Fbits: uint8(8), Fval: uint16(55)},
 10636  	{Fbits: uint8(9), Fval: uint16(206)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(15)}, {Fbits: uint8(8), Fval: uint16(103)}, {Fbits: uint8(8), Fval: uint16(39)}, {Fbits: uint8(9), Fval: uint16(174)}, {Fbits: uint8(8), Fval: uint16(7)}, {Fbits: uint8(8), Fval: uint16(135)},
 10637  	{Fbits: uint8(8), Fval: uint16(71)}, {Fbits: uint8(9), Fval: uint16(238)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(9)}, {Fbits: uint8(8), Fval: uint16(95)}, {Fbits: uint8(8), Fval: uint16(31)}, {Fbits: uint8(9), Fval: uint16(158)}, {Fop: uint8(20), Fbits: uint8(7), Fval: uint16(99)},
 10638  	{Fbits: uint8(8), Fval: uint16(127)}, {Fbits: uint8(8), Fval: uint16(63)}, {Fbits: uint8(9), Fval: uint16(222)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(27)}, {Fbits: uint8(8), Fval: uint16(111)}, {Fbits: uint8(8), Fval: uint16(47)}, {Fbits: uint8(9), Fval: uint16(190)},
 10639  	{Fbits: uint8(8), Fval: uint16(15)}, {Fbits: uint8(8), Fval: uint16(143)}, {Fbits: uint8(8), Fval: uint16(79)}, {Fbits: uint8(9), Fval: uint16(254)}, {Fop: uint8(96), Fbits: uint8(7)}, {Fbits: uint8(8), Fval: uint16(80)}, {Fbits: uint8(8), Fval: uint16(16)},
 10640  	{Fop: uint8(20), Fbits: uint8(8), Fval: uint16(115)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(31)}, {Fbits: uint8(8), Fval: uint16(112)}, {Fbits: uint8(8), Fval: uint16(48)}, {Fbits: uint8(9), Fval: uint16(193)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(10)}, {Fbits: uint8(8), Fval: uint16(96)},
 10641  	{Fbits: uint8(8), Fval: uint16(32)}, {Fbits: uint8(9), Fval: uint16(161)}, {Fbits: uint8(8)}, {Fbits: uint8(8), Fval: uint16(128)}, {Fbits: uint8(8), Fval: uint16(64)}, {Fbits: uint8(9), Fval: uint16(225)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(6)},
 10642  	{Fbits: uint8(8), Fval: uint16(88)}, {Fbits: uint8(8), Fval: uint16(24)}, {Fbits: uint8(9), Fval: uint16(145)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(59)}, {Fbits: uint8(8), Fval: uint16(120)}, {Fbits: uint8(8), Fval: uint16(56)}, {Fbits: uint8(9), Fval: uint16(209)},
 10643  	{Fop: uint8(17), Fbits: uint8(7), Fval: uint16(17)}, {Fbits: uint8(8), Fval: uint16(104)}, {Fbits: uint8(8), Fval: uint16(40)}, {Fbits: uint8(9), Fval: uint16(177)}, {Fbits: uint8(8), Fval: uint16(8)}, {Fbits: uint8(8), Fval: uint16(136)}, {Fbits: uint8(8), Fval: uint16(72)},
 10644  	{Fbits: uint8(9), Fval: uint16(241)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(4)}, {Fbits: uint8(8), Fval: uint16(84)}, {Fbits: uint8(8), Fval: uint16(20)}, {Fop: uint8(21), Fbits: uint8(8), Fval: uint16(227)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(43)}, {Fbits: uint8(8), Fval: uint16(116)},
 10645  	{Fbits: uint8(8), Fval: uint16(52)}, {Fbits: uint8(9), Fval: uint16(201)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(13)}, {Fbits: uint8(8), Fval: uint16(100)}, {Fbits: uint8(8), Fval: uint16(36)}, {Fbits: uint8(9), Fval: uint16(169)}, {Fbits: uint8(8), Fval: uint16(4)},
 10646  	{Fbits: uint8(8), Fval: uint16(132)}, {Fbits: uint8(8), Fval: uint16(68)}, {Fbits: uint8(9), Fval: uint16(233)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(8)}, {Fbits: uint8(8), Fval: uint16(92)}, {Fbits: uint8(8), Fval: uint16(28)}, {Fbits: uint8(9), Fval: uint16(153)},
 10647  	{Fop: uint8(20), Fbits: uint8(7), Fval: uint16(83)}, {Fbits: uint8(8), Fval: uint16(124)}, {Fbits: uint8(8), Fval: uint16(60)}, {Fbits: uint8(9), Fval: uint16(217)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(23)}, {Fbits: uint8(8), Fval: uint16(108)}, {Fbits: uint8(8), Fval: uint16(44)},
 10648  	{Fbits: uint8(9), Fval: uint16(185)}, {Fbits: uint8(8), Fval: uint16(12)}, {Fbits: uint8(8), Fval: uint16(140)}, {Fbits: uint8(8), Fval: uint16(76)}, {Fbits: uint8(9), Fval: uint16(249)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(3)}, {Fbits: uint8(8), Fval: uint16(82)},
 10649  	{Fbits: uint8(8), Fval: uint16(18)}, {Fop: uint8(21), Fbits: uint8(8), Fval: uint16(163)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(35)}, {Fbits: uint8(8), Fval: uint16(114)}, {Fbits: uint8(8), Fval: uint16(50)}, {Fbits: uint8(9), Fval: uint16(197)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(11)},
 10650  	{Fbits: uint8(8), Fval: uint16(98)}, {Fbits: uint8(8), Fval: uint16(34)}, {Fbits: uint8(9), Fval: uint16(165)}, {Fbits: uint8(8), Fval: uint16(2)}, {Fbits: uint8(8), Fval: uint16(130)}, {Fbits: uint8(8), Fval: uint16(66)}, {Fbits: uint8(9), Fval: uint16(229)},
 10651  	{Fop: uint8(16), Fbits: uint8(7), Fval: uint16(7)}, {Fbits: uint8(8), Fval: uint16(90)}, {Fbits: uint8(8), Fval: uint16(26)}, {Fbits: uint8(9), Fval: uint16(149)}, {Fop: uint8(20), Fbits: uint8(7), Fval: uint16(67)}, {Fbits: uint8(8), Fval: uint16(122)}, {Fbits: uint8(8), Fval: uint16(58)},
 10652  	{Fbits: uint8(9), Fval: uint16(213)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(19)}, {Fbits: uint8(8), Fval: uint16(106)}, {Fbits: uint8(8), Fval: uint16(42)}, {Fbits: uint8(9), Fval: uint16(181)}, {Fbits: uint8(8), Fval: uint16(10)}, {Fbits: uint8(8), Fval: uint16(138)},
 10653  	{Fbits: uint8(8), Fval: uint16(74)}, {Fbits: uint8(9), Fval: uint16(245)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(5)}, {Fbits: uint8(8), Fval: uint16(86)}, {Fbits: uint8(8), Fval: uint16(22)}, {Fop: uint8(64), Fbits: uint8(8)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(51)},
 10654  	{Fbits: uint8(8), Fval: uint16(118)}, {Fbits: uint8(8), Fval: uint16(54)}, {Fbits: uint8(9), Fval: uint16(205)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(15)}, {Fbits: uint8(8), Fval: uint16(102)}, {Fbits: uint8(8), Fval: uint16(38)}, {Fbits: uint8(9), Fval: uint16(173)},
 10655  	{Fbits: uint8(8), Fval: uint16(6)}, {Fbits: uint8(8), Fval: uint16(134)}, {Fbits: uint8(8), Fval: uint16(70)}, {Fbits: uint8(9), Fval: uint16(237)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(9)}, {Fbits: uint8(8), Fval: uint16(94)}, {Fbits: uint8(8), Fval: uint16(30)},
 10656  	{Fbits: uint8(9), Fval: uint16(157)}, {Fop: uint8(20), Fbits: uint8(7), Fval: uint16(99)}, {Fbits: uint8(8), Fval: uint16(126)}, {Fbits: uint8(8), Fval: uint16(62)}, {Fbits: uint8(9), Fval: uint16(221)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(27)}, {Fbits: uint8(8), Fval: uint16(110)},
 10657  	{Fbits: uint8(8), Fval: uint16(46)}, {Fbits: uint8(9), Fval: uint16(189)}, {Fbits: uint8(8), Fval: uint16(14)}, {Fbits: uint8(8), Fval: uint16(142)}, {Fbits: uint8(8), Fval: uint16(78)}, {Fbits: uint8(9), Fval: uint16(253)}, {Fop: uint8(96), Fbits: uint8(7)},
 10658  	{Fbits: uint8(8), Fval: uint16(81)}, {Fbits: uint8(8), Fval: uint16(17)}, {Fop: uint8(21), Fbits: uint8(8), Fval: uint16(131)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(31)}, {Fbits: uint8(8), Fval: uint16(113)}, {Fbits: uint8(8), Fval: uint16(49)}, {Fbits: uint8(9), Fval: uint16(195)},
 10659  	{Fop: uint8(16), Fbits: uint8(7), Fval: uint16(10)}, {Fbits: uint8(8), Fval: uint16(97)}, {Fbits: uint8(8), Fval: uint16(33)}, {Fbits: uint8(9), Fval: uint16(163)}, {Fbits: uint8(8), Fval: uint16(1)}, {Fbits: uint8(8), Fval: uint16(129)}, {Fbits: uint8(8), Fval: uint16(65)},
 10660  	{Fbits: uint8(9), Fval: uint16(227)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(6)}, {Fbits: uint8(8), Fval: uint16(89)}, {Fbits: uint8(8), Fval: uint16(25)}, {Fbits: uint8(9), Fval: uint16(147)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(59)}, {Fbits: uint8(8), Fval: uint16(121)},
 10661  	{Fbits: uint8(8), Fval: uint16(57)}, {Fbits: uint8(9), Fval: uint16(211)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(17)}, {Fbits: uint8(8), Fval: uint16(105)}, {Fbits: uint8(8), Fval: uint16(41)}, {Fbits: uint8(9), Fval: uint16(179)}, {Fbits: uint8(8), Fval: uint16(9)},
 10662  	{Fbits: uint8(8), Fval: uint16(137)}, {Fbits: uint8(8), Fval: uint16(73)}, {Fbits: uint8(9), Fval: uint16(243)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(4)}, {Fbits: uint8(8), Fval: uint16(85)}, {Fbits: uint8(8), Fval: uint16(21)}, {Fop: uint8(16), Fbits: uint8(8), Fval: uint16(258)},
 10663  	{Fop: uint8(19), Fbits: uint8(7), Fval: uint16(43)}, {Fbits: uint8(8), Fval: uint16(117)}, {Fbits: uint8(8), Fval: uint16(53)}, {Fbits: uint8(9), Fval: uint16(203)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(13)}, {Fbits: uint8(8), Fval: uint16(101)}, {Fbits: uint8(8), Fval: uint16(37)},
 10664  	{Fbits: uint8(9), Fval: uint16(171)}, {Fbits: uint8(8), Fval: uint16(5)}, {Fbits: uint8(8), Fval: uint16(133)}, {Fbits: uint8(8), Fval: uint16(69)}, {Fbits: uint8(9), Fval: uint16(235)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(8)}, {Fbits: uint8(8), Fval: uint16(93)},
 10665  	{Fbits: uint8(8), Fval: uint16(29)}, {Fbits: uint8(9), Fval: uint16(155)}, {Fop: uint8(20), Fbits: uint8(7), Fval: uint16(83)}, {Fbits: uint8(8), Fval: uint16(125)}, {Fbits: uint8(8), Fval: uint16(61)}, {Fbits: uint8(9), Fval: uint16(219)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(23)},
 10666  	{Fbits: uint8(8), Fval: uint16(109)}, {Fbits: uint8(8), Fval: uint16(45)}, {Fbits: uint8(9), Fval: uint16(187)}, {Fbits: uint8(8), Fval: uint16(13)}, {Fbits: uint8(8), Fval: uint16(141)}, {Fbits: uint8(8), Fval: uint16(77)}, {Fbits: uint8(9), Fval: uint16(251)},
 10667  	{Fop: uint8(16), Fbits: uint8(7), Fval: uint16(3)}, {Fbits: uint8(8), Fval: uint16(83)}, {Fbits: uint8(8), Fval: uint16(19)}, {Fop: uint8(21), Fbits: uint8(8), Fval: uint16(195)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(35)}, {Fbits: uint8(8), Fval: uint16(115)}, {Fbits: uint8(8), Fval: uint16(51)},
 10668  	{Fbits: uint8(9), Fval: uint16(199)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(11)}, {Fbits: uint8(8), Fval: uint16(99)}, {Fbits: uint8(8), Fval: uint16(35)}, {Fbits: uint8(9), Fval: uint16(167)}, {Fbits: uint8(8), Fval: uint16(3)}, {Fbits: uint8(8), Fval: uint16(131)},
 10669  	{Fbits: uint8(8), Fval: uint16(67)}, {Fbits: uint8(9), Fval: uint16(231)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(7)}, {Fbits: uint8(8), Fval: uint16(91)}, {Fbits: uint8(8), Fval: uint16(27)}, {Fbits: uint8(9), Fval: uint16(151)}, {Fop: uint8(20), Fbits: uint8(7), Fval: uint16(67)},
 10670  	{Fbits: uint8(8), Fval: uint16(123)}, {Fbits: uint8(8), Fval: uint16(59)}, {Fbits: uint8(9), Fval: uint16(215)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(19)}, {Fbits: uint8(8), Fval: uint16(107)}, {Fbits: uint8(8), Fval: uint16(43)}, {Fbits: uint8(9), Fval: uint16(183)},
 10671  	{Fbits: uint8(8), Fval: uint16(11)}, {Fbits: uint8(8), Fval: uint16(139)}, {Fbits: uint8(8), Fval: uint16(75)}, {Fbits: uint8(9), Fval: uint16(247)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(5)}, {Fbits: uint8(8), Fval: uint16(87)}, {Fbits: uint8(8), Fval: uint16(23)},
 10672  	{Fop: uint8(64), Fbits: uint8(8)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(51)}, {Fbits: uint8(8), Fval: uint16(119)}, {Fbits: uint8(8), Fval: uint16(55)}, {Fbits: uint8(9), Fval: uint16(207)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(15)}, {Fbits: uint8(8), Fval: uint16(103)},
 10673  	{Fbits: uint8(8), Fval: uint16(39)}, {Fbits: uint8(9), Fval: uint16(175)}, {Fbits: uint8(8), Fval: uint16(7)}, {Fbits: uint8(8), Fval: uint16(135)}, {Fbits: uint8(8), Fval: uint16(71)}, {Fbits: uint8(9), Fval: uint16(239)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(9)},
 10674  	{Fbits: uint8(8), Fval: uint16(95)}, {Fbits: uint8(8), Fval: uint16(31)}, {Fbits: uint8(9), Fval: uint16(159)}, {Fop: uint8(20), Fbits: uint8(7), Fval: uint16(99)}, {Fbits: uint8(8), Fval: uint16(127)}, {Fbits: uint8(8), Fval: uint16(63)}, {Fbits: uint8(9), Fval: uint16(223)},
 10675  	{Fop: uint8(18), Fbits: uint8(7), Fval: uint16(27)}, {Fbits: uint8(8), Fval: uint16(111)}, {Fbits: uint8(8), Fval: uint16(47)}, {Fbits: uint8(9), Fval: uint16(191)}, {Fbits: uint8(8), Fval: uint16(15)}, {Fbits: uint8(8), Fval: uint16(143)}, {Fbits: uint8(8), Fval: uint16(79)},
 10676  	{Fbits: uint8(9), Fval: uint16(255)},
 10677  } /* inffixed.h:10:23 */
 10678  var distfix = [32]Code{
 10679  	{Fop: uint8(16), Fbits: uint8(5), Fval: uint16(1)}, {Fop: uint8(23), Fbits: uint8(5), Fval: uint16(257)}, {Fop: uint8(19), Fbits: uint8(5), Fval: uint16(17)}, {Fop: uint8(27), Fbits: uint8(5), Fval: uint16(4097)}, {Fop: uint8(17), Fbits: uint8(5), Fval: uint16(5)}, {Fop: uint8(25), Fbits: uint8(5), Fval: uint16(1025)},
 10680  	{Fop: uint8(21), Fbits: uint8(5), Fval: uint16(65)}, {Fop: uint8(29), Fbits: uint8(5), Fval: uint16(16385)}, {Fop: uint8(16), Fbits: uint8(5), Fval: uint16(3)}, {Fop: uint8(24), Fbits: uint8(5), Fval: uint16(513)}, {Fop: uint8(20), Fbits: uint8(5), Fval: uint16(33)}, {Fop: uint8(28), Fbits: uint8(5), Fval: uint16(8193)},
 10681  	{Fop: uint8(18), Fbits: uint8(5), Fval: uint16(9)}, {Fop: uint8(26), Fbits: uint8(5), Fval: uint16(2049)}, {Fop: uint8(22), Fbits: uint8(5), Fval: uint16(129)}, {Fop: uint8(64), Fbits: uint8(5)}, {Fop: uint8(16), Fbits: uint8(5), Fval: uint16(2)}, {Fop: uint8(23), Fbits: uint8(5), Fval: uint16(385)},
 10682  	{Fop: uint8(19), Fbits: uint8(5), Fval: uint16(25)}, {Fop: uint8(27), Fbits: uint8(5), Fval: uint16(6145)}, {Fop: uint8(17), Fbits: uint8(5), Fval: uint16(7)}, {Fop: uint8(25), Fbits: uint8(5), Fval: uint16(1537)}, {Fop: uint8(21), Fbits: uint8(5), Fval: uint16(97)}, {Fop: uint8(29), Fbits: uint8(5), Fval: uint16(24577)},
 10683  	{Fop: uint8(16), Fbits: uint8(5), Fval: uint16(4)}, {Fop: uint8(24), Fbits: uint8(5), Fval: uint16(769)}, {Fop: uint8(20), Fbits: uint8(5), Fval: uint16(49)}, {Fop: uint8(28), Fbits: uint8(5), Fval: uint16(12289)}, {Fop: uint8(18), Fbits: uint8(5), Fval: uint16(13)}, {Fop: uint8(26), Fbits: uint8(5), Fval: uint16(3073)},
 10684  	{Fop: uint8(22), Fbits: uint8(5), Fval: uint16(193)}, {Fop: uint8(64), Fbits: uint8(5)},
 10685  } /* inffixed.h:87:23 */
 10686  
 10687  // Macros for inflateBack():
 10688  
 10689  // Load returned state from inflate_fast()
 10690  
 10691  // Set state from registers for inflate_fast()
 10692  
 10693  // Clear the input bit accumulator
 10694  
 10695  // Assure that some input is available.  If input is requested, but denied,
 10696  //    then return a Z_BUF_ERROR from inflateBack().
 10697  
 10698  // Get a byte of input into the bit accumulator, or return from inflateBack()
 10699  //    with an error if there is no input available.
 10700  
 10701  // Assure that there are at least n bits in the bit accumulator.  If there is
 10702  //    not enough available input to do that, then return from inflateBack() with
 10703  //    an error.
 10704  
 10705  // Return the low n bits of the bit accumulator (n < 16)
 10706  
 10707  // Remove n bits from the bit accumulator
 10708  
 10709  // Remove zero to seven bits as needed to go to a byte boundary
 10710  
 10711  // Assure that some output space is available, by writing out the window
 10712  //    if it's full.  If the write fails, return from inflateBack() with a
 10713  //    Z_BUF_ERROR.
 10714  
 10715  //
 10716  //    strm provides the memory allocation functions and window buffer on input,
 10717  //    and provides information on the unused input on return.  For Z_DATA_ERROR
 10718  //    returns, strm will also provide an error message.
 10719  //
 10720  //    in() and out() are the call-back input and output functions.  When
 10721  //    inflateBack() needs more input, it calls in().  When inflateBack() has
 10722  //    filled the window with output, or when it completes with data in the
 10723  //    window, it calls out() to write out the data.  The application must not
 10724  //    change the provided input until in() is called again or inflateBack()
 10725  //    returns.  The application must not change the window/output buffer until
 10726  //    inflateBack() returns.
 10727  //
 10728  //    in() and out() are called with a descriptor parameter provided in the
 10729  //    inflateBack() call.  This parameter can be a structure that provides the
 10730  //    information required to do the read or write, as well as accumulated
 10731  //    information on the input and output such as totals and check values.
 10732  //
 10733  //    in() should return zero on failure.  out() should return non-zero on
 10734  //    failure.  If either in() or out() fails, than inflateBack() returns a
 10735  //    Z_BUF_ERROR.  strm->next_in can be checked for Z_NULL to see whether it
 10736  //    was in() or out() that caused in the error.  Otherwise,  inflateBack()
 10737  //    returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format
 10738  //    error, or Z_MEM_ERROR if it could not allocate memory for the state.
 10739  //    inflateBack() can also return Z_STREAM_ERROR if the input parameters
 10740  //    are not correct, i.e. strm is Z_NULL or the state was not initialized.
 10741  //
 10742  func XinflateBack(tls *libc.TLS, strm Z_streamp, in In_func, in_desc uintptr, out Out_func, out_desc uintptr) int32 { /* infback.c:250:13: */
 10743  	bp := tls.Alloc(8)
 10744  	defer tls.Free(8)
 10745  
 10746  	var state uintptr
 10747  	// var next uintptr at bp, 8
 10748  	// next input
 10749  	var put uintptr // next output
 10750  	var have uint32
 10751  	var left uint32  // available input and output
 10752  	var hold uint64  // bit buffer
 10753  	var bits uint32  // bits in bit buffer
 10754  	var copy uint32  // number of stored or match bytes to copy
 10755  	var from uintptr // where to copy match bytes from
 10756  	var here Code    // current decoding table entry
 10757  	var last Code    // parent table entry
 10758  	var len uint32   // length to copy for repeats, bits to drop
 10759  	var ret int32
 10760  
 10761  	// Check that the strm exists and that the state was initialized
 10762  	if !(strm == uintptr(Z_NULL) || (*Z_stream)(unsafe.Pointer(strm)).Fstate == uintptr(Z_NULL)) {
 10763  		goto __1
 10764  	}
 10765  	return -2
 10766  __1:
 10767  	;
 10768  	state = (*Z_stream)(unsafe.Pointer(strm)).Fstate
 10769  
 10770  	// Reset the state
 10771  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = uintptr(Z_NULL)
 10772  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = TYPE
 10773  	(*Inflate_state)(unsafe.Pointer(state)).Flast = 0
 10774  	(*Inflate_state)(unsafe.Pointer(state)).Fwhave = uint32(0)
 10775  	*(*uintptr)(unsafe.Pointer(bp /* next */)) = (*Z_stream)(unsafe.Pointer(strm)).Fnext_in
 10776  	if *(*uintptr)(unsafe.Pointer(bp)) != uintptr(Z_NULL) {
 10777  		have = (*Z_stream)(unsafe.Pointer(strm)).Favail_in
 10778  	} else {
 10779  		have = uint32(0)
 10780  	}
 10781  	hold = uint64(0)
 10782  	bits = uint32(0)
 10783  	put = (*Inflate_state)(unsafe.Pointer(state)).Fwindow
 10784  	left = (*Inflate_state)(unsafe.Pointer(state)).Fwsize
 10785  
 10786  	// Inflate until end of block marked as last
 10787  __2:
 10788  	switch (*Inflate_state)(unsafe.Pointer(state)).Fmode {
 10789  	case TYPE:
 10790  		goto __6
 10791  
 10792  	case STORED:
 10793  		goto __7
 10794  
 10795  	case TABLE:
 10796  		goto __8
 10797  
 10798  	case LEN:
 10799  		goto __9
 10800  
 10801  	case DONE:
 10802  		goto __10
 10803  
 10804  	case BAD:
 10805  		goto __11
 10806  
 10807  	default:
 10808  		goto __12
 10809  	}
 10810  	goto __5
 10811  __6:
 10812  	// determine and dispatch block type
 10813  	if !((*Inflate_state)(unsafe.Pointer(state)).Flast != 0) {
 10814  		goto __13
 10815  	}
 10816  __14:
 10817  	hold >>= bits & uint32(7)
 10818  	bits = bits - bits&uint32(7)
 10819  	goto __15
 10820  __15:
 10821  	if 0 != 0 {
 10822  		goto __14
 10823  	}
 10824  	goto __16
 10825  __16:
 10826  	;
 10827  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = DONE
 10828  	goto __5
 10829  __13:
 10830  	;
 10831  __17:
 10832  __20:
 10833  	if !(bits < uint32(3)) {
 10834  		goto __21
 10835  	}
 10836  __22:
 10837  __25:
 10838  	if !(have == uint32(0)) {
 10839  		goto __28
 10840  	}
 10841  	have = (*struct {
 10842  		f func(*libc.TLS, uintptr, uintptr) uint32
 10843  	})(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */)
 10844  	if !(have == uint32(0)) {
 10845  		goto __29
 10846  	}
 10847  	*(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL)
 10848  	ret = -5
 10849  	goto inf_leave
 10850  __29:
 10851  	;
 10852  __28:
 10853  	;
 10854  	goto __26
 10855  __26:
 10856  	if 0 != 0 {
 10857  		goto __25
 10858  	}
 10859  	goto __27
 10860  __27:
 10861  	;
 10862  	have--
 10863  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))<<bits
 10864  	bits = bits + uint32(8)
 10865  	goto __23
 10866  __23:
 10867  	if 0 != 0 {
 10868  		goto __22
 10869  	}
 10870  	goto __24
 10871  __24:
 10872  	;
 10873  	goto __20
 10874  __21:
 10875  	;
 10876  	goto __18
 10877  __18:
 10878  	if 0 != 0 {
 10879  		goto __17
 10880  	}
 10881  	goto __19
 10882  __19:
 10883  	;
 10884  	(*Inflate_state)(unsafe.Pointer(state)).Flast = int32(uint32(hold) & (uint32(1)<<1 - uint32(1)))
 10885  __30:
 10886  	hold >>= 1
 10887  	bits = bits - uint32(1)
 10888  	goto __31
 10889  __31:
 10890  	if 0 != 0 {
 10891  		goto __30
 10892  	}
 10893  	goto __32
 10894  __32:
 10895  	;
 10896  	switch uint32(hold) & (uint32(1)<<2 - uint32(1)) {
 10897  	case uint32(0):
 10898  		goto __34
 10899  	case uint32(1):
 10900  		goto __35
 10901  	case uint32(2):
 10902  		goto __36
 10903  	case uint32(3):
 10904  		goto __37
 10905  	}
 10906  	goto __33
 10907  __34: // stored block
 10908  	;
 10909  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = STORED
 10910  	goto __33
 10911  __35: // fixed block
 10912  	fixedtables(tls, state)
 10913  
 10914  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = LEN // decode codes
 10915  	goto __33
 10916  __36: // dynamic block
 10917  	;
 10918  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = TABLE
 10919  	goto __33
 10920  __37:
 10921  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 367 /* "invalid block ty..." */
 10922  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 10923  __33:
 10924  	;
 10925  __38:
 10926  	hold >>= 2
 10927  	bits = bits - uint32(2)
 10928  	goto __39
 10929  __39:
 10930  	if 0 != 0 {
 10931  		goto __38
 10932  	}
 10933  	goto __40
 10934  __40:
 10935  	;
 10936  	goto __5
 10937  
 10938  __7:
 10939  	// get and verify stored block length
 10940  __41:
 10941  	hold >>= bits & uint32(7)
 10942  	bits = bits - bits&uint32(7)
 10943  	goto __42
 10944  __42:
 10945  	if 0 != 0 {
 10946  		goto __41
 10947  	}
 10948  	goto __43
 10949  __43:
 10950  	; // go to byte boundary
 10951  __44:
 10952  __47:
 10953  	if !(bits < uint32(32)) {
 10954  		goto __48
 10955  	}
 10956  __49:
 10957  __52:
 10958  	if !(have == uint32(0)) {
 10959  		goto __55
 10960  	}
 10961  	have = (*struct {
 10962  		f func(*libc.TLS, uintptr, uintptr) uint32
 10963  	})(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */)
 10964  	if !(have == uint32(0)) {
 10965  		goto __56
 10966  	}
 10967  	*(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL)
 10968  	ret = -5
 10969  	goto inf_leave
 10970  __56:
 10971  	;
 10972  __55:
 10973  	;
 10974  	goto __53
 10975  __53:
 10976  	if 0 != 0 {
 10977  		goto __52
 10978  	}
 10979  	goto __54
 10980  __54:
 10981  	;
 10982  	have--
 10983  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))<<bits
 10984  	bits = bits + uint32(8)
 10985  	goto __50
 10986  __50:
 10987  	if 0 != 0 {
 10988  		goto __49
 10989  	}
 10990  	goto __51
 10991  __51:
 10992  	;
 10993  	goto __47
 10994  __48:
 10995  	;
 10996  	goto __45
 10997  __45:
 10998  	if 0 != 0 {
 10999  		goto __44
 11000  	}
 11001  	goto __46
 11002  __46:
 11003  	;
 11004  	if !(hold&uint64(0xffff) != hold>>16^uint64(0xffff)) {
 11005  		goto __57
 11006  	}
 11007  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 386 /* "invalid stored b..." */
 11008  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 11009  	goto __5
 11010  __57:
 11011  	;
 11012  	(*Inflate_state)(unsafe.Pointer(state)).Flength = uint32(hold) & uint32(0xffff)
 11013  
 11014  __58:
 11015  	hold = uint64(0)
 11016  	bits = uint32(0)
 11017  	goto __59
 11018  __59:
 11019  	if 0 != 0 {
 11020  		goto __58
 11021  	}
 11022  	goto __60
 11023  __60:
 11024  	;
 11025  
 11026  	// copy stored block from input to output
 11027  __61:
 11028  	if !((*Inflate_state)(unsafe.Pointer(state)).Flength != uint32(0)) {
 11029  		goto __62
 11030  	}
 11031  	copy = (*Inflate_state)(unsafe.Pointer(state)).Flength
 11032  __63:
 11033  	if !(have == uint32(0)) {
 11034  		goto __66
 11035  	}
 11036  	have = (*struct {
 11037  		f func(*libc.TLS, uintptr, uintptr) uint32
 11038  	})(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */)
 11039  	if !(have == uint32(0)) {
 11040  		goto __67
 11041  	}
 11042  	*(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL)
 11043  	ret = -5
 11044  	goto inf_leave
 11045  __67:
 11046  	;
 11047  __66:
 11048  	;
 11049  	goto __64
 11050  __64:
 11051  	if 0 != 0 {
 11052  		goto __63
 11053  	}
 11054  	goto __65
 11055  __65:
 11056  	;
 11057  __68:
 11058  	if !(left == uint32(0)) {
 11059  		goto __71
 11060  	}
 11061  	put = (*Inflate_state)(unsafe.Pointer(state)).Fwindow
 11062  	left = (*Inflate_state)(unsafe.Pointer(state)).Fwsize
 11063  	(*Inflate_state)(unsafe.Pointer(state)).Fwhave = left
 11064  	if !((*struct {
 11065  		f func(*libc.TLS, uintptr, uintptr, uint32) int32
 11066  	})(unsafe.Pointer(&struct{ uintptr }{out})).f(tls, out_desc, put, left) != 0) {
 11067  		goto __72
 11068  	}
 11069  	ret = -5
 11070  	goto inf_leave
 11071  __72:
 11072  	;
 11073  __71:
 11074  	;
 11075  	goto __69
 11076  __69:
 11077  	if 0 != 0 {
 11078  		goto __68
 11079  	}
 11080  	goto __70
 11081  __70:
 11082  	;
 11083  	if !(copy > have) {
 11084  		goto __73
 11085  	}
 11086  	copy = have
 11087  __73:
 11088  	;
 11089  	if !(copy > left) {
 11090  		goto __74
 11091  	}
 11092  	copy = left
 11093  __74:
 11094  	;
 11095  	libc.Xmemcpy(tls, put, *(*uintptr)(unsafe.Pointer(bp /* next */)), uint64(copy))
 11096  	have = have - copy
 11097  	*(*uintptr)(unsafe.Pointer(bp /* next */)) += uintptr(copy)
 11098  	left = left - copy
 11099  	put += uintptr(copy)
 11100  	*(*uint32)(unsafe.Pointer(state + 92)) -= copy
 11101  	goto __61
 11102  __62:
 11103  	;
 11104  
 11105  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = TYPE
 11106  	goto __5
 11107  
 11108  __8:
 11109  	// get dynamic table entries descriptor
 11110  __75:
 11111  __78:
 11112  	if !(bits < uint32(14)) {
 11113  		goto __79
 11114  	}
 11115  __80:
 11116  __83:
 11117  	if !(have == uint32(0)) {
 11118  		goto __86
 11119  	}
 11120  	have = (*struct {
 11121  		f func(*libc.TLS, uintptr, uintptr) uint32
 11122  	})(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */)
 11123  	if !(have == uint32(0)) {
 11124  		goto __87
 11125  	}
 11126  	*(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL)
 11127  	ret = -5
 11128  	goto inf_leave
 11129  __87:
 11130  	;
 11131  __86:
 11132  	;
 11133  	goto __84
 11134  __84:
 11135  	if 0 != 0 {
 11136  		goto __83
 11137  	}
 11138  	goto __85
 11139  __85:
 11140  	;
 11141  	have--
 11142  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))<<bits
 11143  	bits = bits + uint32(8)
 11144  	goto __81
 11145  __81:
 11146  	if 0 != 0 {
 11147  		goto __80
 11148  	}
 11149  	goto __82
 11150  __82:
 11151  	;
 11152  	goto __78
 11153  __79:
 11154  	;
 11155  	goto __76
 11156  __76:
 11157  	if 0 != 0 {
 11158  		goto __75
 11159  	}
 11160  	goto __77
 11161  __77:
 11162  	;
 11163  	(*Inflate_state)(unsafe.Pointer(state)).Fnlen = uint32(hold)&(uint32(1)<<5-uint32(1)) + uint32(257)
 11164  __88:
 11165  	hold >>= 5
 11166  	bits = bits - uint32(5)
 11167  	goto __89
 11168  __89:
 11169  	if 0 != 0 {
 11170  		goto __88
 11171  	}
 11172  	goto __90
 11173  __90:
 11174  	;
 11175  	(*Inflate_state)(unsafe.Pointer(state)).Fndist = uint32(hold)&(uint32(1)<<5-uint32(1)) + uint32(1)
 11176  __91:
 11177  	hold >>= 5
 11178  	bits = bits - uint32(5)
 11179  	goto __92
 11180  __92:
 11181  	if 0 != 0 {
 11182  		goto __91
 11183  	}
 11184  	goto __93
 11185  __93:
 11186  	;
 11187  	(*Inflate_state)(unsafe.Pointer(state)).Fncode = uint32(hold)&(uint32(1)<<4-uint32(1)) + uint32(4)
 11188  __94:
 11189  	hold >>= 4
 11190  	bits = bits - uint32(4)
 11191  	goto __95
 11192  __95:
 11193  	if 0 != 0 {
 11194  		goto __94
 11195  	}
 11196  	goto __96
 11197  __96:
 11198  	;
 11199  	if !((*Inflate_state)(unsafe.Pointer(state)).Fnlen > uint32(286) || (*Inflate_state)(unsafe.Pointer(state)).Fndist > uint32(30)) {
 11200  		goto __97
 11201  	}
 11202  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 415 /* "too many length ..." */
 11203  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 11204  	goto __5
 11205  __97:
 11206  	;
 11207  
 11208  	// get code length code lengths (not a typo)
 11209  	(*Inflate_state)(unsafe.Pointer(state)).Fhave = uint32(0)
 11210  __98:
 11211  	if !((*Inflate_state)(unsafe.Pointer(state)).Fhave < (*Inflate_state)(unsafe.Pointer(state)).Fncode) {
 11212  		goto __99
 11213  	}
 11214  __100:
 11215  __103:
 11216  	if !(bits < uint32(3)) {
 11217  		goto __104
 11218  	}
 11219  __105:
 11220  __108:
 11221  	if !(have == uint32(0)) {
 11222  		goto __111
 11223  	}
 11224  	have = (*struct {
 11225  		f func(*libc.TLS, uintptr, uintptr) uint32
 11226  	})(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */)
 11227  	if !(have == uint32(0)) {
 11228  		goto __112
 11229  	}
 11230  	*(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL)
 11231  	ret = -5
 11232  	goto inf_leave
 11233  __112:
 11234  	;
 11235  __111:
 11236  	;
 11237  	goto __109
 11238  __109:
 11239  	if 0 != 0 {
 11240  		goto __108
 11241  	}
 11242  	goto __110
 11243  __110:
 11244  	;
 11245  	have--
 11246  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))<<bits
 11247  	bits = bits + uint32(8)
 11248  	goto __106
 11249  __106:
 11250  	if 0 != 0 {
 11251  		goto __105
 11252  	}
 11253  	goto __107
 11254  __107:
 11255  	;
 11256  	goto __103
 11257  __104:
 11258  	;
 11259  	goto __101
 11260  __101:
 11261  	if 0 != 0 {
 11262  		goto __100
 11263  	}
 11264  	goto __102
 11265  __102:
 11266  	;
 11267  	*(*uint16)(unsafe.Pointer(state + 152 + uintptr(order[libc.PostIncUint32(&(*Inflate_state)(unsafe.Pointer(state)).Fhave, 1)])*2)) = uint16(uint32(hold) & (uint32(1)<<3 - uint32(1)))
 11268  __113:
 11269  	hold >>= 3
 11270  	bits = bits - uint32(3)
 11271  	goto __114
 11272  __114:
 11273  	if 0 != 0 {
 11274  		goto __113
 11275  	}
 11276  	goto __115
 11277  __115:
 11278  	;
 11279  	goto __98
 11280  __99:
 11281  	;
 11282  __116:
 11283  	if !((*Inflate_state)(unsafe.Pointer(state)).Fhave < uint32(19)) {
 11284  		goto __117
 11285  	}
 11286  	*(*uint16)(unsafe.Pointer(state + 152 + uintptr(order[libc.PostIncUint32(&(*Inflate_state)(unsafe.Pointer(state)).Fhave, 1)])*2)) = uint16(0)
 11287  	goto __116
 11288  __117:
 11289  	;
 11290  	(*Inflate_state)(unsafe.Pointer(state)).Fnext = state + 1368 /* &.codes */
 11291  	(*Inflate_state)(unsafe.Pointer(state)).Flencode = (*Inflate_state)(unsafe.Pointer(state)).Fnext
 11292  	(*Inflate_state)(unsafe.Pointer(state)).Flenbits = uint32(7)
 11293  	ret = Xinflate_table(tls, CODES, state+152, uint32(19), state+144,
 11294  		state+120, state+792)
 11295  	if !(ret != 0) {
 11296  		goto __118
 11297  	}
 11298  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 451 /* "invalid code len..." */
 11299  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 11300  	goto __5
 11301  __118:
 11302  	;
 11303  
 11304  	// get length and distance code code lengths
 11305  	(*Inflate_state)(unsafe.Pointer(state)).Fhave = uint32(0)
 11306  __119:
 11307  	if !((*Inflate_state)(unsafe.Pointer(state)).Fhave < (*Inflate_state)(unsafe.Pointer(state)).Fnlen+(*Inflate_state)(unsafe.Pointer(state)).Fndist) {
 11308  		goto __120
 11309  	}
 11310  __121:
 11311  	here = *(*Code)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Flencode + uintptr(uint32(hold)&(uint32(1)<<(*Inflate_state)(unsafe.Pointer(state)).Flenbits-uint32(1)))*4))
 11312  	if !(uint32(here.Fbits) <= bits) {
 11313  		goto __124
 11314  	}
 11315  	goto __123
 11316  __124:
 11317  	;
 11318  __125:
 11319  __128:
 11320  	if !(have == uint32(0)) {
 11321  		goto __131
 11322  	}
 11323  	have = (*struct {
 11324  		f func(*libc.TLS, uintptr, uintptr) uint32
 11325  	})(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */)
 11326  	if !(have == uint32(0)) {
 11327  		goto __132
 11328  	}
 11329  	*(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL)
 11330  	ret = -5
 11331  	goto inf_leave
 11332  __132:
 11333  	;
 11334  __131:
 11335  	;
 11336  	goto __129
 11337  __129:
 11338  	if 0 != 0 {
 11339  		goto __128
 11340  	}
 11341  	goto __130
 11342  __130:
 11343  	;
 11344  	have--
 11345  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))<<bits
 11346  	bits = bits + uint32(8)
 11347  	goto __126
 11348  __126:
 11349  	if 0 != 0 {
 11350  		goto __125
 11351  	}
 11352  	goto __127
 11353  __127:
 11354  	;
 11355  	goto __122
 11356  __122:
 11357  	goto __121
 11358  	goto __123
 11359  __123:
 11360  	;
 11361  	if !(int32(here.Fval) < 16) {
 11362  		goto __133
 11363  	}
 11364  __135:
 11365  	hold >>= int32(here.Fbits)
 11366  	bits = bits - uint32(here.Fbits)
 11367  	goto __136
 11368  __136:
 11369  	if 0 != 0 {
 11370  		goto __135
 11371  	}
 11372  	goto __137
 11373  __137:
 11374  	;
 11375  	*(*uint16)(unsafe.Pointer(state + 152 + uintptr(libc.PostIncUint32(&(*Inflate_state)(unsafe.Pointer(state)).Fhave, 1))*2)) = here.Fval
 11376  	goto __134
 11377  __133:
 11378  	if !(int32(here.Fval) == 16) {
 11379  		goto __138
 11380  	}
 11381  __140:
 11382  __143:
 11383  	if !(bits < uint32(int32(here.Fbits)+2)) {
 11384  		goto __144
 11385  	}
 11386  __145:
 11387  __148:
 11388  	if !(have == uint32(0)) {
 11389  		goto __151
 11390  	}
 11391  	have = (*struct {
 11392  		f func(*libc.TLS, uintptr, uintptr) uint32
 11393  	})(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */)
 11394  	if !(have == uint32(0)) {
 11395  		goto __152
 11396  	}
 11397  	*(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL)
 11398  	ret = -5
 11399  	goto inf_leave
 11400  __152:
 11401  	;
 11402  __151:
 11403  	;
 11404  	goto __149
 11405  __149:
 11406  	if 0 != 0 {
 11407  		goto __148
 11408  	}
 11409  	goto __150
 11410  __150:
 11411  	;
 11412  	have--
 11413  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))<<bits
 11414  	bits = bits + uint32(8)
 11415  	goto __146
 11416  __146:
 11417  	if 0 != 0 {
 11418  		goto __145
 11419  	}
 11420  	goto __147
 11421  __147:
 11422  	;
 11423  	goto __143
 11424  __144:
 11425  	;
 11426  	goto __141
 11427  __141:
 11428  	if 0 != 0 {
 11429  		goto __140
 11430  	}
 11431  	goto __142
 11432  __142:
 11433  	;
 11434  __153:
 11435  	hold >>= int32(here.Fbits)
 11436  	bits = bits - uint32(here.Fbits)
 11437  	goto __154
 11438  __154:
 11439  	if 0 != 0 {
 11440  		goto __153
 11441  	}
 11442  	goto __155
 11443  __155:
 11444  	;
 11445  	if !((*Inflate_state)(unsafe.Pointer(state)).Fhave == uint32(0)) {
 11446  		goto __156
 11447  	}
 11448  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 476 /* "invalid bit leng..." */
 11449  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 11450  	goto __120
 11451  __156:
 11452  	;
 11453  	len = uint32(*(*uint16)(unsafe.Pointer(state + 152 + uintptr((*Inflate_state)(unsafe.Pointer(state)).Fhave-uint32(1))*2)))
 11454  	copy = uint32(3) + uint32(hold)&(uint32(1)<<2-uint32(1))
 11455  __157:
 11456  	hold >>= 2
 11457  	bits = bits - uint32(2)
 11458  	goto __158
 11459  __158:
 11460  	if 0 != 0 {
 11461  		goto __157
 11462  	}
 11463  	goto __159
 11464  __159:
 11465  	;
 11466  	goto __139
 11467  __138:
 11468  	if !(int32(here.Fval) == 17) {
 11469  		goto __160
 11470  	}
 11471  __162:
 11472  __165:
 11473  	if !(bits < uint32(int32(here.Fbits)+3)) {
 11474  		goto __166
 11475  	}
 11476  __167:
 11477  __170:
 11478  	if !(have == uint32(0)) {
 11479  		goto __173
 11480  	}
 11481  	have = (*struct {
 11482  		f func(*libc.TLS, uintptr, uintptr) uint32
 11483  	})(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */)
 11484  	if !(have == uint32(0)) {
 11485  		goto __174
 11486  	}
 11487  	*(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL)
 11488  	ret = -5
 11489  	goto inf_leave
 11490  __174:
 11491  	;
 11492  __173:
 11493  	;
 11494  	goto __171
 11495  __171:
 11496  	if 0 != 0 {
 11497  		goto __170
 11498  	}
 11499  	goto __172
 11500  __172:
 11501  	;
 11502  	have--
 11503  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))<<bits
 11504  	bits = bits + uint32(8)
 11505  	goto __168
 11506  __168:
 11507  	if 0 != 0 {
 11508  		goto __167
 11509  	}
 11510  	goto __169
 11511  __169:
 11512  	;
 11513  	goto __165
 11514  __166:
 11515  	;
 11516  	goto __163
 11517  __163:
 11518  	if 0 != 0 {
 11519  		goto __162
 11520  	}
 11521  	goto __164
 11522  __164:
 11523  	;
 11524  __175:
 11525  	hold >>= int32(here.Fbits)
 11526  	bits = bits - uint32(here.Fbits)
 11527  	goto __176
 11528  __176:
 11529  	if 0 != 0 {
 11530  		goto __175
 11531  	}
 11532  	goto __177
 11533  __177:
 11534  	;
 11535  	len = uint32(0)
 11536  	copy = uint32(3) + uint32(hold)&(uint32(1)<<3-uint32(1))
 11537  __178:
 11538  	hold >>= 3
 11539  	bits = bits - uint32(3)
 11540  	goto __179
 11541  __179:
 11542  	if 0 != 0 {
 11543  		goto __178
 11544  	}
 11545  	goto __180
 11546  __180:
 11547  	;
 11548  	goto __161
 11549  __160:
 11550  __181:
 11551  __184:
 11552  	if !(bits < uint32(int32(here.Fbits)+7)) {
 11553  		goto __185
 11554  	}
 11555  __186:
 11556  __189:
 11557  	if !(have == uint32(0)) {
 11558  		goto __192
 11559  	}
 11560  	have = (*struct {
 11561  		f func(*libc.TLS, uintptr, uintptr) uint32
 11562  	})(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */)
 11563  	if !(have == uint32(0)) {
 11564  		goto __193
 11565  	}
 11566  	*(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL)
 11567  	ret = -5
 11568  	goto inf_leave
 11569  __193:
 11570  	;
 11571  __192:
 11572  	;
 11573  	goto __190
 11574  __190:
 11575  	if 0 != 0 {
 11576  		goto __189
 11577  	}
 11578  	goto __191
 11579  __191:
 11580  	;
 11581  	have--
 11582  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))<<bits
 11583  	bits = bits + uint32(8)
 11584  	goto __187
 11585  __187:
 11586  	if 0 != 0 {
 11587  		goto __186
 11588  	}
 11589  	goto __188
 11590  __188:
 11591  	;
 11592  	goto __184
 11593  __185:
 11594  	;
 11595  	goto __182
 11596  __182:
 11597  	if 0 != 0 {
 11598  		goto __181
 11599  	}
 11600  	goto __183
 11601  __183:
 11602  	;
 11603  __194:
 11604  	hold >>= int32(here.Fbits)
 11605  	bits = bits - uint32(here.Fbits)
 11606  	goto __195
 11607  __195:
 11608  	if 0 != 0 {
 11609  		goto __194
 11610  	}
 11611  	goto __196
 11612  __196:
 11613  	;
 11614  	len = uint32(0)
 11615  	copy = uint32(11) + uint32(hold)&(uint32(1)<<7-uint32(1))
 11616  __197:
 11617  	hold >>= 7
 11618  	bits = bits - uint32(7)
 11619  	goto __198
 11620  __198:
 11621  	if 0 != 0 {
 11622  		goto __197
 11623  	}
 11624  	goto __199
 11625  __199:
 11626  	;
 11627  __161:
 11628  	;
 11629  __139:
 11630  	;
 11631  	if !((*Inflate_state)(unsafe.Pointer(state)).Fhave+copy > (*Inflate_state)(unsafe.Pointer(state)).Fnlen+(*Inflate_state)(unsafe.Pointer(state)).Fndist) {
 11632  		goto __200
 11633  	}
 11634  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 476 /* "invalid bit leng..." */
 11635  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 11636  	goto __120
 11637  __200:
 11638  	;
 11639  __201:
 11640  	if !(libc.PostDecUint32(&copy, 1) != 0) {
 11641  		goto __202
 11642  	}
 11643  	*(*uint16)(unsafe.Pointer(state + 152 + uintptr(libc.PostIncUint32(&(*Inflate_state)(unsafe.Pointer(state)).Fhave, 1))*2)) = uint16(len)
 11644  	goto __201
 11645  __202:
 11646  	;
 11647  __134:
 11648  	;
 11649  	goto __119
 11650  __120:
 11651  	;
 11652  
 11653  	// handle error breaks in while
 11654  	if !((*Inflate_state)(unsafe.Pointer(state)).Fmode == BAD) {
 11655  		goto __203
 11656  	}
 11657  	goto __5
 11658  __203:
 11659  	;
 11660  
 11661  	// check for end-of-block code (better have one)
 11662  	if !(int32(*(*uint16)(unsafe.Pointer(state + 152 + 256*2))) == 0) {
 11663  		goto __204
 11664  	}
 11665  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 502 /* "invalid code -- ..." */
 11666  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 11667  	goto __5
 11668  __204:
 11669  	;
 11670  
 11671  	// build code tables -- note: do not change the lenbits or distbits
 11672  	//                values here (9 and 6) without reading the comments in inftrees.h
 11673  	//                concerning the ENOUGH constants, which depend on those values
 11674  	(*Inflate_state)(unsafe.Pointer(state)).Fnext = state + 1368 /* &.codes */
 11675  	(*Inflate_state)(unsafe.Pointer(state)).Flencode = (*Inflate_state)(unsafe.Pointer(state)).Fnext
 11676  	(*Inflate_state)(unsafe.Pointer(state)).Flenbits = uint32(9)
 11677  	ret = Xinflate_table(tls, LENS, state+152, (*Inflate_state)(unsafe.Pointer(state)).Fnlen, state+144,
 11678  		state+120, state+792)
 11679  	if !(ret != 0) {
 11680  		goto __205
 11681  	}
 11682  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 539 /* "invalid literal/..." */
 11683  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 11684  	goto __5
 11685  __205:
 11686  	;
 11687  	(*Inflate_state)(unsafe.Pointer(state)).Fdistcode = (*Inflate_state)(unsafe.Pointer(state)).Fnext
 11688  	(*Inflate_state)(unsafe.Pointer(state)).Fdistbits = uint32(6)
 11689  	ret = Xinflate_table(tls, DISTS, state+152+uintptr((*Inflate_state)(unsafe.Pointer(state)).Fnlen)*2, (*Inflate_state)(unsafe.Pointer(state)).Fndist,
 11690  		state+144, state+124, state+792)
 11691  	if !(ret != 0) {
 11692  		goto __206
 11693  	}
 11694  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 567 /* "invalid distance..." */
 11695  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 11696  	goto __5
 11697  __206:
 11698  	;
 11699  
 11700  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = LEN
 11701  
 11702  __9:
 11703  	// use inflate_fast() if we have enough input and output
 11704  	if !(have >= uint32(6) && left >= uint32(258)) {
 11705  		goto __207
 11706  	}
 11707  __208:
 11708  	(*Z_stream)(unsafe.Pointer(strm)).Fnext_out = put
 11709  	(*Z_stream)(unsafe.Pointer(strm)).Favail_out = left
 11710  	(*Z_stream)(unsafe.Pointer(strm)).Fnext_in = *(*uintptr)(unsafe.Pointer(bp /* next */))
 11711  	(*Z_stream)(unsafe.Pointer(strm)).Favail_in = have
 11712  	(*Inflate_state)(unsafe.Pointer(state)).Fhold = hold
 11713  	(*Inflate_state)(unsafe.Pointer(state)).Fbits = bits
 11714  	goto __209
 11715  __209:
 11716  	if 0 != 0 {
 11717  		goto __208
 11718  	}
 11719  	goto __210
 11720  __210:
 11721  	;
 11722  	if !((*Inflate_state)(unsafe.Pointer(state)).Fwhave < (*Inflate_state)(unsafe.Pointer(state)).Fwsize) {
 11723  		goto __211
 11724  	}
 11725  	(*Inflate_state)(unsafe.Pointer(state)).Fwhave = (*Inflate_state)(unsafe.Pointer(state)).Fwsize - left
 11726  __211:
 11727  	;
 11728  	Xinflate_fast(tls, strm, (*Inflate_state)(unsafe.Pointer(state)).Fwsize)
 11729  __212:
 11730  	put = (*Z_stream)(unsafe.Pointer(strm)).Fnext_out
 11731  	left = (*Z_stream)(unsafe.Pointer(strm)).Favail_out
 11732  	*(*uintptr)(unsafe.Pointer(bp /* next */)) = (*Z_stream)(unsafe.Pointer(strm)).Fnext_in
 11733  	have = (*Z_stream)(unsafe.Pointer(strm)).Favail_in
 11734  	hold = (*Inflate_state)(unsafe.Pointer(state)).Fhold
 11735  	bits = (*Inflate_state)(unsafe.Pointer(state)).Fbits
 11736  	goto __213
 11737  __213:
 11738  	if 0 != 0 {
 11739  		goto __212
 11740  	}
 11741  	goto __214
 11742  __214:
 11743  	;
 11744  	goto __5
 11745  __207:
 11746  	;
 11747  
 11748  	// get a literal, length, or end-of-block code
 11749  __215:
 11750  	here = *(*Code)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Flencode + uintptr(uint32(hold)&(uint32(1)<<(*Inflate_state)(unsafe.Pointer(state)).Flenbits-uint32(1)))*4))
 11751  	if !(uint32(here.Fbits) <= bits) {
 11752  		goto __218
 11753  	}
 11754  	goto __217
 11755  __218:
 11756  	;
 11757  __219:
 11758  __222:
 11759  	if !(have == uint32(0)) {
 11760  		goto __225
 11761  	}
 11762  	have = (*struct {
 11763  		f func(*libc.TLS, uintptr, uintptr) uint32
 11764  	})(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */)
 11765  	if !(have == uint32(0)) {
 11766  		goto __226
 11767  	}
 11768  	*(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL)
 11769  	ret = -5
 11770  	goto inf_leave
 11771  __226:
 11772  	;
 11773  __225:
 11774  	;
 11775  	goto __223
 11776  __223:
 11777  	if 0 != 0 {
 11778  		goto __222
 11779  	}
 11780  	goto __224
 11781  __224:
 11782  	;
 11783  	have--
 11784  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))<<bits
 11785  	bits = bits + uint32(8)
 11786  	goto __220
 11787  __220:
 11788  	if 0 != 0 {
 11789  		goto __219
 11790  	}
 11791  	goto __221
 11792  __221:
 11793  	;
 11794  	goto __216
 11795  __216:
 11796  	goto __215
 11797  	goto __217
 11798  __217:
 11799  	;
 11800  	if !(here.Fop != 0 && int32(here.Fop)&0xf0 == 0) {
 11801  		goto __227
 11802  	}
 11803  	last = here
 11804  __228:
 11805  	here = *(*Code)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Flencode + uintptr(uint32(last.Fval)+uint32(hold)&(uint32(1)<<(int32(last.Fbits)+int32(last.Fop))-uint32(1))>>int32(last.Fbits))*4))
 11806  	if !(uint32(int32(last.Fbits)+int32(here.Fbits)) <= bits) {
 11807  		goto __231
 11808  	}
 11809  	goto __230
 11810  __231:
 11811  	;
 11812  __232:
 11813  __235:
 11814  	if !(have == uint32(0)) {
 11815  		goto __238
 11816  	}
 11817  	have = (*struct {
 11818  		f func(*libc.TLS, uintptr, uintptr) uint32
 11819  	})(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */)
 11820  	if !(have == uint32(0)) {
 11821  		goto __239
 11822  	}
 11823  	*(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL)
 11824  	ret = -5
 11825  	goto inf_leave
 11826  __239:
 11827  	;
 11828  __238:
 11829  	;
 11830  	goto __236
 11831  __236:
 11832  	if 0 != 0 {
 11833  		goto __235
 11834  	}
 11835  	goto __237
 11836  __237:
 11837  	;
 11838  	have--
 11839  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))<<bits
 11840  	bits = bits + uint32(8)
 11841  	goto __233
 11842  __233:
 11843  	if 0 != 0 {
 11844  		goto __232
 11845  	}
 11846  	goto __234
 11847  __234:
 11848  	;
 11849  	goto __229
 11850  __229:
 11851  	goto __228
 11852  	goto __230
 11853  __230:
 11854  	;
 11855  __240:
 11856  	hold >>= int32(last.Fbits)
 11857  	bits = bits - uint32(last.Fbits)
 11858  	goto __241
 11859  __241:
 11860  	if 0 != 0 {
 11861  		goto __240
 11862  	}
 11863  	goto __242
 11864  __242:
 11865  	;
 11866  __227:
 11867  	;
 11868  __243:
 11869  	hold >>= int32(here.Fbits)
 11870  	bits = bits - uint32(here.Fbits)
 11871  	goto __244
 11872  __244:
 11873  	if 0 != 0 {
 11874  		goto __243
 11875  	}
 11876  	goto __245
 11877  __245:
 11878  	;
 11879  	(*Inflate_state)(unsafe.Pointer(state)).Flength = uint32(here.Fval)
 11880  
 11881  	// process literal
 11882  	if !(int32(here.Fop) == 0) {
 11883  		goto __246
 11884  	}
 11885  
 11886  __247:
 11887  	if !(left == uint32(0)) {
 11888  		goto __250
 11889  	}
 11890  	put = (*Inflate_state)(unsafe.Pointer(state)).Fwindow
 11891  	left = (*Inflate_state)(unsafe.Pointer(state)).Fwsize
 11892  	(*Inflate_state)(unsafe.Pointer(state)).Fwhave = left
 11893  	if !((*struct {
 11894  		f func(*libc.TLS, uintptr, uintptr, uint32) int32
 11895  	})(unsafe.Pointer(&struct{ uintptr }{out})).f(tls, out_desc, put, left) != 0) {
 11896  		goto __251
 11897  	}
 11898  	ret = -5
 11899  	goto inf_leave
 11900  __251:
 11901  	;
 11902  __250:
 11903  	;
 11904  	goto __248
 11905  __248:
 11906  	if 0 != 0 {
 11907  		goto __247
 11908  	}
 11909  	goto __249
 11910  __249:
 11911  	;
 11912  	*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&put, 1))) = uint8((*Inflate_state)(unsafe.Pointer(state)).Flength)
 11913  	left--
 11914  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = LEN
 11915  	goto __5
 11916  __246:
 11917  	;
 11918  
 11919  	// process end of block
 11920  	if !(int32(here.Fop)&32 != 0) {
 11921  		goto __252
 11922  	}
 11923  
 11924  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = TYPE
 11925  	goto __5
 11926  __252:
 11927  	;
 11928  
 11929  	// invalid code
 11930  	if !(int32(here.Fop)&64 != 0) {
 11931  		goto __253
 11932  	}
 11933  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 589 /* "invalid literal/..." */
 11934  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 11935  	goto __5
 11936  __253:
 11937  	;
 11938  
 11939  	// length code -- get extra bits, if any
 11940  	(*Inflate_state)(unsafe.Pointer(state)).Fextra = uint32(here.Fop) & uint32(15)
 11941  	if !((*Inflate_state)(unsafe.Pointer(state)).Fextra != uint32(0)) {
 11942  		goto __254
 11943  	}
 11944  __255:
 11945  __258:
 11946  	if !(bits < (*Inflate_state)(unsafe.Pointer(state)).Fextra) {
 11947  		goto __259
 11948  	}
 11949  __260:
 11950  __263:
 11951  	if !(have == uint32(0)) {
 11952  		goto __266
 11953  	}
 11954  	have = (*struct {
 11955  		f func(*libc.TLS, uintptr, uintptr) uint32
 11956  	})(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */)
 11957  	if !(have == uint32(0)) {
 11958  		goto __267
 11959  	}
 11960  	*(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL)
 11961  	ret = -5
 11962  	goto inf_leave
 11963  __267:
 11964  	;
 11965  __266:
 11966  	;
 11967  	goto __264
 11968  __264:
 11969  	if 0 != 0 {
 11970  		goto __263
 11971  	}
 11972  	goto __265
 11973  __265:
 11974  	;
 11975  	have--
 11976  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))<<bits
 11977  	bits = bits + uint32(8)
 11978  	goto __261
 11979  __261:
 11980  	if 0 != 0 {
 11981  		goto __260
 11982  	}
 11983  	goto __262
 11984  __262:
 11985  	;
 11986  	goto __258
 11987  __259:
 11988  	;
 11989  	goto __256
 11990  __256:
 11991  	if 0 != 0 {
 11992  		goto __255
 11993  	}
 11994  	goto __257
 11995  __257:
 11996  	;
 11997  	*(*uint32)(unsafe.Pointer(state + 92)) += uint32(hold) & (uint32(1)<<(*Inflate_state)(unsafe.Pointer(state)).Fextra - uint32(1))
 11998  __268:
 11999  	hold >>= (*Inflate_state)(unsafe.Pointer(state)).Fextra
 12000  	bits = bits - (*Inflate_state)(unsafe.Pointer(state)).Fextra
 12001  	goto __269
 12002  __269:
 12003  	if 0 != 0 {
 12004  		goto __268
 12005  	}
 12006  	goto __270
 12007  __270:
 12008  	;
 12009  __254:
 12010  	;
 12011  
 12012  	// get distance code
 12013  __271:
 12014  	here = *(*Code)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fdistcode + uintptr(uint32(hold)&(uint32(1)<<(*Inflate_state)(unsafe.Pointer(state)).Fdistbits-uint32(1)))*4))
 12015  	if !(uint32(here.Fbits) <= bits) {
 12016  		goto __274
 12017  	}
 12018  	goto __273
 12019  __274:
 12020  	;
 12021  __275:
 12022  __278:
 12023  	if !(have == uint32(0)) {
 12024  		goto __281
 12025  	}
 12026  	have = (*struct {
 12027  		f func(*libc.TLS, uintptr, uintptr) uint32
 12028  	})(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */)
 12029  	if !(have == uint32(0)) {
 12030  		goto __282
 12031  	}
 12032  	*(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL)
 12033  	ret = -5
 12034  	goto inf_leave
 12035  __282:
 12036  	;
 12037  __281:
 12038  	;
 12039  	goto __279
 12040  __279:
 12041  	if 0 != 0 {
 12042  		goto __278
 12043  	}
 12044  	goto __280
 12045  __280:
 12046  	;
 12047  	have--
 12048  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))<<bits
 12049  	bits = bits + uint32(8)
 12050  	goto __276
 12051  __276:
 12052  	if 0 != 0 {
 12053  		goto __275
 12054  	}
 12055  	goto __277
 12056  __277:
 12057  	;
 12058  	goto __272
 12059  __272:
 12060  	goto __271
 12061  	goto __273
 12062  __273:
 12063  	;
 12064  	if !(int32(here.Fop)&0xf0 == 0) {
 12065  		goto __283
 12066  	}
 12067  	last = here
 12068  __284:
 12069  	here = *(*Code)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fdistcode + uintptr(uint32(last.Fval)+uint32(hold)&(uint32(1)<<(int32(last.Fbits)+int32(last.Fop))-uint32(1))>>int32(last.Fbits))*4))
 12070  	if !(uint32(int32(last.Fbits)+int32(here.Fbits)) <= bits) {
 12071  		goto __287
 12072  	}
 12073  	goto __286
 12074  __287:
 12075  	;
 12076  __288:
 12077  __291:
 12078  	if !(have == uint32(0)) {
 12079  		goto __294
 12080  	}
 12081  	have = (*struct {
 12082  		f func(*libc.TLS, uintptr, uintptr) uint32
 12083  	})(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */)
 12084  	if !(have == uint32(0)) {
 12085  		goto __295
 12086  	}
 12087  	*(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL)
 12088  	ret = -5
 12089  	goto inf_leave
 12090  __295:
 12091  	;
 12092  __294:
 12093  	;
 12094  	goto __292
 12095  __292:
 12096  	if 0 != 0 {
 12097  		goto __291
 12098  	}
 12099  	goto __293
 12100  __293:
 12101  	;
 12102  	have--
 12103  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))<<bits
 12104  	bits = bits + uint32(8)
 12105  	goto __289
 12106  __289:
 12107  	if 0 != 0 {
 12108  		goto __288
 12109  	}
 12110  	goto __290
 12111  __290:
 12112  	;
 12113  	goto __285
 12114  __285:
 12115  	goto __284
 12116  	goto __286
 12117  __286:
 12118  	;
 12119  __296:
 12120  	hold >>= int32(last.Fbits)
 12121  	bits = bits - uint32(last.Fbits)
 12122  	goto __297
 12123  __297:
 12124  	if 0 != 0 {
 12125  		goto __296
 12126  	}
 12127  	goto __298
 12128  __298:
 12129  	;
 12130  __283:
 12131  	;
 12132  __299:
 12133  	hold >>= int32(here.Fbits)
 12134  	bits = bits - uint32(here.Fbits)
 12135  	goto __300
 12136  __300:
 12137  	if 0 != 0 {
 12138  		goto __299
 12139  	}
 12140  	goto __301
 12141  __301:
 12142  	;
 12143  	if !(int32(here.Fop)&64 != 0) {
 12144  		goto __302
 12145  	}
 12146  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 617 /* "invalid distance..." */
 12147  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 12148  	goto __5
 12149  __302:
 12150  	;
 12151  	(*Inflate_state)(unsafe.Pointer(state)).Foffset = uint32(here.Fval)
 12152  
 12153  	// get distance extra bits, if any
 12154  	(*Inflate_state)(unsafe.Pointer(state)).Fextra = uint32(here.Fop) & uint32(15)
 12155  	if !((*Inflate_state)(unsafe.Pointer(state)).Fextra != uint32(0)) {
 12156  		goto __303
 12157  	}
 12158  __304:
 12159  __307:
 12160  	if !(bits < (*Inflate_state)(unsafe.Pointer(state)).Fextra) {
 12161  		goto __308
 12162  	}
 12163  __309:
 12164  __312:
 12165  	if !(have == uint32(0)) {
 12166  		goto __315
 12167  	}
 12168  	have = (*struct {
 12169  		f func(*libc.TLS, uintptr, uintptr) uint32
 12170  	})(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */)
 12171  	if !(have == uint32(0)) {
 12172  		goto __316
 12173  	}
 12174  	*(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL)
 12175  	ret = -5
 12176  	goto inf_leave
 12177  __316:
 12178  	;
 12179  __315:
 12180  	;
 12181  	goto __313
 12182  __313:
 12183  	if 0 != 0 {
 12184  		goto __312
 12185  	}
 12186  	goto __314
 12187  __314:
 12188  	;
 12189  	have--
 12190  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))<<bits
 12191  	bits = bits + uint32(8)
 12192  	goto __310
 12193  __310:
 12194  	if 0 != 0 {
 12195  		goto __309
 12196  	}
 12197  	goto __311
 12198  __311:
 12199  	;
 12200  	goto __307
 12201  __308:
 12202  	;
 12203  	goto __305
 12204  __305:
 12205  	if 0 != 0 {
 12206  		goto __304
 12207  	}
 12208  	goto __306
 12209  __306:
 12210  	;
 12211  	*(*uint32)(unsafe.Pointer(state + 96)) += uint32(hold) & (uint32(1)<<(*Inflate_state)(unsafe.Pointer(state)).Fextra - uint32(1))
 12212  __317:
 12213  	hold >>= (*Inflate_state)(unsafe.Pointer(state)).Fextra
 12214  	bits = bits - (*Inflate_state)(unsafe.Pointer(state)).Fextra
 12215  	goto __318
 12216  __318:
 12217  	if 0 != 0 {
 12218  		goto __317
 12219  	}
 12220  	goto __319
 12221  __319:
 12222  	;
 12223  __303:
 12224  	;
 12225  	if !((*Inflate_state)(unsafe.Pointer(state)).Foffset > (*Inflate_state)(unsafe.Pointer(state)).Fwsize-func() uint32 {
 12226  		if (*Inflate_state)(unsafe.Pointer(state)).Fwhave < (*Inflate_state)(unsafe.Pointer(state)).Fwsize {
 12227  			return left
 12228  		}
 12229  		return uint32(0)
 12230  	}()) {
 12231  		goto __320
 12232  	}
 12233  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 639 /* "invalid distance..." */
 12234  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 12235  	goto __5
 12236  __320:
 12237  	;
 12238  
 12239  	// copy match from window to output
 12240  __321:
 12241  __324:
 12242  	if !(left == uint32(0)) {
 12243  		goto __327
 12244  	}
 12245  	put = (*Inflate_state)(unsafe.Pointer(state)).Fwindow
 12246  	left = (*Inflate_state)(unsafe.Pointer(state)).Fwsize
 12247  	(*Inflate_state)(unsafe.Pointer(state)).Fwhave = left
 12248  	if !((*struct {
 12249  		f func(*libc.TLS, uintptr, uintptr, uint32) int32
 12250  	})(unsafe.Pointer(&struct{ uintptr }{out})).f(tls, out_desc, put, left) != 0) {
 12251  		goto __328
 12252  	}
 12253  	ret = -5
 12254  	goto inf_leave
 12255  __328:
 12256  	;
 12257  __327:
 12258  	;
 12259  	goto __325
 12260  __325:
 12261  	if 0 != 0 {
 12262  		goto __324
 12263  	}
 12264  	goto __326
 12265  __326:
 12266  	;
 12267  	copy = (*Inflate_state)(unsafe.Pointer(state)).Fwsize - (*Inflate_state)(unsafe.Pointer(state)).Foffset
 12268  	if !(copy < left) {
 12269  		goto __329
 12270  	}
 12271  	from = put + uintptr(copy)
 12272  	copy = left - copy
 12273  	goto __330
 12274  __329:
 12275  	from = put - uintptr((*Inflate_state)(unsafe.Pointer(state)).Foffset)
 12276  	copy = left
 12277  __330:
 12278  	;
 12279  	if !(copy > (*Inflate_state)(unsafe.Pointer(state)).Flength) {
 12280  		goto __331
 12281  	}
 12282  	copy = (*Inflate_state)(unsafe.Pointer(state)).Flength
 12283  __331:
 12284  	;
 12285  	*(*uint32)(unsafe.Pointer(state + 92)) -= copy
 12286  	left = left - copy
 12287  __332:
 12288  	*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&put, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1)))
 12289  	goto __333
 12290  __333:
 12291  	if libc.PreDecUint32(&copy, 1) != 0 {
 12292  		goto __332
 12293  	}
 12294  	goto __334
 12295  __334:
 12296  	;
 12297  	goto __322
 12298  __322:
 12299  	if (*Inflate_state)(unsafe.Pointer(state)).Flength != uint32(0) {
 12300  		goto __321
 12301  	}
 12302  	goto __323
 12303  __323:
 12304  	;
 12305  	goto __5
 12306  
 12307  __10:
 12308  	// inflate stream terminated properly -- write leftover output
 12309  	ret = Z_STREAM_END
 12310  	if !(left < (*Inflate_state)(unsafe.Pointer(state)).Fwsize) {
 12311  		goto __335
 12312  	}
 12313  	if !((*struct {
 12314  		f func(*libc.TLS, uintptr, uintptr, uint32) int32
 12315  	})(unsafe.Pointer(&struct{ uintptr }{out})).f(tls, out_desc, (*Inflate_state)(unsafe.Pointer(state)).Fwindow, (*Inflate_state)(unsafe.Pointer(state)).Fwsize-left) != 0) {
 12316  		goto __336
 12317  	}
 12318  	ret = -5
 12319  __336:
 12320  	;
 12321  __335:
 12322  	;
 12323  	goto inf_leave
 12324  
 12325  __11:
 12326  	ret = -3
 12327  	goto inf_leave
 12328  
 12329  __12: // can't happen, but makes compilers happy
 12330  	ret = -2
 12331  	goto inf_leave
 12332  __5:
 12333  	;
 12334  	goto __3
 12335  __3:
 12336  	goto __2
 12337  	goto __4
 12338  __4:
 12339  	;
 12340  
 12341  	// Return unused input
 12342  inf_leave:
 12343  	(*Z_stream)(unsafe.Pointer(strm)).Fnext_in = *(*uintptr)(unsafe.Pointer(bp /* next */))
 12344  	(*Z_stream)(unsafe.Pointer(strm)).Favail_in = have
 12345  	return ret
 12346  }
 12347  
 12348  var order =                                                                                                                                                                                                                          // permutation of code lengths
 12349  [19]uint16{uint16(16), uint16(17), uint16(18), uint16(0), uint16(8), uint16(7), uint16(9), uint16(6), uint16(10), uint16(5), uint16(11), uint16(4), uint16(12), uint16(3), uint16(13), uint16(2), uint16(14), uint16(1), uint16(15)} /* infback.c:269:33 */
 12350  
 12351  func XinflateBackEnd(tls *libc.TLS, strm Z_streamp) int32 { /* infback.c:631:13: */
 12352  	if strm == uintptr(Z_NULL) || (*Z_stream)(unsafe.Pointer(strm)).Fstate == uintptr(Z_NULL) || (*Z_stream)(unsafe.Pointer(strm)).Fzfree == uintptr(0) {
 12353  		return -2
 12354  	}
 12355  	(*struct {
 12356  		f func(*libc.TLS, Voidpf, Voidpf)
 12357  	})(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer(strm)).Fzfree})).f(tls, (*Z_stream)(unsafe.Pointer(strm)).Fopaque, (*Z_stream)(unsafe.Pointer(strm)).Fstate)
 12358  	(*Z_stream)(unsafe.Pointer(strm)).Fstate = uintptr(Z_NULL)
 12359  
 12360  	return Z_OK
 12361  }
 12362  
 12363  //
 12364  //    Decode literal, length, and distance codes and write out the resulting
 12365  //    literal and match bytes until either not enough input or output is
 12366  //    available, an end-of-block is encountered, or a data error is encountered.
 12367  //    When large enough input and output buffers are supplied to inflate(), for
 12368  //    example, a 16K input buffer and a 64K output buffer, more than 95% of the
 12369  //    inflate execution time is spent in this routine.
 12370  //
 12371  //    Entry assumptions:
 12372  //
 12373  //         state->mode == LEN
 12374  //         strm->avail_in >= 6
 12375  //         strm->avail_out >= 258
 12376  //         start >= strm->avail_out
 12377  //         state->bits < 8
 12378  //
 12379  //    On return, state->mode is one of:
 12380  //
 12381  //         LEN -- ran out of enough output space or enough available input
 12382  //         TYPE -- reached end of block code, inflate() to interpret next block
 12383  //         BAD -- error in block data
 12384  //
 12385  //    Notes:
 12386  //
 12387  //     - The maximum input bits used by a length/distance pair is 15 bits for the
 12388  //       length code, 5 bits for the length extra, 15 bits for the distance code,
 12389  //       and 13 bits for the distance extra.  This totals 48 bits, or six bytes.
 12390  //       Therefore if strm->avail_in >= 6, then there is enough input to avoid
 12391  //       checking for available input while decoding.
 12392  //
 12393  //     - The maximum bytes that a single length/distance pair can output is 258
 12394  //       bytes, which is the maximum length that can be coded.  inflate_fast()
 12395  //       requires strm->avail_out >= 258 for each loop to avoid checking for
 12396  //       output space.
 12397  //
 12398  func Xinflate_fast(tls *libc.TLS, strm Z_streamp, start uint32) { /* inffast.c:50:20: */
 12399  	var state uintptr
 12400  	var in uintptr     // local strm->next_in
 12401  	var last uintptr   // have enough input while in < last
 12402  	var out uintptr    // local strm->next_out
 12403  	var beg uintptr    // inflate()'s initial strm->next_out
 12404  	var end uintptr    // while out < end, enough space available
 12405  	var wsize uint32   // window size or zero if not using window
 12406  	var whave uint32   // valid bytes in the window
 12407  	var wnext uint32   // window write index
 12408  	var window uintptr // allocated sliding window, if wsize != 0
 12409  	var hold uint64    // local strm->hold
 12410  	var bits uint32    // local strm->bits
 12411  	var lcode uintptr  // local strm->lencode
 12412  	var dcode uintptr  // local strm->distcode
 12413  	var lmask uint32   // mask for first level of length codes
 12414  	var dmask uint32   // mask for first level of distance codes
 12415  	var here Code      // retrieved table entry
 12416  	var op uint32      // code bits, operation, extra bits, or
 12417  	//  window position, window bytes to copy
 12418  	var len uint32   // match length, unused bytes
 12419  	var dist uint32  // match distance
 12420  	var from uintptr // where to copy match from
 12421  
 12422  	// copy state to local variables
 12423  	state = (*Z_stream)(unsafe.Pointer(strm)).Fstate
 12424  	in = (*Z_stream)(unsafe.Pointer(strm)).Fnext_in
 12425  	last = in + uintptr((*Z_stream)(unsafe.Pointer(strm)).Favail_in-UInt(5))
 12426  	out = (*Z_stream)(unsafe.Pointer(strm)).Fnext_out
 12427  	beg = out - uintptr(start-(*Z_stream)(unsafe.Pointer(strm)).Favail_out)
 12428  	end = out + uintptr((*Z_stream)(unsafe.Pointer(strm)).Favail_out-UInt(257))
 12429  	wsize = (*Inflate_state)(unsafe.Pointer(state)).Fwsize
 12430  	whave = (*Inflate_state)(unsafe.Pointer(state)).Fwhave
 12431  	wnext = (*Inflate_state)(unsafe.Pointer(state)).Fwnext
 12432  	window = (*Inflate_state)(unsafe.Pointer(state)).Fwindow
 12433  	hold = (*Inflate_state)(unsafe.Pointer(state)).Fhold
 12434  	bits = (*Inflate_state)(unsafe.Pointer(state)).Fbits
 12435  	lcode = (*Inflate_state)(unsafe.Pointer(state)).Flencode
 12436  	dcode = (*Inflate_state)(unsafe.Pointer(state)).Fdistcode
 12437  	lmask = uint32(1)<<(*Inflate_state)(unsafe.Pointer(state)).Flenbits - uint32(1)
 12438  	dmask = uint32(1)<<(*Inflate_state)(unsafe.Pointer(state)).Fdistbits - uint32(1)
 12439  
 12440  	// decode literals and length/distances until end-of-block or not enough
 12441  	//        input data or output space
 12442  __1:
 12443  	if !(bits < uint32(15)) {
 12444  		goto __4
 12445  	}
 12446  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&in, 1))))<<bits
 12447  	bits = bits + uint32(8)
 12448  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&in, 1))))<<bits
 12449  	bits = bits + uint32(8)
 12450  __4:
 12451  	;
 12452  	here = *(*Code)(unsafe.Pointer(lcode + uintptr(hold&uint64(lmask))*4))
 12453  dolen:
 12454  	op = uint32(here.Fbits)
 12455  	hold >>= op
 12456  	bits = bits - op
 12457  	op = uint32(here.Fop)
 12458  	if !(op == uint32(0)) {
 12459  		goto __5
 12460  	} // literal
 12461  
 12462  	*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = uint8(here.Fval)
 12463  	goto __6
 12464  __5:
 12465  	if !(op&uint32(16) != 0) {
 12466  		goto __7
 12467  	} // length base
 12468  	len = uint32(here.Fval)
 12469  	op = op & uint32(15) // number of extra bits
 12470  	if !(op != 0) {
 12471  		goto __9
 12472  	}
 12473  	if !(bits < op) {
 12474  		goto __10
 12475  	}
 12476  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&in, 1))))<<bits
 12477  	bits = bits + uint32(8)
 12478  __10:
 12479  	;
 12480  	len = len + uint32(hold)&(uint32(1)<<op-uint32(1))
 12481  	hold >>= op
 12482  	bits = bits - op
 12483  __9:
 12484  	;
 12485  
 12486  	if !(bits < uint32(15)) {
 12487  		goto __11
 12488  	}
 12489  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&in, 1))))<<bits
 12490  	bits = bits + uint32(8)
 12491  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&in, 1))))<<bits
 12492  	bits = bits + uint32(8)
 12493  __11:
 12494  	;
 12495  	here = *(*Code)(unsafe.Pointer(dcode + uintptr(hold&uint64(dmask))*4))
 12496  dodist:
 12497  	op = uint32(here.Fbits)
 12498  	hold >>= op
 12499  	bits = bits - op
 12500  	op = uint32(here.Fop)
 12501  	if !(op&uint32(16) != 0) {
 12502  		goto __12
 12503  	} // distance base
 12504  	dist = uint32(here.Fval)
 12505  	op = op & uint32(15) // number of extra bits
 12506  	if !(bits < op) {
 12507  		goto __14
 12508  	}
 12509  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&in, 1))))<<bits
 12510  	bits = bits + uint32(8)
 12511  	if !(bits < op) {
 12512  		goto __15
 12513  	}
 12514  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&in, 1))))<<bits
 12515  	bits = bits + uint32(8)
 12516  __15:
 12517  	;
 12518  __14:
 12519  	;
 12520  	dist = dist + uint32(hold)&(uint32(1)<<op-uint32(1))
 12521  	hold >>= op
 12522  	bits = bits - op
 12523  
 12524  	op = uint32((int64(out) - int64(beg)) / 1) // max distance in output
 12525  	if !(dist > op) {
 12526  		goto __16
 12527  	} // see if copy from window
 12528  	op = dist - op // distance back in window
 12529  	if !(op > whave) {
 12530  		goto __18
 12531  	}
 12532  	if !((*Inflate_state)(unsafe.Pointer(state)).Fsane != 0) {
 12533  		goto __19
 12534  	}
 12535  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 639 /* "invalid distance..." */
 12536  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 12537  	goto __3
 12538  __19:
 12539  	;
 12540  __18:
 12541  	;
 12542  	from = window
 12543  	if !(wnext == uint32(0)) {
 12544  		goto __20
 12545  	} // very common case
 12546  	from += uintptr(wsize - op)
 12547  	if !(op < len) {
 12548  		goto __22
 12549  	} // some from window
 12550  	len = len - op
 12551  __23:
 12552  	*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1)))
 12553  	goto __24
 12554  __24:
 12555  	if libc.PreDecUint32(&op, 1) != 0 {
 12556  		goto __23
 12557  	}
 12558  	goto __25
 12559  __25:
 12560  	;
 12561  	from = out - uintptr(dist) // rest from output
 12562  __22:
 12563  	;
 12564  	goto __21
 12565  __20:
 12566  	if !(wnext < op) {
 12567  		goto __26
 12568  	} // wrap around window
 12569  	from += uintptr(wsize + wnext - op)
 12570  	op = op - wnext
 12571  	if !(op < len) {
 12572  		goto __28
 12573  	} // some from end of window
 12574  	len = len - op
 12575  __29:
 12576  	*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1)))
 12577  	goto __30
 12578  __30:
 12579  	if libc.PreDecUint32(&op, 1) != 0 {
 12580  		goto __29
 12581  	}
 12582  	goto __31
 12583  __31:
 12584  	;
 12585  	from = window
 12586  	if !(wnext < len) {
 12587  		goto __32
 12588  	} // some from start of window
 12589  	op = wnext
 12590  	len = len - op
 12591  __33:
 12592  	*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1)))
 12593  	goto __34
 12594  __34:
 12595  	if libc.PreDecUint32(&op, 1) != 0 {
 12596  		goto __33
 12597  	}
 12598  	goto __35
 12599  __35:
 12600  	;
 12601  	from = out - uintptr(dist) // rest from output
 12602  __32:
 12603  	;
 12604  __28:
 12605  	;
 12606  	goto __27
 12607  __26: // contiguous in window
 12608  	from += uintptr(wnext - op)
 12609  	if !(op < len) {
 12610  		goto __36
 12611  	} // some from window
 12612  	len = len - op
 12613  __37:
 12614  	*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1)))
 12615  	goto __38
 12616  __38:
 12617  	if libc.PreDecUint32(&op, 1) != 0 {
 12618  		goto __37
 12619  	}
 12620  	goto __39
 12621  __39:
 12622  	;
 12623  	from = out - uintptr(dist) // rest from output
 12624  __36:
 12625  	;
 12626  __27:
 12627  	;
 12628  __21:
 12629  	;
 12630  __40:
 12631  	if !(len > uint32(2)) {
 12632  		goto __41
 12633  	}
 12634  	*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1)))
 12635  	*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1)))
 12636  	*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1)))
 12637  	len = len - uint32(3)
 12638  	goto __40
 12639  __41:
 12640  	;
 12641  	if !(len != 0) {
 12642  		goto __42
 12643  	}
 12644  	*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1)))
 12645  	if !(len > uint32(1)) {
 12646  		goto __43
 12647  	}
 12648  	*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1)))
 12649  __43:
 12650  	;
 12651  __42:
 12652  	;
 12653  	goto __17
 12654  __16:
 12655  	from = out - uintptr(dist) // copy direct from output
 12656  __44: // minimum length is three
 12657  	*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1)))
 12658  	*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1)))
 12659  	*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1)))
 12660  	len = len - uint32(3)
 12661  	goto __45
 12662  __45:
 12663  	if len > uint32(2) {
 12664  		goto __44
 12665  	}
 12666  	goto __46
 12667  __46:
 12668  	;
 12669  	if !(len != 0) {
 12670  		goto __47
 12671  	}
 12672  	*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1)))
 12673  	if !(len > uint32(1)) {
 12674  		goto __48
 12675  	}
 12676  	*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1)))
 12677  __48:
 12678  	;
 12679  __47:
 12680  	;
 12681  __17:
 12682  	;
 12683  	goto __13
 12684  __12:
 12685  	if !(op&uint32(64) == uint32(0)) {
 12686  		goto __49
 12687  	} // 2nd level distance code
 12688  	here = *(*Code)(unsafe.Pointer(dcode + uintptr(uint64(here.Fval)+hold&uint64(uint32(1)<<op-uint32(1)))*4))
 12689  	goto dodist
 12690  	goto __50
 12691  __49:
 12692  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 617 /* "invalid distance..." */
 12693  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 12694  	goto __3
 12695  __50:
 12696  	;
 12697  __13:
 12698  	;
 12699  	goto __8
 12700  __7:
 12701  	if !(op&uint32(64) == uint32(0)) {
 12702  		goto __51
 12703  	} // 2nd level length code
 12704  	here = *(*Code)(unsafe.Pointer(lcode + uintptr(uint64(here.Fval)+hold&uint64(uint32(1)<<op-uint32(1)))*4))
 12705  	goto dolen
 12706  	goto __52
 12707  __51:
 12708  	if !(op&uint32(32) != 0) {
 12709  		goto __53
 12710  	} // end-of-block
 12711  
 12712  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = TYPE
 12713  	goto __3
 12714  	goto __54
 12715  __53:
 12716  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 589 /* "invalid literal/..." */
 12717  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 12718  	goto __3
 12719  __54:
 12720  	;
 12721  __52:
 12722  	;
 12723  __8:
 12724  	;
 12725  __6:
 12726  	;
 12727  	goto __2
 12728  __2:
 12729  	if in < last && out < end {
 12730  		goto __1
 12731  	}
 12732  	goto __3
 12733  __3:
 12734  	;
 12735  
 12736  	// return unused bytes (on entry, bits < 8, so in won't go too far back)
 12737  	len = bits >> 3
 12738  	in -= uintptr(len)
 12739  	bits = bits - len<<3
 12740  	hold = hold & uint64(uint32(1)<<bits-uint32(1))
 12741  
 12742  	// update state and return
 12743  	(*Z_stream)(unsafe.Pointer(strm)).Fnext_in = in
 12744  	(*Z_stream)(unsafe.Pointer(strm)).Fnext_out = out
 12745  	(*Z_stream)(unsafe.Pointer(strm)).Favail_in = func() uint32 {
 12746  		if in < last {
 12747  			return uint32(int64(5) + (int64(last)-int64(in))/1)
 12748  		}
 12749  		return uint32(int64(5) - (int64(in)-int64(last))/1)
 12750  	}()
 12751  	(*Z_stream)(unsafe.Pointer(strm)).Favail_out = func() uint32 {
 12752  		if out < end {
 12753  			return uint32(int64(257) + (int64(end)-int64(out))/1)
 12754  		}
 12755  		return uint32(int64(257) - (int64(out)-int64(end))/1)
 12756  	}()
 12757  	(*Inflate_state)(unsafe.Pointer(state)).Fhold = hold
 12758  	(*Inflate_state)(unsafe.Pointer(state)).Fbits = bits
 12759  	return
 12760  }
 12761  
 12762  //
 12763  //    inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe):
 12764  //    - Using bit fields for code structure
 12765  //    - Different op definition to avoid & for extra bits (do & for table bits)
 12766  //    - Three separate decoding do-loops for direct, window, and wnext == 0
 12767  //    - Special case for distance > 1 copies to do overlapped load and store copy
 12768  //    - Explicit branch predictions (based on measured branch probabilities)
 12769  //    - Deferring match copy and interspersed it with decoding subsequent codes
 12770  //    - Swapping literal/length else
 12771  //    - Swapping window/direct else
 12772  //    - Larger unrolled copy loops (three is about right)
 12773  //    - Moving len -= 3 statement into middle of loop
 12774  //
 12775  
 12776  func inflateStateCheck(tls *libc.TLS, strm Z_streamp) int32 { /* inflate.c:105:11: */
 12777  	var state uintptr
 12778  	if strm == uintptr(Z_NULL) || (*Z_stream)(unsafe.Pointer(strm)).Fzalloc == uintptr(0) || (*Z_stream)(unsafe.Pointer(strm)).Fzfree == uintptr(0) {
 12779  		return 1
 12780  	}
 12781  	state = (*Z_stream)(unsafe.Pointer(strm)).Fstate
 12782  	if state == uintptr(Z_NULL) || (*Inflate_state)(unsafe.Pointer(state)).Fstrm != strm || (*Inflate_state)(unsafe.Pointer(state)).Fmode < HEAD || (*Inflate_state)(unsafe.Pointer(state)).Fmode > SYNC {
 12783  		return 1
 12784  	}
 12785  	return 0
 12786  }
 12787  
 12788  func XinflateResetKeep(tls *libc.TLS, strm Z_streamp) int32 { /* inflate.c:119:13: */
 12789  	var state uintptr
 12790  
 12791  	if inflateStateCheck(tls, strm) != 0 {
 12792  		return -2
 12793  	}
 12794  	state = (*Z_stream)(unsafe.Pointer(strm)).Fstate
 12795  	(*Z_stream)(unsafe.Pointer(strm)).Ftotal_in = libc.AssignPtrUint64(strm+40, libc.AssignPtrUint64(state+40, uint64(0)))
 12796  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = uintptr(Z_NULL)
 12797  	if (*Inflate_state)(unsafe.Pointer(state)).Fwrap != 0 { // to support ill-conceived Java test suite
 12798  		(*Z_stream)(unsafe.Pointer(strm)).Fadler = ULong((*Inflate_state)(unsafe.Pointer(state)).Fwrap & 1)
 12799  	}
 12800  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = HEAD
 12801  	(*Inflate_state)(unsafe.Pointer(state)).Flast = 0
 12802  	(*Inflate_state)(unsafe.Pointer(state)).Fhavedict = 0
 12803  	(*Inflate_state)(unsafe.Pointer(state)).Fdmax = 32768
 12804  	(*Inflate_state)(unsafe.Pointer(state)).Fhead = Gz_headerp(Z_NULL)
 12805  	(*Inflate_state)(unsafe.Pointer(state)).Fhold = uint64(0)
 12806  	(*Inflate_state)(unsafe.Pointer(state)).Fbits = uint32(0)
 12807  	(*Inflate_state)(unsafe.Pointer(state)).Flencode = libc.AssignPtrUintptr(state+112, libc.AssignPtrUintptr(state+144, state+1368 /* &.codes */))
 12808  	(*Inflate_state)(unsafe.Pointer(state)).Fsane = 1
 12809  	(*Inflate_state)(unsafe.Pointer(state)).Fback = -1
 12810  
 12811  	return Z_OK
 12812  }
 12813  
 12814  func XinflateReset(tls *libc.TLS, strm Z_streamp) int32 { /* inflate.c:144:13: */
 12815  	var state uintptr
 12816  
 12817  	if inflateStateCheck(tls, strm) != 0 {
 12818  		return -2
 12819  	}
 12820  	state = (*Z_stream)(unsafe.Pointer(strm)).Fstate
 12821  	(*Inflate_state)(unsafe.Pointer(state)).Fwsize = uint32(0)
 12822  	(*Inflate_state)(unsafe.Pointer(state)).Fwhave = uint32(0)
 12823  	(*Inflate_state)(unsafe.Pointer(state)).Fwnext = uint32(0)
 12824  	return XinflateResetKeep(tls, strm)
 12825  }
 12826  
 12827  func XinflateReset2(tls *libc.TLS, strm Z_streamp, windowBits int32) int32 { /* inflate.c:157:13: */
 12828  	var wrap int32
 12829  	var state uintptr
 12830  
 12831  	// get the state
 12832  	if inflateStateCheck(tls, strm) != 0 {
 12833  		return -2
 12834  	}
 12835  	state = (*Z_stream)(unsafe.Pointer(strm)).Fstate
 12836  
 12837  	// extract wrap request from windowBits parameter
 12838  	if windowBits < 0 {
 12839  		wrap = 0
 12840  		windowBits = -windowBits
 12841  	} else {
 12842  		wrap = windowBits>>4 + 5
 12843  		if windowBits < 48 {
 12844  			windowBits = windowBits & 15
 12845  		}
 12846  	}
 12847  
 12848  	// set number of window bits, free window if different
 12849  	if windowBits != 0 && (windowBits < 8 || windowBits > 15) {
 12850  		return -2
 12851  	}
 12852  	if (*Inflate_state)(unsafe.Pointer(state)).Fwindow != uintptr(Z_NULL) && (*Inflate_state)(unsafe.Pointer(state)).Fwbits != uint32(windowBits) {
 12853  		(*struct {
 12854  			f func(*libc.TLS, Voidpf, Voidpf)
 12855  		})(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer(strm)).Fzfree})).f(tls, (*Z_stream)(unsafe.Pointer(strm)).Fopaque, (*Inflate_state)(unsafe.Pointer(state)).Fwindow)
 12856  		(*Inflate_state)(unsafe.Pointer(state)).Fwindow = uintptr(Z_NULL)
 12857  	}
 12858  
 12859  	// update state and reset the rest of it
 12860  	(*Inflate_state)(unsafe.Pointer(state)).Fwrap = wrap
 12861  	(*Inflate_state)(unsafe.Pointer(state)).Fwbits = uint32(windowBits)
 12862  	return XinflateReset(tls, strm)
 12863  }
 12864  
 12865  func XinflateInit2_(tls *libc.TLS, strm Z_streamp, windowBits int32, version uintptr, stream_size int32) int32 { /* inflate.c:195:13: */
 12866  	var ret int32
 12867  	var state uintptr
 12868  
 12869  	if version == uintptr(Z_NULL) || int32(*(*uint8)(unsafe.Pointer(version))) != int32(*(*uint8)(unsafe.Pointer(ts))) || stream_size != int32(unsafe.Sizeof(Z_stream{})) {
 12870  		return -6
 12871  	}
 12872  	if strm == uintptr(Z_NULL) {
 12873  		return -2
 12874  	}
 12875  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = uintptr(Z_NULL) // in case we return an error
 12876  	if (*Z_stream)(unsafe.Pointer(strm)).Fzalloc == uintptr(0) {
 12877  		(*Z_stream)(unsafe.Pointer(strm)).Fzalloc = *(*uintptr)(unsafe.Pointer(&struct {
 12878  			f func(*libc.TLS, Voidpf, uint32, uint32) Voidpf
 12879  		}{Xzcalloc}))
 12880  		(*Z_stream)(unsafe.Pointer(strm)).Fopaque = uintptr(0)
 12881  	}
 12882  	if (*Z_stream)(unsafe.Pointer(strm)).Fzfree == uintptr(0) {
 12883  		(*Z_stream)(unsafe.Pointer(strm)).Fzfree = *(*uintptr)(unsafe.Pointer(&struct {
 12884  			f func(*libc.TLS, Voidpf, Voidpf)
 12885  		}{Xzcfree}))
 12886  	}
 12887  	state = (*struct {
 12888  		f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf
 12889  	})(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer(strm)).Fzalloc})).f(tls, (*Z_stream)(unsafe.Pointer(strm)).Fopaque, uint32(1), uint32(unsafe.Sizeof(Inflate_state{})))
 12890  	if state == uintptr(Z_NULL) {
 12891  		return -4
 12892  	}
 12893  
 12894  	(*Z_stream)(unsafe.Pointer(strm)).Fstate = state
 12895  	(*Inflate_state)(unsafe.Pointer(state)).Fstrm = strm
 12896  	(*Inflate_state)(unsafe.Pointer(state)).Fwindow = uintptr(Z_NULL)
 12897  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = HEAD // to pass state test in inflateReset2()
 12898  	ret = XinflateReset2(tls, strm, windowBits)
 12899  	if ret != Z_OK {
 12900  		(*struct {
 12901  			f func(*libc.TLS, Voidpf, Voidpf)
 12902  		})(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer(strm)).Fzfree})).f(tls, (*Z_stream)(unsafe.Pointer(strm)).Fopaque, state)
 12903  		(*Z_stream)(unsafe.Pointer(strm)).Fstate = uintptr(Z_NULL)
 12904  	}
 12905  	return ret
 12906  }
 12907  
 12908  func XinflateInit_(tls *libc.TLS, strm Z_streamp, version uintptr, stream_size int32) int32 { /* inflate.c:239:13: */
 12909  	return XinflateInit2_(tls, strm, MAX_WBITS, version, stream_size)
 12910  }
 12911  
 12912  func XinflatePrime(tls *libc.TLS, strm Z_streamp, bits int32, value int32) int32 { /* inflate.c:247:13: */
 12913  	var state uintptr
 12914  
 12915  	if inflateStateCheck(tls, strm) != 0 {
 12916  		return -2
 12917  	}
 12918  	state = (*Z_stream)(unsafe.Pointer(strm)).Fstate
 12919  	if bits < 0 {
 12920  		(*Inflate_state)(unsafe.Pointer(state)).Fhold = uint64(0)
 12921  		(*Inflate_state)(unsafe.Pointer(state)).Fbits = uint32(0)
 12922  		return Z_OK
 12923  	}
 12924  	if bits > 16 || (*Inflate_state)(unsafe.Pointer(state)).Fbits+UInt(bits) > uint32(32) {
 12925  		return -2
 12926  	}
 12927  	value = int32(int64(value) & (int64(1)<<bits - int64(1)))
 12928  	*(*uint64)(unsafe.Pointer(state + 80)) += uint64(uint32(value) << (*Inflate_state)(unsafe.Pointer(state)).Fbits)
 12929  	*(*uint32)(unsafe.Pointer(state + 88)) += UInt(bits)
 12930  	return Z_OK
 12931  }
 12932  
 12933  //
 12934  //    Return state with length and distance decoding tables and index sizes set to
 12935  //    fixed code decoding.  Normally this returns fixed tables from inffixed.h.
 12936  //    If BUILDFIXED is defined, then instead this routine builds the tables the
 12937  //    first time it's called, and returns those tables the first time and
 12938  //    thereafter.  This reduces the size of the code by about 2K bytes, in
 12939  //    exchange for a little execution time.  However, BUILDFIXED should not be
 12940  //    used for threaded applications, since the rewriting of the tables and virgin
 12941  //    may not be thread-safe.
 12942  //
 12943  func fixedtables1(tls *libc.TLS, state uintptr) { /* inflate.c:278:12: */
 12944  	(*Inflate_state)(unsafe.Pointer(state)).Flencode = uintptr(unsafe.Pointer(&lenfix1))
 12945  	(*Inflate_state)(unsafe.Pointer(state)).Flenbits = uint32(9)
 12946  	(*Inflate_state)(unsafe.Pointer(state)).Fdistcode = uintptr(unsafe.Pointer(&distfix1))
 12947  	(*Inflate_state)(unsafe.Pointer(state)).Fdistbits = uint32(5)
 12948  }
 12949  
 12950  var lenfix1 = [512]Code{
 12951  	{Fop: uint8(96), Fbits: uint8(7)}, {Fbits: uint8(8), Fval: uint16(80)}, {Fbits: uint8(8), Fval: uint16(16)}, {Fop: uint8(20), Fbits: uint8(8), Fval: uint16(115)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(31)}, {Fbits: uint8(8), Fval: uint16(112)}, {Fbits: uint8(8), Fval: uint16(48)},
 12952  	{Fbits: uint8(9), Fval: uint16(192)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(10)}, {Fbits: uint8(8), Fval: uint16(96)}, {Fbits: uint8(8), Fval: uint16(32)}, {Fbits: uint8(9), Fval: uint16(160)}, {Fbits: uint8(8)}, {Fbits: uint8(8), Fval: uint16(128)},
 12953  	{Fbits: uint8(8), Fval: uint16(64)}, {Fbits: uint8(9), Fval: uint16(224)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(6)}, {Fbits: uint8(8), Fval: uint16(88)}, {Fbits: uint8(8), Fval: uint16(24)}, {Fbits: uint8(9), Fval: uint16(144)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(59)},
 12954  	{Fbits: uint8(8), Fval: uint16(120)}, {Fbits: uint8(8), Fval: uint16(56)}, {Fbits: uint8(9), Fval: uint16(208)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(17)}, {Fbits: uint8(8), Fval: uint16(104)}, {Fbits: uint8(8), Fval: uint16(40)}, {Fbits: uint8(9), Fval: uint16(176)},
 12955  	{Fbits: uint8(8), Fval: uint16(8)}, {Fbits: uint8(8), Fval: uint16(136)}, {Fbits: uint8(8), Fval: uint16(72)}, {Fbits: uint8(9), Fval: uint16(240)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(4)}, {Fbits: uint8(8), Fval: uint16(84)}, {Fbits: uint8(8), Fval: uint16(20)},
 12956  	{Fop: uint8(21), Fbits: uint8(8), Fval: uint16(227)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(43)}, {Fbits: uint8(8), Fval: uint16(116)}, {Fbits: uint8(8), Fval: uint16(52)}, {Fbits: uint8(9), Fval: uint16(200)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(13)}, {Fbits: uint8(8), Fval: uint16(100)},
 12957  	{Fbits: uint8(8), Fval: uint16(36)}, {Fbits: uint8(9), Fval: uint16(168)}, {Fbits: uint8(8), Fval: uint16(4)}, {Fbits: uint8(8), Fval: uint16(132)}, {Fbits: uint8(8), Fval: uint16(68)}, {Fbits: uint8(9), Fval: uint16(232)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(8)},
 12958  	{Fbits: uint8(8), Fval: uint16(92)}, {Fbits: uint8(8), Fval: uint16(28)}, {Fbits: uint8(9), Fval: uint16(152)}, {Fop: uint8(20), Fbits: uint8(7), Fval: uint16(83)}, {Fbits: uint8(8), Fval: uint16(124)}, {Fbits: uint8(8), Fval: uint16(60)}, {Fbits: uint8(9), Fval: uint16(216)},
 12959  	{Fop: uint8(18), Fbits: uint8(7), Fval: uint16(23)}, {Fbits: uint8(8), Fval: uint16(108)}, {Fbits: uint8(8), Fval: uint16(44)}, {Fbits: uint8(9), Fval: uint16(184)}, {Fbits: uint8(8), Fval: uint16(12)}, {Fbits: uint8(8), Fval: uint16(140)}, {Fbits: uint8(8), Fval: uint16(76)},
 12960  	{Fbits: uint8(9), Fval: uint16(248)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(3)}, {Fbits: uint8(8), Fval: uint16(82)}, {Fbits: uint8(8), Fval: uint16(18)}, {Fop: uint8(21), Fbits: uint8(8), Fval: uint16(163)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(35)}, {Fbits: uint8(8), Fval: uint16(114)},
 12961  	{Fbits: uint8(8), Fval: uint16(50)}, {Fbits: uint8(9), Fval: uint16(196)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(11)}, {Fbits: uint8(8), Fval: uint16(98)}, {Fbits: uint8(8), Fval: uint16(34)}, {Fbits: uint8(9), Fval: uint16(164)}, {Fbits: uint8(8), Fval: uint16(2)},
 12962  	{Fbits: uint8(8), Fval: uint16(130)}, {Fbits: uint8(8), Fval: uint16(66)}, {Fbits: uint8(9), Fval: uint16(228)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(7)}, {Fbits: uint8(8), Fval: uint16(90)}, {Fbits: uint8(8), Fval: uint16(26)}, {Fbits: uint8(9), Fval: uint16(148)},
 12963  	{Fop: uint8(20), Fbits: uint8(7), Fval: uint16(67)}, {Fbits: uint8(8), Fval: uint16(122)}, {Fbits: uint8(8), Fval: uint16(58)}, {Fbits: uint8(9), Fval: uint16(212)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(19)}, {Fbits: uint8(8), Fval: uint16(106)}, {Fbits: uint8(8), Fval: uint16(42)},
 12964  	{Fbits: uint8(9), Fval: uint16(180)}, {Fbits: uint8(8), Fval: uint16(10)}, {Fbits: uint8(8), Fval: uint16(138)}, {Fbits: uint8(8), Fval: uint16(74)}, {Fbits: uint8(9), Fval: uint16(244)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(5)}, {Fbits: uint8(8), Fval: uint16(86)},
 12965  	{Fbits: uint8(8), Fval: uint16(22)}, {Fop: uint8(64), Fbits: uint8(8)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(51)}, {Fbits: uint8(8), Fval: uint16(118)}, {Fbits: uint8(8), Fval: uint16(54)}, {Fbits: uint8(9), Fval: uint16(204)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(15)},
 12966  	{Fbits: uint8(8), Fval: uint16(102)}, {Fbits: uint8(8), Fval: uint16(38)}, {Fbits: uint8(9), Fval: uint16(172)}, {Fbits: uint8(8), Fval: uint16(6)}, {Fbits: uint8(8), Fval: uint16(134)}, {Fbits: uint8(8), Fval: uint16(70)}, {Fbits: uint8(9), Fval: uint16(236)},
 12967  	{Fop: uint8(16), Fbits: uint8(7), Fval: uint16(9)}, {Fbits: uint8(8), Fval: uint16(94)}, {Fbits: uint8(8), Fval: uint16(30)}, {Fbits: uint8(9), Fval: uint16(156)}, {Fop: uint8(20), Fbits: uint8(7), Fval: uint16(99)}, {Fbits: uint8(8), Fval: uint16(126)}, {Fbits: uint8(8), Fval: uint16(62)},
 12968  	{Fbits: uint8(9), Fval: uint16(220)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(27)}, {Fbits: uint8(8), Fval: uint16(110)}, {Fbits: uint8(8), Fval: uint16(46)}, {Fbits: uint8(9), Fval: uint16(188)}, {Fbits: uint8(8), Fval: uint16(14)}, {Fbits: uint8(8), Fval: uint16(142)},
 12969  	{Fbits: uint8(8), Fval: uint16(78)}, {Fbits: uint8(9), Fval: uint16(252)}, {Fop: uint8(96), Fbits: uint8(7)}, {Fbits: uint8(8), Fval: uint16(81)}, {Fbits: uint8(8), Fval: uint16(17)}, {Fop: uint8(21), Fbits: uint8(8), Fval: uint16(131)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(31)},
 12970  	{Fbits: uint8(8), Fval: uint16(113)}, {Fbits: uint8(8), Fval: uint16(49)}, {Fbits: uint8(9), Fval: uint16(194)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(10)}, {Fbits: uint8(8), Fval: uint16(97)}, {Fbits: uint8(8), Fval: uint16(33)}, {Fbits: uint8(9), Fval: uint16(162)},
 12971  	{Fbits: uint8(8), Fval: uint16(1)}, {Fbits: uint8(8), Fval: uint16(129)}, {Fbits: uint8(8), Fval: uint16(65)}, {Fbits: uint8(9), Fval: uint16(226)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(6)}, {Fbits: uint8(8), Fval: uint16(89)}, {Fbits: uint8(8), Fval: uint16(25)},
 12972  	{Fbits: uint8(9), Fval: uint16(146)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(59)}, {Fbits: uint8(8), Fval: uint16(121)}, {Fbits: uint8(8), Fval: uint16(57)}, {Fbits: uint8(9), Fval: uint16(210)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(17)}, {Fbits: uint8(8), Fval: uint16(105)},
 12973  	{Fbits: uint8(8), Fval: uint16(41)}, {Fbits: uint8(9), Fval: uint16(178)}, {Fbits: uint8(8), Fval: uint16(9)}, {Fbits: uint8(8), Fval: uint16(137)}, {Fbits: uint8(8), Fval: uint16(73)}, {Fbits: uint8(9), Fval: uint16(242)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(4)},
 12974  	{Fbits: uint8(8), Fval: uint16(85)}, {Fbits: uint8(8), Fval: uint16(21)}, {Fop: uint8(16), Fbits: uint8(8), Fval: uint16(258)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(43)}, {Fbits: uint8(8), Fval: uint16(117)}, {Fbits: uint8(8), Fval: uint16(53)}, {Fbits: uint8(9), Fval: uint16(202)},
 12975  	{Fop: uint8(17), Fbits: uint8(7), Fval: uint16(13)}, {Fbits: uint8(8), Fval: uint16(101)}, {Fbits: uint8(8), Fval: uint16(37)}, {Fbits: uint8(9), Fval: uint16(170)}, {Fbits: uint8(8), Fval: uint16(5)}, {Fbits: uint8(8), Fval: uint16(133)}, {Fbits: uint8(8), Fval: uint16(69)},
 12976  	{Fbits: uint8(9), Fval: uint16(234)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(8)}, {Fbits: uint8(8), Fval: uint16(93)}, {Fbits: uint8(8), Fval: uint16(29)}, {Fbits: uint8(9), Fval: uint16(154)}, {Fop: uint8(20), Fbits: uint8(7), Fval: uint16(83)}, {Fbits: uint8(8), Fval: uint16(125)},
 12977  	{Fbits: uint8(8), Fval: uint16(61)}, {Fbits: uint8(9), Fval: uint16(218)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(23)}, {Fbits: uint8(8), Fval: uint16(109)}, {Fbits: uint8(8), Fval: uint16(45)}, {Fbits: uint8(9), Fval: uint16(186)}, {Fbits: uint8(8), Fval: uint16(13)},
 12978  	{Fbits: uint8(8), Fval: uint16(141)}, {Fbits: uint8(8), Fval: uint16(77)}, {Fbits: uint8(9), Fval: uint16(250)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(3)}, {Fbits: uint8(8), Fval: uint16(83)}, {Fbits: uint8(8), Fval: uint16(19)}, {Fop: uint8(21), Fbits: uint8(8), Fval: uint16(195)},
 12979  	{Fop: uint8(19), Fbits: uint8(7), Fval: uint16(35)}, {Fbits: uint8(8), Fval: uint16(115)}, {Fbits: uint8(8), Fval: uint16(51)}, {Fbits: uint8(9), Fval: uint16(198)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(11)}, {Fbits: uint8(8), Fval: uint16(99)}, {Fbits: uint8(8), Fval: uint16(35)},
 12980  	{Fbits: uint8(9), Fval: uint16(166)}, {Fbits: uint8(8), Fval: uint16(3)}, {Fbits: uint8(8), Fval: uint16(131)}, {Fbits: uint8(8), Fval: uint16(67)}, {Fbits: uint8(9), Fval: uint16(230)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(7)}, {Fbits: uint8(8), Fval: uint16(91)},
 12981  	{Fbits: uint8(8), Fval: uint16(27)}, {Fbits: uint8(9), Fval: uint16(150)}, {Fop: uint8(20), Fbits: uint8(7), Fval: uint16(67)}, {Fbits: uint8(8), Fval: uint16(123)}, {Fbits: uint8(8), Fval: uint16(59)}, {Fbits: uint8(9), Fval: uint16(214)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(19)},
 12982  	{Fbits: uint8(8), Fval: uint16(107)}, {Fbits: uint8(8), Fval: uint16(43)}, {Fbits: uint8(9), Fval: uint16(182)}, {Fbits: uint8(8), Fval: uint16(11)}, {Fbits: uint8(8), Fval: uint16(139)}, {Fbits: uint8(8), Fval: uint16(75)}, {Fbits: uint8(9), Fval: uint16(246)},
 12983  	{Fop: uint8(16), Fbits: uint8(7), Fval: uint16(5)}, {Fbits: uint8(8), Fval: uint16(87)}, {Fbits: uint8(8), Fval: uint16(23)}, {Fop: uint8(64), Fbits: uint8(8)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(51)}, {Fbits: uint8(8), Fval: uint16(119)}, {Fbits: uint8(8), Fval: uint16(55)},
 12984  	{Fbits: uint8(9), Fval: uint16(206)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(15)}, {Fbits: uint8(8), Fval: uint16(103)}, {Fbits: uint8(8), Fval: uint16(39)}, {Fbits: uint8(9), Fval: uint16(174)}, {Fbits: uint8(8), Fval: uint16(7)}, {Fbits: uint8(8), Fval: uint16(135)},
 12985  	{Fbits: uint8(8), Fval: uint16(71)}, {Fbits: uint8(9), Fval: uint16(238)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(9)}, {Fbits: uint8(8), Fval: uint16(95)}, {Fbits: uint8(8), Fval: uint16(31)}, {Fbits: uint8(9), Fval: uint16(158)}, {Fop: uint8(20), Fbits: uint8(7), Fval: uint16(99)},
 12986  	{Fbits: uint8(8), Fval: uint16(127)}, {Fbits: uint8(8), Fval: uint16(63)}, {Fbits: uint8(9), Fval: uint16(222)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(27)}, {Fbits: uint8(8), Fval: uint16(111)}, {Fbits: uint8(8), Fval: uint16(47)}, {Fbits: uint8(9), Fval: uint16(190)},
 12987  	{Fbits: uint8(8), Fval: uint16(15)}, {Fbits: uint8(8), Fval: uint16(143)}, {Fbits: uint8(8), Fval: uint16(79)}, {Fbits: uint8(9), Fval: uint16(254)}, {Fop: uint8(96), Fbits: uint8(7)}, {Fbits: uint8(8), Fval: uint16(80)}, {Fbits: uint8(8), Fval: uint16(16)},
 12988  	{Fop: uint8(20), Fbits: uint8(8), Fval: uint16(115)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(31)}, {Fbits: uint8(8), Fval: uint16(112)}, {Fbits: uint8(8), Fval: uint16(48)}, {Fbits: uint8(9), Fval: uint16(193)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(10)}, {Fbits: uint8(8), Fval: uint16(96)},
 12989  	{Fbits: uint8(8), Fval: uint16(32)}, {Fbits: uint8(9), Fval: uint16(161)}, {Fbits: uint8(8)}, {Fbits: uint8(8), Fval: uint16(128)}, {Fbits: uint8(8), Fval: uint16(64)}, {Fbits: uint8(9), Fval: uint16(225)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(6)},
 12990  	{Fbits: uint8(8), Fval: uint16(88)}, {Fbits: uint8(8), Fval: uint16(24)}, {Fbits: uint8(9), Fval: uint16(145)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(59)}, {Fbits: uint8(8), Fval: uint16(120)}, {Fbits: uint8(8), Fval: uint16(56)}, {Fbits: uint8(9), Fval: uint16(209)},
 12991  	{Fop: uint8(17), Fbits: uint8(7), Fval: uint16(17)}, {Fbits: uint8(8), Fval: uint16(104)}, {Fbits: uint8(8), Fval: uint16(40)}, {Fbits: uint8(9), Fval: uint16(177)}, {Fbits: uint8(8), Fval: uint16(8)}, {Fbits: uint8(8), Fval: uint16(136)}, {Fbits: uint8(8), Fval: uint16(72)},
 12992  	{Fbits: uint8(9), Fval: uint16(241)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(4)}, {Fbits: uint8(8), Fval: uint16(84)}, {Fbits: uint8(8), Fval: uint16(20)}, {Fop: uint8(21), Fbits: uint8(8), Fval: uint16(227)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(43)}, {Fbits: uint8(8), Fval: uint16(116)},
 12993  	{Fbits: uint8(8), Fval: uint16(52)}, {Fbits: uint8(9), Fval: uint16(201)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(13)}, {Fbits: uint8(8), Fval: uint16(100)}, {Fbits: uint8(8), Fval: uint16(36)}, {Fbits: uint8(9), Fval: uint16(169)}, {Fbits: uint8(8), Fval: uint16(4)},
 12994  	{Fbits: uint8(8), Fval: uint16(132)}, {Fbits: uint8(8), Fval: uint16(68)}, {Fbits: uint8(9), Fval: uint16(233)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(8)}, {Fbits: uint8(8), Fval: uint16(92)}, {Fbits: uint8(8), Fval: uint16(28)}, {Fbits: uint8(9), Fval: uint16(153)},
 12995  	{Fop: uint8(20), Fbits: uint8(7), Fval: uint16(83)}, {Fbits: uint8(8), Fval: uint16(124)}, {Fbits: uint8(8), Fval: uint16(60)}, {Fbits: uint8(9), Fval: uint16(217)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(23)}, {Fbits: uint8(8), Fval: uint16(108)}, {Fbits: uint8(8), Fval: uint16(44)},
 12996  	{Fbits: uint8(9), Fval: uint16(185)}, {Fbits: uint8(8), Fval: uint16(12)}, {Fbits: uint8(8), Fval: uint16(140)}, {Fbits: uint8(8), Fval: uint16(76)}, {Fbits: uint8(9), Fval: uint16(249)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(3)}, {Fbits: uint8(8), Fval: uint16(82)},
 12997  	{Fbits: uint8(8), Fval: uint16(18)}, {Fop: uint8(21), Fbits: uint8(8), Fval: uint16(163)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(35)}, {Fbits: uint8(8), Fval: uint16(114)}, {Fbits: uint8(8), Fval: uint16(50)}, {Fbits: uint8(9), Fval: uint16(197)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(11)},
 12998  	{Fbits: uint8(8), Fval: uint16(98)}, {Fbits: uint8(8), Fval: uint16(34)}, {Fbits: uint8(9), Fval: uint16(165)}, {Fbits: uint8(8), Fval: uint16(2)}, {Fbits: uint8(8), Fval: uint16(130)}, {Fbits: uint8(8), Fval: uint16(66)}, {Fbits: uint8(9), Fval: uint16(229)},
 12999  	{Fop: uint8(16), Fbits: uint8(7), Fval: uint16(7)}, {Fbits: uint8(8), Fval: uint16(90)}, {Fbits: uint8(8), Fval: uint16(26)}, {Fbits: uint8(9), Fval: uint16(149)}, {Fop: uint8(20), Fbits: uint8(7), Fval: uint16(67)}, {Fbits: uint8(8), Fval: uint16(122)}, {Fbits: uint8(8), Fval: uint16(58)},
 13000  	{Fbits: uint8(9), Fval: uint16(213)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(19)}, {Fbits: uint8(8), Fval: uint16(106)}, {Fbits: uint8(8), Fval: uint16(42)}, {Fbits: uint8(9), Fval: uint16(181)}, {Fbits: uint8(8), Fval: uint16(10)}, {Fbits: uint8(8), Fval: uint16(138)},
 13001  	{Fbits: uint8(8), Fval: uint16(74)}, {Fbits: uint8(9), Fval: uint16(245)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(5)}, {Fbits: uint8(8), Fval: uint16(86)}, {Fbits: uint8(8), Fval: uint16(22)}, {Fop: uint8(64), Fbits: uint8(8)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(51)},
 13002  	{Fbits: uint8(8), Fval: uint16(118)}, {Fbits: uint8(8), Fval: uint16(54)}, {Fbits: uint8(9), Fval: uint16(205)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(15)}, {Fbits: uint8(8), Fval: uint16(102)}, {Fbits: uint8(8), Fval: uint16(38)}, {Fbits: uint8(9), Fval: uint16(173)},
 13003  	{Fbits: uint8(8), Fval: uint16(6)}, {Fbits: uint8(8), Fval: uint16(134)}, {Fbits: uint8(8), Fval: uint16(70)}, {Fbits: uint8(9), Fval: uint16(237)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(9)}, {Fbits: uint8(8), Fval: uint16(94)}, {Fbits: uint8(8), Fval: uint16(30)},
 13004  	{Fbits: uint8(9), Fval: uint16(157)}, {Fop: uint8(20), Fbits: uint8(7), Fval: uint16(99)}, {Fbits: uint8(8), Fval: uint16(126)}, {Fbits: uint8(8), Fval: uint16(62)}, {Fbits: uint8(9), Fval: uint16(221)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(27)}, {Fbits: uint8(8), Fval: uint16(110)},
 13005  	{Fbits: uint8(8), Fval: uint16(46)}, {Fbits: uint8(9), Fval: uint16(189)}, {Fbits: uint8(8), Fval: uint16(14)}, {Fbits: uint8(8), Fval: uint16(142)}, {Fbits: uint8(8), Fval: uint16(78)}, {Fbits: uint8(9), Fval: uint16(253)}, {Fop: uint8(96), Fbits: uint8(7)},
 13006  	{Fbits: uint8(8), Fval: uint16(81)}, {Fbits: uint8(8), Fval: uint16(17)}, {Fop: uint8(21), Fbits: uint8(8), Fval: uint16(131)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(31)}, {Fbits: uint8(8), Fval: uint16(113)}, {Fbits: uint8(8), Fval: uint16(49)}, {Fbits: uint8(9), Fval: uint16(195)},
 13007  	{Fop: uint8(16), Fbits: uint8(7), Fval: uint16(10)}, {Fbits: uint8(8), Fval: uint16(97)}, {Fbits: uint8(8), Fval: uint16(33)}, {Fbits: uint8(9), Fval: uint16(163)}, {Fbits: uint8(8), Fval: uint16(1)}, {Fbits: uint8(8), Fval: uint16(129)}, {Fbits: uint8(8), Fval: uint16(65)},
 13008  	{Fbits: uint8(9), Fval: uint16(227)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(6)}, {Fbits: uint8(8), Fval: uint16(89)}, {Fbits: uint8(8), Fval: uint16(25)}, {Fbits: uint8(9), Fval: uint16(147)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(59)}, {Fbits: uint8(8), Fval: uint16(121)},
 13009  	{Fbits: uint8(8), Fval: uint16(57)}, {Fbits: uint8(9), Fval: uint16(211)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(17)}, {Fbits: uint8(8), Fval: uint16(105)}, {Fbits: uint8(8), Fval: uint16(41)}, {Fbits: uint8(9), Fval: uint16(179)}, {Fbits: uint8(8), Fval: uint16(9)},
 13010  	{Fbits: uint8(8), Fval: uint16(137)}, {Fbits: uint8(8), Fval: uint16(73)}, {Fbits: uint8(9), Fval: uint16(243)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(4)}, {Fbits: uint8(8), Fval: uint16(85)}, {Fbits: uint8(8), Fval: uint16(21)}, {Fop: uint8(16), Fbits: uint8(8), Fval: uint16(258)},
 13011  	{Fop: uint8(19), Fbits: uint8(7), Fval: uint16(43)}, {Fbits: uint8(8), Fval: uint16(117)}, {Fbits: uint8(8), Fval: uint16(53)}, {Fbits: uint8(9), Fval: uint16(203)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(13)}, {Fbits: uint8(8), Fval: uint16(101)}, {Fbits: uint8(8), Fval: uint16(37)},
 13012  	{Fbits: uint8(9), Fval: uint16(171)}, {Fbits: uint8(8), Fval: uint16(5)}, {Fbits: uint8(8), Fval: uint16(133)}, {Fbits: uint8(8), Fval: uint16(69)}, {Fbits: uint8(9), Fval: uint16(235)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(8)}, {Fbits: uint8(8), Fval: uint16(93)},
 13013  	{Fbits: uint8(8), Fval: uint16(29)}, {Fbits: uint8(9), Fval: uint16(155)}, {Fop: uint8(20), Fbits: uint8(7), Fval: uint16(83)}, {Fbits: uint8(8), Fval: uint16(125)}, {Fbits: uint8(8), Fval: uint16(61)}, {Fbits: uint8(9), Fval: uint16(219)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(23)},
 13014  	{Fbits: uint8(8), Fval: uint16(109)}, {Fbits: uint8(8), Fval: uint16(45)}, {Fbits: uint8(9), Fval: uint16(187)}, {Fbits: uint8(8), Fval: uint16(13)}, {Fbits: uint8(8), Fval: uint16(141)}, {Fbits: uint8(8), Fval: uint16(77)}, {Fbits: uint8(9), Fval: uint16(251)},
 13015  	{Fop: uint8(16), Fbits: uint8(7), Fval: uint16(3)}, {Fbits: uint8(8), Fval: uint16(83)}, {Fbits: uint8(8), Fval: uint16(19)}, {Fop: uint8(21), Fbits: uint8(8), Fval: uint16(195)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(35)}, {Fbits: uint8(8), Fval: uint16(115)}, {Fbits: uint8(8), Fval: uint16(51)},
 13016  	{Fbits: uint8(9), Fval: uint16(199)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(11)}, {Fbits: uint8(8), Fval: uint16(99)}, {Fbits: uint8(8), Fval: uint16(35)}, {Fbits: uint8(9), Fval: uint16(167)}, {Fbits: uint8(8), Fval: uint16(3)}, {Fbits: uint8(8), Fval: uint16(131)},
 13017  	{Fbits: uint8(8), Fval: uint16(67)}, {Fbits: uint8(9), Fval: uint16(231)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(7)}, {Fbits: uint8(8), Fval: uint16(91)}, {Fbits: uint8(8), Fval: uint16(27)}, {Fbits: uint8(9), Fval: uint16(151)}, {Fop: uint8(20), Fbits: uint8(7), Fval: uint16(67)},
 13018  	{Fbits: uint8(8), Fval: uint16(123)}, {Fbits: uint8(8), Fval: uint16(59)}, {Fbits: uint8(9), Fval: uint16(215)}, {Fop: uint8(18), Fbits: uint8(7), Fval: uint16(19)}, {Fbits: uint8(8), Fval: uint16(107)}, {Fbits: uint8(8), Fval: uint16(43)}, {Fbits: uint8(9), Fval: uint16(183)},
 13019  	{Fbits: uint8(8), Fval: uint16(11)}, {Fbits: uint8(8), Fval: uint16(139)}, {Fbits: uint8(8), Fval: uint16(75)}, {Fbits: uint8(9), Fval: uint16(247)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(5)}, {Fbits: uint8(8), Fval: uint16(87)}, {Fbits: uint8(8), Fval: uint16(23)},
 13020  	{Fop: uint8(64), Fbits: uint8(8)}, {Fop: uint8(19), Fbits: uint8(7), Fval: uint16(51)}, {Fbits: uint8(8), Fval: uint16(119)}, {Fbits: uint8(8), Fval: uint16(55)}, {Fbits: uint8(9), Fval: uint16(207)}, {Fop: uint8(17), Fbits: uint8(7), Fval: uint16(15)}, {Fbits: uint8(8), Fval: uint16(103)},
 13021  	{Fbits: uint8(8), Fval: uint16(39)}, {Fbits: uint8(9), Fval: uint16(175)}, {Fbits: uint8(8), Fval: uint16(7)}, {Fbits: uint8(8), Fval: uint16(135)}, {Fbits: uint8(8), Fval: uint16(71)}, {Fbits: uint8(9), Fval: uint16(239)}, {Fop: uint8(16), Fbits: uint8(7), Fval: uint16(9)},
 13022  	{Fbits: uint8(8), Fval: uint16(95)}, {Fbits: uint8(8), Fval: uint16(31)}, {Fbits: uint8(9), Fval: uint16(159)}, {Fop: uint8(20), Fbits: uint8(7), Fval: uint16(99)}, {Fbits: uint8(8), Fval: uint16(127)}, {Fbits: uint8(8), Fval: uint16(63)}, {Fbits: uint8(9), Fval: uint16(223)},
 13023  	{Fop: uint8(18), Fbits: uint8(7), Fval: uint16(27)}, {Fbits: uint8(8), Fval: uint16(111)}, {Fbits: uint8(8), Fval: uint16(47)}, {Fbits: uint8(9), Fval: uint16(191)}, {Fbits: uint8(8), Fval: uint16(15)}, {Fbits: uint8(8), Fval: uint16(143)}, {Fbits: uint8(8), Fval: uint16(79)},
 13024  	{Fbits: uint8(9), Fval: uint16(255)},
 13025  } /* inffixed.h:10:23 */
 13026  var distfix1 = [32]Code{
 13027  	{Fop: uint8(16), Fbits: uint8(5), Fval: uint16(1)}, {Fop: uint8(23), Fbits: uint8(5), Fval: uint16(257)}, {Fop: uint8(19), Fbits: uint8(5), Fval: uint16(17)}, {Fop: uint8(27), Fbits: uint8(5), Fval: uint16(4097)}, {Fop: uint8(17), Fbits: uint8(5), Fval: uint16(5)}, {Fop: uint8(25), Fbits: uint8(5), Fval: uint16(1025)},
 13028  	{Fop: uint8(21), Fbits: uint8(5), Fval: uint16(65)}, {Fop: uint8(29), Fbits: uint8(5), Fval: uint16(16385)}, {Fop: uint8(16), Fbits: uint8(5), Fval: uint16(3)}, {Fop: uint8(24), Fbits: uint8(5), Fval: uint16(513)}, {Fop: uint8(20), Fbits: uint8(5), Fval: uint16(33)}, {Fop: uint8(28), Fbits: uint8(5), Fval: uint16(8193)},
 13029  	{Fop: uint8(18), Fbits: uint8(5), Fval: uint16(9)}, {Fop: uint8(26), Fbits: uint8(5), Fval: uint16(2049)}, {Fop: uint8(22), Fbits: uint8(5), Fval: uint16(129)}, {Fop: uint8(64), Fbits: uint8(5)}, {Fop: uint8(16), Fbits: uint8(5), Fval: uint16(2)}, {Fop: uint8(23), Fbits: uint8(5), Fval: uint16(385)},
 13030  	{Fop: uint8(19), Fbits: uint8(5), Fval: uint16(25)}, {Fop: uint8(27), Fbits: uint8(5), Fval: uint16(6145)}, {Fop: uint8(17), Fbits: uint8(5), Fval: uint16(7)}, {Fop: uint8(25), Fbits: uint8(5), Fval: uint16(1537)}, {Fop: uint8(21), Fbits: uint8(5), Fval: uint16(97)}, {Fop: uint8(29), Fbits: uint8(5), Fval: uint16(24577)},
 13031  	{Fop: uint8(16), Fbits: uint8(5), Fval: uint16(4)}, {Fop: uint8(24), Fbits: uint8(5), Fval: uint16(769)}, {Fop: uint8(20), Fbits: uint8(5), Fval: uint16(49)}, {Fop: uint8(28), Fbits: uint8(5), Fval: uint16(12289)}, {Fop: uint8(18), Fbits: uint8(5), Fval: uint16(13)}, {Fop: uint8(26), Fbits: uint8(5), Fval: uint16(3073)},
 13032  	{Fop: uint8(22), Fbits: uint8(5), Fval: uint16(193)}, {Fop: uint8(64), Fbits: uint8(5)},
 13033  } /* inffixed.h:87:23 */
 13034  
 13035  //
 13036  //    Update the window with the last wsize (normally 32K) bytes written before
 13037  //    returning.  If window does not exist yet, create it.  This is only called
 13038  //    when a window is already in use, or when output has been written during this
 13039  //    inflate call, but the end of the deflate stream has not been reached yet.
 13040  //    It is also called to create a window for dictionary data when a dictionary
 13041  //    is loaded.
 13042  //
 13043  //    Providing output buffers larger than 32K to inflate() should provide a speed
 13044  //    advantage, since only the last 32K of output is copied to the sliding window
 13045  //    upon return from inflate(), and since all distances after the first 32K of
 13046  //    output will fall in the output data, making match copies simpler and faster.
 13047  //    The advantage may be dependent on the size of the processor's data caches.
 13048  //
 13049  func updatewindow(tls *libc.TLS, strm Z_streamp, end uintptr, copy uint32) int32 { /* inflate.c:396:11: */
 13050  	var state uintptr
 13051  	var dist uint32
 13052  
 13053  	state = (*Z_stream)(unsafe.Pointer(strm)).Fstate
 13054  
 13055  	// if it hasn't been done already, allocate space for the window
 13056  	if (*Inflate_state)(unsafe.Pointer(state)).Fwindow == uintptr(Z_NULL) {
 13057  		(*Inflate_state)(unsafe.Pointer(state)).Fwindow = (*struct {
 13058  			f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf
 13059  		})(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer(strm)).Fzalloc})).f(tls, (*Z_stream)(unsafe.Pointer(strm)).Fopaque, uint32(1)<<(*Inflate_state)(unsafe.Pointer(state)).Fwbits, uint32(unsafe.Sizeof(uint8(0))))
 13060  		if (*Inflate_state)(unsafe.Pointer(state)).Fwindow == uintptr(Z_NULL) {
 13061  			return 1
 13062  		}
 13063  	}
 13064  
 13065  	// if window not in use yet, initialize
 13066  	if (*Inflate_state)(unsafe.Pointer(state)).Fwsize == uint32(0) {
 13067  		(*Inflate_state)(unsafe.Pointer(state)).Fwsize = uint32(1) << (*Inflate_state)(unsafe.Pointer(state)).Fwbits
 13068  		(*Inflate_state)(unsafe.Pointer(state)).Fwnext = uint32(0)
 13069  		(*Inflate_state)(unsafe.Pointer(state)).Fwhave = uint32(0)
 13070  	}
 13071  
 13072  	// copy state->wsize or less output bytes into the circular window
 13073  	if copy >= (*Inflate_state)(unsafe.Pointer(state)).Fwsize {
 13074  		libc.Xmemcpy(tls, (*Inflate_state)(unsafe.Pointer(state)).Fwindow, end-uintptr((*Inflate_state)(unsafe.Pointer(state)).Fwsize), uint64((*Inflate_state)(unsafe.Pointer(state)).Fwsize))
 13075  		(*Inflate_state)(unsafe.Pointer(state)).Fwnext = uint32(0)
 13076  		(*Inflate_state)(unsafe.Pointer(state)).Fwhave = (*Inflate_state)(unsafe.Pointer(state)).Fwsize
 13077  	} else {
 13078  		dist = (*Inflate_state)(unsafe.Pointer(state)).Fwsize - (*Inflate_state)(unsafe.Pointer(state)).Fwnext
 13079  		if dist > copy {
 13080  			dist = copy
 13081  		}
 13082  		libc.Xmemcpy(tls, (*Inflate_state)(unsafe.Pointer(state)).Fwindow+uintptr((*Inflate_state)(unsafe.Pointer(state)).Fwnext), end-uintptr(copy), uint64(dist))
 13083  		copy = copy - dist
 13084  		if copy != 0 {
 13085  			libc.Xmemcpy(tls, (*Inflate_state)(unsafe.Pointer(state)).Fwindow, end-uintptr(copy), uint64(copy))
 13086  			(*Inflate_state)(unsafe.Pointer(state)).Fwnext = copy
 13087  			(*Inflate_state)(unsafe.Pointer(state)).Fwhave = (*Inflate_state)(unsafe.Pointer(state)).Fwsize
 13088  		} else {
 13089  			*(*uint32)(unsafe.Pointer(state + 68)) += dist
 13090  			if (*Inflate_state)(unsafe.Pointer(state)).Fwnext == (*Inflate_state)(unsafe.Pointer(state)).Fwsize {
 13091  				(*Inflate_state)(unsafe.Pointer(state)).Fwnext = uint32(0)
 13092  			}
 13093  			if (*Inflate_state)(unsafe.Pointer(state)).Fwhave < (*Inflate_state)(unsafe.Pointer(state)).Fwsize {
 13094  				*(*uint32)(unsafe.Pointer(state + 64)) += dist
 13095  			}
 13096  		}
 13097  	}
 13098  	return 0
 13099  }
 13100  
 13101  // Macros for inflate():
 13102  
 13103  // check function to use adler32() for zlib or crc32() for gzip
 13104  
 13105  // check macros for header crc
 13106  
 13107  // Load registers with state in inflate() for speed
 13108  
 13109  // Restore state from registers in inflate()
 13110  
 13111  // Clear the input bit accumulator
 13112  
 13113  // Get a byte of input into the bit accumulator, or return from inflate()
 13114  //    if there is no input available.
 13115  
 13116  // Assure that there are at least n bits in the bit accumulator.  If there is
 13117  //    not enough available input to do that, then return from inflate().
 13118  
 13119  // Return the low n bits of the bit accumulator (n < 16)
 13120  
 13121  // Remove n bits from the bit accumulator
 13122  
 13123  // Remove zero to seven bits as needed to go to a byte boundary
 13124  
 13125  //
 13126  //    inflate() uses a state machine to process as much input data and generate as
 13127  //    much output data as possible before returning.  The state machine is
 13128  //    structured roughly as follows:
 13129  //
 13130  //     for (;;) switch (state) {
 13131  //     ...
 13132  //     case STATEn:
 13133  //         if (not enough input data or output space to make progress)
 13134  //             return;
 13135  //         ... make progress ...
 13136  //         state = STATEm;
 13137  //         break;
 13138  //     ...
 13139  //     }
 13140  //
 13141  //    so when inflate() is called again, the same case is attempted again, and
 13142  //    if the appropriate resources are provided, the machine proceeds to the
 13143  //    next state.  The NEEDBITS() macro is usually the way the state evaluates
 13144  //    whether it can proceed or should return.  NEEDBITS() does the return if
 13145  //    the requested bits are not available.  The typical use of the BITS macros
 13146  //    is:
 13147  //
 13148  //         NEEDBITS(n);
 13149  //         ... do something with BITS(n) ...
 13150  //         DROPBITS(n);
 13151  //
 13152  //    where NEEDBITS(n) either returns from inflate() if there isn't enough
 13153  //    input left to load n bits into the accumulator, or it continues.  BITS(n)
 13154  //    gives the low n bits in the accumulator.  When done, DROPBITS(n) drops
 13155  //    the low n bits off the accumulator.  INITBITS() clears the accumulator
 13156  //    and sets the number of available bits to zero.  BYTEBITS() discards just
 13157  //    enough bits to put the accumulator on a byte boundary.  After BYTEBITS()
 13158  //    and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.
 13159  //
 13160  //    NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
 13161  //    if there is no input available.  The decoding of variable length codes uses
 13162  //    PULLBYTE() directly in order to pull just enough bytes to decode the next
 13163  //    code, and no more.
 13164  //
 13165  //    Some states loop until they get enough input, making sure that enough
 13166  //    state information is maintained to continue the loop where it left off
 13167  //    if NEEDBITS() returns in the loop.  For example, want, need, and keep
 13168  //    would all have to actually be part of the saved state in case NEEDBITS()
 13169  //    returns:
 13170  //
 13171  //     case STATEw:
 13172  //         while (want < need) {
 13173  //             NEEDBITS(n);
 13174  //             keep[want++] = BITS(n);
 13175  //             DROPBITS(n);
 13176  //         }
 13177  //         state = STATEx;
 13178  //     case STATEx:
 13179  //
 13180  //    As shown above, if the next state is also the next case, then the break
 13181  //    is omitted.
 13182  //
 13183  //    A state may also return if there is not enough output space available to
 13184  //    complete that state.  Those states are copying stored data, writing a
 13185  //    literal byte, and copying a matching string.
 13186  //
 13187  //    When returning, a "goto inf_leave" is used to update the total counters,
 13188  //    update the check value, and determine whether any progress has been made
 13189  //    during that inflate() call in order to return the proper return code.
 13190  //    Progress is defined as a change in either strm->avail_in or strm->avail_out.
 13191  //    When there is a window, goto inf_leave will update the window with the last
 13192  //    output written.  If a goto inf_leave occurs in the middle of decompression
 13193  //    and there is no window currently, goto inf_leave will create one and copy
 13194  //    output to the window for the next call of inflate().
 13195  //
 13196  //    In this implementation, the flush parameter of inflate() only affects the
 13197  //    return code (per zlib.h).  inflate() always writes as much as possible to
 13198  //    strm->next_out, given the space available and the provided input--the effect
 13199  //    documented in zlib.h of Z_SYNC_FLUSH.  Furthermore, inflate() always defers
 13200  //    the allocation of and copying into a sliding window until necessary, which
 13201  //    provides the effect documented in zlib.h for Z_FINISH when the entire input
 13202  //    stream available.  So the only thing the flush parameter actually does is:
 13203  //    when flush is set to Z_FINISH, inflate() cannot return Z_OK.  Instead it
 13204  //    will return Z_BUF_ERROR if it has not reached the end of the stream.
 13205  //
 13206  
 13207  func Xinflate(tls *libc.TLS, strm Z_streamp, flush int32) int32 { /* inflate.c:622:13: */
 13208  	bp := tls.Alloc(4)
 13209  	defer tls.Free(4)
 13210  
 13211  	var state uintptr
 13212  	var next uintptr // next input
 13213  	var put uintptr  // next output
 13214  	var have uint32
 13215  	var left uint32 // available input and output
 13216  	var hold uint64 // bit buffer
 13217  	var bits uint32 // bits in bit buffer
 13218  	var in uint32
 13219  	var out uint32   // save starting available input and output
 13220  	var copy uint32  // number of stored or match bytes to copy
 13221  	var from uintptr // where to copy match bytes from
 13222  	var here Code    // current decoding table entry
 13223  	var last Code    // parent table entry
 13224  	var len uint32   // length to copy for repeats, bits to drop
 13225  	var ret int32    // return code
 13226  	// var hbuf [4]uint8 at bp, 4
 13227  
 13228  	if !(inflateStateCheck(tls, strm) != 0 || (*Z_stream)(unsafe.Pointer(strm)).Fnext_out == uintptr(Z_NULL) || (*Z_stream)(unsafe.Pointer(strm)).Fnext_in == uintptr(Z_NULL) && (*Z_stream)(unsafe.Pointer(strm)).Favail_in != UInt(0)) {
 13229  		goto __1
 13230  	}
 13231  	return -2
 13232  __1:
 13233  	;
 13234  
 13235  	state = (*Z_stream)(unsafe.Pointer(strm)).Fstate
 13236  	if !((*Inflate_state)(unsafe.Pointer(state)).Fmode == TYPE) {
 13237  		goto __2
 13238  	}
 13239  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = TYPEDO
 13240  __2:
 13241  	; // skip check
 13242  __3:
 13243  	put = (*Z_stream)(unsafe.Pointer(strm)).Fnext_out
 13244  	left = (*Z_stream)(unsafe.Pointer(strm)).Favail_out
 13245  	next = (*Z_stream)(unsafe.Pointer(strm)).Fnext_in
 13246  	have = (*Z_stream)(unsafe.Pointer(strm)).Favail_in
 13247  	hold = (*Inflate_state)(unsafe.Pointer(state)).Fhold
 13248  	bits = (*Inflate_state)(unsafe.Pointer(state)).Fbits
 13249  	goto __4
 13250  __4:
 13251  	if 0 != 0 {
 13252  		goto __3
 13253  	}
 13254  	goto __5
 13255  __5:
 13256  	;
 13257  	in = have
 13258  	out = left
 13259  	ret = Z_OK
 13260  __6:
 13261  	switch (*Inflate_state)(unsafe.Pointer(state)).Fmode {
 13262  	case HEAD:
 13263  		goto __10
 13264  	case FLAGS:
 13265  		goto __11
 13266  	case TIME:
 13267  		goto __12
 13268  	case OS:
 13269  		goto __13
 13270  	case EXLEN:
 13271  		goto __14
 13272  	case EXTRA:
 13273  		goto __15
 13274  	case NAME:
 13275  		goto __16
 13276  	case COMMENT:
 13277  		goto __17
 13278  	case HCRC:
 13279  		goto __18
 13280  	case DICTID:
 13281  		goto __19
 13282  	case DICT:
 13283  		goto __20
 13284  	case TYPE:
 13285  		goto __21
 13286  	case TYPEDO:
 13287  		goto __22
 13288  	case STORED:
 13289  		goto __23
 13290  	case COPY_:
 13291  		goto __24
 13292  	case COPY:
 13293  		goto __25
 13294  	case TABLE:
 13295  		goto __26
 13296  	case LENLENS:
 13297  		goto __27
 13298  	case CODELENS:
 13299  		goto __28
 13300  	case LEN_:
 13301  		goto __29
 13302  	case LEN:
 13303  		goto __30
 13304  	case LENEXT:
 13305  		goto __31
 13306  	case DIST:
 13307  		goto __32
 13308  	case DISTEXT:
 13309  		goto __33
 13310  	case MATCH:
 13311  		goto __34
 13312  	case LIT:
 13313  		goto __35
 13314  	case CHECK:
 13315  		goto __36
 13316  	case LENGTH:
 13317  		goto __37
 13318  	case DONE:
 13319  		goto __38
 13320  	case BAD:
 13321  		goto __39
 13322  	case MEM:
 13323  		goto __40
 13324  	case SYNC:
 13325  		goto __41
 13326  	default:
 13327  		goto __42
 13328  	}
 13329  	goto __9
 13330  __10:
 13331  	if !((*Inflate_state)(unsafe.Pointer(state)).Fwrap == 0) {
 13332  		goto __43
 13333  	}
 13334  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = TYPEDO
 13335  	goto __9
 13336  __43:
 13337  	;
 13338  __44:
 13339  __47:
 13340  	if !(bits < uint32(16)) {
 13341  		goto __48
 13342  	}
 13343  __49:
 13344  	if !(have == uint32(0)) {
 13345  		goto __52
 13346  	}
 13347  	goto inf_leave
 13348  __52:
 13349  	;
 13350  	have--
 13351  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))<<bits
 13352  	bits = bits + uint32(8)
 13353  	goto __50
 13354  __50:
 13355  	if 0 != 0 {
 13356  		goto __49
 13357  	}
 13358  	goto __51
 13359  __51:
 13360  	;
 13361  	goto __47
 13362  __48:
 13363  	;
 13364  	goto __45
 13365  __45:
 13366  	if 0 != 0 {
 13367  		goto __44
 13368  	}
 13369  	goto __46
 13370  __46:
 13371  	;
 13372  	if !((*Inflate_state)(unsafe.Pointer(state)).Fwrap&2 != 0 && hold == uint64(0x8b1f)) {
 13373  		goto __53
 13374  	} // gzip header
 13375  	if !((*Inflate_state)(unsafe.Pointer(state)).Fwbits == uint32(0)) {
 13376  		goto __54
 13377  	}
 13378  	(*Inflate_state)(unsafe.Pointer(state)).Fwbits = uint32(15)
 13379  __54:
 13380  	;
 13381  	(*Inflate_state)(unsafe.Pointer(state)).Fcheck = Xcrc32(tls, uint64(0), uintptr(Z_NULL), uint32(0))
 13382  __55:
 13383  	*(*uint8)(unsafe.Pointer(bp)) = uint8(hold)
 13384  	*(*uint8)(unsafe.Pointer(bp + 1)) = uint8(hold >> 8)
 13385  	(*Inflate_state)(unsafe.Pointer(state)).Fcheck = Xcrc32(tls, (*Inflate_state)(unsafe.Pointer(state)).Fcheck, bp, uint32(2))
 13386  	goto __56
 13387  __56:
 13388  	if 0 != 0 {
 13389  		goto __55
 13390  	}
 13391  	goto __57
 13392  __57:
 13393  	;
 13394  __58:
 13395  	hold = uint64(0)
 13396  	bits = uint32(0)
 13397  	goto __59
 13398  __59:
 13399  	if 0 != 0 {
 13400  		goto __58
 13401  	}
 13402  	goto __60
 13403  __60:
 13404  	;
 13405  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = FLAGS
 13406  	goto __9
 13407  __53:
 13408  	;
 13409  	(*Inflate_state)(unsafe.Pointer(state)).Fflags = 0 // expect zlib header
 13410  	if !((*Inflate_state)(unsafe.Pointer(state)).Fhead != uintptr(Z_NULL)) {
 13411  		goto __61
 13412  	}
 13413  	(*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fdone = -1
 13414  __61:
 13415  	;
 13416  	if !(!((*Inflate_state)(unsafe.Pointer(state)).Fwrap&1 != 0) || (uint64(uint32(hold)&(uint32(1)<<8-uint32(1))<<8)+hold>>8)%uint64(31) != 0) {
 13417  		goto __62
 13418  	}
 13419  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 669 /* "incorrect header..." */
 13420  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 13421  	goto __9
 13422  __62:
 13423  	;
 13424  	if !(uint32(hold)&(uint32(1)<<4-uint32(1)) != uint32(Z_DEFLATED)) {
 13425  		goto __63
 13426  	}
 13427  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 692 /* "unknown compress..." */
 13428  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 13429  	goto __9
 13430  __63:
 13431  	;
 13432  __64:
 13433  	hold >>= 4
 13434  	bits = bits - uint32(4)
 13435  	goto __65
 13436  __65:
 13437  	if 0 != 0 {
 13438  		goto __64
 13439  	}
 13440  	goto __66
 13441  __66:
 13442  	;
 13443  	len = uint32(hold)&(uint32(1)<<4-uint32(1)) + uint32(8)
 13444  	if !((*Inflate_state)(unsafe.Pointer(state)).Fwbits == uint32(0)) {
 13445  		goto __67
 13446  	}
 13447  	(*Inflate_state)(unsafe.Pointer(state)).Fwbits = len
 13448  __67:
 13449  	;
 13450  	if !(len > uint32(15) || len > (*Inflate_state)(unsafe.Pointer(state)).Fwbits) {
 13451  		goto __68
 13452  	}
 13453  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 719 /* "invalid window s..." */
 13454  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 13455  	goto __9
 13456  __68:
 13457  	;
 13458  	(*Inflate_state)(unsafe.Pointer(state)).Fdmax = uint32(1) << len
 13459  
 13460  	(*Z_stream)(unsafe.Pointer(strm)).Fadler = libc.AssignPtrUint64(state+32, Xadler32(tls, uint64(0), uintptr(Z_NULL), uint32(0)))
 13461  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = func() uint32 {
 13462  		if hold&uint64(0x200) != 0 {
 13463  			return DICTID
 13464  		}
 13465  		return TYPE
 13466  	}()
 13467  __69:
 13468  	hold = uint64(0)
 13469  	bits = uint32(0)
 13470  	goto __70
 13471  __70:
 13472  	if 0 != 0 {
 13473  		goto __69
 13474  	}
 13475  	goto __71
 13476  __71:
 13477  	;
 13478  	goto __9
 13479  __11:
 13480  __72:
 13481  __75:
 13482  	if !(bits < uint32(16)) {
 13483  		goto __76
 13484  	}
 13485  __77:
 13486  	if !(have == uint32(0)) {
 13487  		goto __80
 13488  	}
 13489  	goto inf_leave
 13490  __80:
 13491  	;
 13492  	have--
 13493  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))<<bits
 13494  	bits = bits + uint32(8)
 13495  	goto __78
 13496  __78:
 13497  	if 0 != 0 {
 13498  		goto __77
 13499  	}
 13500  	goto __79
 13501  __79:
 13502  	;
 13503  	goto __75
 13504  __76:
 13505  	;
 13506  	goto __73
 13507  __73:
 13508  	if 0 != 0 {
 13509  		goto __72
 13510  	}
 13511  	goto __74
 13512  __74:
 13513  	;
 13514  	(*Inflate_state)(unsafe.Pointer(state)).Fflags = int32(hold)
 13515  	if !((*Inflate_state)(unsafe.Pointer(state)).Fflags&0xff != Z_DEFLATED) {
 13516  		goto __81
 13517  	}
 13518  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 692 /* "unknown compress..." */
 13519  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 13520  	goto __9
 13521  __81:
 13522  	;
 13523  	if !((*Inflate_state)(unsafe.Pointer(state)).Fflags&0xe000 != 0) {
 13524  		goto __82
 13525  	}
 13526  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 739 /* "unknown header f..." */
 13527  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 13528  	goto __9
 13529  __82:
 13530  	;
 13531  	if !((*Inflate_state)(unsafe.Pointer(state)).Fhead != uintptr(Z_NULL)) {
 13532  		goto __83
 13533  	}
 13534  	(*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Ftext = int32(hold >> 8 & uint64(1))
 13535  __83:
 13536  	;
 13537  	if !((*Inflate_state)(unsafe.Pointer(state)).Fflags&0x0200 != 0 && (*Inflate_state)(unsafe.Pointer(state)).Fwrap&4 != 0) {
 13538  		goto __84
 13539  	}
 13540  __85:
 13541  	*(*uint8)(unsafe.Pointer(bp)) = uint8(hold)
 13542  	*(*uint8)(unsafe.Pointer(bp + 1)) = uint8(hold >> 8)
 13543  	(*Inflate_state)(unsafe.Pointer(state)).Fcheck = Xcrc32(tls, (*Inflate_state)(unsafe.Pointer(state)).Fcheck, bp, uint32(2))
 13544  	goto __86
 13545  __86:
 13546  	if 0 != 0 {
 13547  		goto __85
 13548  	}
 13549  	goto __87
 13550  __87:
 13551  	;
 13552  __84:
 13553  	;
 13554  __88:
 13555  	hold = uint64(0)
 13556  	bits = uint32(0)
 13557  	goto __89
 13558  __89:
 13559  	if 0 != 0 {
 13560  		goto __88
 13561  	}
 13562  	goto __90
 13563  __90:
 13564  	;
 13565  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = TIME
 13566  __12:
 13567  __91:
 13568  __94:
 13569  	if !(bits < uint32(32)) {
 13570  		goto __95
 13571  	}
 13572  __96:
 13573  	if !(have == uint32(0)) {
 13574  		goto __99
 13575  	}
 13576  	goto inf_leave
 13577  __99:
 13578  	;
 13579  	have--
 13580  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))<<bits
 13581  	bits = bits + uint32(8)
 13582  	goto __97
 13583  __97:
 13584  	if 0 != 0 {
 13585  		goto __96
 13586  	}
 13587  	goto __98
 13588  __98:
 13589  	;
 13590  	goto __94
 13591  __95:
 13592  	;
 13593  	goto __92
 13594  __92:
 13595  	if 0 != 0 {
 13596  		goto __91
 13597  	}
 13598  	goto __93
 13599  __93:
 13600  	;
 13601  	if !((*Inflate_state)(unsafe.Pointer(state)).Fhead != uintptr(Z_NULL)) {
 13602  		goto __100
 13603  	}
 13604  	(*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Ftime = hold
 13605  __100:
 13606  	;
 13607  	if !((*Inflate_state)(unsafe.Pointer(state)).Fflags&0x0200 != 0 && (*Inflate_state)(unsafe.Pointer(state)).Fwrap&4 != 0) {
 13608  		goto __101
 13609  	}
 13610  __102:
 13611  	*(*uint8)(unsafe.Pointer(bp)) = uint8(hold)
 13612  	*(*uint8)(unsafe.Pointer(bp + 1)) = uint8(hold >> 8)
 13613  	*(*uint8)(unsafe.Pointer(bp + 2)) = uint8(hold >> 16)
 13614  	*(*uint8)(unsafe.Pointer(bp + 3)) = uint8(hold >> 24)
 13615  	(*Inflate_state)(unsafe.Pointer(state)).Fcheck = Xcrc32(tls, (*Inflate_state)(unsafe.Pointer(state)).Fcheck, bp, uint32(4))
 13616  	goto __103
 13617  __103:
 13618  	if 0 != 0 {
 13619  		goto __102
 13620  	}
 13621  	goto __104
 13622  __104:
 13623  	;
 13624  __101:
 13625  	;
 13626  __105:
 13627  	hold = uint64(0)
 13628  	bits = uint32(0)
 13629  	goto __106
 13630  __106:
 13631  	if 0 != 0 {
 13632  		goto __105
 13633  	}
 13634  	goto __107
 13635  __107:
 13636  	;
 13637  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = OS
 13638  __13:
 13639  __108:
 13640  __111:
 13641  	if !(bits < uint32(16)) {
 13642  		goto __112
 13643  	}
 13644  __113:
 13645  	if !(have == uint32(0)) {
 13646  		goto __116
 13647  	}
 13648  	goto inf_leave
 13649  __116:
 13650  	;
 13651  	have--
 13652  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))<<bits
 13653  	bits = bits + uint32(8)
 13654  	goto __114
 13655  __114:
 13656  	if 0 != 0 {
 13657  		goto __113
 13658  	}
 13659  	goto __115
 13660  __115:
 13661  	;
 13662  	goto __111
 13663  __112:
 13664  	;
 13665  	goto __109
 13666  __109:
 13667  	if 0 != 0 {
 13668  		goto __108
 13669  	}
 13670  	goto __110
 13671  __110:
 13672  	;
 13673  	if !((*Inflate_state)(unsafe.Pointer(state)).Fhead != uintptr(Z_NULL)) {
 13674  		goto __117
 13675  	}
 13676  	(*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fxflags = int32(hold & uint64(0xff))
 13677  	(*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fos = int32(hold >> 8)
 13678  __117:
 13679  	;
 13680  	if !((*Inflate_state)(unsafe.Pointer(state)).Fflags&0x0200 != 0 && (*Inflate_state)(unsafe.Pointer(state)).Fwrap&4 != 0) {
 13681  		goto __118
 13682  	}
 13683  __119:
 13684  	*(*uint8)(unsafe.Pointer(bp)) = uint8(hold)
 13685  	*(*uint8)(unsafe.Pointer(bp + 1)) = uint8(hold >> 8)
 13686  	(*Inflate_state)(unsafe.Pointer(state)).Fcheck = Xcrc32(tls, (*Inflate_state)(unsafe.Pointer(state)).Fcheck, bp, uint32(2))
 13687  	goto __120
 13688  __120:
 13689  	if 0 != 0 {
 13690  		goto __119
 13691  	}
 13692  	goto __121
 13693  __121:
 13694  	;
 13695  __118:
 13696  	;
 13697  __122:
 13698  	hold = uint64(0)
 13699  	bits = uint32(0)
 13700  	goto __123
 13701  __123:
 13702  	if 0 != 0 {
 13703  		goto __122
 13704  	}
 13705  	goto __124
 13706  __124:
 13707  	;
 13708  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = EXLEN
 13709  __14:
 13710  	if !((*Inflate_state)(unsafe.Pointer(state)).Fflags&0x0400 != 0) {
 13711  		goto __125
 13712  	}
 13713  __127:
 13714  __130:
 13715  	if !(bits < uint32(16)) {
 13716  		goto __131
 13717  	}
 13718  __132:
 13719  	if !(have == uint32(0)) {
 13720  		goto __135
 13721  	}
 13722  	goto inf_leave
 13723  __135:
 13724  	;
 13725  	have--
 13726  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))<<bits
 13727  	bits = bits + uint32(8)
 13728  	goto __133
 13729  __133:
 13730  	if 0 != 0 {
 13731  		goto __132
 13732  	}
 13733  	goto __134
 13734  __134:
 13735  	;
 13736  	goto __130
 13737  __131:
 13738  	;
 13739  	goto __128
 13740  __128:
 13741  	if 0 != 0 {
 13742  		goto __127
 13743  	}
 13744  	goto __129
 13745  __129:
 13746  	;
 13747  	(*Inflate_state)(unsafe.Pointer(state)).Flength = uint32(hold)
 13748  	if !((*Inflate_state)(unsafe.Pointer(state)).Fhead != uintptr(Z_NULL)) {
 13749  		goto __136
 13750  	}
 13751  	(*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fextra_len = uint32(hold)
 13752  __136:
 13753  	;
 13754  	if !((*Inflate_state)(unsafe.Pointer(state)).Fflags&0x0200 != 0 && (*Inflate_state)(unsafe.Pointer(state)).Fwrap&4 != 0) {
 13755  		goto __137
 13756  	}
 13757  __138:
 13758  	*(*uint8)(unsafe.Pointer(bp)) = uint8(hold)
 13759  	*(*uint8)(unsafe.Pointer(bp + 1)) = uint8(hold >> 8)
 13760  	(*Inflate_state)(unsafe.Pointer(state)).Fcheck = Xcrc32(tls, (*Inflate_state)(unsafe.Pointer(state)).Fcheck, bp, uint32(2))
 13761  	goto __139
 13762  __139:
 13763  	if 0 != 0 {
 13764  		goto __138
 13765  	}
 13766  	goto __140
 13767  __140:
 13768  	;
 13769  __137:
 13770  	;
 13771  __141:
 13772  	hold = uint64(0)
 13773  	bits = uint32(0)
 13774  	goto __142
 13775  __142:
 13776  	if 0 != 0 {
 13777  		goto __141
 13778  	}
 13779  	goto __143
 13780  __143:
 13781  	;
 13782  	goto __126
 13783  __125:
 13784  	if !((*Inflate_state)(unsafe.Pointer(state)).Fhead != uintptr(Z_NULL)) {
 13785  		goto __144
 13786  	}
 13787  	(*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fextra = uintptr(Z_NULL)
 13788  __144:
 13789  	;
 13790  __126:
 13791  	;
 13792  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = EXTRA
 13793  __15:
 13794  	if !((*Inflate_state)(unsafe.Pointer(state)).Fflags&0x0400 != 0) {
 13795  		goto __145
 13796  	}
 13797  	copy = (*Inflate_state)(unsafe.Pointer(state)).Flength
 13798  	if !(copy > have) {
 13799  		goto __146
 13800  	}
 13801  	copy = have
 13802  __146:
 13803  	;
 13804  	if !(copy != 0) {
 13805  		goto __147
 13806  	}
 13807  	if !((*Inflate_state)(unsafe.Pointer(state)).Fhead != uintptr(Z_NULL) && (*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fextra != uintptr(Z_NULL)) {
 13808  		goto __148
 13809  	}
 13810  	len = (*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fextra_len - (*Inflate_state)(unsafe.Pointer(state)).Flength
 13811  	libc.Xmemcpy(tls, (*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fextra+uintptr(len), next,
 13812  		func() uint64 {
 13813  			if len+copy > (*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fextra_max {
 13814  				return uint64((*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fextra_max - len)
 13815  			}
 13816  			return uint64(copy)
 13817  		}())
 13818  __148:
 13819  	;
 13820  	if !((*Inflate_state)(unsafe.Pointer(state)).Fflags&0x0200 != 0 && (*Inflate_state)(unsafe.Pointer(state)).Fwrap&4 != 0) {
 13821  		goto __149
 13822  	}
 13823  	(*Inflate_state)(unsafe.Pointer(state)).Fcheck = Xcrc32(tls, (*Inflate_state)(unsafe.Pointer(state)).Fcheck, next, copy)
 13824  __149:
 13825  	;
 13826  	have = have - copy
 13827  	next += uintptr(copy)
 13828  	*(*uint32)(unsafe.Pointer(state + 92)) -= copy
 13829  __147:
 13830  	;
 13831  	if !((*Inflate_state)(unsafe.Pointer(state)).Flength != 0) {
 13832  		goto __150
 13833  	}
 13834  	goto inf_leave
 13835  __150:
 13836  	;
 13837  __145:
 13838  	;
 13839  	(*Inflate_state)(unsafe.Pointer(state)).Flength = uint32(0)
 13840  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = NAME
 13841  __16:
 13842  	if !((*Inflate_state)(unsafe.Pointer(state)).Fflags&0x0800 != 0) {
 13843  		goto __151
 13844  	}
 13845  	if !(have == uint32(0)) {
 13846  		goto __153
 13847  	}
 13848  	goto inf_leave
 13849  __153:
 13850  	;
 13851  	copy = uint32(0)
 13852  __154:
 13853  	len = uint32(*(*uint8)(unsafe.Pointer(next + uintptr(libc.PostIncUint32(&copy, 1)))))
 13854  	if !((*Inflate_state)(unsafe.Pointer(state)).Fhead != uintptr(Z_NULL) && (*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fname != uintptr(Z_NULL) && (*Inflate_state)(unsafe.Pointer(state)).Flength < (*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fname_max) {
 13855  		goto __157
 13856  	}
 13857  	*(*Bytef)(unsafe.Pointer((*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fname + uintptr(libc.PostIncUint32(&(*Inflate_state)(unsafe.Pointer(state)).Flength, 1)))) = Bytef(len)
 13858  __157:
 13859  	;
 13860  	goto __155
 13861  __155:
 13862  	if len != 0 && copy < have {
 13863  		goto __154
 13864  	}
 13865  	goto __156
 13866  __156:
 13867  	;
 13868  	if !((*Inflate_state)(unsafe.Pointer(state)).Fflags&0x0200 != 0 && (*Inflate_state)(unsafe.Pointer(state)).Fwrap&4 != 0) {
 13869  		goto __158
 13870  	}
 13871  	(*Inflate_state)(unsafe.Pointer(state)).Fcheck = Xcrc32(tls, (*Inflate_state)(unsafe.Pointer(state)).Fcheck, next, copy)
 13872  __158:
 13873  	;
 13874  	have = have - copy
 13875  	next += uintptr(copy)
 13876  	if !(len != 0) {
 13877  		goto __159
 13878  	}
 13879  	goto inf_leave
 13880  __159:
 13881  	;
 13882  	goto __152
 13883  __151:
 13884  	if !((*Inflate_state)(unsafe.Pointer(state)).Fhead != uintptr(Z_NULL)) {
 13885  		goto __160
 13886  	}
 13887  	(*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fname = uintptr(Z_NULL)
 13888  __160:
 13889  	;
 13890  __152:
 13891  	;
 13892  	(*Inflate_state)(unsafe.Pointer(state)).Flength = uint32(0)
 13893  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = COMMENT
 13894  __17:
 13895  	if !((*Inflate_state)(unsafe.Pointer(state)).Fflags&0x1000 != 0) {
 13896  		goto __161
 13897  	}
 13898  	if !(have == uint32(0)) {
 13899  		goto __163
 13900  	}
 13901  	goto inf_leave
 13902  __163:
 13903  	;
 13904  	copy = uint32(0)
 13905  __164:
 13906  	len = uint32(*(*uint8)(unsafe.Pointer(next + uintptr(libc.PostIncUint32(&copy, 1)))))
 13907  	if !((*Inflate_state)(unsafe.Pointer(state)).Fhead != uintptr(Z_NULL) && (*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fcomment != uintptr(Z_NULL) && (*Inflate_state)(unsafe.Pointer(state)).Flength < (*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fcomm_max) {
 13908  		goto __167
 13909  	}
 13910  	*(*Bytef)(unsafe.Pointer((*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fcomment + uintptr(libc.PostIncUint32(&(*Inflate_state)(unsafe.Pointer(state)).Flength, 1)))) = Bytef(len)
 13911  __167:
 13912  	;
 13913  	goto __165
 13914  __165:
 13915  	if len != 0 && copy < have {
 13916  		goto __164
 13917  	}
 13918  	goto __166
 13919  __166:
 13920  	;
 13921  	if !((*Inflate_state)(unsafe.Pointer(state)).Fflags&0x0200 != 0 && (*Inflate_state)(unsafe.Pointer(state)).Fwrap&4 != 0) {
 13922  		goto __168
 13923  	}
 13924  	(*Inflate_state)(unsafe.Pointer(state)).Fcheck = Xcrc32(tls, (*Inflate_state)(unsafe.Pointer(state)).Fcheck, next, copy)
 13925  __168:
 13926  	;
 13927  	have = have - copy
 13928  	next += uintptr(copy)
 13929  	if !(len != 0) {
 13930  		goto __169
 13931  	}
 13932  	goto inf_leave
 13933  __169:
 13934  	;
 13935  	goto __162
 13936  __161:
 13937  	if !((*Inflate_state)(unsafe.Pointer(state)).Fhead != uintptr(Z_NULL)) {
 13938  		goto __170
 13939  	}
 13940  	(*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fcomment = uintptr(Z_NULL)
 13941  __170:
 13942  	;
 13943  __162:
 13944  	;
 13945  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = HCRC
 13946  __18:
 13947  	if !((*Inflate_state)(unsafe.Pointer(state)).Fflags&0x0200 != 0) {
 13948  		goto __171
 13949  	}
 13950  __172:
 13951  __175:
 13952  	if !(bits < uint32(16)) {
 13953  		goto __176
 13954  	}
 13955  __177:
 13956  	if !(have == uint32(0)) {
 13957  		goto __180
 13958  	}
 13959  	goto inf_leave
 13960  __180:
 13961  	;
 13962  	have--
 13963  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))<<bits
 13964  	bits = bits + uint32(8)
 13965  	goto __178
 13966  __178:
 13967  	if 0 != 0 {
 13968  		goto __177
 13969  	}
 13970  	goto __179
 13971  __179:
 13972  	;
 13973  	goto __175
 13974  __176:
 13975  	;
 13976  	goto __173
 13977  __173:
 13978  	if 0 != 0 {
 13979  		goto __172
 13980  	}
 13981  	goto __174
 13982  __174:
 13983  	;
 13984  	if !((*Inflate_state)(unsafe.Pointer(state)).Fwrap&4 != 0 && hold != (*Inflate_state)(unsafe.Pointer(state)).Fcheck&uint64(0xffff)) {
 13985  		goto __181
 13986  	}
 13987  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 764 /* "header crc misma..." */
 13988  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 13989  	goto __9
 13990  __181:
 13991  	;
 13992  __182:
 13993  	hold = uint64(0)
 13994  	bits = uint32(0)
 13995  	goto __183
 13996  __183:
 13997  	if 0 != 0 {
 13998  		goto __182
 13999  	}
 14000  	goto __184
 14001  __184:
 14002  	;
 14003  __171:
 14004  	;
 14005  	if !((*Inflate_state)(unsafe.Pointer(state)).Fhead != uintptr(Z_NULL)) {
 14006  		goto __185
 14007  	}
 14008  	(*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fhcrc = (*Inflate_state)(unsafe.Pointer(state)).Fflags >> 9 & 1
 14009  	(*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fdone = 1
 14010  __185:
 14011  	;
 14012  	(*Z_stream)(unsafe.Pointer(strm)).Fadler = libc.AssignPtrUint64(state+32, Xcrc32(tls, uint64(0), uintptr(Z_NULL), uint32(0)))
 14013  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = TYPE
 14014  	goto __9
 14015  __19:
 14016  __186:
 14017  __189:
 14018  	if !(bits < uint32(32)) {
 14019  		goto __190
 14020  	}
 14021  __191:
 14022  	if !(have == uint32(0)) {
 14023  		goto __194
 14024  	}
 14025  	goto inf_leave
 14026  __194:
 14027  	;
 14028  	have--
 14029  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))<<bits
 14030  	bits = bits + uint32(8)
 14031  	goto __192
 14032  __192:
 14033  	if 0 != 0 {
 14034  		goto __191
 14035  	}
 14036  	goto __193
 14037  __193:
 14038  	;
 14039  	goto __189
 14040  __190:
 14041  	;
 14042  	goto __187
 14043  __187:
 14044  	if 0 != 0 {
 14045  		goto __186
 14046  	}
 14047  	goto __188
 14048  __188:
 14049  	;
 14050  	(*Z_stream)(unsafe.Pointer(strm)).Fadler = libc.AssignPtrUint64(state+32, hold>>24&uint64(0xff)+hold>>8&uint64(0xff00)+hold&uint64(0xff00)<<8+hold&uint64(0xff)<<24)
 14051  __195:
 14052  	hold = uint64(0)
 14053  	bits = uint32(0)
 14054  	goto __196
 14055  __196:
 14056  	if 0 != 0 {
 14057  		goto __195
 14058  	}
 14059  	goto __197
 14060  __197:
 14061  	;
 14062  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = DICT
 14063  __20:
 14064  	if !((*Inflate_state)(unsafe.Pointer(state)).Fhavedict == 0) {
 14065  		goto __198
 14066  	}
 14067  __199:
 14068  	(*Z_stream)(unsafe.Pointer(strm)).Fnext_out = put
 14069  	(*Z_stream)(unsafe.Pointer(strm)).Favail_out = left
 14070  	(*Z_stream)(unsafe.Pointer(strm)).Fnext_in = next
 14071  	(*Z_stream)(unsafe.Pointer(strm)).Favail_in = have
 14072  	(*Inflate_state)(unsafe.Pointer(state)).Fhold = hold
 14073  	(*Inflate_state)(unsafe.Pointer(state)).Fbits = bits
 14074  	goto __200
 14075  __200:
 14076  	if 0 != 0 {
 14077  		goto __199
 14078  	}
 14079  	goto __201
 14080  __201:
 14081  	;
 14082  	return Z_NEED_DICT
 14083  __198:
 14084  	;
 14085  	(*Z_stream)(unsafe.Pointer(strm)).Fadler = libc.AssignPtrUint64(state+32, Xadler32(tls, uint64(0), uintptr(Z_NULL), uint32(0)))
 14086  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = TYPE
 14087  __21:
 14088  	if !(flush == Z_BLOCK || flush == Z_TREES) {
 14089  		goto __202
 14090  	}
 14091  	goto inf_leave
 14092  __202:
 14093  	;
 14094  __22:
 14095  	if !((*Inflate_state)(unsafe.Pointer(state)).Flast != 0) {
 14096  		goto __203
 14097  	}
 14098  __204:
 14099  	hold >>= bits & uint32(7)
 14100  	bits = bits - bits&uint32(7)
 14101  	goto __205
 14102  __205:
 14103  	if 0 != 0 {
 14104  		goto __204
 14105  	}
 14106  	goto __206
 14107  __206:
 14108  	;
 14109  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = CHECK
 14110  	goto __9
 14111  __203:
 14112  	;
 14113  __207:
 14114  __210:
 14115  	if !(bits < uint32(3)) {
 14116  		goto __211
 14117  	}
 14118  __212:
 14119  	if !(have == uint32(0)) {
 14120  		goto __215
 14121  	}
 14122  	goto inf_leave
 14123  __215:
 14124  	;
 14125  	have--
 14126  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))<<bits
 14127  	bits = bits + uint32(8)
 14128  	goto __213
 14129  __213:
 14130  	if 0 != 0 {
 14131  		goto __212
 14132  	}
 14133  	goto __214
 14134  __214:
 14135  	;
 14136  	goto __210
 14137  __211:
 14138  	;
 14139  	goto __208
 14140  __208:
 14141  	if 0 != 0 {
 14142  		goto __207
 14143  	}
 14144  	goto __209
 14145  __209:
 14146  	;
 14147  	(*Inflate_state)(unsafe.Pointer(state)).Flast = int32(uint32(hold) & (uint32(1)<<1 - uint32(1)))
 14148  __216:
 14149  	hold >>= 1
 14150  	bits = bits - uint32(1)
 14151  	goto __217
 14152  __217:
 14153  	if 0 != 0 {
 14154  		goto __216
 14155  	}
 14156  	goto __218
 14157  __218:
 14158  	;
 14159  	switch uint32(hold) & (uint32(1)<<2 - uint32(1)) {
 14160  	case uint32(0):
 14161  		goto __220
 14162  	case uint32(1):
 14163  		goto __221
 14164  	case uint32(2):
 14165  		goto __222
 14166  	case uint32(3):
 14167  		goto __223
 14168  	}
 14169  	goto __219
 14170  __220: // stored block
 14171  	;
 14172  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = STORED
 14173  	goto __219
 14174  __221: // fixed block
 14175  	fixedtables1(tls, state)
 14176  
 14177  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = LEN_ // decode codes
 14178  	if !(flush == Z_TREES) {
 14179  		goto __224
 14180  	}
 14181  __225:
 14182  	hold >>= 2
 14183  	bits = bits - uint32(2)
 14184  	goto __226
 14185  __226:
 14186  	if 0 != 0 {
 14187  		goto __225
 14188  	}
 14189  	goto __227
 14190  __227:
 14191  	;
 14192  	goto inf_leave
 14193  __224:
 14194  	;
 14195  	goto __219
 14196  __222: // dynamic block
 14197  	;
 14198  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = TABLE
 14199  	goto __219
 14200  __223:
 14201  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 367 /* "invalid block ty..." */
 14202  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 14203  __219:
 14204  	;
 14205  __228:
 14206  	hold >>= 2
 14207  	bits = bits - uint32(2)
 14208  	goto __229
 14209  __229:
 14210  	if 0 != 0 {
 14211  		goto __228
 14212  	}
 14213  	goto __230
 14214  __230:
 14215  	;
 14216  	goto __9
 14217  __23:
 14218  __231:
 14219  	hold >>= bits & uint32(7)
 14220  	bits = bits - bits&uint32(7)
 14221  	goto __232
 14222  __232:
 14223  	if 0 != 0 {
 14224  		goto __231
 14225  	}
 14226  	goto __233
 14227  __233:
 14228  	; // go to byte boundary
 14229  __234:
 14230  __237:
 14231  	if !(bits < uint32(32)) {
 14232  		goto __238
 14233  	}
 14234  __239:
 14235  	if !(have == uint32(0)) {
 14236  		goto __242
 14237  	}
 14238  	goto inf_leave
 14239  __242:
 14240  	;
 14241  	have--
 14242  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))<<bits
 14243  	bits = bits + uint32(8)
 14244  	goto __240
 14245  __240:
 14246  	if 0 != 0 {
 14247  		goto __239
 14248  	}
 14249  	goto __241
 14250  __241:
 14251  	;
 14252  	goto __237
 14253  __238:
 14254  	;
 14255  	goto __235
 14256  __235:
 14257  	if 0 != 0 {
 14258  		goto __234
 14259  	}
 14260  	goto __236
 14261  __236:
 14262  	;
 14263  	if !(hold&uint64(0xffff) != hold>>16^uint64(0xffff)) {
 14264  		goto __243
 14265  	}
 14266  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 386 /* "invalid stored b..." */
 14267  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 14268  	goto __9
 14269  __243:
 14270  	;
 14271  	(*Inflate_state)(unsafe.Pointer(state)).Flength = uint32(hold) & uint32(0xffff)
 14272  
 14273  __244:
 14274  	hold = uint64(0)
 14275  	bits = uint32(0)
 14276  	goto __245
 14277  __245:
 14278  	if 0 != 0 {
 14279  		goto __244
 14280  	}
 14281  	goto __246
 14282  __246:
 14283  	;
 14284  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = COPY_
 14285  	if !(flush == Z_TREES) {
 14286  		goto __247
 14287  	}
 14288  	goto inf_leave
 14289  __247:
 14290  	;
 14291  __24:
 14292  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = COPY
 14293  __25:
 14294  	copy = (*Inflate_state)(unsafe.Pointer(state)).Flength
 14295  	if !(copy != 0) {
 14296  		goto __248
 14297  	}
 14298  	if !(copy > have) {
 14299  		goto __249
 14300  	}
 14301  	copy = have
 14302  __249:
 14303  	;
 14304  	if !(copy > left) {
 14305  		goto __250
 14306  	}
 14307  	copy = left
 14308  __250:
 14309  	;
 14310  	if !(copy == uint32(0)) {
 14311  		goto __251
 14312  	}
 14313  	goto inf_leave
 14314  __251:
 14315  	;
 14316  	libc.Xmemcpy(tls, put, next, uint64(copy))
 14317  	have = have - copy
 14318  	next += uintptr(copy)
 14319  	left = left - copy
 14320  	put += uintptr(copy)
 14321  	*(*uint32)(unsafe.Pointer(state + 92)) -= copy
 14322  	goto __9
 14323  __248:
 14324  	;
 14325  
 14326  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = TYPE
 14327  	goto __9
 14328  __26:
 14329  __252:
 14330  __255:
 14331  	if !(bits < uint32(14)) {
 14332  		goto __256
 14333  	}
 14334  __257:
 14335  	if !(have == uint32(0)) {
 14336  		goto __260
 14337  	}
 14338  	goto inf_leave
 14339  __260:
 14340  	;
 14341  	have--
 14342  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))<<bits
 14343  	bits = bits + uint32(8)
 14344  	goto __258
 14345  __258:
 14346  	if 0 != 0 {
 14347  		goto __257
 14348  	}
 14349  	goto __259
 14350  __259:
 14351  	;
 14352  	goto __255
 14353  __256:
 14354  	;
 14355  	goto __253
 14356  __253:
 14357  	if 0 != 0 {
 14358  		goto __252
 14359  	}
 14360  	goto __254
 14361  __254:
 14362  	;
 14363  	(*Inflate_state)(unsafe.Pointer(state)).Fnlen = uint32(hold)&(uint32(1)<<5-uint32(1)) + uint32(257)
 14364  __261:
 14365  	hold >>= 5
 14366  	bits = bits - uint32(5)
 14367  	goto __262
 14368  __262:
 14369  	if 0 != 0 {
 14370  		goto __261
 14371  	}
 14372  	goto __263
 14373  __263:
 14374  	;
 14375  	(*Inflate_state)(unsafe.Pointer(state)).Fndist = uint32(hold)&(uint32(1)<<5-uint32(1)) + uint32(1)
 14376  __264:
 14377  	hold >>= 5
 14378  	bits = bits - uint32(5)
 14379  	goto __265
 14380  __265:
 14381  	if 0 != 0 {
 14382  		goto __264
 14383  	}
 14384  	goto __266
 14385  __266:
 14386  	;
 14387  	(*Inflate_state)(unsafe.Pointer(state)).Fncode = uint32(hold)&(uint32(1)<<4-uint32(1)) + uint32(4)
 14388  __267:
 14389  	hold >>= 4
 14390  	bits = bits - uint32(4)
 14391  	goto __268
 14392  __268:
 14393  	if 0 != 0 {
 14394  		goto __267
 14395  	}
 14396  	goto __269
 14397  __269:
 14398  	;
 14399  	if !((*Inflate_state)(unsafe.Pointer(state)).Fnlen > uint32(286) || (*Inflate_state)(unsafe.Pointer(state)).Fndist > uint32(30)) {
 14400  		goto __270
 14401  	}
 14402  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 415 /* "too many length ..." */
 14403  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 14404  	goto __9
 14405  __270:
 14406  	;
 14407  
 14408  	(*Inflate_state)(unsafe.Pointer(state)).Fhave = uint32(0)
 14409  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = LENLENS
 14410  __27:
 14411  __271:
 14412  	if !((*Inflate_state)(unsafe.Pointer(state)).Fhave < (*Inflate_state)(unsafe.Pointer(state)).Fncode) {
 14413  		goto __272
 14414  	}
 14415  __273:
 14416  __276:
 14417  	if !(bits < uint32(3)) {
 14418  		goto __277
 14419  	}
 14420  __278:
 14421  	if !(have == uint32(0)) {
 14422  		goto __281
 14423  	}
 14424  	goto inf_leave
 14425  __281:
 14426  	;
 14427  	have--
 14428  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))<<bits
 14429  	bits = bits + uint32(8)
 14430  	goto __279
 14431  __279:
 14432  	if 0 != 0 {
 14433  		goto __278
 14434  	}
 14435  	goto __280
 14436  __280:
 14437  	;
 14438  	goto __276
 14439  __277:
 14440  	;
 14441  	goto __274
 14442  __274:
 14443  	if 0 != 0 {
 14444  		goto __273
 14445  	}
 14446  	goto __275
 14447  __275:
 14448  	;
 14449  	*(*uint16)(unsafe.Pointer(state + 152 + uintptr(order1[libc.PostIncUint32(&(*Inflate_state)(unsafe.Pointer(state)).Fhave, 1)])*2)) = uint16(uint32(hold) & (uint32(1)<<3 - uint32(1)))
 14450  __282:
 14451  	hold >>= 3
 14452  	bits = bits - uint32(3)
 14453  	goto __283
 14454  __283:
 14455  	if 0 != 0 {
 14456  		goto __282
 14457  	}
 14458  	goto __284
 14459  __284:
 14460  	;
 14461  	goto __271
 14462  __272:
 14463  	;
 14464  __285:
 14465  	if !((*Inflate_state)(unsafe.Pointer(state)).Fhave < uint32(19)) {
 14466  		goto __286
 14467  	}
 14468  	*(*uint16)(unsafe.Pointer(state + 152 + uintptr(order1[libc.PostIncUint32(&(*Inflate_state)(unsafe.Pointer(state)).Fhave, 1)])*2)) = uint16(0)
 14469  	goto __285
 14470  __286:
 14471  	;
 14472  	(*Inflate_state)(unsafe.Pointer(state)).Fnext = state + 1368 /* &.codes */
 14473  	(*Inflate_state)(unsafe.Pointer(state)).Flencode = (*Inflate_state)(unsafe.Pointer(state)).Fnext
 14474  	(*Inflate_state)(unsafe.Pointer(state)).Flenbits = uint32(7)
 14475  	ret = Xinflate_table(tls, CODES, state+152, uint32(19), state+144,
 14476  		state+120, state+792)
 14477  	if !(ret != 0) {
 14478  		goto __287
 14479  	}
 14480  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 451 /* "invalid code len..." */
 14481  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 14482  	goto __9
 14483  __287:
 14484  	;
 14485  
 14486  	(*Inflate_state)(unsafe.Pointer(state)).Fhave = uint32(0)
 14487  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = CODELENS
 14488  __28:
 14489  __288:
 14490  	if !((*Inflate_state)(unsafe.Pointer(state)).Fhave < (*Inflate_state)(unsafe.Pointer(state)).Fnlen+(*Inflate_state)(unsafe.Pointer(state)).Fndist) {
 14491  		goto __289
 14492  	}
 14493  __290:
 14494  	here = *(*Code)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Flencode + uintptr(uint32(hold)&(uint32(1)<<(*Inflate_state)(unsafe.Pointer(state)).Flenbits-uint32(1)))*4))
 14495  	if !(uint32(here.Fbits) <= bits) {
 14496  		goto __293
 14497  	}
 14498  	goto __292
 14499  __293:
 14500  	;
 14501  __294:
 14502  	if !(have == uint32(0)) {
 14503  		goto __297
 14504  	}
 14505  	goto inf_leave
 14506  __297:
 14507  	;
 14508  	have--
 14509  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))<<bits
 14510  	bits = bits + uint32(8)
 14511  	goto __295
 14512  __295:
 14513  	if 0 != 0 {
 14514  		goto __294
 14515  	}
 14516  	goto __296
 14517  __296:
 14518  	;
 14519  	goto __291
 14520  __291:
 14521  	goto __290
 14522  	goto __292
 14523  __292:
 14524  	;
 14525  	if !(int32(here.Fval) < 16) {
 14526  		goto __298
 14527  	}
 14528  __300:
 14529  	hold >>= int32(here.Fbits)
 14530  	bits = bits - uint32(here.Fbits)
 14531  	goto __301
 14532  __301:
 14533  	if 0 != 0 {
 14534  		goto __300
 14535  	}
 14536  	goto __302
 14537  __302:
 14538  	;
 14539  	*(*uint16)(unsafe.Pointer(state + 152 + uintptr(libc.PostIncUint32(&(*Inflate_state)(unsafe.Pointer(state)).Fhave, 1))*2)) = here.Fval
 14540  	goto __299
 14541  __298:
 14542  	if !(int32(here.Fval) == 16) {
 14543  		goto __303
 14544  	}
 14545  __305:
 14546  __308:
 14547  	if !(bits < uint32(int32(here.Fbits)+2)) {
 14548  		goto __309
 14549  	}
 14550  __310:
 14551  	if !(have == uint32(0)) {
 14552  		goto __313
 14553  	}
 14554  	goto inf_leave
 14555  __313:
 14556  	;
 14557  	have--
 14558  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))<<bits
 14559  	bits = bits + uint32(8)
 14560  	goto __311
 14561  __311:
 14562  	if 0 != 0 {
 14563  		goto __310
 14564  	}
 14565  	goto __312
 14566  __312:
 14567  	;
 14568  	goto __308
 14569  __309:
 14570  	;
 14571  	goto __306
 14572  __306:
 14573  	if 0 != 0 {
 14574  		goto __305
 14575  	}
 14576  	goto __307
 14577  __307:
 14578  	;
 14579  __314:
 14580  	hold >>= int32(here.Fbits)
 14581  	bits = bits - uint32(here.Fbits)
 14582  	goto __315
 14583  __315:
 14584  	if 0 != 0 {
 14585  		goto __314
 14586  	}
 14587  	goto __316
 14588  __316:
 14589  	;
 14590  	if !((*Inflate_state)(unsafe.Pointer(state)).Fhave == uint32(0)) {
 14591  		goto __317
 14592  	}
 14593  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 476 /* "invalid bit leng..." */
 14594  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 14595  	goto __289
 14596  __317:
 14597  	;
 14598  	len = uint32(*(*uint16)(unsafe.Pointer(state + 152 + uintptr((*Inflate_state)(unsafe.Pointer(state)).Fhave-uint32(1))*2)))
 14599  	copy = uint32(3) + uint32(hold)&(uint32(1)<<2-uint32(1))
 14600  __318:
 14601  	hold >>= 2
 14602  	bits = bits - uint32(2)
 14603  	goto __319
 14604  __319:
 14605  	if 0 != 0 {
 14606  		goto __318
 14607  	}
 14608  	goto __320
 14609  __320:
 14610  	;
 14611  	goto __304
 14612  __303:
 14613  	if !(int32(here.Fval) == 17) {
 14614  		goto __321
 14615  	}
 14616  __323:
 14617  __326:
 14618  	if !(bits < uint32(int32(here.Fbits)+3)) {
 14619  		goto __327
 14620  	}
 14621  __328:
 14622  	if !(have == uint32(0)) {
 14623  		goto __331
 14624  	}
 14625  	goto inf_leave
 14626  __331:
 14627  	;
 14628  	have--
 14629  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))<<bits
 14630  	bits = bits + uint32(8)
 14631  	goto __329
 14632  __329:
 14633  	if 0 != 0 {
 14634  		goto __328
 14635  	}
 14636  	goto __330
 14637  __330:
 14638  	;
 14639  	goto __326
 14640  __327:
 14641  	;
 14642  	goto __324
 14643  __324:
 14644  	if 0 != 0 {
 14645  		goto __323
 14646  	}
 14647  	goto __325
 14648  __325:
 14649  	;
 14650  __332:
 14651  	hold >>= int32(here.Fbits)
 14652  	bits = bits - uint32(here.Fbits)
 14653  	goto __333
 14654  __333:
 14655  	if 0 != 0 {
 14656  		goto __332
 14657  	}
 14658  	goto __334
 14659  __334:
 14660  	;
 14661  	len = uint32(0)
 14662  	copy = uint32(3) + uint32(hold)&(uint32(1)<<3-uint32(1))
 14663  __335:
 14664  	hold >>= 3
 14665  	bits = bits - uint32(3)
 14666  	goto __336
 14667  __336:
 14668  	if 0 != 0 {
 14669  		goto __335
 14670  	}
 14671  	goto __337
 14672  __337:
 14673  	;
 14674  	goto __322
 14675  __321:
 14676  __338:
 14677  __341:
 14678  	if !(bits < uint32(int32(here.Fbits)+7)) {
 14679  		goto __342
 14680  	}
 14681  __343:
 14682  	if !(have == uint32(0)) {
 14683  		goto __346
 14684  	}
 14685  	goto inf_leave
 14686  __346:
 14687  	;
 14688  	have--
 14689  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))<<bits
 14690  	bits = bits + uint32(8)
 14691  	goto __344
 14692  __344:
 14693  	if 0 != 0 {
 14694  		goto __343
 14695  	}
 14696  	goto __345
 14697  __345:
 14698  	;
 14699  	goto __341
 14700  __342:
 14701  	;
 14702  	goto __339
 14703  __339:
 14704  	if 0 != 0 {
 14705  		goto __338
 14706  	}
 14707  	goto __340
 14708  __340:
 14709  	;
 14710  __347:
 14711  	hold >>= int32(here.Fbits)
 14712  	bits = bits - uint32(here.Fbits)
 14713  	goto __348
 14714  __348:
 14715  	if 0 != 0 {
 14716  		goto __347
 14717  	}
 14718  	goto __349
 14719  __349:
 14720  	;
 14721  	len = uint32(0)
 14722  	copy = uint32(11) + uint32(hold)&(uint32(1)<<7-uint32(1))
 14723  __350:
 14724  	hold >>= 7
 14725  	bits = bits - uint32(7)
 14726  	goto __351
 14727  __351:
 14728  	if 0 != 0 {
 14729  		goto __350
 14730  	}
 14731  	goto __352
 14732  __352:
 14733  	;
 14734  __322:
 14735  	;
 14736  __304:
 14737  	;
 14738  	if !((*Inflate_state)(unsafe.Pointer(state)).Fhave+copy > (*Inflate_state)(unsafe.Pointer(state)).Fnlen+(*Inflate_state)(unsafe.Pointer(state)).Fndist) {
 14739  		goto __353
 14740  	}
 14741  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 476 /* "invalid bit leng..." */
 14742  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 14743  	goto __289
 14744  __353:
 14745  	;
 14746  __354:
 14747  	if !(libc.PostDecUint32(&copy, 1) != 0) {
 14748  		goto __355
 14749  	}
 14750  	*(*uint16)(unsafe.Pointer(state + 152 + uintptr(libc.PostIncUint32(&(*Inflate_state)(unsafe.Pointer(state)).Fhave, 1))*2)) = uint16(len)
 14751  	goto __354
 14752  __355:
 14753  	;
 14754  __299:
 14755  	;
 14756  	goto __288
 14757  __289:
 14758  	;
 14759  
 14760  	// handle error breaks in while
 14761  	if !((*Inflate_state)(unsafe.Pointer(state)).Fmode == BAD) {
 14762  		goto __356
 14763  	}
 14764  	goto __9
 14765  __356:
 14766  	;
 14767  
 14768  	// check for end-of-block code (better have one)
 14769  	if !(int32(*(*uint16)(unsafe.Pointer(state + 152 + 256*2))) == 0) {
 14770  		goto __357
 14771  	}
 14772  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 502 /* "invalid code -- ..." */
 14773  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 14774  	goto __9
 14775  __357:
 14776  	;
 14777  
 14778  	// build code tables -- note: do not change the lenbits or distbits
 14779  	//                values here (9 and 6) without reading the comments in inftrees.h
 14780  	//                concerning the ENOUGH constants, which depend on those values
 14781  	(*Inflate_state)(unsafe.Pointer(state)).Fnext = state + 1368 /* &.codes */
 14782  	(*Inflate_state)(unsafe.Pointer(state)).Flencode = (*Inflate_state)(unsafe.Pointer(state)).Fnext
 14783  	(*Inflate_state)(unsafe.Pointer(state)).Flenbits = uint32(9)
 14784  	ret = Xinflate_table(tls, LENS, state+152, (*Inflate_state)(unsafe.Pointer(state)).Fnlen, state+144,
 14785  		state+120, state+792)
 14786  	if !(ret != 0) {
 14787  		goto __358
 14788  	}
 14789  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 539 /* "invalid literal/..." */
 14790  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 14791  	goto __9
 14792  __358:
 14793  	;
 14794  	(*Inflate_state)(unsafe.Pointer(state)).Fdistcode = (*Inflate_state)(unsafe.Pointer(state)).Fnext
 14795  	(*Inflate_state)(unsafe.Pointer(state)).Fdistbits = uint32(6)
 14796  	ret = Xinflate_table(tls, DISTS, state+152+uintptr((*Inflate_state)(unsafe.Pointer(state)).Fnlen)*2, (*Inflate_state)(unsafe.Pointer(state)).Fndist,
 14797  		state+144, state+124, state+792)
 14798  	if !(ret != 0) {
 14799  		goto __359
 14800  	}
 14801  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 567 /* "invalid distance..." */
 14802  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 14803  	goto __9
 14804  __359:
 14805  	;
 14806  
 14807  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = LEN_
 14808  	if !(flush == Z_TREES) {
 14809  		goto __360
 14810  	}
 14811  	goto inf_leave
 14812  __360:
 14813  	;
 14814  __29:
 14815  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = LEN
 14816  __30:
 14817  	if !(have >= uint32(6) && left >= uint32(258)) {
 14818  		goto __361
 14819  	}
 14820  __362:
 14821  	(*Z_stream)(unsafe.Pointer(strm)).Fnext_out = put
 14822  	(*Z_stream)(unsafe.Pointer(strm)).Favail_out = left
 14823  	(*Z_stream)(unsafe.Pointer(strm)).Fnext_in = next
 14824  	(*Z_stream)(unsafe.Pointer(strm)).Favail_in = have
 14825  	(*Inflate_state)(unsafe.Pointer(state)).Fhold = hold
 14826  	(*Inflate_state)(unsafe.Pointer(state)).Fbits = bits
 14827  	goto __363
 14828  __363:
 14829  	if 0 != 0 {
 14830  		goto __362
 14831  	}
 14832  	goto __364
 14833  __364:
 14834  	;
 14835  	Xinflate_fast(tls, strm, out)
 14836  __365:
 14837  	put = (*Z_stream)(unsafe.Pointer(strm)).Fnext_out
 14838  	left = (*Z_stream)(unsafe.Pointer(strm)).Favail_out
 14839  	next = (*Z_stream)(unsafe.Pointer(strm)).Fnext_in
 14840  	have = (*Z_stream)(unsafe.Pointer(strm)).Favail_in
 14841  	hold = (*Inflate_state)(unsafe.Pointer(state)).Fhold
 14842  	bits = (*Inflate_state)(unsafe.Pointer(state)).Fbits
 14843  	goto __366
 14844  __366:
 14845  	if 0 != 0 {
 14846  		goto __365
 14847  	}
 14848  	goto __367
 14849  __367:
 14850  	;
 14851  	if !((*Inflate_state)(unsafe.Pointer(state)).Fmode == TYPE) {
 14852  		goto __368
 14853  	}
 14854  	(*Inflate_state)(unsafe.Pointer(state)).Fback = -1
 14855  __368:
 14856  	;
 14857  	goto __9
 14858  __361:
 14859  	;
 14860  	(*Inflate_state)(unsafe.Pointer(state)).Fback = 0
 14861  __369:
 14862  	here = *(*Code)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Flencode + uintptr(uint32(hold)&(uint32(1)<<(*Inflate_state)(unsafe.Pointer(state)).Flenbits-uint32(1)))*4))
 14863  	if !(uint32(here.Fbits) <= bits) {
 14864  		goto __372
 14865  	}
 14866  	goto __371
 14867  __372:
 14868  	;
 14869  __373:
 14870  	if !(have == uint32(0)) {
 14871  		goto __376
 14872  	}
 14873  	goto inf_leave
 14874  __376:
 14875  	;
 14876  	have--
 14877  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))<<bits
 14878  	bits = bits + uint32(8)
 14879  	goto __374
 14880  __374:
 14881  	if 0 != 0 {
 14882  		goto __373
 14883  	}
 14884  	goto __375
 14885  __375:
 14886  	;
 14887  	goto __370
 14888  __370:
 14889  	goto __369
 14890  	goto __371
 14891  __371:
 14892  	;
 14893  	if !(here.Fop != 0 && int32(here.Fop)&0xf0 == 0) {
 14894  		goto __377
 14895  	}
 14896  	last = here
 14897  __378:
 14898  	here = *(*Code)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Flencode + uintptr(uint32(last.Fval)+uint32(hold)&(uint32(1)<<(int32(last.Fbits)+int32(last.Fop))-uint32(1))>>int32(last.Fbits))*4))
 14899  	if !(uint32(int32(last.Fbits)+int32(here.Fbits)) <= bits) {
 14900  		goto __381
 14901  	}
 14902  	goto __380
 14903  __381:
 14904  	;
 14905  __382:
 14906  	if !(have == uint32(0)) {
 14907  		goto __385
 14908  	}
 14909  	goto inf_leave
 14910  __385:
 14911  	;
 14912  	have--
 14913  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))<<bits
 14914  	bits = bits + uint32(8)
 14915  	goto __383
 14916  __383:
 14917  	if 0 != 0 {
 14918  		goto __382
 14919  	}
 14920  	goto __384
 14921  __384:
 14922  	;
 14923  	goto __379
 14924  __379:
 14925  	goto __378
 14926  	goto __380
 14927  __380:
 14928  	;
 14929  __386:
 14930  	hold >>= int32(last.Fbits)
 14931  	bits = bits - uint32(last.Fbits)
 14932  	goto __387
 14933  __387:
 14934  	if 0 != 0 {
 14935  		goto __386
 14936  	}
 14937  	goto __388
 14938  __388:
 14939  	;
 14940  	*(*int32)(unsafe.Pointer(state + 7148)) += int32(last.Fbits)
 14941  __377:
 14942  	;
 14943  __389:
 14944  	hold >>= int32(here.Fbits)
 14945  	bits = bits - uint32(here.Fbits)
 14946  	goto __390
 14947  __390:
 14948  	if 0 != 0 {
 14949  		goto __389
 14950  	}
 14951  	goto __391
 14952  __391:
 14953  	;
 14954  	*(*int32)(unsafe.Pointer(state + 7148)) += int32(here.Fbits)
 14955  	(*Inflate_state)(unsafe.Pointer(state)).Flength = uint32(here.Fval)
 14956  	if !(int32(here.Fop) == 0) {
 14957  		goto __392
 14958  	}
 14959  
 14960  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = LIT
 14961  	goto __9
 14962  __392:
 14963  	;
 14964  	if !(int32(here.Fop)&32 != 0) {
 14965  		goto __393
 14966  	}
 14967  
 14968  	(*Inflate_state)(unsafe.Pointer(state)).Fback = -1
 14969  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = TYPE
 14970  	goto __9
 14971  __393:
 14972  	;
 14973  	if !(int32(here.Fop)&64 != 0) {
 14974  		goto __394
 14975  	}
 14976  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 589 /* "invalid literal/..." */
 14977  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 14978  	goto __9
 14979  __394:
 14980  	;
 14981  	(*Inflate_state)(unsafe.Pointer(state)).Fextra = uint32(here.Fop) & uint32(15)
 14982  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = LENEXT
 14983  __31:
 14984  	if !((*Inflate_state)(unsafe.Pointer(state)).Fextra != 0) {
 14985  		goto __395
 14986  	}
 14987  __396:
 14988  __399:
 14989  	if !(bits < (*Inflate_state)(unsafe.Pointer(state)).Fextra) {
 14990  		goto __400
 14991  	}
 14992  __401:
 14993  	if !(have == uint32(0)) {
 14994  		goto __404
 14995  	}
 14996  	goto inf_leave
 14997  __404:
 14998  	;
 14999  	have--
 15000  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))<<bits
 15001  	bits = bits + uint32(8)
 15002  	goto __402
 15003  __402:
 15004  	if 0 != 0 {
 15005  		goto __401
 15006  	}
 15007  	goto __403
 15008  __403:
 15009  	;
 15010  	goto __399
 15011  __400:
 15012  	;
 15013  	goto __397
 15014  __397:
 15015  	if 0 != 0 {
 15016  		goto __396
 15017  	}
 15018  	goto __398
 15019  __398:
 15020  	;
 15021  	*(*uint32)(unsafe.Pointer(state + 92)) += uint32(hold) & (uint32(1)<<(*Inflate_state)(unsafe.Pointer(state)).Fextra - uint32(1))
 15022  __405:
 15023  	hold >>= (*Inflate_state)(unsafe.Pointer(state)).Fextra
 15024  	bits = bits - (*Inflate_state)(unsafe.Pointer(state)).Fextra
 15025  	goto __406
 15026  __406:
 15027  	if 0 != 0 {
 15028  		goto __405
 15029  	}
 15030  	goto __407
 15031  __407:
 15032  	;
 15033  	*(*int32)(unsafe.Pointer(state + 7148)) += int32((*Inflate_state)(unsafe.Pointer(state)).Fextra)
 15034  __395:
 15035  	;
 15036  
 15037  	(*Inflate_state)(unsafe.Pointer(state)).Fwas = (*Inflate_state)(unsafe.Pointer(state)).Flength
 15038  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = DIST
 15039  __32:
 15040  __408:
 15041  	here = *(*Code)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fdistcode + uintptr(uint32(hold)&(uint32(1)<<(*Inflate_state)(unsafe.Pointer(state)).Fdistbits-uint32(1)))*4))
 15042  	if !(uint32(here.Fbits) <= bits) {
 15043  		goto __411
 15044  	}
 15045  	goto __410
 15046  __411:
 15047  	;
 15048  __412:
 15049  	if !(have == uint32(0)) {
 15050  		goto __415
 15051  	}
 15052  	goto inf_leave
 15053  __415:
 15054  	;
 15055  	have--
 15056  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))<<bits
 15057  	bits = bits + uint32(8)
 15058  	goto __413
 15059  __413:
 15060  	if 0 != 0 {
 15061  		goto __412
 15062  	}
 15063  	goto __414
 15064  __414:
 15065  	;
 15066  	goto __409
 15067  __409:
 15068  	goto __408
 15069  	goto __410
 15070  __410:
 15071  	;
 15072  	if !(int32(here.Fop)&0xf0 == 0) {
 15073  		goto __416
 15074  	}
 15075  	last = here
 15076  __417:
 15077  	here = *(*Code)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fdistcode + uintptr(uint32(last.Fval)+uint32(hold)&(uint32(1)<<(int32(last.Fbits)+int32(last.Fop))-uint32(1))>>int32(last.Fbits))*4))
 15078  	if !(uint32(int32(last.Fbits)+int32(here.Fbits)) <= bits) {
 15079  		goto __420
 15080  	}
 15081  	goto __419
 15082  __420:
 15083  	;
 15084  __421:
 15085  	if !(have == uint32(0)) {
 15086  		goto __424
 15087  	}
 15088  	goto inf_leave
 15089  __424:
 15090  	;
 15091  	have--
 15092  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))<<bits
 15093  	bits = bits + uint32(8)
 15094  	goto __422
 15095  __422:
 15096  	if 0 != 0 {
 15097  		goto __421
 15098  	}
 15099  	goto __423
 15100  __423:
 15101  	;
 15102  	goto __418
 15103  __418:
 15104  	goto __417
 15105  	goto __419
 15106  __419:
 15107  	;
 15108  __425:
 15109  	hold >>= int32(last.Fbits)
 15110  	bits = bits - uint32(last.Fbits)
 15111  	goto __426
 15112  __426:
 15113  	if 0 != 0 {
 15114  		goto __425
 15115  	}
 15116  	goto __427
 15117  __427:
 15118  	;
 15119  	*(*int32)(unsafe.Pointer(state + 7148)) += int32(last.Fbits)
 15120  __416:
 15121  	;
 15122  __428:
 15123  	hold >>= int32(here.Fbits)
 15124  	bits = bits - uint32(here.Fbits)
 15125  	goto __429
 15126  __429:
 15127  	if 0 != 0 {
 15128  		goto __428
 15129  	}
 15130  	goto __430
 15131  __430:
 15132  	;
 15133  	*(*int32)(unsafe.Pointer(state + 7148)) += int32(here.Fbits)
 15134  	if !(int32(here.Fop)&64 != 0) {
 15135  		goto __431
 15136  	}
 15137  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 617 /* "invalid distance..." */
 15138  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 15139  	goto __9
 15140  __431:
 15141  	;
 15142  	(*Inflate_state)(unsafe.Pointer(state)).Foffset = uint32(here.Fval)
 15143  	(*Inflate_state)(unsafe.Pointer(state)).Fextra = uint32(here.Fop) & uint32(15)
 15144  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = DISTEXT
 15145  __33:
 15146  	if !((*Inflate_state)(unsafe.Pointer(state)).Fextra != 0) {
 15147  		goto __432
 15148  	}
 15149  __433:
 15150  __436:
 15151  	if !(bits < (*Inflate_state)(unsafe.Pointer(state)).Fextra) {
 15152  		goto __437
 15153  	}
 15154  __438:
 15155  	if !(have == uint32(0)) {
 15156  		goto __441
 15157  	}
 15158  	goto inf_leave
 15159  __441:
 15160  	;
 15161  	have--
 15162  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))<<bits
 15163  	bits = bits + uint32(8)
 15164  	goto __439
 15165  __439:
 15166  	if 0 != 0 {
 15167  		goto __438
 15168  	}
 15169  	goto __440
 15170  __440:
 15171  	;
 15172  	goto __436
 15173  __437:
 15174  	;
 15175  	goto __434
 15176  __434:
 15177  	if 0 != 0 {
 15178  		goto __433
 15179  	}
 15180  	goto __435
 15181  __435:
 15182  	;
 15183  	*(*uint32)(unsafe.Pointer(state + 96)) += uint32(hold) & (uint32(1)<<(*Inflate_state)(unsafe.Pointer(state)).Fextra - uint32(1))
 15184  __442:
 15185  	hold >>= (*Inflate_state)(unsafe.Pointer(state)).Fextra
 15186  	bits = bits - (*Inflate_state)(unsafe.Pointer(state)).Fextra
 15187  	goto __443
 15188  __443:
 15189  	if 0 != 0 {
 15190  		goto __442
 15191  	}
 15192  	goto __444
 15193  __444:
 15194  	;
 15195  	*(*int32)(unsafe.Pointer(state + 7148)) += int32((*Inflate_state)(unsafe.Pointer(state)).Fextra)
 15196  __432:
 15197  	;
 15198  
 15199  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = MATCH
 15200  __34:
 15201  	if !(left == uint32(0)) {
 15202  		goto __445
 15203  	}
 15204  	goto inf_leave
 15205  __445:
 15206  	;
 15207  	copy = out - left
 15208  	if !((*Inflate_state)(unsafe.Pointer(state)).Foffset > copy) {
 15209  		goto __446
 15210  	} // copy from window
 15211  	copy = (*Inflate_state)(unsafe.Pointer(state)).Foffset - copy
 15212  	if !(copy > (*Inflate_state)(unsafe.Pointer(state)).Fwhave) {
 15213  		goto __448
 15214  	}
 15215  	if !((*Inflate_state)(unsafe.Pointer(state)).Fsane != 0) {
 15216  		goto __449
 15217  	}
 15218  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 639 /* "invalid distance..." */
 15219  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 15220  	goto __9
 15221  __449:
 15222  	;
 15223  __448:
 15224  	;
 15225  	if !(copy > (*Inflate_state)(unsafe.Pointer(state)).Fwnext) {
 15226  		goto __450
 15227  	}
 15228  	copy = copy - (*Inflate_state)(unsafe.Pointer(state)).Fwnext
 15229  	from = (*Inflate_state)(unsafe.Pointer(state)).Fwindow + uintptr((*Inflate_state)(unsafe.Pointer(state)).Fwsize-copy)
 15230  	goto __451
 15231  __450:
 15232  	from = (*Inflate_state)(unsafe.Pointer(state)).Fwindow + uintptr((*Inflate_state)(unsafe.Pointer(state)).Fwnext-copy)
 15233  __451:
 15234  	;
 15235  	if !(copy > (*Inflate_state)(unsafe.Pointer(state)).Flength) {
 15236  		goto __452
 15237  	}
 15238  	copy = (*Inflate_state)(unsafe.Pointer(state)).Flength
 15239  __452:
 15240  	;
 15241  	goto __447
 15242  __446: // copy from output
 15243  	from = put - uintptr((*Inflate_state)(unsafe.Pointer(state)).Foffset)
 15244  	copy = (*Inflate_state)(unsafe.Pointer(state)).Flength
 15245  __447:
 15246  	;
 15247  	if !(copy > left) {
 15248  		goto __453
 15249  	}
 15250  	copy = left
 15251  __453:
 15252  	;
 15253  	left = left - copy
 15254  	*(*uint32)(unsafe.Pointer(state + 92)) -= copy
 15255  __454:
 15256  	*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&put, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1)))
 15257  	goto __455
 15258  __455:
 15259  	if libc.PreDecUint32(&copy, 1) != 0 {
 15260  		goto __454
 15261  	}
 15262  	goto __456
 15263  __456:
 15264  	;
 15265  	if !((*Inflate_state)(unsafe.Pointer(state)).Flength == uint32(0)) {
 15266  		goto __457
 15267  	}
 15268  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = LEN
 15269  __457:
 15270  	;
 15271  	goto __9
 15272  __35:
 15273  	if !(left == uint32(0)) {
 15274  		goto __458
 15275  	}
 15276  	goto inf_leave
 15277  __458:
 15278  	;
 15279  	*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&put, 1))) = uint8((*Inflate_state)(unsafe.Pointer(state)).Flength)
 15280  	left--
 15281  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = LEN
 15282  	goto __9
 15283  __36:
 15284  	if !((*Inflate_state)(unsafe.Pointer(state)).Fwrap != 0) {
 15285  		goto __459
 15286  	}
 15287  __460:
 15288  __463:
 15289  	if !(bits < uint32(32)) {
 15290  		goto __464
 15291  	}
 15292  __465:
 15293  	if !(have == uint32(0)) {
 15294  		goto __468
 15295  	}
 15296  	goto inf_leave
 15297  __468:
 15298  	;
 15299  	have--
 15300  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))<<bits
 15301  	bits = bits + uint32(8)
 15302  	goto __466
 15303  __466:
 15304  	if 0 != 0 {
 15305  		goto __465
 15306  	}
 15307  	goto __467
 15308  __467:
 15309  	;
 15310  	goto __463
 15311  __464:
 15312  	;
 15313  	goto __461
 15314  __461:
 15315  	if 0 != 0 {
 15316  		goto __460
 15317  	}
 15318  	goto __462
 15319  __462:
 15320  	;
 15321  	out = out - left
 15322  	*(*ULong)(unsafe.Pointer(strm + 40)) += ULong(out)
 15323  	*(*uint64)(unsafe.Pointer(state + 40)) += uint64(out)
 15324  	if !((*Inflate_state)(unsafe.Pointer(state)).Fwrap&4 != 0 && out != 0) {
 15325  		goto __469
 15326  	}
 15327  	(*Z_stream)(unsafe.Pointer(strm)).Fadler = libc.AssignPtrUint64(state+32, func() uint64 {
 15328  		if (*Inflate_state)(unsafe.Pointer(state)).Fflags != 0 {
 15329  			return Xcrc32(tls, (*Inflate_state)(unsafe.Pointer(state)).Fcheck, put-uintptr(out), out)
 15330  		}
 15331  		return Xadler32(tls, (*Inflate_state)(unsafe.Pointer(state)).Fcheck, put-uintptr(out), out)
 15332  	}())
 15333  __469:
 15334  	;
 15335  	out = left
 15336  	if !((*Inflate_state)(unsafe.Pointer(state)).Fwrap&4 != 0 && func() uint64 {
 15337  		if (*Inflate_state)(unsafe.Pointer(state)).Fflags != 0 {
 15338  			return hold
 15339  		}
 15340  		return hold>>24&uint64(0xff) + hold>>8&uint64(0xff00) + hold&uint64(0xff00)<<8 + hold&uint64(0xff)<<24
 15341  	}() != (*Inflate_state)(unsafe.Pointer(state)).Fcheck) {
 15342  		goto __470
 15343  	}
 15344  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 784 /* "incorrect data c..." */
 15345  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 15346  	goto __9
 15347  __470:
 15348  	;
 15349  __471:
 15350  	hold = uint64(0)
 15351  	bits = uint32(0)
 15352  	goto __472
 15353  __472:
 15354  	if 0 != 0 {
 15355  		goto __471
 15356  	}
 15357  	goto __473
 15358  __473:
 15359  	;
 15360  
 15361  __459:
 15362  	;
 15363  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = LENGTH
 15364  __37:
 15365  	if !((*Inflate_state)(unsafe.Pointer(state)).Fwrap != 0 && (*Inflate_state)(unsafe.Pointer(state)).Fflags != 0) {
 15366  		goto __474
 15367  	}
 15368  __475:
 15369  __478:
 15370  	if !(bits < uint32(32)) {
 15371  		goto __479
 15372  	}
 15373  __480:
 15374  	if !(have == uint32(0)) {
 15375  		goto __483
 15376  	}
 15377  	goto inf_leave
 15378  __483:
 15379  	;
 15380  	have--
 15381  	hold = hold + uint64(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))<<bits
 15382  	bits = bits + uint32(8)
 15383  	goto __481
 15384  __481:
 15385  	if 0 != 0 {
 15386  		goto __480
 15387  	}
 15388  	goto __482
 15389  __482:
 15390  	;
 15391  	goto __478
 15392  __479:
 15393  	;
 15394  	goto __476
 15395  __476:
 15396  	if 0 != 0 {
 15397  		goto __475
 15398  	}
 15399  	goto __477
 15400  __477:
 15401  	;
 15402  	if !(hold != (*Inflate_state)(unsafe.Pointer(state)).Ftotal&0xffffffff) {
 15403  		goto __484
 15404  	}
 15405  	(*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 805 /* "incorrect length..." */
 15406  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD
 15407  	goto __9
 15408  __484:
 15409  	;
 15410  __485:
 15411  	hold = uint64(0)
 15412  	bits = uint32(0)
 15413  	goto __486
 15414  __486:
 15415  	if 0 != 0 {
 15416  		goto __485
 15417  	}
 15418  	goto __487
 15419  __487:
 15420  	;
 15421  
 15422  __474:
 15423  	;
 15424  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = DONE
 15425  __38:
 15426  	ret = Z_STREAM_END
 15427  	goto inf_leave
 15428  __39:
 15429  	ret = -3
 15430  	goto inf_leave
 15431  __40:
 15432  	return -4
 15433  __41:
 15434  __42:
 15435  	return -2
 15436  __9:
 15437  	;
 15438  	goto __7
 15439  __7:
 15440  	goto __6
 15441  	goto __8
 15442  __8:
 15443  	;
 15444  
 15445  	//
 15446  	//        Return from inflate(), updating the total counts and the check value.
 15447  	//        If there was no progress during the inflate() call, return a buffer
 15448  	//        error.  Call updatewindow() to create and/or update the window state.
 15449  	//        Note: a memory error from inflate() is non-recoverable.
 15450  	//
 15451  inf_leave:
 15452  __488:
 15453  	(*Z_stream)(unsafe.Pointer(strm)).Fnext_out = put
 15454  	(*Z_stream)(unsafe.Pointer(strm)).Favail_out = left
 15455  	(*Z_stream)(unsafe.Pointer(strm)).Fnext_in = next
 15456  	(*Z_stream)(unsafe.Pointer(strm)).Favail_in = have
 15457  	(*Inflate_state)(unsafe.Pointer(state)).Fhold = hold
 15458  	(*Inflate_state)(unsafe.Pointer(state)).Fbits = bits
 15459  	goto __489
 15460  __489:
 15461  	if 0 != 0 {
 15462  		goto __488
 15463  	}
 15464  	goto __490
 15465  __490:
 15466  	;
 15467  	if !((*Inflate_state)(unsafe.Pointer(state)).Fwsize != 0 || out != (*Z_stream)(unsafe.Pointer(strm)).Favail_out && (*Inflate_state)(unsafe.Pointer(state)).Fmode < BAD && ((*Inflate_state)(unsafe.Pointer(state)).Fmode < CHECK || flush != Z_FINISH)) {
 15468  		goto __491
 15469  	}
 15470  	if !(updatewindow(tls, strm, (*Z_stream)(unsafe.Pointer(strm)).Fnext_out, out-(*Z_stream)(unsafe.Pointer(strm)).Favail_out) != 0) {
 15471  		goto __492
 15472  	}
 15473  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = MEM
 15474  	return -4
 15475  __492:
 15476  	;
 15477  __491:
 15478  	;
 15479  	in = in - (*Z_stream)(unsafe.Pointer(strm)).Favail_in
 15480  	out = out - (*Z_stream)(unsafe.Pointer(strm)).Favail_out
 15481  	*(*ULong)(unsafe.Pointer(strm + 16)) += ULong(in)
 15482  	*(*ULong)(unsafe.Pointer(strm + 40)) += ULong(out)
 15483  	*(*uint64)(unsafe.Pointer(state + 40)) += uint64(out)
 15484  	if !((*Inflate_state)(unsafe.Pointer(state)).Fwrap&4 != 0 && out != 0) {
 15485  		goto __493
 15486  	}
 15487  	(*Z_stream)(unsafe.Pointer(strm)).Fadler = libc.AssignPtrUint64(state+32, func() uint64 {
 15488  		if (*Inflate_state)(unsafe.Pointer(state)).Fflags != 0 {
 15489  			return Xcrc32(tls, (*Inflate_state)(unsafe.Pointer(state)).Fcheck, (*Z_stream)(unsafe.Pointer(strm)).Fnext_out-uintptr(out), out)
 15490  		}
 15491  		return Xadler32(tls, (*Inflate_state)(unsafe.Pointer(state)).Fcheck, (*Z_stream)(unsafe.Pointer(strm)).Fnext_out-uintptr(out), out)
 15492  	}())
 15493  __493:
 15494  	;
 15495  	(*Z_stream)(unsafe.Pointer(strm)).Fdata_type = int32((*Inflate_state)(unsafe.Pointer(state)).Fbits) + func() int32 {
 15496  		if (*Inflate_state)(unsafe.Pointer(state)).Flast != 0 {
 15497  			return 64
 15498  		}
 15499  		return 0
 15500  	}() + func() int32 {
 15501  		if (*Inflate_state)(unsafe.Pointer(state)).Fmode == TYPE {
 15502  			return 128
 15503  		}
 15504  		return 0
 15505  	}() + func() int32 {
 15506  		if (*Inflate_state)(unsafe.Pointer(state)).Fmode == LEN_ || (*Inflate_state)(unsafe.Pointer(state)).Fmode == COPY_ {
 15507  			return 256
 15508  		}
 15509  		return 0
 15510  	}()
 15511  	if !((in == uint32(0) && out == uint32(0) || flush == Z_FINISH) && ret == Z_OK) {
 15512  		goto __494
 15513  	}
 15514  	ret = -5
 15515  __494:
 15516  	;
 15517  	return ret
 15518  }
 15519  
 15520  var order1 =                                                                                                                                                                                                                         // permutation of code lengths
 15521  [19]uint16{uint16(16), uint16(17), uint16(18), uint16(0), uint16(8), uint16(7), uint16(9), uint16(6), uint16(10), uint16(5), uint16(11), uint16(4), uint16(12), uint16(3), uint16(13), uint16(2), uint16(14), uint16(1), uint16(15)} /* inflate.c:642:33 */
 15522  
 15523  func XinflateEnd(tls *libc.TLS, strm Z_streamp) int32 { /* inflate.c:1277:13: */
 15524  	var state uintptr
 15525  	if inflateStateCheck(tls, strm) != 0 {
 15526  		return -2
 15527  	}
 15528  	state = (*Z_stream)(unsafe.Pointer(strm)).Fstate
 15529  	if (*Inflate_state)(unsafe.Pointer(state)).Fwindow != uintptr(Z_NULL) {
 15530  		(*struct {
 15531  			f func(*libc.TLS, Voidpf, Voidpf)
 15532  		})(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer(strm)).Fzfree})).f(tls, (*Z_stream)(unsafe.Pointer(strm)).Fopaque, (*Inflate_state)(unsafe.Pointer(state)).Fwindow)
 15533  	}
 15534  	(*struct {
 15535  		f func(*libc.TLS, Voidpf, Voidpf)
 15536  	})(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer(strm)).Fzfree})).f(tls, (*Z_stream)(unsafe.Pointer(strm)).Fopaque, (*Z_stream)(unsafe.Pointer(strm)).Fstate)
 15537  	(*Z_stream)(unsafe.Pointer(strm)).Fstate = uintptr(Z_NULL)
 15538  
 15539  	return Z_OK
 15540  }
 15541  
 15542  func XinflateGetDictionary(tls *libc.TLS, strm Z_streamp, dictionary uintptr, dictLength uintptr) int32 { /* inflate.c:1291:13: */
 15543  	var state uintptr
 15544  
 15545  	// check state
 15546  	if inflateStateCheck(tls, strm) != 0 {
 15547  		return -2
 15548  	}
 15549  	state = (*Z_stream)(unsafe.Pointer(strm)).Fstate
 15550  
 15551  	// copy dictionary
 15552  	if (*Inflate_state)(unsafe.Pointer(state)).Fwhave != 0 && dictionary != uintptr(Z_NULL) {
 15553  		libc.Xmemcpy(tls, dictionary, (*Inflate_state)(unsafe.Pointer(state)).Fwindow+uintptr((*Inflate_state)(unsafe.Pointer(state)).Fwnext),
 15554  			uint64((*Inflate_state)(unsafe.Pointer(state)).Fwhave-(*Inflate_state)(unsafe.Pointer(state)).Fwnext))
 15555  		libc.Xmemcpy(tls, dictionary+uintptr((*Inflate_state)(unsafe.Pointer(state)).Fwhave)-uintptr((*Inflate_state)(unsafe.Pointer(state)).Fwnext),
 15556  			(*Inflate_state)(unsafe.Pointer(state)).Fwindow, uint64((*Inflate_state)(unsafe.Pointer(state)).Fwnext))
 15557  	}
 15558  	if dictLength != uintptr(Z_NULL) {
 15559  		*(*UInt)(unsafe.Pointer(dictLength)) = (*Inflate_state)(unsafe.Pointer(state)).Fwhave
 15560  	}
 15561  	return Z_OK
 15562  }
 15563  
 15564  func XinflateSetDictionary(tls *libc.TLS, strm Z_streamp, dictionary uintptr, dictLength UInt) int32 { /* inflate.c:1314:13: */
 15565  	var state uintptr
 15566  	var dictid uint64
 15567  	var ret int32
 15568  
 15569  	// check state
 15570  	if inflateStateCheck(tls, strm) != 0 {
 15571  		return -2
 15572  	}
 15573  	state = (*Z_stream)(unsafe.Pointer(strm)).Fstate
 15574  	if (*Inflate_state)(unsafe.Pointer(state)).Fwrap != 0 && (*Inflate_state)(unsafe.Pointer(state)).Fmode != DICT {
 15575  		return -2
 15576  	}
 15577  
 15578  	// check for correct dictionary identifier
 15579  	if (*Inflate_state)(unsafe.Pointer(state)).Fmode == DICT {
 15580  		dictid = Xadler32(tls, uint64(0), uintptr(Z_NULL), uint32(0))
 15581  		dictid = Xadler32(tls, dictid, dictionary, dictLength)
 15582  		if dictid != (*Inflate_state)(unsafe.Pointer(state)).Fcheck {
 15583  			return -3
 15584  		}
 15585  	}
 15586  
 15587  	// copy dictionary to window using updatewindow(), which will amend the
 15588  	//        existing dictionary if appropriate
 15589  	ret = updatewindow(tls, strm, dictionary+uintptr(dictLength), dictLength)
 15590  	if ret != 0 {
 15591  		(*Inflate_state)(unsafe.Pointer(state)).Fmode = MEM
 15592  		return -4
 15593  	}
 15594  	(*Inflate_state)(unsafe.Pointer(state)).Fhavedict = 1
 15595  
 15596  	return Z_OK
 15597  }
 15598  
 15599  func XinflateGetHeader(tls *libc.TLS, strm Z_streamp, head Gz_headerp) int32 { /* inflate.c:1349:13: */
 15600  	var state uintptr
 15601  
 15602  	// check state
 15603  	if inflateStateCheck(tls, strm) != 0 {
 15604  		return -2
 15605  	}
 15606  	state = (*Z_stream)(unsafe.Pointer(strm)).Fstate
 15607  	if (*Inflate_state)(unsafe.Pointer(state)).Fwrap&2 == 0 {
 15608  		return -2
 15609  	}
 15610  
 15611  	// save header structure
 15612  	(*Inflate_state)(unsafe.Pointer(state)).Fhead = head
 15613  	(*Gz_header)(unsafe.Pointer(head)).Fdone = 0
 15614  	return Z_OK
 15615  }
 15616  
 15617  //
 15618  //    Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff.  Return when found
 15619  //    or when out of input.  When called, *have is the number of pattern bytes
 15620  //    found in order so far, in 0..3.  On return *have is updated to the new
 15621  //    state.  If on return *have equals four, then the pattern was found and the
 15622  //    return value is how many bytes were read including the last byte of the
 15623  //    pattern.  If *have is less than four, then the pattern has not been found
 15624  //    yet and the return value is len.  In the latter case, syncsearch() can be
 15625  //    called again with more data and the *have state.  *have is initialized to
 15626  //    zero for the first call.
 15627  //
 15628  func syncsearch(tls *libc.TLS, have uintptr, buf uintptr, len uint32) uint32 { /* inflate.c:1377:16: */
 15629  	var got uint32
 15630  	var next uint32
 15631  
 15632  	got = *(*uint32)(unsafe.Pointer(have))
 15633  	next = uint32(0)
 15634  	for next < len && got < uint32(4) {
 15635  		if int32(*(*uint8)(unsafe.Pointer(buf + uintptr(next)))) == func() int32 {
 15636  			if got < uint32(2) {
 15637  				return 0
 15638  			}
 15639  			return 0xff
 15640  		}() {
 15641  			got++
 15642  		} else if *(*uint8)(unsafe.Pointer(buf + uintptr(next))) != 0 {
 15643  			got = uint32(0)
 15644  		} else {
 15645  			got = uint32(4) - got
 15646  		}
 15647  		next++
 15648  	}
 15649  	*(*uint32)(unsafe.Pointer(have)) = got
 15650  	return next
 15651  }
 15652  
 15653  func XinflateSync(tls *libc.TLS, strm Z_streamp) int32 { /* inflate.c:1400:13: */
 15654  	bp := tls.Alloc(4)
 15655  	defer tls.Free(4)
 15656  
 15657  	var len uint32 // number of bytes to look at or looked at
 15658  	var in uint64
 15659  	var out uint64 // temporary to save total_in and total_out
 15660  	// var buf [4]uint8 at bp, 4
 15661  	// to restore bit buffer to byte string
 15662  	var state uintptr
 15663  
 15664  	// check parameters
 15665  	if inflateStateCheck(tls, strm) != 0 {
 15666  		return -2
 15667  	}
 15668  	state = (*Z_stream)(unsafe.Pointer(strm)).Fstate
 15669  	if (*Z_stream)(unsafe.Pointer(strm)).Favail_in == UInt(0) && (*Inflate_state)(unsafe.Pointer(state)).Fbits < uint32(8) {
 15670  		return -5
 15671  	}
 15672  
 15673  	// if first time, start search in bit buffer
 15674  	if (*Inflate_state)(unsafe.Pointer(state)).Fmode != SYNC {
 15675  		(*Inflate_state)(unsafe.Pointer(state)).Fmode = SYNC
 15676  		libc.AssignShlPtrUint64(state+80, int((*Inflate_state)(unsafe.Pointer(state)).Fbits&uint32(7)))
 15677  		*(*uint32)(unsafe.Pointer(state + 88)) -= (*Inflate_state)(unsafe.Pointer(state)).Fbits & uint32(7)
 15678  		len = uint32(0)
 15679  		for (*Inflate_state)(unsafe.Pointer(state)).Fbits >= uint32(8) {
 15680  			*(*uint8)(unsafe.Pointer(bp + uintptr(libc.PostIncUint32(&len, 1)))) = uint8((*Inflate_state)(unsafe.Pointer(state)).Fhold)
 15681  			libc.AssignShrPtrUint64(state+80, int(8))
 15682  			*(*uint32)(unsafe.Pointer(state + 88)) -= uint32(8)
 15683  		}
 15684  		(*Inflate_state)(unsafe.Pointer(state)).Fhave = uint32(0)
 15685  		syncsearch(tls, state+140, bp, len)
 15686  	}
 15687  
 15688  	// search available input
 15689  	len = syncsearch(tls, state+140, (*Z_stream)(unsafe.Pointer(strm)).Fnext_in, (*Z_stream)(unsafe.Pointer(strm)).Favail_in)
 15690  	*(*UInt)(unsafe.Pointer(strm + 8)) -= len
 15691  	*(*uintptr)(unsafe.Pointer(strm)) += uintptr(len)
 15692  	*(*ULong)(unsafe.Pointer(strm + 16)) += ULong(len)
 15693  
 15694  	// return no joy or set up to restart inflate() on a new block
 15695  	if (*Inflate_state)(unsafe.Pointer(state)).Fhave != uint32(4) {
 15696  		return -3
 15697  	}
 15698  	in = (*Z_stream)(unsafe.Pointer(strm)).Ftotal_in
 15699  	out = (*Z_stream)(unsafe.Pointer(strm)).Ftotal_out
 15700  	XinflateReset(tls, strm)
 15701  	(*Z_stream)(unsafe.Pointer(strm)).Ftotal_in = in
 15702  	(*Z_stream)(unsafe.Pointer(strm)).Ftotal_out = out
 15703  	(*Inflate_state)(unsafe.Pointer(state)).Fmode = TYPE
 15704  	return Z_OK
 15705  }
 15706  
 15707  //
 15708  //    Returns true if inflate is currently at the end of a block generated by
 15709  //    Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
 15710  //    implementation to provide an additional safety check. PPP uses
 15711  //    Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored
 15712  //    block. When decompressing, PPP checks that at the end of input packet,
 15713  //    inflate is waiting for these length bytes.
 15714  //
 15715  func XinflateSyncPoint(tls *libc.TLS, strm Z_streamp) int32 { /* inflate.c:1451:13: */
 15716  	var state uintptr
 15717  
 15718  	if inflateStateCheck(tls, strm) != 0 {
 15719  		return -2
 15720  	}
 15721  	state = (*Z_stream)(unsafe.Pointer(strm)).Fstate
 15722  	return libc.Bool32((*Inflate_state)(unsafe.Pointer(state)).Fmode == STORED && (*Inflate_state)(unsafe.Pointer(state)).Fbits == uint32(0))
 15723  }
 15724  
 15725  func XinflateCopy(tls *libc.TLS, dest Z_streamp, source Z_streamp) int32 { /* inflate.c:1461:13: */
 15726  	var state uintptr
 15727  	var copy uintptr
 15728  	var window uintptr
 15729  	var wsize uint32
 15730  
 15731  	// check input
 15732  	if inflateStateCheck(tls, source) != 0 || dest == uintptr(Z_NULL) {
 15733  		return -2
 15734  	}
 15735  	state = (*Z_stream)(unsafe.Pointer(source)).Fstate
 15736  
 15737  	// allocate space
 15738  	copy = (*struct {
 15739  		f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf
 15740  	})(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer(source)).Fzalloc})).f(tls, (*Z_stream)(unsafe.Pointer(source)).Fopaque, uint32(1), uint32(unsafe.Sizeof(Inflate_state{})))
 15741  	if copy == uintptr(Z_NULL) {
 15742  		return -4
 15743  	}
 15744  	window = uintptr(Z_NULL)
 15745  	if (*Inflate_state)(unsafe.Pointer(state)).Fwindow != uintptr(Z_NULL) {
 15746  		window = (*struct {
 15747  			f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf
 15748  		})(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer(source)).Fzalloc})).f(tls, (*Z_stream)(unsafe.Pointer(source)).Fopaque, uint32(1)<<(*Inflate_state)(unsafe.Pointer(state)).Fwbits, uint32(unsafe.Sizeof(uint8(0))))
 15749  		if window == uintptr(Z_NULL) {
 15750  			(*struct {
 15751  				f func(*libc.TLS, Voidpf, Voidpf)
 15752  			})(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer(source)).Fzfree})).f(tls, (*Z_stream)(unsafe.Pointer(source)).Fopaque, copy)
 15753  			return -4
 15754  		}
 15755  	}
 15756  
 15757  	// copy state
 15758  	libc.Xmemcpy(tls, dest, source, uint64(unsafe.Sizeof(Z_stream{})))
 15759  	libc.Xmemcpy(tls, copy, state, uint64(unsafe.Sizeof(Inflate_state{})))
 15760  	(*Inflate_state)(unsafe.Pointer(copy)).Fstrm = dest
 15761  	if (*Inflate_state)(unsafe.Pointer(state)).Flencode >= state+1368 && (*Inflate_state)(unsafe.Pointer(state)).Flencode <= state+1368+uintptr(ENOUGH_LENS+ENOUGH_DISTS)*4-uintptr(1)*4 {
 15762  		(*Inflate_state)(unsafe.Pointer(copy)).Flencode = copy + 1368 + uintptr(int64(((*Inflate_state)(unsafe.Pointer(state)).Flencode-(state+1368))/4))*4
 15763  		(*Inflate_state)(unsafe.Pointer(copy)).Fdistcode = copy + 1368 + uintptr(int64(((*Inflate_state)(unsafe.Pointer(state)).Fdistcode-(state+1368))/4))*4
 15764  	}
 15765  	(*Inflate_state)(unsafe.Pointer(copy)).Fnext = copy + 1368 + uintptr(int64(((*Inflate_state)(unsafe.Pointer(state)).Fnext-(state+1368))/4))*4
 15766  	if window != uintptr(Z_NULL) {
 15767  		wsize = uint32(1) << (*Inflate_state)(unsafe.Pointer(state)).Fwbits
 15768  		libc.Xmemcpy(tls, window, (*Inflate_state)(unsafe.Pointer(state)).Fwindow, uint64(wsize))
 15769  	}
 15770  	(*Inflate_state)(unsafe.Pointer(copy)).Fwindow = window
 15771  	(*Z_stream)(unsafe.Pointer(dest)).Fstate = copy
 15772  	return Z_OK
 15773  }
 15774  
 15775  func XinflateUndermine(tls *libc.TLS, strm Z_streamp, subvert int32) int32 { /* inflate.c:1508:13: */
 15776  	var state uintptr
 15777  
 15778  	if inflateStateCheck(tls, strm) != 0 {
 15779  		return -2
 15780  	}
 15781  	state = (*Z_stream)(unsafe.Pointer(strm)).Fstate
 15782  	_ = subvert
 15783  	(*Inflate_state)(unsafe.Pointer(state)).Fsane = 1
 15784  	return -3
 15785  }
 15786  
 15787  func XinflateValidate(tls *libc.TLS, strm Z_streamp, check int32) int32 { /* inflate.c:1526:13: */
 15788  	var state uintptr
 15789  
 15790  	if inflateStateCheck(tls, strm) != 0 {
 15791  		return -2
 15792  	}
 15793  	state = (*Z_stream)(unsafe.Pointer(strm)).Fstate
 15794  	if check != 0 {
 15795  		*(*int32)(unsafe.Pointer(state + 16)) |= 4
 15796  	} else {
 15797  		*(*int32)(unsafe.Pointer(state + 16)) &= libc.CplInt32(4)
 15798  	}
 15799  	return Z_OK
 15800  }
 15801  
 15802  func XinflateMark(tls *libc.TLS, strm Z_streamp) int64 { /* inflate.c:1541:14: */
 15803  	var state uintptr
 15804  
 15805  	if inflateStateCheck(tls, strm) != 0 {
 15806  		return -(int64(1) << 16)
 15807  	}
 15808  	state = (*Z_stream)(unsafe.Pointer(strm)).Fstate
 15809  	return int64(uint64(int64((*Inflate_state)(unsafe.Pointer(state)).Fback))<<16) + func() int64 {
 15810  		if (*Inflate_state)(unsafe.Pointer(state)).Fmode == COPY {
 15811  			return int64((*Inflate_state)(unsafe.Pointer(state)).Flength)
 15812  		}
 15813  		return func() int64 {
 15814  			if (*Inflate_state)(unsafe.Pointer(state)).Fmode == MATCH {
 15815  				return int64((*Inflate_state)(unsafe.Pointer(state)).Fwas - (*Inflate_state)(unsafe.Pointer(state)).Flength)
 15816  			}
 15817  			return int64(0)
 15818  		}()
 15819  	}()
 15820  }
 15821  
 15822  func XinflateCodesUsed(tls *libc.TLS, strm Z_streamp) uint64 { /* inflate.c:1554:23: */
 15823  	var state uintptr
 15824  	if inflateStateCheck(tls, strm) != 0 {
 15825  		return libc.Uint64(libc.Uint64FromInt32(-1))
 15826  	}
 15827  	state = (*Z_stream)(unsafe.Pointer(strm)).Fstate
 15828  	return uint64(int64(((*Inflate_state)(unsafe.Pointer(state)).Fnext - (state + 1368)) / 4))
 15829  }
 15830  
 15831  var Xinflate_copyright = *(*[48]uint8)(unsafe.Pointer(ts + 828)) /* inftrees.c:11:12 */
 15832  
 15833  //
 15834  //   If you use the zlib library in a product, an acknowledgment is welcome
 15835  //   in the documentation of your product. If for some reason you cannot
 15836  //   include such an acknowledgment, I would appreciate that you keep this
 15837  //   copyright string in the executable of your product.
 15838  //
 15839  
 15840  //
 15841  //    Build a set of tables to decode the provided canonical Huffman code.
 15842  //    The code lengths are lens[0..codes-1].  The result starts at *table,
 15843  //    whose indices are 0..2^bits-1.  work is a writable array of at least
 15844  //    lens shorts, which is used as a work area.  type is the type of code
 15845  //    to be generated, CODES, LENS, or DISTS.  On return, zero is success,
 15846  //    -1 is an invalid code, and +1 means that ENOUGH isn't enough.  table
 15847  //    on return points to the next available entry's address.  bits is the
 15848  //    requested root table index bits, and on return it is the actual root
 15849  //    table index bits.  It will differ if the request is greater than the
 15850  //    longest code or if it is less than the shortest code.
 15851  //
 15852  func Xinflate_table(tls *libc.TLS, type1 Codetype, lens uintptr, codes uint32, table uintptr, bits uintptr, work uintptr) int32 { /* inftrees.c:32:19: */
 15853  	bp := tls.Alloc(64)
 15854  	defer tls.Free(64)
 15855  
 15856  	var len uint32 // a code's length in bits
 15857  	var sym uint32 // index of code symbols
 15858  	var min uint32
 15859  	var max uint32    // minimum and maximum code lengths
 15860  	var root uint32   // number of index bits for root table
 15861  	var curr uint32   // number of index bits for current table
 15862  	var drop uint32   // code bits to drop for sub-table
 15863  	var left int32    // number of prefix codes available
 15864  	var used uint32   // code entries in table used
 15865  	var huff uint32   // Huffman code
 15866  	var incr uint32   // for incrementing code, index
 15867  	var fill uint32   // index for replicating entries
 15868  	var low uint32    // low bits for current root entry
 15869  	var mask uint32   // mask for low root bits
 15870  	var here Code     // table entry for duplication
 15871  	var next uintptr  // next available space in table
 15872  	var base uintptr  // base value table to use
 15873  	var extra uintptr // extra bits table to use
 15874  	var match uint32  // use base and extra for symbol >= match
 15875  	// var count [16]uint16 at bp, 32
 15876  	// number of codes of each length
 15877  	// var offs [16]uint16 at bp+32, 32
 15878  
 15879  	//
 15880  	//        Process a set of code lengths to create a canonical Huffman code.  The
 15881  	//        code lengths are lens[0..codes-1].  Each length corresponds to the
 15882  	//        symbols 0..codes-1.  The Huffman code is generated by first sorting the
 15883  	//        symbols by length from short to long, and retaining the symbol order
 15884  	//        for codes with equal lengths.  Then the code starts with all zero bits
 15885  	//        for the first code of the shortest length, and the codes are integer
 15886  	//        increments for the same length, and zeros are appended as the length
 15887  	//        increases.  For the deflate format, these bits are stored backwards
 15888  	//        from their more natural integer increment ordering, and so when the
 15889  	//        decoding tables are built in the large loop below, the integer codes
 15890  	//        are incremented backwards.
 15891  	//
 15892  	//        This routine assumes, but does not check, that all of the entries in
 15893  	//        lens[] are in the range 0..MAXBITS.  The caller must assure this.
 15894  	//        1..MAXBITS is interpreted as that code length.  zero means that that
 15895  	//        symbol does not occur in this code.
 15896  	//
 15897  	//        The codes are sorted by computing a count of codes for each length,
 15898  	//        creating from that a table of starting indices for each length in the
 15899  	//        sorted table, and then entering the symbols in order in the sorted
 15900  	//        table.  The sorted table is work[], with that space being provided by
 15901  	//        the caller.
 15902  	//
 15903  	//        The length counts are used for other purposes as well, i.e. finding
 15904  	//        the minimum and maximum length codes, determining if there are any
 15905  	//        codes at all, checking for a valid set of lengths, and looking ahead
 15906  	//        at length counts to determine sub-table sizes when building the
 15907  	//        decoding tables.
 15908  	//
 15909  
 15910  	// accumulate lengths for codes (assumes lens[] all in 0..MAXBITS)
 15911  	for len = uint32(0); len <= uint32(MAXBITS); len++ {
 15912  		*(*uint16)(unsafe.Pointer(bp + uintptr(len)*2)) = uint16(0)
 15913  	}
 15914  	for sym = uint32(0); sym < codes; sym++ {
 15915  		*(*uint16)(unsafe.Pointer(bp + uintptr(*(*uint16)(unsafe.Pointer(lens + uintptr(sym)*2)))*2))++
 15916  	}
 15917  
 15918  	// bound code lengths, force root to be within code lengths
 15919  	root = *(*uint32)(unsafe.Pointer(bits))
 15920  	for max = uint32(MAXBITS); max >= uint32(1); max-- {
 15921  		if int32(*(*uint16)(unsafe.Pointer(bp + uintptr(max)*2))) != 0 {
 15922  			break
 15923  		}
 15924  	}
 15925  	if root > max {
 15926  		root = max
 15927  	}
 15928  	if max == uint32(0) { // no symbols to code at all
 15929  		here.Fop = uint8(64) // invalid code marker
 15930  		here.Fbits = uint8(1)
 15931  		here.Fval = uint16(0)
 15932  		*(*Code)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(table)), 4))) = here // make a table to force an error
 15933  		*(*Code)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(table)), 4))) = here
 15934  		*(*uint32)(unsafe.Pointer(bits)) = uint32(1)
 15935  		return 0 // no symbols, but wait for decoding to report error
 15936  	}
 15937  	for min = uint32(1); min < max; min++ {
 15938  		if int32(*(*uint16)(unsafe.Pointer(bp + uintptr(min)*2))) != 0 {
 15939  			break
 15940  		}
 15941  	}
 15942  	if root < min {
 15943  		root = min
 15944  	}
 15945  
 15946  	// check for an over-subscribed or incomplete set of lengths
 15947  	left = 1
 15948  	for len = uint32(1); len <= uint32(MAXBITS); len++ {
 15949  		left <<= 1
 15950  		left = left - int32(*(*uint16)(unsafe.Pointer(bp + uintptr(len)*2)))
 15951  		if left < 0 {
 15952  			return -1
 15953  		} // over-subscribed
 15954  	}
 15955  	if left > 0 && (type1 == CODES || max != uint32(1)) {
 15956  		return -1
 15957  	} // incomplete set
 15958  
 15959  	// generate offsets into symbol table for each length for sorting
 15960  	*(*uint16)(unsafe.Pointer(bp + 32 + 1*2)) = uint16(0)
 15961  	for len = uint32(1); len < uint32(MAXBITS); len++ {
 15962  		*(*uint16)(unsafe.Pointer(bp + 32 + uintptr(len+uint32(1))*2)) = uint16(int32(*(*uint16)(unsafe.Pointer(bp + 32 + uintptr(len)*2))) + int32(*(*uint16)(unsafe.Pointer(bp + uintptr(len)*2))))
 15963  	}
 15964  
 15965  	// sort symbols by length, by symbol order within each length
 15966  	for sym = uint32(0); sym < codes; sym++ {
 15967  		if int32(*(*uint16)(unsafe.Pointer(lens + uintptr(sym)*2))) != 0 {
 15968  			*(*uint16)(unsafe.Pointer(work + uintptr(libc.PostIncUint16(&*(*uint16)(unsafe.Pointer(bp + 32 + uintptr(*(*uint16)(unsafe.Pointer(lens + uintptr(sym)*2)))*2)), 1))*2)) = uint16(sym)
 15969  		}
 15970  	}
 15971  
 15972  	//
 15973  	//        Create and fill in decoding tables.  In this loop, the table being
 15974  	//        filled is at next and has curr index bits.  The code being used is huff
 15975  	//        with length len.  That code is converted to an index by dropping drop
 15976  	//        bits off of the bottom.  For codes where len is less than drop + curr,
 15977  	//        those top drop + curr - len bits are incremented through all values to
 15978  	//        fill the table with replicated entries.
 15979  	//
 15980  	//        root is the number of index bits for the root table.  When len exceeds
 15981  	//        root, sub-tables are created pointed to by the root entry with an index
 15982  	//        of the low root bits of huff.  This is saved in low to check for when a
 15983  	//        new sub-table should be started.  drop is zero when the root table is
 15984  	//        being filled, and drop is root when sub-tables are being filled.
 15985  	//
 15986  	//        When a new sub-table is needed, it is necessary to look ahead in the
 15987  	//        code lengths to determine what size sub-table is needed.  The length
 15988  	//        counts are used for this, and so count[] is decremented as codes are
 15989  	//        entered in the tables.
 15990  	//
 15991  	//        used keeps track of how many table entries have been allocated from the
 15992  	//        provided *table space.  It is checked for LENS and DIST tables against
 15993  	//        the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in
 15994  	//        the initial root table size constants.  See the comments in inftrees.h
 15995  	//        for more information.
 15996  	//
 15997  	//        sym increments through all symbols, and the loop terminates when
 15998  	//        all codes of length max, i.e. all codes, have been processed.  This
 15999  	//        routine permits incomplete codes, so another loop after this one fills
 16000  	//        in the rest of the decoding tables with invalid code markers.
 16001  	//
 16002  
 16003  	// set up for code type
 16004  	switch type1 {
 16005  	case CODES:
 16006  		base = libc.AssignUintptr(&extra, work) // dummy value--not used
 16007  		match = uint32(20)
 16008  		break
 16009  	case LENS:
 16010  		base = uintptr(unsafe.Pointer(&lbase))
 16011  		extra = uintptr(unsafe.Pointer(&lext))
 16012  		match = uint32(257)
 16013  		break
 16014  	default: // DISTS
 16015  		base = uintptr(unsafe.Pointer(&dbase))
 16016  		extra = uintptr(unsafe.Pointer(&dext))
 16017  		match = uint32(0)
 16018  	}
 16019  
 16020  	// initialize state for loop
 16021  	huff = uint32(0)                            // starting code
 16022  	sym = uint32(0)                             // starting code symbol
 16023  	len = min                                   // starting code length
 16024  	next = *(*uintptr)(unsafe.Pointer(table))   // current table to fill in
 16025  	curr = root                                 // current table index bits
 16026  	drop = uint32(0)                            // current bits to drop from code for index
 16027  	low = libc.Uint32(libc.Uint32FromInt32(-1)) // trigger new sub-table when len > root
 16028  	used = uint32(1) << root                    // use root table entries
 16029  	mask = used - uint32(1)                     // mask for comparing low
 16030  
 16031  	// check available table space
 16032  	if type1 == LENS && used > uint32(ENOUGH_LENS) || type1 == DISTS && used > uint32(ENOUGH_DISTS) {
 16033  		return 1
 16034  	}
 16035  
 16036  	// process all codes and make table entries
 16037  	for {
 16038  		// create table entry
 16039  		here.Fbits = uint8(len - drop)
 16040  		if uint32(*(*uint16)(unsafe.Pointer(work + uintptr(sym)*2)))+1 < match {
 16041  			here.Fop = uint8(0)
 16042  			here.Fval = *(*uint16)(unsafe.Pointer(work + uintptr(sym)*2))
 16043  		} else if uint32(*(*uint16)(unsafe.Pointer(work + uintptr(sym)*2))) >= match {
 16044  			here.Fop = uint8(*(*uint16)(unsafe.Pointer(extra + uintptr(uint32(*(*uint16)(unsafe.Pointer(work + uintptr(sym)*2)))-match)*2)))
 16045  			here.Fval = *(*uint16)(unsafe.Pointer(base + uintptr(uint32(*(*uint16)(unsafe.Pointer(work + uintptr(sym)*2)))-match)*2))
 16046  		} else {
 16047  			here.Fop = uint8(32 + 64) // end of block
 16048  			here.Fval = uint16(0)
 16049  		}
 16050  
 16051  		// replicate for those indices with low len bits equal to huff
 16052  		incr = uint32(1) << (len - drop)
 16053  		fill = uint32(1) << curr
 16054  		min = fill // save offset to next table
 16055  		for __ccgo := true; __ccgo; __ccgo = fill != uint32(0) {
 16056  			fill = fill - incr
 16057  			*(*Code)(unsafe.Pointer(next + uintptr(huff>>drop+fill)*4)) = here
 16058  		}
 16059  
 16060  		// backwards increment the len-bit code huff
 16061  		incr = uint32(1) << (len - uint32(1))
 16062  		for huff&incr != 0 {
 16063  			incr >>= 1
 16064  		}
 16065  		if incr != uint32(0) {
 16066  			huff = huff & (incr - uint32(1))
 16067  			huff = huff + incr
 16068  		} else {
 16069  			huff = uint32(0)
 16070  		}
 16071  
 16072  		// go to next symbol, update count, len
 16073  		sym++
 16074  		if int32(libc.PreDecUint16(&*(*uint16)(unsafe.Pointer(bp + uintptr(len)*2)), 1)) == 0 {
 16075  			if len == max {
 16076  				break
 16077  			}
 16078  			len = uint32(*(*uint16)(unsafe.Pointer(lens + uintptr(*(*uint16)(unsafe.Pointer(work + uintptr(sym)*2)))*2)))
 16079  		}
 16080  
 16081  		// create new sub-table if needed
 16082  		if len > root && huff&mask != low {
 16083  			// if first time, transition to sub-tables
 16084  			if drop == uint32(0) {
 16085  				drop = root
 16086  			}
 16087  
 16088  			// increment past last table
 16089  			next += 4 * uintptr(min) // here min is 1 << curr
 16090  
 16091  			// determine length of next table
 16092  			curr = len - drop
 16093  			left = int32(1) << curr
 16094  			for curr+drop < max {
 16095  				left = left - int32(*(*uint16)(unsafe.Pointer(bp + uintptr(curr+drop)*2)))
 16096  				if left <= 0 {
 16097  					break
 16098  				}
 16099  				curr++
 16100  				left <<= 1
 16101  			}
 16102  
 16103  			// check for enough space
 16104  			used = used + uint32(1)<<curr
 16105  			if type1 == LENS && used > uint32(ENOUGH_LENS) || type1 == DISTS && used > uint32(ENOUGH_DISTS) {
 16106  				return 1
 16107  			}
 16108  
 16109  			// point entry in root table to sub-table
 16110  			low = huff & mask
 16111  			(*Code)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(table)) + uintptr(low)*4)).Fop = uint8(curr)
 16112  			(*Code)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(table)) + uintptr(low)*4)).Fbits = uint8(root)
 16113  			(*Code)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(table)) + uintptr(low)*4)).Fval = uint16((int64(next) - int64(*(*uintptr)(unsafe.Pointer(table)))) / 4)
 16114  		}
 16115  	}
 16116  
 16117  	// fill in remaining table entry if code is incomplete (guaranteed to have
 16118  	//        at most one remaining entry, since if the code is incomplete, the
 16119  	//        maximum code length that was allowed to get this far is one bit)
 16120  	if huff != uint32(0) {
 16121  		here.Fop = uint8(64) // invalid code marker
 16122  		here.Fbits = uint8(len - drop)
 16123  		here.Fval = uint16(0)
 16124  		*(*Code)(unsafe.Pointer(next + uintptr(huff)*4)) = here
 16125  	}
 16126  
 16127  	// set return parameters
 16128  	*(*uintptr)(unsafe.Pointer(table)) += uintptr(used) * 4
 16129  	*(*uint32)(unsafe.Pointer(bits)) = root
 16130  	return 0
 16131  }
 16132  
 16133  var lbase = [31]uint16{ // Length codes 257..285 base
 16134  	uint16(3), uint16(4), uint16(5), uint16(6), uint16(7), uint16(8), uint16(9), uint16(10), uint16(11), uint16(13), uint16(15), uint16(17), uint16(19), uint16(23), uint16(27), uint16(31),
 16135  			uint16(35), uint16(43), uint16(51), uint16(59), uint16(67), uint16(83), uint16(99), uint16(115), uint16(131), uint16(163), uint16(195), uint16(227), uint16(258), uint16(0), uint16(0)} /* inftrees.c:60:33 */
 16136  var lext = [31]uint16{ // Length codes 257..285 extra
 16137  	uint16(16), uint16(16), uint16(16), uint16(16), uint16(16), uint16(16), uint16(16), uint16(16), uint16(17), uint16(17), uint16(17), uint16(17), uint16(18), uint16(18), uint16(18), uint16(18),
 16138  			uint16(19), uint16(19), uint16(19), uint16(19), uint16(20), uint16(20), uint16(20), uint16(20), uint16(21), uint16(21), uint16(21), uint16(21), uint16(16), uint16(77), uint16(202)} /* inftrees.c:63:33 */
 16139  var dbase = [32]uint16{ // Distance codes 0..29 base
 16140  	uint16(1), uint16(2), uint16(3), uint16(4), uint16(5), uint16(7), uint16(9), uint16(13), uint16(17), uint16(25), uint16(33), uint16(49), uint16(65), uint16(97), uint16(129), uint16(193),
 16141  	uint16(257), uint16(385), uint16(513), uint16(769), uint16(1025), uint16(1537), uint16(2049), uint16(3073), uint16(4097), uint16(6145),
 16142  			uint16(8193), uint16(12289), uint16(16385), uint16(24577), uint16(0), uint16(0)} /* inftrees.c:66:33 */
 16143  var dext = [32]uint16{ // Distance codes 0..29 extra
 16144  	uint16(16), uint16(16), uint16(16), uint16(16), uint16(17), uint16(17), uint16(18), uint16(18), uint16(19), uint16(19), uint16(20), uint16(20), uint16(21), uint16(21), uint16(22), uint16(22),
 16145  	uint16(23), uint16(23), uint16(24), uint16(24), uint16(25), uint16(25), uint16(26), uint16(26), uint16(27), uint16(27),
 16146  	uint16(28), uint16(28), uint16(29), uint16(29), uint16(64), uint16(64)} /* inftrees.c:70:33 */
 16147  
 16148  type Static_tree_desc = Static_tree_desc_s /* deflate.h:84:36 */
 16149  
 16150  // ===========================================================================
 16151  // Constants
 16152  
 16153  // Bit length codes must not exceed MAX_BL_BITS bits
 16154  
 16155  // end of block literal code
 16156  
 16157  // repeat previous bit length 3-6 times (2 bits of repeat count)
 16158  
 16159  // repeat a zero length 3-10 times  (3 bits of repeat count)
 16160  
 16161  // repeat a zero length 11-138 times  (7 bits of repeat count)
 16162  
 16163  var extra_lbits = [29]int32{0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0} /* trees.c:62:17 */
 16164  
 16165  var extra_dbits = [30]int32{0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13} /* trees.c:65:17 */
 16166  
 16167  var extra_blbits = [19]int32{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7} /* trees.c:68:17 */
 16168  
 16169  var bl_order = [19]Uch{Uch(16), Uch(17), Uch(18), Uch(0), Uch(8), Uch(7), Uch(9), Uch(6), Uch(10), Uch(5), Uch(11), Uch(4), Uch(12), Uch(3), Uch(13), Uch(2), Uch(14), Uch(1), Uch(15)} /* trees.c:71:17 */
 16170  // The lengths of the bit length codes are sent in order of decreasing
 16171  // probability, to avoid transmitting the lengths for unused bit length codes.
 16172  
 16173  // ===========================================================================
 16174  // Local data. These are initialized only once.
 16175  
 16176  // header created automatically with -DGEN_TREES_H
 16177  
 16178  var static_ltree = [288]Ct_data{{Ffc: func() (r struct{ Ffreq Ush }) {
 16179  	*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(12)
 16180  	return r
 16181  }(), Fdl: func() (r struct{ Fdad Ush }) {
 16182  	*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16183  	return r
 16184  }()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16185  	*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(140)
 16186  	return r
 16187  }(), Fdl: func() (r struct{ Fdad Ush }) {
 16188  	*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16189  	return r
 16190  }()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16191  	*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(76)
 16192  	return r
 16193  }(), Fdl: func() (r struct{ Fdad Ush }) {
 16194  	*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16195  	return r
 16196  }()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16197  	*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(204)
 16198  	return r
 16199  }(), Fdl: func() (r struct{ Fdad Ush }) {
 16200  	*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16201  	return r
 16202  }()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16203  	*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(44)
 16204  	return r
 16205  }(), Fdl: func() (r struct{ Fdad Ush }) {
 16206  	*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16207  	return r
 16208  }()},
 16209  	{Ffc: func() (r struct{ Ffreq Ush }) {
 16210  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(172)
 16211  		return r
 16212  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16213  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16214  		return r
 16215  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16216  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(108)
 16217  		return r
 16218  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16219  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16220  		return r
 16221  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16222  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(236)
 16223  		return r
 16224  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16225  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16226  		return r
 16227  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16228  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(28)
 16229  		return r
 16230  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16231  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16232  		return r
 16233  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16234  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(156)
 16235  		return r
 16236  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16237  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16238  		return r
 16239  	}()},
 16240  	{Ffc: func() (r struct{ Ffreq Ush }) {
 16241  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(92)
 16242  		return r
 16243  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16244  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16245  		return r
 16246  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16247  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(220)
 16248  		return r
 16249  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16250  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16251  		return r
 16252  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16253  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(60)
 16254  		return r
 16255  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16256  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16257  		return r
 16258  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16259  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(188)
 16260  		return r
 16261  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16262  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16263  		return r
 16264  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16265  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(124)
 16266  		return r
 16267  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16268  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16269  		return r
 16270  	}()},
 16271  	{Ffc: func() (r struct{ Ffreq Ush }) {
 16272  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(252)
 16273  		return r
 16274  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16275  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16276  		return r
 16277  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16278  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(2)
 16279  		return r
 16280  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16281  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16282  		return r
 16283  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16284  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(130)
 16285  		return r
 16286  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16287  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16288  		return r
 16289  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16290  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(66)
 16291  		return r
 16292  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16293  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16294  		return r
 16295  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16296  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(194)
 16297  		return r
 16298  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16299  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16300  		return r
 16301  	}()},
 16302  	{Ffc: func() (r struct{ Ffreq Ush }) {
 16303  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(34)
 16304  		return r
 16305  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16306  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16307  		return r
 16308  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16309  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(162)
 16310  		return r
 16311  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16312  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16313  		return r
 16314  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16315  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(98)
 16316  		return r
 16317  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16318  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16319  		return r
 16320  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16321  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(226)
 16322  		return r
 16323  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16324  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16325  		return r
 16326  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16327  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(18)
 16328  		return r
 16329  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16330  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16331  		return r
 16332  	}()},
 16333  	{Ffc: func() (r struct{ Ffreq Ush }) {
 16334  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(146)
 16335  		return r
 16336  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16337  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16338  		return r
 16339  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16340  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(82)
 16341  		return r
 16342  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16343  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16344  		return r
 16345  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16346  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(210)
 16347  		return r
 16348  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16349  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16350  		return r
 16351  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16352  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(50)
 16353  		return r
 16354  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16355  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16356  		return r
 16357  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16358  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(178)
 16359  		return r
 16360  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16361  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16362  		return r
 16363  	}()},
 16364  	{Ffc: func() (r struct{ Ffreq Ush }) {
 16365  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(114)
 16366  		return r
 16367  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16368  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16369  		return r
 16370  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16371  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(242)
 16372  		return r
 16373  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16374  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16375  		return r
 16376  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16377  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(10)
 16378  		return r
 16379  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16380  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16381  		return r
 16382  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16383  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(138)
 16384  		return r
 16385  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16386  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16387  		return r
 16388  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16389  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(74)
 16390  		return r
 16391  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16392  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16393  		return r
 16394  	}()},
 16395  	{Ffc: func() (r struct{ Ffreq Ush }) {
 16396  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(202)
 16397  		return r
 16398  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16399  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16400  		return r
 16401  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16402  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(42)
 16403  		return r
 16404  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16405  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16406  		return r
 16407  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16408  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(170)
 16409  		return r
 16410  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16411  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16412  		return r
 16413  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16414  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(106)
 16415  		return r
 16416  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16417  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16418  		return r
 16419  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16420  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(234)
 16421  		return r
 16422  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16423  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16424  		return r
 16425  	}()},
 16426  	{Ffc: func() (r struct{ Ffreq Ush }) {
 16427  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(26)
 16428  		return r
 16429  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16430  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16431  		return r
 16432  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16433  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(154)
 16434  		return r
 16435  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16436  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16437  		return r
 16438  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16439  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(90)
 16440  		return r
 16441  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16442  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16443  		return r
 16444  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16445  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(218)
 16446  		return r
 16447  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16448  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16449  		return r
 16450  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16451  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(58)
 16452  		return r
 16453  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16454  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16455  		return r
 16456  	}()},
 16457  	{Ffc: func() (r struct{ Ffreq Ush }) {
 16458  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(186)
 16459  		return r
 16460  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16461  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16462  		return r
 16463  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16464  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(122)
 16465  		return r
 16466  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16467  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16468  		return r
 16469  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16470  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(250)
 16471  		return r
 16472  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16473  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16474  		return r
 16475  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16476  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(6)
 16477  		return r
 16478  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16479  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16480  		return r
 16481  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16482  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(134)
 16483  		return r
 16484  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16485  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16486  		return r
 16487  	}()},
 16488  	{Ffc: func() (r struct{ Ffreq Ush }) {
 16489  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(70)
 16490  		return r
 16491  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16492  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16493  		return r
 16494  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16495  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(198)
 16496  		return r
 16497  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16498  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16499  		return r
 16500  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16501  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(38)
 16502  		return r
 16503  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16504  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16505  		return r
 16506  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16507  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(166)
 16508  		return r
 16509  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16510  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16511  		return r
 16512  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16513  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(102)
 16514  		return r
 16515  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16516  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16517  		return r
 16518  	}()},
 16519  	{Ffc: func() (r struct{ Ffreq Ush }) {
 16520  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(230)
 16521  		return r
 16522  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16523  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16524  		return r
 16525  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16526  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(22)
 16527  		return r
 16528  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16529  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16530  		return r
 16531  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16532  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(150)
 16533  		return r
 16534  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16535  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16536  		return r
 16537  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16538  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(86)
 16539  		return r
 16540  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16541  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16542  		return r
 16543  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16544  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(214)
 16545  		return r
 16546  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16547  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16548  		return r
 16549  	}()},
 16550  	{Ffc: func() (r struct{ Ffreq Ush }) {
 16551  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(54)
 16552  		return r
 16553  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16554  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16555  		return r
 16556  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16557  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(182)
 16558  		return r
 16559  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16560  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16561  		return r
 16562  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16563  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(118)
 16564  		return r
 16565  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16566  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16567  		return r
 16568  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16569  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(246)
 16570  		return r
 16571  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16572  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16573  		return r
 16574  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16575  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(14)
 16576  		return r
 16577  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16578  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16579  		return r
 16580  	}()},
 16581  	{Ffc: func() (r struct{ Ffreq Ush }) {
 16582  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(142)
 16583  		return r
 16584  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16585  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16586  		return r
 16587  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16588  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(78)
 16589  		return r
 16590  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16591  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16592  		return r
 16593  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16594  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(206)
 16595  		return r
 16596  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16597  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16598  		return r
 16599  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16600  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(46)
 16601  		return r
 16602  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16603  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16604  		return r
 16605  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16606  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(174)
 16607  		return r
 16608  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16609  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16610  		return r
 16611  	}()},
 16612  	{Ffc: func() (r struct{ Ffreq Ush }) {
 16613  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(110)
 16614  		return r
 16615  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16616  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16617  		return r
 16618  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16619  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(238)
 16620  		return r
 16621  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16622  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16623  		return r
 16624  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16625  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(30)
 16626  		return r
 16627  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16628  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16629  		return r
 16630  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16631  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(158)
 16632  		return r
 16633  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16634  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16635  		return r
 16636  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16637  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(94)
 16638  		return r
 16639  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16640  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16641  		return r
 16642  	}()},
 16643  	{Ffc: func() (r struct{ Ffreq Ush }) {
 16644  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(222)
 16645  		return r
 16646  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16647  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16648  		return r
 16649  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16650  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(62)
 16651  		return r
 16652  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16653  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16654  		return r
 16655  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16656  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(190)
 16657  		return r
 16658  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16659  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16660  		return r
 16661  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16662  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(126)
 16663  		return r
 16664  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16665  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16666  		return r
 16667  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16668  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(254)
 16669  		return r
 16670  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16671  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16672  		return r
 16673  	}()},
 16674  	{Ffc: func() (r struct{ Ffreq Ush }) {
 16675  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(1)
 16676  		return r
 16677  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16678  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16679  		return r
 16680  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16681  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(129)
 16682  		return r
 16683  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16684  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16685  		return r
 16686  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16687  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(65)
 16688  		return r
 16689  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16690  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16691  		return r
 16692  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16693  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(193)
 16694  		return r
 16695  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16696  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16697  		return r
 16698  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16699  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(33)
 16700  		return r
 16701  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16702  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16703  		return r
 16704  	}()},
 16705  	{Ffc: func() (r struct{ Ffreq Ush }) {
 16706  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(161)
 16707  		return r
 16708  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16709  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16710  		return r
 16711  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16712  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(97)
 16713  		return r
 16714  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16715  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16716  		return r
 16717  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16718  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(225)
 16719  		return r
 16720  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16721  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16722  		return r
 16723  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16724  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(17)
 16725  		return r
 16726  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16727  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16728  		return r
 16729  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16730  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(145)
 16731  		return r
 16732  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16733  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16734  		return r
 16735  	}()},
 16736  	{Ffc: func() (r struct{ Ffreq Ush }) {
 16737  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(81)
 16738  		return r
 16739  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16740  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16741  		return r
 16742  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16743  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(209)
 16744  		return r
 16745  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16746  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16747  		return r
 16748  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16749  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(49)
 16750  		return r
 16751  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16752  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16753  		return r
 16754  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16755  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(177)
 16756  		return r
 16757  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16758  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16759  		return r
 16760  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16761  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(113)
 16762  		return r
 16763  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16764  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16765  		return r
 16766  	}()},
 16767  	{Ffc: func() (r struct{ Ffreq Ush }) {
 16768  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(241)
 16769  		return r
 16770  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16771  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16772  		return r
 16773  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16774  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 16775  		return r
 16776  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16777  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16778  		return r
 16779  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16780  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(137)
 16781  		return r
 16782  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16783  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16784  		return r
 16785  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16786  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(73)
 16787  		return r
 16788  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16789  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16790  		return r
 16791  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16792  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(201)
 16793  		return r
 16794  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16795  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16796  		return r
 16797  	}()},
 16798  	{Ffc: func() (r struct{ Ffreq Ush }) {
 16799  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(41)
 16800  		return r
 16801  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16802  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16803  		return r
 16804  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16805  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(169)
 16806  		return r
 16807  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16808  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16809  		return r
 16810  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16811  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(105)
 16812  		return r
 16813  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16814  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16815  		return r
 16816  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16817  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(233)
 16818  		return r
 16819  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16820  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16821  		return r
 16822  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16823  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(25)
 16824  		return r
 16825  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16826  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16827  		return r
 16828  	}()},
 16829  	{Ffc: func() (r struct{ Ffreq Ush }) {
 16830  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(153)
 16831  		return r
 16832  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16833  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16834  		return r
 16835  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16836  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(89)
 16837  		return r
 16838  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16839  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16840  		return r
 16841  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16842  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(217)
 16843  		return r
 16844  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16845  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16846  		return r
 16847  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16848  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(57)
 16849  		return r
 16850  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16851  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16852  		return r
 16853  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16854  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(185)
 16855  		return r
 16856  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16857  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16858  		return r
 16859  	}()},
 16860  	{Ffc: func() (r struct{ Ffreq Ush }) {
 16861  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(121)
 16862  		return r
 16863  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16864  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16865  		return r
 16866  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16867  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(249)
 16868  		return r
 16869  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16870  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16871  		return r
 16872  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16873  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 16874  		return r
 16875  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16876  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16877  		return r
 16878  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16879  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(133)
 16880  		return r
 16881  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16882  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16883  		return r
 16884  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16885  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(69)
 16886  		return r
 16887  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16888  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16889  		return r
 16890  	}()},
 16891  	{Ffc: func() (r struct{ Ffreq Ush }) {
 16892  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(197)
 16893  		return r
 16894  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16895  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16896  		return r
 16897  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16898  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(37)
 16899  		return r
 16900  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16901  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16902  		return r
 16903  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16904  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(165)
 16905  		return r
 16906  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16907  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16908  		return r
 16909  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16910  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(101)
 16911  		return r
 16912  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16913  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16914  		return r
 16915  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16916  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(229)
 16917  		return r
 16918  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16919  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16920  		return r
 16921  	}()},
 16922  	{Ffc: func() (r struct{ Ffreq Ush }) {
 16923  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(21)
 16924  		return r
 16925  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16926  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16927  		return r
 16928  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16929  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(149)
 16930  		return r
 16931  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16932  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16933  		return r
 16934  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16935  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(85)
 16936  		return r
 16937  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16938  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16939  		return r
 16940  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16941  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(213)
 16942  		return r
 16943  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16944  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16945  		return r
 16946  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16947  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(53)
 16948  		return r
 16949  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16950  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16951  		return r
 16952  	}()},
 16953  	{Ffc: func() (r struct{ Ffreq Ush }) {
 16954  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(181)
 16955  		return r
 16956  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16957  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16958  		return r
 16959  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16960  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(117)
 16961  		return r
 16962  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16963  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16964  		return r
 16965  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16966  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(245)
 16967  		return r
 16968  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16969  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16970  		return r
 16971  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16972  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(13)
 16973  		return r
 16974  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16975  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16976  		return r
 16977  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16978  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(141)
 16979  		return r
 16980  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16981  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16982  		return r
 16983  	}()},
 16984  	{Ffc: func() (r struct{ Ffreq Ush }) {
 16985  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(77)
 16986  		return r
 16987  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16988  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16989  		return r
 16990  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16991  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(205)
 16992  		return r
 16993  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 16994  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 16995  		return r
 16996  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 16997  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(45)
 16998  		return r
 16999  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17000  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 17001  		return r
 17002  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17003  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(173)
 17004  		return r
 17005  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17006  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 17007  		return r
 17008  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17009  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(109)
 17010  		return r
 17011  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17012  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 17013  		return r
 17014  	}()},
 17015  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17016  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(237)
 17017  		return r
 17018  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17019  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 17020  		return r
 17021  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17022  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(29)
 17023  		return r
 17024  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17025  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 17026  		return r
 17027  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17028  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(157)
 17029  		return r
 17030  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17031  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 17032  		return r
 17033  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17034  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(93)
 17035  		return r
 17036  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17037  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 17038  		return r
 17039  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17040  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(221)
 17041  		return r
 17042  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17043  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 17044  		return r
 17045  	}()},
 17046  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17047  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(61)
 17048  		return r
 17049  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17050  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 17051  		return r
 17052  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17053  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(189)
 17054  		return r
 17055  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17056  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 17057  		return r
 17058  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17059  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(125)
 17060  		return r
 17061  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17062  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 17063  		return r
 17064  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17065  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(253)
 17066  		return r
 17067  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17068  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 17069  		return r
 17070  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17071  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(19)
 17072  		return r
 17073  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17074  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17075  		return r
 17076  	}()},
 17077  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17078  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(275)
 17079  		return r
 17080  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17081  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17082  		return r
 17083  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17084  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(147)
 17085  		return r
 17086  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17087  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17088  		return r
 17089  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17090  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(403)
 17091  		return r
 17092  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17093  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17094  		return r
 17095  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17096  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(83)
 17097  		return r
 17098  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17099  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17100  		return r
 17101  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17102  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(339)
 17103  		return r
 17104  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17105  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17106  		return r
 17107  	}()},
 17108  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17109  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(211)
 17110  		return r
 17111  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17112  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17113  		return r
 17114  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17115  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(467)
 17116  		return r
 17117  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17118  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17119  		return r
 17120  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17121  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(51)
 17122  		return r
 17123  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17124  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17125  		return r
 17126  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17127  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(307)
 17128  		return r
 17129  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17130  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17131  		return r
 17132  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17133  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(179)
 17134  		return r
 17135  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17136  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17137  		return r
 17138  	}()},
 17139  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17140  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(435)
 17141  		return r
 17142  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17143  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17144  		return r
 17145  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17146  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(115)
 17147  		return r
 17148  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17149  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17150  		return r
 17151  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17152  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(371)
 17153  		return r
 17154  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17155  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17156  		return r
 17157  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17158  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(243)
 17159  		return r
 17160  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17161  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17162  		return r
 17163  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17164  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(499)
 17165  		return r
 17166  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17167  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17168  		return r
 17169  	}()},
 17170  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17171  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(11)
 17172  		return r
 17173  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17174  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17175  		return r
 17176  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17177  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(267)
 17178  		return r
 17179  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17180  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17181  		return r
 17182  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17183  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(139)
 17184  		return r
 17185  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17186  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17187  		return r
 17188  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17189  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(395)
 17190  		return r
 17191  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17192  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17193  		return r
 17194  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17195  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(75)
 17196  		return r
 17197  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17198  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17199  		return r
 17200  	}()},
 17201  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17202  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(331)
 17203  		return r
 17204  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17205  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17206  		return r
 17207  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17208  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(203)
 17209  		return r
 17210  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17211  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17212  		return r
 17213  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17214  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(459)
 17215  		return r
 17216  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17217  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17218  		return r
 17219  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17220  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(43)
 17221  		return r
 17222  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17223  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17224  		return r
 17225  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17226  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(299)
 17227  		return r
 17228  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17229  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17230  		return r
 17231  	}()},
 17232  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17233  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(171)
 17234  		return r
 17235  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17236  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17237  		return r
 17238  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17239  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(427)
 17240  		return r
 17241  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17242  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17243  		return r
 17244  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17245  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(107)
 17246  		return r
 17247  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17248  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17249  		return r
 17250  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17251  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(363)
 17252  		return r
 17253  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17254  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17255  		return r
 17256  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17257  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(235)
 17258  		return r
 17259  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17260  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17261  		return r
 17262  	}()},
 17263  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17264  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(491)
 17265  		return r
 17266  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17267  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17268  		return r
 17269  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17270  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(27)
 17271  		return r
 17272  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17273  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17274  		return r
 17275  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17276  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(283)
 17277  		return r
 17278  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17279  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17280  		return r
 17281  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17282  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(155)
 17283  		return r
 17284  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17285  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17286  		return r
 17287  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17288  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(411)
 17289  		return r
 17290  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17291  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17292  		return r
 17293  	}()},
 17294  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17295  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(91)
 17296  		return r
 17297  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17298  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17299  		return r
 17300  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17301  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(347)
 17302  		return r
 17303  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17304  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17305  		return r
 17306  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17307  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(219)
 17308  		return r
 17309  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17310  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17311  		return r
 17312  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17313  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(475)
 17314  		return r
 17315  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17316  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17317  		return r
 17318  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17319  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(59)
 17320  		return r
 17321  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17322  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17323  		return r
 17324  	}()},
 17325  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17326  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(315)
 17327  		return r
 17328  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17329  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17330  		return r
 17331  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17332  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(187)
 17333  		return r
 17334  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17335  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17336  		return r
 17337  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17338  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(443)
 17339  		return r
 17340  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17341  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17342  		return r
 17343  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17344  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(123)
 17345  		return r
 17346  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17347  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17348  		return r
 17349  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17350  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(379)
 17351  		return r
 17352  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17353  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17354  		return r
 17355  	}()},
 17356  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17357  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(251)
 17358  		return r
 17359  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17360  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17361  		return r
 17362  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17363  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(507)
 17364  		return r
 17365  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17366  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17367  		return r
 17368  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17369  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7)
 17370  		return r
 17371  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17372  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17373  		return r
 17374  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17375  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(263)
 17376  		return r
 17377  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17378  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17379  		return r
 17380  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17381  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(135)
 17382  		return r
 17383  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17384  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17385  		return r
 17386  	}()},
 17387  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17388  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(391)
 17389  		return r
 17390  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17391  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17392  		return r
 17393  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17394  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(71)
 17395  		return r
 17396  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17397  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17398  		return r
 17399  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17400  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(327)
 17401  		return r
 17402  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17403  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17404  		return r
 17405  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17406  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(199)
 17407  		return r
 17408  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17409  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17410  		return r
 17411  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17412  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(455)
 17413  		return r
 17414  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17415  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17416  		return r
 17417  	}()},
 17418  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17419  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(39)
 17420  		return r
 17421  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17422  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17423  		return r
 17424  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17425  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(295)
 17426  		return r
 17427  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17428  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17429  		return r
 17430  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17431  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(167)
 17432  		return r
 17433  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17434  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17435  		return r
 17436  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17437  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(423)
 17438  		return r
 17439  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17440  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17441  		return r
 17442  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17443  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(103)
 17444  		return r
 17445  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17446  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17447  		return r
 17448  	}()},
 17449  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17450  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(359)
 17451  		return r
 17452  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17453  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17454  		return r
 17455  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17456  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(231)
 17457  		return r
 17458  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17459  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17460  		return r
 17461  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17462  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(487)
 17463  		return r
 17464  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17465  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17466  		return r
 17467  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17468  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(23)
 17469  		return r
 17470  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17471  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17472  		return r
 17473  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17474  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(279)
 17475  		return r
 17476  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17477  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17478  		return r
 17479  	}()},
 17480  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17481  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(151)
 17482  		return r
 17483  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17484  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17485  		return r
 17486  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17487  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(407)
 17488  		return r
 17489  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17490  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17491  		return r
 17492  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17493  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(87)
 17494  		return r
 17495  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17496  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17497  		return r
 17498  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17499  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(343)
 17500  		return r
 17501  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17502  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17503  		return r
 17504  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17505  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(215)
 17506  		return r
 17507  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17508  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17509  		return r
 17510  	}()},
 17511  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17512  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(471)
 17513  		return r
 17514  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17515  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17516  		return r
 17517  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17518  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(55)
 17519  		return r
 17520  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17521  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17522  		return r
 17523  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17524  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(311)
 17525  		return r
 17526  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17527  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17528  		return r
 17529  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17530  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(183)
 17531  		return r
 17532  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17533  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17534  		return r
 17535  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17536  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(439)
 17537  		return r
 17538  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17539  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17540  		return r
 17541  	}()},
 17542  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17543  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(119)
 17544  		return r
 17545  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17546  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17547  		return r
 17548  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17549  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(375)
 17550  		return r
 17551  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17552  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17553  		return r
 17554  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17555  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(247)
 17556  		return r
 17557  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17558  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17559  		return r
 17560  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17561  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(503)
 17562  		return r
 17563  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17564  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17565  		return r
 17566  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17567  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(15)
 17568  		return r
 17569  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17570  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17571  		return r
 17572  	}()},
 17573  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17574  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(271)
 17575  		return r
 17576  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17577  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17578  		return r
 17579  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17580  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(143)
 17581  		return r
 17582  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17583  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17584  		return r
 17585  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17586  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(399)
 17587  		return r
 17588  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17589  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17590  		return r
 17591  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17592  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(79)
 17593  		return r
 17594  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17595  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17596  		return r
 17597  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17598  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(335)
 17599  		return r
 17600  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17601  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17602  		return r
 17603  	}()},
 17604  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17605  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(207)
 17606  		return r
 17607  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17608  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17609  		return r
 17610  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17611  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(463)
 17612  		return r
 17613  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17614  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17615  		return r
 17616  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17617  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(47)
 17618  		return r
 17619  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17620  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17621  		return r
 17622  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17623  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(303)
 17624  		return r
 17625  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17626  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17627  		return r
 17628  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17629  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(175)
 17630  		return r
 17631  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17632  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17633  		return r
 17634  	}()},
 17635  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17636  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(431)
 17637  		return r
 17638  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17639  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17640  		return r
 17641  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17642  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(111)
 17643  		return r
 17644  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17645  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17646  		return r
 17647  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17648  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(367)
 17649  		return r
 17650  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17651  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17652  		return r
 17653  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17654  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(239)
 17655  		return r
 17656  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17657  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17658  		return r
 17659  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17660  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(495)
 17661  		return r
 17662  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17663  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17664  		return r
 17665  	}()},
 17666  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17667  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(31)
 17668  		return r
 17669  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17670  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17671  		return r
 17672  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17673  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(287)
 17674  		return r
 17675  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17676  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17677  		return r
 17678  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17679  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(159)
 17680  		return r
 17681  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17682  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17683  		return r
 17684  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17685  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(415)
 17686  		return r
 17687  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17688  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17689  		return r
 17690  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17691  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(95)
 17692  		return r
 17693  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17694  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17695  		return r
 17696  	}()},
 17697  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17698  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(351)
 17699  		return r
 17700  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17701  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17702  		return r
 17703  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17704  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(223)
 17705  		return r
 17706  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17707  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17708  		return r
 17709  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17710  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(479)
 17711  		return r
 17712  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17713  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17714  		return r
 17715  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17716  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(63)
 17717  		return r
 17718  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17719  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17720  		return r
 17721  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17722  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(319)
 17723  		return r
 17724  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17725  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17726  		return r
 17727  	}()},
 17728  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17729  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(191)
 17730  		return r
 17731  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17732  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17733  		return r
 17734  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17735  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(447)
 17736  		return r
 17737  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17738  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17739  		return r
 17740  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17741  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(127)
 17742  		return r
 17743  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17744  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17745  		return r
 17746  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17747  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(383)
 17748  		return r
 17749  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17750  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17751  		return r
 17752  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17753  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(255)
 17754  		return r
 17755  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17756  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17757  		return r
 17758  	}()},
 17759  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17760  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(511)
 17761  		return r
 17762  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17763  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 17764  		return r
 17765  	}()}, {Fdl: func() (r struct{ Fdad Ush }) {
 17766  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7)
 17767  		return r
 17768  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17769  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(64)
 17770  		return r
 17771  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17772  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7)
 17773  		return r
 17774  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17775  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(32)
 17776  		return r
 17777  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17778  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7)
 17779  		return r
 17780  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17781  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(96)
 17782  		return r
 17783  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17784  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7)
 17785  		return r
 17786  	}()},
 17787  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17788  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(16)
 17789  		return r
 17790  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17791  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7)
 17792  		return r
 17793  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17794  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(80)
 17795  		return r
 17796  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17797  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7)
 17798  		return r
 17799  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17800  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(48)
 17801  		return r
 17802  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17803  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7)
 17804  		return r
 17805  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17806  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(112)
 17807  		return r
 17808  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17809  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7)
 17810  		return r
 17811  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17812  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 17813  		return r
 17814  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17815  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7)
 17816  		return r
 17817  	}()},
 17818  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17819  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(72)
 17820  		return r
 17821  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17822  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7)
 17823  		return r
 17824  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17825  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(40)
 17826  		return r
 17827  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17828  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7)
 17829  		return r
 17830  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17831  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(104)
 17832  		return r
 17833  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17834  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7)
 17835  		return r
 17836  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17837  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(24)
 17838  		return r
 17839  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17840  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7)
 17841  		return r
 17842  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17843  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(88)
 17844  		return r
 17845  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17846  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7)
 17847  		return r
 17848  	}()},
 17849  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17850  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(56)
 17851  		return r
 17852  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17853  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7)
 17854  		return r
 17855  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17856  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(120)
 17857  		return r
 17858  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17859  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7)
 17860  		return r
 17861  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17862  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(4)
 17863  		return r
 17864  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17865  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7)
 17866  		return r
 17867  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17868  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(68)
 17869  		return r
 17870  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17871  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7)
 17872  		return r
 17873  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17874  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(36)
 17875  		return r
 17876  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17877  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7)
 17878  		return r
 17879  	}()},
 17880  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17881  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(100)
 17882  		return r
 17883  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17884  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7)
 17885  		return r
 17886  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17887  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(20)
 17888  		return r
 17889  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17890  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7)
 17891  		return r
 17892  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17893  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(84)
 17894  		return r
 17895  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17896  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7)
 17897  		return r
 17898  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17899  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(52)
 17900  		return r
 17901  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17902  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7)
 17903  		return r
 17904  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17905  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(116)
 17906  		return r
 17907  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17908  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7)
 17909  		return r
 17910  	}()},
 17911  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17912  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(3)
 17913  		return r
 17914  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17915  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 17916  		return r
 17917  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17918  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(131)
 17919  		return r
 17920  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17921  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 17922  		return r
 17923  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17924  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(67)
 17925  		return r
 17926  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17927  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 17928  		return r
 17929  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17930  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(195)
 17931  		return r
 17932  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17933  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 17934  		return r
 17935  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17936  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(35)
 17937  		return r
 17938  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17939  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 17940  		return r
 17941  	}()},
 17942  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17943  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(163)
 17944  		return r
 17945  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17946  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 17947  		return r
 17948  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17949  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(99)
 17950  		return r
 17951  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17952  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 17953  		return r
 17954  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17955  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(227)
 17956  		return r
 17957  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17958  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 17959  		return r
 17960  	}()}} /* trees.h:3:21 */
 17961  
 17962  var static_dtree = [30]Ct_data{{Fdl: func() (r struct{ Fdad Ush }) {
 17963  	*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 17964  	return r
 17965  }()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17966  	*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(16)
 17967  	return r
 17968  }(), Fdl: func() (r struct{ Fdad Ush }) {
 17969  	*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 17970  	return r
 17971  }()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17972  	*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8)
 17973  	return r
 17974  }(), Fdl: func() (r struct{ Fdad Ush }) {
 17975  	*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 17976  	return r
 17977  }()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17978  	*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(24)
 17979  	return r
 17980  }(), Fdl: func() (r struct{ Fdad Ush }) {
 17981  	*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 17982  	return r
 17983  }()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17984  	*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(4)
 17985  	return r
 17986  }(), Fdl: func() (r struct{ Fdad Ush }) {
 17987  	*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 17988  	return r
 17989  }()},
 17990  	{Ffc: func() (r struct{ Ffreq Ush }) {
 17991  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(20)
 17992  		return r
 17993  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 17994  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 17995  		return r
 17996  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 17997  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(12)
 17998  		return r
 17999  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 18000  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 18001  		return r
 18002  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 18003  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(28)
 18004  		return r
 18005  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 18006  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 18007  		return r
 18008  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 18009  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(2)
 18010  		return r
 18011  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 18012  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 18013  		return r
 18014  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 18015  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(18)
 18016  		return r
 18017  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 18018  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 18019  		return r
 18020  	}()},
 18021  	{Ffc: func() (r struct{ Ffreq Ush }) {
 18022  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(10)
 18023  		return r
 18024  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 18025  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 18026  		return r
 18027  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 18028  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(26)
 18029  		return r
 18030  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 18031  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 18032  		return r
 18033  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 18034  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(6)
 18035  		return r
 18036  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 18037  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 18038  		return r
 18039  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 18040  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(22)
 18041  		return r
 18042  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 18043  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 18044  		return r
 18045  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 18046  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(14)
 18047  		return r
 18048  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 18049  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 18050  		return r
 18051  	}()},
 18052  	{Ffc: func() (r struct{ Ffreq Ush }) {
 18053  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(30)
 18054  		return r
 18055  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 18056  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 18057  		return r
 18058  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 18059  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(1)
 18060  		return r
 18061  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 18062  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 18063  		return r
 18064  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 18065  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(17)
 18066  		return r
 18067  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 18068  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 18069  		return r
 18070  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 18071  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9)
 18072  		return r
 18073  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 18074  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 18075  		return r
 18076  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 18077  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(25)
 18078  		return r
 18079  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 18080  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 18081  		return r
 18082  	}()},
 18083  	{Ffc: func() (r struct{ Ffreq Ush }) {
 18084  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 18085  		return r
 18086  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 18087  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 18088  		return r
 18089  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 18090  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(21)
 18091  		return r
 18092  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 18093  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 18094  		return r
 18095  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 18096  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(13)
 18097  		return r
 18098  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 18099  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 18100  		return r
 18101  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 18102  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(29)
 18103  		return r
 18104  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 18105  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 18106  		return r
 18107  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 18108  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(3)
 18109  		return r
 18110  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 18111  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 18112  		return r
 18113  	}()},
 18114  	{Ffc: func() (r struct{ Ffreq Ush }) {
 18115  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(19)
 18116  		return r
 18117  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 18118  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 18119  		return r
 18120  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 18121  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(11)
 18122  		return r
 18123  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 18124  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 18125  		return r
 18126  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 18127  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(27)
 18128  		return r
 18129  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 18130  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 18131  		return r
 18132  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 18133  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7)
 18134  		return r
 18135  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 18136  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 18137  		return r
 18138  	}()}, {Ffc: func() (r struct{ Ffreq Ush }) {
 18139  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(23)
 18140  		return r
 18141  	}(), Fdl: func() (r struct{ Fdad Ush }) {
 18142  		*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5)
 18143  		return r
 18144  	}()}} /* trees.h:64:21 */
 18145  
 18146  var X_dist_code = [512]Uch{
 18147  	Uch(0), Uch(1), Uch(2), Uch(3), Uch(4), Uch(4), Uch(5), Uch(5), Uch(6), Uch(6), Uch(6), Uch(6), Uch(7), Uch(7), Uch(7), Uch(7), Uch(8), Uch(8), Uch(8), Uch(8),
 18148  	Uch(8), Uch(8), Uch(8), Uch(8), Uch(9), Uch(9), Uch(9), Uch(9), Uch(9), Uch(9), Uch(9), Uch(9), Uch(10), Uch(10), Uch(10), Uch(10), Uch(10), Uch(10), Uch(10), Uch(10),
 18149  	Uch(10), Uch(10), Uch(10), Uch(10), Uch(10), Uch(10), Uch(10), Uch(10), Uch(11), Uch(11), Uch(11), Uch(11), Uch(11), Uch(11), Uch(11), Uch(11), Uch(11), Uch(11), Uch(11), Uch(11),
 18150  	Uch(11), Uch(11), Uch(11), Uch(11), Uch(12), Uch(12), Uch(12), Uch(12), Uch(12), Uch(12), Uch(12), Uch(12), Uch(12), Uch(12), Uch(12), Uch(12), Uch(12), Uch(12), Uch(12), Uch(12),
 18151  	Uch(12), Uch(12), Uch(12), Uch(12), Uch(12), Uch(12), Uch(12), Uch(12), Uch(12), Uch(12), Uch(12), Uch(12), Uch(12), Uch(12), Uch(12), Uch(12), Uch(13), Uch(13), Uch(13), Uch(13),
 18152  	Uch(13), Uch(13), Uch(13), Uch(13), Uch(13), Uch(13), Uch(13), Uch(13), Uch(13), Uch(13), Uch(13), Uch(13), Uch(13), Uch(13), Uch(13), Uch(13), Uch(13), Uch(13), Uch(13), Uch(13),
 18153  	Uch(13), Uch(13), Uch(13), Uch(13), Uch(13), Uch(13), Uch(13), Uch(13), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14),
 18154  	Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14),
 18155  	Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14),
 18156  	Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(14), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15),
 18157  	Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15),
 18158  	Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15),
 18159  	Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(15), Uch(0), Uch(0), Uch(16), Uch(17),
 18160  	Uch(18), Uch(18), Uch(19), Uch(19), Uch(20), Uch(20), Uch(20), Uch(20), Uch(21), Uch(21), Uch(21), Uch(21), Uch(22), Uch(22), Uch(22), Uch(22), Uch(22), Uch(22), Uch(22), Uch(22),
 18161  	Uch(23), Uch(23), Uch(23), Uch(23), Uch(23), Uch(23), Uch(23), Uch(23), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24),
 18162  	Uch(24), Uch(24), Uch(24), Uch(24), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25),
 18163  	Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26),
 18164  	Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27),
 18165  	Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27),
 18166  	Uch(27), Uch(27), Uch(27), Uch(27), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28),
 18167  	Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28),
 18168  	Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28),
 18169  	Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(28), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29),
 18170  	Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29),
 18171  	Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29),
 18172  	Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29),
 18173  } /* trees.h:73:25 */
 18174  
 18175  var X_length_code = [256]Uch{
 18176  	Uch(0), Uch(1), Uch(2), Uch(3), Uch(4), Uch(5), Uch(6), Uch(7), Uch(8), Uch(8), Uch(9), Uch(9), Uch(10), Uch(10), Uch(11), Uch(11), Uch(12), Uch(12), Uch(12), Uch(12),
 18177  	Uch(13), Uch(13), Uch(13), Uch(13), Uch(14), Uch(14), Uch(14), Uch(14), Uch(15), Uch(15), Uch(15), Uch(15), Uch(16), Uch(16), Uch(16), Uch(16), Uch(16), Uch(16), Uch(16), Uch(16),
 18178  	Uch(17), Uch(17), Uch(17), Uch(17), Uch(17), Uch(17), Uch(17), Uch(17), Uch(18), Uch(18), Uch(18), Uch(18), Uch(18), Uch(18), Uch(18), Uch(18), Uch(19), Uch(19), Uch(19), Uch(19),
 18179  	Uch(19), Uch(19), Uch(19), Uch(19), Uch(20), Uch(20), Uch(20), Uch(20), Uch(20), Uch(20), Uch(20), Uch(20), Uch(20), Uch(20), Uch(20), Uch(20), Uch(20), Uch(20), Uch(20), Uch(20),
 18180  	Uch(21), Uch(21), Uch(21), Uch(21), Uch(21), Uch(21), Uch(21), Uch(21), Uch(21), Uch(21), Uch(21), Uch(21), Uch(21), Uch(21), Uch(21), Uch(21), Uch(22), Uch(22), Uch(22), Uch(22),
 18181  	Uch(22), Uch(22), Uch(22), Uch(22), Uch(22), Uch(22), Uch(22), Uch(22), Uch(22), Uch(22), Uch(22), Uch(22), Uch(23), Uch(23), Uch(23), Uch(23), Uch(23), Uch(23), Uch(23), Uch(23),
 18182  	Uch(23), Uch(23), Uch(23), Uch(23), Uch(23), Uch(23), Uch(23), Uch(23), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24),
 18183  	Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24), Uch(24),
 18184  	Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25),
 18185  	Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(25), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26),
 18186  	Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26), Uch(26),
 18187  	Uch(26), Uch(26), Uch(26), Uch(26), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27),
 18188  	Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(27), Uch(28),
 18189  } /* trees.h:102:25 */
 18190  
 18191  var base_length = [29]int32{
 18192  	0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56,
 18193  	64, 80, 96, 112, 128, 160, 192, 224, 0,
 18194  } /* trees.h:118:17 */
 18195  
 18196  var base_dist = [30]int32{
 18197  	0, 1, 2, 3, 4, 6, 8, 12, 16, 24,
 18198  	32, 48, 64, 96, 128, 192, 256, 384, 512, 768,
 18199  	1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576,
 18200  } /* trees.h:123:17 */
 18201  
 18202  var static_l_desc = Static_tree_desc{Fstatic_tree: 0, Fextra_bits: 0, Fextra_base: LITERALS + 1, Felems: LITERALS + 1 + LENGTH_CODES, Fmax_length: MAX_BITS} /* trees.c:125:31 */
 18203  
 18204  var static_d_desc = Static_tree_desc{Fstatic_tree: 0, Fextra_bits: 0, Felems: D_CODES, Fmax_length: MAX_BITS} /* trees.c:128:31 */
 18205  
 18206  var static_bl_desc = Static_tree_desc{Fextra_bits: 0, Felems: BL_CODES, Fmax_length: MAX_BL_BITS} /* trees.c:131:31 */
 18207  
 18208  // Send a code of the given tree. c and tree must not have side effects
 18209  
 18210  // ===========================================================================
 18211  // Output a short LSB first on the stream.
 18212  // IN assertion: there is enough room in pendingBuf.
 18213  
 18214  // ===========================================================================
 18215  // Send a value on a given number of bits.
 18216  // IN assertion: length <= 16 and value fits in length bits.
 18217  
 18218  // the arguments must not have side effects
 18219  
 18220  // ===========================================================================
 18221  // Initialize the various 'constant' tables.
 18222  func tr_static_init(tls *libc.TLS) { /* trees.c:232:12: */
 18223  }
 18224  
 18225  // ===========================================================================
 18226  // Genererate the file trees.h describing the static trees.
 18227  
 18228  // ===========================================================================
 18229  // Initialize the tree data structures for a new zlib stream.
 18230  func X_tr_init(tls *libc.TLS, s uintptr) { /* trees.c:379:20: */
 18231  	tr_static_init(tls)
 18232  
 18233  	(*Deflate_state)(unsafe.Pointer(s)).Fl_desc.Fdyn_tree = s + 212 /* &.dyn_ltree */
 18234  	(*Deflate_state)(unsafe.Pointer(s)).Fl_desc.Fstat_desc = uintptr(unsafe.Pointer(&static_l_desc))
 18235  
 18236  	(*Deflate_state)(unsafe.Pointer(s)).Fd_desc.Fdyn_tree = s + 2504 /* &.dyn_dtree */
 18237  	(*Deflate_state)(unsafe.Pointer(s)).Fd_desc.Fstat_desc = uintptr(unsafe.Pointer(&static_d_desc))
 18238  
 18239  	(*Deflate_state)(unsafe.Pointer(s)).Fbl_desc.Fdyn_tree = s + 2748 /* &.bl_tree */
 18240  	(*Deflate_state)(unsafe.Pointer(s)).Fbl_desc.Fstat_desc = uintptr(unsafe.Pointer(&static_bl_desc))
 18241  
 18242  	(*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(0)
 18243  	(*Deflate_state)(unsafe.Pointer(s)).Fbi_valid = 0
 18244  
 18245  	// Initialize the first block of the first file:
 18246  	init_block(tls, s)
 18247  }
 18248  
 18249  // ===========================================================================
 18250  // Initialize a new block.
 18251  func init_block(tls *libc.TLS, s uintptr) { /* trees.c:407:12: */
 18252  	var n int32 // iterates over tree elements
 18253  
 18254  	// Initialize the trees.
 18255  	for n = 0; n < LITERALS+1+LENGTH_CODES; n++ {
 18256  		*(*Ush)(unsafe.Pointer(s + 212 + uintptr(n)*4)) = Ush(0)
 18257  	}
 18258  	for n = 0; n < D_CODES; n++ {
 18259  		*(*Ush)(unsafe.Pointer(s + 2504 + uintptr(n)*4)) = Ush(0)
 18260  	}
 18261  	for n = 0; n < BL_CODES; n++ {
 18262  		*(*Ush)(unsafe.Pointer(s + 2748 + uintptr(n)*4)) = Ush(0)
 18263  	}
 18264  
 18265  	*(*Ush)(unsafe.Pointer(s + 212 + 256*4)) = Ush(1)
 18266  	(*Deflate_state)(unsafe.Pointer(s)).Fopt_len = libc.AssignPtrUint64(s+5920, uint64(0))
 18267  	(*Deflate_state)(unsafe.Pointer(s)).Flast_lit = libc.AssignPtrUint32(s+5928, UInt(0))
 18268  }
 18269  
 18270  // Index within the heap array of least frequent node in the Huffman tree
 18271  
 18272  // ===========================================================================
 18273  // Remove the smallest element from the heap and recreate the heap with
 18274  // one less element. Updates heap and heap_len.
 18275  
 18276  // ===========================================================================
 18277  // Compares to subtrees, using the tree depth as tie breaker when
 18278  // the subtrees have equal frequency. This minimizes the worst case length.
 18279  
 18280  // ===========================================================================
 18281  // Restore the heap property by moving down the tree starting at node k,
 18282  // exchanging a node with the smallest of its two sons if necessary, stopping
 18283  // when the heap property is re-established (each father smaller than its
 18284  // two sons).
 18285  func pqdownheap(tls *libc.TLS, s uintptr, tree uintptr, k int32) { /* trees.c:451:12: */
 18286  	var v int32 = *(*int32)(unsafe.Pointer(s + 3008 + uintptr(k)*4))
 18287  	var j int32 = k << 1 // left son of k
 18288  	for j <= (*Deflate_state)(unsafe.Pointer(s)).Fheap_len {
 18289  		// Set j to the smallest of the two sons:
 18290  		if j < (*Deflate_state)(unsafe.Pointer(s)).Fheap_len && (int32(*(*Ush)(unsafe.Pointer(tree + uintptr(*(*int32)(unsafe.Pointer(s + 3008 + uintptr(j+1)*4)))*4))) < int32(*(*Ush)(unsafe.Pointer(tree + uintptr(*(*int32)(unsafe.Pointer(s + 3008 + uintptr(j)*4)))*4))) || int32(*(*Ush)(unsafe.Pointer(tree + uintptr(*(*int32)(unsafe.Pointer(s + 3008 + uintptr(j+1)*4)))*4))) == int32(*(*Ush)(unsafe.Pointer(tree + uintptr(*(*int32)(unsafe.Pointer(s + 3008 + uintptr(j)*4)))*4))) && int32(*(*Uch)(unsafe.Pointer(s + 5308 + uintptr(*(*int32)(unsafe.Pointer(s + 3008 + uintptr(j+1)*4)))))) <= int32(*(*Uch)(unsafe.Pointer(s + 5308 + uintptr(*(*int32)(unsafe.Pointer(s + 3008 + uintptr(j)*4))))))) {
 18291  			j++
 18292  		}
 18293  		// Exit if v is smaller than both sons
 18294  		if int32(*(*Ush)(unsafe.Pointer(tree + uintptr(v)*4))) < int32(*(*Ush)(unsafe.Pointer(tree + uintptr(*(*int32)(unsafe.Pointer(s + 3008 + uintptr(j)*4)))*4))) || int32(*(*Ush)(unsafe.Pointer(tree + uintptr(v)*4))) == int32(*(*Ush)(unsafe.Pointer(tree + uintptr(*(*int32)(unsafe.Pointer(s + 3008 + uintptr(j)*4)))*4))) && int32(*(*Uch)(unsafe.Pointer(s + 5308 + uintptr(v)))) <= int32(*(*Uch)(unsafe.Pointer(s + 5308 + uintptr(*(*int32)(unsafe.Pointer(s + 3008 + uintptr(j)*4)))))) {
 18295  			break
 18296  		}
 18297  
 18298  		// Exchange v with the smallest son
 18299  		*(*int32)(unsafe.Pointer(s + 3008 + uintptr(k)*4)) = *(*int32)(unsafe.Pointer(s + 3008 + uintptr(j)*4))
 18300  		k = j
 18301  
 18302  		// And continue down the tree, setting j to the left son of k
 18303  		j <<= 1
 18304  	}
 18305  	*(*int32)(unsafe.Pointer(s + 3008 + uintptr(k)*4)) = v
 18306  }
 18307  
 18308  // ===========================================================================
 18309  // Compute the optimal bit lengths for a tree and update the total bit length
 18310  // for the current block.
 18311  // IN assertion: the fields freq and dad are set, heap[heap_max] and
 18312  //    above are the tree nodes sorted by increasing frequency.
 18313  // OUT assertions: the field len is set to the optimal bit length, the
 18314  //     array bl_count contains the frequencies for each bit length.
 18315  //     The length opt_len is updated; static_len is also updated if stree is
 18316  //     not null.
 18317  func gen_bitlen(tls *libc.TLS, s uintptr, desc uintptr) { /* trees.c:486:12: */
 18318  	var tree uintptr = (*Tree_desc)(unsafe.Pointer(desc)).Fdyn_tree
 18319  	var max_code int32 = (*Tree_desc)(unsafe.Pointer(desc)).Fmax_code
 18320  	var stree uintptr = (*Static_tree_desc)(unsafe.Pointer((*Tree_desc)(unsafe.Pointer(desc)).Fstat_desc)).Fstatic_tree
 18321  	var extra uintptr = (*Static_tree_desc)(unsafe.Pointer((*Tree_desc)(unsafe.Pointer(desc)).Fstat_desc)).Fextra_bits
 18322  	var base int32 = (*Static_tree_desc)(unsafe.Pointer((*Tree_desc)(unsafe.Pointer(desc)).Fstat_desc)).Fextra_base
 18323  	var max_length int32 = (*Static_tree_desc)(unsafe.Pointer((*Tree_desc)(unsafe.Pointer(desc)).Fstat_desc)).Fmax_length
 18324  	var h int32 // heap index
 18325  	var n int32
 18326  	var m int32            // iterate over the tree elements
 18327  	var bits int32         // bit length
 18328  	var xbits int32        // extra bits
 18329  	var f Ush              // frequency
 18330  	var overflow int32 = 0 // number of elements with bit length too large
 18331  
 18332  	for bits = 0; bits <= MAX_BITS; bits++ {
 18333  		*(*Ush)(unsafe.Pointer(s + 2976 + uintptr(bits)*2)) = Ush(0)
 18334  	}
 18335  
 18336  	// In a first pass, compute the optimal bit lengths (which may
 18337  	// overflow in the case of the bit length tree).
 18338  	*(*Ush)(unsafe.Pointer(tree + uintptr(*(*int32)(unsafe.Pointer(s + 3008 + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fheap_max)*4)))*4 + 2)) = Ush(0) // root of the heap
 18339  
 18340  	for h = (*Deflate_state)(unsafe.Pointer(s)).Fheap_max + 1; h < 2*(LITERALS+1+LENGTH_CODES)+1; h++ {
 18341  		n = *(*int32)(unsafe.Pointer(s + 3008 + uintptr(h)*4))
 18342  		bits = int32(*(*Ush)(unsafe.Pointer(tree + uintptr(*(*Ush)(unsafe.Pointer(tree + uintptr(n)*4 + 2)))*4 + 2))) + 1
 18343  		if bits > max_length {
 18344  			bits = max_length
 18345  			overflow++
 18346  		}
 18347  		*(*Ush)(unsafe.Pointer(tree + uintptr(n)*4 + 2)) = Ush(bits)
 18348  		// We overwrite tree[n].Dad which is no longer needed
 18349  
 18350  		if n > max_code {
 18351  			continue
 18352  		} // not a leaf node
 18353  
 18354  		*(*Ush)(unsafe.Pointer(s + 2976 + uintptr(bits)*2))++
 18355  		xbits = 0
 18356  		if n >= base {
 18357  			xbits = *(*Intf)(unsafe.Pointer(extra + uintptr(n-base)*4))
 18358  		}
 18359  		f = *(*Ush)(unsafe.Pointer(tree + uintptr(n)*4))
 18360  		*(*Ulg)(unsafe.Pointer(s + 5912)) += Ulg(f) * Ulg(uint32(bits+xbits))
 18361  		if stree != 0 {
 18362  			*(*Ulg)(unsafe.Pointer(s + 5920)) += Ulg(f) * Ulg(uint32(int32(*(*Ush)(unsafe.Pointer(stree + uintptr(n)*4 + 2)))+xbits))
 18363  		}
 18364  	}
 18365  	if overflow == 0 {
 18366  		return
 18367  	}
 18368  
 18369  	// This happens for example on obj2 and pic of the Calgary corpus
 18370  
 18371  	// Find the first bit length which could increase:
 18372  	for __ccgo := true; __ccgo; __ccgo = overflow > 0 {
 18373  		bits = max_length - 1
 18374  		for int32(*(*Ush)(unsafe.Pointer(s + 2976 + uintptr(bits)*2))) == 0 {
 18375  			bits--
 18376  		}
 18377  		*(*Ush)(unsafe.Pointer(s + 2976 + uintptr(bits)*2))--           // move one leaf down the tree
 18378  		*(*Ush)(unsafe.Pointer(s + 2976 + uintptr(bits+1)*2)) += Ush(2) // move one overflow item as its brother
 18379  		*(*Ush)(unsafe.Pointer(s + 2976 + uintptr(max_length)*2))--
 18380  		// The brother of the overflow item also moves one step up,
 18381  		// but this does not affect bl_count[max_length]
 18382  		overflow = overflow - 2
 18383  	}
 18384  
 18385  	// Now recompute all bit lengths, scanning in increasing frequency.
 18386  	// h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
 18387  	// lengths instead of fixing only the wrong ones. This idea is taken
 18388  	// from 'ar' written by Haruhiko Okumura.)
 18389  	for bits = max_length; bits != 0; bits-- {
 18390  		n = int32(*(*Ush)(unsafe.Pointer(s + 2976 + uintptr(bits)*2)))
 18391  		for n != 0 {
 18392  			m = *(*int32)(unsafe.Pointer(s + 3008 + uintptr(libc.PreDecInt32(&h, 1))*4))
 18393  			if m > max_code {
 18394  				continue
 18395  			}
 18396  			if uint32(*(*Ush)(unsafe.Pointer(tree + uintptr(m)*4 + 2))) != uint32(bits) {
 18397  
 18398  				*(*Ulg)(unsafe.Pointer(s + 5912)) += (Ulg(bits) - Ulg(*(*Ush)(unsafe.Pointer(tree + uintptr(m)*4 + 2)))) * Ulg(*(*Ush)(unsafe.Pointer(tree + uintptr(m)*4)))
 18399  				*(*Ush)(unsafe.Pointer(tree + uintptr(m)*4 + 2)) = Ush(bits)
 18400  			}
 18401  			n--
 18402  		}
 18403  	}
 18404  }
 18405  
 18406  // ===========================================================================
 18407  // Generate the codes for a given tree and bit counts (which need not be
 18408  // optimal).
 18409  // IN assertion: the array bl_count contains the bit length statistics for
 18410  // the given tree and the field len is set for all tree elements.
 18411  // OUT assertion: the field code is set for all tree elements of non
 18412  //     zero code length.
 18413  func gen_codes(tls *libc.TLS, tree uintptr, max_code int32, bl_count uintptr) { /* trees.c:572:12: */
 18414  	bp := tls.Alloc(32)
 18415  	defer tls.Free(32)
 18416  
 18417  	// var next_code [16]Ush at bp, 32
 18418  	// next code value for each bit length
 18419  	var code uint32 = uint32(0) // running code value
 18420  	var bits int32              // bit index
 18421  	var n int32                 // code index
 18422  
 18423  	// The distribution counts are first used to generate the code values
 18424  	// without bit reversal.
 18425  	for bits = 1; bits <= MAX_BITS; bits++ {
 18426  		code = (code + uint32(*(*Ushf)(unsafe.Pointer(bl_count + uintptr(bits-1)*2)))) << 1
 18427  		*(*Ush)(unsafe.Pointer(bp + uintptr(bits)*2)) = Ush(code)
 18428  	}
 18429  	// Check that the bit counts in bl_count are consistent. The last code
 18430  	// must be all ones.
 18431  
 18432  	for n = 0; n <= max_code; n++ {
 18433  		var len int32 = int32(*(*Ush)(unsafe.Pointer(tree + uintptr(n)*4 + 2)))
 18434  		if len == 0 {
 18435  			continue
 18436  		}
 18437  		// Now reverse the bits
 18438  		*(*Ush)(unsafe.Pointer(tree + uintptr(n)*4)) = Ush(bi_reverse(tls, uint32(libc.PostIncUint16(&*(*Ush)(unsafe.Pointer(bp + uintptr(len)*2)), 1)), len))
 18439  
 18440  	}
 18441  }
 18442  
 18443  // ===========================================================================
 18444  // Construct one Huffman tree and assigns the code bit strings and lengths.
 18445  // Update the total bit length for the current block.
 18446  // IN assertion: the field freq is set for all tree elements.
 18447  // OUT assertions: the fields len and code are set to the optimal bit length
 18448  //     and corresponding code. The length opt_len is updated; static_len is
 18449  //     also updated if stree is not null. The field max_code is set.
 18450  func build_tree(tls *libc.TLS, s uintptr, desc uintptr) { /* trees.c:615:12: */
 18451  	var tree uintptr = (*Tree_desc)(unsafe.Pointer(desc)).Fdyn_tree
 18452  	var stree uintptr = (*Static_tree_desc)(unsafe.Pointer((*Tree_desc)(unsafe.Pointer(desc)).Fstat_desc)).Fstatic_tree
 18453  	var elems int32 = (*Static_tree_desc)(unsafe.Pointer((*Tree_desc)(unsafe.Pointer(desc)).Fstat_desc)).Felems
 18454  	var n int32
 18455  	var m int32             // iterate over heap elements
 18456  	var max_code int32 = -1 // largest code with non zero frequency
 18457  	var node int32          // new node being created
 18458  
 18459  	// Construct the initial heap, with least frequent element in
 18460  	// heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
 18461  	// heap[0] is not used.
 18462  	(*Deflate_state)(unsafe.Pointer(s)).Fheap_len = 0
 18463  	(*Deflate_state)(unsafe.Pointer(s)).Fheap_max = 2*(LITERALS+1+LENGTH_CODES) + 1
 18464  
 18465  	for n = 0; n < elems; n++ {
 18466  		if int32(*(*Ush)(unsafe.Pointer(tree + uintptr(n)*4))) != 0 {
 18467  			*(*int32)(unsafe.Pointer(s + 3008 + uintptr(libc.PreIncInt32(&(*Deflate_state)(unsafe.Pointer(s)).Fheap_len, 1))*4)) = libc.AssignInt32(&max_code, n)
 18468  			*(*Uch)(unsafe.Pointer(s + 5308 + uintptr(n))) = Uch(0)
 18469  		} else {
 18470  			*(*Ush)(unsafe.Pointer(tree + uintptr(n)*4 + 2)) = Ush(0)
 18471  		}
 18472  	}
 18473  
 18474  	// The pkzip format requires that at least one distance code exists,
 18475  	// and that at least one bit should be sent even if there is only one
 18476  	// possible code. So to avoid special checks later on we force at least
 18477  	// two codes of non zero frequency.
 18478  	for (*Deflate_state)(unsafe.Pointer(s)).Fheap_len < 2 {
 18479  		node = libc.AssignPtrInt32(s+3008+uintptr(libc.PreIncInt32(&(*Deflate_state)(unsafe.Pointer(s)).Fheap_len, 1))*4, func() int32 {
 18480  			if max_code < 2 {
 18481  				return libc.PreIncInt32(&max_code, 1)
 18482  			}
 18483  			return 0
 18484  		}())
 18485  		*(*Ush)(unsafe.Pointer(tree + uintptr(node)*4)) = Ush(1)
 18486  		*(*Uch)(unsafe.Pointer(s + 5308 + uintptr(node))) = Uch(0)
 18487  		(*Deflate_state)(unsafe.Pointer(s)).Fopt_len--
 18488  		if stree != 0 {
 18489  			*(*Ulg)(unsafe.Pointer(s + 5920)) -= Ulg(*(*Ush)(unsafe.Pointer(stree + uintptr(node)*4 + 2)))
 18490  		}
 18491  		// node is 0 or 1 so it does not have extra bits
 18492  	}
 18493  	(*Tree_desc)(unsafe.Pointer(desc)).Fmax_code = max_code
 18494  
 18495  	// The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
 18496  	// establish sub-heaps of increasing lengths:
 18497  	for n = (*Deflate_state)(unsafe.Pointer(s)).Fheap_len / 2; n >= 1; n-- {
 18498  		pqdownheap(tls, s, tree, n)
 18499  	}
 18500  
 18501  	// Construct the Huffman tree by repeatedly combining the least two
 18502  	// frequent nodes.
 18503  	node = elems // next internal node of the tree
 18504  	for __ccgo := true; __ccgo; __ccgo = (*Deflate_state)(unsafe.Pointer(s)).Fheap_len >= 2 {
 18505  		{
 18506  			n = *(*int32)(unsafe.Pointer(s + 3008 + 1*4))
 18507  			*(*int32)(unsafe.Pointer(s + 3008 + 1*4)) = *(*int32)(unsafe.Pointer(s + 3008 + uintptr(libc.PostDecInt32(&(*Deflate_state)(unsafe.Pointer(s)).Fheap_len, 1))*4))
 18508  			pqdownheap(tls, s, tree, SMALLEST)
 18509  		}
 18510  		// n = node of least frequency
 18511  		m = *(*int32)(unsafe.Pointer(s + 3008 + 1*4)) // m = node of next least frequency
 18512  
 18513  		*(*int32)(unsafe.Pointer(s + 3008 + uintptr(libc.PreDecInt32(&(*Deflate_state)(unsafe.Pointer(s)).Fheap_max, 1))*4)) = n // keep the nodes sorted by frequency
 18514  		*(*int32)(unsafe.Pointer(s + 3008 + uintptr(libc.PreDecInt32(&(*Deflate_state)(unsafe.Pointer(s)).Fheap_max, 1))*4)) = m
 18515  
 18516  		// Create a new node father of n and m
 18517  		*(*Ush)(unsafe.Pointer(tree + uintptr(node)*4)) = Ush(int32(*(*Ush)(unsafe.Pointer(tree + uintptr(n)*4))) + int32(*(*Ush)(unsafe.Pointer(tree + uintptr(m)*4))))
 18518  		*(*Uch)(unsafe.Pointer(s + 5308 + uintptr(node))) = Uch(func() int32 {
 18519  			if int32(*(*Uch)(unsafe.Pointer(s + 5308 + uintptr(n)))) >= int32(*(*Uch)(unsafe.Pointer(s + 5308 + uintptr(m)))) {
 18520  				return int32(*(*Uch)(unsafe.Pointer(s + 5308 + uintptr(n))))
 18521  			}
 18522  			return int32(*(*Uch)(unsafe.Pointer(s + 5308 + uintptr(m))))
 18523  		}() + 1)
 18524  		*(*Ush)(unsafe.Pointer(tree + uintptr(n)*4 + 2)) = libc.AssignPtrUint16(tree+uintptr(m)*4+2, Ush(node))
 18525  		// and insert the new node in the heap
 18526  		*(*int32)(unsafe.Pointer(s + 3008 + 1*4)) = libc.PostIncInt32(&node, 1)
 18527  		pqdownheap(tls, s, tree, SMALLEST)
 18528  
 18529  	}
 18530  
 18531  	*(*int32)(unsafe.Pointer(s + 3008 + uintptr(libc.PreDecInt32(&(*Deflate_state)(unsafe.Pointer(s)).Fheap_max, 1))*4)) = *(*int32)(unsafe.Pointer(s + 3008 + 1*4))
 18532  
 18533  	// At this point, the fields freq and dad are set. We can now
 18534  	// generate the bit lengths.
 18535  	gen_bitlen(tls, s, desc)
 18536  
 18537  	// The field len is now set, we can generate the bit codes
 18538  	gen_codes(tls, tree, max_code, s+2976)
 18539  }
 18540  
 18541  // ===========================================================================
 18542  // Scan a literal or distance tree to determine the frequencies of the codes
 18543  // in the bit length tree.
 18544  func scan_tree(tls *libc.TLS, s uintptr, tree uintptr, max_code int32) { /* trees.c:703:12: */
 18545  	var n int32                                                  // iterates over all tree elements
 18546  	var prevlen int32 = -1                                       // last emitted length
 18547  	var curlen int32                                             // length of current code
 18548  	var nextlen int32 = int32(*(*Ush)(unsafe.Pointer(tree + 2))) // length of next code
 18549  	var count int32 = 0                                          // repeat count of the current code
 18550  	var max_count int32 = 7                                      // max repeat count
 18551  	var min_count int32 = 4                                      // min repeat count
 18552  
 18553  	if nextlen == 0 {
 18554  		max_count = 138
 18555  		min_count = 3
 18556  	}
 18557  	*(*Ush)(unsafe.Pointer(tree + uintptr(max_code+1)*4 + 2)) = Ush(0xffff) // guard
 18558  
 18559  	for n = 0; n <= max_code; n++ {
 18560  		curlen = nextlen
 18561  		nextlen = int32(*(*Ush)(unsafe.Pointer(tree + uintptr(n+1)*4 + 2)))
 18562  		if libc.PreIncInt32(&count, 1) < max_count && curlen == nextlen {
 18563  			continue
 18564  		} else if count < min_count {
 18565  			*(*Ush)(unsafe.Pointer(s + 2748 + uintptr(curlen)*4)) += Ush(count)
 18566  		} else if curlen != 0 {
 18567  			if curlen != prevlen {
 18568  				*(*Ush)(unsafe.Pointer(s + 2748 + uintptr(curlen)*4))++
 18569  			}
 18570  			*(*Ush)(unsafe.Pointer(s + 2748 + 16*4))++
 18571  		} else if count <= 10 {
 18572  			*(*Ush)(unsafe.Pointer(s + 2748 + 17*4))++
 18573  		} else {
 18574  			*(*Ush)(unsafe.Pointer(s + 2748 + 18*4))++
 18575  		}
 18576  		count = 0
 18577  		prevlen = curlen
 18578  		if nextlen == 0 {
 18579  			max_count = 138
 18580  			min_count = 3
 18581  		} else if curlen == nextlen {
 18582  			max_count = 6
 18583  			min_count = 3
 18584  		} else {
 18585  			max_count = 7
 18586  			min_count = 4
 18587  		}
 18588  	}
 18589  }
 18590  
 18591  // ===========================================================================
 18592  // Send a literal or distance tree in compressed form, using the codes in
 18593  // bl_tree.
 18594  func send_tree(tls *libc.TLS, s uintptr, tree uintptr, max_code int32) { /* trees.c:748:12: */
 18595  	var n int32                                                  // iterates over all tree elements
 18596  	var prevlen int32 = -1                                       // last emitted length
 18597  	var curlen int32                                             // length of current code
 18598  	var nextlen int32 = int32(*(*Ush)(unsafe.Pointer(tree + 2))) // length of next code
 18599  	var count int32 = 0                                          // repeat count of the current code
 18600  	var max_count int32 = 7                                      // max repeat count
 18601  	var min_count int32 = 4                                      // min repeat count
 18602  
 18603  	/* tree[max_code+1].Len = -1; */ // guard already set
 18604  	if nextlen == 0 {
 18605  		max_count = 138
 18606  		min_count = 3
 18607  	}
 18608  
 18609  	for n = 0; n <= max_code; n++ {
 18610  		curlen = nextlen
 18611  		nextlen = int32(*(*Ush)(unsafe.Pointer(tree + uintptr(n+1)*4 + 2)))
 18612  		if libc.PreIncInt32(&count, 1) < max_count && curlen == nextlen {
 18613  			continue
 18614  		} else if count < min_count {
 18615  			for __ccgo := true; __ccgo; __ccgo = libc.PreDecInt32(&count, 1) != 0 {
 18616  				{
 18617  					var len int32 = int32(*(*Ush)(unsafe.Pointer(s + 2748 + uintptr(curlen)*4 + 2)))
 18618  					if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > Buf_size-len {
 18619  						var val int32 = int32(*(*Ush)(unsafe.Pointer(s + 2748 + uintptr(curlen)*4)))
 18620  						*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 18621  						{
 18622  							{
 18623  								*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) & 0xff)
 18624  							}
 18625  							{
 18626  								*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) >> 8)
 18627  							}
 18628  
 18629  						}
 18630  						(*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))
 18631  						*(*int32)(unsafe.Pointer(s + 5940)) += len - Buf_size
 18632  					} else {
 18633  						*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(*(*Ush)(unsafe.Pointer(s + 2748 + uintptr(curlen)*4))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 18634  						*(*int32)(unsafe.Pointer(s + 5940)) += len
 18635  					}
 18636  				}
 18637  			}
 18638  
 18639  		} else if curlen != 0 {
 18640  			if curlen != prevlen {
 18641  				{
 18642  					var len int32 = int32(*(*Ush)(unsafe.Pointer(s + 2748 + uintptr(curlen)*4 + 2)))
 18643  					if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > Buf_size-len {
 18644  						var val int32 = int32(*(*Ush)(unsafe.Pointer(s + 2748 + uintptr(curlen)*4)))
 18645  						*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 18646  						{
 18647  							{
 18648  								*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) & 0xff)
 18649  							}
 18650  							{
 18651  								*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) >> 8)
 18652  							}
 18653  
 18654  						}
 18655  						(*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))
 18656  						*(*int32)(unsafe.Pointer(s + 5940)) += len - Buf_size
 18657  					} else {
 18658  						*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(*(*Ush)(unsafe.Pointer(s + 2748 + uintptr(curlen)*4))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 18659  						*(*int32)(unsafe.Pointer(s + 5940)) += len
 18660  					}
 18661  				}
 18662  				count--
 18663  			}
 18664  
 18665  			{
 18666  				var len int32 = int32(*(*Ush)(unsafe.Pointer(s + 2748 + 16*4 + 2)))
 18667  				if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > Buf_size-len {
 18668  					var val int32 = int32(*(*Ush)(unsafe.Pointer(s + 2748 + 16*4)))
 18669  					*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 18670  					{
 18671  						{
 18672  							*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) & 0xff)
 18673  						}
 18674  						{
 18675  							*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) >> 8)
 18676  						}
 18677  
 18678  					}
 18679  					(*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))
 18680  					*(*int32)(unsafe.Pointer(s + 5940)) += len - Buf_size
 18681  				} else {
 18682  					*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(*(*Ush)(unsafe.Pointer(s + 2748 + 16*4))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 18683  					*(*int32)(unsafe.Pointer(s + 5940)) += len
 18684  				}
 18685  			}
 18686  			{
 18687  				var len int32 = 2
 18688  				if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > Buf_size-len {
 18689  					var val int32 = count - 3
 18690  					*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 18691  					{
 18692  						{
 18693  							*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) & 0xff)
 18694  						}
 18695  						{
 18696  							*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) >> 8)
 18697  						}
 18698  
 18699  					}
 18700  					(*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))
 18701  					*(*int32)(unsafe.Pointer(s + 5940)) += len - Buf_size
 18702  				} else {
 18703  					*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(count-3)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 18704  					*(*int32)(unsafe.Pointer(s + 5940)) += len
 18705  				}
 18706  			}
 18707  
 18708  		} else if count <= 10 {
 18709  			{
 18710  				var len int32 = int32(*(*Ush)(unsafe.Pointer(s + 2748 + 17*4 + 2)))
 18711  				if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > Buf_size-len {
 18712  					var val int32 = int32(*(*Ush)(unsafe.Pointer(s + 2748 + 17*4)))
 18713  					*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 18714  					{
 18715  						{
 18716  							*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) & 0xff)
 18717  						}
 18718  						{
 18719  							*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) >> 8)
 18720  						}
 18721  
 18722  					}
 18723  					(*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))
 18724  					*(*int32)(unsafe.Pointer(s + 5940)) += len - Buf_size
 18725  				} else {
 18726  					*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(*(*Ush)(unsafe.Pointer(s + 2748 + 17*4))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 18727  					*(*int32)(unsafe.Pointer(s + 5940)) += len
 18728  				}
 18729  			}
 18730  			{
 18731  				var len int32 = 3
 18732  				if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > Buf_size-len {
 18733  					var val int32 = count - 3
 18734  					*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 18735  					{
 18736  						{
 18737  							*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) & 0xff)
 18738  						}
 18739  						{
 18740  							*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) >> 8)
 18741  						}
 18742  
 18743  					}
 18744  					(*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))
 18745  					*(*int32)(unsafe.Pointer(s + 5940)) += len - Buf_size
 18746  				} else {
 18747  					*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(count-3)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 18748  					*(*int32)(unsafe.Pointer(s + 5940)) += len
 18749  				}
 18750  			}
 18751  
 18752  		} else {
 18753  			{
 18754  				var len int32 = int32(*(*Ush)(unsafe.Pointer(s + 2748 + 18*4 + 2)))
 18755  				if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > Buf_size-len {
 18756  					var val int32 = int32(*(*Ush)(unsafe.Pointer(s + 2748 + 18*4)))
 18757  					*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 18758  					{
 18759  						{
 18760  							*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) & 0xff)
 18761  						}
 18762  						{
 18763  							*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) >> 8)
 18764  						}
 18765  
 18766  					}
 18767  					(*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))
 18768  					*(*int32)(unsafe.Pointer(s + 5940)) += len - Buf_size
 18769  				} else {
 18770  					*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(*(*Ush)(unsafe.Pointer(s + 2748 + 18*4))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 18771  					*(*int32)(unsafe.Pointer(s + 5940)) += len
 18772  				}
 18773  			}
 18774  			{
 18775  				var len int32 = 7
 18776  				if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > Buf_size-len {
 18777  					var val int32 = count - 11
 18778  					*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 18779  					{
 18780  						{
 18781  							*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) & 0xff)
 18782  						}
 18783  						{
 18784  							*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) >> 8)
 18785  						}
 18786  
 18787  					}
 18788  					(*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))
 18789  					*(*int32)(unsafe.Pointer(s + 5940)) += len - Buf_size
 18790  				} else {
 18791  					*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(count-11)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 18792  					*(*int32)(unsafe.Pointer(s + 5940)) += len
 18793  				}
 18794  			}
 18795  
 18796  		}
 18797  		count = 0
 18798  		prevlen = curlen
 18799  		if nextlen == 0 {
 18800  			max_count = 138
 18801  			min_count = 3
 18802  		} else if curlen == nextlen {
 18803  			max_count = 6
 18804  			min_count = 3
 18805  		} else {
 18806  			max_count = 7
 18807  			min_count = 4
 18808  		}
 18809  	}
 18810  }
 18811  
 18812  // ===========================================================================
 18813  // Construct the Huffman tree for the bit lengths and return the index in
 18814  // bl_order of the last bit length code to send.
 18815  func build_bl_tree(tls *libc.TLS, s uintptr) int32 { /* trees.c:799:11: */
 18816  	var max_blindex int32 // index of last bit length code of non zero freq
 18817  
 18818  	// Determine the bit length frequencies for literal and distance trees
 18819  	scan_tree(tls, s, s+212 /* &.dyn_ltree */, (*Deflate_state)(unsafe.Pointer(s)).Fl_desc.Fmax_code)
 18820  	scan_tree(tls, s, s+2504 /* &.dyn_dtree */, (*Deflate_state)(unsafe.Pointer(s)).Fd_desc.Fmax_code)
 18821  
 18822  	// Build the bit length tree:
 18823  	build_tree(tls, s, s+2952)
 18824  	// opt_len now includes the length of the tree representations, except
 18825  	// the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
 18826  
 18827  	// Determine the number of bit length codes to send. The pkzip format
 18828  	// requires that at least 4 bit length codes be sent. (appnote.txt says
 18829  	// 3 but the actual value used is 4.)
 18830  	for max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex-- {
 18831  		if int32(*(*Ush)(unsafe.Pointer(s + 2748 + uintptr(bl_order[max_blindex])*4 + 2))) != 0 {
 18832  			break
 18833  		}
 18834  	}
 18835  	// Update opt_len to include the bit length tree and counts
 18836  	*(*Ulg)(unsafe.Pointer(s + 5912)) += uint64(3)*(Ulg(max_blindex)+uint64(1)) + uint64(5) + uint64(5) + uint64(4)
 18837  
 18838  	return max_blindex
 18839  }
 18840  
 18841  // ===========================================================================
 18842  // Send the header for a block using dynamic Huffman trees: the counts, the
 18843  // lengths of the bit length codes, the literal tree and the distance tree.
 18844  // IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
 18845  func send_all_trees(tls *libc.TLS, s uintptr, lcodes int32, dcodes int32, blcodes int32) { /* trees.c:834:12: */
 18846  	var rank int32 // index in bl_order
 18847  
 18848  	{
 18849  		var len int32 = 5
 18850  		if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > Buf_size-len {
 18851  			var val int32 = lcodes - 257
 18852  			*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 18853  			{
 18854  				{
 18855  					*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) & 0xff)
 18856  				}
 18857  				{
 18858  					*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) >> 8)
 18859  				}
 18860  
 18861  			}
 18862  			(*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))
 18863  			*(*int32)(unsafe.Pointer(s + 5940)) += len - Buf_size
 18864  		} else {
 18865  			*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(lcodes-257)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 18866  			*(*int32)(unsafe.Pointer(s + 5940)) += len
 18867  		}
 18868  	}
 18869  	/* not +255 as stated in appnote.txt */
 18870  	{
 18871  		var len int32 = 5
 18872  		if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > Buf_size-len {
 18873  			var val int32 = dcodes - 1
 18874  			*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 18875  			{
 18876  				{
 18877  					*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) & 0xff)
 18878  				}
 18879  				{
 18880  					*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) >> 8)
 18881  				}
 18882  
 18883  			}
 18884  			(*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))
 18885  			*(*int32)(unsafe.Pointer(s + 5940)) += len - Buf_size
 18886  		} else {
 18887  			*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(dcodes-1)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 18888  			*(*int32)(unsafe.Pointer(s + 5940)) += len
 18889  		}
 18890  	}
 18891  
 18892  	{
 18893  		var len int32 = 4
 18894  		if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > Buf_size-len {
 18895  			var val int32 = blcodes - 4
 18896  			*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 18897  			{
 18898  				{
 18899  					*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) & 0xff)
 18900  				}
 18901  				{
 18902  					*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) >> 8)
 18903  				}
 18904  
 18905  			}
 18906  			(*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))
 18907  			*(*int32)(unsafe.Pointer(s + 5940)) += len - Buf_size
 18908  		} else {
 18909  			*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(blcodes-4)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 18910  			*(*int32)(unsafe.Pointer(s + 5940)) += len
 18911  		}
 18912  	}
 18913  	// not -3 as stated in appnote.txt
 18914  	for rank = 0; rank < blcodes; rank++ {
 18915  
 18916  		{
 18917  			var len int32 = 3
 18918  			if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > Buf_size-len {
 18919  				var val int32 = int32(*(*Ush)(unsafe.Pointer(s + 2748 + uintptr(bl_order[rank])*4 + 2)))
 18920  				*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 18921  				{
 18922  					{
 18923  						*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) & 0xff)
 18924  					}
 18925  					{
 18926  						*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) >> 8)
 18927  					}
 18928  
 18929  				}
 18930  				(*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))
 18931  				*(*int32)(unsafe.Pointer(s + 5940)) += len - Buf_size
 18932  			} else {
 18933  				*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(*(*Ush)(unsafe.Pointer(s + 2748 + uintptr(bl_order[rank])*4 + 2))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 18934  				*(*int32)(unsafe.Pointer(s + 5940)) += len
 18935  			}
 18936  		}
 18937  
 18938  	}
 18939  
 18940  	send_tree(tls, s, s+212 /* &.dyn_ltree */, lcodes-1) // literal tree
 18941  
 18942  	send_tree(tls, s, s+2504 /* &.dyn_dtree */, dcodes-1) // distance tree
 18943  
 18944  }
 18945  
 18946  // ===========================================================================
 18947  // Send a stored block
 18948  func X_tr_stored_block(tls *libc.TLS, s uintptr, buf uintptr, stored_len Ulg, last int32) { /* trees.c:863:20: */
 18949  	{
 18950  		var len int32 = 3
 18951  		if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > Buf_size-len {
 18952  			var val int32 = int32(STORED_BLOCK)<<1 + last
 18953  			*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 18954  			{
 18955  				{
 18956  					*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) & 0xff)
 18957  				}
 18958  				{
 18959  					*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) >> 8)
 18960  				}
 18961  
 18962  			}
 18963  			(*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))
 18964  			*(*int32)(unsafe.Pointer(s + 5940)) += len - Buf_size
 18965  		} else {
 18966  			*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(int32(STORED_BLOCK)<<1+last)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 18967  			*(*int32)(unsafe.Pointer(s + 5940)) += len
 18968  		}
 18969  	}
 18970  	// send block type
 18971  	bi_windup(tls, s) /* align on byte boundary */
 18972  	{
 18973  		{
 18974  			*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32(Ush(stored_len)) & 0xff)
 18975  		}
 18976  		{
 18977  			*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32(Ush(stored_len)) >> 8)
 18978  		}
 18979  
 18980  	}
 18981  
 18982  	{
 18983  		{
 18984  			*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32(Ush(^stored_len)) & 0xff)
 18985  		}
 18986  		{
 18987  			*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32(Ush(^stored_len)) >> 8)
 18988  		}
 18989  
 18990  	}
 18991  
 18992  	libc.Xmemcpy(tls, (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf+uintptr((*Deflate_state)(unsafe.Pointer(s)).Fpending), buf, stored_len)
 18993  	*(*Ulg)(unsafe.Pointer(s + 40)) += stored_len
 18994  }
 18995  
 18996  // ===========================================================================
 18997  // Flush the bits in the bit buffer to pending output (leaves at most 7 bits)
 18998  func X_tr_flush_bits(tls *libc.TLS, s uintptr) { /* trees.c:886:20: */
 18999  	bi_flush(tls, s)
 19000  }
 19001  
 19002  // ===========================================================================
 19003  // Send one empty static block to give enough lookahead for inflate.
 19004  // This takes 10 bits, of which 7 may remain in the bit buffer.
 19005  func X_tr_align(tls *libc.TLS, s uintptr) { /* trees.c:896:20: */
 19006  	{
 19007  		var len int32 = 3
 19008  		if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > Buf_size-len {
 19009  			var val int32 = int32(STATIC_TREES) << 1
 19010  			*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 19011  			{
 19012  				{
 19013  					*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) & 0xff)
 19014  				}
 19015  				{
 19016  					*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) >> 8)
 19017  				}
 19018  
 19019  			}
 19020  			(*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))
 19021  			*(*int32)(unsafe.Pointer(s + 5940)) += len - Buf_size
 19022  		} else {
 19023  			*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(int32(Ush(int32(STATIC_TREES)<<1))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 19024  			*(*int32)(unsafe.Pointer(s + 5940)) += len
 19025  		}
 19026  	}
 19027  
 19028  	{
 19029  		var len int32 = int32(*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&static_ltree)) + 256*4 + 2)))
 19030  		if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > Buf_size-len {
 19031  			var val int32 = int32(*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&static_ltree)) + 256*4)))
 19032  			*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 19033  			{
 19034  				{
 19035  					*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) & 0xff)
 19036  				}
 19037  				{
 19038  					*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) >> 8)
 19039  				}
 19040  
 19041  			}
 19042  			(*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))
 19043  			*(*int32)(unsafe.Pointer(s + 5940)) += len - Buf_size
 19044  		} else {
 19045  			*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&static_ltree)) + 256*4))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 19046  			*(*int32)(unsafe.Pointer(s + 5940)) += len
 19047  		}
 19048  	}
 19049  
 19050  	bi_flush(tls, s)
 19051  }
 19052  
 19053  // ===========================================================================
 19054  // Determine the best encoding for the current block: dynamic trees, static
 19055  // trees or store, and write out the encoded block.
 19056  func X_tr_flush_block(tls *libc.TLS, s uintptr, buf uintptr, stored_len Ulg, last int32) { /* trees.c:911:20: */
 19057  	var opt_lenb Ulg
 19058  	var static_lenb Ulg       // opt_len and static_len in bytes
 19059  	var max_blindex int32 = 0 // index of last bit length code of non zero freq
 19060  
 19061  	// Build the Huffman trees unless a stored block is forced
 19062  	if (*Deflate_state)(unsafe.Pointer(s)).Flevel > 0 {
 19063  
 19064  		// Check if the file is binary or text
 19065  		if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Fdata_type == Z_UNKNOWN {
 19066  			(*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Fdata_type = detect_data_type(tls, s)
 19067  		}
 19068  
 19069  		// Construct the literal and distance trees
 19070  		build_tree(tls, s, s+2904)
 19071  
 19072  		build_tree(tls, s, s+2928)
 19073  
 19074  		// At this point, opt_len and static_len are the total bit lengths of
 19075  		// the compressed block data, excluding the tree representations.
 19076  
 19077  		// Build the bit length tree for the above two trees, and get the index
 19078  		// in bl_order of the last bit length code to send.
 19079  		max_blindex = build_bl_tree(tls, s)
 19080  
 19081  		// Determine the best encoding. Compute the block lengths in bytes.
 19082  		opt_lenb = ((*Deflate_state)(unsafe.Pointer(s)).Fopt_len + uint64(3) + uint64(7)) >> 3
 19083  		static_lenb = ((*Deflate_state)(unsafe.Pointer(s)).Fstatic_len + uint64(3) + uint64(7)) >> 3
 19084  
 19085  		if static_lenb <= opt_lenb {
 19086  			opt_lenb = static_lenb
 19087  		}
 19088  
 19089  	} else {
 19090  
 19091  		opt_lenb = libc.AssignUint64(&static_lenb, stored_len+uint64(5)) // force a stored block
 19092  	}
 19093  
 19094  	if stored_len+uint64(4) <= opt_lenb && buf != uintptr(0) {
 19095  		// 4: two words for the lengths
 19096  		// The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
 19097  		// Otherwise we can't have processed more than WSIZE input bytes since
 19098  		// the last block flush, because compression would have been
 19099  		// successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
 19100  		// transform a block into a stored block.
 19101  		X_tr_stored_block(tls, s, buf, stored_len, last)
 19102  
 19103  	} else if (*Deflate_state)(unsafe.Pointer(s)).Fstrategy == Z_FIXED || static_lenb == opt_lenb {
 19104  		{
 19105  			var len int32 = 3
 19106  			if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > Buf_size-len {
 19107  				var val int32 = int32(STATIC_TREES)<<1 + last
 19108  				*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 19109  				{
 19110  					{
 19111  						*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) & 0xff)
 19112  					}
 19113  					{
 19114  						*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) >> 8)
 19115  					}
 19116  
 19117  				}
 19118  				(*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))
 19119  				*(*int32)(unsafe.Pointer(s + 5940)) += len - Buf_size
 19120  			} else {
 19121  				*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(int32(STATIC_TREES)<<1+last)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 19122  				*(*int32)(unsafe.Pointer(s + 5940)) += len
 19123  			}
 19124  		}
 19125  
 19126  		compress_block(tls, s, uintptr(uintptr(unsafe.Pointer(&static_ltree))),
 19127  			uintptr(uintptr(unsafe.Pointer(&static_dtree))))
 19128  	} else {
 19129  		{
 19130  			var len int32 = 3
 19131  			if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > Buf_size-len {
 19132  				var val int32 = int32(DYN_TREES)<<1 + last
 19133  				*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 19134  				{
 19135  					{
 19136  						*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) & 0xff)
 19137  					}
 19138  					{
 19139  						*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) >> 8)
 19140  					}
 19141  
 19142  				}
 19143  				(*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))
 19144  				*(*int32)(unsafe.Pointer(s + 5940)) += len - Buf_size
 19145  			} else {
 19146  				*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(int32(DYN_TREES)<<1+last)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 19147  				*(*int32)(unsafe.Pointer(s + 5940)) += len
 19148  			}
 19149  		}
 19150  
 19151  		send_all_trees(tls, s, (*Deflate_state)(unsafe.Pointer(s)).Fl_desc.Fmax_code+1, (*Deflate_state)(unsafe.Pointer(s)).Fd_desc.Fmax_code+1,
 19152  			max_blindex+1)
 19153  		compress_block(tls, s, s+212, /* &.dyn_ltree */
 19154  			s+2504 /* &.dyn_dtree */)
 19155  	}
 19156  
 19157  	// The above check is made mod 2^32, for files larger than 512 MB
 19158  	// and uLong implemented on 32 bits.
 19159  	init_block(tls, s)
 19160  
 19161  	if last != 0 {
 19162  		bi_windup(tls, s)
 19163  	}
 19164  
 19165  }
 19166  
 19167  // ===========================================================================
 19168  // Save the match info and tally the frequency counts. Return true if
 19169  // the current block must be flushed.
 19170  func X_tr_tally(tls *libc.TLS, s uintptr, dist uint32, lc uint32) int32 { /* trees.c:1014:19: */
 19171  	*(*Ushf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fd_buf + uintptr((*Deflate_state)(unsafe.Pointer(s)).Flast_lit)*2)) = Ush(dist)
 19172  	*(*Uchf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fl_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Flast_lit, 1)))) = Uch(lc)
 19173  	if dist == uint32(0) {
 19174  		// lc is the unmatched char
 19175  		*(*Ush)(unsafe.Pointer(s + 212 + uintptr(lc)*4))++
 19176  	} else {
 19177  		(*Deflate_state)(unsafe.Pointer(s)).Fmatches++
 19178  		// Here, lc is the match length - MIN_MATCH
 19179  		dist-- // dist = match distance - 1
 19180  
 19181  		*(*Ush)(unsafe.Pointer(s + 212 + uintptr(int32(X_length_code[lc])+LITERALS+1)*4))++
 19182  		*(*Ush)(unsafe.Pointer(s + 2504 + uintptr(func() int32 {
 19183  			if dist < uint32(256) {
 19184  				return int32(X_dist_code[dist])
 19185  			}
 19186  			return int32(X_dist_code[uint32(256)+dist>>7])
 19187  		}())*4))++
 19188  	}
 19189  
 19190  	return libc.Bool32((*Deflate_state)(unsafe.Pointer(s)).Flast_lit == (*Deflate_state)(unsafe.Pointer(s)).Flit_bufsize-UInt(1))
 19191  	// We avoid equality with lit_bufsize because of wraparound at 64K
 19192  	// on 16 bit machines and because stored blocks are restricted to
 19193  	// 64K-1 bytes.
 19194  }
 19195  
 19196  // ===========================================================================
 19197  // Send the block data compressed using the given Huffman trees
 19198  func compress_block(tls *libc.TLS, s uintptr, ltree uintptr, dtree uintptr) { /* trees.c:1064:12: */
 19199  	var dist uint32           // distance of matched string
 19200  	var lc int32              // match length or unmatched char (if dist == 0)
 19201  	var lx uint32 = uint32(0) // running index in l_buf
 19202  	var code uint32           // the code to send
 19203  	var extra int32           // number of extra bits to send
 19204  
 19205  	if (*Deflate_state)(unsafe.Pointer(s)).Flast_lit != UInt(0) {
 19206  		for __ccgo := true; __ccgo; __ccgo = lx < (*Deflate_state)(unsafe.Pointer(s)).Flast_lit {
 19207  			dist = uint32(*(*Ushf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fd_buf + uintptr(lx)*2)))
 19208  			lc = int32(*(*Uchf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fl_buf + uintptr(libc.PostIncUint32(&lx, 1)))))
 19209  			if dist == uint32(0) {
 19210  				{
 19211  					var len int32 = int32(*(*Ush)(unsafe.Pointer(ltree + uintptr(lc)*4 + 2)))
 19212  					if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > Buf_size-len {
 19213  						var val int32 = int32(*(*Ush)(unsafe.Pointer(ltree + uintptr(lc)*4)))
 19214  						*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 19215  						{
 19216  							{
 19217  								*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) & 0xff)
 19218  							}
 19219  							{
 19220  								*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) >> 8)
 19221  							}
 19222  
 19223  						}
 19224  						(*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))
 19225  						*(*int32)(unsafe.Pointer(s + 5940)) += len - Buf_size
 19226  					} else {
 19227  						*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(*(*Ush)(unsafe.Pointer(ltree + uintptr(lc)*4))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 19228  						*(*int32)(unsafe.Pointer(s + 5940)) += len
 19229  					}
 19230  				}
 19231  				// send a literal byte
 19232  
 19233  			} else {
 19234  				// Here, lc is the match length - MIN_MATCH
 19235  				code = uint32(X_length_code[lc])
 19236  				{
 19237  					var len int32 = int32(*(*Ush)(unsafe.Pointer(ltree + uintptr(code+uint32(LITERALS)+uint32(1))*4 + 2)))
 19238  					if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > Buf_size-len {
 19239  						var val int32 = int32(*(*Ush)(unsafe.Pointer(ltree + uintptr(code+uint32(LITERALS)+uint32(1))*4)))
 19240  						*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 19241  						{
 19242  							{
 19243  								*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) & 0xff)
 19244  							}
 19245  							{
 19246  								*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) >> 8)
 19247  							}
 19248  
 19249  						}
 19250  						(*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))
 19251  						*(*int32)(unsafe.Pointer(s + 5940)) += len - Buf_size
 19252  					} else {
 19253  						*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(*(*Ush)(unsafe.Pointer(ltree + uintptr(code+uint32(LITERALS)+uint32(1))*4))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 19254  						*(*int32)(unsafe.Pointer(s + 5940)) += len
 19255  					}
 19256  				}
 19257  				// send the length code
 19258  				extra = extra_lbits[code]
 19259  				if extra != 0 {
 19260  					lc = lc - base_length[code]
 19261  					{
 19262  						var len int32 = extra
 19263  						if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > Buf_size-len {
 19264  							var val int32 = lc
 19265  							*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 19266  							{
 19267  								{
 19268  									*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) & 0xff)
 19269  								}
 19270  								{
 19271  									*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) >> 8)
 19272  								}
 19273  
 19274  							}
 19275  							(*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))
 19276  							*(*int32)(unsafe.Pointer(s + 5940)) += len - Buf_size
 19277  						} else {
 19278  							*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(lc)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 19279  							*(*int32)(unsafe.Pointer(s + 5940)) += len
 19280  						}
 19281  					}
 19282  					// send the extra length bits
 19283  				}
 19284  				dist-- // dist is now the match distance - 1
 19285  				code = func() uint32 {
 19286  					if dist < uint32(256) {
 19287  						return uint32(X_dist_code[dist])
 19288  					}
 19289  					return uint32(X_dist_code[uint32(256)+dist>>7])
 19290  				}()
 19291  
 19292  				{
 19293  					var len int32 = int32(*(*Ush)(unsafe.Pointer(dtree + uintptr(code)*4 + 2)))
 19294  					if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > Buf_size-len {
 19295  						var val int32 = int32(*(*Ush)(unsafe.Pointer(dtree + uintptr(code)*4)))
 19296  						*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 19297  						{
 19298  							{
 19299  								*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) & 0xff)
 19300  							}
 19301  							{
 19302  								*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) >> 8)
 19303  							}
 19304  
 19305  						}
 19306  						(*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))
 19307  						*(*int32)(unsafe.Pointer(s + 5940)) += len - Buf_size
 19308  					} else {
 19309  						*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(*(*Ush)(unsafe.Pointer(dtree + uintptr(code)*4))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 19310  						*(*int32)(unsafe.Pointer(s + 5940)) += len
 19311  					}
 19312  				}
 19313  				// send the distance code
 19314  				extra = extra_dbits[code]
 19315  				if extra != 0 {
 19316  					dist = dist - uint32(base_dist[code])
 19317  					{
 19318  						var len int32 = extra
 19319  						if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > Buf_size-len {
 19320  							var val int32 = int32(dist)
 19321  							*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 19322  							{
 19323  								{
 19324  									*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) & 0xff)
 19325  								}
 19326  								{
 19327  									*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) >> 8)
 19328  								}
 19329  
 19330  							}
 19331  							(*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))
 19332  							*(*int32)(unsafe.Pointer(s + 5940)) += len - Buf_size
 19333  						} else {
 19334  							*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(dist)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 19335  							*(*int32)(unsafe.Pointer(s + 5940)) += len
 19336  						}
 19337  					}
 19338  					// send the extra distance bits
 19339  				}
 19340  			} // literal or match pair ?
 19341  
 19342  			// Check that the overlay between pending_buf and d_buf+l_buf is ok:
 19343  
 19344  		}
 19345  	}
 19346  
 19347  	{
 19348  		var len int32 = int32(*(*Ush)(unsafe.Pointer(ltree + 256*4 + 2)))
 19349  		if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > Buf_size-len {
 19350  			var val int32 = int32(*(*Ush)(unsafe.Pointer(ltree + 256*4)))
 19351  			*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 19352  			{
 19353  				{
 19354  					*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) & 0xff)
 19355  				}
 19356  				{
 19357  					*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) >> 8)
 19358  				}
 19359  
 19360  			}
 19361  			(*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))
 19362  			*(*int32)(unsafe.Pointer(s + 5940)) += len - Buf_size
 19363  		} else {
 19364  			*(*Ush)(unsafe.Pointer(s + 5936)) |= Ush(int32(*(*Ush)(unsafe.Pointer(ltree + 256*4))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)
 19365  			*(*int32)(unsafe.Pointer(s + 5940)) += len
 19366  		}
 19367  	}
 19368  
 19369  }
 19370  
 19371  // ===========================================================================
 19372  // Check if the data type is TEXT or BINARY, using the following algorithm:
 19373  // - TEXT if the two conditions below are satisfied:
 19374  //    a) There are no non-portable control characters belonging to the
 19375  //       "black list" (0..6, 14..25, 28..31).
 19376  //    b) There is at least one printable character belonging to the
 19377  //       "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255).
 19378  // - BINARY otherwise.
 19379  // - The following partially-portable control characters form a
 19380  //   "gray list" that is ignored in this detection algorithm:
 19381  //   (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}).
 19382  // IN assertion: the fields Freq of dyn_ltree are set.
 19383  func detect_data_type(tls *libc.TLS, s uintptr) int32 { /* trees.c:1124:11: */
 19384  	// black_mask is the bit mask of black-listed bytes
 19385  	// set bits 0..6, 14..25, and 28..31
 19386  	// 0xf3ffc07f = binary 11110011111111111100000001111111
 19387  	var black_mask uint64 = 0xf3ffc07f
 19388  	var n int32
 19389  
 19390  	// Check for non-textual ("black-listed") bytes.
 19391  	n = 0
 19392  __1:
 19393  	if !(n <= 31) {
 19394  		goto __3
 19395  	}
 19396  	if black_mask&uint64(1) != 0 && int32(*(*Ush)(unsafe.Pointer(s + 212 + uintptr(n)*4))) != 0 {
 19397  		return Z_BINARY
 19398  	}
 19399  	goto __2
 19400  __2:
 19401  	n++
 19402  	black_mask >>= 1
 19403  	goto __1
 19404  	goto __3
 19405  __3:
 19406  	;
 19407  
 19408  	// Check for textual ("white-listed") bytes.
 19409  	if int32(*(*Ush)(unsafe.Pointer(s + 212 + 9*4))) != 0 || int32(*(*Ush)(unsafe.Pointer(s + 212 + 10*4))) != 0 ||
 19410  		int32(*(*Ush)(unsafe.Pointer(s + 212 + 13*4))) != 0 {
 19411  		return Z_TEXT
 19412  	}
 19413  	for n = 32; n < LITERALS; n++ {
 19414  		if int32(*(*Ush)(unsafe.Pointer(s + 212 + uintptr(n)*4))) != 0 {
 19415  			return Z_TEXT
 19416  		}
 19417  	}
 19418  
 19419  	// There are no "black-listed" or "white-listed" bytes:
 19420  	// this stream either is empty or has tolerated ("gray-listed") bytes only.
 19421  	return Z_BINARY
 19422  }
 19423  
 19424  // ===========================================================================
 19425  // Reverse the first len bits of a code, using straightforward code (a faster
 19426  // method would use a table)
 19427  // IN assertion: 1 <= len <= 15
 19428  func bi_reverse(tls *libc.TLS, code uint32, len int32) uint32 { /* trees.c:1158:16: */
 19429  	var res uint32 = uint32(0)
 19430  	for __ccgo := true; __ccgo; __ccgo = libc.PreDecInt32(&len, 1) > 0 {
 19431  		res = res | code&uint32(1)
 19432  		code >>= 1
 19433  		res <<= 1
 19434  	}
 19435  	return res >> 1
 19436  }
 19437  
 19438  // ===========================================================================
 19439  // Flush the bit buffer, keeping at most 7 bits in it.
 19440  func bi_flush(tls *libc.TLS, s uintptr) { /* trees.c:1173:12: */
 19441  	if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid == 16 {
 19442  		{
 19443  			{
 19444  				*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) & 0xff)
 19445  			}
 19446  			{
 19447  				*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) >> 8)
 19448  			}
 19449  
 19450  		}
 19451  
 19452  		(*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(0)
 19453  		(*Deflate_state)(unsafe.Pointer(s)).Fbi_valid = 0
 19454  	} else if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid >= 8 {
 19455  		{
 19456  			*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Byte((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)
 19457  		}
 19458  
 19459  		libc.AssignShrPtrUint16(s+5936, int(8))
 19460  		*(*int32)(unsafe.Pointer(s + 5940)) -= 8
 19461  	}
 19462  }
 19463  
 19464  // ===========================================================================
 19465  // Flush the bit buffer and align the output on a byte boundary
 19466  func bi_windup(tls *libc.TLS, s uintptr) { /* trees.c:1190:12: */
 19467  	if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > 8 {
 19468  		{
 19469  			{
 19470  				*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) & 0xff)
 19471  			}
 19472  			{
 19473  				*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Uch(int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) >> 8)
 19474  			}
 19475  
 19476  		}
 19477  
 19478  	} else if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > 0 {
 19479  		{
 19480  			*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint64(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Byte((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)
 19481  		}
 19482  
 19483  	}
 19484  	(*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(0)
 19485  	(*Deflate_state)(unsafe.Pointer(s)).Fbi_valid = 0
 19486  }
 19487  
 19488  // ===========================================================================
 19489  //      Decompresses the source buffer into the destination buffer.  *sourceLen is
 19490  //    the byte length of the source buffer. Upon entry, *destLen is the total size
 19491  //    of the destination buffer, which must be large enough to hold the entire
 19492  //    uncompressed data. (The size of the uncompressed data must have been saved
 19493  //    previously by the compressor and transmitted to the decompressor by some
 19494  //    mechanism outside the scope of this compression library.) Upon exit,
 19495  //    *destLen is the size of the decompressed data and *sourceLen is the number
 19496  //    of source bytes consumed. Upon return, source + *sourceLen points to the
 19497  //    first unused input byte.
 19498  //
 19499  //      uncompress returns Z_OK if success, Z_MEM_ERROR if there was not enough
 19500  //    memory, Z_BUF_ERROR if there was not enough room in the output buffer, or
 19501  //    Z_DATA_ERROR if the input data was corrupted, including if the input data is
 19502  //    an incomplete zlib stream.
 19503  func Xuncompress2(tls *libc.TLS, dest uintptr, destLen uintptr, source uintptr, sourceLen uintptr) int32 { /* uncompr.c:27:13: */
 19504  	bp := tls.Alloc(120)
 19505  	defer tls.Free(120)
 19506  
 19507  	// var stream Z_stream at bp+8, 112
 19508  
 19509  	var err int32
 19510  	var max UInt = libc.Uint32(libc.Uint32FromInt32(-1))
 19511  	var len ULong
 19512  	var left ULong
 19513  	// var buf [1]Byte at bp, 1
 19514  	// for detection of incomplete stream when *destLen == 0
 19515  
 19516  	len = *(*ULong)(unsafe.Pointer(sourceLen))
 19517  	if *(*ULongf)(unsafe.Pointer(destLen)) != 0 {
 19518  		left = *(*ULongf)(unsafe.Pointer(destLen))
 19519  		*(*ULongf)(unsafe.Pointer(destLen)) = uint64(0)
 19520  	} else {
 19521  		left = uint64(1)
 19522  		dest = bp /* &buf[0] */
 19523  	}
 19524  
 19525  	(*Z_stream)(unsafe.Pointer(bp + 8 /* &stream */)).Fnext_in = source
 19526  	(*Z_stream)(unsafe.Pointer(bp + 8 /* &stream */)).Favail_in = UInt(0)
 19527  	(*Z_stream)(unsafe.Pointer(bp + 8 /* &stream */)).Fzalloc = uintptr(0)
 19528  	(*Z_stream)(unsafe.Pointer(bp + 8 /* &stream */)).Fzfree = uintptr(0)
 19529  	(*Z_stream)(unsafe.Pointer(bp + 8 /* &stream */)).Fopaque = uintptr(0)
 19530  
 19531  	err = XinflateInit_(tls, bp+8, ts, int32(unsafe.Sizeof(Z_stream{})))
 19532  	if err != Z_OK {
 19533  		return err
 19534  	}
 19535  
 19536  	(*Z_stream)(unsafe.Pointer(bp + 8 /* &stream */)).Fnext_out = dest
 19537  	(*Z_stream)(unsafe.Pointer(bp + 8 /* &stream */)).Favail_out = UInt(0)
 19538  
 19539  	for __ccgo := true; __ccgo; __ccgo = err == Z_OK {
 19540  		if (*Z_stream)(unsafe.Pointer(bp+8)).Favail_out == UInt(0) {
 19541  			(*Z_stream)(unsafe.Pointer(bp + 8 /* &stream */)).Favail_out = func() uint32 {
 19542  				if left > ULong(max) {
 19543  					return max
 19544  				}
 19545  				return UInt(left)
 19546  			}()
 19547  			left = left - ULong((*Z_stream)(unsafe.Pointer(bp+8)).Favail_out)
 19548  		}
 19549  		if (*Z_stream)(unsafe.Pointer(bp+8)).Favail_in == UInt(0) {
 19550  			(*Z_stream)(unsafe.Pointer(bp + 8 /* &stream */)).Favail_in = func() uint32 {
 19551  				if len > ULong(max) {
 19552  					return max
 19553  				}
 19554  				return UInt(len)
 19555  			}()
 19556  			len = len - ULong((*Z_stream)(unsafe.Pointer(bp+8)).Favail_in)
 19557  		}
 19558  		err = Xinflate(tls, bp+8, Z_NO_FLUSH)
 19559  	}
 19560  
 19561  	*(*ULong)(unsafe.Pointer(sourceLen)) -= len + ULong((*Z_stream)(unsafe.Pointer(bp+8)).Favail_in)
 19562  	if dest != bp {
 19563  		*(*ULongf)(unsafe.Pointer(destLen)) = (*Z_stream)(unsafe.Pointer(bp + 8 /* &stream */)).Ftotal_out
 19564  	} else if (*Z_stream)(unsafe.Pointer(bp+8)).Ftotal_out != 0 && err == -5 {
 19565  		left = uint64(1)
 19566  	}
 19567  
 19568  	XinflateEnd(tls, bp+8)
 19569  	if err == Z_STREAM_END {
 19570  		return Z_OK
 19571  	}
 19572  	if err == Z_NEED_DICT {
 19573  		return -3
 19574  	}
 19575  	if err == -5 && left+ULong((*Z_stream)(unsafe.Pointer(bp+8)).Favail_out) != 0 {
 19576  		return -3
 19577  	}
 19578  	return err
 19579  }
 19580  
 19581  func Xuncompress(tls *libc.TLS, dest uintptr, destLen uintptr, source uintptr, sourceLen ULong) int32 { /* uncompr.c:86:13: */
 19582  	bp := tls.Alloc(8)
 19583  	defer tls.Free(8)
 19584  	*(*ULong)(unsafe.Pointer(bp)) = sourceLen
 19585  
 19586  	return Xuncompress2(tls, dest, destLen, source, bp)
 19587  }
 19588  
 19589  // GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t
 19590  //    value -- needed when comparing unsigned to z_off64_t, which is signed
 19591  //    (possible z_off64_t types off_t, off64_t, and long are all signed)
 19592  
 19593  var Xz_errmsg = [10]uintptr{
 19594  	uintptr(ts + 876),
 19595  	uintptr(ts + 892),
 19596  	uintptr(ts + 101),
 19597  	uintptr(ts + 903),
 19598  	uintptr(ts + 914),
 19599  	uintptr(ts + 927),
 19600  	uintptr(ts + 938),
 19601  	uintptr(ts + 958),
 19602  	uintptr(ts + 971),
 19603  	uintptr(ts + 101),
 19604  } /* zutil.c:13:14 */
 19605  
 19606  func XzlibVersion(tls *libc.TLS) uintptr { /* zutil.c:27:12: */
 19607  	return ts /* "1.2.11" */
 19608  }
 19609  
 19610  func XzlibCompileFlags(tls *libc.TLS) ULong { /* zutil.c:32:15: */
 19611  	var flags ULong
 19612  
 19613  	flags = uint64(0)
 19614  	switch int32(unsafe.Sizeof(UInt(0))) {
 19615  	case 2:
 19616  		break
 19617  	case 4:
 19618  		flags = flags + uint64(1)
 19619  		break
 19620  	case 8:
 19621  		flags = flags + uint64(2)
 19622  		break
 19623  	default:
 19624  		flags = flags + uint64(3)
 19625  	}
 19626  	switch int32(unsafe.Sizeof(ULong(0))) {
 19627  	case 2:
 19628  		break
 19629  	case 4:
 19630  		flags = flags + uint64(int32(1)<<2)
 19631  		break
 19632  	case 8:
 19633  		flags = flags + uint64(int32(2)<<2)
 19634  		break
 19635  	default:
 19636  		flags = flags + uint64(int32(3)<<2)
 19637  	}
 19638  	switch int32(unsafe.Sizeof(Voidpf(0))) {
 19639  	case 2:
 19640  		break
 19641  	case 4:
 19642  		flags = flags + uint64(int32(1)<<4)
 19643  		break
 19644  	case 8:
 19645  		flags = flags + uint64(int32(2)<<4)
 19646  		break
 19647  	default:
 19648  		flags = flags + uint64(int32(3)<<4)
 19649  	}
 19650  	switch int32(unsafe.Sizeof(Off_t(0))) {
 19651  	case 2:
 19652  		break
 19653  	case 4:
 19654  		flags = flags + uint64(int32(1)<<6)
 19655  		break
 19656  	case 8:
 19657  		flags = flags + uint64(int32(2)<<6)
 19658  		break
 19659  	default:
 19660  		flags = flags + uint64(int32(3)<<6)
 19661  	}
 19662  	return flags
 19663  }
 19664  
 19665  // exported to allow conversion of error code to string for compress() and
 19666  // uncompress()
 19667  func XzError(tls *libc.TLS, err int32) uintptr { /* zutil.c:133:12: */
 19668  	return Xz_errmsg[Z_NEED_DICT-err]
 19669  }
 19670  
 19671  func Xzcalloc(tls *libc.TLS, opaque Voidpf, items uint32, size uint32) Voidpf { /* zutil.c:305:22: */
 19672  	_ = opaque
 19673  	if uint64(unsafe.Sizeof(UInt(0))) > uint64(2) {
 19674  		return libc.Xmalloc(tls, uint64(items*size))
 19675  	}
 19676  	return libc.Xcalloc(tls, uint64(items), uint64(size))
 19677  }
 19678  
 19679  func Xzcfree(tls *libc.TLS, opaque Voidpf, ptr Voidpf) { /* zutil.c:315:20: */
 19680  	_ = opaque
 19681  	libc.Xfree(tls, ptr)
 19682  }
 19683  
 19684  func init() {
 19685  	*(*func(*libc.TLS, uintptr, int32) Block_state)(unsafe.Pointer(uintptr(unsafe.Pointer(&configuration_table)) + 8)) = deflate_stored  // deflate.c:136:29:
 19686  	*(*func(*libc.TLS, uintptr, int32) Block_state)(unsafe.Pointer(uintptr(unsafe.Pointer(&configuration_table)) + 24)) = deflate_fast   // deflate.c:137:29:
 19687  	*(*func(*libc.TLS, uintptr, int32) Block_state)(unsafe.Pointer(uintptr(unsafe.Pointer(&configuration_table)) + 40)) = deflate_fast   // deflate.c:138:29:
 19688  	*(*func(*libc.TLS, uintptr, int32) Block_state)(unsafe.Pointer(uintptr(unsafe.Pointer(&configuration_table)) + 56)) = deflate_fast   // deflate.c:139:29:
 19689  	*(*func(*libc.TLS, uintptr, int32) Block_state)(unsafe.Pointer(uintptr(unsafe.Pointer(&configuration_table)) + 72)) = deflate_slow   // deflate.c:141:29:
 19690  	*(*func(*libc.TLS, uintptr, int32) Block_state)(unsafe.Pointer(uintptr(unsafe.Pointer(&configuration_table)) + 88)) = deflate_slow   // deflate.c:142:29:
 19691  	*(*func(*libc.TLS, uintptr, int32) Block_state)(unsafe.Pointer(uintptr(unsafe.Pointer(&configuration_table)) + 104)) = deflate_slow  // deflate.c:143:29:
 19692  	*(*func(*libc.TLS, uintptr, int32) Block_state)(unsafe.Pointer(uintptr(unsafe.Pointer(&configuration_table)) + 120)) = deflate_slow  // deflate.c:144:29:
 19693  	*(*func(*libc.TLS, uintptr, int32) Block_state)(unsafe.Pointer(uintptr(unsafe.Pointer(&configuration_table)) + 136)) = deflate_slow  // deflate.c:145:30:
 19694  	*(*func(*libc.TLS, uintptr, int32) Block_state)(unsafe.Pointer(uintptr(unsafe.Pointer(&configuration_table)) + 152)) = deflate_slow  // deflate.c:146:30:
 19695  	*(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&static_bl_desc)) + 8 /* .extra_bits */)) = uintptr(unsafe.Pointer(&extra_blbits)) // trees.c:132:22:
 19696  	*(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&static_d_desc)) + 0 /* .static_tree */)) = uintptr(unsafe.Pointer(&static_dtree)) // trees.c:129:2:
 19697  	*(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&static_d_desc)) + 8 /* .extra_bits */)) = uintptr(unsafe.Pointer(&extra_dbits))   // trees.c:129:16:
 19698  	*(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&static_l_desc)) + 0 /* .static_tree */)) = uintptr(unsafe.Pointer(&static_ltree)) // trees.c:126:2:
 19699  	*(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&static_l_desc)) + 8 /* .extra_bits */)) = uintptr(unsafe.Pointer(&extra_lbits))   // trees.c:126:16:
 19700  }
 19701  
 19702  var ts1 = "1.2.11\x00 deflate 1.2.11 Copyright 1995-2017 Jean-loup Gailly and Mark Adler \x00%s\x00<fd:%d>\x00out of memory\x00\x00%s%s%s\x00: \x00unexpected end of file\x00internal error: inflate stream corrupt\x00compressed data error\x00request does not fit in an int\x00request does not fit in a size_t\x00out of room to push characters\x00internal error: deflate stream corrupt\x00requested length does not fit in int\x00invalid block type\x00invalid stored block lengths\x00too many length or distance symbols\x00invalid code lengths set\x00invalid bit length repeat\x00invalid code -- missing end-of-block\x00invalid literal/lengths set\x00invalid distances set\x00invalid literal/length code\x00invalid distance code\x00invalid distance too far back\x00incorrect header check\x00unknown compression method\x00invalid window size\x00unknown header flags set\x00header crc mismatch\x00incorrect data check\x00incorrect length check\x00 inflate 1.2.11 Copyright 1995-2017 Mark Adler \x00need dictionary\x00stream end\x00file error\x00stream error\x00data error\x00insufficient memory\x00buffer error\x00incompatible version\x00"
 19703  var ts = (*reflect.StringHeader)(unsafe.Pointer(&ts1)).Data