modernc.org/z@v1.7.4/lib/z_windows_amd64.go (about) 1 // Code generated by 'ccgo -export-defines "" -export-enums "" -export-externs X -export-fields F -export-structs "" -export-typedefs "" -o lib\z_windows_amd64.go -pkgname z -trace-translation-units C:\Users\0xjnml\go\src\modernc.org\z\tmp\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 _ types.Size_t 20 21 const ( 22 BASE = 65521 23 CHAR_BIT = 8 24 CHAR_MAX = 127 25 CHAR_MIN = -128 26 DEF_MEM_LEVEL = 8 27 DEF_WBITS = 15 28 DUMMYSTRUCTNAME = 0 29 DUMMYSTRUCTNAME1 = 0 30 DUMMYSTRUCTNAME2 = 0 31 DUMMYSTRUCTNAME3 = 0 32 DUMMYSTRUCTNAME4 = 0 33 DUMMYSTRUCTNAME5 = 0 34 DUMMYUNIONNAME = 0 35 DUMMYUNIONNAME1 = 0 36 DUMMYUNIONNAME2 = 0 37 DUMMYUNIONNAME3 = 0 38 DUMMYUNIONNAME4 = 0 39 DUMMYUNIONNAME5 = 0 40 DUMMYUNIONNAME6 = 0 41 DUMMYUNIONNAME7 = 0 42 DUMMYUNIONNAME8 = 0 43 DUMMYUNIONNAME9 = 0 44 DYN_TREES = 2 45 EXIT_FAILURE = 1 46 EXIT_SUCCESS = 0 47 FAR = 0 48 HAVE_MEMCPY = 0 49 INT_MAX = 2147483647 50 INT_MIN = -2147483648 51 LLONG_MAX = 9223372036854775807 52 LLONG_MIN = -9223372036854775808 53 LONG_LONG_MAX = 9223372036854775807 54 LONG_LONG_MIN = -9223372036854775808 55 LONG_MAX = 2147483647 56 LONG_MIN = -2147483648 57 MAX_MATCH = 258 58 MAX_MEM_LEVEL = 9 59 MAX_WBITS = 15 60 MB_LEN_MAX = 5 61 MINGW_DDK_H = 0 62 MINGW_DDRAW_VERSION = 7 63 MINGW_HAS_DDK_H = 1 64 MINGW_HAS_DDRAW_H = 1 65 MINGW_HAS_SECURE_API = 1 66 MINGW_SDK_INIT = 0 67 MIN_MATCH = 3 68 NMAX = 5552 69 OS_CODE = 10 70 PATH_MAX = 260 71 PRESET_DICT = 0x20 72 RAND_MAX = 0x7fff 73 SCHAR_MAX = 127 74 SCHAR_MIN = -128 75 SEEK_CUR = 1 76 SEEK_END = 2 77 SEEK_SET = 0 78 SHRT_MAX = 32767 79 SHRT_MIN = -32768 80 SIZE_MAX = 18446744073709551615 81 SSIZE_MAX = 9223372036854775807 82 STATIC_TREES = 1 83 STDC = 0 84 STDC99 = 0 85 STORED_BLOCK = 0 86 UCHAR_MAX = 255 87 UINT_MAX = 4294967295 88 ULLONG_MAX = 18446744073709551615 89 ULONG_LONG_MAX = 18446744073709551615 90 ULONG_MAX = 4294967295 91 UNALIGNED = 0 92 USE___UUIDOF = 0 93 USHRT_MAX = 65535 94 WIN32 = 1 95 WIN64 = 1 96 WINNT = 1 97 ZCONF_H = 0 98 ZEXPORT = 0 99 ZEXPORTVA = 0 100 ZLIB_H = 0 101 ZLIB_INTERNAL = 0 102 ZLIB_VERNUM = 0x12b0 103 ZLIB_VERSION = "1.2.11" 104 ZLIB_VER_MAJOR = 1 105 ZLIB_VER_MINOR = 2 106 ZLIB_VER_REVISION = 11 107 ZLIB_VER_SUBREVISION = 0 108 ZUTIL_H = 0 109 Z_ASCII = 1 110 Z_BEST_COMPRESSION = 9 111 Z_BEST_SPEED = 1 112 Z_BINARY = 0 113 Z_BLOCK = 5 114 Z_BUF_ERROR = -5 115 Z_DATA_ERROR = -3 116 Z_DEFAULT_COMPRESSION = -1 117 Z_DEFAULT_STRATEGY = 0 118 Z_DEFLATED = 8 119 Z_ERRNO = -1 120 Z_FILTERED = 1 121 Z_FINISH = 4 122 Z_FIXED = 4 123 Z_FULL_FLUSH = 3 124 Z_HUFFMAN_ONLY = 2 125 Z_MEM_ERROR = -4 126 Z_NEED_DICT = 2 127 Z_NO_COMPRESSION = 0 128 Z_NO_FLUSH = 0 129 Z_NULL = 0 130 Z_OK = 0 131 Z_PARTIAL_FLUSH = 1 132 Z_RLE = 3 133 Z_STREAM_END = 1 134 Z_STREAM_ERROR = -2 135 Z_SYNC_FLUSH = 2 136 Z_TEXT = 1 137 Z_TREES = 6 138 Z_UNKNOWN = 2 139 Z_VERSION_ERROR = -6 140 X_AGLOBAL = 0 141 X_ALLOCA_S_HEAP_MARKER = 0xDDDD 142 X_ALLOCA_S_MARKER_SIZE = 16 143 X_ALLOCA_S_STACK_MARKER = 0xCCCC 144 X_ALLOCA_S_THRESHOLD = 1024 145 X_ANONYMOUS_STRUCT = 0 146 X_ANONYMOUS_UNION = 0 147 X_ANSI_STDARG_H_ = 0 148 X_ANSI_STDDEF_H = 0 149 X_ARGMAX = 100 150 X_CALL_REPORTFAULT = 0x2 151 X_CONST_RETURN = 0 152 X_CRTNOALIAS = 0 153 X_CRTRESTRICT = 0 154 X_CRT_ABS_DEFINED = 0 155 X_CRT_ALGO_DEFINED = 0 156 X_CRT_ALLOCATION_DEFINED = 0 157 X_CRT_ALTERNATIVE_IMPORTED = 0 158 X_CRT_ATOF_DEFINED = 0 159 X_CRT_DOUBLE_DEC = 0 160 X_CRT_ERRNO_DEFINED = 0 161 X_CRT_MANAGED_HEAP_DEPRECATE = 0 162 X_CRT_MEMORY_DEFINED = 0 163 X_CRT_PACKING = 8 164 X_CRT_PERROR_DEFINED = 0 165 X_CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES = 0 166 X_CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_MEMORY = 0 167 X_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES = 0 168 X_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT = 0 169 X_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_MEMORY = 0 170 X_CRT_SWAB_DEFINED = 0 171 X_CRT_SYSTEM_DEFINED = 0 172 X_CRT_TERMINATE_DEFINED = 0 173 X_CRT_WPERROR_DEFINED = 0 174 X_CRT_WSYSTEM_DEFINED = 0 175 X_CVTBUFSIZE = 349 176 X_DEV_T_DEFINED = 0 177 X_DIV_T_DEFINED = 0 178 X_DLL = 0 179 X_ERRCODE_DEFINED = 0 180 X_FILE_OFFSET_BITS = 64 181 X_FILE_OFFSET_BITS_SET_OFFT = 0 182 X_FREEA_INLINE = 0 183 X_FREEENTRY = 0 184 X_GCC_LIMITS_H_ = 0 185 X_GCC_MAX_ALIGN_T = 0 186 X_HEAPBADBEGIN = -3 187 X_HEAPBADNODE = -4 188 X_HEAPBADPTR = -6 189 X_HEAPEMPTY = -1 190 X_HEAPEND = -5 191 X_HEAPINFO_DEFINED = 0 192 X_HEAPOK = -2 193 X_HEAP_MAXREQ = 0xFFFFFFFFFFFFFFE0 194 X_I16_MAX = 32767 195 X_I16_MIN = -32768 196 X_I32_MAX = 2147483647 197 X_I32_MIN = -2147483648 198 X_I64_MAX = 9223372036854775807 199 X_I64_MIN = -9223372036854775808 200 X_I8_MAX = 127 201 X_I8_MIN = -128 202 X_INC_CRTDEFS = 0 203 X_INC_CRTDEFS_MACRO = 0 204 X_INC_LIMITS = 0 205 X_INC_MINGW_SECAPI = 0 206 X_INC_STDARG = 0 207 X_INC_STDDEF = 0 208 X_INC_STDLIB = 0 209 X_INC_STDLIB_S = 0 210 X_INC_STRING = 0 211 X_INC_STRING_S = 0 212 X_INC_TYPES = 0 213 X_INC_VADEFS = 0 214 X_INC__MINGW_H = 0 215 X_INO_T_DEFINED = 0 216 X_INT128_DEFINED = 0 217 X_INTEGRAL_MAX_BITS = 64 218 X_INTPTR_T_DEFINED = 0 219 X_LIMITS_H___ = 0 220 X_MALLOC_H_ = 0 221 X_MAX_DIR = 256 222 X_MAX_DRIVE = 3 223 X_MAX_ENV = 32767 224 X_MAX_EXT = 256 225 X_MAX_FNAME = 256 226 X_MAX_PATH = 260 227 X_MAX_WAIT_MALLOC_CRT = 60000 228 X_MM_MALLOC_H_INCLUDED = 0 229 X_MODE_T_ = 0 230 X_MT = 0 231 X_M_AMD64 = 100 232 X_M_X64 = 100 233 X_NLSCMPERROR = 2147483647 234 X_NLSCMP_DEFINED = 0 235 X_OFF64_T_DEFINED = 0 236 X_OFF_T_ = 0 237 X_OFF_T_DEFINED = 0 238 X_ONEXIT_T_DEFINED = 0 239 X_OUT_TO_DEFAULT = 0 240 X_OUT_TO_MSGBOX = 2 241 X_OUT_TO_STDERR = 1 242 X_PGLOBAL = 0 243 X_PID_T_ = 0 244 X_PTRDIFF_T_ = 0 245 X_PTRDIFF_T_DEFINED = 0 246 X_QSORT_S_DEFINED = 0 247 X_REENTRANT = 1 248 X_REPORT_ERRMODE = 3 249 X_RSIZE_T_DEFINED = 0 250 X_SECURECRT_FILL_BUFFER_PATTERN = 0xFD 251 X_SIGSET_T_ = 0 252 X_SIZE_T_DEFINED = 0 253 X_SSIZE_T_DEFINED = 0 254 X_STDARG_H = 0 255 X_STDDEF_H = 0 256 X_STDDEF_H_ = 0 257 X_TAGLC_ID_DEFINED = 0 258 X_THREADLOCALEINFO = 0 259 X_TIME32_T_DEFINED = 0 260 X_TIME64_T_DEFINED = 0 261 X_TIMESPEC_DEFINED = 0 262 X_TIME_T_DEFINED = 0 263 X_UI16_MAX = 0xffff 264 X_UI32_MAX = 0xffffffff 265 X_UI64_MAX = 0xffffffffffffffff 266 X_UI8_MAX = 0xff 267 X_UINTPTR_T_DEFINED = 0 268 X_USEDENTRY = 1 269 X_VA_LIST = 0 270 X_VA_LIST_ = 0 271 X_VA_LIST_DEFINED = 0 272 X_VA_LIST_T_H = 0 273 X_W64 = 0 274 X_WCHAR_T_DEFINED = 0 275 X_WCTYPE_T_DEFINED = 0 276 X_WConst_return = 0 277 X_WIN32 = 1 278 X_WIN32_WINNT = 0x502 279 X_WIN64 = 1 280 X_WINT_T = 0 281 X_WRITE_ABORT_MSG = 0x1 282 X_WSTDLIBP_DEFINED = 0 283 X_WSTDLIBP_S_DEFINED = 0 284 X_WSTDLIB_DEFINED = 0 285 X_WSTDLIB_S_DEFINED = 0 286 X_WSTRING_DEFINED = 0 287 X_WSTRING_S_DEFINED = 0 288 Z_const = 0 289 BYFOUR = 0 290 GF2_DIM = 32 291 TBLS = 8 292 BL_CODES = 19 293 BUSY_STATE = 113 294 Buf_size = 16 295 COMMENT_STATE = 91 296 DEFLATE_H = 0 297 D_CODES = 30 298 EXTRA_STATE = 69 299 FINISH_STATE = 666 300 GZIP = 0 301 GZIP_STATE = 57 302 HCRC_STATE = 103 303 HEAP_SIZE = 573 304 INIT_STATE = 42 305 LENGTH_CODES = 29 306 LITERALS = 256 307 L_CODES = 286 308 MAX_BITS = 15 309 MAX_STORED = 65535 310 MIN_LOOKAHEAD = 262 311 NAME_STATE = 73 312 NIL = 0 313 TOO_FAR = 4096 314 WIN_INIT = 258 315 BUFSIZ = 512 316 COPY1 = 1 317 E2BIG = 7 318 EACCES = 13 319 EADDRINUSE = 100 320 EADDRNOTAVAIL = 101 321 EAFNOSUPPORT = 102 322 EAGAIN = 11 323 EALREADY = 103 324 EBADF = 9 325 EBADMSG = 104 326 EBUSY = 16 327 ECANCELED = 105 328 ECHILD = 10 329 ECONNABORTED = 106 330 ECONNREFUSED = 107 331 ECONNRESET = 108 332 EDEADLK = 36 333 EDEADLOCK = 36 334 EDESTADDRREQ = 109 335 EDOM = 33 336 EEXIST = 17 337 EFAULT = 14 338 EFBIG = 27 339 EHOSTUNREACH = 110 340 EIDRM = 111 341 EILSEQ = 42 342 EINPROGRESS = 112 343 EINTR = 4 344 EINVAL = 22 345 EIO = 5 346 EISCONN = 113 347 EISDIR = 21 348 ELOOP = 114 349 EMFILE = 24 350 EMLINK = 31 351 EMSGSIZE = 115 352 ENAMETOOLONG = 38 353 ENETDOWN = 116 354 ENETRESET = 117 355 ENETUNREACH = 118 356 ENFILE = 23 357 ENOBUFS = 119 358 ENODATA = 120 359 ENODEV = 19 360 ENOENT = 2 361 ENOEXEC = 8 362 ENOFILE = 2 363 ENOLCK = 39 364 ENOLINK = 121 365 ENOMEM = 12 366 ENOMSG = 122 367 ENOPROTOOPT = 123 368 ENOSPC = 28 369 ENOSR = 124 370 ENOSTR = 125 371 ENOSYS = 40 372 ENOTCONN = 126 373 ENOTDIR = 20 374 ENOTEMPTY = 41 375 ENOTRECOVERABLE = 127 376 ENOTSOCK = 128 377 ENOTSUP = 129 378 ENOTTY = 25 379 ENXIO = 6 380 EOF = -1 381 EOPNOTSUPP = 130 382 EOVERFLOW = 132 383 EOWNERDEAD = 133 384 EPERM = 1 385 EPIPE = 32 386 EPROTO = 134 387 EPROTONOSUPPORT = 135 388 EPROTOTYPE = 136 389 ERANGE = 34 390 EROFS = 30 391 ESPIPE = 29 392 ESRCH = 3 393 ETIME = 137 394 ETIMEDOUT = 138 395 ETXTBSY = 139 396 EWOULDBLOCK = 140 397 EXDEV = 18 398 FILENAME_MAX = 260 399 FOPEN_MAX = 20 400 F_OK = 0 401 GZBUFSIZE = 8192 402 GZ_APPEND = 1 403 GZ_NONE = 0 404 GZ_READ = 7247 405 GZ_WRITE = 31153 406 HAVE_VSNPRINTF = 0 407 LOOK = 0 408 O_ACCMODE = 3 409 O_APPEND = 8 410 O_BINARY = 32768 411 O_CREAT = 256 412 O_EXCL = 1024 413 O_NOINHERIT = 128 414 O_RANDOM = 16 415 O_RAW = 32768 416 O_RDONLY = 0 417 O_RDWR = 2 418 O_SEQUENTIAL = 32 419 O_TEMPORARY = 64 420 O_TEXT = 16384 421 O_TRUNC = 512 422 O_WRONLY = 1 423 R_OK = 4 424 STDERR_FILENO = 2 425 STDIN_FILENO = 0 426 STDOUT_FILENO = 1 427 STRUNCATE = 80 428 SYS_OPEN = 20 429 TMP_MAX = 32767 430 WIDECHAR = 0 431 W_OK = 2 432 X_OK = 1 433 X_A_ARCH = 0x20 434 X_A_HIDDEN = 0x02 435 X_A_NORMAL = 0x00 436 X_A_RDONLY = 0x01 437 X_A_SUBDIR = 0x10 438 X_A_SYSTEM = 0x04 439 X_CRT_DIRECTORY_DEFINED = 0 440 X_FILE_DEFINED = 0 441 X_FILE_OFFSET_BITS_SET_FSEEKO = 0 442 X_FILE_OFFSET_BITS_SET_FTELLO = 0 443 X_FILE_OFFSET_BITS_SET_LSEEK = 0 444 X_FINDDATA_T_DEFINED = 0 445 X_FPOS_T_DEFINED = 0 446 X_FSIZE_T_DEFINED = 0 447 X_INC_ERRNO = 0 448 X_INC_FCNTL = 0 449 X_INC_STDIO = 0 450 X_INC_STDIO_S = 0 451 X_INC_SWPRINTF_INL = 0 452 X_IOB_ENTRIES = 20 453 X_IOEOF = 0x0010 454 X_IOERR = 0x0020 455 X_IOFBF = 0x0000 456 X_IOLBF = 0x0040 457 X_IOMYBUF = 0x0008 458 X_IONBF = 0x0004 459 X_IOREAD = 0x0001 460 X_IORW = 0x0080 461 X_IOSTRG = 0x0040 462 X_IOWRT = 0x0002 463 X_IO_H_ = 0 464 X_NFILE = 512 465 X_NSTREAM_ = 512 466 X_OLD_P_OVERLAY = 2 467 X_O_ACCMODE = 3 468 X_O_APPEND = 0x0008 469 X_O_BINARY = 0x8000 470 X_O_CREAT = 0x0100 471 X_O_EXCL = 0x0400 472 X_O_NOINHERIT = 0x0080 473 X_O_RANDOM = 0x0010 474 X_O_RAW = 32768 475 X_O_RDONLY = 0x0000 476 X_O_RDWR = 0x0002 477 X_O_SEQUENTIAL = 0x0020 478 X_O_SHORT_LIVED = 0x1000 479 X_O_TEMPORARY = 0x0040 480 X_O_TEXT = 0x4000 481 X_O_TRUNC = 0x0200 482 X_O_U16TEXT = 0x20000 483 X_O_U8TEXT = 0x40000 484 X_O_WRONLY = 0x0001 485 X_O_WTEXT = 0x10000 486 X_POSIX_SOURCE = 0 487 X_P_DETACH = 4 488 X_P_NOWAIT = 1 489 X_P_NOWAITO = 3 490 X_P_OVERLAY = 2 491 X_P_WAIT = 0 492 X_P_tmpdir = "\\" 493 X_SECURECRT_ERRCODE_VALUES_DEFINED = 0 494 X_SPAWNV_DEFINED = 0 495 X_STDIO_DEFINED = 0 496 X_STDIO_S_DEFINED = 0 497 X_STDSTREAM_DEFINED = 0 498 X_SYS_OPEN = 20 499 X_TWO_DIGIT_EXPONENT = 0x1 500 X_WAIT_CHILD = 0 501 X_WAIT_GRANDCHILD = 1 502 X_WFINDDATA_T_DEFINED = 0 503 X_WIO_DEFINED = 0 504 X_WSPAWN_DEFINED = 0 505 X_WSTDIO_DEFINED = 0 506 X_WSTDIO_S_DEFINED = 0 507 ENOUGH = 1444 508 ENOUGH_DISTS = 592 509 ENOUGH_LENS = 852 510 GUNZIP = 0 511 MAXBITS = 15 512 DIST_CODE_LEN = 512 513 END_BLOCK = 256 514 MAX_BL_BITS = 7 515 REPZ_11_138 = 18 516 REPZ_3_10 = 17 517 REP_3_6 = 16 518 SMALLEST = 1 519 ) 520 521 // 522 // If you use the zlib library in a product, an acknowledgment is welcome 523 // in the documentation of your product. If for some reason you cannot 524 // include such an acknowledgment, I would appreciate that you keep this 525 // copyright string in the executable of your product. 526 // 527 528 // =========================================================================== 529 // Function prototypes. 530 const ( /* deflate.c:66:1: */ 531 Need_more = 0 // block not completed, need more input or more output 532 Block_done = 1 // block flush performed 533 Finish_started = 2 // finish started, need only more output at next deflate 534 Finish_done = 3 535 ) 536 537 // inflate.h -- internal inflate state definition 538 // Copyright (C) 1995-2016 Mark Adler 539 // For conditions of distribution and use, see copyright notice in zlib.h 540 541 // WARNING: this file should *not* be used by applications. It is 542 // part of the implementation of the compression library and is 543 // subject to change. Applications should only use zlib.h. 544 // 545 546 // define NO_GZIP when compiling if you want to disable gzip header and 547 // trailer decoding by inflate(). NO_GZIP would be used to avoid linking in 548 // the crc code when it is not needed. For shared libraries, gzip decoding 549 // should be left enabled. 550 551 // Possible inflate modes between inflate() calls 552 const ( /* inflate.h:20:1: */ 553 HEAD = 16180 // i: waiting for magic header 554 FLAGS = 16181 // i: waiting for method and flags (gzip) 555 TIME = 16182 // i: waiting for modification time (gzip) 556 OS = 16183 // i: waiting for extra flags and operating system (gzip) 557 EXLEN = 16184 // i: waiting for extra length (gzip) 558 EXTRA = 16185 // i: waiting for extra bytes (gzip) 559 NAME = 16186 // i: waiting for end of file name (gzip) 560 COMMENT = 16187 // i: waiting for end of comment (gzip) 561 HCRC = 16188 // i: waiting for header crc (gzip) 562 DICTID = 16189 // i: waiting for dictionary check value 563 DICT = 16190 // waiting for inflateSetDictionary() call 564 TYPE = 16191 // i: waiting for type bits, including last-flag bit 565 TYPEDO = 16192 // i: same, but skip check to exit inflate on new block 566 STORED = 16193 // i: waiting for stored size (length and complement) 567 COPY_ = 16194 // i/o: same as COPY below, but only first time in 568 COPY = 16195 // i/o: waiting for input or output to copy stored block 569 TABLE = 16196 // i: waiting for dynamic block table lengths 570 LENLENS = 16197 // i: waiting for code length code lengths 571 CODELENS = 16198 // i: waiting for length/lit and distance code lengths 572 LEN_ = 16199 // i: same as LEN below, but only first time in 573 LEN = 16200 // i: waiting for length/lit/eob code 574 LENEXT = 16201 // i: waiting for length extra bits 575 DIST = 16202 // i: waiting for distance code 576 DISTEXT = 16203 // i: waiting for distance extra bits 577 MATCH = 16204 // o: waiting for output space to copy string 578 LIT = 16205 // o: waiting for output space to write literal 579 CHECK = 16206 // i: waiting for 32-bit check value 580 LENGTH = 16207 // i: waiting for 32-bit length (gzip) 581 DONE = 16208 // finished check, done -- remain here until reset 582 BAD = 16209 // got a data error -- remain here until reset 583 MEM = 16210 // got an inflate() memory error -- remain here until reset 584 SYNC = 16211 585 ) 586 587 // op values as set by inflate_table(): 588 // 00000000 - literal 589 // 0000tttt - table link, tttt != 0 is the number of table index bits 590 // 0001eeee - length or distance, eeee is the number of extra bits 591 // 01100000 - end of block 592 // 01000000 - invalid code 593 // 594 595 // Maximum size of the dynamic table. The maximum number of code structures is 596 // 1444, which is the sum of 852 for literal/length codes and 592 for distance 597 // codes. These values were found by exhaustive searches using the program 598 // examples/enough.c found in the zlib distribtution. The arguments to that 599 // program are the number of symbols, the initial root table size, and the 600 // maximum bit length of a code. "enough 286 9 15" for literal/length codes 601 // returns returns 852, and "enough 30 6 15" for distance codes returns 592. 602 // The initial root table size (9 or 6) is found in the fifth argument of the 603 // inflate_table() calls in inflate.c and infback.c. If the root table size is 604 // changed, then these maximum sizes would be need to be recalculated and 605 // updated. 606 607 // Type of code to build for inflate_table() 608 const ( /* inftrees.h:54:1: */ 609 CODES = 0 610 LENS = 1 611 DISTS = 2 612 ) 613 614 type Ptrdiff_t = int64 /* <builtin>:3:26 */ 615 616 type Size_t = uint64 /* <builtin>:9:23 */ 617 618 type Wchar_t = uint16 /* <builtin>:15:24 */ 619 620 type X__int128_t = struct { 621 Flo int64 622 Fhi int64 623 } /* <builtin>:21:43 */ // must match modernc.org/mathutil.Int128 624 type X__uint128_t = struct { 625 Flo uint64 626 Fhi uint64 627 } /* <builtin>:22:44 */ // must match modernc.org/mathutil.Int128 628 629 type X__builtin_va_list = uintptr /* <builtin>:46:14 */ 630 type X__float128 = float64 /* <builtin>:47:21 */ 631 632 type Va_list = X__builtin_va_list /* <builtin>:50:27 */ 633 634 // adler32.c -- compute the Adler-32 checksum of a data stream 635 // Copyright (C) 1995-2011, 2016 Mark Adler 636 // For conditions of distribution and use, see copyright notice in zlib.h 637 638 // @(#) $Id$ 639 640 // zutil.h -- internal interface and configuration of the compression library 641 // Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler 642 // For conditions of distribution and use, see copyright notice in zlib.h 643 644 // WARNING: this file should *not* be used by applications. It is 645 // part of the implementation of the compression library and is 646 // subject to change. Applications should only use zlib.h. 647 // 648 649 // @(#) $Id$ 650 651 // zlib.h -- interface of the 'zlib' general purpose compression library 652 // version 1.2.11, January 15th, 2017 653 // 654 // Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler 655 // 656 // This software is provided 'as-is', without any express or implied 657 // warranty. In no event will the authors be held liable for any damages 658 // arising from the use of this software. 659 // 660 // Permission is granted to anyone to use this software for any purpose, 661 // including commercial applications, and to alter it and redistribute it 662 // freely, subject to the following restrictions: 663 // 664 // 1. The origin of this software must not be misrepresented; you must not 665 // claim that you wrote the original software. If you use this software 666 // in a product, an acknowledgment in the product documentation would be 667 // appreciated but is not required. 668 // 2. Altered source versions must be plainly marked as such, and must not be 669 // misrepresented as being the original software. 670 // 3. This notice may not be removed or altered from any source distribution. 671 // 672 // Jean-loup Gailly Mark Adler 673 // jloup@gzip.org madler@alumni.caltech.edu 674 // 675 // 676 // The data format used by the zlib library is described by RFCs (Request for 677 // Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950 678 // (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format). 679 680 // zconf.h -- configuration of the zlib compression library 681 // Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler 682 // For conditions of distribution and use, see copyright notice in zlib.h 683 684 // @(#) $Id$ 685 686 // If you *really* need a unique prefix for all types and library functions, 687 // compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. 688 // Even better than compiling with -DZ_PREFIX would be to use configure to set 689 // this permanently in zconf.h using "./configure --zprefix". 690 691 // Compile with -DMAXSEG_64K if the alloc function cannot allocate more 692 // than 64k bytes at a time (needed on systems with 16-bit int). 693 694 // * 695 // This file has no copyright assigned and is placed in the Public Domain. 696 // This file is part of the mingw-w64 runtime package. 697 // No warranty is given; refer to the file DISCLAIMER.PD within this package. 698 699 // * 700 // This file has no copyright assigned and is placed in the Public Domain. 701 // This file is part of the mingw-w64 runtime package. 702 // No warranty is given; refer to the file DISCLAIMER.PD within this package. 703 704 // * 705 // This file has no copyright assigned and is placed in the Public Domain. 706 // This file is part of the mingw-w64 runtime package. 707 // No warranty is given; refer to the file DISCLAIMER.PD within this package. 708 709 // * 710 // This file has no copyright assigned and is placed in the Public Domain. 711 // This file is part of the mingw-w64 runtime package. 712 // No warranty is given; refer to the file DISCLAIMER.PD within this package. 713 714 // This macro holds an monotonic increasing value, which indicates 715 // a specific fix/patch is present on trunk. This value isn't related to 716 // minor/major version-macros. It is increased on demand, if a big 717 // fix was applied to trunk. This macro gets just increased on trunk. For 718 // other branches its value won't be modified. 719 720 // mingw.org's version macros: these make gcc to define 721 // MINGW32_SUPPORTS_MT_EH and to use the _CRT_MT global 722 // and the __mingwthr_key_dtor() function from the MinGW 723 // CRT in its private gthr-win32.h header. 724 725 // Set VC specific compiler target macros. 726 727 // MS does not prefix symbols by underscores for 64-bit. 728 // As we have to support older gcc version, which are using underscores 729 // as symbol prefix for x64, we have to check here for the user label 730 // prefix defined by gcc. 731 732 // Special case nameless struct/union. 733 734 // MinGW-w64 has some additional C99 printf/scanf feature support. 735 // So we add some helper macros to ease recognition of them. 736 737 // * 738 // This file has no copyright assigned and is placed in the Public Domain. 739 // This file is part of the mingw-w64 runtime package. 740 // No warranty is given; refer to the file DISCLAIMER.PD within this package. 741 742 // http://msdn.microsoft.com/en-us/library/ms175759%28v=VS.100%29.aspx 743 // Templates won't work in C, will break if secure API is not enabled, disabled 744 745 // https://blogs.msdn.com/b/sdl/archive/2010/02/16/vc-2010-and-memcpy.aspx?Redirected=true 746 // fallback on default implementation if we can't know the size of the destination 747 748 // Include _cygwin.h if we're building a Cygwin application. 749 750 // Target specific macro replacement for type "long". In the Windows API, 751 // the type long is always 32 bit, even if the target is 64 bit (LLP64). 752 // On 64 bit Cygwin, the type long is 64 bit (LP64). So, to get the right 753 // sized definitions and declarations, all usage of type long in the Windows 754 // headers have to be replaced by the below defined macro __LONG32. 755 756 // C/C++ specific language defines. 757 758 // Note the extern. This is needed to work around GCC's 759 // limitations in handling dllimport attribute. 760 761 // Attribute `nonnull' was valid as of gcc 3.3. We don't use GCC's 762 // variadiac macro facility, because variadic macros cause syntax 763 // errors with --traditional-cpp. 764 765 // High byte is the major version, low byte is the minor. 766 767 // * 768 // This file has no copyright assigned and is placed in the Public Domain. 769 // This file is part of the mingw-w64 runtime package. 770 // No warranty is given; refer to the file DISCLAIMER.PD within this package. 771 772 // * 773 // This file has no copyright assigned and is placed in the Public Domain. 774 // This file is part of the mingw-w64 runtime package. 775 // No warranty is given; refer to the file DISCLAIMER.PD within this package. 776 777 type X__gnuc_va_list = X__builtin_va_list /* vadefs.h:24:29 */ 778 779 type Ssize_t = int64 /* crtdefs.h:45:35 */ 780 781 type Rsize_t = Size_t /* crtdefs.h:52:16 */ 782 783 type Intptr_t = int64 /* crtdefs.h:62:35 */ 784 785 type Uintptr_t = uint64 /* crtdefs.h:75:44 */ 786 787 type Wint_t = uint16 /* crtdefs.h:106:24 */ 788 type Wctype_t = uint16 /* crtdefs.h:107:24 */ 789 790 type Errno_t = int32 /* crtdefs.h:113:13 */ 791 792 type X__time32_t = int32 /* crtdefs.h:118:14 */ 793 794 type X__time64_t = int64 /* crtdefs.h:123:35 */ 795 796 type Time_t = X__time64_t /* crtdefs.h:138:20 */ 797 798 type Threadlocaleinfostruct = struct { 799 Frefcount int32 800 Flc_codepage uint32 801 Flc_collate_cp uint32 802 Flc_handle [6]uint32 803 Flc_id [6]LC_ID 804 Flc_category [6]struct { 805 Flocale uintptr 806 Fwlocale uintptr 807 Frefcount uintptr 808 Fwrefcount uintptr 809 } 810 Flc_clike int32 811 Fmb_cur_max int32 812 Flconv_intl_refcount uintptr 813 Flconv_num_refcount uintptr 814 Flconv_mon_refcount uintptr 815 Flconv uintptr 816 Fctype1_refcount uintptr 817 Fctype1 uintptr 818 Fpctype uintptr 819 Fpclmap uintptr 820 Fpcumap uintptr 821 Flc_time_curr uintptr 822 } /* crtdefs.h:422:1 */ 823 824 type Pthreadlocinfo = uintptr /* crtdefs.h:424:39 */ 825 type Pthreadmbcinfo = uintptr /* crtdefs.h:425:36 */ 826 827 type Localeinfo_struct = struct { 828 Flocinfo Pthreadlocinfo 829 Fmbcinfo Pthreadmbcinfo 830 } /* crtdefs.h:428:9 */ 831 832 type X_locale_tstruct = Localeinfo_struct /* crtdefs.h:431:3 */ 833 type X_locale_t = uintptr /* crtdefs.h:431:19 */ 834 835 type TagLC_ID = struct { 836 FwLanguage uint16 837 FwCountry uint16 838 FwCodePage uint16 839 } /* crtdefs.h:422:1 */ 840 841 type LC_ID = TagLC_ID /* crtdefs.h:439:3 */ 842 type LPLC_ID = uintptr /* crtdefs.h:439:9 */ 843 844 type Threadlocinfo = Threadlocaleinfostruct /* crtdefs.h:468:3 */ 845 846 // ISO C Standard: 7.17 Common definitions <stddef.h> 847 848 // Any one of these symbols __need_* means that GNU libc 849 // wants us just to define one data type. So don't define 850 // the symbols that indicate this file's entire job has been done. 851 // snaroff@next.com says the NeXT needs this. 852 // Irix 5.1 needs this. 853 854 // In 4.3bsd-net2, machine/ansi.h defines these symbols, which are 855 // defined if the corresponding type is *not* defined. 856 // FreeBSD-2.1 defines _MACHINE_ANSI_H_ instead of _ANSI_H_ 857 858 // Sequent's header files use _PTRDIFF_T_ in some conflicting way. 859 // Just ignore it. 860 861 // On VxWorks, <type/vxTypesBase.h> may have defined macros like 862 // _TYPE_size_t which will typedef size_t. fixincludes patched the 863 // vxTypesBase.h so that this macro is only defined if _GCC_SIZE_T is 864 // not defined, and so that defining this macro defines _GCC_SIZE_T. 865 // If we find that the macros are still defined at this point, we must 866 // invoke them so that the type is defined as expected. 867 868 // In case nobody has defined these types, but we aren't running under 869 // GCC 2.00, make sure that __PTRDIFF_TYPE__, __SIZE_TYPE__, and 870 // __WCHAR_TYPE__ have reasonable values. This can happen if the 871 // parts of GCC is compiled by an older compiler, that actually 872 // include gstddef.h, such as collect2. 873 874 // Signed type of difference of two pointers. 875 876 // Define this type if we are doing the whole job, 877 // or if we want this type in particular. 878 879 // If this symbol has done its job, get rid of it. 880 881 // Unsigned type of `sizeof' something. 882 883 // Define this type if we are doing the whole job, 884 // or if we want this type in particular. 885 886 // Wide character type. 887 // Locale-writers should change this as necessary to 888 // be big enough to hold unique values not between 0 and 127, 889 // and not (wchar_t) -1, for each defined multibyte character. 890 891 // Define this type if we are doing the whole job, 892 // or if we want this type in particular. 893 894 // In 4.3bsd-net2, leave these undefined to indicate that size_t, etc. 895 // are already defined. 896 // BSD/OS 3.1 and FreeBSD [23].x require the MACHINE_ANSI_H check here. 897 898 // A null pointer constant. 899 900 // Offset of member MEMBER in a struct of type TYPE. 901 902 // Type whose alignment is supported in every context and is at least 903 // as great as that of any standard type not using alignment 904 // specifiers. 905 type Max_align_t = struct { 906 F__max_align_ll int64 907 F__max_align_ld float64 908 } /* stddef.h:426:3 */ 909 910 // Copyright (C) 1989-2018 Free Software Foundation, Inc. 911 // 912 // This file is part of GCC. 913 // 914 // GCC is free software; you can redistribute it and/or modify 915 // it under the terms of the GNU General Public License as published by 916 // the Free Software Foundation; either version 3, or (at your option) 917 // any later version. 918 // 919 // GCC is distributed in the hope that it will be useful, 920 // but WITHOUT ANY WARRANTY; without even the implied warranty of 921 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 922 // GNU General Public License for more details. 923 // 924 // Under Section 7 of GPL version 3, you are granted additional 925 // permissions described in the GCC Runtime Library Exception, version 926 // 3.1, as published by the Free Software Foundation. 927 // 928 // You should have received a copy of the GNU General Public License and 929 // a copy of the GCC Runtime Library Exception along with this program; 930 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 931 // <http://www.gnu.org/licenses/>. 932 933 // ISO C Standard: 7.17 Common definitions <stddef.h> 934 type Z_size_t = Size_t /* zconf.h:248:21 */ 935 936 // Maximum value for memLevel in deflateInit2 937 938 // Maximum value for windowBits in deflateInit2 and inflateInit2. 939 // WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files 940 // created by gzip. (Files created by minigzip can still be extracted by 941 // gzip.) 942 943 // The memory requirements for deflate are (in bytes): 944 // (1 << (windowBits+2)) + (1 << (memLevel+9)) 945 // that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) 946 // plus a few kilobytes for small objects. For example, if you want to reduce 947 // the default memory requirements from 256K to 128K, compile with 948 // make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" 949 // Of course this will generally degrade compression (there's no free lunch). 950 // 951 // The memory requirements for inflate are (in bytes) 1 << windowBits 952 // that is, 32K for windowBits=15 (default value) plus about 7 kilobytes 953 // for small objects. 954 955 // Type declarations 956 957 // The following definitions for FAR are needed only for MSDOS mixed 958 // model programming (small or medium model with some far allocations). 959 // This was tested only with MSC; for other MSDOS compilers you may have 960 // to define NO_MEMCPY in zutil.h. If you don't need the mixed model, 961 // just define FAR to be empty. 962 963 // If building or using zlib as a DLL, define ZLIB_DLL. 964 // This is not mandatory, but it offers a little performance increase. 965 // If building or using zlib with the WINAPI/WINAPIV calling convention, 966 // define ZLIB_WINAPI. 967 // Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. 968 969 type Byte = uint8 /* zconf.h:391:24 */ // 8 bits 970 type UInt = uint32 /* zconf.h:393:24 */ // 16 bits or more 971 type ULong = uint32 /* zconf.h:394:24 */ // 32 bits or more 972 973 type Bytef = Byte /* zconf.h:400:22 */ 974 type Charf = int8 /* zconf.h:402:19 */ 975 type Intf = int32 /* zconf.h:403:19 */ 976 type UIntf = UInt /* zconf.h:404:19 */ 977 type ULongf = ULong /* zconf.h:405:19 */ 978 979 type Voidpc = uintptr /* zconf.h:408:23 */ 980 type Voidpf = uintptr /* zconf.h:409:23 */ 981 type Voidp = uintptr /* zconf.h:410:23 */ 982 983 // Copyright (C) 1992-2018 Free Software Foundation, Inc. 984 // 985 // This file is part of GCC. 986 // 987 // GCC is free software; you can redistribute it and/or modify it under 988 // the terms of the GNU General Public License as published by the Free 989 // Software Foundation; either version 3, or (at your option) any later 990 // version. 991 // 992 // GCC is distributed in the hope that it will be useful, but WITHOUT ANY 993 // WARRANTY; without even the implied warranty of MERCHANTABILITY or 994 // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 995 // for more details. 996 // 997 // Under Section 7 of GPL version 3, you are granted additional 998 // permissions described in the GCC Runtime Library Exception, version 999 // 3.1, as published by the Free Software Foundation. 1000 // 1001 // You should have received a copy of the GNU General Public License and 1002 // a copy of the GCC Runtime Library Exception along with this program; 1003 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 1004 // <http://www.gnu.org/licenses/>. 1005 1006 // This administrivia gets added to the beginning of limits.h 1007 // if the system has its own version of limits.h. 1008 1009 // We use _GCC_LIMITS_H_ because we want this not to match 1010 // any macros that the system's limits.h uses for its own purposes. 1011 1012 // Use "..." so that we find syslimits.h only in this same directory. 1013 // syslimits.h stands for the system's own limits.h file. 1014 // If we can use it ok unmodified, then we install this text. 1015 // If fixincludes fixes it, then the fixed version is installed 1016 // instead of this text. 1017 1018 // * 1019 // This file has no copyright assigned and is placed in the Public Domain. 1020 // This file is part of the mingw-w64 runtime package. 1021 // No warranty is given; refer to the file DISCLAIMER.PD within this package. 1022 // * 1023 // This file has no copyright assigned and is placed in the Public Domain. 1024 // This file is part of the mingw-w64 runtime package. 1025 // No warranty is given; refer to the file DISCLAIMER.PD within this package. 1026 1027 // File system limits 1028 // 1029 // NOTE: Apparently the actual size of PATH_MAX is 260, but a space is 1030 // required for the NUL. TODO: Test? 1031 // NOTE: PATH_MAX is the POSIX equivalent for Microsoft's MAX_PATH; the two 1032 // are semantically identical, with a limit of 259 characters for the 1033 // path name, plus one for a terminating NUL, for a total of 260. 1034 1035 // Copyright (C) 1991-2018 Free Software Foundation, Inc. 1036 // 1037 // This file is part of GCC. 1038 // 1039 // GCC is free software; you can redistribute it and/or modify it under 1040 // the terms of the GNU General Public License as published by the Free 1041 // Software Foundation; either version 3, or (at your option) any later 1042 // version. 1043 // 1044 // GCC is distributed in the hope that it will be useful, but WITHOUT ANY 1045 // WARRANTY; without even the implied warranty of MERCHANTABILITY or 1046 // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 1047 // for more details. 1048 // 1049 // Under Section 7 of GPL version 3, you are granted additional 1050 // permissions described in the GCC Runtime Library Exception, version 1051 // 3.1, as published by the Free Software Foundation. 1052 // 1053 // You should have received a copy of the GNU General Public License and 1054 // a copy of the GCC Runtime Library Exception along with this program; 1055 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 1056 // <http://www.gnu.org/licenses/>. 1057 1058 // Number of bits in a `char'. 1059 1060 // Maximum length of a multibyte character. 1061 1062 // Minimum and maximum values a `signed char' can hold. 1063 1064 // Maximum value an `unsigned char' can hold. (Minimum is 0). 1065 1066 // Minimum and maximum values a `char' can hold. 1067 1068 // Minimum and maximum values a `signed short int' can hold. 1069 1070 // Maximum value an `unsigned short int' can hold. (Minimum is 0). 1071 1072 // Minimum and maximum values a `signed int' can hold. 1073 1074 // Maximum value an `unsigned int' can hold. (Minimum is 0). 1075 1076 // Minimum and maximum values a `signed long int' can hold. 1077 // (Same as `int'). 1078 1079 // Maximum value an `unsigned long int' can hold. (Minimum is 0). 1080 1081 // Minimum and maximum values a `signed long long int' can hold. 1082 1083 // Maximum value an `unsigned long long int' can hold. (Minimum is 0). 1084 1085 // Minimum and maximum values a `signed long long int' can hold. 1086 1087 // Maximum value an `unsigned long long int' can hold. (Minimum is 0). 1088 1089 // This administrivia gets added to the end of limits.h 1090 // if the system has its own version of limits.h. 1091 1092 type Z_crc_t = uint32 /* zconf.h:429:17 */ 1093 1094 // * 1095 // This file has no copyright assigned and is placed in the Public Domain. 1096 // This file is part of the mingw-w64 runtime package. 1097 // No warranty is given; refer to the file DISCLAIMER.PD within this package. 1098 1099 // * 1100 // This file has no copyright assigned and is placed in the Public Domain. 1101 // This file is part of the mingw-w64 runtime package. 1102 // No warranty is given; refer to the file DISCLAIMER.PD within this package. 1103 1104 type X_ino_t = uint16 /* types.h:43:24 */ 1105 type Ino_t = uint16 /* types.h:45:24 */ 1106 1107 type X_dev_t = uint32 /* types.h:51:22 */ 1108 type Dev_t = uint32 /* types.h:53:22 */ 1109 1110 type X_pid_t = int64 /* types.h:63:17 */ 1111 1112 type Pid_t = X_pid_t /* types.h:68:16 */ 1113 1114 type X_mode_t = uint16 /* types.h:74:24 */ 1115 1116 type Mode_t = X_mode_t /* types.h:77:17 */ 1117 1118 type X_off_t = int32 /* _mingw_off_t.h:5:16 */ 1119 type Off32_t = int32 /* _mingw_off_t.h:7:16 */ 1120 1121 type X_off64_t = int64 /* _mingw_off_t.h:13:39 */ 1122 type Off64_t = int64 /* _mingw_off_t.h:15:39 */ 1123 1124 type Off_t = Off64_t /* _mingw_off_t.h:24:17 */ 1125 1126 type Useconds_t = uint32 /* types.h:84:22 */ 1127 1128 type Timespec = struct { 1129 Ftv_sec Time_t 1130 Ftv_nsec int32 1131 F__ccgo_pad1 [4]byte 1132 } /* types.h:89:1 */ 1133 1134 type Itimerspec = struct { 1135 Fit_interval struct { 1136 Ftv_sec Time_t 1137 Ftv_nsec int32 1138 F__ccgo_pad1 [4]byte 1139 } 1140 Fit_value struct { 1141 Ftv_sec Time_t 1142 Ftv_nsec int32 1143 F__ccgo_pad1 [4]byte 1144 } 1145 } /* types.h:94:1 */ 1146 1147 type X_sigset_t = uint64 /* types.h:104:28 */ 1148 1149 // Copyright (C) 1989, 1997, 1998, 1999, 2000 Free Software Foundation, Inc. 1150 // 1151 // This file is part of GCC. 1152 // 1153 // GCC is free software; you can redistribute it and/or modify 1154 // it under the terms of the GNU General Public License as published by 1155 // the Free Software Foundation; either version 2, or (at your option) 1156 // any later version. 1157 // 1158 // GCC is distributed in the hope that it will be useful, 1159 // but WITHOUT ANY WARRANTY; without even the implied warranty of 1160 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1161 // GNU General Public License for more details. 1162 // 1163 // You should have received a copy of the GNU General Public License 1164 // along with GCC; see the file COPYING. If not, write to 1165 // the Free Software Foundation, 51 Franklin Street, Fifth Floor, 1166 // Boston, MA 02110-1301, USA. 1167 1168 // As a special exception, if you include this header file into source 1169 // files compiled by GCC, this header file does not by itself cause 1170 // the resulting executable to be covered by the GNU General Public 1171 // License. This exception does not however invalidate any other 1172 // reasons why the executable file might be covered by the GNU General 1173 // Public License. 1174 1175 // ISO C Standard: 7.15 Variable arguments <stdarg.h> 1176 1177 // Define __gnuc_va_list. 1178 1179 // Define the standard macros for the user, 1180 // if this invocation was from the user program. 1181 1182 // Define va_list, if desired, from __gnuc_va_list. 1183 // We deliberately do not define va_list when called from 1184 // stdio.h, because ANSI C says that stdio.h is not supposed to define 1185 // va_list. stdio.h needs to have access to that data type, 1186 // but must not use that name. It should use the name __gnuc_va_list, 1187 // which is safe because it is reserved for the implementation. 1188 1189 // The macro _VA_LIST_ is the same thing used by this file in Ultrix. 1190 // But on BSD NET2 we must not test or define or undef it. 1191 // (Note that the comments in NET 2's ansi.h 1192 // are incorrect for _VA_LIST_--see stdio.h!) 1193 // The macro _VA_LIST_DEFINED is used in Windows NT 3.5 1194 1195 // include mingw stuff 1196 // * 1197 // This file has no copyright assigned and is placed in the Public Domain. 1198 // This file is part of the mingw-w64 runtime package. 1199 // No warranty is given; refer to the file DISCLAIMER.PD within this package. 1200 1201 // * 1202 // This file has no copyright assigned and is placed in the Public Domain. 1203 // This file is part of the mingw-w64 runtime package. 1204 // No warranty is given; refer to the file DISCLAIMER.PD within this package. 1205 1206 // Copyright (C) 1989-2018 Free Software Foundation, Inc. 1207 // 1208 // This file is part of GCC. 1209 // 1210 // GCC is free software; you can redistribute it and/or modify 1211 // it under the terms of the GNU General Public License as published by 1212 // the Free Software Foundation; either version 3, or (at your option) 1213 // any later version. 1214 // 1215 // GCC is distributed in the hope that it will be useful, 1216 // but WITHOUT ANY WARRANTY; without even the implied warranty of 1217 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1218 // GNU General Public License for more details. 1219 // 1220 // Under Section 7 of GPL version 3, you are granted additional 1221 // permissions described in the GCC Runtime Library Exception, version 1222 // 3.1, as published by the Free Software Foundation. 1223 // 1224 // You should have received a copy of the GNU General Public License and 1225 // a copy of the GCC Runtime Library Exception along with this program; 1226 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 1227 // <http://www.gnu.org/licenses/>. 1228 1229 // ISO C Standard: 7.15 Variable arguments <stdarg.h> 1230 1231 // * 1232 // This file has no copyright assigned and is placed in the Public Domain. 1233 // This file is part of the mingw-w64 runtime package. 1234 // No warranty is given; refer to the file DISCLAIMER.PD within this package. 1235 1236 // * 1237 // This file has no copyright assigned and is placed in the Public Domain. 1238 // This file is part of the mingw-w64 runtime package. 1239 // No warranty is given; refer to the file DISCLAIMER.PD within this package. 1240 1241 // ISO C Standard: 7.17 Common definitions <stddef.h> 1242 1243 // Copyright (C) 1989-2018 Free Software Foundation, Inc. 1244 // 1245 // This file is part of GCC. 1246 // 1247 // GCC is free software; you can redistribute it and/or modify 1248 // it under the terms of the GNU General Public License as published by 1249 // the Free Software Foundation; either version 3, or (at your option) 1250 // any later version. 1251 // 1252 // GCC is distributed in the hope that it will be useful, 1253 // but WITHOUT ANY WARRANTY; without even the implied warranty of 1254 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1255 // GNU General Public License for more details. 1256 // 1257 // Under Section 7 of GPL version 3, you are granted additional 1258 // permissions described in the GCC Runtime Library Exception, version 1259 // 3.1, as published by the Free Software Foundation. 1260 // 1261 // You should have received a copy of the GNU General Public License and 1262 // a copy of the GCC Runtime Library Exception along with this program; 1263 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 1264 // <http://www.gnu.org/licenses/>. 1265 1266 // ISO C Standard: 7.17 Common definitions <stddef.h> 1267 1268 // a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and 1269 // "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even 1270 // though the former does not conform to the LFS document), but considering 1271 // both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as 1272 // equivalently requesting no 64-bit operations 1273 1274 // MVS linker does not support external names larger than 8 bytes 1275 1276 // 1277 // The 'zlib' compression library provides in-memory compression and 1278 // decompression functions, including integrity checks of the uncompressed data. 1279 // This version of the library supports only one compression method (deflation) 1280 // but other algorithms will be added later and will have the same stream 1281 // interface. 1282 // 1283 // Compression can be done in a single step if the buffers are large enough, 1284 // or can be done by repeated calls of the compression function. In the latter 1285 // case, the application must provide more input and/or consume the output 1286 // (providing more output space) before each call. 1287 // 1288 // The compressed data format used by default by the in-memory functions is 1289 // the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped 1290 // around a deflate stream, which is itself documented in RFC 1951. 1291 // 1292 // The library also supports reading and writing files in gzip (.gz) format 1293 // with an interface similar to that of stdio using the functions that start 1294 // with "gz". The gzip format is different from the zlib format. gzip is a 1295 // gzip wrapper, documented in RFC 1952, wrapped around a deflate stream. 1296 // 1297 // This library can optionally read and write gzip and raw deflate streams in 1298 // memory as well. 1299 // 1300 // The zlib format was designed to be compact and fast for use in memory 1301 // and on communications channels. The gzip format was designed for single- 1302 // file compression on file systems, has a larger header than zlib to maintain 1303 // directory information, and uses a different, slower check method than zlib. 1304 // 1305 // The library does not install any signal handler. The decoder checks 1306 // the consistency of the compressed data, so the library should never crash 1307 // even in the case of corrupted input. 1308 1309 type Alloc_func = uintptr /* zlib.h:81:16 */ 1310 type Free_func = uintptr /* zlib.h:82:16 */ 1311 1312 type Internal_state = struct { 1313 Fstrm Z_streamp 1314 Fstatus int32 1315 F__ccgo_pad1 [4]byte 1316 Fpending_buf uintptr 1317 Fpending_buf_size Ulg 1318 F__ccgo_pad2 [4]byte 1319 Fpending_out uintptr 1320 Fpending Ulg 1321 Fwrap int32 1322 Fgzhead Gz_headerp 1323 Fgzindex Ulg 1324 Fmethod Byte 1325 F__ccgo_pad3 [3]byte 1326 Flast_flush int32 1327 Fw_size UInt 1328 Fw_bits UInt 1329 Fw_mask UInt 1330 Fwindow uintptr 1331 Fwindow_size Ulg 1332 F__ccgo_pad4 [4]byte 1333 Fprev uintptr 1334 Fhead uintptr 1335 Fins_h UInt 1336 Fhash_size UInt 1337 Fhash_bits UInt 1338 Fhash_mask UInt 1339 Fhash_shift UInt 1340 Fblock_start int32 1341 Fmatch_length UInt 1342 Fprev_match IPos 1343 Fmatch_available int32 1344 Fstrstart UInt 1345 Fmatch_start UInt 1346 Flookahead UInt 1347 Fprev_length UInt 1348 Fmax_chain_length UInt 1349 Fmax_lazy_match UInt 1350 Flevel int32 1351 Fstrategy int32 1352 Fgood_match UInt 1353 Fnice_match int32 1354 Fdyn_ltree [573]struct { 1355 Ffc struct{ Ffreq Ush } 1356 Fdl struct{ Fdad Ush } 1357 } 1358 Fdyn_dtree [61]struct { 1359 Ffc struct{ Ffreq Ush } 1360 Fdl struct{ Fdad Ush } 1361 } 1362 Fbl_tree [39]struct { 1363 Ffc struct{ Ffreq Ush } 1364 Fdl struct{ Fdad Ush } 1365 } 1366 Fl_desc struct { 1367 Fdyn_tree uintptr 1368 Fmax_code int32 1369 F__ccgo_pad1 [4]byte 1370 Fstat_desc uintptr 1371 } 1372 Fd_desc struct { 1373 Fdyn_tree uintptr 1374 Fmax_code int32 1375 F__ccgo_pad1 [4]byte 1376 Fstat_desc uintptr 1377 } 1378 Fbl_desc struct { 1379 Fdyn_tree uintptr 1380 Fmax_code int32 1381 F__ccgo_pad1 [4]byte 1382 Fstat_desc uintptr 1383 } 1384 Fbl_count [16]Ush 1385 Fheap [573]int32 1386 Fheap_len int32 1387 Fheap_max int32 1388 Fdepth [573]Uch 1389 F__ccgo_pad5 [7]byte 1390 Fl_buf uintptr 1391 Flit_bufsize UInt 1392 Flast_lit UInt 1393 Fd_buf uintptr 1394 Fopt_len Ulg 1395 Fstatic_len Ulg 1396 Fmatches UInt 1397 Finsert UInt 1398 Fbi_buf Ush 1399 F__ccgo_pad6 [2]byte 1400 Fbi_valid int32 1401 Fhigh_water Ulg 1402 F__ccgo_pad7 [4]byte 1403 } /* zlib.h:84:1 */ 1404 1405 type Z_stream_s = struct { 1406 Fnext_in uintptr 1407 Favail_in UInt 1408 Ftotal_in ULong 1409 Fnext_out uintptr 1410 Favail_out UInt 1411 Ftotal_out ULong 1412 Fmsg uintptr 1413 Fstate uintptr 1414 Fzalloc Alloc_func 1415 Fzfree Free_func 1416 Fopaque Voidpf 1417 Fdata_type int32 1418 Fadler ULong 1419 Freserved ULong 1420 F__ccgo_pad1 [4]byte 1421 } /* zlib.h:86:9 */ 1422 1423 type Z_stream = Z_stream_s /* zlib.h:106:3 */ 1424 1425 type Z_streamp = uintptr /* zlib.h:108:22 */ 1426 1427 // 1428 // gzip header information passed to and from zlib routines. See RFC 1952 1429 // for more details on the meanings of these fields. 1430 type Gz_header_s = struct { 1431 Ftext int32 1432 Ftime ULong 1433 Fxflags int32 1434 Fos int32 1435 Fextra uintptr 1436 Fextra_len UInt 1437 Fextra_max UInt 1438 Fname uintptr 1439 Fname_max UInt 1440 F__ccgo_pad1 [4]byte 1441 Fcomment uintptr 1442 Fcomm_max UInt 1443 Fhcrc int32 1444 Fdone int32 1445 F__ccgo_pad2 [4]byte 1446 } /* zlib.h:114:9 */ 1447 1448 // 1449 // gzip header information passed to and from zlib routines. See RFC 1952 1450 // for more details on the meanings of these fields. 1451 type Gz_header = Gz_header_s /* zlib.h:129:3 */ 1452 1453 type Gz_headerp = uintptr /* zlib.h:131:23 */ 1454 // 1455 // inflateGetHeader() requests that gzip header information be stored in the 1456 // provided gz_header structure. inflateGetHeader() may be called after 1457 // inflateInit2() or inflateReset(), and before the first call of inflate(). 1458 // As inflate() processes the gzip stream, head->done is zero until the header 1459 // is completed, at which time head->done is set to one. If a zlib stream is 1460 // being decoded, then head->done is set to -1 to indicate that there will be 1461 // no gzip header information forthcoming. Note that Z_BLOCK or Z_TREES can be 1462 // used to force inflate() to return immediately after header processing is 1463 // complete and before any actual data is decompressed. 1464 // 1465 // The text, time, xflags, and os fields are filled in with the gzip header 1466 // contents. hcrc is set to true if there is a header CRC. (The header CRC 1467 // was valid if done is set to one.) If extra is not Z_NULL, then extra_max 1468 // contains the maximum number of bytes to write to extra. Once done is true, 1469 // extra_len contains the actual extra field length, and extra contains the 1470 // extra field, or that field truncated if extra_max is less than extra_len. 1471 // If name is not Z_NULL, then up to name_max characters are written there, 1472 // terminated with a zero unless the length is greater than name_max. If 1473 // comment is not Z_NULL, then up to comm_max characters are written there, 1474 // terminated with a zero unless the length is greater than comm_max. When any 1475 // of extra, name, or comment are not Z_NULL and the respective field is not 1476 // present in the header, then that field is set to Z_NULL to signal its 1477 // absence. This allows the use of deflateSetHeader() with the returned 1478 // structure to duplicate the header. However if those fields are set to 1479 // allocated memory, then the application will need to save those pointers 1480 // elsewhere so that they can be eventually freed. 1481 // 1482 // If inflateGetHeader is not used, then the header information is simply 1483 // discarded. The header is always checked for validity, including the header 1484 // CRC if present. inflateReset() will reset the process to discard the header 1485 // information. The application would need to call inflateGetHeader() again to 1486 // retrieve the header from the next gzip stream. 1487 // 1488 // inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source 1489 // stream state was inconsistent. 1490 1491 // 1492 // ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits, 1493 // unsigned char FAR *window)); 1494 // 1495 // Initialize the internal stream state for decompression using inflateBack() 1496 // calls. The fields zalloc, zfree and opaque in strm must be initialized 1497 // before the call. If zalloc and zfree are Z_NULL, then the default library- 1498 // derived memory allocation routines are used. windowBits is the base two 1499 // logarithm of the window size, in the range 8..15. window is a caller 1500 // supplied buffer of that size. Except for special applications where it is 1501 // assured that deflate was used with small window sizes, windowBits must be 15 1502 // and a 32K byte window must be supplied to be able to decompress general 1503 // deflate streams. 1504 // 1505 // See inflateBack() for the usage of these routines. 1506 // 1507 // inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of 1508 // the parameters are invalid, Z_MEM_ERROR if the internal state could not be 1509 // allocated, or Z_VERSION_ERROR if the version of the library does not match 1510 // the version of the header file. 1511 1512 type In_func = uintptr /* zlib.h:1092:18 */ 1513 type Out_func = uintptr /* zlib.h:1094:13 */ 1514 // 1515 // Same as uncompress, except that sourceLen is a pointer, where the 1516 // length of the source is *sourceLen. On return, *sourceLen is the number of 1517 // source bytes consumed. 1518 1519 // gzip file access functions 1520 1521 // 1522 // This library supports reading and writing files in gzip (.gz) format with 1523 // an interface similar to that of stdio, using the functions that start with 1524 // "gz". The gzip format is different from the zlib format. gzip is a gzip 1525 // wrapper, documented in RFC 1952, wrapped around a deflate stream. 1526 1527 type GzFile_s = struct { 1528 Fhave uint32 1529 F__ccgo_pad1 [4]byte 1530 Fnext uintptr 1531 Fpos int32 1532 F__ccgo_pad2 [4]byte 1533 } /* zlib.h:1300:9 */ 1534 1535 // 1536 // Same as uncompress, except that sourceLen is a pointer, where the 1537 // length of the source is *sourceLen. On return, *sourceLen is the number of 1538 // source bytes consumed. 1539 1540 // gzip file access functions 1541 1542 // 1543 // This library supports reading and writing files in gzip (.gz) format with 1544 // an interface similar to that of stdio, using the functions that start with 1545 // "gz". The gzip format is different from the zlib format. gzip is a gzip 1546 // wrapper, documented in RFC 1952, wrapped around a deflate stream. 1547 1548 type GzFile = uintptr /* zlib.h:1300:25 */ 1549 1550 // * 1551 // This file has no copyright assigned and is placed in the Public Domain. 1552 // This file is part of the mingw-w64 runtime package. 1553 // No warranty is given; refer to the file DISCLAIMER.PD within this package. 1554 1555 // * 1556 // This file has no copyright assigned and is placed in the Public Domain. 1557 // This file is part of the mingw-w64 runtime package. 1558 // No warranty is given; refer to the file DISCLAIMER.PD within this package. 1559 1560 // Copyright (C) 1992-2018 Free Software Foundation, Inc. 1561 // 1562 // This file is part of GCC. 1563 // 1564 // GCC is free software; you can redistribute it and/or modify it under 1565 // the terms of the GNU General Public License as published by the Free 1566 // Software Foundation; either version 3, or (at your option) any later 1567 // version. 1568 // 1569 // GCC is distributed in the hope that it will be useful, but WITHOUT ANY 1570 // WARRANTY; without even the implied warranty of MERCHANTABILITY or 1571 // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 1572 // for more details. 1573 // 1574 // Under Section 7 of GPL version 3, you are granted additional 1575 // permissions described in the GCC Runtime Library Exception, version 1576 // 3.1, as published by the Free Software Foundation. 1577 // 1578 // You should have received a copy of the GNU General Public License and 1579 // a copy of the GCC Runtime Library Exception along with this program; 1580 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 1581 // <http://www.gnu.org/licenses/>. 1582 1583 // This administrivia gets added to the beginning of limits.h 1584 // if the system has its own version of limits.h. 1585 1586 // We use _GCC_LIMITS_H_ because we want this not to match 1587 // any macros that the system's limits.h uses for its own purposes. 1588 1589 type X_onexit_t = uintptr /* stdlib.h:49:15 */ 1590 1591 type X_div_t = struct { 1592 Fquot int32 1593 Frem int32 1594 } /* stdlib.h:59:11 */ 1595 1596 type Div_t = X_div_t /* stdlib.h:62:5 */ 1597 1598 type X_ldiv_t = struct { 1599 Fquot int32 1600 Frem int32 1601 } /* stdlib.h:64:11 */ 1602 1603 type Ldiv_t = X_ldiv_t /* stdlib.h:67:5 */ 1604 1605 type X_LDOUBLE = struct{ Fld [10]uint8 } /* stdlib.h:76:5 */ 1606 1607 type X_CRT_DOUBLE = struct{ Fx float64 } /* stdlib.h:83:5 */ 1608 1609 type X_CRT_FLOAT = struct{ Ff float32 } /* stdlib.h:87:5 */ 1610 1611 type X_LONGDOUBLE = struct{ Fx float64 } /* stdlib.h:94:5 */ 1612 1613 type X_LDBL12 = struct{ Fld12 [12]uint8 } /* stdlib.h:101:5 */ 1614 1615 type X_purecall_handler = uintptr /* stdlib.h:142:16 */ 1616 1617 type X_invalid_parameter_handler = uintptr /* stdlib.h:147:16 */ 1618 1619 type Lldiv_t = struct { 1620 Fquot int64 1621 Frem int64 1622 } /* stdlib.h:699:61 */ 1623 1624 // * 1625 // This file has no copyright assigned and is placed in the Public Domain. 1626 // This file is part of the mingw-w64 runtime package. 1627 // No warranty is given; refer to the file DISCLAIMER.PD within this package. 1628 1629 // * 1630 // This file has no copyright assigned and is placed in the Public Domain. 1631 // This file is part of the mingw-w64 runtime package. 1632 // No warranty is given; refer to the file DISCLAIMER.PD within this package. 1633 1634 // Return codes for _heapwalk() 1635 1636 // Values for _heapinfo.useflag 1637 1638 // The structure used to walk through the heap with _heapwalk. 1639 type X_heapinfo = struct { 1640 F_pentry uintptr 1641 F_size Size_t 1642 F_useflag int32 1643 F__ccgo_pad1 [4]byte 1644 } /* malloc.h:46:11 */ 1645 1646 // * 1647 // This file has no copyright assigned and is placed in the Public Domain. 1648 // This file is part of the mingw-w64 runtime package. 1649 // No warranty is given; refer to the file DISCLAIMER.PD within this package. 1650 1651 // * 1652 // This file has no copyright assigned and is placed in the Public Domain. 1653 // This file is part of the mingw-w64 runtime package. 1654 // No warranty is given; refer to the file DISCLAIMER.PD within this package. 1655 1656 // Return codes for _heapwalk() 1657 1658 // Values for _heapinfo.useflag 1659 1660 // The structure used to walk through the heap with _heapwalk. 1661 type X_HEAPINFO = X_heapinfo /* malloc.h:50:5 */ 1662 1663 // since "static" is used to mean two completely different things in C, we 1664 // define "local" for the non-static meaning of "static", for readability 1665 // (compile with -Dlocal if your debugger can't find static symbols) 1666 1667 type Uch = uint8 /* zutil.h:43:24 */ 1668 type Uchf = Uch /* zutil.h:44:17 */ 1669 type Ush = uint16 /* zutil.h:45:24 */ 1670 type Ushf = Ush /* zutil.h:46:17 */ 1671 type Ulg = uint32 /* zutil.h:47:24 */ 1672 1673 // NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 1674 1675 // use NO_DIVIDE if your processor does not do division in hardware -- 1676 // try it both ways to see which is faster 1677 1678 // ========================================================================= 1679 func Xadler32_z(tls *libc.TLS, adler ULong, buf uintptr, len Z_size_t) ULong { /* adler32.c:63:15: */ 1680 var sum2 uint32 1681 var n uint32 1682 1683 // split Adler-32 into component sums 1684 sum2 = ((adler >> 16) & ULong(0xffff)) 1685 adler = adler & (ULong(0xffff)) 1686 1687 // in case user likes doing a byte at a time, keep it fast 1688 if len == uint64(1) { 1689 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer(buf)))) 1690 if adler >= BASE { 1691 adler = adler - (BASE) 1692 } 1693 sum2 = sum2 + (adler) 1694 if sum2 >= BASE { 1695 sum2 = sum2 - (BASE) 1696 } 1697 return (adler | (sum2 << 16)) 1698 } 1699 1700 // initial Adler-32 value (deferred check for len == 1 speed) 1701 if buf == uintptr(Z_NULL) { 1702 return ULong(1) 1703 } 1704 1705 // in case short lengths are provided, keep it somewhat fast 1706 if len < uint64(16) { 1707 for libc.PostDecUint64(&len, 1) != 0 { 1708 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer(libc.PostIncUintptr(&buf, 1))))) 1709 sum2 = sum2 + (adler) 1710 } 1711 if adler >= BASE { 1712 adler = adler - (BASE) 1713 } 1714 sum2 = sum2 % (BASE) // only added so many BASE's 1715 return (adler | (sum2 << 16)) 1716 } 1717 1718 // do length NMAX blocks -- requires just one modulo operation 1719 for len >= uint64(NMAX) { 1720 len = len - (uint64(NMAX)) 1721 n = (uint32(NMAX / 16)) // NMAX is divisible by 16 1722 for ok := true; ok; ok = libc.PreDecUint32(&n, 1) != 0 { 1723 { 1724 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf))))) 1725 sum2 = sum2 + (adler) 1726 } 1727 { 1728 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 1)))) 1729 sum2 = sum2 + (adler) 1730 } 1731 1732 { 1733 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 2)))) 1734 sum2 = sum2 + (adler) 1735 } 1736 { 1737 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 3)))) 1738 sum2 = sum2 + (adler) 1739 } 1740 1741 { 1742 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 4)))) 1743 sum2 = sum2 + (adler) 1744 } 1745 { 1746 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 5)))) 1747 sum2 = sum2 + (adler) 1748 } 1749 1750 { 1751 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 6)))) 1752 sum2 = sum2 + (adler) 1753 } 1754 { 1755 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 7)))) 1756 sum2 = sum2 + (adler) 1757 } 1758 1759 { 1760 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 8)))) 1761 sum2 = sum2 + (adler) 1762 } 1763 { 1764 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 9)))) 1765 sum2 = sum2 + (adler) 1766 } 1767 1768 { 1769 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 10)))) 1770 sum2 = sum2 + (adler) 1771 } 1772 { 1773 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 11)))) 1774 sum2 = sum2 + (adler) 1775 } 1776 1777 { 1778 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 12)))) 1779 sum2 = sum2 + (adler) 1780 } 1781 { 1782 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 13)))) 1783 sum2 = sum2 + (adler) 1784 } 1785 1786 { 1787 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 14)))) 1788 sum2 = sum2 + (adler) 1789 } 1790 { 1791 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 15)))) 1792 sum2 = sum2 + (adler) 1793 } 1794 1795 // 16 sums unrolled 1796 buf += uintptr(16) 1797 } 1798 adler = adler % (BASE) 1799 sum2 = sum2 % (BASE) 1800 } 1801 1802 // do remaining bytes (less than NMAX, still just one modulo) 1803 if len != 0 { // avoid modulos if none remaining 1804 for len >= uint64(16) { 1805 len = len - (uint64(16)) 1806 { 1807 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf))))) 1808 sum2 = sum2 + (adler) 1809 } 1810 { 1811 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 1)))) 1812 sum2 = sum2 + (adler) 1813 } 1814 1815 { 1816 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 2)))) 1817 sum2 = sum2 + (adler) 1818 } 1819 { 1820 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 3)))) 1821 sum2 = sum2 + (adler) 1822 } 1823 1824 { 1825 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 4)))) 1826 sum2 = sum2 + (adler) 1827 } 1828 { 1829 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 5)))) 1830 sum2 = sum2 + (adler) 1831 } 1832 1833 { 1834 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 6)))) 1835 sum2 = sum2 + (adler) 1836 } 1837 { 1838 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 7)))) 1839 sum2 = sum2 + (adler) 1840 } 1841 1842 { 1843 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 8)))) 1844 sum2 = sum2 + (adler) 1845 } 1846 { 1847 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 9)))) 1848 sum2 = sum2 + (adler) 1849 } 1850 1851 { 1852 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 10)))) 1853 sum2 = sum2 + (adler) 1854 } 1855 { 1856 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 11)))) 1857 sum2 = sum2 + (adler) 1858 } 1859 1860 { 1861 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 12)))) 1862 sum2 = sum2 + (adler) 1863 } 1864 { 1865 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 13)))) 1866 sum2 = sum2 + (adler) 1867 } 1868 1869 { 1870 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 14)))) 1871 sum2 = sum2 + (adler) 1872 } 1873 { 1874 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer((buf) + 15)))) 1875 sum2 = sum2 + (adler) 1876 } 1877 1878 buf += uintptr(16) 1879 } 1880 for libc.PostDecUint64(&len, 1) != 0 { 1881 adler = adler + (ULong(*(*Bytef)(unsafe.Pointer(libc.PostIncUintptr(&buf, 1))))) 1882 sum2 = sum2 + (adler) 1883 } 1884 adler = adler % (BASE) 1885 sum2 = sum2 % (BASE) 1886 } 1887 1888 // return recombined sums 1889 return (adler | (sum2 << 16)) 1890 } 1891 1892 // ========================================================================= 1893 func Xadler32(tls *libc.TLS, adler ULong, buf uintptr, len UInt) ULong { /* adler32.c:134:15: */ 1894 return Xadler32_z(tls, adler, buf, uint64(len)) 1895 } 1896 1897 // ========================================================================= 1898 func adler32_combine_(tls *libc.TLS, adler1 ULong, adler2 ULong, len2 int32) ULong { /* adler32.c:143:13: */ 1899 var sum1 uint32 1900 var sum2 uint32 1901 var rem uint32 1902 1903 // for negative len, return invalid adler32 as a clue for debugging 1904 if len2 < 0 { 1905 return 0xffffffff 1906 } 1907 1908 // the derivation of this formula is left as an exercise for the reader 1909 len2 = int32(uint32(len2) % (BASE)) // assumes len2 >= 0 1910 rem = uint32(len2) 1911 sum1 = (adler1 & ULong(0xffff)) 1912 sum2 = (uint32(rem) * sum1) 1913 sum2 = sum2 % (BASE) 1914 sum1 = sum1 + (((adler2 & ULong(0xffff)) + BASE) - ULong(1)) 1915 sum2 = sum2 + (((((adler1 >> 16) & ULong(0xffff)) + ((adler2 >> 16) & ULong(0xffff))) + BASE) - ULong(rem)) 1916 if sum1 >= BASE { 1917 sum1 = sum1 - (BASE) 1918 } 1919 if sum1 >= BASE { 1920 sum1 = sum1 - (BASE) 1921 } 1922 if sum2 >= (uint32(BASE) << 1) { 1923 sum2 = sum2 - (uint32(BASE) << 1) 1924 } 1925 if sum2 >= BASE { 1926 sum2 = sum2 - (BASE) 1927 } 1928 return (sum1 | (sum2 << 16)) 1929 } 1930 1931 // ========================================================================= 1932 func Xadler32_combine(tls *libc.TLS, adler1 ULong, adler2 ULong, len2 int32) ULong { /* adler32.c:172:15: */ 1933 return adler32_combine_(tls, adler1, adler2, len2) 1934 } 1935 1936 func Xadler32_combine64(tls *libc.TLS, adler1 ULong, adler2 ULong, len2 int32) ULong { /* adler32.c:180:15: */ 1937 return adler32_combine_(tls, adler1, adler2, len2) 1938 } 1939 1940 // =========================================================================== 1941 // Compresses the source buffer into the destination buffer. The level 1942 // parameter has the same meaning as in deflateInit. sourceLen is the byte 1943 // length of the source buffer. Upon entry, destLen is the total size of the 1944 // destination buffer, which must be at least 0.1% larger than sourceLen plus 1945 // 12 bytes. Upon exit, destLen is the actual size of the compressed buffer. 1946 // 1947 // compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough 1948 // memory, Z_BUF_ERROR if there was not enough room in the output buffer, 1949 // Z_STREAM_ERROR if the level parameter is invalid. 1950 func Xcompress2(tls *libc.TLS, dest uintptr, destLen uintptr, source uintptr, sourceLen ULong, level int32) int32 { /* compress.c:22:13: */ 1951 bp := tls.Alloc(88) 1952 defer tls.Free(88) 1953 1954 // var stream Z_stream at bp, 88 1955 1956 var err int32 1957 var max UInt = libc.Uint32(libc.Uint32FromInt32(-1)) 1958 var left ULong 1959 1960 left = *(*ULongf)(unsafe.Pointer(destLen)) 1961 *(*ULongf)(unsafe.Pointer(destLen)) = ULongf(0) 1962 1963 (*Z_stream)(unsafe.Pointer(bp /* &stream */)).Fzalloc = uintptr(0) 1964 (*Z_stream)(unsafe.Pointer(bp /* &stream */)).Fzfree = uintptr(0) 1965 (*Z_stream)(unsafe.Pointer(bp /* &stream */)).Fopaque = uintptr(0) 1966 1967 err = XdeflateInit_(tls, bp /* &stream */, level, ts /* "1.2.11" */, int32(unsafe.Sizeof(Z_stream{}))) 1968 if err != Z_OK { 1969 return err 1970 } 1971 1972 (*Z_stream)(unsafe.Pointer(bp /* &stream */)).Fnext_out = dest 1973 (*Z_stream)(unsafe.Pointer(bp /* &stream */)).Favail_out = UInt(0) 1974 (*Z_stream)(unsafe.Pointer(bp /* &stream */)).Fnext_in = source 1975 (*Z_stream)(unsafe.Pointer(bp /* &stream */)).Favail_in = UInt(0) 1976 1977 for ok := true; ok; ok = (err == Z_OK) { 1978 if (*Z_stream)(unsafe.Pointer(bp /* &stream */)).Favail_out == UInt(0) { 1979 (*Z_stream)(unsafe.Pointer(bp /* &stream */)).Favail_out = func() uint32 { 1980 if left > ULong(max) { 1981 return max 1982 } 1983 return UInt(left) 1984 }() 1985 left = left - (ULong((*Z_stream)(unsafe.Pointer(bp /* &stream */)).Favail_out)) 1986 } 1987 if (*Z_stream)(unsafe.Pointer(bp /* &stream */)).Favail_in == UInt(0) { 1988 (*Z_stream)(unsafe.Pointer(bp /* &stream */)).Favail_in = func() uint32 { 1989 if sourceLen > ULong(max) { 1990 return max 1991 } 1992 return UInt(sourceLen) 1993 }() 1994 sourceLen = sourceLen - (ULong((*Z_stream)(unsafe.Pointer(bp /* &stream */)).Favail_in)) 1995 } 1996 err = Xdeflate(tls, bp /* &stream */, func() int32 { 1997 if sourceLen != 0 { 1998 return Z_NO_FLUSH 1999 } 2000 return Z_FINISH 2001 }()) 2002 } 2003 2004 *(*ULongf)(unsafe.Pointer(destLen)) = (*Z_stream)(unsafe.Pointer(bp /* &stream */)).Ftotal_out 2005 XdeflateEnd(tls, bp /* &stream */) 2006 if err == Z_STREAM_END { 2007 return Z_OK 2008 } 2009 return err 2010 } 2011 2012 // =========================================================================== 2013 func Xcompress(tls *libc.TLS, dest uintptr, destLen uintptr, source uintptr, sourceLen ULong) int32 { /* compress.c:68:13: */ 2014 return Xcompress2(tls, dest, destLen, source, sourceLen, -1) 2015 } 2016 2017 // =========================================================================== 2018 // If the default memLevel or windowBits for deflateInit() is changed, then 2019 // this function needs to be updated. 2020 // 2021 func XcompressBound(tls *libc.TLS, sourceLen ULong) ULong { /* compress.c:81:15: */ 2022 return ((((sourceLen + (sourceLen >> 12)) + (sourceLen >> 14)) + (sourceLen >> 25)) + ULong(13)) 2023 } 2024 2025 // ======================================================================== 2026 // Tables of CRC-32s of all single-byte values, made by make_crc_table(). 2027 // crc32.h -- tables for rapid CRC calculation 2028 // Generated automatically by crc32.c 2029 2030 var crc_table = [8][256]Z_crc_t{ 2031 { 2032 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 2033 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 2034 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 2035 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 2036 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 2037 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 2038 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 2039 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 2040 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 2041 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 2042 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 2043 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 2044 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 2045 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 2046 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 2047 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 2048 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 2049 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 2050 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 2051 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 2052 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 2053 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 2054 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 2055 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 2056 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 2057 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 2058 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 2059 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 2060 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 2061 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 2062 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 2063 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 2064 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 2065 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 2066 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 2067 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 2068 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 2069 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 2070 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 2071 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 2072 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 2073 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 2074 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 2075 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 2076 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, 2077 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 2078 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 2079 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 2080 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 2081 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 2082 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 2083 0x2d02ef8d, 2084 }, 2085 { 2086 0x00000000, 0x191b3141, 0x32366282, 0x2b2d53c3, 0x646cc504, 2087 0x7d77f445, 0x565aa786, 0x4f4196c7, 0xc8d98a08, 0xd1c2bb49, 2088 0xfaefe88a, 0xe3f4d9cb, 0xacb54f0c, 0xb5ae7e4d, 0x9e832d8e, 2089 0x87981ccf, 0x4ac21251, 0x53d92310, 0x78f470d3, 0x61ef4192, 2090 0x2eaed755, 0x37b5e614, 0x1c98b5d7, 0x05838496, 0x821b9859, 2091 0x9b00a918, 0xb02dfadb, 0xa936cb9a, 0xe6775d5d, 0xff6c6c1c, 2092 0xd4413fdf, 0xcd5a0e9e, 0x958424a2, 0x8c9f15e3, 0xa7b24620, 2093 0xbea97761, 0xf1e8e1a6, 0xe8f3d0e7, 0xc3de8324, 0xdac5b265, 2094 0x5d5daeaa, 0x44469feb, 0x6f6bcc28, 0x7670fd69, 0x39316bae, 2095 0x202a5aef, 0x0b07092c, 0x121c386d, 0xdf4636f3, 0xc65d07b2, 2096 0xed705471, 0xf46b6530, 0xbb2af3f7, 0xa231c2b6, 0x891c9175, 2097 0x9007a034, 0x179fbcfb, 0x0e848dba, 0x25a9de79, 0x3cb2ef38, 2098 0x73f379ff, 0x6ae848be, 0x41c51b7d, 0x58de2a3c, 0xf0794f05, 2099 0xe9627e44, 0xc24f2d87, 0xdb541cc6, 0x94158a01, 0x8d0ebb40, 2100 0xa623e883, 0xbf38d9c2, 0x38a0c50d, 0x21bbf44c, 0x0a96a78f, 2101 0x138d96ce, 0x5ccc0009, 0x45d73148, 0x6efa628b, 0x77e153ca, 2102 0xbabb5d54, 0xa3a06c15, 0x888d3fd6, 0x91960e97, 0xded79850, 2103 0xc7cca911, 0xece1fad2, 0xf5facb93, 0x7262d75c, 0x6b79e61d, 2104 0x4054b5de, 0x594f849f, 0x160e1258, 0x0f152319, 0x243870da, 2105 0x3d23419b, 0x65fd6ba7, 0x7ce65ae6, 0x57cb0925, 0x4ed03864, 2106 0x0191aea3, 0x188a9fe2, 0x33a7cc21, 0x2abcfd60, 0xad24e1af, 2107 0xb43fd0ee, 0x9f12832d, 0x8609b26c, 0xc94824ab, 0xd05315ea, 2108 0xfb7e4629, 0xe2657768, 0x2f3f79f6, 0x362448b7, 0x1d091b74, 2109 0x04122a35, 0x4b53bcf2, 0x52488db3, 0x7965de70, 0x607eef31, 2110 0xe7e6f3fe, 0xfefdc2bf, 0xd5d0917c, 0xcccba03d, 0x838a36fa, 2111 0x9a9107bb, 0xb1bc5478, 0xa8a76539, 0x3b83984b, 0x2298a90a, 2112 0x09b5fac9, 0x10aecb88, 0x5fef5d4f, 0x46f46c0e, 0x6dd93fcd, 2113 0x74c20e8c, 0xf35a1243, 0xea412302, 0xc16c70c1, 0xd8774180, 2114 0x9736d747, 0x8e2de606, 0xa500b5c5, 0xbc1b8484, 0x71418a1a, 2115 0x685abb5b, 0x4377e898, 0x5a6cd9d9, 0x152d4f1e, 0x0c367e5f, 2116 0x271b2d9c, 0x3e001cdd, 0xb9980012, 0xa0833153, 0x8bae6290, 2117 0x92b553d1, 0xddf4c516, 0xc4eff457, 0xefc2a794, 0xf6d996d5, 2118 0xae07bce9, 0xb71c8da8, 0x9c31de6b, 0x852aef2a, 0xca6b79ed, 2119 0xd37048ac, 0xf85d1b6f, 0xe1462a2e, 0x66de36e1, 0x7fc507a0, 2120 0x54e85463, 0x4df36522, 0x02b2f3e5, 0x1ba9c2a4, 0x30849167, 2121 0x299fa026, 0xe4c5aeb8, 0xfdde9ff9, 0xd6f3cc3a, 0xcfe8fd7b, 2122 0x80a96bbc, 0x99b25afd, 0xb29f093e, 0xab84387f, 0x2c1c24b0, 2123 0x350715f1, 0x1e2a4632, 0x07317773, 0x4870e1b4, 0x516bd0f5, 2124 0x7a468336, 0x635db277, 0xcbfad74e, 0xd2e1e60f, 0xf9ccb5cc, 2125 0xe0d7848d, 0xaf96124a, 0xb68d230b, 0x9da070c8, 0x84bb4189, 2126 0x03235d46, 0x1a386c07, 0x31153fc4, 0x280e0e85, 0x674f9842, 2127 0x7e54a903, 0x5579fac0, 0x4c62cb81, 0x8138c51f, 0x9823f45e, 2128 0xb30ea79d, 0xaa1596dc, 0xe554001b, 0xfc4f315a, 0xd7626299, 2129 0xce7953d8, 0x49e14f17, 0x50fa7e56, 0x7bd72d95, 0x62cc1cd4, 2130 0x2d8d8a13, 0x3496bb52, 0x1fbbe891, 0x06a0d9d0, 0x5e7ef3ec, 2131 0x4765c2ad, 0x6c48916e, 0x7553a02f, 0x3a1236e8, 0x230907a9, 2132 0x0824546a, 0x113f652b, 0x96a779e4, 0x8fbc48a5, 0xa4911b66, 2133 0xbd8a2a27, 0xf2cbbce0, 0xebd08da1, 0xc0fdde62, 0xd9e6ef23, 2134 0x14bce1bd, 0x0da7d0fc, 0x268a833f, 0x3f91b27e, 0x70d024b9, 2135 0x69cb15f8, 0x42e6463b, 0x5bfd777a, 0xdc656bb5, 0xc57e5af4, 2136 0xee530937, 0xf7483876, 0xb809aeb1, 0xa1129ff0, 0x8a3fcc33, 2137 0x9324fd72, 2138 }, 2139 { 2140 0x00000000, 0x01c26a37, 0x0384d46e, 0x0246be59, 0x0709a8dc, 2141 0x06cbc2eb, 0x048d7cb2, 0x054f1685, 0x0e1351b8, 0x0fd13b8f, 2142 0x0d9785d6, 0x0c55efe1, 0x091af964, 0x08d89353, 0x0a9e2d0a, 2143 0x0b5c473d, 0x1c26a370, 0x1de4c947, 0x1fa2771e, 0x1e601d29, 2144 0x1b2f0bac, 0x1aed619b, 0x18abdfc2, 0x1969b5f5, 0x1235f2c8, 2145 0x13f798ff, 0x11b126a6, 0x10734c91, 0x153c5a14, 0x14fe3023, 2146 0x16b88e7a, 0x177ae44d, 0x384d46e0, 0x398f2cd7, 0x3bc9928e, 2147 0x3a0bf8b9, 0x3f44ee3c, 0x3e86840b, 0x3cc03a52, 0x3d025065, 2148 0x365e1758, 0x379c7d6f, 0x35dac336, 0x3418a901, 0x3157bf84, 2149 0x3095d5b3, 0x32d36bea, 0x331101dd, 0x246be590, 0x25a98fa7, 2150 0x27ef31fe, 0x262d5bc9, 0x23624d4c, 0x22a0277b, 0x20e69922, 2151 0x2124f315, 0x2a78b428, 0x2bbade1f, 0x29fc6046, 0x283e0a71, 2152 0x2d711cf4, 0x2cb376c3, 0x2ef5c89a, 0x2f37a2ad, 0x709a8dc0, 2153 0x7158e7f7, 0x731e59ae, 0x72dc3399, 0x7793251c, 0x76514f2b, 2154 0x7417f172, 0x75d59b45, 0x7e89dc78, 0x7f4bb64f, 0x7d0d0816, 2155 0x7ccf6221, 0x798074a4, 0x78421e93, 0x7a04a0ca, 0x7bc6cafd, 2156 0x6cbc2eb0, 0x6d7e4487, 0x6f38fade, 0x6efa90e9, 0x6bb5866c, 2157 0x6a77ec5b, 0x68315202, 0x69f33835, 0x62af7f08, 0x636d153f, 2158 0x612bab66, 0x60e9c151, 0x65a6d7d4, 0x6464bde3, 0x662203ba, 2159 0x67e0698d, 0x48d7cb20, 0x4915a117, 0x4b531f4e, 0x4a917579, 2160 0x4fde63fc, 0x4e1c09cb, 0x4c5ab792, 0x4d98dda5, 0x46c49a98, 2161 0x4706f0af, 0x45404ef6, 0x448224c1, 0x41cd3244, 0x400f5873, 2162 0x4249e62a, 0x438b8c1d, 0x54f16850, 0x55330267, 0x5775bc3e, 2163 0x56b7d609, 0x53f8c08c, 0x523aaabb, 0x507c14e2, 0x51be7ed5, 2164 0x5ae239e8, 0x5b2053df, 0x5966ed86, 0x58a487b1, 0x5deb9134, 2165 0x5c29fb03, 0x5e6f455a, 0x5fad2f6d, 0xe1351b80, 0xe0f771b7, 2166 0xe2b1cfee, 0xe373a5d9, 0xe63cb35c, 0xe7fed96b, 0xe5b86732, 2167 0xe47a0d05, 0xef264a38, 0xeee4200f, 0xeca29e56, 0xed60f461, 2168 0xe82fe2e4, 0xe9ed88d3, 0xebab368a, 0xea695cbd, 0xfd13b8f0, 2169 0xfcd1d2c7, 0xfe976c9e, 0xff5506a9, 0xfa1a102c, 0xfbd87a1b, 2170 0xf99ec442, 0xf85cae75, 0xf300e948, 0xf2c2837f, 0xf0843d26, 2171 0xf1465711, 0xf4094194, 0xf5cb2ba3, 0xf78d95fa, 0xf64fffcd, 2172 0xd9785d60, 0xd8ba3757, 0xdafc890e, 0xdb3ee339, 0xde71f5bc, 2173 0xdfb39f8b, 0xddf521d2, 0xdc374be5, 0xd76b0cd8, 0xd6a966ef, 2174 0xd4efd8b6, 0xd52db281, 0xd062a404, 0xd1a0ce33, 0xd3e6706a, 2175 0xd2241a5d, 0xc55efe10, 0xc49c9427, 0xc6da2a7e, 0xc7184049, 2176 0xc25756cc, 0xc3953cfb, 0xc1d382a2, 0xc011e895, 0xcb4dafa8, 2177 0xca8fc59f, 0xc8c97bc6, 0xc90b11f1, 0xcc440774, 0xcd866d43, 2178 0xcfc0d31a, 0xce02b92d, 0x91af9640, 0x906dfc77, 0x922b422e, 2179 0x93e92819, 0x96a63e9c, 0x976454ab, 0x9522eaf2, 0x94e080c5, 2180 0x9fbcc7f8, 0x9e7eadcf, 0x9c381396, 0x9dfa79a1, 0x98b56f24, 2181 0x99770513, 0x9b31bb4a, 0x9af3d17d, 0x8d893530, 0x8c4b5f07, 2182 0x8e0de15e, 0x8fcf8b69, 0x8a809dec, 0x8b42f7db, 0x89044982, 2183 0x88c623b5, 0x839a6488, 0x82580ebf, 0x801eb0e6, 0x81dcdad1, 2184 0x8493cc54, 0x8551a663, 0x8717183a, 0x86d5720d, 0xa9e2d0a0, 2185 0xa820ba97, 0xaa6604ce, 0xaba46ef9, 0xaeeb787c, 0xaf29124b, 2186 0xad6fac12, 0xacadc625, 0xa7f18118, 0xa633eb2f, 0xa4755576, 2187 0xa5b73f41, 0xa0f829c4, 0xa13a43f3, 0xa37cfdaa, 0xa2be979d, 2188 0xb5c473d0, 0xb40619e7, 0xb640a7be, 0xb782cd89, 0xb2cddb0c, 2189 0xb30fb13b, 0xb1490f62, 0xb08b6555, 0xbbd72268, 0xba15485f, 2190 0xb853f606, 0xb9919c31, 0xbcde8ab4, 0xbd1ce083, 0xbf5a5eda, 2191 0xbe9834ed, 2192 }, 2193 { 2194 0x00000000, 0xb8bc6765, 0xaa09c88b, 0x12b5afee, 0x8f629757, 2195 0x37def032, 0x256b5fdc, 0x9dd738b9, 0xc5b428ef, 0x7d084f8a, 2196 0x6fbde064, 0xd7018701, 0x4ad6bfb8, 0xf26ad8dd, 0xe0df7733, 2197 0x58631056, 0x5019579f, 0xe8a530fa, 0xfa109f14, 0x42acf871, 2198 0xdf7bc0c8, 0x67c7a7ad, 0x75720843, 0xcdce6f26, 0x95ad7f70, 2199 0x2d111815, 0x3fa4b7fb, 0x8718d09e, 0x1acfe827, 0xa2738f42, 2200 0xb0c620ac, 0x087a47c9, 0xa032af3e, 0x188ec85b, 0x0a3b67b5, 2201 0xb28700d0, 0x2f503869, 0x97ec5f0c, 0x8559f0e2, 0x3de59787, 2202 0x658687d1, 0xdd3ae0b4, 0xcf8f4f5a, 0x7733283f, 0xeae41086, 2203 0x525877e3, 0x40edd80d, 0xf851bf68, 0xf02bf8a1, 0x48979fc4, 2204 0x5a22302a, 0xe29e574f, 0x7f496ff6, 0xc7f50893, 0xd540a77d, 2205 0x6dfcc018, 0x359fd04e, 0x8d23b72b, 0x9f9618c5, 0x272a7fa0, 2206 0xbafd4719, 0x0241207c, 0x10f48f92, 0xa848e8f7, 0x9b14583d, 2207 0x23a83f58, 0x311d90b6, 0x89a1f7d3, 0x1476cf6a, 0xaccaa80f, 2208 0xbe7f07e1, 0x06c36084, 0x5ea070d2, 0xe61c17b7, 0xf4a9b859, 2209 0x4c15df3c, 0xd1c2e785, 0x697e80e0, 0x7bcb2f0e, 0xc377486b, 2210 0xcb0d0fa2, 0x73b168c7, 0x6104c729, 0xd9b8a04c, 0x446f98f5, 2211 0xfcd3ff90, 0xee66507e, 0x56da371b, 0x0eb9274d, 0xb6054028, 2212 0xa4b0efc6, 0x1c0c88a3, 0x81dbb01a, 0x3967d77f, 0x2bd27891, 2213 0x936e1ff4, 0x3b26f703, 0x839a9066, 0x912f3f88, 0x299358ed, 2214 0xb4446054, 0x0cf80731, 0x1e4da8df, 0xa6f1cfba, 0xfe92dfec, 2215 0x462eb889, 0x549b1767, 0xec277002, 0x71f048bb, 0xc94c2fde, 2216 0xdbf98030, 0x6345e755, 0x6b3fa09c, 0xd383c7f9, 0xc1366817, 2217 0x798a0f72, 0xe45d37cb, 0x5ce150ae, 0x4e54ff40, 0xf6e89825, 2218 0xae8b8873, 0x1637ef16, 0x048240f8, 0xbc3e279d, 0x21e91f24, 2219 0x99557841, 0x8be0d7af, 0x335cb0ca, 0xed59b63b, 0x55e5d15e, 2220 0x47507eb0, 0xffec19d5, 0x623b216c, 0xda874609, 0xc832e9e7, 2221 0x708e8e82, 0x28ed9ed4, 0x9051f9b1, 0x82e4565f, 0x3a58313a, 2222 0xa78f0983, 0x1f336ee6, 0x0d86c108, 0xb53aa66d, 0xbd40e1a4, 2223 0x05fc86c1, 0x1749292f, 0xaff54e4a, 0x322276f3, 0x8a9e1196, 2224 0x982bbe78, 0x2097d91d, 0x78f4c94b, 0xc048ae2e, 0xd2fd01c0, 2225 0x6a4166a5, 0xf7965e1c, 0x4f2a3979, 0x5d9f9697, 0xe523f1f2, 2226 0x4d6b1905, 0xf5d77e60, 0xe762d18e, 0x5fdeb6eb, 0xc2098e52, 2227 0x7ab5e937, 0x680046d9, 0xd0bc21bc, 0x88df31ea, 0x3063568f, 2228 0x22d6f961, 0x9a6a9e04, 0x07bda6bd, 0xbf01c1d8, 0xadb46e36, 2229 0x15080953, 0x1d724e9a, 0xa5ce29ff, 0xb77b8611, 0x0fc7e174, 2230 0x9210d9cd, 0x2aacbea8, 0x38191146, 0x80a57623, 0xd8c66675, 2231 0x607a0110, 0x72cfaefe, 0xca73c99b, 0x57a4f122, 0xef189647, 2232 0xfdad39a9, 0x45115ecc, 0x764dee06, 0xcef18963, 0xdc44268d, 2233 0x64f841e8, 0xf92f7951, 0x41931e34, 0x5326b1da, 0xeb9ad6bf, 2234 0xb3f9c6e9, 0x0b45a18c, 0x19f00e62, 0xa14c6907, 0x3c9b51be, 2235 0x842736db, 0x96929935, 0x2e2efe50, 0x2654b999, 0x9ee8defc, 2236 0x8c5d7112, 0x34e11677, 0xa9362ece, 0x118a49ab, 0x033fe645, 2237 0xbb838120, 0xe3e09176, 0x5b5cf613, 0x49e959fd, 0xf1553e98, 2238 0x6c820621, 0xd43e6144, 0xc68bceaa, 0x7e37a9cf, 0xd67f4138, 2239 0x6ec3265d, 0x7c7689b3, 0xc4caeed6, 0x591dd66f, 0xe1a1b10a, 2240 0xf3141ee4, 0x4ba87981, 0x13cb69d7, 0xab770eb2, 0xb9c2a15c, 2241 0x017ec639, 0x9ca9fe80, 0x241599e5, 0x36a0360b, 0x8e1c516e, 2242 0x866616a7, 0x3eda71c2, 0x2c6fde2c, 0x94d3b949, 0x090481f0, 2243 0xb1b8e695, 0xa30d497b, 0x1bb12e1e, 0x43d23e48, 0xfb6e592d, 2244 0xe9dbf6c3, 0x516791a6, 0xccb0a91f, 0x740cce7a, 0x66b96194, 2245 0xde0506f1, 2246 }, 2247 { 2248 0x00000000, 0x96300777, 0x2c610eee, 0xba510999, 0x19c46d07, 2249 0x8ff46a70, 0x35a563e9, 0xa395649e, 0x3288db0e, 0xa4b8dc79, 2250 0x1ee9d5e0, 0x88d9d297, 0x2b4cb609, 0xbd7cb17e, 0x072db8e7, 2251 0x911dbf90, 0x6410b71d, 0xf220b06a, 0x4871b9f3, 0xde41be84, 2252 0x7dd4da1a, 0xebe4dd6d, 0x51b5d4f4, 0xc785d383, 0x56986c13, 2253 0xc0a86b64, 0x7af962fd, 0xecc9658a, 0x4f5c0114, 0xd96c0663, 2254 0x633d0ffa, 0xf50d088d, 0xc8206e3b, 0x5e10694c, 0xe44160d5, 2255 0x727167a2, 0xd1e4033c, 0x47d4044b, 0xfd850dd2, 0x6bb50aa5, 2256 0xfaa8b535, 0x6c98b242, 0xd6c9bbdb, 0x40f9bcac, 0xe36cd832, 2257 0x755cdf45, 0xcf0dd6dc, 0x593dd1ab, 0xac30d926, 0x3a00de51, 2258 0x8051d7c8, 0x1661d0bf, 0xb5f4b421, 0x23c4b356, 0x9995bacf, 2259 0x0fa5bdb8, 0x9eb80228, 0x0888055f, 0xb2d90cc6, 0x24e90bb1, 2260 0x877c6f2f, 0x114c6858, 0xab1d61c1, 0x3d2d66b6, 0x9041dc76, 2261 0x0671db01, 0xbc20d298, 0x2a10d5ef, 0x8985b171, 0x1fb5b606, 2262 0xa5e4bf9f, 0x33d4b8e8, 0xa2c90778, 0x34f9000f, 0x8ea80996, 2263 0x18980ee1, 0xbb0d6a7f, 0x2d3d6d08, 0x976c6491, 0x015c63e6, 2264 0xf4516b6b, 0x62616c1c, 0xd8306585, 0x4e0062f2, 0xed95066c, 2265 0x7ba5011b, 0xc1f40882, 0x57c40ff5, 0xc6d9b065, 0x50e9b712, 2266 0xeab8be8b, 0x7c88b9fc, 0xdf1ddd62, 0x492dda15, 0xf37cd38c, 2267 0x654cd4fb, 0x5861b24d, 0xce51b53a, 0x7400bca3, 0xe230bbd4, 2268 0x41a5df4a, 0xd795d83d, 0x6dc4d1a4, 0xfbf4d6d3, 0x6ae96943, 2269 0xfcd96e34, 0x468867ad, 0xd0b860da, 0x732d0444, 0xe51d0333, 2270 0x5f4c0aaa, 0xc97c0ddd, 0x3c710550, 0xaa410227, 0x10100bbe, 2271 0x86200cc9, 0x25b56857, 0xb3856f20, 0x09d466b9, 0x9fe461ce, 2272 0x0ef9de5e, 0x98c9d929, 0x2298d0b0, 0xb4a8d7c7, 0x173db359, 2273 0x810db42e, 0x3b5cbdb7, 0xad6cbac0, 0x2083b8ed, 0xb6b3bf9a, 2274 0x0ce2b603, 0x9ad2b174, 0x3947d5ea, 0xaf77d29d, 0x1526db04, 2275 0x8316dc73, 0x120b63e3, 0x843b6494, 0x3e6a6d0d, 0xa85a6a7a, 2276 0x0bcf0ee4, 0x9dff0993, 0x27ae000a, 0xb19e077d, 0x44930ff0, 2277 0xd2a30887, 0x68f2011e, 0xfec20669, 0x5d5762f7, 0xcb676580, 2278 0x71366c19, 0xe7066b6e, 0x761bd4fe, 0xe02bd389, 0x5a7ada10, 2279 0xcc4add67, 0x6fdfb9f9, 0xf9efbe8e, 0x43beb717, 0xd58eb060, 2280 0xe8a3d6d6, 0x7e93d1a1, 0xc4c2d838, 0x52f2df4f, 0xf167bbd1, 2281 0x6757bca6, 0xdd06b53f, 0x4b36b248, 0xda2b0dd8, 0x4c1b0aaf, 2282 0xf64a0336, 0x607a0441, 0xc3ef60df, 0x55df67a8, 0xef8e6e31, 2283 0x79be6946, 0x8cb361cb, 0x1a8366bc, 0xa0d26f25, 0x36e26852, 2284 0x95770ccc, 0x03470bbb, 0xb9160222, 0x2f260555, 0xbe3bbac5, 2285 0x280bbdb2, 0x925ab42b, 0x046ab35c, 0xa7ffd7c2, 0x31cfd0b5, 2286 0x8b9ed92c, 0x1daede5b, 0xb0c2649b, 0x26f263ec, 0x9ca36a75, 2287 0x0a936d02, 0xa906099c, 0x3f360eeb, 0x85670772, 0x13570005, 2288 0x824abf95, 0x147ab8e2, 0xae2bb17b, 0x381bb60c, 0x9b8ed292, 2289 0x0dbed5e5, 0xb7efdc7c, 0x21dfdb0b, 0xd4d2d386, 0x42e2d4f1, 2290 0xf8b3dd68, 0x6e83da1f, 0xcd16be81, 0x5b26b9f6, 0xe177b06f, 2291 0x7747b718, 0xe65a0888, 0x706a0fff, 0xca3b0666, 0x5c0b0111, 2292 0xff9e658f, 0x69ae62f8, 0xd3ff6b61, 0x45cf6c16, 0x78e20aa0, 2293 0xeed20dd7, 0x5483044e, 0xc2b30339, 0x612667a7, 0xf71660d0, 2294 0x4d476949, 0xdb776e3e, 0x4a6ad1ae, 0xdc5ad6d9, 0x660bdf40, 2295 0xf03bd837, 0x53aebca9, 0xc59ebbde, 0x7fcfb247, 0xe9ffb530, 2296 0x1cf2bdbd, 0x8ac2baca, 0x3093b353, 0xa6a3b424, 0x0536d0ba, 2297 0x9306d7cd, 0x2957de54, 0xbf67d923, 0x2e7a66b3, 0xb84a61c4, 2298 0x021b685d, 0x942b6f2a, 0x37be0bb4, 0xa18e0cc3, 0x1bdf055a, 2299 0x8def022d, 2300 }, 2301 { 2302 0x00000000, 0x41311b19, 0x82623632, 0xc3532d2b, 0x04c56c64, 2303 0x45f4777d, 0x86a75a56, 0xc796414f, 0x088ad9c8, 0x49bbc2d1, 2304 0x8ae8effa, 0xcbd9f4e3, 0x0c4fb5ac, 0x4d7eaeb5, 0x8e2d839e, 2305 0xcf1c9887, 0x5112c24a, 0x1023d953, 0xd370f478, 0x9241ef61, 2306 0x55d7ae2e, 0x14e6b537, 0xd7b5981c, 0x96848305, 0x59981b82, 2307 0x18a9009b, 0xdbfa2db0, 0x9acb36a9, 0x5d5d77e6, 0x1c6c6cff, 2308 0xdf3f41d4, 0x9e0e5acd, 0xa2248495, 0xe3159f8c, 0x2046b2a7, 2309 0x6177a9be, 0xa6e1e8f1, 0xe7d0f3e8, 0x2483dec3, 0x65b2c5da, 2310 0xaaae5d5d, 0xeb9f4644, 0x28cc6b6f, 0x69fd7076, 0xae6b3139, 2311 0xef5a2a20, 0x2c09070b, 0x6d381c12, 0xf33646df, 0xb2075dc6, 2312 0x715470ed, 0x30656bf4, 0xf7f32abb, 0xb6c231a2, 0x75911c89, 2313 0x34a00790, 0xfbbc9f17, 0xba8d840e, 0x79dea925, 0x38efb23c, 2314 0xff79f373, 0xbe48e86a, 0x7d1bc541, 0x3c2ade58, 0x054f79f0, 2315 0x447e62e9, 0x872d4fc2, 0xc61c54db, 0x018a1594, 0x40bb0e8d, 2316 0x83e823a6, 0xc2d938bf, 0x0dc5a038, 0x4cf4bb21, 0x8fa7960a, 2317 0xce968d13, 0x0900cc5c, 0x4831d745, 0x8b62fa6e, 0xca53e177, 2318 0x545dbbba, 0x156ca0a3, 0xd63f8d88, 0x970e9691, 0x5098d7de, 2319 0x11a9ccc7, 0xd2fae1ec, 0x93cbfaf5, 0x5cd76272, 0x1de6796b, 2320 0xdeb55440, 0x9f844f59, 0x58120e16, 0x1923150f, 0xda703824, 2321 0x9b41233d, 0xa76bfd65, 0xe65ae67c, 0x2509cb57, 0x6438d04e, 2322 0xa3ae9101, 0xe29f8a18, 0x21cca733, 0x60fdbc2a, 0xafe124ad, 2323 0xeed03fb4, 0x2d83129f, 0x6cb20986, 0xab2448c9, 0xea1553d0, 2324 0x29467efb, 0x687765e2, 0xf6793f2f, 0xb7482436, 0x741b091d, 2325 0x352a1204, 0xf2bc534b, 0xb38d4852, 0x70de6579, 0x31ef7e60, 2326 0xfef3e6e7, 0xbfc2fdfe, 0x7c91d0d5, 0x3da0cbcc, 0xfa368a83, 2327 0xbb07919a, 0x7854bcb1, 0x3965a7a8, 0x4b98833b, 0x0aa99822, 2328 0xc9fab509, 0x88cbae10, 0x4f5def5f, 0x0e6cf446, 0xcd3fd96d, 2329 0x8c0ec274, 0x43125af3, 0x022341ea, 0xc1706cc1, 0x804177d8, 2330 0x47d73697, 0x06e62d8e, 0xc5b500a5, 0x84841bbc, 0x1a8a4171, 2331 0x5bbb5a68, 0x98e87743, 0xd9d96c5a, 0x1e4f2d15, 0x5f7e360c, 2332 0x9c2d1b27, 0xdd1c003e, 0x120098b9, 0x533183a0, 0x9062ae8b, 2333 0xd153b592, 0x16c5f4dd, 0x57f4efc4, 0x94a7c2ef, 0xd596d9f6, 2334 0xe9bc07ae, 0xa88d1cb7, 0x6bde319c, 0x2aef2a85, 0xed796bca, 2335 0xac4870d3, 0x6f1b5df8, 0x2e2a46e1, 0xe136de66, 0xa007c57f, 2336 0x6354e854, 0x2265f34d, 0xe5f3b202, 0xa4c2a91b, 0x67918430, 2337 0x26a09f29, 0xb8aec5e4, 0xf99fdefd, 0x3accf3d6, 0x7bfde8cf, 2338 0xbc6ba980, 0xfd5ab299, 0x3e099fb2, 0x7f3884ab, 0xb0241c2c, 2339 0xf1150735, 0x32462a1e, 0x73773107, 0xb4e17048, 0xf5d06b51, 2340 0x3683467a, 0x77b25d63, 0x4ed7facb, 0x0fe6e1d2, 0xccb5ccf9, 2341 0x8d84d7e0, 0x4a1296af, 0x0b238db6, 0xc870a09d, 0x8941bb84, 2342 0x465d2303, 0x076c381a, 0xc43f1531, 0x850e0e28, 0x42984f67, 2343 0x03a9547e, 0xc0fa7955, 0x81cb624c, 0x1fc53881, 0x5ef42398, 2344 0x9da70eb3, 0xdc9615aa, 0x1b0054e5, 0x5a314ffc, 0x996262d7, 2345 0xd85379ce, 0x174fe149, 0x567efa50, 0x952dd77b, 0xd41ccc62, 2346 0x138a8d2d, 0x52bb9634, 0x91e8bb1f, 0xd0d9a006, 0xecf37e5e, 2347 0xadc26547, 0x6e91486c, 0x2fa05375, 0xe836123a, 0xa9070923, 2348 0x6a542408, 0x2b653f11, 0xe479a796, 0xa548bc8f, 0x661b91a4, 2349 0x272a8abd, 0xe0bccbf2, 0xa18dd0eb, 0x62defdc0, 0x23efe6d9, 2350 0xbde1bc14, 0xfcd0a70d, 0x3f838a26, 0x7eb2913f, 0xb924d070, 2351 0xf815cb69, 0x3b46e642, 0x7a77fd5b, 0xb56b65dc, 0xf45a7ec5, 2352 0x370953ee, 0x763848f7, 0xb1ae09b8, 0xf09f12a1, 0x33cc3f8a, 2353 0x72fd2493, 2354 }, 2355 { 2356 0x00000000, 0x376ac201, 0x6ed48403, 0x59be4602, 0xdca80907, 2357 0xebc2cb06, 0xb27c8d04, 0x85164f05, 0xb851130e, 0x8f3bd10f, 2358 0xd685970d, 0xe1ef550c, 0x64f91a09, 0x5393d808, 0x0a2d9e0a, 2359 0x3d475c0b, 0x70a3261c, 0x47c9e41d, 0x1e77a21f, 0x291d601e, 2360 0xac0b2f1b, 0x9b61ed1a, 0xc2dfab18, 0xf5b56919, 0xc8f23512, 2361 0xff98f713, 0xa626b111, 0x914c7310, 0x145a3c15, 0x2330fe14, 2362 0x7a8eb816, 0x4de47a17, 0xe0464d38, 0xd72c8f39, 0x8e92c93b, 2363 0xb9f80b3a, 0x3cee443f, 0x0b84863e, 0x523ac03c, 0x6550023d, 2364 0x58175e36, 0x6f7d9c37, 0x36c3da35, 0x01a91834, 0x84bf5731, 2365 0xb3d59530, 0xea6bd332, 0xdd011133, 0x90e56b24, 0xa78fa925, 2366 0xfe31ef27, 0xc95b2d26, 0x4c4d6223, 0x7b27a022, 0x2299e620, 2367 0x15f32421, 0x28b4782a, 0x1fdeba2b, 0x4660fc29, 0x710a3e28, 2368 0xf41c712d, 0xc376b32c, 0x9ac8f52e, 0xada2372f, 0xc08d9a70, 2369 0xf7e75871, 0xae591e73, 0x9933dc72, 0x1c259377, 0x2b4f5176, 2370 0x72f11774, 0x459bd575, 0x78dc897e, 0x4fb64b7f, 0x16080d7d, 2371 0x2162cf7c, 0xa4748079, 0x931e4278, 0xcaa0047a, 0xfdcac67b, 2372 0xb02ebc6c, 0x87447e6d, 0xdefa386f, 0xe990fa6e, 0x6c86b56b, 2373 0x5bec776a, 0x02523168, 0x3538f369, 0x087faf62, 0x3f156d63, 2374 0x66ab2b61, 0x51c1e960, 0xd4d7a665, 0xe3bd6464, 0xba032266, 2375 0x8d69e067, 0x20cbd748, 0x17a11549, 0x4e1f534b, 0x7975914a, 2376 0xfc63de4f, 0xcb091c4e, 0x92b75a4c, 0xa5dd984d, 0x989ac446, 2377 0xaff00647, 0xf64e4045, 0xc1248244, 0x4432cd41, 0x73580f40, 2378 0x2ae64942, 0x1d8c8b43, 0x5068f154, 0x67023355, 0x3ebc7557, 2379 0x09d6b756, 0x8cc0f853, 0xbbaa3a52, 0xe2147c50, 0xd57ebe51, 2380 0xe839e25a, 0xdf53205b, 0x86ed6659, 0xb187a458, 0x3491eb5d, 2381 0x03fb295c, 0x5a456f5e, 0x6d2fad5f, 0x801b35e1, 0xb771f7e0, 2382 0xeecfb1e2, 0xd9a573e3, 0x5cb33ce6, 0x6bd9fee7, 0x3267b8e5, 2383 0x050d7ae4, 0x384a26ef, 0x0f20e4ee, 0x569ea2ec, 0x61f460ed, 2384 0xe4e22fe8, 0xd388ede9, 0x8a36abeb, 0xbd5c69ea, 0xf0b813fd, 2385 0xc7d2d1fc, 0x9e6c97fe, 0xa90655ff, 0x2c101afa, 0x1b7ad8fb, 2386 0x42c49ef9, 0x75ae5cf8, 0x48e900f3, 0x7f83c2f2, 0x263d84f0, 2387 0x115746f1, 0x944109f4, 0xa32bcbf5, 0xfa958df7, 0xcdff4ff6, 2388 0x605d78d9, 0x5737bad8, 0x0e89fcda, 0x39e33edb, 0xbcf571de, 2389 0x8b9fb3df, 0xd221f5dd, 0xe54b37dc, 0xd80c6bd7, 0xef66a9d6, 2390 0xb6d8efd4, 0x81b22dd5, 0x04a462d0, 0x33cea0d1, 0x6a70e6d3, 2391 0x5d1a24d2, 0x10fe5ec5, 0x27949cc4, 0x7e2adac6, 0x494018c7, 2392 0xcc5657c2, 0xfb3c95c3, 0xa282d3c1, 0x95e811c0, 0xa8af4dcb, 2393 0x9fc58fca, 0xc67bc9c8, 0xf1110bc9, 0x740744cc, 0x436d86cd, 2394 0x1ad3c0cf, 0x2db902ce, 0x4096af91, 0x77fc6d90, 0x2e422b92, 2395 0x1928e993, 0x9c3ea696, 0xab546497, 0xf2ea2295, 0xc580e094, 2396 0xf8c7bc9f, 0xcfad7e9e, 0x9613389c, 0xa179fa9d, 0x246fb598, 2397 0x13057799, 0x4abb319b, 0x7dd1f39a, 0x3035898d, 0x075f4b8c, 2398 0x5ee10d8e, 0x698bcf8f, 0xec9d808a, 0xdbf7428b, 0x82490489, 2399 0xb523c688, 0x88649a83, 0xbf0e5882, 0xe6b01e80, 0xd1dadc81, 2400 0x54cc9384, 0x63a65185, 0x3a181787, 0x0d72d586, 0xa0d0e2a9, 2401 0x97ba20a8, 0xce0466aa, 0xf96ea4ab, 0x7c78ebae, 0x4b1229af, 2402 0x12ac6fad, 0x25c6adac, 0x1881f1a7, 0x2feb33a6, 0x765575a4, 2403 0x413fb7a5, 0xc429f8a0, 0xf3433aa1, 0xaafd7ca3, 0x9d97bea2, 2404 0xd073c4b5, 0xe71906b4, 0xbea740b6, 0x89cd82b7, 0x0cdbcdb2, 2405 0x3bb10fb3, 0x620f49b1, 0x55658bb0, 0x6822d7bb, 0x5f4815ba, 2406 0x06f653b8, 0x319c91b9, 0xb48adebc, 0x83e01cbd, 0xda5e5abf, 2407 0xed3498be, 2408 }, 2409 { 2410 0x00000000, 0x6567bcb8, 0x8bc809aa, 0xeeafb512, 0x5797628f, 2411 0x32f0de37, 0xdc5f6b25, 0xb938d79d, 0xef28b4c5, 0x8a4f087d, 2412 0x64e0bd6f, 0x018701d7, 0xb8bfd64a, 0xddd86af2, 0x3377dfe0, 2413 0x56106358, 0x9f571950, 0xfa30a5e8, 0x149f10fa, 0x71f8ac42, 2414 0xc8c07bdf, 0xada7c767, 0x43087275, 0x266fcecd, 0x707fad95, 2415 0x1518112d, 0xfbb7a43f, 0x9ed01887, 0x27e8cf1a, 0x428f73a2, 2416 0xac20c6b0, 0xc9477a08, 0x3eaf32a0, 0x5bc88e18, 0xb5673b0a, 2417 0xd00087b2, 0x6938502f, 0x0c5fec97, 0xe2f05985, 0x8797e53d, 2418 0xd1878665, 0xb4e03add, 0x5a4f8fcf, 0x3f283377, 0x8610e4ea, 2419 0xe3775852, 0x0dd8ed40, 0x68bf51f8, 0xa1f82bf0, 0xc49f9748, 2420 0x2a30225a, 0x4f579ee2, 0xf66f497f, 0x9308f5c7, 0x7da740d5, 2421 0x18c0fc6d, 0x4ed09f35, 0x2bb7238d, 0xc518969f, 0xa07f2a27, 2422 0x1947fdba, 0x7c204102, 0x928ff410, 0xf7e848a8, 0x3d58149b, 2423 0x583fa823, 0xb6901d31, 0xd3f7a189, 0x6acf7614, 0x0fa8caac, 2424 0xe1077fbe, 0x8460c306, 0xd270a05e, 0xb7171ce6, 0x59b8a9f4, 2425 0x3cdf154c, 0x85e7c2d1, 0xe0807e69, 0x0e2fcb7b, 0x6b4877c3, 2426 0xa20f0dcb, 0xc768b173, 0x29c70461, 0x4ca0b8d9, 0xf5986f44, 2427 0x90ffd3fc, 0x7e5066ee, 0x1b37da56, 0x4d27b90e, 0x284005b6, 2428 0xc6efb0a4, 0xa3880c1c, 0x1ab0db81, 0x7fd76739, 0x9178d22b, 2429 0xf41f6e93, 0x03f7263b, 0x66909a83, 0x883f2f91, 0xed589329, 2430 0x546044b4, 0x3107f80c, 0xdfa84d1e, 0xbacff1a6, 0xecdf92fe, 2431 0x89b82e46, 0x67179b54, 0x027027ec, 0xbb48f071, 0xde2f4cc9, 2432 0x3080f9db, 0x55e74563, 0x9ca03f6b, 0xf9c783d3, 0x176836c1, 2433 0x720f8a79, 0xcb375de4, 0xae50e15c, 0x40ff544e, 0x2598e8f6, 2434 0x73888bae, 0x16ef3716, 0xf8408204, 0x9d273ebc, 0x241fe921, 2435 0x41785599, 0xafd7e08b, 0xcab05c33, 0x3bb659ed, 0x5ed1e555, 2436 0xb07e5047, 0xd519ecff, 0x6c213b62, 0x094687da, 0xe7e932c8, 2437 0x828e8e70, 0xd49eed28, 0xb1f95190, 0x5f56e482, 0x3a31583a, 2438 0x83098fa7, 0xe66e331f, 0x08c1860d, 0x6da63ab5, 0xa4e140bd, 2439 0xc186fc05, 0x2f294917, 0x4a4ef5af, 0xf3762232, 0x96119e8a, 2440 0x78be2b98, 0x1dd99720, 0x4bc9f478, 0x2eae48c0, 0xc001fdd2, 2441 0xa566416a, 0x1c5e96f7, 0x79392a4f, 0x97969f5d, 0xf2f123e5, 2442 0x05196b4d, 0x607ed7f5, 0x8ed162e7, 0xebb6de5f, 0x528e09c2, 2443 0x37e9b57a, 0xd9460068, 0xbc21bcd0, 0xea31df88, 0x8f566330, 2444 0x61f9d622, 0x049e6a9a, 0xbda6bd07, 0xd8c101bf, 0x366eb4ad, 2445 0x53090815, 0x9a4e721d, 0xff29cea5, 0x11867bb7, 0x74e1c70f, 2446 0xcdd91092, 0xa8beac2a, 0x46111938, 0x2376a580, 0x7566c6d8, 2447 0x10017a60, 0xfeaecf72, 0x9bc973ca, 0x22f1a457, 0x479618ef, 2448 0xa939adfd, 0xcc5e1145, 0x06ee4d76, 0x6389f1ce, 0x8d2644dc, 2449 0xe841f864, 0x51792ff9, 0x341e9341, 0xdab12653, 0xbfd69aeb, 2450 0xe9c6f9b3, 0x8ca1450b, 0x620ef019, 0x07694ca1, 0xbe519b3c, 2451 0xdb362784, 0x35999296, 0x50fe2e2e, 0x99b95426, 0xfcdee89e, 2452 0x12715d8c, 0x7716e134, 0xce2e36a9, 0xab498a11, 0x45e63f03, 2453 0x208183bb, 0x7691e0e3, 0x13f65c5b, 0xfd59e949, 0x983e55f1, 2454 0x2106826c, 0x44613ed4, 0xaace8bc6, 0xcfa9377e, 0x38417fd6, 2455 0x5d26c36e, 0xb389767c, 0xd6eecac4, 0x6fd61d59, 0x0ab1a1e1, 2456 0xe41e14f3, 0x8179a84b, 0xd769cb13, 0xb20e77ab, 0x5ca1c2b9, 2457 0x39c67e01, 0x80fea99c, 0xe5991524, 0x0b36a036, 0x6e511c8e, 2458 0xa7166686, 0xc271da3e, 0x2cde6f2c, 0x49b9d394, 0xf0810409, 2459 0x95e6b8b1, 0x7b490da3, 0x1e2eb11b, 0x483ed243, 0x2d596efb, 2460 0xc3f6dbe9, 0xa6916751, 0x1fa9b0cc, 0x7ace0c74, 0x9461b966, 2461 0xf10605de, 2462 }, 2463 } /* crc32.h:5:25 */ 2464 2465 // ========================================================================= 2466 // This function can be used by asm versions of crc32() 2467 func Xget_crc_table(tls *libc.TLS) uintptr { /* crc32.c:188:19: */ 2468 return uintptr(uintptr(unsafe.Pointer(&crc_table))) 2469 } 2470 2471 // ========================================================================= 2472 2473 // ========================================================================= 2474 func Xcrc32_z(tls *libc.TLS, crc uint32, buf uintptr, len Z_size_t) uint32 { /* crc32.c:202:23: */ 2475 bp := tls.Alloc(4) 2476 defer tls.Free(4) 2477 2478 if buf == uintptr(Z_NULL) { 2479 return 0 2480 } 2481 2482 if uint64(unsafe.Sizeof(uintptr(0))) == uint64(unsafe.Sizeof(Ptrdiff_t(0))) { 2483 // var endian Z_crc_t at bp, 4 2484 2485 *(*Z_crc_t)(unsafe.Pointer(bp /* endian */)) = Z_crc_t(1) 2486 if *(*uint8)(unsafe.Pointer(bp /* &endian */)) != 0 { 2487 return crc32_little(tls, crc, buf, len) 2488 } else { 2489 return crc32_big(tls, crc, buf, len) 2490 } 2491 } 2492 crc = (crc ^ 0xffffffff) 2493 for len >= uint64(8) { 2494 crc = (uint32(*(*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)) 2495 crc = (uint32(*(*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)) 2496 crc = (uint32(*(*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)) 2497 crc = (uint32(*(*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)) 2498 crc = (uint32(*(*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)) 2499 crc = (uint32(*(*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)) 2500 crc = (uint32(*(*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)) 2501 crc = (uint32(*(*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)) 2502 len = len - (uint64(8)) 2503 } 2504 if len != 0 { 2505 for ok := true; ok; ok = libc.PreDecUint64(&len, 1) != 0 { 2506 crc = (uint32(*(*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)) 2507 } 2508 } 2509 return (crc ^ 0xffffffff) 2510 } 2511 2512 // ========================================================================= 2513 func Xcrc32(tls *libc.TLS, crc uint32, buf uintptr, len UInt) uint32 { /* crc32.c:237:23: */ 2514 return Xcrc32_z(tls, crc, buf, uint64(len)) 2515 } 2516 2517 // 2518 // This BYFOUR code accesses the passed unsigned char * buffer with a 32-bit 2519 // integer pointer type. This violates the strict aliasing rule, where a 2520 // compiler can assume, for optimization purposes, that two pointers to 2521 // fundamentally different types won't ever point to the same memory. This can 2522 // manifest as a problem only if one of the pointers is written to. This code 2523 // only reads from those pointers. So long as this code remains isolated in 2524 // this compilation unit, there won't be a problem. For this reason, this code 2525 // should not be copied and pasted into a compilation unit in which other code 2526 // writes to the buffer that is passed to these routines. 2527 // 2528 2529 // ========================================================================= 2530 2531 // ========================================================================= 2532 func crc32_little(tls *libc.TLS, crc uint32, buf uintptr, len Z_size_t) uint32 { /* crc32.c:266:21: */ 2533 var c Z_crc_t 2534 var buf4 uintptr 2535 2536 c = Z_crc_t(crc) 2537 c = ^c 2538 for (len != 0) && ((Ptrdiff_t(buf) & int64(3)) != 0) { 2539 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)) 2540 len-- 2541 } 2542 2543 buf4 = buf 2544 for len >= uint64(32) { 2545 c = c ^ (*(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))) 2546 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))) 2547 c = c ^ (*(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))) 2548 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))) 2549 c = c ^ (*(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))) 2550 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))) 2551 c = c ^ (*(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))) 2552 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))) 2553 c = c ^ (*(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))) 2554 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))) 2555 c = c ^ (*(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))) 2556 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))) 2557 c = c ^ (*(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))) 2558 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))) 2559 c = c ^ (*(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))) 2560 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))) 2561 len = len - (uint64(32)) 2562 } 2563 for len >= uint64(4) { 2564 c = c ^ (*(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))) 2565 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))) 2566 len = len - (uint64(4)) 2567 } 2568 buf = buf4 2569 2570 if len != 0 { 2571 for ok := true; ok; ok = libc.PreDecUint64(&len, 1) != 0 { 2572 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)) 2573 } 2574 } 2575 c = ^c 2576 return uint32(c) 2577 } 2578 2579 // ========================================================================= 2580 2581 // ========================================================================= 2582 func crc32_big(tls *libc.TLS, crc uint32, buf uintptr, len Z_size_t) uint32 { /* crc32.c:306:21: */ 2583 var c Z_crc_t 2584 var buf4 uintptr 2585 2586 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)) 2587 c = ^c 2588 for (len != 0) && ((Ptrdiff_t(buf) & int64(3)) != 0) { 2589 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)) 2590 len-- 2591 } 2592 2593 buf4 = buf 2594 for len >= uint64(32) { 2595 c = c ^ (*(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))) 2596 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))) 2597 c = c ^ (*(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))) 2598 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))) 2599 c = c ^ (*(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))) 2600 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))) 2601 c = c ^ (*(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))) 2602 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))) 2603 c = c ^ (*(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))) 2604 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))) 2605 c = c ^ (*(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))) 2606 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))) 2607 c = c ^ (*(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))) 2608 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))) 2609 c = c ^ (*(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))) 2610 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))) 2611 len = len - (uint64(32)) 2612 } 2613 for len >= uint64(4) { 2614 c = c ^ (*(*Z_crc_t)(unsafe.Pointer(libc.PostIncUintptr(&buf4, 4)))) 2615 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))) 2616 len = len - (uint64(4)) 2617 } 2618 buf = buf4 2619 2620 if len != 0 { 2621 for ok := true; ok; ok = libc.PreDecUint64(&len, 1) != 0 { 2622 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)) 2623 } 2624 } 2625 c = ^c 2626 return (uint32((((((c) >> 24) & Z_crc_t(0xff)) + (((c) >> 8) & Z_crc_t(0xff00))) + (((c) & Z_crc_t(0xff00)) << 8)) + (((c) & Z_crc_t(0xff)) << 24))) 2627 } 2628 2629 // ========================================================================= 2630 func gf2_matrix_times(tls *libc.TLS, mat uintptr, vec uint32) uint32 { /* crc32.c:344:21: */ 2631 var sum uint32 2632 2633 sum = uint32(0) 2634 for vec != 0 { 2635 if (vec & uint32(1)) != 0 { 2636 sum = sum ^ (*(*uint32)(unsafe.Pointer(mat))) 2637 } 2638 vec >>= 1 2639 mat += 4 2640 } 2641 return sum 2642 } 2643 2644 // ========================================================================= 2645 func gf2_matrix_square(tls *libc.TLS, square uintptr, mat uintptr) { /* crc32.c:361:12: */ 2646 var n int32 2647 2648 for n = 0; n < GF2_DIM; n++ { 2649 *(*uint32)(unsafe.Pointer(square + uintptr(n)*4)) = gf2_matrix_times(tls, mat, *(*uint32)(unsafe.Pointer(mat + uintptr(n)*4))) 2650 } 2651 } 2652 2653 // ========================================================================= 2654 func crc32_combine_(tls *libc.TLS, crc1 ULong, crc2 ULong, len2 int32) ULong { /* crc32.c:372:13: */ 2655 bp := tls.Alloc(256) 2656 defer tls.Free(256) 2657 2658 var n int32 2659 var row uint32 2660 // var even [32]uint32 at bp+128, 128 2661 // even-power-of-two zeros operator 2662 // var odd [32]uint32 at bp, 128 2663 // odd-power-of-two zeros operator 2664 2665 // degenerate case (also disallow negative lengths) 2666 if len2 <= 0 { 2667 return crc1 2668 } 2669 2670 // put operator for one zero bit in odd 2671 *(*uint32)(unsafe.Pointer(bp /* &odd[0] */)) = 0xedb88320 // CRC-32 polynomial 2672 row = uint32(1) 2673 for n = 1; n < GF2_DIM; n++ { 2674 *(*uint32)(unsafe.Pointer(bp /* &odd[0] */ + uintptr(n)*4)) = row 2675 row <<= 1 2676 } 2677 2678 // put operator for two zero bits in even 2679 gf2_matrix_square(tls, bp+128 /* &even[0] */, bp /* &odd[0] */) 2680 2681 // put operator for four zero bits in odd 2682 gf2_matrix_square(tls, bp /* &odd[0] */, bp+128 /* &even[0] */) 2683 2684 // apply len2 zeros to crc1 (first square will put the operator for one 2685 // zero byte, eight zero bits, in even) 2686 for ok := true; ok; ok = (len2 != 0) { 2687 // apply zeros operator for this bit of len2 2688 gf2_matrix_square(tls, bp+128 /* &even[0] */, bp /* &odd[0] */) 2689 if (len2 & 1) != 0 { 2690 crc1 = gf2_matrix_times(tls, bp+128 /* &even[0] */, crc1) 2691 } 2692 len2 >>= 1 2693 2694 // if no more bits set, then done 2695 if len2 == 0 { 2696 break 2697 } 2698 2699 // another iteration of the loop with odd and even swapped 2700 gf2_matrix_square(tls, bp /* &odd[0] */, bp+128 /* &even[0] */) 2701 if (len2 & 1) != 0 { 2702 crc1 = gf2_matrix_times(tls, bp /* &odd[0] */, crc1) 2703 } 2704 len2 >>= 1 2705 2706 // if no more bits set, then done 2707 } 2708 2709 // return combined crc 2710 crc1 = crc1 ^ (crc2) 2711 return crc1 2712 } 2713 2714 // ========================================================================= 2715 func Xcrc32_combine(tls *libc.TLS, crc1 ULong, crc2 ULong, len2 int32) ULong { /* crc32.c:428:15: */ 2716 return crc32_combine_(tls, crc1, crc2, len2) 2717 } 2718 2719 func Xcrc32_combine64(tls *libc.TLS, crc1 ULong, crc2 ULong, len2 int32) ULong { /* crc32.c:436:15: */ 2720 return crc32_combine_(tls, crc1, crc2, len2) 2721 } 2722 2723 // Reverse the bytes in a 32-bit value 2724 2725 // define NO_GZIP when compiling if you want to disable gzip header and 2726 // trailer creation by deflate(). NO_GZIP would be used to avoid linking in 2727 // the crc code when it is not needed. For shared libraries, gzip encoding 2728 // should be left enabled. 2729 2730 // =========================================================================== 2731 // Internal compression state. 2732 2733 // number of length codes, not counting the special END_BLOCK code 2734 2735 // number of literal bytes 0..255 2736 2737 // number of Literal or Length codes, including the END_BLOCK code 2738 2739 // number of distance codes 2740 2741 // number of codes used to transfer the bit lengths 2742 2743 // maximum heap size 2744 2745 // All codes must not exceed MAX_BITS bits 2746 2747 // size of bit buffer in bi_buf 2748 2749 // Stream status 2750 2751 // Data structure describing a single value and its code string. 2752 type Ct_data_s = struct { 2753 Ffc struct{ Ffreq Ush } 2754 Fdl struct{ Fdad Ush } 2755 } /* zlib.h:84:1 */ 2756 2757 // Reverse the bytes in a 32-bit value 2758 2759 // define NO_GZIP when compiling if you want to disable gzip header and 2760 // trailer creation by deflate(). NO_GZIP would be used to avoid linking in 2761 // the crc code when it is not needed. For shared libraries, gzip encoding 2762 // should be left enabled. 2763 2764 // =========================================================================== 2765 // Internal compression state. 2766 2767 // number of length codes, not counting the special END_BLOCK code 2768 2769 // number of literal bytes 0..255 2770 2771 // number of Literal or Length codes, including the END_BLOCK code 2772 2773 // number of distance codes 2774 2775 // number of codes used to transfer the bit lengths 2776 2777 // maximum heap size 2778 2779 // All codes must not exceed MAX_BITS bits 2780 2781 // size of bit buffer in bi_buf 2782 2783 // Stream status 2784 2785 // Data structure describing a single value and its code string. 2786 type Ct_data = Ct_data_s /* deflate.h:77:7 */ 2787 2788 type Static_tree_desc_s = struct { 2789 Fstatic_tree uintptr 2790 Fextra_bits uintptr 2791 Fextra_base int32 2792 Felems int32 2793 Fmax_length int32 2794 F__ccgo_pad1 [4]byte 2795 } /* deflate.h:84:9 */ 2796 2797 type Tree_desc_s = struct { 2798 Fdyn_tree uintptr 2799 Fmax_code int32 2800 F__ccgo_pad1 [4]byte 2801 Fstat_desc uintptr 2802 } /* zlib.h:84:1 */ 2803 2804 type Tree_desc = Tree_desc_s /* deflate.h:90:7 */ 2805 2806 type Pos = Ush /* deflate.h:92:13 */ 2807 type Posf = Pos /* deflate.h:93:17 */ 2808 type IPos = uint32 /* deflate.h:94:18 */ 2809 2810 // A Pos is an index in the character window. We use short instead of int to 2811 // save space in the various tables. IPos is used only for parameter passing. 2812 2813 type Deflate_state = Internal_state /* deflate.h:276:7 */ 2814 2815 var Xdeflate_copyright = *(*[69]int8)(unsafe.Pointer(ts + 7 /* " deflate 1.2.11 ..." */)) /* deflate.c:54:12 */ 2816 // 2817 // If you use the zlib library in a product, an acknowledgment is welcome 2818 // in the documentation of your product. If for some reason you cannot 2819 // include such an acknowledgment, I would appreciate that you keep this 2820 // copyright string in the executable of your product. 2821 // 2822 2823 // =========================================================================== 2824 // Function prototypes. 2825 type Block_state = uint32 /* deflate.c:71:3 */ 2826 2827 type Compress_func = uintptr /* deflate.c:73:21 */ 2828 2829 // =========================================================================== 2830 // Local data 2831 2832 // Tail of hash chains 2833 2834 // Matches of length 3 are discarded if their distance exceeds TOO_FAR 2835 2836 // Values for max_lazy_match, good_match and max_chain_length, depending on 2837 // the desired pack level (0..9). The values given below have been tuned to 2838 // exclude worst case performance for pathological files. Better values may be 2839 // found for specific files. 2840 type Config_s = struct { 2841 Fgood_length Ush 2842 Fmax_lazy Ush 2843 Fnice_length Ush 2844 Fmax_chain Ush 2845 Ffunc Compress_func 2846 } /* deflate.c:120:9 */ 2847 2848 // =========================================================================== 2849 // Local data 2850 2851 // Tail of hash chains 2852 2853 // Matches of length 3 are discarded if their distance exceeds TOO_FAR 2854 2855 // Values for max_lazy_match, good_match and max_chain_length, depending on 2856 // the desired pack level (0..9). The values given below have been tuned to 2857 // exclude worst case performance for pathological files. Better values may be 2858 // found for specific files. 2859 type Config = Config_s /* deflate.c:126:3 */ 2860 2861 var configuration_table = [10]Config{ 2862 // good lazy nice chain 2863 /* 0 */ {Ffunc: 0}, // store only 2864 /* 1 */ {Fgood_length: Ush(4), Fmax_lazy: Ush(4), Fnice_length: Ush(8), Fmax_chain: Ush(4), Ffunc: 0}, // max speed, no lazy matches 2865 /* 2 */ {Fgood_length: Ush(4), Fmax_lazy: Ush(5), Fnice_length: Ush(16), Fmax_chain: Ush(8), Ffunc: 0}, 2866 /* 3 */ {Fgood_length: Ush(4), Fmax_lazy: Ush(6), Fnice_length: Ush(32), Fmax_chain: Ush(32), Ffunc: 0}, 2867 2868 /* 4 */ {Fgood_length: Ush(4), Fmax_lazy: Ush(4), Fnice_length: Ush(16), Fmax_chain: Ush(16), Ffunc: 0}, // lazy matches 2869 /* 5 */ {Fgood_length: Ush(8), Fmax_lazy: Ush(16), Fnice_length: Ush(32), Fmax_chain: Ush(32), Ffunc: 0}, 2870 /* 6 */ {Fgood_length: Ush(8), Fmax_lazy: Ush(16), Fnice_length: Ush(128), Fmax_chain: Ush(128), Ffunc: 0}, 2871 /* 7 */ {Fgood_length: Ush(8), Fmax_lazy: Ush(32), Fnice_length: Ush(128), Fmax_chain: Ush(256), Ffunc: 0}, 2872 /* 8 */ {Fgood_length: Ush(32), Fmax_lazy: Ush(128), Fnice_length: Ush(258), Fmax_chain: Ush(1024), Ffunc: 0}, 2873 /* 9 */ {Fgood_length: Ush(32), Fmax_lazy: Ush(258), Fnice_length: Ush(258), Fmax_chain: Ush(4096), Ffunc: 0}} /* deflate.c:134:20 */ 2874 2875 // max compression 2876 2877 // Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4 2878 // For deflate_fast() (levels <= 3) good is ignored and lazy has a different 2879 // meaning. 2880 2881 // rank Z_BLOCK between Z_NO_FLUSH and Z_PARTIAL_FLUSH 2882 2883 // =========================================================================== 2884 // Update a hash value with the given input byte 2885 // IN assertion: all calls to UPDATE_HASH are made with consecutive input 2886 // characters, so that a running hash key can be computed from the previous 2887 // key instead of complete recalculation each time. 2888 2889 // =========================================================================== 2890 // Insert string str in the dictionary and set match_head to the previous head 2891 // of the hash chain (the most recent string with same hash key). Return 2892 // the previous length of the hash chain. 2893 // If this file is compiled with -DFASTEST, the compression level is forced 2894 // to 1, and no hash chains are maintained. 2895 // IN assertion: all calls to INSERT_STRING are made with consecutive input 2896 // characters and the first MIN_MATCH bytes of str are valid (except for 2897 // the last MIN_MATCH-1 bytes of the input file). 2898 2899 // =========================================================================== 2900 // Initialize the hash table (avoiding 64K overflow for 16 bit systems). 2901 // prev[] will be initialized on the fly. 2902 2903 // =========================================================================== 2904 // Slide the hash table when sliding the window down (could be avoided with 32 2905 // bit values at the expense of memory usage). We slide even when level == 0 to 2906 // keep the hash table consistent if we switch back to level > 0 later. 2907 func slide_hash(tls *libc.TLS, s uintptr) { /* deflate.c:201:12: */ 2908 var n uint32 2909 var m uint32 2910 var p uintptr 2911 var wsize UInt = (*Deflate_state)(unsafe.Pointer(s)).Fw_size 2912 2913 n = (*Deflate_state)(unsafe.Pointer(s)).Fhash_size 2914 p = ((*Deflate_state)(unsafe.Pointer(s)).Fhead + uintptr(n)*2) 2915 for ok := true; ok; ok = libc.PreDecUint32(&n, 1) != 0 { 2916 m = uint32(*(*Posf)(unsafe.Pointer(libc.PreDecUintptr(&p, 2)))) 2917 *(*Posf)(unsafe.Pointer(p)) = func() uint16 { 2918 if m >= wsize { 2919 return (uint16(m - wsize)) 2920 } 2921 return uint16(NIL) 2922 }() 2923 } 2924 n = wsize 2925 p = ((*Deflate_state)(unsafe.Pointer(s)).Fprev + uintptr(n)*2) 2926 for ok1 := true; ok1; ok1 = libc.PreDecUint32(&n, 1) != 0 { 2927 m = uint32(*(*Posf)(unsafe.Pointer(libc.PreDecUintptr(&p, 2)))) 2928 *(*Posf)(unsafe.Pointer(p)) = func() uint16 { 2929 if m >= wsize { 2930 return (uint16(m - wsize)) 2931 } 2932 return uint16(NIL) 2933 }() 2934 // If n is not on any hash chain, prev[n] is garbage but 2935 // its value will never be used. 2936 } 2937 } 2938 2939 // ========================================================================= 2940 func XdeflateInit_(tls *libc.TLS, strm Z_streamp, level int32, version uintptr, stream_size int32) int32 { /* deflate.c:228:13: */ 2941 return XdeflateInit2_(tls, strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, 2942 Z_DEFAULT_STRATEGY, version, stream_size) 2943 // To do: ignore strm->next_in if we use it as window 2944 } 2945 2946 // ========================================================================= 2947 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: */ 2948 var s uintptr 2949 var wrap int32 = 1 2950 var overlay uintptr 2951 // We overlay pending_buf and d_buf+l_buf. This works since the average 2952 // output size for (length,distance) codes is <= 24 bits. 2953 2954 if ((version == uintptr(Z_NULL)) || (int32(*(*int8)(unsafe.Pointer(version))) != int32(my_version[0]))) || (uint64(stream_size) != uint64(unsafe.Sizeof(Z_stream{}))) { 2955 return -6 2956 } 2957 if strm == uintptr(Z_NULL) { 2958 return -2 2959 } 2960 2961 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = uintptr(Z_NULL) 2962 if (*Z_stream)(unsafe.Pointer(strm)).Fzalloc == uintptr(0) { 2963 (*Z_stream)(unsafe.Pointer(strm)).Fzalloc = *(*uintptr)(unsafe.Pointer(&struct { 2964 f func(*libc.TLS, Voidpf, uint32, uint32) Voidpf 2965 }{Xzcalloc})) 2966 (*Z_stream)(unsafe.Pointer(strm)).Fopaque = uintptr(0) 2967 } 2968 if (*Z_stream)(unsafe.Pointer(strm)).Fzfree == uintptr(0) { 2969 (*Z_stream)(unsafe.Pointer(strm)).Fzfree = *(*uintptr)(unsafe.Pointer(&struct { 2970 f func(*libc.TLS, Voidpf, Voidpf) 2971 }{Xzcfree})) 2972 } 2973 2974 if level == (-1) { 2975 level = 6 2976 } 2977 2978 if windowBits < 0 { // suppress zlib wrapper 2979 wrap = 0 2980 windowBits = -windowBits 2981 } else if windowBits > 15 { 2982 wrap = 2 // write gzip wrapper instead 2983 windowBits = windowBits - (16) 2984 } 2985 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)) { 2986 return -2 2987 } 2988 if windowBits == 8 { 2989 windowBits = 9 2990 } // until 256-byte window bug fixed 2991 s = (*struct { 2992 f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf 2993 })(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{}))) 2994 if s == uintptr(Z_NULL) { 2995 return -4 2996 } 2997 (*Z_stream)(unsafe.Pointer(strm)).Fstate = s 2998 (*Deflate_state)(unsafe.Pointer(s)).Fstrm = strm 2999 (*Deflate_state)(unsafe.Pointer(s)).Fstatus = INIT_STATE // to pass state test in deflateReset() 3000 3001 (*Deflate_state)(unsafe.Pointer(s)).Fwrap = wrap 3002 (*Deflate_state)(unsafe.Pointer(s)).Fgzhead = Gz_headerp(Z_NULL) 3003 (*Deflate_state)(unsafe.Pointer(s)).Fw_bits = UInt(windowBits) 3004 (*Deflate_state)(unsafe.Pointer(s)).Fw_size = (UInt(int32(1) << (*Deflate_state)(unsafe.Pointer(s)).Fw_bits)) 3005 (*Deflate_state)(unsafe.Pointer(s)).Fw_mask = ((*Deflate_state)(unsafe.Pointer(s)).Fw_size - UInt(1)) 3006 3007 (*Deflate_state)(unsafe.Pointer(s)).Fhash_bits = (UInt(memLevel) + UInt(7)) 3008 (*Deflate_state)(unsafe.Pointer(s)).Fhash_size = (UInt(int32(1) << (*Deflate_state)(unsafe.Pointer(s)).Fhash_bits)) 3009 (*Deflate_state)(unsafe.Pointer(s)).Fhash_mask = ((*Deflate_state)(unsafe.Pointer(s)).Fhash_size - UInt(1)) 3010 (*Deflate_state)(unsafe.Pointer(s)).Fhash_shift = ((((*Deflate_state)(unsafe.Pointer(s)).Fhash_bits + UInt(MIN_MATCH)) - UInt(1)) / UInt(MIN_MATCH)) 3011 3012 (*Deflate_state)(unsafe.Pointer(s)).Fwindow = (*struct { 3013 f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf 3014 })(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)))))) 3015 (*Deflate_state)(unsafe.Pointer(s)).Fprev = (*struct { 3016 f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf 3017 })(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)))) 3018 (*Deflate_state)(unsafe.Pointer(s)).Fhead = (*struct { 3019 f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf 3020 })(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)))) 3021 3022 (*Deflate_state)(unsafe.Pointer(s)).Fhigh_water = Ulg(0) // nothing written to s->window yet 3023 3024 (*Deflate_state)(unsafe.Pointer(s)).Flit_bufsize = (UInt(int32(1) << (memLevel + 6))) // 16K elements by default 3025 3026 overlay = (*struct { 3027 f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf 3028 })(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)))) 3029 (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf = overlay 3030 (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf_size = (Ulg(uint64(Ulg((*Deflate_state)(unsafe.Pointer(s)).Flit_bufsize)) * (uint64(unsafe.Sizeof(Ush(0))) + uint64(2)))) 3031 3032 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)) { 3033 (*Deflate_state)(unsafe.Pointer(s)).Fstatus = FINISH_STATE 3034 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = Xz_errmsg[(Z_NEED_DICT - (-4))] 3035 XdeflateEnd(tls, strm) 3036 return -4 3037 } 3038 (*Deflate_state)(unsafe.Pointer(s)).Fd_buf = (overlay + uintptr((uint64((*Deflate_state)(unsafe.Pointer(s)).Flit_bufsize)/uint64(unsafe.Sizeof(Ush(0)))))*2) 3039 (*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)))) 3040 3041 (*Deflate_state)(unsafe.Pointer(s)).Flevel = level 3042 (*Deflate_state)(unsafe.Pointer(s)).Fstrategy = strategy 3043 (*Deflate_state)(unsafe.Pointer(s)).Fmethod = Byte(method) 3044 3045 return XdeflateReset(tls, strm) 3046 } 3047 3048 var my_version = *(*[7]int8)(unsafe.Pointer(ts /* "1.2.11" */)) /* deflate.c:253:23 */ 3049 3050 // ========================================================================= 3051 // Check for a valid deflate stream state. Return 0 if ok, 1 if not. 3052 func deflateStateCheck(tls *libc.TLS, strm Z_streamp) int32 { /* deflate.c:353:11: */ 3053 var s uintptr 3054 if ((strm == uintptr(Z_NULL)) || ((*Z_stream)(unsafe.Pointer(strm)).Fzalloc == uintptr(0))) || ((*Z_stream)(unsafe.Pointer(strm)).Fzfree == uintptr(0)) { 3055 return 1 3056 } 3057 s = (*Z_stream)(unsafe.Pointer(strm)).Fstate 3058 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)) { 3059 return 1 3060 } 3061 return 0 3062 } 3063 3064 // ========================================================================= 3065 func XdeflateSetDictionary(tls *libc.TLS, strm Z_streamp, dictionary uintptr, dictLength UInt) int32 { /* deflate.c:376:13: */ 3066 var s uintptr 3067 var str UInt 3068 var n UInt 3069 var wrap int32 3070 var avail uint32 3071 var next uintptr 3072 3073 if (deflateStateCheck(tls, strm) != 0) || (dictionary == uintptr(Z_NULL)) { 3074 return -2 3075 } 3076 s = (*Z_stream)(unsafe.Pointer(strm)).Fstate 3077 wrap = (*Deflate_state)(unsafe.Pointer(s)).Fwrap 3078 if ((wrap == 2) || ((wrap == 1) && ((*Deflate_state)(unsafe.Pointer(s)).Fstatus != INIT_STATE))) || ((*Deflate_state)(unsafe.Pointer(s)).Flookahead != 0) { 3079 return -2 3080 } 3081 3082 // when using zlib wrappers, compute Adler-32 for provided dictionary 3083 if wrap == 1 { 3084 (*Z_stream)(unsafe.Pointer(strm)).Fadler = Xadler32(tls, (*Z_stream)(unsafe.Pointer(strm)).Fadler, dictionary, dictLength) 3085 } 3086 (*Deflate_state)(unsafe.Pointer(s)).Fwrap = 0 // avoid computing Adler-32 in read_buf 3087 3088 // if dictionary would fill window, just replace the history 3089 if dictLength >= (*Deflate_state)(unsafe.Pointer(s)).Fw_size { 3090 if wrap == 0 { // already empty otherwise 3091 *(*Posf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fhead + uintptr(((*Deflate_state)(unsafe.Pointer(s)).Fhash_size-UInt(1)))*2)) = Posf(NIL) 3092 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))))) 3093 3094 (*Deflate_state)(unsafe.Pointer(s)).Fstrstart = UInt(0) 3095 (*Deflate_state)(unsafe.Pointer(s)).Fblock_start = 0 3096 (*Deflate_state)(unsafe.Pointer(s)).Finsert = UInt(0) 3097 } 3098 dictionary += (uintptr(dictLength - (*Deflate_state)(unsafe.Pointer(s)).Fw_size)) // use the tail 3099 dictLength = (*Deflate_state)(unsafe.Pointer(s)).Fw_size 3100 } 3101 3102 // insert dictionary into window and hash 3103 avail = (*Z_stream)(unsafe.Pointer(strm)).Favail_in 3104 next = (*Z_stream)(unsafe.Pointer(strm)).Fnext_in 3105 (*Z_stream)(unsafe.Pointer(strm)).Favail_in = dictLength 3106 (*Z_stream)(unsafe.Pointer(strm)).Fnext_in = dictionary 3107 fill_window(tls, s) 3108 for (*Deflate_state)(unsafe.Pointer(s)).Flookahead >= UInt(MIN_MATCH) { 3109 str = (*Deflate_state)(unsafe.Pointer(s)).Fstrstart 3110 n = ((*Deflate_state)(unsafe.Pointer(s)).Flookahead - (UInt(MIN_MATCH - 1))) 3111 for ok := true; ok; ok = libc.PreDecUint32(&n, 1) != 0 { 3112 (*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) 3113 *(*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)) 3114 *(*Posf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fhead + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fins_h)*2)) = Pos(str) 3115 str++ 3116 } 3117 (*Deflate_state)(unsafe.Pointer(s)).Fstrstart = str 3118 (*Deflate_state)(unsafe.Pointer(s)).Flookahead = (UInt(MIN_MATCH - 1)) 3119 fill_window(tls, s) 3120 } 3121 *(*UInt)(unsafe.Pointer(s + 148 /* &.strstart */)) += ((*Deflate_state)(unsafe.Pointer(s)).Flookahead) 3122 (*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) 3123 (*Deflate_state)(unsafe.Pointer(s)).Finsert = (*Deflate_state)(unsafe.Pointer(s)).Flookahead 3124 (*Deflate_state)(unsafe.Pointer(s)).Flookahead = UInt(0) 3125 (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length = libc.AssignPtrUint32(s+160 /* &.prev_length */, (UInt(MIN_MATCH - 1))) 3126 (*Deflate_state)(unsafe.Pointer(s)).Fmatch_available = 0 3127 (*Z_stream)(unsafe.Pointer(strm)).Fnext_in = next 3128 (*Z_stream)(unsafe.Pointer(strm)).Favail_in = avail 3129 (*Deflate_state)(unsafe.Pointer(s)).Fwrap = wrap 3130 return Z_OK 3131 } 3132 3133 // ========================================================================= 3134 func XdeflateGetDictionary(tls *libc.TLS, strm Z_streamp, dictionary uintptr, dictLength uintptr) int32 { /* deflate.c:445:13: */ 3135 var s uintptr 3136 var len UInt 3137 3138 if deflateStateCheck(tls, strm) != 0 { 3139 return -2 3140 } 3141 s = (*Z_stream)(unsafe.Pointer(strm)).Fstate 3142 len = ((*Deflate_state)(unsafe.Pointer(s)).Fstrstart + (*Deflate_state)(unsafe.Pointer(s)).Flookahead) 3143 if len > (*Deflate_state)(unsafe.Pointer(s)).Fw_size { 3144 len = (*Deflate_state)(unsafe.Pointer(s)).Fw_size 3145 } 3146 if (dictionary != uintptr(Z_NULL)) && (len != 0) { 3147 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)) 3148 } 3149 if dictLength != uintptr(Z_NULL) { 3150 *(*UInt)(unsafe.Pointer(dictLength)) = len 3151 } 3152 return Z_OK 3153 } 3154 3155 // ========================================================================= 3156 func XdeflateResetKeep(tls *libc.TLS, strm Z_streamp) int32 { /* deflate.c:467:13: */ 3157 var s uintptr 3158 3159 if deflateStateCheck(tls, strm) != 0 { 3160 return -2 3161 } 3162 3163 (*Z_stream)(unsafe.Pointer(strm)).Ftotal_in = libc.AssignPtrUint32(strm+28 /* &.total_out */, ULong(0)) 3164 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = uintptr(Z_NULL) // use zfree if we ever allocate msg dynamically 3165 (*Z_stream)(unsafe.Pointer(strm)).Fdata_type = Z_UNKNOWN 3166 3167 s = (*Z_stream)(unsafe.Pointer(strm)).Fstate 3168 (*Deflate_state)(unsafe.Pointer(s)).Fpending = Ulg(0) 3169 (*Deflate_state)(unsafe.Pointer(s)).Fpending_out = (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf 3170 3171 if (*Deflate_state)(unsafe.Pointer(s)).Fwrap < 0 { 3172 (*Deflate_state)(unsafe.Pointer(s)).Fwrap = -(*Deflate_state)(unsafe.Pointer(s)).Fwrap // was made negative by deflate(..., Z_FINISH); 3173 } 3174 (*Deflate_state)(unsafe.Pointer(s)).Fstatus = func() int32 { 3175 if (*Deflate_state)(unsafe.Pointer(s)).Fwrap == 2 { 3176 return GZIP_STATE 3177 } 3178 return func() int32 { 3179 if (*Deflate_state)(unsafe.Pointer(s)).Fwrap != 0 { 3180 return INIT_STATE 3181 } 3182 return BUSY_STATE 3183 }() 3184 }() 3185 (*Z_stream)(unsafe.Pointer(strm)).Fadler = func() uint32 { 3186 if (*Deflate_state)(unsafe.Pointer(s)).Fwrap == 2 { 3187 return Xcrc32(tls, uint32(0), uintptr(Z_NULL), uint32(0)) 3188 } 3189 return Xadler32(tls, uint32(0), uintptr(Z_NULL), uint32(0)) 3190 }() 3191 (*Deflate_state)(unsafe.Pointer(s)).Flast_flush = Z_NO_FLUSH 3192 3193 X_tr_init(tls, s) 3194 3195 return Z_OK 3196 } 3197 3198 // ========================================================================= 3199 func XdeflateReset(tls *libc.TLS, strm Z_streamp) int32 { /* deflate.c:505:13: */ 3200 var ret int32 3201 3202 ret = XdeflateResetKeep(tls, strm) 3203 if ret == Z_OK { 3204 lm_init(tls, (*Z_stream)(unsafe.Pointer(strm)).Fstate) 3205 } 3206 return ret 3207 } 3208 3209 // ========================================================================= 3210 func XdeflateSetHeader(tls *libc.TLS, strm Z_streamp, head Gz_headerp) int32 { /* deflate.c:517:13: */ 3211 if (deflateStateCheck(tls, strm) != 0) || ((*Internal_state)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fstate)).Fwrap != 2) { 3212 return -2 3213 } 3214 (*Internal_state)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fstate)).Fgzhead = head 3215 return Z_OK 3216 } 3217 3218 // ========================================================================= 3219 func XdeflatePending(tls *libc.TLS, strm Z_streamp, pending uintptr, bits uintptr) int32 { /* deflate.c:528:13: */ 3220 if deflateStateCheck(tls, strm) != 0 { 3221 return -2 3222 } 3223 if pending != uintptr(Z_NULL) { 3224 *(*uint32)(unsafe.Pointer(pending)) = uint32((*Internal_state)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fstate)).Fpending) 3225 } 3226 if bits != uintptr(Z_NULL) { 3227 *(*int32)(unsafe.Pointer(bits)) = (*Internal_state)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fstate)).Fbi_valid 3228 } 3229 return Z_OK 3230 } 3231 3232 // ========================================================================= 3233 func XdeflatePrime(tls *libc.TLS, strm Z_streamp, bits int32, value int32) int32 { /* deflate.c:542:13: */ 3234 var s uintptr 3235 var put int32 3236 3237 if deflateStateCheck(tls, strm) != 0 { 3238 return -2 3239 } 3240 s = (*Z_stream)(unsafe.Pointer(strm)).Fstate 3241 if ((*Deflate_state)(unsafe.Pointer(s)).Fd_buf) < ((*Deflate_state)(unsafe.Pointer(s)).Fpending_out + uintptr((int32((Buf_size + 7)) >> 3))) { 3242 return -5 3243 } 3244 for ok := true; ok; ok = bits != 0 { 3245 put = (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid) 3246 if put > bits { 3247 put = bits 3248 } 3249 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32((Ush((value & ((int32(1) << put) - 1)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))))) 3250 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (put) 3251 X_tr_flush_bits(tls, s) 3252 value >>= put 3253 bits = bits - (put) 3254 } 3255 return Z_OK 3256 } 3257 3258 // ========================================================================= 3259 func XdeflateParams(tls *libc.TLS, strm Z_streamp, level int32, strategy int32) int32 { /* deflate.c:568:13: */ 3260 var s uintptr 3261 var func1 Compress_func 3262 3263 if deflateStateCheck(tls, strm) != 0 { 3264 return -2 3265 } 3266 s = (*Z_stream)(unsafe.Pointer(strm)).Fstate 3267 3268 if level == (-1) { 3269 level = 6 3270 } 3271 if (((level < 0) || (level > 9)) || (strategy < 0)) || (strategy > Z_FIXED) { 3272 return -2 3273 } 3274 func1 = configuration_table[(*Deflate_state)(unsafe.Pointer(s)).Flevel].Ffunc 3275 3276 if ((strategy != (*Deflate_state)(unsafe.Pointer(s)).Fstrategy) || (func1 != configuration_table[level].Ffunc)) && ((*Deflate_state)(unsafe.Pointer(s)).Fhigh_water != 0) { 3277 // Flush the last buffer: 3278 var err int32 = Xdeflate(tls, strm, Z_BLOCK) 3279 if err == (-2) { 3280 return err 3281 } 3282 if (*Z_stream)(unsafe.Pointer(strm)).Favail_out == UInt(0) { 3283 return -5 3284 } 3285 } 3286 if (*Deflate_state)(unsafe.Pointer(s)).Flevel != level { 3287 if ((*Deflate_state)(unsafe.Pointer(s)).Flevel == 0) && ((*Deflate_state)(unsafe.Pointer(s)).Fmatches != UInt(0)) { 3288 if (*Deflate_state)(unsafe.Pointer(s)).Fmatches == UInt(1) { 3289 slide_hash(tls, s) 3290 } else { 3291 *(*Posf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fhead + uintptr(((*Deflate_state)(unsafe.Pointer(s)).Fhash_size-UInt(1)))*2)) = Posf(NIL) 3292 } 3293 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))))) 3294 3295 (*Deflate_state)(unsafe.Pointer(s)).Fmatches = UInt(0) 3296 } 3297 (*Deflate_state)(unsafe.Pointer(s)).Flevel = level 3298 (*Deflate_state)(unsafe.Pointer(s)).Fmax_lazy_match = UInt(configuration_table[level].Fmax_lazy) 3299 (*Deflate_state)(unsafe.Pointer(s)).Fgood_match = UInt(configuration_table[level].Fgood_length) 3300 (*Deflate_state)(unsafe.Pointer(s)).Fnice_match = int32(configuration_table[level].Fnice_length) 3301 (*Deflate_state)(unsafe.Pointer(s)).Fmax_chain_length = UInt(configuration_table[level].Fmax_chain) 3302 } 3303 (*Deflate_state)(unsafe.Pointer(s)).Fstrategy = strategy 3304 return Z_OK 3305 } 3306 3307 // ========================================================================= 3308 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: */ 3309 var s uintptr 3310 3311 if deflateStateCheck(tls, strm) != 0 { 3312 return -2 3313 } 3314 s = (*Z_stream)(unsafe.Pointer(strm)).Fstate 3315 (*Deflate_state)(unsafe.Pointer(s)).Fgood_match = UInt(good_length) 3316 (*Deflate_state)(unsafe.Pointer(s)).Fmax_lazy_match = UInt(max_lazy) 3317 (*Deflate_state)(unsafe.Pointer(s)).Fnice_match = nice_length 3318 (*Deflate_state)(unsafe.Pointer(s)).Fmax_chain_length = UInt(max_chain) 3319 return Z_OK 3320 } 3321 3322 // ========================================================================= 3323 // For the default windowBits of 15 and memLevel of 8, this function returns 3324 // a close to exact, as well as small, upper bound on the compressed size. 3325 // They are coded as constants here for a reason--if the #define's are 3326 // changed, then this function needs to be changed as well. The return 3327 // value for 15 and 8 only works for those exact settings. 3328 // 3329 // For any setting other than those defaults for windowBits and memLevel, 3330 // the value returned is a conservative worst case for the maximum expansion 3331 // resulting from using fixed blocks instead of stored blocks, which deflate 3332 // can emit on compressed data for some combinations of the parameters. 3333 // 3334 // This function could be more sophisticated to provide closer upper bounds for 3335 // every combination of windowBits and memLevel. But even the conservative 3336 // upper bound of about 14% expansion does not seem onerous for output buffer 3337 // allocation. 3338 func XdeflateBound(tls *libc.TLS, strm Z_streamp, sourceLen ULong) ULong { /* deflate.c:652:15: */ 3339 var s uintptr 3340 var complen ULong 3341 var wraplen ULong 3342 3343 // conservative upper bound for compressed data 3344 complen = (((sourceLen + ((sourceLen + ULong(7)) >> 3)) + ((sourceLen + ULong(63)) >> 6)) + ULong(5)) 3345 3346 // if can't get parameters, return conservative bound plus zlib wrapper 3347 if deflateStateCheck(tls, strm) != 0 { 3348 return (complen + ULong(6)) 3349 } 3350 3351 // compute wrapper length 3352 s = (*Z_stream)(unsafe.Pointer(strm)).Fstate 3353 switch (*Deflate_state)(unsafe.Pointer(s)).Fwrap { 3354 case 0: // raw deflate 3355 wraplen = ULong(0) 3356 break 3357 case 1: // zlib wrapper 3358 wraplen = (ULong(6 + (func() int32 { 3359 if (*Deflate_state)(unsafe.Pointer(s)).Fstrstart != 0 { 3360 return 4 3361 } 3362 return 0 3363 }()))) 3364 break 3365 case 2: // gzip wrapper 3366 wraplen = ULong(18) 3367 if (*Deflate_state)(unsafe.Pointer(s)).Fgzhead != uintptr(Z_NULL) { // user-supplied gzip header 3368 var str uintptr 3369 if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fextra != uintptr(Z_NULL) { 3370 wraplen = wraplen + (ULong(UInt(2) + (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fextra_len)) 3371 } 3372 str = (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fname 3373 if str != uintptr(Z_NULL) { 3374 for ok := true; ok; ok = *(*Bytef)(unsafe.Pointer(libc.PostIncUintptr(&str, 1))) != 0 { 3375 wraplen++ 3376 } 3377 } 3378 str = (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fcomment 3379 if str != uintptr(Z_NULL) { 3380 for ok1 := true; ok1; ok1 = *(*Bytef)(unsafe.Pointer(libc.PostIncUintptr(&str, 1))) != 0 { 3381 wraplen++ 3382 } 3383 } 3384 if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fhcrc != 0 { 3385 wraplen = wraplen + (ULong(2)) 3386 } 3387 } 3388 break 3389 default: // for compiler happiness 3390 wraplen = ULong(6) 3391 } 3392 3393 // if not default parameters, return conservative bound 3394 if ((*Deflate_state)(unsafe.Pointer(s)).Fw_bits != UInt(15)) || ((*Deflate_state)(unsafe.Pointer(s)).Fhash_bits != (UInt(8 + 7))) { 3395 return (complen + wraplen) 3396 } 3397 3398 // default settings: return tight bound for that case 3399 return ((((((sourceLen + (sourceLen >> 12)) + (sourceLen >> 14)) + (sourceLen >> 25)) + ULong(13)) - ULong(6)) + wraplen) 3400 } 3401 3402 // ========================================================================= 3403 // Put a short in the pending buffer. The 16-bit value is put in MSB order. 3404 // IN assertion: the stream state is correct and there is enough room in 3405 // pending_buf. 3406 func putShortMSB(tls *libc.TLS, s uintptr, b UInt) { /* deflate.c:716:12: */ 3407 { 3408 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Byte(b >> 8)) 3409 } 3410 3411 { 3412 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Byte(b & UInt(0xff))) 3413 } 3414 3415 } 3416 3417 // ========================================================================= 3418 // Flush as much pending output as possible. All deflate() output, except for 3419 // some deflate_stored() output, goes through this function so some 3420 // applications may wish to modify it to avoid allocating a large 3421 // strm->next_out buffer and copying into it. (See also read_buf()). 3422 func flush_pending(tls *libc.TLS, strm Z_streamp) { /* deflate.c:730:12: */ 3423 var len uint32 3424 var s uintptr = (*Z_stream)(unsafe.Pointer(strm)).Fstate 3425 3426 X_tr_flush_bits(tls, s) 3427 len = uint32((*Deflate_state)(unsafe.Pointer(s)).Fpending) 3428 if len > (*Z_stream)(unsafe.Pointer(strm)).Favail_out { 3429 len = (*Z_stream)(unsafe.Pointer(strm)).Favail_out 3430 } 3431 if len == uint32(0) { 3432 return 3433 } 3434 3435 libc.Xmemcpy(tls, (*Z_stream)(unsafe.Pointer(strm)).Fnext_out, (*Deflate_state)(unsafe.Pointer(s)).Fpending_out, uint64(len)) 3436 *(*uintptr)(unsafe.Pointer(strm + 16 /* &.next_out */)) += (uintptr(len)) 3437 *(*uintptr)(unsafe.Pointer(s + 32 /* &.pending_out */)) += (uintptr(len)) 3438 *(*ULong)(unsafe.Pointer(strm + 28 /* &.total_out */)) += (ULong(len)) 3439 *(*UInt)(unsafe.Pointer(strm + 24 /* &.avail_out */)) -= (len) 3440 *(*Ulg)(unsafe.Pointer(s + 40 /* &.pending */)) -= (Ulg(len)) 3441 if (*Deflate_state)(unsafe.Pointer(s)).Fpending == Ulg(0) { 3442 (*Deflate_state)(unsafe.Pointer(s)).Fpending_out = (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf 3443 } 3444 } 3445 3446 // =========================================================================== 3447 // Update the header CRC with the bytes s->pending_buf[beg..s->pending - 1]. 3448 3449 // ========================================================================= 3450 func Xdeflate(tls *libc.TLS, strm Z_streamp, flush int32) int32 { /* deflate.c:763:13: */ 3451 var old_flush int32 // value of flush param for previous deflate call 3452 var s uintptr 3453 3454 if ((deflateStateCheck(tls, strm) != 0) || (flush > Z_BLOCK)) || (flush < 0) { 3455 return -2 3456 } 3457 s = (*Z_stream)(unsafe.Pointer(strm)).Fstate 3458 3459 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)) { 3460 return func() int32 { (*Z_stream)(unsafe.Pointer(strm)).Fmsg = Xz_errmsg[(Z_NEED_DICT - (-2))]; return -2 }() 3461 } 3462 if (*Z_stream)(unsafe.Pointer(strm)).Favail_out == UInt(0) { 3463 return func() int32 { (*Z_stream)(unsafe.Pointer(strm)).Fmsg = Xz_errmsg[(Z_NEED_DICT - (-5))]; return -5 }() 3464 } 3465 3466 old_flush = (*Deflate_state)(unsafe.Pointer(s)).Flast_flush 3467 (*Deflate_state)(unsafe.Pointer(s)).Flast_flush = flush 3468 3469 // Flush as much pending output as possible 3470 if (*Deflate_state)(unsafe.Pointer(s)).Fpending != Ulg(0) { 3471 flush_pending(tls, strm) 3472 if (*Z_stream)(unsafe.Pointer(strm)).Favail_out == UInt(0) { 3473 // Since avail_out is 0, deflate will be called again with 3474 // more output space, but possibly with both pending and 3475 // avail_in equal to zero. There won't be anything to do, 3476 // but this is not an error situation so make sure we 3477 // return OK instead of BUF_ERROR at next call of deflate: 3478 (*Deflate_state)(unsafe.Pointer(s)).Flast_flush = -1 3479 return Z_OK 3480 } 3481 3482 // Make sure there is something to do and avoid duplicate consecutive 3483 // flushes. For repeated and useless calls with Z_FINISH, we keep 3484 // returning Z_STREAM_END instead of Z_BUF_ERROR. 3485 } else if (((*Z_stream)(unsafe.Pointer(strm)).Favail_in == UInt(0)) && ((((flush) * 2) - (func() int32 { 3486 if (flush) > 4 { 3487 return 9 3488 } 3489 return 0 3490 }())) <= (((old_flush) * 2) - (func() int32 { 3491 if (old_flush) > 4 { 3492 return 9 3493 } 3494 return 0 3495 }())))) && (flush != Z_FINISH) { 3496 return func() int32 { (*Z_stream)(unsafe.Pointer(strm)).Fmsg = Xz_errmsg[(Z_NEED_DICT - (-5))]; return -5 }() 3497 } 3498 3499 // User must not provide more input after the first FINISH: 3500 if ((*Deflate_state)(unsafe.Pointer(s)).Fstatus == FINISH_STATE) && ((*Z_stream)(unsafe.Pointer(strm)).Favail_in != UInt(0)) { 3501 return func() int32 { (*Z_stream)(unsafe.Pointer(strm)).Fmsg = Xz_errmsg[(Z_NEED_DICT - (-5))]; return -5 }() 3502 } 3503 3504 // Write the header 3505 if (*Deflate_state)(unsafe.Pointer(s)).Fstatus == INIT_STATE { 3506 // zlib header 3507 var header UInt = ((UInt(Z_DEFLATED) + (((*Deflate_state)(unsafe.Pointer(s)).Fw_bits - UInt(8)) << 4)) << 8) 3508 var level_flags UInt 3509 3510 if ((*Deflate_state)(unsafe.Pointer(s)).Fstrategy >= Z_HUFFMAN_ONLY) || ((*Deflate_state)(unsafe.Pointer(s)).Flevel < 2) { 3511 level_flags = UInt(0) 3512 } else if (*Deflate_state)(unsafe.Pointer(s)).Flevel < 6 { 3513 level_flags = UInt(1) 3514 } else if (*Deflate_state)(unsafe.Pointer(s)).Flevel == 6 { 3515 level_flags = UInt(2) 3516 } else { 3517 level_flags = UInt(3) 3518 } 3519 header = header | (level_flags << 6) 3520 if (*Deflate_state)(unsafe.Pointer(s)).Fstrstart != UInt(0) { 3521 header = header | (UInt(PRESET_DICT)) 3522 } 3523 header = header + (UInt(31) - (header % UInt(31))) 3524 3525 putShortMSB(tls, s, header) 3526 3527 // Save the adler32 of the preset dictionary: 3528 if (*Deflate_state)(unsafe.Pointer(s)).Fstrstart != UInt(0) { 3529 putShortMSB(tls, s, (UInt((*Z_stream)(unsafe.Pointer(strm)).Fadler >> 16))) 3530 putShortMSB(tls, s, (UInt((*Z_stream)(unsafe.Pointer(strm)).Fadler & ULong(0xffff)))) 3531 } 3532 (*Z_stream)(unsafe.Pointer(strm)).Fadler = Xadler32(tls, uint32(0), uintptr(Z_NULL), uint32(0)) 3533 (*Deflate_state)(unsafe.Pointer(s)).Fstatus = BUSY_STATE 3534 3535 // Compression must start with an empty pending buffer 3536 flush_pending(tls, strm) 3537 if (*Deflate_state)(unsafe.Pointer(s)).Fpending != Ulg(0) { 3538 (*Deflate_state)(unsafe.Pointer(s)).Flast_flush = -1 3539 return Z_OK 3540 } 3541 } 3542 if (*Deflate_state)(unsafe.Pointer(s)).Fstatus == GZIP_STATE { 3543 // gzip header 3544 (*Z_stream)(unsafe.Pointer(strm)).Fadler = Xcrc32(tls, uint32(0), uintptr(Z_NULL), uint32(0)) 3545 { 3546 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Bytef(31) 3547 } 3548 3549 { 3550 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Bytef(139) 3551 } 3552 3553 { 3554 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Bytef(8) 3555 } 3556 3557 if (*Deflate_state)(unsafe.Pointer(s)).Fgzhead == uintptr(Z_NULL) { 3558 { 3559 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Bytef(0) 3560 } 3561 3562 { 3563 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Bytef(0) 3564 } 3565 3566 { 3567 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Bytef(0) 3568 } 3569 3570 { 3571 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Bytef(0) 3572 } 3573 3574 { 3575 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Bytef(0) 3576 } 3577 3578 { 3579 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = func() uint8 { 3580 if (*Deflate_state)(unsafe.Pointer(s)).Flevel == 9 { 3581 return uint8(2) 3582 } 3583 return func() uint8 { 3584 if ((*Deflate_state)(unsafe.Pointer(s)).Fstrategy >= Z_HUFFMAN_ONLY) || ((*Deflate_state)(unsafe.Pointer(s)).Flevel < 2) { 3585 return uint8(4) 3586 } 3587 return uint8(0) 3588 }() 3589 }() 3590 } 3591 3592 { 3593 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Bytef(OS_CODE) 3594 } 3595 3596 (*Deflate_state)(unsafe.Pointer(s)).Fstatus = BUSY_STATE 3597 3598 // Compression must start with an empty pending buffer 3599 flush_pending(tls, strm) 3600 if (*Deflate_state)(unsafe.Pointer(s)).Fpending != Ulg(0) { 3601 (*Deflate_state)(unsafe.Pointer(s)).Flast_flush = -1 3602 return Z_OK 3603 } 3604 } else { 3605 { 3606 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Bytef(((((func() int32 { 3607 if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Ftext != 0 { 3608 return 1 3609 } 3610 return 0 3611 }()) + (func() int32 { 3612 if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fhcrc != 0 { 3613 return 2 3614 } 3615 return 0 3616 }())) + (func() int32 { 3617 if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fextra == uintptr(Z_NULL) { 3618 return 0 3619 } 3620 return 4 3621 }())) + (func() int32 { 3622 if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fname == uintptr(Z_NULL) { 3623 return 0 3624 } 3625 return 8 3626 }())) + (func() int32 { 3627 if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fcomment == uintptr(Z_NULL) { 3628 return 0 3629 } 3630 return 16 3631 }()))) 3632 } 3633 3634 { 3635 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Byte((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Ftime & ULong(0xff))) 3636 } 3637 3638 { 3639 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Byte(((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Ftime >> 8) & ULong(0xff))) 3640 } 3641 3642 { 3643 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Byte(((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Ftime >> 16) & ULong(0xff))) 3644 } 3645 3646 { 3647 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Byte(((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Ftime >> 24) & ULong(0xff))) 3648 } 3649 3650 { 3651 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = func() uint8 { 3652 if (*Deflate_state)(unsafe.Pointer(s)).Flevel == 9 { 3653 return uint8(2) 3654 } 3655 return func() uint8 { 3656 if ((*Deflate_state)(unsafe.Pointer(s)).Fstrategy >= Z_HUFFMAN_ONLY) || ((*Deflate_state)(unsafe.Pointer(s)).Flevel < 2) { 3657 return uint8(4) 3658 } 3659 return uint8(0) 3660 }() 3661 }() 3662 } 3663 3664 { 3665 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Bytef((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fos & 0xff)) 3666 } 3667 3668 if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fextra != uintptr(Z_NULL) { 3669 { 3670 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Bytef((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fextra_len & UInt(0xff))) 3671 } 3672 3673 { 3674 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Bytef(((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fextra_len >> 8) & UInt(0xff))) 3675 } 3676 3677 } 3678 if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fhcrc != 0 { 3679 (*Z_stream)(unsafe.Pointer(strm)).Fadler = Xcrc32(tls, (*Z_stream)(unsafe.Pointer(strm)).Fadler, (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf, 3680 uint32((*Deflate_state)(unsafe.Pointer(s)).Fpending)) 3681 } 3682 (*Deflate_state)(unsafe.Pointer(s)).Fgzindex = Ulg(0) 3683 (*Deflate_state)(unsafe.Pointer(s)).Fstatus = EXTRA_STATE 3684 } 3685 } 3686 if (*Deflate_state)(unsafe.Pointer(s)).Fstatus == EXTRA_STATE { 3687 if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fextra != uintptr(Z_NULL) { 3688 var beg Ulg = (*Deflate_state)(unsafe.Pointer(s)).Fpending // start of bytes to update crc 3689 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)) 3690 for ((*Deflate_state)(unsafe.Pointer(s)).Fpending + Ulg(left)) > (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf_size { 3691 var copy UInt = (UInt((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fpending)) 3692 libc.Xmemcpy(tls, ((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fpending)), 3693 ((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fextra + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fgzindex)), uint64(copy)) 3694 (*Deflate_state)(unsafe.Pointer(s)).Fpending = (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf_size 3695 for ok := true; ok; ok = 0 != 0 { 3696 if ((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fhcrc != 0) && ((*Deflate_state)(unsafe.Pointer(s)).Fpending > (beg)) { 3697 (*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)))) 3698 } 3699 } 3700 *(*Ulg)(unsafe.Pointer(s + 56 /* &.gzindex */)) += (Ulg(copy)) 3701 flush_pending(tls, strm) 3702 if (*Deflate_state)(unsafe.Pointer(s)).Fpending != Ulg(0) { 3703 (*Deflate_state)(unsafe.Pointer(s)).Flast_flush = -1 3704 return Z_OK 3705 } 3706 beg = Ulg(0) 3707 left = left - (copy) 3708 } 3709 libc.Xmemcpy(tls, ((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fpending)), 3710 ((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fextra + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fgzindex)), uint64(left)) 3711 *(*Ulg)(unsafe.Pointer(s + 40 /* &.pending */)) += (Ulg(left)) 3712 for ok1 := true; ok1; ok1 = 0 != 0 { 3713 if ((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fhcrc != 0) && ((*Deflate_state)(unsafe.Pointer(s)).Fpending > (beg)) { 3714 (*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)))) 3715 } 3716 } 3717 (*Deflate_state)(unsafe.Pointer(s)).Fgzindex = Ulg(0) 3718 } 3719 (*Deflate_state)(unsafe.Pointer(s)).Fstatus = NAME_STATE 3720 } 3721 if (*Deflate_state)(unsafe.Pointer(s)).Fstatus == NAME_STATE { 3722 if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fname != uintptr(Z_NULL) { 3723 var beg Ulg = (*Deflate_state)(unsafe.Pointer(s)).Fpending // start of bytes to update crc 3724 var val int32 3725 for ok2 := true; ok2; ok2 = (val != 0) { 3726 if (*Deflate_state)(unsafe.Pointer(s)).Fpending == (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf_size { 3727 for ok3 := true; ok3; ok3 = 0 != 0 { 3728 if ((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fhcrc != 0) && ((*Deflate_state)(unsafe.Pointer(s)).Fpending > (beg)) { 3729 (*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)))) 3730 } 3731 } 3732 flush_pending(tls, strm) 3733 if (*Deflate_state)(unsafe.Pointer(s)).Fpending != Ulg(0) { 3734 (*Deflate_state)(unsafe.Pointer(s)).Flast_flush = -1 3735 return Z_OK 3736 } 3737 beg = Ulg(0) 3738 } 3739 val = int32(*(*Bytef)(unsafe.Pointer((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fname + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fgzindex, 1))))) 3740 { 3741 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Bytef(val) 3742 } 3743 3744 } 3745 for ok4 := true; ok4; ok4 = 0 != 0 { 3746 if ((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fhcrc != 0) && ((*Deflate_state)(unsafe.Pointer(s)).Fpending > (beg)) { 3747 (*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)))) 3748 } 3749 } 3750 (*Deflate_state)(unsafe.Pointer(s)).Fgzindex = Ulg(0) 3751 } 3752 (*Deflate_state)(unsafe.Pointer(s)).Fstatus = COMMENT_STATE 3753 } 3754 if (*Deflate_state)(unsafe.Pointer(s)).Fstatus == COMMENT_STATE { 3755 if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fcomment != uintptr(Z_NULL) { 3756 var beg Ulg = (*Deflate_state)(unsafe.Pointer(s)).Fpending // start of bytes to update crc 3757 var val int32 3758 for ok5 := true; ok5; ok5 = (val != 0) { 3759 if (*Deflate_state)(unsafe.Pointer(s)).Fpending == (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf_size { 3760 for ok6 := true; ok6; ok6 = 0 != 0 { 3761 if ((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fhcrc != 0) && ((*Deflate_state)(unsafe.Pointer(s)).Fpending > (beg)) { 3762 (*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)))) 3763 } 3764 } 3765 flush_pending(tls, strm) 3766 if (*Deflate_state)(unsafe.Pointer(s)).Fpending != Ulg(0) { 3767 (*Deflate_state)(unsafe.Pointer(s)).Flast_flush = -1 3768 return Z_OK 3769 } 3770 beg = Ulg(0) 3771 } 3772 val = int32(*(*Bytef)(unsafe.Pointer((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fcomment + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fgzindex, 1))))) 3773 { 3774 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Bytef(val) 3775 } 3776 3777 } 3778 for ok7 := true; ok7; ok7 = 0 != 0 { 3779 if ((*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fhcrc != 0) && ((*Deflate_state)(unsafe.Pointer(s)).Fpending > (beg)) { 3780 (*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)))) 3781 } 3782 } 3783 } 3784 (*Deflate_state)(unsafe.Pointer(s)).Fstatus = HCRC_STATE 3785 } 3786 if (*Deflate_state)(unsafe.Pointer(s)).Fstatus == HCRC_STATE { 3787 if (*Gz_header)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fgzhead)).Fhcrc != 0 { 3788 if ((*Deflate_state)(unsafe.Pointer(s)).Fpending + Ulg(2)) > (*Deflate_state)(unsafe.Pointer(s)).Fpending_buf_size { 3789 flush_pending(tls, strm) 3790 if (*Deflate_state)(unsafe.Pointer(s)).Fpending != Ulg(0) { 3791 (*Deflate_state)(unsafe.Pointer(s)).Flast_flush = -1 3792 return Z_OK 3793 } 3794 } 3795 { 3796 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Byte((*Z_stream)(unsafe.Pointer(strm)).Fadler & ULong(0xff))) 3797 } 3798 3799 { 3800 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Byte(((*Z_stream)(unsafe.Pointer(strm)).Fadler >> 8) & ULong(0xff))) 3801 } 3802 3803 (*Z_stream)(unsafe.Pointer(strm)).Fadler = Xcrc32(tls, uint32(0), uintptr(Z_NULL), uint32(0)) 3804 } 3805 (*Deflate_state)(unsafe.Pointer(s)).Fstatus = BUSY_STATE 3806 3807 // Compression must start with an empty pending buffer 3808 flush_pending(tls, strm) 3809 if (*Deflate_state)(unsafe.Pointer(s)).Fpending != Ulg(0) { 3810 (*Deflate_state)(unsafe.Pointer(s)).Flast_flush = -1 3811 return Z_OK 3812 } 3813 } 3814 3815 // Start a new block or continue the current one. 3816 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)) { 3817 var bstate Block_state 3818 3819 if (*Deflate_state)(unsafe.Pointer(s)).Flevel == 0 { 3820 bstate = deflate_stored(tls, s, flush) 3821 } else { 3822 if (*Deflate_state)(unsafe.Pointer(s)).Fstrategy == Z_HUFFMAN_ONLY { 3823 bstate = deflate_huff(tls, s, flush) 3824 } else { 3825 if (*Deflate_state)(unsafe.Pointer(s)).Fstrategy == Z_RLE { 3826 bstate = deflate_rle(tls, s, flush) 3827 } else { 3828 bstate = (*struct { 3829 f func(*libc.TLS, uintptr, int32) Block_state 3830 })(unsafe.Pointer(&struct{ uintptr }{configuration_table[(*Deflate_state)(unsafe.Pointer(s)).Flevel].Ffunc})).f(tls, s, flush) 3831 } 3832 } 3833 } 3834 3835 if (bstate == Finish_started) || (bstate == Finish_done) { 3836 (*Deflate_state)(unsafe.Pointer(s)).Fstatus = FINISH_STATE 3837 } 3838 if (bstate == Need_more) || (bstate == Finish_started) { 3839 if (*Z_stream)(unsafe.Pointer(strm)).Favail_out == UInt(0) { 3840 (*Deflate_state)(unsafe.Pointer(s)).Flast_flush = -1 // avoid BUF_ERROR next call, see above 3841 } 3842 return Z_OK 3843 // If flush != Z_NO_FLUSH && avail_out == 0, the next call 3844 // of deflate should use the same flush parameter to make sure 3845 // that the flush is complete. So we don't have to output an 3846 // empty block here, this will be done at next call. This also 3847 // ensures that for a very small output buffer, we emit at most 3848 // one empty block. 3849 } 3850 if bstate == Block_done { 3851 if flush == Z_PARTIAL_FLUSH { 3852 X_tr_align(tls, s) 3853 } else if flush != Z_BLOCK { // FULL_FLUSH or SYNC_FLUSH 3854 X_tr_stored_block(tls, s, uintptr(0), uint32(0), 0) 3855 // For a full flush, this empty block will be recognized 3856 // as a special marker by inflate_sync(). 3857 if flush == Z_FULL_FLUSH { 3858 *(*Posf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fhead + uintptr(((*Deflate_state)(unsafe.Pointer(s)).Fhash_size-UInt(1)))*2)) = Posf(NIL) 3859 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))))) 3860 // forget history 3861 if (*Deflate_state)(unsafe.Pointer(s)).Flookahead == UInt(0) { 3862 (*Deflate_state)(unsafe.Pointer(s)).Fstrstart = UInt(0) 3863 (*Deflate_state)(unsafe.Pointer(s)).Fblock_start = 0 3864 (*Deflate_state)(unsafe.Pointer(s)).Finsert = UInt(0) 3865 } 3866 } 3867 } 3868 flush_pending(tls, strm) 3869 if (*Z_stream)(unsafe.Pointer(strm)).Favail_out == UInt(0) { 3870 (*Deflate_state)(unsafe.Pointer(s)).Flast_flush = -1 // avoid BUF_ERROR at next call, see above 3871 return Z_OK 3872 } 3873 } 3874 } 3875 3876 if flush != Z_FINISH { 3877 return Z_OK 3878 } 3879 if (*Deflate_state)(unsafe.Pointer(s)).Fwrap <= 0 { 3880 return Z_STREAM_END 3881 } 3882 3883 // Write the trailer 3884 if (*Deflate_state)(unsafe.Pointer(s)).Fwrap == 2 { 3885 { 3886 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Byte((*Z_stream)(unsafe.Pointer(strm)).Fadler & ULong(0xff))) 3887 } 3888 3889 { 3890 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Byte(((*Z_stream)(unsafe.Pointer(strm)).Fadler >> 8) & ULong(0xff))) 3891 } 3892 3893 { 3894 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Byte(((*Z_stream)(unsafe.Pointer(strm)).Fadler >> 16) & ULong(0xff))) 3895 } 3896 3897 { 3898 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Byte(((*Z_stream)(unsafe.Pointer(strm)).Fadler >> 24) & ULong(0xff))) 3899 } 3900 3901 { 3902 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Byte((*Z_stream)(unsafe.Pointer(strm)).Ftotal_in & ULong(0xff))) 3903 } 3904 3905 { 3906 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Byte(((*Z_stream)(unsafe.Pointer(strm)).Ftotal_in >> 8) & ULong(0xff))) 3907 } 3908 3909 { 3910 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Byte(((*Z_stream)(unsafe.Pointer(strm)).Ftotal_in >> 16) & ULong(0xff))) 3911 } 3912 3913 { 3914 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Byte(((*Z_stream)(unsafe.Pointer(strm)).Ftotal_in >> 24) & ULong(0xff))) 3915 } 3916 3917 } else { 3918 putShortMSB(tls, s, (UInt((*Z_stream)(unsafe.Pointer(strm)).Fadler >> 16))) 3919 putShortMSB(tls, s, (UInt((*Z_stream)(unsafe.Pointer(strm)).Fadler & ULong(0xffff)))) 3920 } 3921 flush_pending(tls, strm) 3922 // If avail_out is zero, the application will call deflate again 3923 // to flush the rest. 3924 if (*Deflate_state)(unsafe.Pointer(s)).Fwrap > 0 { 3925 (*Deflate_state)(unsafe.Pointer(s)).Fwrap = -(*Deflate_state)(unsafe.Pointer(s)).Fwrap 3926 } // write the trailer only once! 3927 if (*Deflate_state)(unsafe.Pointer(s)).Fpending != Ulg(0) { 3928 return Z_OK 3929 } 3930 return Z_STREAM_END 3931 } 3932 3933 // ========================================================================= 3934 func XdeflateEnd(tls *libc.TLS, strm Z_streamp) int32 { /* deflate.c:1076:13: */ 3935 var status int32 3936 3937 if deflateStateCheck(tls, strm) != 0 { 3938 return -2 3939 } 3940 3941 status = (*Internal_state)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fstate)).Fstatus 3942 3943 /* Deallocate in reverse order of allocations: */ 3944 { 3945 if (*Internal_state)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fstate)).Fpending_buf != 0 { 3946 (*struct { 3947 f func(*libc.TLS, Voidpf, Voidpf) 3948 })(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) 3949 } 3950 } 3951 3952 { 3953 if (*Internal_state)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fstate)).Fhead != 0 { 3954 (*struct { 3955 f func(*libc.TLS, Voidpf, Voidpf) 3956 })(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) 3957 } 3958 } 3959 3960 { 3961 if (*Internal_state)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fstate)).Fprev != 0 { 3962 (*struct { 3963 f func(*libc.TLS, Voidpf, Voidpf) 3964 })(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) 3965 } 3966 } 3967 3968 { 3969 if (*Internal_state)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fstate)).Fwindow != 0 { 3970 (*struct { 3971 f func(*libc.TLS, Voidpf, Voidpf) 3972 })(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) 3973 } 3974 } 3975 3976 (*struct { 3977 f func(*libc.TLS, Voidpf, Voidpf) 3978 })(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer((strm))).Fzfree})).f(tls, (*Z_stream)(unsafe.Pointer(strm)).Fopaque, (*Z_stream)(unsafe.Pointer(strm)).Fstate) 3979 (*Z_stream)(unsafe.Pointer(strm)).Fstate = uintptr(Z_NULL) 3980 3981 if status == BUSY_STATE { 3982 return -3 3983 } 3984 return Z_OK 3985 } 3986 3987 // ========================================================================= 3988 // Copy the source state to the destination state. 3989 // To simplify the source, this is not supported for 16-bit MSDOS (which 3990 // doesn't have enough memory anyway to duplicate compression states). 3991 func XdeflateCopy(tls *libc.TLS, dest Z_streamp, source Z_streamp) int32 { /* deflate.c:1102:13: */ 3992 var ds uintptr 3993 var ss uintptr 3994 var overlay uintptr 3995 3996 if (deflateStateCheck(tls, source) != 0) || (dest == uintptr(Z_NULL)) { 3997 return -2 3998 } 3999 4000 ss = (*Z_stream)(unsafe.Pointer(source)).Fstate 4001 4002 libc.Xmemcpy(tls, dest, source, uint64(unsafe.Sizeof(Z_stream{}))) 4003 4004 ds = (*struct { 4005 f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf 4006 })(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{}))) 4007 if ds == uintptr(Z_NULL) { 4008 return -4 4009 } 4010 (*Z_stream)(unsafe.Pointer(dest)).Fstate = ds 4011 libc.Xmemcpy(tls, ds, ss, uint64(unsafe.Sizeof(Deflate_state{}))) 4012 (*Deflate_state)(unsafe.Pointer(ds)).Fstrm = dest 4013 4014 (*Deflate_state)(unsafe.Pointer(ds)).Fwindow = (*struct { 4015 f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf 4016 })(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)))))) 4017 (*Deflate_state)(unsafe.Pointer(ds)).Fprev = (*struct { 4018 f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf 4019 })(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)))) 4020 (*Deflate_state)(unsafe.Pointer(ds)).Fhead = (*struct { 4021 f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf 4022 })(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)))) 4023 overlay = (*struct { 4024 f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf 4025 })(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)))) 4026 (*Deflate_state)(unsafe.Pointer(ds)).Fpending_buf = overlay 4027 4028 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)) { 4029 XdeflateEnd(tls, dest) 4030 return -4 4031 } 4032 // following zmemcpy do not work for 16-bit MSDOS 4033 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))))) 4034 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))))) 4035 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))))) 4036 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))) 4037 4038 (*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))) 4039 (*Deflate_state)(unsafe.Pointer(ds)).Fd_buf = (overlay + uintptr((uint64((*Deflate_state)(unsafe.Pointer(ds)).Flit_bufsize)/uint64(unsafe.Sizeof(Ush(0)))))*2) 4040 (*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)))) 4041 4042 (*Deflate_state)(unsafe.Pointer(ds)).Fl_desc.Fdyn_tree = ds + 188 /* &.dyn_ltree */ 4043 (*Deflate_state)(unsafe.Pointer(ds)).Fd_desc.Fdyn_tree = ds + 2480 /* &.dyn_dtree */ 4044 (*Deflate_state)(unsafe.Pointer(ds)).Fbl_desc.Fdyn_tree = ds + 2724 /* &.bl_tree */ 4045 4046 return Z_OK 4047 } 4048 4049 // =========================================================================== 4050 // Read a new buffer from the current input stream, update the adler32 4051 // and total number of bytes read. All deflate() input goes through 4052 // this function so some applications may wish to modify it to avoid 4053 // allocating a large strm->next_in buffer and copying from it. 4054 // (See also flush_pending()). 4055 func read_buf(tls *libc.TLS, strm Z_streamp, buf uintptr, size uint32) uint32 { /* deflate.c:1164:16: */ 4056 var len uint32 = (*Z_stream)(unsafe.Pointer(strm)).Favail_in 4057 4058 if len > size { 4059 len = size 4060 } 4061 if len == uint32(0) { 4062 return uint32(0) 4063 } 4064 4065 *(*UInt)(unsafe.Pointer(strm + 8 /* &.avail_in */)) -= (len) 4066 4067 libc.Xmemcpy(tls, buf, (*Z_stream)(unsafe.Pointer(strm)).Fnext_in, uint64(len)) 4068 if (*Internal_state)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fstate)).Fwrap == 1 { 4069 (*Z_stream)(unsafe.Pointer(strm)).Fadler = Xadler32(tls, (*Z_stream)(unsafe.Pointer(strm)).Fadler, buf, len) 4070 } else if (*Internal_state)(unsafe.Pointer((*Z_stream)(unsafe.Pointer(strm)).Fstate)).Fwrap == 2 { 4071 (*Z_stream)(unsafe.Pointer(strm)).Fadler = Xcrc32(tls, (*Z_stream)(unsafe.Pointer(strm)).Fadler, buf, len) 4072 } 4073 *(*uintptr)(unsafe.Pointer(strm /* &.next_in */)) += (uintptr(len)) 4074 *(*ULong)(unsafe.Pointer(strm + 12 /* &.total_in */)) += (ULong(len)) 4075 4076 return len 4077 } 4078 4079 // =========================================================================== 4080 // Initialize the "longest match" routines for a new zlib stream 4081 func lm_init(tls *libc.TLS, s uintptr) { /* deflate.c:1194:12: */ 4082 (*Deflate_state)(unsafe.Pointer(s)).Fwindow_size = (Ulg(2) * Ulg((*Deflate_state)(unsafe.Pointer(s)).Fw_size)) 4083 4084 *(*Posf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fhead + uintptr(((*Deflate_state)(unsafe.Pointer(s)).Fhash_size-UInt(1)))*2)) = Posf(NIL) 4085 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))))) 4086 4087 // Set the default configuration parameters: 4088 (*Deflate_state)(unsafe.Pointer(s)).Fmax_lazy_match = UInt(configuration_table[(*Deflate_state)(unsafe.Pointer(s)).Flevel].Fmax_lazy) 4089 (*Deflate_state)(unsafe.Pointer(s)).Fgood_match = UInt(configuration_table[(*Deflate_state)(unsafe.Pointer(s)).Flevel].Fgood_length) 4090 (*Deflate_state)(unsafe.Pointer(s)).Fnice_match = int32(configuration_table[(*Deflate_state)(unsafe.Pointer(s)).Flevel].Fnice_length) 4091 (*Deflate_state)(unsafe.Pointer(s)).Fmax_chain_length = UInt(configuration_table[(*Deflate_state)(unsafe.Pointer(s)).Flevel].Fmax_chain) 4092 4093 (*Deflate_state)(unsafe.Pointer(s)).Fstrstart = UInt(0) 4094 (*Deflate_state)(unsafe.Pointer(s)).Fblock_start = 0 4095 (*Deflate_state)(unsafe.Pointer(s)).Flookahead = UInt(0) 4096 (*Deflate_state)(unsafe.Pointer(s)).Finsert = UInt(0) 4097 (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length = libc.AssignPtrUint32(s+160 /* &.prev_length */, (UInt(MIN_MATCH - 1))) 4098 (*Deflate_state)(unsafe.Pointer(s)).Fmatch_available = 0 4099 (*Deflate_state)(unsafe.Pointer(s)).Fins_h = UInt(0) 4100 } 4101 4102 // =========================================================================== 4103 // Set match_start to the longest match starting at the given string and 4104 // return its length. Matches shorter or equal to prev_length are discarded, 4105 // in which case the result is equal to prev_length and match_start is 4106 // garbage. 4107 // IN assertions: cur_match is the head of the hash chain for the current 4108 // string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 4109 // OUT assertion: the match length is not greater than s->lookahead. 4110 // For 80x86 and 680x0, an optimized version will be provided in match.asm or 4111 // match.S. The code will be functionally equivalent. 4112 func longest_match(tls *libc.TLS, s uintptr, cur_match IPos) UInt { /* deflate.c:1236:12: */ 4113 var chain_length uint32 = (*Deflate_state)(unsafe.Pointer(s)).Fmax_chain_length // max hash chain length 4114 var scan uintptr = ((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)) // current string 4115 var match uintptr // matched string 4116 var len int32 // length of current match 4117 var best_len int32 = int32((*Deflate_state)(unsafe.Pointer(s)).Fprev_length) // best match length so far 4118 var nice_match int32 = (*Deflate_state)(unsafe.Pointer(s)).Fnice_match // stop if match long enough 4119 var limit IPos 4120 if (*Deflate_state)(unsafe.Pointer(s)).Fstrstart > ((*Deflate_state)(unsafe.Pointer((s))).Fw_size - (UInt((MAX_MATCH + MIN_MATCH) + 1))) { 4121 limit = ((*Deflate_state)(unsafe.Pointer(s)).Fstrstart - ((*Deflate_state)(unsafe.Pointer((s))).Fw_size - (UInt((MAX_MATCH + MIN_MATCH) + 1)))) 4122 } else { 4123 limit = uint32(NIL) 4124 } 4125 // Stop when cur_match becomes <= limit. To simplify the code, 4126 // we prevent matches with the string of window index 0. 4127 var prev uintptr = (*Deflate_state)(unsafe.Pointer(s)).Fprev 4128 var wmask UInt = (*Deflate_state)(unsafe.Pointer(s)).Fw_mask 4129 4130 var strend uintptr = (((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)) + uintptr(MAX_MATCH)) 4131 var scan_end1 Byte = *(*Bytef)(unsafe.Pointer(scan + uintptr((best_len - 1)))) 4132 var scan_end Byte = *(*Bytef)(unsafe.Pointer(scan + uintptr(best_len))) 4133 4134 // The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. 4135 // It is easy to get rid of this optimization if necessary. 4136 4137 // Do not waste too much time if we already have a good match: 4138 if (*Deflate_state)(unsafe.Pointer(s)).Fprev_length >= (*Deflate_state)(unsafe.Pointer(s)).Fgood_match { 4139 chain_length >>= 2 4140 } 4141 // Do not look for matches beyond the end of the input. This is necessary 4142 // to make deflate deterministic. 4143 if UInt(nice_match) > (*Deflate_state)(unsafe.Pointer(s)).Flookahead { 4144 nice_match = int32((*Deflate_state)(unsafe.Pointer(s)).Flookahead) 4145 } 4146 4147 for ok := true; ok; ok = (((libc.AssignUint32(&cur_match, IPos(*(*Posf)(unsafe.Pointer(prev + uintptr((cur_match&wmask))*2))))) > limit) && 4148 (libc.PreDecUint32(&chain_length, 1) != uint32(0))) { 4149 4150 match = ((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(cur_match)) 4151 4152 // Skip to next match if the match length cannot increase 4153 // or if the match length is less than 2. Note that the checks below 4154 // for insufficient lookahead only occur occasionally for performance 4155 // reasons. Therefore uninitialized memory will be accessed, and 4156 // conditional jumps will be made that depend on those values. 4157 // However the length of the match is limited to the lookahead, so 4158 // the output of deflate is not affected by the uninitialized values. 4159 4160 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)))) { 4161 continue 4162 } 4163 4164 // The check at best_len-1 can be removed because it will be made 4165 // again later. (This heuristic is not always a win.) 4166 // It is not necessary to compare scan[2] and match[2] since they 4167 // are always equal when the other bytes match, given that 4168 // the hash keys are equal and that HASH_BITS >= 8. 4169 scan += uintptr(2) 4170 match++ 4171 4172 // We check for insufficient lookahead only every 8th comparison; 4173 // the 256th check will be made at strstart+258. 4174 for ok1 := true; ok1; ok1 = (((((((((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)) { 4175 } 4176 4177 len = (MAX_MATCH - (int32((int64(strend) - int64(scan)) / 1))) 4178 scan = (strend - uintptr(MAX_MATCH)) 4179 4180 if len > best_len { 4181 (*Deflate_state)(unsafe.Pointer(s)).Fmatch_start = cur_match 4182 best_len = len 4183 if len >= nice_match { 4184 break 4185 } 4186 scan_end1 = *(*Bytef)(unsafe.Pointer(scan + uintptr((best_len - 1)))) 4187 scan_end = *(*Bytef)(unsafe.Pointer(scan + uintptr(best_len))) 4188 } 4189 } 4190 4191 if UInt(best_len) <= (*Deflate_state)(unsafe.Pointer(s)).Flookahead { 4192 return UInt(best_len) 4193 } 4194 return (*Deflate_state)(unsafe.Pointer(s)).Flookahead 4195 } 4196 4197 // =========================================================================== 4198 // Fill the window when the lookahead becomes insufficient. 4199 // Updates strstart and lookahead. 4200 // 4201 // IN assertion: lookahead < MIN_LOOKAHEAD 4202 // OUT assertions: strstart <= window_size-MIN_LOOKAHEAD 4203 // At least one byte has been read, or avail_in == 0; reads are 4204 // performed for at least two bytes (required for the zip translate_eol 4205 // option -- not supported here). 4206 func fill_window(tls *libc.TLS, s uintptr) { /* deflate.c:1482:12: */ 4207 var n uint32 4208 var more uint32 // Amount of free space at the end of the window. 4209 var wsize UInt = (*Deflate_state)(unsafe.Pointer(s)).Fw_size 4210 4211 for ok := true; ok; ok = (((*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))) { 4212 more = (uint32(((*Deflate_state)(unsafe.Pointer(s)).Fwindow_size - Ulg((*Deflate_state)(unsafe.Pointer(s)).Flookahead)) - Ulg((*Deflate_state)(unsafe.Pointer(s)).Fstrstart))) 4213 4214 // Deal with !@#$% 64K limit: 4215 if uint64(unsafe.Sizeof(int32(0))) <= uint64(2) { 4216 if ((more == uint32(0)) && ((*Deflate_state)(unsafe.Pointer(s)).Fstrstart == UInt(0))) && ((*Deflate_state)(unsafe.Pointer(s)).Flookahead == UInt(0)) { 4217 more = wsize 4218 4219 } else if more == libc.Uint32(libc.Uint32FromInt32(-1)) { 4220 // Very unlikely, but possible on 16 bit machine if 4221 // strstart == 0 && lookahead == 1 (input done a byte at time) 4222 more-- 4223 } 4224 } 4225 4226 // If the window is almost full and there is insufficient lookahead, 4227 // move the upper half to the lower one to make room in the upper half. 4228 if (*Deflate_state)(unsafe.Pointer(s)).Fstrstart >= (wsize + ((*Deflate_state)(unsafe.Pointer((s))).Fw_size - (UInt((MAX_MATCH + MIN_MATCH) + 1)))) { 4229 4230 libc.Xmemcpy(tls, (*Deflate_state)(unsafe.Pointer(s)).Fwindow, ((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(wsize)), (uint64(wsize - more))) 4231 *(*UInt)(unsafe.Pointer(s + 152 /* &.match_start */)) -= (wsize) 4232 *(*UInt)(unsafe.Pointer(s + 148 /* &.strstart */)) -= (wsize) // we now have strstart >= MAX_DIST 4233 *(*int32)(unsafe.Pointer(s + 132 /* &.block_start */)) -= (int32(wsize)) 4234 slide_hash(tls, s) 4235 more = more + (wsize) 4236 } 4237 if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_in == UInt(0) { 4238 break 4239 } 4240 4241 // If there was no sliding: 4242 // strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && 4243 // more == window_size - lookahead - strstart 4244 // => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) 4245 // => more >= window_size - 2*WSIZE + 2 4246 // In the BIG_MEM or MMAP case (not yet supported), 4247 // window_size == input_size + MIN_LOOKAHEAD && 4248 // strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD. 4249 // Otherwise, window_size == 2*WSIZE so more >= 2. 4250 // If there was sliding, more >= WSIZE. So in all cases, more >= 2. 4251 4252 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) 4253 *(*UInt)(unsafe.Pointer(s + 156 /* &.lookahead */)) += (n) 4254 4255 // Initialize the hash value now that we have some input: 4256 if ((*Deflate_state)(unsafe.Pointer(s)).Flookahead + (*Deflate_state)(unsafe.Pointer(s)).Finsert) >= UInt(MIN_MATCH) { 4257 var str UInt = ((*Deflate_state)(unsafe.Pointer(s)).Fstrstart - (*Deflate_state)(unsafe.Pointer(s)).Finsert) 4258 (*Deflate_state)(unsafe.Pointer(s)).Fins_h = UInt(*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(str)))) 4259 (*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) 4260 for (*Deflate_state)(unsafe.Pointer(s)).Finsert != 0 { 4261 (*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) 4262 *(*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)) 4263 *(*Posf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fhead + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fins_h)*2)) = Pos(str) 4264 str++ 4265 (*Deflate_state)(unsafe.Pointer(s)).Finsert-- 4266 if ((*Deflate_state)(unsafe.Pointer(s)).Flookahead + (*Deflate_state)(unsafe.Pointer(s)).Finsert) < UInt(MIN_MATCH) { 4267 break 4268 } 4269 } 4270 } 4271 // If the whole input has less than MIN_MATCH bytes, ins_h is garbage, 4272 // but this is not important since only literal bytes will be emitted. 4273 4274 } 4275 4276 // If the WIN_INIT bytes after the end of the current data have never been 4277 // written, then zero those bytes in order to avoid memory check reports of 4278 // the use of uninitialized (or uninitialised as Julian writes) bytes by 4279 // the longest match routines. Update the high water mark for the next 4280 // time through here. WIN_INIT is set to MAX_MATCH since the longest match 4281 // routines allow scanning to strstart + MAX_MATCH, ignoring lookahead. 4282 if (*Deflate_state)(unsafe.Pointer(s)).Fhigh_water < (*Deflate_state)(unsafe.Pointer(s)).Fwindow_size { 4283 var curr Ulg = (Ulg((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) + (Ulg((*Deflate_state)(unsafe.Pointer(s)).Flookahead))) 4284 var init1 Ulg 4285 4286 if (*Deflate_state)(unsafe.Pointer(s)).Fhigh_water < curr { 4287 // Previous high water mark below current data -- zero WIN_INIT 4288 // bytes or up to end of window, whichever is less. 4289 init1 = ((*Deflate_state)(unsafe.Pointer(s)).Fwindow_size - curr) 4290 if init1 > Ulg(MAX_MATCH) { 4291 init1 = Ulg(MAX_MATCH) 4292 } 4293 libc.Xmemset(tls, ((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(curr)), 0, uint64(uint32(init1))) 4294 (*Deflate_state)(unsafe.Pointer(s)).Fhigh_water = (curr + init1) 4295 } else if (*Deflate_state)(unsafe.Pointer(s)).Fhigh_water < (curr + Ulg(MAX_MATCH)) { 4296 // High water mark at or above current data, but below current data 4297 // plus WIN_INIT -- zero out to current data plus WIN_INIT, or up 4298 // to end of window, whichever is less. 4299 init1 = ((curr + Ulg(MAX_MATCH)) - (*Deflate_state)(unsafe.Pointer(s)).Fhigh_water) 4300 if init1 > ((*Deflate_state)(unsafe.Pointer(s)).Fwindow_size - (*Deflate_state)(unsafe.Pointer(s)).Fhigh_water) { 4301 init1 = ((*Deflate_state)(unsafe.Pointer(s)).Fwindow_size - (*Deflate_state)(unsafe.Pointer(s)).Fhigh_water) 4302 } 4303 libc.Xmemset(tls, ((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fhigh_water)), 0, uint64(uint32(init1))) 4304 *(*Ulg)(unsafe.Pointer(s + 5912 /* &.high_water */)) += (init1) 4305 } 4306 } 4307 4308 } 4309 4310 // =========================================================================== 4311 // Flush the current block, with given end-of-file flag. 4312 // IN assertion: strstart is set to the end of the current match. 4313 4314 // Same but force premature exit if necessary. 4315 4316 // Maximum stored block length in deflate format (not including header). 4317 4318 // Minimum of a and b. 4319 4320 // =========================================================================== 4321 // Copy without compression as much as possible from the input stream, return 4322 // the current block state. 4323 // 4324 // In case deflateParams() is used to later switch to a non-zero compression 4325 // level, s->matches (otherwise unused when storing) keeps track of the number 4326 // of hash table slides to perform. If s->matches is 1, then one hash table 4327 // slide will be done when switching. If s->matches is 2, the maximum value 4328 // allowed here, then the hash table will be cleared, since two or more slides 4329 // is the same as a clear. 4330 // 4331 // deflate_stored() is written to minimize the number of times an input byte is 4332 // copied. It is most efficient with large input and output buffers, which 4333 // maximizes the opportunites to have a single copy from next_in to next_out. 4334 func deflate_stored(tls *libc.TLS, s uintptr, flush int32) Block_state { /* deflate.c:1643:19: */ 4335 // Smallest worthy block size when not flushing or finishing. By default 4336 // this is 32K. This can be as small as 507 bytes for memLevel == 1. For 4337 // large input and output buffers, the stored block size will be larger. 4338 var min_block uint32 = func() uint32 { 4339 if ((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf_size - Ulg(5)) > (Ulg((*Deflate_state)(unsafe.Pointer(s)).Fw_size)) { 4340 return (*Deflate_state)(unsafe.Pointer(s)).Fw_size 4341 } 4342 return (uint32((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf_size - Ulg(5))) 4343 }() 4344 4345 // Copy as many min_block or larger stored blocks directly to next_out as 4346 // possible. If flushing, copy the remaining available input to next_out as 4347 // stored blocks, if there is enough space. 4348 var len uint32 4349 var left uint32 4350 var have uint32 4351 var last uint32 = uint32(0) 4352 var used uint32 = (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_in 4353 for ok := true; ok; ok = (last == uint32(0)) { 4354 // Set len to the maximum size block that we can copy directly with the 4355 // available input data and output space. Set left to how much of that 4356 // would be copied from what's left in the window. 4357 len = uint32(MAX_STORED) // maximum deflate stored block length 4358 have = (uint32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_valid + 42) >> 3)) // number of header bytes 4359 if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out < have { // need room for header 4360 break 4361 } 4362 // maximum stored block length that will fit in avail_out: 4363 have = ((*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out - have) 4364 left = (uint32(uint32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) - uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))) // bytes left in window 4365 if Ulg(len) > (Ulg(left) + Ulg((*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_in)) { 4366 len = (left + (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_in) 4367 } // limit len to the input 4368 if len > have { 4369 len = have 4370 } // limit len to the output 4371 4372 // If the stored block would be less than min_block in length, or if 4373 // unable to copy all of the available input when flushing, then try 4374 // copying to the window and the pending buffer instead. Also don't 4375 // write an empty block when flushing -- deflate() does that. 4376 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))) { 4377 break 4378 } 4379 4380 // Make a dummy stored block in pending to get the header bytes, 4381 // including any pending bits. This also updates the debugging counts. 4382 if (flush == Z_FINISH) && (len == (left + (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_in)) { 4383 last = uint32(1) 4384 } else { 4385 last = uint32(0) 4386 } 4387 X_tr_stored_block(tls, s, uintptr(0), uint32(0), int32(last)) 4388 4389 // Replace the lengths in the dummy stored block with len. 4390 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(((*Deflate_state)(unsafe.Pointer(s)).Fpending - Ulg(4))))) = Bytef(len) 4391 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(((*Deflate_state)(unsafe.Pointer(s)).Fpending - Ulg(3))))) = (Bytef(len >> 8)) 4392 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(((*Deflate_state)(unsafe.Pointer(s)).Fpending - Ulg(2))))) = Bytef(^len) 4393 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(((*Deflate_state)(unsafe.Pointer(s)).Fpending - Ulg(1))))) = (Bytef(^len >> 8)) 4394 4395 // Write the stored block header bytes. 4396 flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm) 4397 4398 // Copy uncompressed bytes from the window to next_out. 4399 if left != 0 { 4400 if left > len { 4401 left = len 4402 } 4403 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)) 4404 *(*uintptr)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm + 16 /* &.next_out */)) += (uintptr(left)) 4405 *(*UInt)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm + 24 /* &.avail_out */)) -= (left) 4406 *(*ULong)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm + 28 /* &.total_out */)) += (ULong(left)) 4407 *(*int32)(unsafe.Pointer(s + 132 /* &.block_start */)) += int32((uint32(left))) 4408 len = len - (left) 4409 } 4410 4411 // Copy uncompressed bytes directly from next_in to next_out, updating 4412 // the check value. 4413 if len != 0 { 4414 read_buf(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm, (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Fnext_out, len) 4415 *(*uintptr)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm + 16 /* &.next_out */)) += (uintptr(len)) 4416 *(*UInt)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm + 24 /* &.avail_out */)) -= (len) 4417 *(*ULong)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm + 28 /* &.total_out */)) += (ULong(len)) 4418 } 4419 } 4420 4421 // Update the sliding window with the last s->w_size bytes of the copied 4422 // data, or append all of the copied data to the existing window if less 4423 // than s->w_size bytes were copied. Also update the number of bytes to 4424 // insert in the hash tables, in the event that deflateParams() switches to 4425 // a non-zero compression level. 4426 used = used - ((*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_in) // number of input bytes directly copied 4427 if used != 0 { 4428 // If any input was used, then no unused input remains in the window, 4429 // therefore s->block_start == s->strstart. 4430 if used >= (*Deflate_state)(unsafe.Pointer(s)).Fw_size { // supplant the previous history 4431 (*Deflate_state)(unsafe.Pointer(s)).Fmatches = UInt(2) // clear hash 4432 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)) 4433 (*Deflate_state)(unsafe.Pointer(s)).Fstrstart = (*Deflate_state)(unsafe.Pointer(s)).Fw_size 4434 } else { 4435 if ((*Deflate_state)(unsafe.Pointer(s)).Fwindow_size - Ulg((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)) <= Ulg(used) { 4436 // Slide the window down. 4437 *(*UInt)(unsafe.Pointer(s + 148 /* &.strstart */)) -= ((*Deflate_state)(unsafe.Pointer(s)).Fw_size) 4438 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)) 4439 if (*Deflate_state)(unsafe.Pointer(s)).Fmatches < UInt(2) { 4440 (*Deflate_state)(unsafe.Pointer(s)).Fmatches++ 4441 } // add a pending slide_hash() 4442 } 4443 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)) 4444 *(*UInt)(unsafe.Pointer(s + 148 /* &.strstart */)) += (used) 4445 } 4446 (*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) 4447 *(*UInt)(unsafe.Pointer(s + 5900 /* &.insert */)) += (func() uint32 { 4448 if (used) > ((*Deflate_state)(unsafe.Pointer(s)).Fw_size - (*Deflate_state)(unsafe.Pointer(s)).Finsert) { 4449 return ((*Deflate_state)(unsafe.Pointer(s)).Fw_size - (*Deflate_state)(unsafe.Pointer(s)).Finsert) 4450 } 4451 return used 4452 }()) 4453 } 4454 if (*Deflate_state)(unsafe.Pointer(s)).Fhigh_water < Ulg((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) { 4455 (*Deflate_state)(unsafe.Pointer(s)).Fhigh_water = Ulg((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) 4456 } 4457 4458 // If the last block was written to next_out, then done. 4459 if last != 0 { 4460 return Finish_done 4461 } 4462 4463 // If flushing and all input has been consumed, then done. 4464 if (((flush != Z_NO_FLUSH) && (flush != Z_FINISH)) && ((*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_in == UInt(0))) && (int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) == (*Deflate_state)(unsafe.Pointer(s)).Fblock_start) { 4465 return Block_done 4466 } 4467 4468 // Fill the window with any remaining input. 4469 have = (uint32(((*Deflate_state)(unsafe.Pointer(s)).Fwindow_size - Ulg((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)) - Ulg(1))) 4470 if ((*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_in > have) && ((*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= int32((*Deflate_state)(unsafe.Pointer(s)).Fw_size)) { 4471 // Slide the window down. 4472 *(*int32)(unsafe.Pointer(s + 132 /* &.block_start */)) -= int32((uint32((*Deflate_state)(unsafe.Pointer(s)).Fw_size))) 4473 *(*UInt)(unsafe.Pointer(s + 148 /* &.strstart */)) -= ((*Deflate_state)(unsafe.Pointer(s)).Fw_size) 4474 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)) 4475 if (*Deflate_state)(unsafe.Pointer(s)).Fmatches < UInt(2) { 4476 (*Deflate_state)(unsafe.Pointer(s)).Fmatches++ 4477 } // add a pending slide_hash() 4478 have = have + ((*Deflate_state)(unsafe.Pointer(s)).Fw_size) // more space now 4479 } 4480 if have > (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_in { 4481 have = (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_in 4482 } 4483 if have != 0 { 4484 read_buf(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm, ((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)), have) 4485 *(*UInt)(unsafe.Pointer(s + 148 /* &.strstart */)) += (have) 4486 } 4487 if (*Deflate_state)(unsafe.Pointer(s)).Fhigh_water < Ulg((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) { 4488 (*Deflate_state)(unsafe.Pointer(s)).Fhigh_water = Ulg((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) 4489 } 4490 4491 // There was not enough avail_out to write a complete worthy or flushed 4492 // stored block to next_out. Write a stored block to pending instead, if we 4493 // have enough input for a worthy block, or if flushing and there is enough 4494 // room for the remaining input as a stored block in the pending buffer. 4495 have = (uint32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_valid + 42) >> 3)) // number of header bytes 4496 // maximum stored block length that will fit in pending: 4497 have = func() uint32 { 4498 if ((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf_size - Ulg(have)) > (Ulg(MAX_STORED)) { 4499 return uint32(MAX_STORED) 4500 } 4501 return (uint32((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf_size - Ulg(have))) 4502 }() 4503 min_block = func() uint32 { 4504 if (have) > ((*Deflate_state)(unsafe.Pointer(s)).Fw_size) { 4505 return (*Deflate_state)(unsafe.Pointer(s)).Fw_size 4506 } 4507 return have 4508 }() 4509 left = (uint32(uint32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) - uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))) 4510 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)) { 4511 len = func() uint32 { 4512 if (left) > (have) { 4513 return have 4514 } 4515 return left 4516 }() 4517 if ((flush == Z_FINISH) && ((*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_in == UInt(0))) && (len == left) { 4518 last = uint32(1) 4519 } else { 4520 last = uint32(0) 4521 } 4522 X_tr_stored_block(tls, s, ((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fblock_start)), uint32(len), int32(last)) 4523 *(*int32)(unsafe.Pointer(s + 132 /* &.block_start */)) += int32((uint32(len))) 4524 flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm) 4525 } 4526 4527 // We've done all we can with the available input and output. 4528 if last != 0 { 4529 return Finish_started 4530 } 4531 return Need_more 4532 } 4533 4534 // =========================================================================== 4535 // Compress as much as possible from the input stream, return the current 4536 // block state. 4537 // This function does not perform lazy evaluation of matches and inserts 4538 // new strings in the dictionary only for unmatched strings or for short 4539 // matches. It is used only for the fast compression options. 4540 func deflate_fast(tls *libc.TLS, s uintptr, flush int32) Block_state { /* deflate.c:1824:19: */ 4541 var hash_head IPos // head of the hash chain 4542 var bflush int32 // set if current block must be flushed 4543 4544 for { 4545 // Make sure that we always have enough lookahead, except 4546 // at the end of the input file. We need MAX_MATCH bytes 4547 // for the next match, plus MIN_MATCH bytes to insert the 4548 // string following the next match. 4549 if (*Deflate_state)(unsafe.Pointer(s)).Flookahead < (UInt((MAX_MATCH + MIN_MATCH) + 1)) { 4550 fill_window(tls, s) 4551 if ((*Deflate_state)(unsafe.Pointer(s)).Flookahead < (UInt((MAX_MATCH + MIN_MATCH) + 1))) && (flush == Z_NO_FLUSH) { 4552 return Need_more 4553 } 4554 if (*Deflate_state)(unsafe.Pointer(s)).Flookahead == UInt(0) { 4555 break 4556 } // flush the current block 4557 } 4558 4559 // Insert the string window[strstart .. strstart+2] in the 4560 // dictionary, and set hash_head to the head of the hash chain: 4561 hash_head = IPos(NIL) 4562 if (*Deflate_state)(unsafe.Pointer(s)).Flookahead >= UInt(MIN_MATCH) { 4563 (*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) 4564 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)))) 4565 *(*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) 4566 } 4567 4568 // Find the longest match, discarding those <= prev_length. 4569 // At this point we have always match_length < MIN_MATCH 4570 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)))) { 4571 // To simplify the code, we prevent matches with the string 4572 // of window index 0 (in particular we have to avoid a match 4573 // of the string with itself at the start of the input file). 4574 (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length = longest_match(tls, s, hash_head) 4575 // longest_match() sets match_start 4576 } 4577 if (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length >= UInt(MIN_MATCH) { 4578 4579 { 4580 var len Uch = (Uch((*Deflate_state)(unsafe.Pointer(s)).Fmatch_length - UInt(MIN_MATCH))) 4581 var dist Ush = (Ush((*Deflate_state)(unsafe.Pointer(s)).Fstrstart - (*Deflate_state)(unsafe.Pointer(s)).Fmatch_start)) 4582 *(*Ushf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fd_buf + uintptr((*Deflate_state)(unsafe.Pointer(s)).Flast_lit)*2)) = dist 4583 *(*Uchf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fl_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Flast_lit, 1)))) = len 4584 dist-- 4585 *(*Ush)(unsafe.Pointer((s + 188 /* &.dyn_ltree */) + uintptr(((int32(X_length_code[len])+LITERALS)+1))*4 /* &.fc */))++ 4586 *(*Ush)(unsafe.Pointer((s + 2480 /* &.dyn_dtree */) + uintptr((func() int32 { 4587 if (int32(dist)) < 256 { 4588 return int32(X_dist_code[dist]) 4589 } 4590 return int32(X_dist_code[(256 + ((int32(dist)) >> 7))]) 4591 }()))*4 /* &.fc */))++ 4592 bflush = (libc.Bool32((*Deflate_state)(unsafe.Pointer(s)).Flast_lit == ((*Deflate_state)(unsafe.Pointer(s)).Flit_bufsize - UInt(1)))) 4593 } 4594 4595 *(*UInt)(unsafe.Pointer(s + 156 /* &.lookahead */)) -= ((*Deflate_state)(unsafe.Pointer(s)).Fmatch_length) 4596 4597 // Insert new strings in the hash table only if the match length 4598 // is not too large. This saves time but degrades compression. 4599 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)) { 4600 (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length-- // string at strstart already in table 4601 for ok := true; ok; ok = (libc.PreDecUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fmatch_length, 1) != UInt(0)) { 4602 (*Deflate_state)(unsafe.Pointer(s)).Fstrstart++ 4603 (*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) 4604 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)))) 4605 *(*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) 4606 // strstart never exceeds WSIZE-MAX_MATCH, so there are 4607 // always MIN_MATCH bytes ahead. 4608 } 4609 (*Deflate_state)(unsafe.Pointer(s)).Fstrstart++ 4610 } else { 4611 *(*UInt)(unsafe.Pointer(s + 148 /* &.strstart */)) += ((*Deflate_state)(unsafe.Pointer(s)).Fmatch_length) 4612 (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length = UInt(0) 4613 (*Deflate_state)(unsafe.Pointer(s)).Fins_h = UInt(*(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)))) 4614 (*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) 4615 // If lookahead < MIN_MATCH, ins_h is garbage, but it does not 4616 // matter since it will be recomputed at next deflate call. 4617 } 4618 } else { 4619 // No match, output a literal byte 4620 4621 { 4622 var cc Uch = *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart))) 4623 *(*Ushf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fd_buf + uintptr((*Deflate_state)(unsafe.Pointer(s)).Flast_lit)*2)) = Ushf(0) 4624 *(*Uchf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fl_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Flast_lit, 1)))) = cc 4625 *(*Ush)(unsafe.Pointer((s + 188 /* &.dyn_ltree */) + uintptr(cc)*4 /* &.fc */))++ 4626 bflush = (libc.Bool32((*Deflate_state)(unsafe.Pointer(s)).Flast_lit == ((*Deflate_state)(unsafe.Pointer(s)).Flit_bufsize - UInt(1)))) 4627 } 4628 4629 (*Deflate_state)(unsafe.Pointer(s)).Flookahead-- 4630 (*Deflate_state)(unsafe.Pointer(s)).Fstrstart++ 4631 } 4632 if bflush != 0 { 4633 { 4634 X_tr_flush_block(tls, s, func() uintptr { 4635 if (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= 0 { 4636 return ((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))) 4637 } 4638 return uintptr(Z_NULL) 4639 }(), (Ulg(int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) - (*Deflate_state)(unsafe.Pointer(s)).Fblock_start)), 0) 4640 (*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) 4641 flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm) 4642 } 4643 if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out == UInt(0) { 4644 if 0 != 0 { 4645 return Finish_started 4646 } 4647 return Need_more 4648 } 4649 } 4650 4651 } 4652 (*Deflate_state)(unsafe.Pointer(s)).Finsert = func() uint32 { 4653 if (*Deflate_state)(unsafe.Pointer(s)).Fstrstart < (UInt(MIN_MATCH - 1)) { 4654 return (*Deflate_state)(unsafe.Pointer(s)).Fstrstart 4655 } 4656 return (uint32(MIN_MATCH - 1)) 4657 }() 4658 if flush == Z_FINISH { 4659 { 4660 { 4661 X_tr_flush_block(tls, s, func() uintptr { 4662 if (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= 0 { 4663 return ((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))) 4664 } 4665 return uintptr(Z_NULL) 4666 }(), (Ulg(int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) - (*Deflate_state)(unsafe.Pointer(s)).Fblock_start)), 1) 4667 (*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) 4668 flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm) 4669 } 4670 if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out == UInt(0) { 4671 if 1 != 0 { 4672 return Finish_started 4673 } 4674 return Need_more 4675 } 4676 } 4677 4678 return Finish_done 4679 } 4680 if (*Deflate_state)(unsafe.Pointer(s)).Flast_lit != 0 { 4681 { 4682 X_tr_flush_block(tls, s, func() uintptr { 4683 if (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= 0 { 4684 return ((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))) 4685 } 4686 return uintptr(Z_NULL) 4687 }(), (Ulg(int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) - (*Deflate_state)(unsafe.Pointer(s)).Fblock_start)), 0) 4688 (*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) 4689 flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm) 4690 } 4691 if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out == UInt(0) { 4692 if 0 != 0 { 4693 return Finish_started 4694 } 4695 return Need_more 4696 } 4697 } 4698 4699 return Block_done 4700 } 4701 4702 // =========================================================================== 4703 // Same as above, but achieves better compression. We use a lazy 4704 // evaluation for matches: a match is finally adopted only if there is 4705 // no better match at the next window position. 4706 func deflate_slow(tls *libc.TLS, s uintptr, flush int32) Block_state { /* deflate.c:1926:19: */ 4707 var hash_head IPos // head of hash chain 4708 var bflush int32 // set if current block must be flushed 4709 4710 // Process the input block. 4711 for { 4712 // Make sure that we always have enough lookahead, except 4713 // at the end of the input file. We need MAX_MATCH bytes 4714 // for the next match, plus MIN_MATCH bytes to insert the 4715 // string following the next match. 4716 if (*Deflate_state)(unsafe.Pointer(s)).Flookahead < (UInt((MAX_MATCH + MIN_MATCH) + 1)) { 4717 fill_window(tls, s) 4718 if ((*Deflate_state)(unsafe.Pointer(s)).Flookahead < (UInt((MAX_MATCH + MIN_MATCH) + 1))) && (flush == Z_NO_FLUSH) { 4719 return Need_more 4720 } 4721 if (*Deflate_state)(unsafe.Pointer(s)).Flookahead == UInt(0) { 4722 break 4723 } // flush the current block 4724 } 4725 4726 // Insert the string window[strstart .. strstart+2] in the 4727 // dictionary, and set hash_head to the head of the hash chain: 4728 hash_head = IPos(NIL) 4729 if (*Deflate_state)(unsafe.Pointer(s)).Flookahead >= UInt(MIN_MATCH) { 4730 (*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) 4731 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)))) 4732 *(*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) 4733 } 4734 4735 // Find the longest match, discarding those <= prev_length. 4736 (*Deflate_state)(unsafe.Pointer(s)).Fprev_length = (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length 4737 (*Deflate_state)(unsafe.Pointer(s)).Fprev_match = (*Deflate_state)(unsafe.Pointer(s)).Fmatch_start 4738 (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length = (UInt(MIN_MATCH - 1)) 4739 4740 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)))) { 4741 // To simplify the code, we prevent matches with the string 4742 // of window index 0 (in particular we have to avoid a match 4743 // of the string with itself at the start of the input file). 4744 (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length = longest_match(tls, s, hash_head) 4745 // longest_match() sets match_start 4746 4747 if ((*Deflate_state)(unsafe.Pointer(s)).Fmatch_length <= UInt(5)) && (((*Deflate_state)(unsafe.Pointer(s)).Fstrategy == Z_FILTERED) || 4748 (((*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)))) { 4749 4750 // If prev_match is also MIN_MATCH, match_start is garbage 4751 // but we will ignore the current match anyway. 4752 (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length = (UInt(MIN_MATCH - 1)) 4753 } 4754 } 4755 // If there was a match at the previous step and the current 4756 // match is not better, output the previous match: 4757 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) { 4758 var max_insert UInt = (((*Deflate_state)(unsafe.Pointer(s)).Fstrstart + (*Deflate_state)(unsafe.Pointer(s)).Flookahead) - UInt(MIN_MATCH)) 4759 // Do not insert strings in hash table beyond this. 4760 4761 { 4762 var len Uch = (Uch((*Deflate_state)(unsafe.Pointer(s)).Fprev_length - UInt(MIN_MATCH))) 4763 var dist Ush = (Ush(((*Deflate_state)(unsafe.Pointer(s)).Fstrstart - UInt(1)) - (*Deflate_state)(unsafe.Pointer(s)).Fprev_match)) 4764 *(*Ushf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fd_buf + uintptr((*Deflate_state)(unsafe.Pointer(s)).Flast_lit)*2)) = dist 4765 *(*Uchf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fl_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Flast_lit, 1)))) = len 4766 dist-- 4767 *(*Ush)(unsafe.Pointer((s + 188 /* &.dyn_ltree */) + uintptr(((int32(X_length_code[len])+LITERALS)+1))*4 /* &.fc */))++ 4768 *(*Ush)(unsafe.Pointer((s + 2480 /* &.dyn_dtree */) + uintptr((func() int32 { 4769 if (int32(dist)) < 256 { 4770 return int32(X_dist_code[dist]) 4771 } 4772 return int32(X_dist_code[(256 + ((int32(dist)) >> 7))]) 4773 }()))*4 /* &.fc */))++ 4774 bflush = (libc.Bool32((*Deflate_state)(unsafe.Pointer(s)).Flast_lit == ((*Deflate_state)(unsafe.Pointer(s)).Flit_bufsize - UInt(1)))) 4775 } 4776 4777 // Insert in hash table all strings up to the end of the match. 4778 // strstart-1 and strstart are already inserted. If there is not 4779 // enough lookahead, the last two strings are not inserted in 4780 // the hash table. 4781 *(*UInt)(unsafe.Pointer(s + 156 /* &.lookahead */)) -= ((*Deflate_state)(unsafe.Pointer(s)).Fprev_length - UInt(1)) 4782 *(*UInt)(unsafe.Pointer(s + 160 /* &.prev_length */)) -= (UInt(2)) 4783 for ok := true; ok; ok = (libc.PreDecUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fprev_length, 1) != UInt(0)) { 4784 if libc.PreIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fstrstart, 1) <= max_insert { 4785 (*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) 4786 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)))) 4787 *(*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) 4788 } 4789 } 4790 (*Deflate_state)(unsafe.Pointer(s)).Fmatch_available = 0 4791 (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length = (UInt(MIN_MATCH - 1)) 4792 (*Deflate_state)(unsafe.Pointer(s)).Fstrstart++ 4793 4794 if bflush != 0 { 4795 { 4796 X_tr_flush_block(tls, s, func() uintptr { 4797 if (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= 0 { 4798 return ((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))) 4799 } 4800 return uintptr(Z_NULL) 4801 }(), (Ulg(int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) - (*Deflate_state)(unsafe.Pointer(s)).Fblock_start)), 0) 4802 (*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) 4803 flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm) 4804 } 4805 if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out == UInt(0) { 4806 if 0 != 0 { 4807 return Finish_started 4808 } 4809 return Need_more 4810 } 4811 } 4812 4813 } else if (*Deflate_state)(unsafe.Pointer(s)).Fmatch_available != 0 { 4814 // If there was no match at the previous position, output a 4815 // single literal. If there was a match but the current match 4816 // is longer, truncate the previous match to a single literal. 4817 4818 { 4819 var cc Uch = *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(((*Deflate_state)(unsafe.Pointer(s)).Fstrstart - UInt(1))))) 4820 *(*Ushf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fd_buf + uintptr((*Deflate_state)(unsafe.Pointer(s)).Flast_lit)*2)) = Ushf(0) 4821 *(*Uchf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fl_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Flast_lit, 1)))) = cc 4822 *(*Ush)(unsafe.Pointer((s + 188 /* &.dyn_ltree */) + uintptr(cc)*4 /* &.fc */))++ 4823 bflush = (libc.Bool32((*Deflate_state)(unsafe.Pointer(s)).Flast_lit == ((*Deflate_state)(unsafe.Pointer(s)).Flit_bufsize - UInt(1)))) 4824 } 4825 4826 if bflush != 0 { 4827 { 4828 X_tr_flush_block(tls, s, func() uintptr { 4829 if (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= 0 { 4830 return ((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))) 4831 } 4832 return uintptr(Z_NULL) 4833 }(), (Ulg(int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) - (*Deflate_state)(unsafe.Pointer(s)).Fblock_start)), 0) 4834 (*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) 4835 flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm) 4836 } 4837 4838 } 4839 (*Deflate_state)(unsafe.Pointer(s)).Fstrstart++ 4840 (*Deflate_state)(unsafe.Pointer(s)).Flookahead-- 4841 if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out == UInt(0) { 4842 return Need_more 4843 } 4844 } else { 4845 // There is no previous match to compare with, wait for 4846 // the next step to decide. 4847 (*Deflate_state)(unsafe.Pointer(s)).Fmatch_available = 1 4848 (*Deflate_state)(unsafe.Pointer(s)).Fstrstart++ 4849 (*Deflate_state)(unsafe.Pointer(s)).Flookahead-- 4850 } 4851 } 4852 4853 if (*Deflate_state)(unsafe.Pointer(s)).Fmatch_available != 0 { 4854 4855 { 4856 var cc Uch = *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(((*Deflate_state)(unsafe.Pointer(s)).Fstrstart - UInt(1))))) 4857 *(*Ushf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fd_buf + uintptr((*Deflate_state)(unsafe.Pointer(s)).Flast_lit)*2)) = Ushf(0) 4858 *(*Uchf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fl_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Flast_lit, 1)))) = cc 4859 *(*Ush)(unsafe.Pointer((s + 188 /* &.dyn_ltree */) + uintptr(cc)*4 /* &.fc */))++ 4860 bflush = (libc.Bool32((*Deflate_state)(unsafe.Pointer(s)).Flast_lit == ((*Deflate_state)(unsafe.Pointer(s)).Flit_bufsize - UInt(1)))) 4861 } 4862 4863 (*Deflate_state)(unsafe.Pointer(s)).Fmatch_available = 0 4864 } 4865 (*Deflate_state)(unsafe.Pointer(s)).Finsert = func() uint32 { 4866 if (*Deflate_state)(unsafe.Pointer(s)).Fstrstart < (UInt(MIN_MATCH - 1)) { 4867 return (*Deflate_state)(unsafe.Pointer(s)).Fstrstart 4868 } 4869 return (uint32(MIN_MATCH - 1)) 4870 }() 4871 if flush == Z_FINISH { 4872 { 4873 { 4874 X_tr_flush_block(tls, s, func() uintptr { 4875 if (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= 0 { 4876 return ((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))) 4877 } 4878 return uintptr(Z_NULL) 4879 }(), (Ulg(int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) - (*Deflate_state)(unsafe.Pointer(s)).Fblock_start)), 1) 4880 (*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) 4881 flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm) 4882 } 4883 if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out == UInt(0) { 4884 if 1 != 0 { 4885 return Finish_started 4886 } 4887 return Need_more 4888 } 4889 } 4890 4891 return Finish_done 4892 } 4893 if (*Deflate_state)(unsafe.Pointer(s)).Flast_lit != 0 { 4894 { 4895 X_tr_flush_block(tls, s, func() uintptr { 4896 if (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= 0 { 4897 return ((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))) 4898 } 4899 return uintptr(Z_NULL) 4900 }(), (Ulg(int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) - (*Deflate_state)(unsafe.Pointer(s)).Fblock_start)), 0) 4901 (*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) 4902 flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm) 4903 } 4904 if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out == UInt(0) { 4905 if 0 != 0 { 4906 return Finish_started 4907 } 4908 return Need_more 4909 } 4910 } 4911 4912 return Block_done 4913 } 4914 4915 // =========================================================================== 4916 // For Z_RLE, simply look for runs of bytes, generate matches only of distance 4917 // one. Do not maintain a hash table. (It will be regenerated if this run of 4918 // deflate switches away from Z_RLE.) 4919 func deflate_rle(tls *libc.TLS, s uintptr, flush int32) Block_state { /* deflate.c:2057:19: */ 4920 var bflush int32 // set if current block must be flushed 4921 var prev UInt // byte at distance one to match 4922 var scan uintptr 4923 var strend uintptr // scan goes up to strend for length of run 4924 4925 for { 4926 // Make sure that we always have enough lookahead, except 4927 // at the end of the input file. We need MAX_MATCH bytes 4928 // for the longest run, plus one for the unrolled loop. 4929 if (*Deflate_state)(unsafe.Pointer(s)).Flookahead <= UInt(MAX_MATCH) { 4930 fill_window(tls, s) 4931 if ((*Deflate_state)(unsafe.Pointer(s)).Flookahead <= UInt(MAX_MATCH)) && (flush == Z_NO_FLUSH) { 4932 return Need_more 4933 } 4934 if (*Deflate_state)(unsafe.Pointer(s)).Flookahead == UInt(0) { 4935 break 4936 } // flush the current block 4937 } 4938 4939 // See how many times the previous byte repeats 4940 (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length = UInt(0) 4941 if ((*Deflate_state)(unsafe.Pointer(s)).Flookahead >= UInt(MIN_MATCH)) && ((*Deflate_state)(unsafe.Pointer(s)).Fstrstart > UInt(0)) { 4942 scan = (((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)) - uintptr(1)) 4943 prev = UInt(*(*Bytef)(unsafe.Pointer(scan))) 4944 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))))) { 4945 strend = (((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart)) + uintptr(MAX_MATCH)) 4946 for ok := true; ok; ok = (((((((((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)) { 4947 } 4948 (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length = (UInt(MAX_MATCH) - (UInt((int64(strend) - int64(scan)) / 1))) 4949 if (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length > (*Deflate_state)(unsafe.Pointer(s)).Flookahead { 4950 (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length = (*Deflate_state)(unsafe.Pointer(s)).Flookahead 4951 } 4952 } 4953 4954 } 4955 4956 // Emit match if have run of MIN_MATCH or longer, else emit literal 4957 if (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length >= UInt(MIN_MATCH) { 4958 4959 { 4960 var len Uch = (Uch((*Deflate_state)(unsafe.Pointer(s)).Fmatch_length - UInt(MIN_MATCH))) 4961 var dist Ush = Ush(1) 4962 *(*Ushf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fd_buf + uintptr((*Deflate_state)(unsafe.Pointer(s)).Flast_lit)*2)) = dist 4963 *(*Uchf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fl_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Flast_lit, 1)))) = len 4964 dist-- 4965 *(*Ush)(unsafe.Pointer((s + 188 /* &.dyn_ltree */) + uintptr(((int32(X_length_code[len])+LITERALS)+1))*4 /* &.fc */))++ 4966 *(*Ush)(unsafe.Pointer((s + 2480 /* &.dyn_dtree */) + uintptr((func() int32 { 4967 if (int32(dist)) < 256 { 4968 return int32(X_dist_code[dist]) 4969 } 4970 return int32(X_dist_code[(256 + ((int32(dist)) >> 7))]) 4971 }()))*4 /* &.fc */))++ 4972 bflush = (libc.Bool32((*Deflate_state)(unsafe.Pointer(s)).Flast_lit == ((*Deflate_state)(unsafe.Pointer(s)).Flit_bufsize - UInt(1)))) 4973 } 4974 4975 *(*UInt)(unsafe.Pointer(s + 156 /* &.lookahead */)) -= ((*Deflate_state)(unsafe.Pointer(s)).Fmatch_length) 4976 *(*UInt)(unsafe.Pointer(s + 148 /* &.strstart */)) += ((*Deflate_state)(unsafe.Pointer(s)).Fmatch_length) 4977 (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length = UInt(0) 4978 } else { 4979 // No match, output a literal byte 4980 4981 { 4982 var cc Uch = *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart))) 4983 *(*Ushf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fd_buf + uintptr((*Deflate_state)(unsafe.Pointer(s)).Flast_lit)*2)) = Ushf(0) 4984 *(*Uchf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fl_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Flast_lit, 1)))) = cc 4985 *(*Ush)(unsafe.Pointer((s + 188 /* &.dyn_ltree */) + uintptr(cc)*4 /* &.fc */))++ 4986 bflush = (libc.Bool32((*Deflate_state)(unsafe.Pointer(s)).Flast_lit == ((*Deflate_state)(unsafe.Pointer(s)).Flit_bufsize - UInt(1)))) 4987 } 4988 4989 (*Deflate_state)(unsafe.Pointer(s)).Flookahead-- 4990 (*Deflate_state)(unsafe.Pointer(s)).Fstrstart++ 4991 } 4992 if bflush != 0 { 4993 { 4994 X_tr_flush_block(tls, s, func() uintptr { 4995 if (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= 0 { 4996 return ((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))) 4997 } 4998 return uintptr(Z_NULL) 4999 }(), (Ulg(int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) - (*Deflate_state)(unsafe.Pointer(s)).Fblock_start)), 0) 5000 (*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) 5001 flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm) 5002 } 5003 if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out == UInt(0) { 5004 if 0 != 0 { 5005 return Finish_started 5006 } 5007 return Need_more 5008 } 5009 } 5010 5011 } 5012 (*Deflate_state)(unsafe.Pointer(s)).Finsert = UInt(0) 5013 if flush == Z_FINISH { 5014 { 5015 { 5016 X_tr_flush_block(tls, s, func() uintptr { 5017 if (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= 0 { 5018 return ((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))) 5019 } 5020 return uintptr(Z_NULL) 5021 }(), (Ulg(int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) - (*Deflate_state)(unsafe.Pointer(s)).Fblock_start)), 1) 5022 (*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) 5023 flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm) 5024 } 5025 if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out == UInt(0) { 5026 if 1 != 0 { 5027 return Finish_started 5028 } 5029 return Need_more 5030 } 5031 } 5032 5033 return Finish_done 5034 } 5035 if (*Deflate_state)(unsafe.Pointer(s)).Flast_lit != 0 { 5036 { 5037 X_tr_flush_block(tls, s, func() uintptr { 5038 if (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= 0 { 5039 return ((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))) 5040 } 5041 return uintptr(Z_NULL) 5042 }(), (Ulg(int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) - (*Deflate_state)(unsafe.Pointer(s)).Fblock_start)), 0) 5043 (*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) 5044 flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm) 5045 } 5046 if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out == UInt(0) { 5047 if 0 != 0 { 5048 return Finish_started 5049 } 5050 return Need_more 5051 } 5052 } 5053 5054 return Block_done 5055 } 5056 5057 // =========================================================================== 5058 // For Z_HUFFMAN_ONLY, do not look for matches. Do not maintain a hash table. 5059 // (It will be regenerated if this run of deflate switches away from Huffman.) 5060 func deflate_huff(tls *libc.TLS, s uintptr, flush int32) Block_state { /* deflate.c:2130:19: */ 5061 var bflush int32 // set if current block must be flushed 5062 5063 for { 5064 // Make sure that we have a literal to write. 5065 if (*Deflate_state)(unsafe.Pointer(s)).Flookahead == UInt(0) { 5066 fill_window(tls, s) 5067 if (*Deflate_state)(unsafe.Pointer(s)).Flookahead == UInt(0) { 5068 if flush == Z_NO_FLUSH { 5069 return Need_more 5070 } 5071 break // flush the current block 5072 } 5073 } 5074 5075 // Output a literal byte 5076 (*Deflate_state)(unsafe.Pointer(s)).Fmatch_length = UInt(0) 5077 5078 { 5079 var cc Uch = *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fstrstart))) 5080 *(*Ushf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fd_buf + uintptr((*Deflate_state)(unsafe.Pointer(s)).Flast_lit)*2)) = Ushf(0) 5081 *(*Uchf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fl_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Flast_lit, 1)))) = cc 5082 *(*Ush)(unsafe.Pointer((s + 188 /* &.dyn_ltree */) + uintptr(cc)*4 /* &.fc */))++ 5083 bflush = (libc.Bool32((*Deflate_state)(unsafe.Pointer(s)).Flast_lit == ((*Deflate_state)(unsafe.Pointer(s)).Flit_bufsize - UInt(1)))) 5084 } 5085 5086 (*Deflate_state)(unsafe.Pointer(s)).Flookahead-- 5087 (*Deflate_state)(unsafe.Pointer(s)).Fstrstart++ 5088 if bflush != 0 { 5089 { 5090 X_tr_flush_block(tls, s, func() uintptr { 5091 if (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= 0 { 5092 return ((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))) 5093 } 5094 return uintptr(Z_NULL) 5095 }(), (Ulg(int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) - (*Deflate_state)(unsafe.Pointer(s)).Fblock_start)), 0) 5096 (*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) 5097 flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm) 5098 } 5099 if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out == UInt(0) { 5100 if 0 != 0 { 5101 return Finish_started 5102 } 5103 return Need_more 5104 } 5105 } 5106 5107 } 5108 (*Deflate_state)(unsafe.Pointer(s)).Finsert = UInt(0) 5109 if flush == Z_FINISH { 5110 { 5111 { 5112 X_tr_flush_block(tls, s, func() uintptr { 5113 if (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= 0 { 5114 return ((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))) 5115 } 5116 return uintptr(Z_NULL) 5117 }(), (Ulg(int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) - (*Deflate_state)(unsafe.Pointer(s)).Fblock_start)), 1) 5118 (*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) 5119 flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm) 5120 } 5121 if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out == UInt(0) { 5122 if 1 != 0 { 5123 return Finish_started 5124 } 5125 return Need_more 5126 } 5127 } 5128 5129 return Finish_done 5130 } 5131 if (*Deflate_state)(unsafe.Pointer(s)).Flast_lit != 0 { 5132 { 5133 X_tr_flush_block(tls, s, func() uintptr { 5134 if (*Deflate_state)(unsafe.Pointer(s)).Fblock_start >= 0 { 5135 return ((*Deflate_state)(unsafe.Pointer(s)).Fwindow + uintptr(uint32((*Deflate_state)(unsafe.Pointer(s)).Fblock_start))) 5136 } 5137 return uintptr(Z_NULL) 5138 }(), (Ulg(int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) - (*Deflate_state)(unsafe.Pointer(s)).Fblock_start)), 0) 5139 (*Deflate_state)(unsafe.Pointer(s)).Fblock_start = int32((*Deflate_state)(unsafe.Pointer(s)).Fstrstart) 5140 flush_pending(tls, (*Deflate_state)(unsafe.Pointer(s)).Fstrm) 5141 } 5142 if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Favail_out == UInt(0) { 5143 if 0 != 0 { 5144 return Finish_started 5145 } 5146 return Need_more 5147 } 5148 } 5149 5150 return Block_done 5151 } 5152 5153 // * 5154 // This file has no copyright assigned and is placed in the Public Domain. 5155 // This file is part of the mingw-w64 runtime package. 5156 // No warranty is given; refer to the file DISCLAIMER.PD within this package. 5157 5158 // Undefine __mingw_<printf> macros. 5159 5160 type X_iobuf = struct { 5161 F_ptr uintptr 5162 F_cnt int32 5163 F__ccgo_pad1 [4]byte 5164 F_base uintptr 5165 F_flag int32 5166 F_file int32 5167 F_charbuf int32 5168 F_bufsiz int32 5169 F_tmpfname uintptr 5170 } /* stdio.h:26:3 */ 5171 5172 type FILE = X_iobuf /* stdio.h:36:25 */ 5173 5174 type Fpos_t = int64 /* stdio.h:104:37 */ 5175 5176 func vsnprintf(tls *libc.TLS, __stream uintptr, __n Size_t, __format uintptr, __local_argv Va_list) int32 { /* stdio.h:775:7: */ 5177 return libc.X__ms_vsnprintf(tls, __stream, __n, __format, __local_argv) 5178 5179 } 5180 5181 func snprintf(tls *libc.TLS, __stream uintptr, __n Size_t, __format uintptr, va uintptr) int32 { /* stdio.h:786:5: */ 5182 var __retval int32 5183 var __local_argv X__builtin_va_list 5184 __local_argv = va 5185 __retval = libc.X__ms_vsnprintf(tls, __stream, __n, __format, __local_argv) 5186 _ = __local_argv 5187 return __retval 5188 } 5189 5190 func vsnwprintf(tls *libc.TLS, s uintptr, n Size_t, format uintptr, arg Va_list) int32 { /* stdio.h:1209:15: */ 5191 return libc.X_vsnwprintf(tls, s, n, format, arg) 5192 5193 } 5194 5195 // * 5196 // This file has no copyright assigned and is placed in the Public Domain. 5197 // This file is part of the mingw-w64 runtime package. 5198 // No warranty is given; refer to the file DISCLAIMER.PD within this package. 5199 5200 // * 5201 // This file has no copyright assigned and is placed in the Public Domain. 5202 // This file is part of the mingw-w64 runtime package. 5203 // No warranty is given; refer to the file DISCLAIMER.PD within this package. 5204 5205 func vswprintf(tls *libc.TLS, __stream uintptr, __count Size_t, __format uintptr, __local_argv X__builtin_va_list) int32 { /* swprintf.inl:27:5: */ 5206 return vsnwprintf(tls, __stream, __count, __format, __local_argv) 5207 } 5208 5209 type X_fsize_t = uint32 /* io.h:29:25 */ 5210 5211 type X_finddata32_t = struct { 5212 Fattrib uint32 5213 Ftime_create X__time32_t 5214 Ftime_access X__time32_t 5215 Ftime_write X__time32_t 5216 Fsize X_fsize_t 5217 Fname [260]int8 5218 } /* io.h:35:3 */ 5219 5220 type X_finddata32i64_t = struct { 5221 Fattrib uint32 5222 Ftime_create X__time32_t 5223 Ftime_access X__time32_t 5224 Ftime_write X__time32_t 5225 Fsize int64 5226 Fname [260]int8 5227 F__ccgo_pad1 [4]byte 5228 } /* io.h:44:3 */ 5229 5230 type X_finddata64i32_t = struct { 5231 Fattrib uint32 5232 F__ccgo_pad1 [4]byte 5233 Ftime_create X__time64_t 5234 Ftime_access X__time64_t 5235 Ftime_write X__time64_t 5236 Fsize X_fsize_t 5237 Fname [260]int8 5238 } /* io.h:53:3 */ 5239 5240 type X__finddata64_t = struct { 5241 Fattrib uint32 5242 F__ccgo_pad1 [4]byte 5243 Ftime_create X__time64_t 5244 Ftime_access X__time64_t 5245 Ftime_write X__time64_t 5246 Fsize int64 5247 Fname [260]int8 5248 F__ccgo_pad2 [4]byte 5249 } /* io.h:62:3 */ 5250 5251 type X_wfinddata32_t = struct { 5252 Fattrib uint32 5253 Ftime_create X__time32_t 5254 Ftime_access X__time32_t 5255 Ftime_write X__time32_t 5256 Fsize X_fsize_t 5257 Fname [260]Wchar_t 5258 } /* io.h:94:3 */ 5259 5260 type X_wfinddata32i64_t = struct { 5261 Fattrib uint32 5262 Ftime_create X__time32_t 5263 Ftime_access X__time32_t 5264 Ftime_write X__time32_t 5265 Fsize int64 5266 Fname [260]Wchar_t 5267 } /* io.h:103:3 */ 5268 5269 type X_wfinddata64i32_t = struct { 5270 Fattrib uint32 5271 F__ccgo_pad1 [4]byte 5272 Ftime_create X__time64_t 5273 Ftime_access X__time64_t 5274 Ftime_write X__time64_t 5275 Fsize X_fsize_t 5276 Fname [260]Wchar_t 5277 F__ccgo_pad2 [4]byte 5278 } /* io.h:112:3 */ 5279 5280 type X_wfinddata64_t = struct { 5281 Fattrib uint32 5282 F__ccgo_pad1 [4]byte 5283 Ftime_create X__time64_t 5284 Ftime_access X__time64_t 5285 Ftime_write X__time64_t 5286 Fsize int64 5287 Fname [260]Wchar_t 5288 } /* io.h:121:3 */ 5289 5290 // default memLevel 5291 5292 // default i/o buffer size -- double this for output when reading (this and 5293 // twice this must be able to fit in an unsigned type) 5294 5295 // gzip modes, also provide a little integrity check on the passed structure 5296 5297 // values for gz_state how 5298 5299 // internal gzip file state data structure 5300 type Gz_state = struct { 5301 Fx GzFile_s 5302 Fmode int32 5303 Ffd int32 5304 Fpath uintptr 5305 Fsize uint32 5306 Fwant uint32 5307 Fin uintptr 5308 Fout uintptr 5309 Fdirect int32 5310 Fhow int32 5311 Fstart int32 5312 Feof int32 5313 Fpast int32 5314 Flevel int32 5315 Fstrategy int32 5316 Fskip int32 5317 Fseek int32 5318 Ferr int32 5319 Fmsg uintptr 5320 Fstrm Z_stream 5321 } /* gzguts.h:201:3 */ 5322 type Gz_statep = uintptr /* gzguts.h:202:22 */ 5323 5324 // GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t 5325 // value -- needed when comparing unsigned to z_off64_t, which is signed 5326 // (possible z_off64_t types off_t, off64_t, and long are all signed) 5327 5328 // gzclose() is in a separate file so that it is linked in only if it is used. 5329 // That way the other gzclose functions can be used instead to avoid linking in 5330 // unneeded compression or decompression routines. 5331 func Xgzclose(tls *libc.TLS, file GzFile) int32 { /* gzclose.c:11:13: */ 5332 var state Gz_statep 5333 5334 if file == (uintptr(0)) { 5335 return -2 5336 } 5337 state = file 5338 5339 if (*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_READ { 5340 return Xgzclose_r(tls, file) 5341 } 5342 return Xgzclose_w(tls, file) 5343 } 5344 5345 // Reset gzip file state 5346 func gz_reset(tls *libc.TLS, state Gz_statep) { /* gzlib.c:75:12: */ 5347 (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave = uint32(0) // no output data available 5348 if (*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_READ { // for reading ... 5349 (*Gz_state)(unsafe.Pointer(state)).Feof = 0 // not at end of file 5350 (*Gz_state)(unsafe.Pointer(state)).Fpast = 0 // have not read past end yet 5351 (*Gz_state)(unsafe.Pointer(state)).Fhow = LOOK // look for gzip header 5352 } 5353 (*Gz_state)(unsafe.Pointer(state)).Fseek = 0 // no seek request pending 5354 Xgz_error(tls, state, Z_OK, uintptr(0)) // clear error 5355 (*Gz_state)(unsafe.Pointer(state)).Fx.Fpos = 0 // no uncompressed data yet 5356 (*Gz_state)(unsafe.Pointer(state)).Fstrm.Favail_in = UInt(0) // no input data yet 5357 } 5358 5359 // Open a gzip file either by name or file descriptor. 5360 func gz_open(tls *libc.TLS, path uintptr, fd int32, mode uintptr) GzFile { /* gzlib.c:91:14: */ 5361 bp := tls.Alloc(24) 5362 defer tls.Free(24) 5363 5364 var state Gz_statep 5365 var len Z_size_t 5366 var oflag int32 5367 var exclusive int32 = 0 5368 5369 // check input 5370 if path == (uintptr(0)) { 5371 return uintptr(0) 5372 } 5373 5374 // allocate gzFile structure to return 5375 state = libc.Xmalloc(tls, uint64(unsafe.Sizeof(Gz_state{}))) 5376 if state == (uintptr(0)) { 5377 return uintptr(0) 5378 } 5379 (*Gz_state)(unsafe.Pointer(state)).Fsize = uint32(0) // no buffers allocated yet 5380 (*Gz_state)(unsafe.Pointer(state)).Fwant = uint32(GZBUFSIZE) // requested buffer size 5381 (*Gz_state)(unsafe.Pointer(state)).Fmsg = uintptr(0) // no error message yet 5382 5383 // interpret mode 5384 (*Gz_state)(unsafe.Pointer(state)).Fmode = GZ_NONE 5385 (*Gz_state)(unsafe.Pointer(state)).Flevel = -1 5386 (*Gz_state)(unsafe.Pointer(state)).Fstrategy = Z_DEFAULT_STRATEGY 5387 (*Gz_state)(unsafe.Pointer(state)).Fdirect = 0 5388 for *(*int8)(unsafe.Pointer(mode)) != 0 { 5389 if (int32(*(*int8)(unsafe.Pointer(mode))) >= '0') && (int32(*(*int8)(unsafe.Pointer(mode))) <= '9') { 5390 (*Gz_state)(unsafe.Pointer(state)).Flevel = (int32(*(*int8)(unsafe.Pointer(mode))) - '0') 5391 } else { 5392 switch int32(*(*int8)(unsafe.Pointer(mode))) { 5393 case 'r': 5394 (*Gz_state)(unsafe.Pointer(state)).Fmode = GZ_READ 5395 break 5396 fallthrough 5397 case 'w': 5398 (*Gz_state)(unsafe.Pointer(state)).Fmode = GZ_WRITE 5399 break 5400 fallthrough 5401 case 'a': 5402 (*Gz_state)(unsafe.Pointer(state)).Fmode = GZ_APPEND 5403 break 5404 fallthrough 5405 case '+': // can't read and write at the same time 5406 libc.Xfree(tls, state) 5407 return uintptr(0) 5408 fallthrough 5409 case 'b': // ignore -- will request binary anyway 5410 break 5411 fallthrough 5412 case 'x': 5413 exclusive = 1 5414 break 5415 fallthrough 5416 case 'f': 5417 (*Gz_state)(unsafe.Pointer(state)).Fstrategy = Z_FILTERED 5418 break 5419 fallthrough 5420 case 'h': 5421 (*Gz_state)(unsafe.Pointer(state)).Fstrategy = Z_HUFFMAN_ONLY 5422 break 5423 fallthrough 5424 case 'R': 5425 (*Gz_state)(unsafe.Pointer(state)).Fstrategy = Z_RLE 5426 break 5427 fallthrough 5428 case 'F': 5429 (*Gz_state)(unsafe.Pointer(state)).Fstrategy = Z_FIXED 5430 break 5431 fallthrough 5432 case 'T': 5433 (*Gz_state)(unsafe.Pointer(state)).Fdirect = 1 5434 break 5435 fallthrough 5436 default: // could consider as an error, but just ignore 5437 5438 } 5439 } 5440 mode++ 5441 } 5442 5443 // must provide an "r", "w", or "a" 5444 if (*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_NONE { 5445 libc.Xfree(tls, state) 5446 return uintptr(0) 5447 } 5448 5449 // can't force transparent read 5450 if (*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_READ { 5451 if (*Gz_state)(unsafe.Pointer(state)).Fdirect != 0 { 5452 libc.Xfree(tls, state) 5453 return uintptr(0) 5454 } 5455 (*Gz_state)(unsafe.Pointer(state)).Fdirect = 1 // for empty file 5456 } 5457 5458 // save the path name for error messages 5459 if fd == -2 { 5460 len = libc.Xwcstombs(tls, uintptr(0), path, uint64(0)) 5461 if len == libc.Uint64(libc.Uint64FromInt32(-1)) { 5462 len = uint64(0) 5463 } 5464 } else { 5465 len = libc.Xstrlen(tls, path) 5466 } 5467 (*Gz_state)(unsafe.Pointer(state)).Fpath = libc.Xmalloc(tls, (len + uint64(1))) 5468 if (*Gz_state)(unsafe.Pointer(state)).Fpath == (uintptr(0)) { 5469 libc.Xfree(tls, state) 5470 return uintptr(0) 5471 } 5472 if fd == -2 { 5473 if len != 0 { 5474 libc.Xwcstombs(tls, (*Gz_state)(unsafe.Pointer(state)).Fpath, path, (len + uint64(1))) 5475 } else { 5476 *(*int8)(unsafe.Pointer((*Gz_state)(unsafe.Pointer(state)).Fpath)) = int8(0) 5477 } 5478 } else { 5479 snprintf(tls, (*Gz_state)(unsafe.Pointer(state)).Fpath, (len + uint64(1)), ts+76 /* "%s" */, libc.VaList(bp, path)) 5480 } 5481 5482 // compute the flags for open() 5483 oflag = (X_O_BINARY | (func() int32 { 5484 if (*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_READ { 5485 return X_O_RDONLY 5486 } 5487 return (((X_O_WRONLY | X_O_CREAT) | (func() int32 { 5488 if exclusive != 0 { 5489 return X_O_EXCL 5490 } 5491 return 0 5492 }())) | (func() int32 { 5493 if (*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_WRITE { 5494 return X_O_TRUNC 5495 } 5496 return X_O_APPEND 5497 }())) 5498 }())) 5499 5500 // open the file with the appropriate flags (or just use fd) 5501 (*Gz_state)(unsafe.Pointer(state)).Ffd = func() int32 { 5502 if fd > -1 { 5503 return fd 5504 } 5505 return func() int32 { 5506 if fd == -2 { 5507 return libc.X_wopen(tls, path, oflag, libc.VaList(bp+16, 0666)) 5508 } 5509 return libc.Xopen(tls, path, oflag, libc.VaList(bp+8, 0666)) 5510 }() 5511 }() 5512 if (*Gz_state)(unsafe.Pointer(state)).Ffd == -1 { 5513 libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fpath) 5514 libc.Xfree(tls, state) 5515 return uintptr(0) 5516 } 5517 if (*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_APPEND { 5518 libc.Xlseek64(tls, (*Gz_state)(unsafe.Pointer(state)).Ffd, int64(0), SEEK_END) // so gzoffset() is correct 5519 (*Gz_state)(unsafe.Pointer(state)).Fmode = GZ_WRITE // simplify later checks 5520 } 5521 5522 // save the current position for rewinding (only if reading) 5523 if (*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_READ { 5524 (*Gz_state)(unsafe.Pointer(state)).Fstart = int32(libc.Xlseek64(tls, (*Gz_state)(unsafe.Pointer(state)).Ffd, int64(0), SEEK_CUR)) 5525 if (*Gz_state)(unsafe.Pointer(state)).Fstart == -1 { 5526 (*Gz_state)(unsafe.Pointer(state)).Fstart = 0 5527 } 5528 } 5529 5530 // initialize stream 5531 gz_reset(tls, state) 5532 5533 // return stream 5534 return state 5535 } 5536 5537 // -- see zlib.h -- 5538 func Xgzopen(tls *libc.TLS, path uintptr, mode uintptr) GzFile { /* gzlib.c:270:16: */ 5539 return gz_open(tls, path, -1, mode) 5540 } 5541 5542 // -- see zlib.h -- 5543 func Xgzopen64(tls *libc.TLS, path uintptr, mode uintptr) GzFile { /* gzlib.c:278:16: */ 5544 return gz_open(tls, path, -1, mode) 5545 } 5546 5547 // -- see zlib.h -- 5548 func Xgzdopen(tls *libc.TLS, fd int32, mode uintptr) GzFile { /* gzlib.c:286:16: */ 5549 bp := tls.Alloc(8) 5550 defer tls.Free(8) 5551 5552 var path uintptr // identifier for error messages 5553 var gz GzFile 5554 5555 if (fd == -1) || ((libc.AssignUintptr(&path, libc.Xmalloc(tls, (uint64(7)+(uint64(3)*uint64(unsafe.Sizeof(int32(0)))))))) == (uintptr(0))) { 5556 return uintptr(0) 5557 } 5558 snprintf(tls, path, (uint64(7) + (uint64(3) * uint64(unsafe.Sizeof(int32(0))))), ts+79 /* "<fd:%d>" */, libc.VaList(bp, fd)) 5559 gz = gz_open(tls, path, fd, mode) 5560 libc.Xfree(tls, path) 5561 return gz 5562 } 5563 5564 // -- see zlib.h -- 5565 func Xgzopen_w(tls *libc.TLS, path uintptr, mode uintptr) GzFile { /* gzlib.c:307:16: */ 5566 return gz_open(tls, path, -2, mode) 5567 } 5568 5569 // -- see zlib.h -- 5570 func Xgzbuffer(tls *libc.TLS, file GzFile, size uint32) int32 { /* gzlib.c:316:13: */ 5571 var state Gz_statep 5572 5573 // get internal structure and check integrity 5574 if file == (uintptr(0)) { 5575 return -1 5576 } 5577 state = file 5578 if ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ) && ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE) { 5579 return -1 5580 } 5581 5582 // make sure we haven't already allocated memory 5583 if (*Gz_state)(unsafe.Pointer(state)).Fsize != uint32(0) { 5584 return -1 5585 } 5586 5587 // check and set requested size 5588 if (size << 1) < size { 5589 return -1 5590 } // need to be able to double it 5591 if size < uint32(2) { 5592 size = uint32(2) 5593 } // need two bytes to check magic header 5594 (*Gz_state)(unsafe.Pointer(state)).Fwant = size 5595 return 0 5596 } 5597 5598 // -- see zlib.h -- 5599 func Xgzrewind(tls *libc.TLS, file GzFile) int32 { /* gzlib.c:343:13: */ 5600 var state Gz_statep 5601 5602 // get internal structure 5603 if file == (uintptr(0)) { 5604 return -1 5605 } 5606 state = file 5607 5608 // check that we're reading and that there's no error 5609 if ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ) || (((*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK) && ((*Gz_state)(unsafe.Pointer(state)).Ferr != (-5))) { 5610 return -1 5611 } 5612 5613 // back up and start over 5614 if libc.Xlseek64(tls, (*Gz_state)(unsafe.Pointer(state)).Ffd, int64((*Gz_state)(unsafe.Pointer(state)).Fstart), SEEK_SET) == int64(-1) { 5615 return -1 5616 } 5617 gz_reset(tls, state) 5618 return 0 5619 } 5620 5621 // -- see zlib.h -- 5622 func Xgzseek64(tls *libc.TLS, file GzFile, offset int32, whence int32) int32 { /* gzlib.c:366:19: */ 5623 var n uint32 5624 var ret int32 5625 var state Gz_statep 5626 5627 // get internal structure and check integrity 5628 if file == (uintptr(0)) { 5629 return -1 5630 } 5631 state = file 5632 if ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ) && ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE) { 5633 return -1 5634 } 5635 5636 // check that there's no error 5637 if ((*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK) && ((*Gz_state)(unsafe.Pointer(state)).Ferr != (-5)) { 5638 return -1 5639 } 5640 5641 // can only seek from start or relative to current position 5642 if (whence != SEEK_SET) && (whence != SEEK_CUR) { 5643 return -1 5644 } 5645 5646 // normalize offset to a SEEK_CUR specification 5647 if whence == SEEK_SET { 5648 offset = offset - ((*Gz_state)(unsafe.Pointer(state)).Fx.Fpos) 5649 } else if (*Gz_state)(unsafe.Pointer(state)).Fseek != 0 { 5650 offset = offset + ((*Gz_state)(unsafe.Pointer(state)).Fskip) 5651 } 5652 (*Gz_state)(unsafe.Pointer(state)).Fseek = 0 5653 5654 // if within raw area while reading, just go there 5655 if (((*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_READ) && ((*Gz_state)(unsafe.Pointer(state)).Fhow == COPY1)) && (((*Gz_state)(unsafe.Pointer(state)).Fx.Fpos + offset) >= 0) { 5656 ret = int32(libc.Xlseek64(tls, (*Gz_state)(unsafe.Pointer(state)).Ffd, (int64(uint32(offset) - uint32((*Gz_state)(unsafe.Pointer(state)).Fx.Fhave))), SEEK_CUR)) 5657 if ret == -1 { 5658 return -1 5659 } 5660 (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave = uint32(0) 5661 (*Gz_state)(unsafe.Pointer(state)).Feof = 0 5662 (*Gz_state)(unsafe.Pointer(state)).Fpast = 0 5663 (*Gz_state)(unsafe.Pointer(state)).Fseek = 0 5664 Xgz_error(tls, state, Z_OK, uintptr(0)) 5665 (*Gz_state)(unsafe.Pointer(state)).Fstrm.Favail_in = UInt(0) 5666 *(*int32)(unsafe.Pointer(state /* &.x */ + 16 /* &.pos */)) += (offset) 5667 return (*Gz_state)(unsafe.Pointer(state)).Fx.Fpos 5668 } 5669 5670 // calculate skip amount, rewinding if needed for back seek when reading 5671 if offset < 0 { 5672 if (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ { // writing -- can't go backwards 5673 return -1 5674 } 5675 offset = offset + ((*Gz_state)(unsafe.Pointer(state)).Fx.Fpos) 5676 if offset < 0 { // before start of file! 5677 return -1 5678 } 5679 if Xgzrewind(tls, file) == -1 { // rewind, then skip to offset 5680 return -1 5681 } 5682 } 5683 5684 // if reading, skip what's in output buffer (one less gzgetc() check) 5685 if (*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_READ { 5686 if ((uint64(unsafe.Sizeof(int32(0))) == uint64(unsafe.Sizeof(int32(0)))) && (((*Gz_state)(unsafe.Pointer(state)).Fx.Fhave) > uint32(0x7fffffff))) || (int32((*Gz_state)(unsafe.Pointer(state)).Fx.Fhave) > offset) { 5687 n = uint32(offset) 5688 } else { 5689 n = (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave 5690 } 5691 *(*uint32)(unsafe.Pointer(state /* &.x */ /* &.have */)) -= (n) 5692 *(*uintptr)(unsafe.Pointer(state /* &.x */ + 8 /* &.next */)) += (uintptr(n)) 5693 *(*int32)(unsafe.Pointer(state /* &.x */ + 16 /* &.pos */)) += int32((uint32(n))) 5694 offset = int32(uint32(offset) - (uint32(n))) 5695 } 5696 5697 // request skip (if not zero) 5698 if offset != 0 { 5699 (*Gz_state)(unsafe.Pointer(state)).Fseek = 1 5700 (*Gz_state)(unsafe.Pointer(state)).Fskip = offset 5701 } 5702 return ((*Gz_state)(unsafe.Pointer(state)).Fx.Fpos + offset) 5703 } 5704 5705 // -- see zlib.h -- 5706 func Xgzseek(tls *libc.TLS, file GzFile, offset int32, whence int32) int32 { /* gzlib.c:443:17: */ 5707 var ret int32 5708 5709 ret = Xgzseek64(tls, file, offset, whence) 5710 if ret == ret { 5711 return ret 5712 } 5713 return -1 5714 } 5715 5716 // -- see zlib.h -- 5717 func Xgztell64(tls *libc.TLS, file GzFile) int32 { /* gzlib.c:455:19: */ 5718 var state Gz_statep 5719 5720 // get internal structure and check integrity 5721 if file == (uintptr(0)) { 5722 return -1 5723 } 5724 state = file 5725 if ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ) && ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE) { 5726 return -1 5727 } 5728 5729 // return position 5730 return ((*Gz_state)(unsafe.Pointer(state)).Fx.Fpos + (func() int32 { 5731 if (*Gz_state)(unsafe.Pointer(state)).Fseek != 0 { 5732 return (*Gz_state)(unsafe.Pointer(state)).Fskip 5733 } 5734 return 0 5735 }())) 5736 } 5737 5738 // -- see zlib.h -- 5739 func Xgztell(tls *libc.TLS, file GzFile) int32 { /* gzlib.c:472:17: */ 5740 var ret int32 5741 5742 ret = Xgztell64(tls, file) 5743 if ret == ret { 5744 return ret 5745 } 5746 return -1 5747 } 5748 5749 // -- see zlib.h -- 5750 func Xgzoffset64(tls *libc.TLS, file GzFile) int32 { /* gzlib.c:482:19: */ 5751 var offset int32 5752 var state Gz_statep 5753 5754 // get internal structure and check integrity 5755 if file == (uintptr(0)) { 5756 return -1 5757 } 5758 state = file 5759 if ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ) && ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE) { 5760 return -1 5761 } 5762 5763 // compute and return effective offset in file 5764 offset = int32(libc.Xlseek64(tls, (*Gz_state)(unsafe.Pointer(state)).Ffd, int64(0), SEEK_CUR)) 5765 if offset == -1 { 5766 return -1 5767 } 5768 if (*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_READ { // reading 5769 offset = int32(uint32(offset) - (uint32((*Gz_state)(unsafe.Pointer(state)).Fstrm.Favail_in))) 5770 } // don't count buffered input 5771 return offset 5772 } 5773 5774 // -- see zlib.h -- 5775 func Xgzoffset(tls *libc.TLS, file GzFile) int32 { /* gzlib.c:505:17: */ 5776 var ret int32 5777 5778 ret = Xgzoffset64(tls, file) 5779 if ret == ret { 5780 return ret 5781 } 5782 return -1 5783 } 5784 5785 // -- see zlib.h -- 5786 func Xgzeof(tls *libc.TLS, file GzFile) int32 { /* gzlib.c:515:13: */ 5787 var state Gz_statep 5788 5789 // get internal structure and check integrity 5790 if file == (uintptr(0)) { 5791 return 0 5792 } 5793 state = file 5794 if ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ) && ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE) { 5795 return 0 5796 } 5797 5798 // return end-of-file state 5799 if (*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_READ { 5800 return (*Gz_state)(unsafe.Pointer(state)).Fpast 5801 } 5802 return 0 5803 } 5804 5805 // -- see zlib.h -- 5806 func Xgzerror(tls *libc.TLS, file GzFile, errnum uintptr) uintptr { /* gzlib.c:532:12: */ 5807 var state Gz_statep 5808 5809 // get internal structure and check integrity 5810 if file == (uintptr(0)) { 5811 return uintptr(0) 5812 } 5813 state = file 5814 if ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ) && ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE) { 5815 return uintptr(0) 5816 } 5817 5818 // return error information 5819 if errnum != (uintptr(0)) { 5820 *(*int32)(unsafe.Pointer(errnum)) = (*Gz_state)(unsafe.Pointer(state)).Ferr 5821 } 5822 if (*Gz_state)(unsafe.Pointer(state)).Ferr == (-4) { 5823 return ts + 87 /* "out of memory" */ 5824 } 5825 return func() uintptr { 5826 if (*Gz_state)(unsafe.Pointer(state)).Fmsg == (uintptr(0)) { 5827 return ts + 101 /* "" */ 5828 } 5829 return (*Gz_state)(unsafe.Pointer(state)).Fmsg 5830 }() 5831 } 5832 5833 // -- see zlib.h -- 5834 func Xgzclearerr(tls *libc.TLS, file GzFile) { /* gzlib.c:553:14: */ 5835 var state Gz_statep 5836 5837 // get internal structure and check integrity 5838 if file == (uintptr(0)) { 5839 return 5840 } 5841 state = file 5842 if ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ) && ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE) { 5843 return 5844 } 5845 5846 // clear error and end-of-file 5847 if (*Gz_state)(unsafe.Pointer(state)).Fmode == GZ_READ { 5848 (*Gz_state)(unsafe.Pointer(state)).Feof = 0 5849 (*Gz_state)(unsafe.Pointer(state)).Fpast = 0 5850 } 5851 Xgz_error(tls, state, Z_OK, uintptr(0)) 5852 } 5853 5854 // Create an error message in allocated memory and set state->err and 5855 // state->msg accordingly. Free any previous error message already there. Do 5856 // not try to free or allocate space if the error is Z_MEM_ERROR (out of 5857 // memory). Simply save the error message as a static string. If there is an 5858 // allocation failure constructing the error message, then convert the error to 5859 // out of memory. 5860 func Xgz_error(tls *libc.TLS, state Gz_statep, err int32, msg uintptr) { /* gzlib.c:579:20: */ 5861 bp := tls.Alloc(24) 5862 defer tls.Free(24) 5863 5864 // free previously allocated message and clear 5865 if (*Gz_state)(unsafe.Pointer(state)).Fmsg != (uintptr(0)) { 5866 if (*Gz_state)(unsafe.Pointer(state)).Ferr != (-4) { 5867 libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fmsg) 5868 } 5869 (*Gz_state)(unsafe.Pointer(state)).Fmsg = uintptr(0) 5870 } 5871 5872 // if fatal, set state->x.have to 0 so that the gzgetc() macro fails 5873 if (err != Z_OK) && (err != (-5)) { 5874 (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave = uint32(0) 5875 } 5876 5877 // set error code, and if no message, then done 5878 (*Gz_state)(unsafe.Pointer(state)).Ferr = err 5879 if msg == (uintptr(0)) { 5880 return 5881 } 5882 5883 // for an out of memory error, return literal string when requested 5884 if err == (-4) { 5885 return 5886 } 5887 5888 // construct error message with path 5889 if (libc.AssignPtrUintptr(state+104 /* &.msg */, libc.Xmalloc(tls, ((libc.Xstrlen(tls, (*Gz_state)(unsafe.Pointer(state)).Fpath)+libc.Xstrlen(tls, msg))+uint64(3))))) == (uintptr(0)) { 5890 (*Gz_state)(unsafe.Pointer(state)).Ferr = -4 5891 return 5892 } 5893 snprintf(tls, (*Gz_state)(unsafe.Pointer(state)).Fmsg, ((libc.Xstrlen(tls, (*Gz_state)(unsafe.Pointer(state)).Fpath) + libc.Xstrlen(tls, msg)) + uint64(3)), 5894 ts+102 /* "%s%s%s" */, libc.VaList(bp, (*Gz_state)(unsafe.Pointer(state)).Fpath, ts+109 /* ": " */, msg)) 5895 } 5896 5897 // Use read() to load a buffer -- return -1 on error, otherwise 0. Read from 5898 // state->fd, and update state->eof, state->err, and state->msg as appropriate. 5899 // This function needs to loop on read(), since read() is not guaranteed to 5900 // read the number of bytes requested, depending on the type of descriptor. 5901 func gz_load(tls *libc.TLS, state Gz_statep, buf uintptr, len uint32, have uintptr) int32 { /* gzread.c:21:11: */ 5902 var ret int32 5903 var get uint32 5904 var max uint32 = ((uint32(libc.Uint32(libc.Uint32FromInt32(-1))) >> 2) + uint32(1)) 5905 5906 *(*uint32)(unsafe.Pointer(have)) = uint32(0) 5907 for ok := true; ok; ok = (*(*uint32)(unsafe.Pointer(have)) < len) { 5908 get = (len - *(*uint32)(unsafe.Pointer(have))) 5909 if get > max { 5910 get = max 5911 } 5912 ret = libc.Xread(tls, (*Gz_state)(unsafe.Pointer(state)).Ffd, (buf + uintptr(*(*uint32)(unsafe.Pointer(have)))), get) 5913 if ret <= 0 { 5914 break 5915 } 5916 *(*uint32)(unsafe.Pointer(have)) += (uint32(ret)) 5917 } 5918 if ret < 0 { 5919 Xgz_error(tls, state, -1, libc.Xstrerror(tls, *(*int32)(unsafe.Pointer(libc.X_errno(tls))))) 5920 return -1 5921 } 5922 if ret == 0 { 5923 (*Gz_state)(unsafe.Pointer(state)).Feof = 1 5924 } 5925 return 0 5926 } 5927 5928 // Load up input buffer and set eof flag if last data loaded -- return -1 on 5929 // error, 0 otherwise. Note that the eof flag is set when the end of the input 5930 // file is reached, even though there may be unused data in the buffer. Once 5931 // that data has been used, no more attempts will be made to read the file. 5932 // If strm->avail_in != 0, then the current data is moved to the beginning of 5933 // the input buffer, and then the remainder of the buffer is loaded with the 5934 // available data from the input file. 5935 func gz_avail(tls *libc.TLS, state Gz_statep) int32 { /* gzread.c:56:11: */ 5936 bp := tls.Alloc(4) 5937 defer tls.Free(4) 5938 5939 // var got uint32 at bp, 4 5940 5941 var strm Z_streamp = (state + 112 /* &.strm */) 5942 5943 if ((*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK) && ((*Gz_state)(unsafe.Pointer(state)).Ferr != (-5)) { 5944 return -1 5945 } 5946 if (*Gz_state)(unsafe.Pointer(state)).Feof == 0 { 5947 if (*Z_stream)(unsafe.Pointer(strm)).Favail_in != 0 { // copy what's there to the start 5948 var p uintptr = (*Gz_state)(unsafe.Pointer(state)).Fin 5949 var q uintptr = (*Z_stream)(unsafe.Pointer(strm)).Fnext_in 5950 var n uint32 = (*Z_stream)(unsafe.Pointer(strm)).Favail_in 5951 for ok := true; ok; ok = libc.PreDecUint32(&n, 1) != 0 { 5952 *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&p, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&q, 1))) 5953 } 5954 } 5955 if gz_load(tls, state, ((*Gz_state)(unsafe.Pointer(state)).Fin+uintptr((*Z_stream)(unsafe.Pointer(strm)).Favail_in)), 5956 ((*Gz_state)(unsafe.Pointer(state)).Fsize-(*Z_stream)(unsafe.Pointer(strm)).Favail_in), bp /* &got */) == -1 { 5957 return -1 5958 } 5959 *(*UInt)(unsafe.Pointer(strm + 8 /* &.avail_in */)) += (*(*uint32)(unsafe.Pointer(bp /* got */))) 5960 (*Z_stream)(unsafe.Pointer(strm)).Fnext_in = (*Gz_state)(unsafe.Pointer(state)).Fin 5961 } 5962 return 0 5963 } 5964 5965 // Look for gzip header, set up for inflate or copy. state->x.have must be 0. 5966 // If this is the first time in, allocate required memory. state->how will be 5967 // left unchanged if there is no more input data available, will be set to COPY 5968 // if there is no gzip header and direct copying will be performed, or it will 5969 // be set to GZIP for decompression. If direct copying, then leftover input 5970 // data from the input buffer will be copied to the output buffer. In that 5971 // case, all further file reads will be directly to either the output buffer or 5972 // a user buffer. If decompressing, the inflate state will be initialized. 5973 // gz_look() will return 0 on success or -1 on failure. 5974 func gz_look(tls *libc.TLS, state Gz_statep) int32 { /* gzread.c:91:11: */ 5975 var strm Z_streamp = (state + 112 /* &.strm */) 5976 5977 // allocate read buffers and inflate memory 5978 if (*Gz_state)(unsafe.Pointer(state)).Fsize == uint32(0) { 5979 // allocate buffers 5980 (*Gz_state)(unsafe.Pointer(state)).Fin = libc.Xmalloc(tls, uint64((*Gz_state)(unsafe.Pointer(state)).Fwant)) 5981 (*Gz_state)(unsafe.Pointer(state)).Fout = libc.Xmalloc(tls, (uint64((*Gz_state)(unsafe.Pointer(state)).Fwant << 1))) 5982 if ((*Gz_state)(unsafe.Pointer(state)).Fin == (uintptr(0))) || ((*Gz_state)(unsafe.Pointer(state)).Fout == (uintptr(0))) { 5983 libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fout) 5984 libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fin) 5985 Xgz_error(tls, state, -4, ts+87 /* "out of memory" */) 5986 return -1 5987 } 5988 (*Gz_state)(unsafe.Pointer(state)).Fsize = (*Gz_state)(unsafe.Pointer(state)).Fwant 5989 5990 // allocate inflate memory 5991 (*Gz_state)(unsafe.Pointer(state)).Fstrm.Fzalloc = Alloc_func(Z_NULL) 5992 (*Gz_state)(unsafe.Pointer(state)).Fstrm.Fzfree = Free_func(Z_NULL) 5993 (*Gz_state)(unsafe.Pointer(state)).Fstrm.Fopaque = Voidpf(Z_NULL) 5994 (*Gz_state)(unsafe.Pointer(state)).Fstrm.Favail_in = UInt(0) 5995 (*Gz_state)(unsafe.Pointer(state)).Fstrm.Fnext_in = uintptr(Z_NULL) 5996 if (XinflateInit2_(tls, (state+112 /* &.strm */), (15+16), ts /* "1.2.11" */, int32(unsafe.Sizeof(Z_stream{}))) != Z_OK) { // gunzip 5997 libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fout) 5998 libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fin) 5999 (*Gz_state)(unsafe.Pointer(state)).Fsize = uint32(0) 6000 Xgz_error(tls, state, -4, ts+87 /* "out of memory" */) 6001 return -1 6002 } 6003 } 6004 6005 // get at least the magic bytes in the input buffer 6006 if (*Z_stream)(unsafe.Pointer(strm)).Favail_in < UInt(2) { 6007 if gz_avail(tls, state) == -1 { 6008 return -1 6009 } 6010 if (*Z_stream)(unsafe.Pointer(strm)).Favail_in == UInt(0) { 6011 return 0 6012 } 6013 } 6014 6015 // look for gzip magic bytes -- if there, do gzip decoding (note: there is 6016 // a logical dilemma here when considering the case of a partially written 6017 // gzip file, to wit, if a single 31 byte is written, then we cannot tell 6018 // whether this is a single-byte file, or just a partially written gzip 6019 // file -- for here we assume that if a gzip file is being written, then 6020 // the header will be written in a single operation, so that reading a 6021 // single byte is sufficient indication that it is not a gzip file) 6022 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) { 6023 XinflateReset(tls, strm) 6024 (*Gz_state)(unsafe.Pointer(state)).Fhow = /* GZIP */ 2 6025 (*Gz_state)(unsafe.Pointer(state)).Fdirect = 0 6026 return 0 6027 } 6028 6029 // no gzip header -- if we were decoding gzip before, then this is trailing 6030 // garbage. Ignore the trailing garbage and finish. 6031 if (*Gz_state)(unsafe.Pointer(state)).Fdirect == 0 { 6032 (*Z_stream)(unsafe.Pointer(strm)).Favail_in = UInt(0) 6033 (*Gz_state)(unsafe.Pointer(state)).Feof = 1 6034 (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave = uint32(0) 6035 return 0 6036 } 6037 6038 // doing raw i/o, copy any leftover input to output -- this assumes that 6039 // the output buffer is larger than the input buffer, which also assures 6040 // space for gzungetc() 6041 (*Gz_state)(unsafe.Pointer(state)).Fx.Fnext = (*Gz_state)(unsafe.Pointer(state)).Fout 6042 if (*Z_stream)(unsafe.Pointer(strm)).Favail_in != 0 { 6043 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)) 6044 (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave = (*Z_stream)(unsafe.Pointer(strm)).Favail_in 6045 (*Z_stream)(unsafe.Pointer(strm)).Favail_in = UInt(0) 6046 } 6047 (*Gz_state)(unsafe.Pointer(state)).Fhow = COPY1 6048 (*Gz_state)(unsafe.Pointer(state)).Fdirect = 1 6049 return 0 6050 } 6051 6052 // Decompress from input to the provided next_out and avail_out in the state. 6053 // On return, state->x.have and state->x.next point to the just decompressed 6054 // data. If the gzip stream completes, state->how is reset to LOOK to look for 6055 // the next gzip stream or raw data, once state->x.have is depleted. Returns 0 6056 // on success, -1 on failure. 6057 func gz_decomp(tls *libc.TLS, state Gz_statep) int32 { /* gzread.c:175:11: */ 6058 var ret int32 = Z_OK 6059 var had uint32 6060 var strm Z_streamp = (state + 112 /* &.strm */) 6061 6062 // fill output buffer up to end of deflate stream 6063 had = (*Z_stream)(unsafe.Pointer(strm)).Favail_out 6064 for ok := true; ok; ok = (((*Z_stream)(unsafe.Pointer(strm)).Favail_out != 0) && (ret != Z_STREAM_END)) { 6065 // get more input for inflate() 6066 if ((*Z_stream)(unsafe.Pointer(strm)).Favail_in == UInt(0)) && (gz_avail(tls, state) == -1) { 6067 return -1 6068 } 6069 if (*Z_stream)(unsafe.Pointer(strm)).Favail_in == UInt(0) { 6070 Xgz_error(tls, state, -5, ts+112 /* "unexpected end o..." */) 6071 break 6072 } 6073 6074 // decompress and handle errors 6075 ret = Xinflate(tls, strm, Z_NO_FLUSH) 6076 if (ret == (-2)) || (ret == Z_NEED_DICT) { 6077 Xgz_error(tls, state, -2, 6078 ts+135 /* "internal error: ..." */) 6079 return -1 6080 } 6081 if ret == (-4) { 6082 Xgz_error(tls, state, -4, ts+87 /* "out of memory" */) 6083 return -1 6084 } 6085 if ret == (-3) { // deflate stream invalid 6086 Xgz_error(tls, state, -3, 6087 func() uintptr { 6088 if (*Z_stream)(unsafe.Pointer(strm)).Fmsg == (uintptr(0)) { 6089 return ts + 174 /* "compressed data ..." */ 6090 } 6091 return (*Z_stream)(unsafe.Pointer(strm)).Fmsg 6092 }()) 6093 return -1 6094 } 6095 } 6096 6097 // update available output 6098 (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave = (had - (*Z_stream)(unsafe.Pointer(strm)).Favail_out) 6099 (*Gz_state)(unsafe.Pointer(state)).Fx.Fnext = ((*Z_stream)(unsafe.Pointer(strm)).Fnext_out - uintptr((*Gz_state)(unsafe.Pointer(state)).Fx.Fhave)) 6100 6101 // if the gzip stream completed successfully, look for another 6102 if ret == Z_STREAM_END { 6103 (*Gz_state)(unsafe.Pointer(state)).Fhow = LOOK 6104 } 6105 6106 // good decompression 6107 return 0 6108 } 6109 6110 // Fetch data and put it in the output buffer. Assumes state->x.have is 0. 6111 // Data is either copied from the input file or decompressed from the input 6112 // file depending on state->how. If state->how is LOOK, then a gzip header is 6113 // looked for to determine whether to copy or decompress. Returns -1 on error, 6114 // otherwise 0. gz_fetch() will leave state->how as COPY or GZIP unless the 6115 // end of the input file has been reached and all data has been processed. 6116 func gz_fetch(tls *libc.TLS, state Gz_statep) int32 { /* gzread.c:229:11: */ 6117 var strm Z_streamp = (state + 112 /* &.strm */) 6118 6119 for ok := true; ok; ok = (((*Gz_state)(unsafe.Pointer(state)).Fx.Fhave == uint32(0)) && (!((*Gz_state)(unsafe.Pointer(state)).Feof != 0) || ((*Z_stream)(unsafe.Pointer(strm)).Favail_in != 0))) { 6120 switch (*Gz_state)(unsafe.Pointer(state)).Fhow { 6121 case LOOK: // -> LOOK, COPY (only if never GZIP), or GZIP 6122 if gz_look(tls, state) == -1 { 6123 return -1 6124 } 6125 if (*Gz_state)(unsafe.Pointer(state)).Fhow == LOOK { 6126 return 0 6127 } 6128 break 6129 case COPY1: // -> COPY 6130 if gz_load(tls, state, (*Gz_state)(unsafe.Pointer(state)).Fout, ((*Gz_state)(unsafe.Pointer(state)).Fsize<<1), (state /* &.x */ /* &.have */)) == 6131 -1 { 6132 return -1 6133 } 6134 (*Gz_state)(unsafe.Pointer(state)).Fx.Fnext = (*Gz_state)(unsafe.Pointer(state)).Fout 6135 return 0 6136 case /* GZIP */ 2: // -> GZIP or LOOK (if end of gzip stream) 6137 (*Z_stream)(unsafe.Pointer(strm)).Favail_out = ((*Gz_state)(unsafe.Pointer(state)).Fsize << 1) 6138 (*Z_stream)(unsafe.Pointer(strm)).Fnext_out = (*Gz_state)(unsafe.Pointer(state)).Fout 6139 if gz_decomp(tls, state) == -1 { 6140 return -1 6141 } 6142 } 6143 } 6144 return 0 6145 } 6146 6147 // Skip len uncompressed bytes of output. Return -1 on error, 0 on success. 6148 func gz_skip(tls *libc.TLS, state Gz_statep, len int32) int32 { /* gzread.c:259:11: */ 6149 var n uint32 6150 6151 // skip over len bytes or reach end-of-file, whichever comes first 6152 for len != 0 { 6153 // skip over whatever is in output buffer 6154 if (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave != 0 { 6155 if ((uint64(unsafe.Sizeof(int32(0))) == uint64(unsafe.Sizeof(int32(0)))) && (((*Gz_state)(unsafe.Pointer(state)).Fx.Fhave) > uint32(0x7fffffff))) || (int32((*Gz_state)(unsafe.Pointer(state)).Fx.Fhave) > len) { 6156 n = uint32(len) 6157 } else { 6158 n = (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave 6159 } 6160 *(*uint32)(unsafe.Pointer(state /* &.x */ /* &.have */)) -= (n) 6161 *(*uintptr)(unsafe.Pointer(state /* &.x */ + 8 /* &.next */)) += (uintptr(n)) 6162 *(*int32)(unsafe.Pointer(state /* &.x */ + 16 /* &.pos */)) += int32((uint32(n))) 6163 len = int32(uint32(len) - (uint32(n))) 6164 } else if ((*Gz_state)(unsafe.Pointer(state)).Feof != 0) && ((*Gz_state)(unsafe.Pointer(state)).Fstrm.Favail_in == UInt(0)) { 6165 break 6166 } else { 6167 // get more output, looking for header if required 6168 if gz_fetch(tls, state) == -1 { 6169 return -1 6170 } 6171 } 6172 } 6173 return 0 6174 } 6175 6176 // Read len bytes into buf from file, or less than len up to the end of the 6177 // input. Return the number of bytes read. If zero is returned, either the 6178 // end of file was reached, or there was an error. state->err must be 6179 // consulted in that case to determine which. 6180 func gz_read(tls *libc.TLS, state Gz_statep, buf Voidp, len Z_size_t) Z_size_t { /* gzread.c:294:16: */ 6181 bp := tls.Alloc(4) 6182 defer tls.Free(4) 6183 6184 var got Z_size_t 6185 // var n uint32 at bp, 4 6186 6187 // if len is zero, avoid unnecessary operations 6188 if len == uint64(0) { 6189 return uint64(0) 6190 } 6191 6192 // process a skip request 6193 if (*Gz_state)(unsafe.Pointer(state)).Fseek != 0 { 6194 (*Gz_state)(unsafe.Pointer(state)).Fseek = 0 6195 if gz_skip(tls, state, (*Gz_state)(unsafe.Pointer(state)).Fskip) == -1 { 6196 return uint64(0) 6197 } 6198 } 6199 6200 // get len bytes to buf, or less than len if at the end 6201 got = uint64(0) 6202 for ok := true; ok; ok = len != 0 { 6203 // set n to the maximum amount of len that fits in an unsigned int 6204 *(*uint32)(unsafe.Pointer(bp /* n */)) = libc.Uint32FromInt32(-1) 6205 if Z_size_t(*(*uint32)(unsafe.Pointer(bp /* n */))) > len { 6206 *(*uint32)(unsafe.Pointer(bp /* n */)) = uint32(len) 6207 } 6208 6209 // first just try copying data from the output buffer 6210 if (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave != 0 { 6211 if (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave < *(*uint32)(unsafe.Pointer(bp /* n */)) { 6212 *(*uint32)(unsafe.Pointer(bp /* n */)) = (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave 6213 } 6214 libc.Xmemcpy(tls, buf, (*Gz_state)(unsafe.Pointer(state)).Fx.Fnext, uint64(*(*uint32)(unsafe.Pointer(bp /* n */)))) 6215 *(*uintptr)(unsafe.Pointer(state /* &.x */ + 8 /* &.next */)) += (uintptr(*(*uint32)(unsafe.Pointer(bp /* n */)))) 6216 *(*uint32)(unsafe.Pointer(state /* &.x */ /* &.have */)) -= (*(*uint32)(unsafe.Pointer(bp /* n */))) 6217 } else if ((*Gz_state)(unsafe.Pointer(state)).Feof != 0) && ((*Gz_state)(unsafe.Pointer(state)).Fstrm.Favail_in == UInt(0)) { 6218 (*Gz_state)(unsafe.Pointer(state)).Fpast = 1 // tried to read past end 6219 break 6220 } else if ((*Gz_state)(unsafe.Pointer(state)).Fhow == LOOK) || (*(*uint32)(unsafe.Pointer(bp /* n */)) < ((*Gz_state)(unsafe.Pointer(state)).Fsize << 1)) { 6221 // get more output, looking for header if required 6222 if gz_fetch(tls, state) == -1 { 6223 return uint64(0) 6224 } 6225 continue // no progress yet -- go back to copy above 6226 // the copy above assures that we will leave with space in the 6227 // output buffer, allowing at least one gzungetc() to succeed 6228 } else if (*Gz_state)(unsafe.Pointer(state)).Fhow == COPY1 { // read directly 6229 if gz_load(tls, state, buf, *(*uint32)(unsafe.Pointer(bp /* n */)), bp /* &n */) == -1 { 6230 return uint64(0) 6231 } 6232 } else { // state->how == GZIP 6233 (*Gz_state)(unsafe.Pointer(state)).Fstrm.Favail_out = *(*uint32)(unsafe.Pointer(bp /* n */)) 6234 (*Gz_state)(unsafe.Pointer(state)).Fstrm.Fnext_out = buf 6235 if gz_decomp(tls, state) == -1 { 6236 return uint64(0) 6237 } 6238 *(*uint32)(unsafe.Pointer(bp /* n */)) = (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave 6239 (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave = uint32(0) 6240 } 6241 6242 // update progress 6243 len = len - (Z_size_t(*(*uint32)(unsafe.Pointer(bp /* n */)))) 6244 buf = (buf + uintptr(*(*uint32)(unsafe.Pointer(bp /* n */)))) 6245 got = got + (Z_size_t(*(*uint32)(unsafe.Pointer(bp /* n */)))) 6246 *(*int32)(unsafe.Pointer(state /* &.x */ + 16 /* &.pos */)) += int32((uint32(*(*uint32)(unsafe.Pointer(bp /* n */))))) 6247 } 6248 6249 // return number of bytes read into user buffer 6250 return got 6251 } 6252 6253 // -- see zlib.h -- 6254 func Xgzread(tls *libc.TLS, file GzFile, buf Voidp, len uint32) int32 { /* gzread.c:375:13: */ 6255 var state Gz_statep 6256 6257 // get internal structure 6258 if file == (uintptr(0)) { 6259 return -1 6260 } 6261 state = file 6262 6263 // check that we're reading and that there's no (serious) error 6264 if ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ) || (((*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK) && ((*Gz_state)(unsafe.Pointer(state)).Ferr != (-5))) { 6265 return -1 6266 } 6267 6268 // since an int is returned, make sure len fits in one, otherwise return 6269 // with an error (this avoids a flaw in the interface) 6270 if int32(len) < 0 { 6271 Xgz_error(tls, state, -2, ts+196 /* "request does not..." */) 6272 return -1 6273 } 6274 6275 // read len or fewer bytes to buf 6276 len = uint32(gz_read(tls, state, buf, uint64(len))) 6277 6278 // check for an error 6279 if ((len == uint32(0)) && ((*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK)) && ((*Gz_state)(unsafe.Pointer(state)).Ferr != (-5)) { 6280 return -1 6281 } 6282 6283 // return the number of bytes read (this is assured to fit in an int) 6284 return int32(len) 6285 } 6286 6287 // -- see zlib.h -- 6288 func Xgzfread(tls *libc.TLS, buf Voidp, size Z_size_t, nitems Z_size_t, file GzFile) Z_size_t { /* gzread.c:411:18: */ 6289 var len Z_size_t 6290 var state Gz_statep 6291 6292 // get internal structure 6293 if file == (uintptr(0)) { 6294 return uint64(0) 6295 } 6296 state = file 6297 6298 // check that we're reading and that there's no (serious) error 6299 if ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ) || (((*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK) && ((*Gz_state)(unsafe.Pointer(state)).Ferr != (-5))) { 6300 return uint64(0) 6301 } 6302 6303 // compute bytes to read -- error on overflow 6304 len = (nitems * size) 6305 if (size != 0) && ((len / size) != nitems) { 6306 Xgz_error(tls, state, -2, ts+227 /* "request does not..." */) 6307 return uint64(0) 6308 } 6309 6310 // read len or fewer bytes to buf, return the number of full items read 6311 if len != 0 { 6312 return (gz_read(tls, state, buf, len) / size) 6313 } 6314 return uint64(0) 6315 } 6316 6317 // -- see zlib.h -- 6318 func Xgzgetc(tls *libc.TLS, file GzFile) int32 { /* gzread.c:447:13: */ 6319 bp := tls.Alloc(1) 6320 defer tls.Free(1) 6321 6322 var ret int32 6323 // var buf [1]uint8 at bp, 1 6324 6325 var state Gz_statep 6326 6327 // get internal structure 6328 if file == (uintptr(0)) { 6329 return -1 6330 } 6331 state = file 6332 6333 // check that we're reading and that there's no (serious) error 6334 if ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ) || (((*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK) && ((*Gz_state)(unsafe.Pointer(state)).Ferr != (-5))) { 6335 return -1 6336 } 6337 6338 // try output buffer (no need to check for skip request) 6339 if (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave != 0 { 6340 (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave-- 6341 (*Gz_state)(unsafe.Pointer(state)).Fx.Fpos++ 6342 return int32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&((*Gz_state)(unsafe.Pointer(state)).Fx.Fnext), 1)))) 6343 } 6344 6345 // nothing there -- try gz_read() 6346 ret = int32(gz_read(tls, state, bp /* &buf[0] */, uint64(1))) 6347 if ret < 1 { 6348 return -1 6349 } 6350 return int32(*(*uint8)(unsafe.Pointer(bp /* &buf[0] */))) 6351 } 6352 6353 func Xgzgetc_(tls *libc.TLS, file GzFile) int32 { /* gzread.c:476:13: */ 6354 return Xgzgetc(tls, file) 6355 } 6356 6357 // -- see zlib.h -- 6358 func Xgzungetc(tls *libc.TLS, c int32, file GzFile) int32 { /* gzread.c:483:13: */ 6359 var state Gz_statep 6360 6361 // get internal structure 6362 if file == (uintptr(0)) { 6363 return -1 6364 } 6365 state = file 6366 6367 // check that we're reading and that there's no (serious) error 6368 if ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ) || (((*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK) && ((*Gz_state)(unsafe.Pointer(state)).Ferr != (-5))) { 6369 return -1 6370 } 6371 6372 // process a skip request 6373 if (*Gz_state)(unsafe.Pointer(state)).Fseek != 0 { 6374 (*Gz_state)(unsafe.Pointer(state)).Fseek = 0 6375 if gz_skip(tls, state, (*Gz_state)(unsafe.Pointer(state)).Fskip) == -1 { 6376 return -1 6377 } 6378 } 6379 6380 // can't push EOF 6381 if c < 0 { 6382 return -1 6383 } 6384 6385 // if output buffer empty, put byte at end (allows more pushing) 6386 if (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave == uint32(0) { 6387 (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave = uint32(1) 6388 (*Gz_state)(unsafe.Pointer(state)).Fx.Fnext = (((*Gz_state)(unsafe.Pointer(state)).Fout + uintptr(((*Gz_state)(unsafe.Pointer(state)).Fsize << 1))) - uintptr(1)) 6389 *(*uint8)(unsafe.Pointer((*Gz_state)(unsafe.Pointer(state)).Fx.Fnext)) = uint8(c) 6390 (*Gz_state)(unsafe.Pointer(state)).Fx.Fpos-- 6391 (*Gz_state)(unsafe.Pointer(state)).Fpast = 0 6392 return c 6393 } 6394 6395 // if no room, give up (must have already done a gzungetc()) 6396 if (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave == ((*Gz_state)(unsafe.Pointer(state)).Fsize << 1) { 6397 Xgz_error(tls, state, -3, ts+260 /* "out of room to p..." */) 6398 return -1 6399 } 6400 6401 // slide output data if needed and insert byte before existing data 6402 if (*Gz_state)(unsafe.Pointer(state)).Fx.Fnext == (*Gz_state)(unsafe.Pointer(state)).Fout { 6403 var src uintptr = ((*Gz_state)(unsafe.Pointer(state)).Fout + uintptr((*Gz_state)(unsafe.Pointer(state)).Fx.Fhave)) 6404 var dest uintptr = ((*Gz_state)(unsafe.Pointer(state)).Fout + uintptr(((*Gz_state)(unsafe.Pointer(state)).Fsize << 1))) 6405 for src > (*Gz_state)(unsafe.Pointer(state)).Fout { 6406 *(*uint8)(unsafe.Pointer(libc.PreDecUintptr(&dest, 1))) = *(*uint8)(unsafe.Pointer(libc.PreDecUintptr(&src, 1))) 6407 } 6408 (*Gz_state)(unsafe.Pointer(state)).Fx.Fnext = dest 6409 } 6410 (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave++ 6411 (*Gz_state)(unsafe.Pointer(state)).Fx.Fnext-- 6412 *(*uint8)(unsafe.Pointer((*Gz_state)(unsafe.Pointer(state)).Fx.Fnext)) = uint8(c) 6413 (*Gz_state)(unsafe.Pointer(state)).Fx.Fpos-- 6414 (*Gz_state)(unsafe.Pointer(state)).Fpast = 0 6415 return c 6416 } 6417 6418 // -- see zlib.h -- 6419 func Xgzgets(tls *libc.TLS, file GzFile, buf uintptr, len int32) uintptr { /* gzread.c:543:6: */ 6420 var left uint32 6421 var n uint32 6422 var str uintptr 6423 var eol uintptr 6424 var state Gz_statep 6425 6426 // check parameters and get internal structure 6427 if ((file == (uintptr(0))) || (buf == (uintptr(0)))) || (len < 1) { 6428 return uintptr(0) 6429 } 6430 state = file 6431 6432 // check that we're reading and that there's no (serious) error 6433 if ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ) || (((*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK) && ((*Gz_state)(unsafe.Pointer(state)).Ferr != (-5))) { 6434 return uintptr(0) 6435 } 6436 6437 // process a skip request 6438 if (*Gz_state)(unsafe.Pointer(state)).Fseek != 0 { 6439 (*Gz_state)(unsafe.Pointer(state)).Fseek = 0 6440 if gz_skip(tls, state, (*Gz_state)(unsafe.Pointer(state)).Fskip) == -1 { 6441 return uintptr(0) 6442 } 6443 } 6444 6445 // copy output bytes up to new line or len - 1, whichever comes first -- 6446 // append a terminating zero to the string (we don't check for a zero in 6447 // the contents, let the user worry about that) 6448 str = buf 6449 left = (uint32(len) - uint32(1)) 6450 if left != 0 { 6451 for ok := true; ok; ok = ((left != 0) && (eol == (uintptr(0)))) { 6452 // assure that something is in the output buffer 6453 if ((*Gz_state)(unsafe.Pointer(state)).Fx.Fhave == uint32(0)) && (gz_fetch(tls, state) == -1) { 6454 return uintptr(0) 6455 } // error 6456 if (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave == uint32(0) { // end of file 6457 (*Gz_state)(unsafe.Pointer(state)).Fpast = 1 // read past end 6458 break // return what we have 6459 } 6460 6461 // look for end-of-line in current output buffer 6462 if (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave > left { 6463 n = left 6464 } else { 6465 n = (*Gz_state)(unsafe.Pointer(state)).Fx.Fhave 6466 } 6467 eol = libc.Xmemchr(tls, (*Gz_state)(unsafe.Pointer(state)).Fx.Fnext, '\n', uint64(n)) 6468 if eol != (uintptr(0)) { 6469 n = ((uint32((int64(eol) - int64((*Gz_state)(unsafe.Pointer(state)).Fx.Fnext)) / 1)) + uint32(1)) 6470 } 6471 6472 // copy through end-of-line, or remainder if not found 6473 libc.Xmemcpy(tls, buf, (*Gz_state)(unsafe.Pointer(state)).Fx.Fnext, uint64(n)) 6474 *(*uint32)(unsafe.Pointer(state /* &.x */ /* &.have */)) -= (n) 6475 *(*uintptr)(unsafe.Pointer(state /* &.x */ + 8 /* &.next */)) += (uintptr(n)) 6476 *(*int32)(unsafe.Pointer(state /* &.x */ + 16 /* &.pos */)) += int32((uint32(n))) 6477 left = left - (n) 6478 buf += uintptr(n) 6479 } 6480 } 6481 6482 // return terminated string, or if nothing, end of file 6483 if buf == str { 6484 return uintptr(0) 6485 } 6486 *(*int8)(unsafe.Pointer(buf)) = int8(0) 6487 return str 6488 } 6489 6490 // -- see zlib.h -- 6491 func Xgzdirect(tls *libc.TLS, file GzFile) int32 { /* gzread.c:607:13: */ 6492 var state Gz_statep 6493 6494 // get internal structure 6495 if file == (uintptr(0)) { 6496 return 0 6497 } 6498 state = file 6499 6500 // if the state is not known, but we can find out, then do so (this is 6501 // mainly for right after a gzopen() or gzdopen()) 6502 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)) { 6503 gz_look(tls, state) 6504 } 6505 6506 // return 1 if transparent, 0 if processing a gzip stream 6507 return (*Gz_state)(unsafe.Pointer(state)).Fdirect 6508 } 6509 6510 // -- see zlib.h -- 6511 func Xgzclose_r(tls *libc.TLS, file GzFile) int32 { /* gzread.c:627:13: */ 6512 var ret int32 6513 var err int32 6514 var state Gz_statep 6515 6516 // get internal structure 6517 if file == (uintptr(0)) { 6518 return -2 6519 } 6520 state = file 6521 6522 // check that we're reading 6523 if (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_READ { 6524 return -2 6525 } 6526 6527 // free memory and close file 6528 if (*Gz_state)(unsafe.Pointer(state)).Fsize != 0 { 6529 XinflateEnd(tls, (state + 112 /* &.strm */)) 6530 libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fout) 6531 libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fin) 6532 } 6533 if (*Gz_state)(unsafe.Pointer(state)).Ferr == (-5) { 6534 err = -5 6535 } else { 6536 err = Z_OK 6537 } 6538 Xgz_error(tls, state, Z_OK, uintptr(0)) 6539 libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fpath) 6540 ret = libc.Xclose(tls, (*Gz_state)(unsafe.Pointer(state)).Ffd) 6541 libc.Xfree(tls, state) 6542 if ret != 0 { 6543 return -1 6544 } 6545 return err 6546 } 6547 6548 // Initialize state for writing a gzip file. Mark initialization by setting 6549 // state->size to non-zero. Return -1 on a memory allocation failure, or 0 on 6550 // success. 6551 func gz_init(tls *libc.TLS, state Gz_statep) int32 { /* gzwrite.c:17:11: */ 6552 var ret int32 6553 var strm Z_streamp = (state + 112 /* &.strm */) 6554 6555 // allocate input buffer (double size for gzprintf) 6556 (*Gz_state)(unsafe.Pointer(state)).Fin = libc.Xmalloc(tls, (uint64((*Gz_state)(unsafe.Pointer(state)).Fwant << 1))) 6557 if (*Gz_state)(unsafe.Pointer(state)).Fin == (uintptr(0)) { 6558 Xgz_error(tls, state, -4, ts+87 /* "out of memory" */) 6559 return -1 6560 } 6561 6562 // only need output buffer and deflate state if compressing 6563 if !((*Gz_state)(unsafe.Pointer(state)).Fdirect != 0) { 6564 // allocate output buffer 6565 (*Gz_state)(unsafe.Pointer(state)).Fout = libc.Xmalloc(tls, uint64((*Gz_state)(unsafe.Pointer(state)).Fwant)) 6566 if (*Gz_state)(unsafe.Pointer(state)).Fout == (uintptr(0)) { 6567 libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fin) 6568 Xgz_error(tls, state, -4, ts+87 /* "out of memory" */) 6569 return -1 6570 } 6571 6572 // allocate deflate memory, set up for gzip compression 6573 (*Z_stream)(unsafe.Pointer(strm)).Fzalloc = Alloc_func(Z_NULL) 6574 (*Z_stream)(unsafe.Pointer(strm)).Fzfree = Free_func(Z_NULL) 6575 (*Z_stream)(unsafe.Pointer(strm)).Fopaque = Voidpf(Z_NULL) 6576 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 /* "1.2.11" */, int32(unsafe.Sizeof(Z_stream{}))) 6577 if ret != Z_OK { 6578 libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fout) 6579 libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fin) 6580 Xgz_error(tls, state, -4, ts+87 /* "out of memory" */) 6581 return -1 6582 } 6583 (*Z_stream)(unsafe.Pointer(strm)).Fnext_in = uintptr(0) 6584 } 6585 6586 // mark state as initialized 6587 (*Gz_state)(unsafe.Pointer(state)).Fsize = (*Gz_state)(unsafe.Pointer(state)).Fwant 6588 6589 // initialize write buffer if compressing 6590 if !((*Gz_state)(unsafe.Pointer(state)).Fdirect != 0) { 6591 (*Z_stream)(unsafe.Pointer(strm)).Favail_out = (*Gz_state)(unsafe.Pointer(state)).Fsize 6592 (*Z_stream)(unsafe.Pointer(strm)).Fnext_out = (*Gz_state)(unsafe.Pointer(state)).Fout 6593 (*Gz_state)(unsafe.Pointer(state)).Fx.Fnext = (*Z_stream)(unsafe.Pointer(strm)).Fnext_out 6594 } 6595 return 0 6596 } 6597 6598 // Compress whatever is at avail_in and next_in and write to the output file. 6599 // Return -1 if there is an error writing to the output file or if gz_init() 6600 // fails to allocate memory, otherwise 0. flush is assumed to be a valid 6601 // deflate() flush value. If flush is Z_FINISH, then the deflate() state is 6602 // reset to start a new gzip stream. If gz->direct is true, then simply write 6603 // to the output file without compressing, and ignore flush. 6604 func gz_comp(tls *libc.TLS, state Gz_statep, flush int32) int32 { /* gzwrite.c:73:11: */ 6605 var ret int32 6606 var writ int32 6607 var have uint32 6608 var put uint32 6609 var max uint32 = ((uint32(libc.Uint32(libc.Uint32FromInt32(-1))) >> 2) + uint32(1)) 6610 var strm Z_streamp = (state + 112 /* &.strm */) 6611 6612 // allocate memory if this is the first time through 6613 if ((*Gz_state)(unsafe.Pointer(state)).Fsize == uint32(0)) && (gz_init(tls, state) == -1) { 6614 return -1 6615 } 6616 6617 // write directly if requested 6618 if (*Gz_state)(unsafe.Pointer(state)).Fdirect != 0 { 6619 for (*Z_stream)(unsafe.Pointer(strm)).Favail_in != 0 { 6620 if (*Z_stream)(unsafe.Pointer(strm)).Favail_in > max { 6621 put = max 6622 } else { 6623 put = (*Z_stream)(unsafe.Pointer(strm)).Favail_in 6624 } 6625 writ = libc.Xwrite(tls, (*Gz_state)(unsafe.Pointer(state)).Ffd, (*Z_stream)(unsafe.Pointer(strm)).Fnext_in, put) 6626 if writ < 0 { 6627 Xgz_error(tls, state, -1, libc.Xstrerror(tls, *(*int32)(unsafe.Pointer(libc.X_errno(tls))))) 6628 return -1 6629 } 6630 *(*UInt)(unsafe.Pointer(strm + 8 /* &.avail_in */)) -= (uint32(writ)) 6631 *(*uintptr)(unsafe.Pointer(strm /* &.next_in */)) += (uintptr(writ)) 6632 } 6633 return 0 6634 } 6635 6636 // run deflate() on provided input until it produces no more output 6637 ret = Z_OK 6638 for ok := true; ok; ok = have != 0 { 6639 // write out current buffer contents if full, or if flushing, but if 6640 // doing Z_FINISH then don't write until we get to Z_STREAM_END 6641 if ((*Z_stream)(unsafe.Pointer(strm)).Favail_out == UInt(0)) || ((flush != Z_NO_FLUSH) && ((flush != Z_FINISH) || (ret == Z_STREAM_END))) { 6642 for (*Z_stream)(unsafe.Pointer(strm)).Fnext_out > (*Gz_state)(unsafe.Pointer(state)).Fx.Fnext { 6643 if ((int64((*Z_stream)(unsafe.Pointer(strm)).Fnext_out) - int64((*Gz_state)(unsafe.Pointer(state)).Fx.Fnext)) / 1) > int64(int32(max)) { 6644 put = max 6645 } else { 6646 put = (uint32((int64((*Z_stream)(unsafe.Pointer(strm)).Fnext_out) - int64((*Gz_state)(unsafe.Pointer(state)).Fx.Fnext)) / 1)) 6647 } 6648 writ = libc.Xwrite(tls, (*Gz_state)(unsafe.Pointer(state)).Ffd, (*Gz_state)(unsafe.Pointer(state)).Fx.Fnext, put) 6649 if writ < 0 { 6650 Xgz_error(tls, state, -1, libc.Xstrerror(tls, *(*int32)(unsafe.Pointer(libc.X_errno(tls))))) 6651 return -1 6652 } 6653 *(*uintptr)(unsafe.Pointer(state /* &.x */ + 8 /* &.next */)) += (uintptr(writ)) 6654 } 6655 if (*Z_stream)(unsafe.Pointer(strm)).Favail_out == UInt(0) { 6656 (*Z_stream)(unsafe.Pointer(strm)).Favail_out = (*Gz_state)(unsafe.Pointer(state)).Fsize 6657 (*Z_stream)(unsafe.Pointer(strm)).Fnext_out = (*Gz_state)(unsafe.Pointer(state)).Fout 6658 (*Gz_state)(unsafe.Pointer(state)).Fx.Fnext = (*Gz_state)(unsafe.Pointer(state)).Fout 6659 } 6660 } 6661 6662 // compress 6663 have = (*Z_stream)(unsafe.Pointer(strm)).Favail_out 6664 ret = Xdeflate(tls, strm, flush) 6665 if ret == (-2) { 6666 Xgz_error(tls, state, -2, 6667 ts+291 /* "internal error: ..." */) 6668 return -1 6669 } 6670 have = have - ((*Z_stream)(unsafe.Pointer(strm)).Favail_out) 6671 } 6672 6673 // if that completed a deflate stream, allow another to start 6674 if flush == Z_FINISH { 6675 XdeflateReset(tls, strm) 6676 } 6677 6678 // all done, no errors 6679 return 0 6680 } 6681 6682 // Compress len zeros to output. Return -1 on a write error or memory 6683 // allocation failure by gz_comp(), or 0 on success. 6684 func gz_zero(tls *libc.TLS, state Gz_statep, len int32) int32 { /* gzwrite.c:145:11: */ 6685 var first int32 6686 var n uint32 6687 var strm Z_streamp = (state + 112 /* &.strm */) 6688 6689 // consume whatever's left in the input buffer 6690 if ((*Z_stream)(unsafe.Pointer(strm)).Favail_in != 0) && (gz_comp(tls, state, Z_NO_FLUSH) == -1) { 6691 return -1 6692 } 6693 6694 // compress len zeros (len guaranteed > 0) 6695 first = 1 6696 for len != 0 { 6697 if ((uint64(unsafe.Sizeof(int32(0))) == uint64(unsafe.Sizeof(int32(0)))) && (((*Gz_state)(unsafe.Pointer(state)).Fsize) > uint32(0x7fffffff))) || (int32((*Gz_state)(unsafe.Pointer(state)).Fsize) > len) { 6698 n = uint32(len) 6699 } else { 6700 n = (*Gz_state)(unsafe.Pointer(state)).Fsize 6701 } 6702 if first != 0 { 6703 libc.Xmemset(tls, (*Gz_state)(unsafe.Pointer(state)).Fin, 0, uint64(n)) 6704 first = 0 6705 } 6706 (*Z_stream)(unsafe.Pointer(strm)).Favail_in = n 6707 (*Z_stream)(unsafe.Pointer(strm)).Fnext_in = (*Gz_state)(unsafe.Pointer(state)).Fin 6708 *(*int32)(unsafe.Pointer(state /* &.x */ + 16 /* &.pos */)) += int32((uint32(n))) 6709 if gz_comp(tls, state, Z_NO_FLUSH) == -1 { 6710 return -1 6711 } 6712 len = int32(uint32(len) - (uint32(n))) 6713 } 6714 return 0 6715 } 6716 6717 // Write len bytes from buf to file. Return the number of bytes written. If 6718 // the returned value is less than len, then there was an error. 6719 func gz_write(tls *libc.TLS, state Gz_statep, buf Voidpc, len Z_size_t) Z_size_t { /* gzwrite.c:178:16: */ 6720 var put Z_size_t = len 6721 6722 // if len is zero, avoid unnecessary operations 6723 if len == uint64(0) { 6724 return uint64(0) 6725 } 6726 6727 // allocate memory if this is the first time through 6728 if ((*Gz_state)(unsafe.Pointer(state)).Fsize == uint32(0)) && (gz_init(tls, state) == -1) { 6729 return uint64(0) 6730 } 6731 6732 // check for seek request 6733 if (*Gz_state)(unsafe.Pointer(state)).Fseek != 0 { 6734 (*Gz_state)(unsafe.Pointer(state)).Fseek = 0 6735 if gz_zero(tls, state, (*Gz_state)(unsafe.Pointer(state)).Fskip) == -1 { 6736 return uint64(0) 6737 } 6738 } 6739 6740 // for small len, copy to input buffer, otherwise compress directly 6741 if len < Z_size_t((*Gz_state)(unsafe.Pointer(state)).Fsize) { 6742 // copy to input buffer, compress when full 6743 for ok := true; ok; ok = len != 0 { 6744 var have uint32 6745 var copy uint32 6746 6747 if (*Gz_state)(unsafe.Pointer(state)).Fstrm.Favail_in == UInt(0) { 6748 (*Gz_state)(unsafe.Pointer(state)).Fstrm.Fnext_in = (*Gz_state)(unsafe.Pointer(state)).Fin 6749 } 6750 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)) 6751 copy = ((*Gz_state)(unsafe.Pointer(state)).Fsize - have) 6752 if Z_size_t(copy) > len { 6753 copy = uint32(len) 6754 } 6755 libc.Xmemcpy(tls, ((*Gz_state)(unsafe.Pointer(state)).Fin + uintptr(have)), buf, uint64(copy)) 6756 *(*UInt)(unsafe.Pointer(state + 112 /* &.strm */ + 8 /* &.avail_in */)) += (copy) 6757 *(*int32)(unsafe.Pointer(state /* &.x */ + 16 /* &.pos */)) += int32((uint32(copy))) 6758 buf = (buf + uintptr(copy)) 6759 len = len - (Z_size_t(copy)) 6760 if (len != 0) && (gz_comp(tls, state, Z_NO_FLUSH) == -1) { 6761 return uint64(0) 6762 } 6763 } 6764 } else { 6765 // consume whatever's left in the input buffer 6766 if ((*Gz_state)(unsafe.Pointer(state)).Fstrm.Favail_in != 0) && (gz_comp(tls, state, Z_NO_FLUSH) == -1) { 6767 return uint64(0) 6768 } 6769 6770 // directly compress user buffer to file 6771 (*Gz_state)(unsafe.Pointer(state)).Fstrm.Fnext_in = buf 6772 for ok1 := true; ok1; ok1 = len != 0 { 6773 var n uint32 = libc.Uint32(libc.Uint32FromInt32(-1)) 6774 if Z_size_t(n) > len { 6775 n = uint32(len) 6776 } 6777 (*Gz_state)(unsafe.Pointer(state)).Fstrm.Favail_in = n 6778 *(*int32)(unsafe.Pointer(state /* &.x */ + 16 /* &.pos */)) += int32((uint32(n))) 6779 if gz_comp(tls, state, Z_NO_FLUSH) == -1 { 6780 return uint64(0) 6781 } 6782 len = len - (Z_size_t(n)) 6783 } 6784 } 6785 6786 // input was all buffered or compressed 6787 return put 6788 } 6789 6790 // -- see zlib.h -- 6791 func Xgzwrite(tls *libc.TLS, file GzFile, buf Voidpc, len uint32) int32 { /* gzwrite.c:246:13: */ 6792 var state Gz_statep 6793 6794 // get internal structure 6795 if file == (uintptr(0)) { 6796 return 0 6797 } 6798 state = file 6799 6800 // check that we're writing and that there's no error 6801 if ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE) || ((*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK) { 6802 return 0 6803 } 6804 6805 // since an int is returned, make sure len fits in one, otherwise return 6806 // with an error (this avoids a flaw in the interface) 6807 if int32(len) < 0 { 6808 Xgz_error(tls, state, -3, ts+330 /* "requested length..." */) 6809 return 0 6810 } 6811 6812 // write len bytes from buf (the return value will fit in an int) 6813 return int32(gz_write(tls, state, buf, uint64(len))) 6814 } 6815 6816 // -- see zlib.h -- 6817 func Xgzfwrite(tls *libc.TLS, buf Voidpc, size Z_size_t, nitems Z_size_t, file GzFile) Z_size_t { /* gzwrite.c:274:18: */ 6818 var len Z_size_t 6819 var state Gz_statep 6820 6821 // get internal structure 6822 if file == (uintptr(0)) { 6823 return uint64(0) 6824 } 6825 state = file 6826 6827 // check that we're writing and that there's no error 6828 if ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE) || ((*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK) { 6829 return uint64(0) 6830 } 6831 6832 // compute bytes to read -- error on overflow 6833 len = (nitems * size) 6834 if (size != 0) && ((len / size) != nitems) { 6835 Xgz_error(tls, state, -2, ts+227 /* "request does not..." */) 6836 return uint64(0) 6837 } 6838 6839 // write len bytes to buf, return the number of full items written 6840 if len != 0 { 6841 return (gz_write(tls, state, buf, len) / size) 6842 } 6843 return uint64(0) 6844 } 6845 6846 // -- see zlib.h -- 6847 func Xgzputc(tls *libc.TLS, file GzFile, c int32) int32 { /* gzwrite.c:304:13: */ 6848 bp := tls.Alloc(1) 6849 defer tls.Free(1) 6850 6851 var have uint32 6852 // var buf [1]uint8 at bp, 1 6853 6854 var state Gz_statep 6855 var strm Z_streamp 6856 6857 // get internal structure 6858 if file == (uintptr(0)) { 6859 return -1 6860 } 6861 state = file 6862 strm = (state + 112 /* &.strm */) 6863 6864 // check that we're writing and that there's no error 6865 if ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE) || ((*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK) { 6866 return -1 6867 } 6868 6869 // check for seek request 6870 if (*Gz_state)(unsafe.Pointer(state)).Fseek != 0 { 6871 (*Gz_state)(unsafe.Pointer(state)).Fseek = 0 6872 if gz_zero(tls, state, (*Gz_state)(unsafe.Pointer(state)).Fskip) == -1 { 6873 return -1 6874 } 6875 } 6876 6877 // try writing to input buffer for speed (state->size == 0 if buffer not 6878 // initialized) 6879 if (*Gz_state)(unsafe.Pointer(state)).Fsize != 0 { 6880 if (*Z_stream)(unsafe.Pointer(strm)).Favail_in == UInt(0) { 6881 (*Z_stream)(unsafe.Pointer(strm)).Fnext_in = (*Gz_state)(unsafe.Pointer(state)).Fin 6882 } 6883 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)) 6884 if have < (*Gz_state)(unsafe.Pointer(state)).Fsize { 6885 *(*uint8)(unsafe.Pointer((*Gz_state)(unsafe.Pointer(state)).Fin + uintptr(have))) = uint8(c) 6886 (*Z_stream)(unsafe.Pointer(strm)).Favail_in++ 6887 (*Gz_state)(unsafe.Pointer(state)).Fx.Fpos++ 6888 return (c & 0xff) 6889 } 6890 } 6891 6892 // no room in buffer or not initialized, use gz_write() 6893 *(*uint8)(unsafe.Pointer(bp /* &buf[0] */)) = uint8(c) 6894 if gz_write(tls, state, bp /* &buf[0] */, uint64(1)) != uint64(1) { 6895 return -1 6896 } 6897 return (c & 0xff) 6898 } 6899 6900 // -- see zlib.h -- 6901 func Xgzputs(tls *libc.TLS, file GzFile, str uintptr) int32 { /* gzwrite.c:352:13: */ 6902 var ret int32 6903 var len Z_size_t 6904 var state Gz_statep 6905 6906 // get internal structure 6907 if file == (uintptr(0)) { 6908 return -1 6909 } 6910 state = file 6911 6912 // check that we're writing and that there's no error 6913 if ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE) || ((*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK) { 6914 return -1 6915 } 6916 6917 // write string 6918 len = libc.Xstrlen(tls, str) 6919 ret = int32(gz_write(tls, state, str, len)) 6920 if (ret == 0) && (len != uint64(0)) { 6921 return -1 6922 } 6923 return ret 6924 } 6925 6926 // Copyright (C) 1989, 1997, 1998, 1999, 2000 Free Software Foundation, Inc. 6927 // 6928 // This file is part of GCC. 6929 // 6930 // GCC is free software; you can redistribute it and/or modify 6931 // it under the terms of the GNU General Public License as published by 6932 // the Free Software Foundation; either version 2, or (at your option) 6933 // any later version. 6934 // 6935 // GCC is distributed in the hope that it will be useful, 6936 // but WITHOUT ANY WARRANTY; without even the implied warranty of 6937 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 6938 // GNU General Public License for more details. 6939 // 6940 // You should have received a copy of the GNU General Public License 6941 // along with GCC; see the file COPYING. If not, write to 6942 // the Free Software Foundation, 51 Franklin Street, Fifth Floor, 6943 // Boston, MA 02110-1301, USA. 6944 6945 // As a special exception, if you include this header file into source 6946 // files compiled by GCC, this header file does not by itself cause 6947 // the resulting executable to be covered by the GNU General Public 6948 // License. This exception does not however invalidate any other 6949 // reasons why the executable file might be covered by the GNU General 6950 // Public License. 6951 6952 // ISO C Standard: 7.15 Variable arguments <stdarg.h> 6953 6954 // include mingw stuff 6955 // * 6956 // This file has no copyright assigned and is placed in the Public Domain. 6957 // This file is part of the mingw-w64 runtime package. 6958 // No warranty is given; refer to the file DISCLAIMER.PD within this package. 6959 6960 // Copyright (C) 1989-2018 Free Software Foundation, Inc. 6961 // 6962 // This file is part of GCC. 6963 // 6964 // GCC is free software; you can redistribute it and/or modify 6965 // it under the terms of the GNU General Public License as published by 6966 // the Free Software Foundation; either version 3, or (at your option) 6967 // any later version. 6968 // 6969 // GCC is distributed in the hope that it will be useful, 6970 // but WITHOUT ANY WARRANTY; without even the implied warranty of 6971 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 6972 // GNU General Public License for more details. 6973 // 6974 // Under Section 7 of GPL version 3, you are granted additional 6975 // permissions described in the GCC Runtime Library Exception, version 6976 // 3.1, as published by the Free Software Foundation. 6977 // 6978 // You should have received a copy of the GNU General Public License and 6979 // a copy of the GCC Runtime Library Exception along with this program; 6980 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 6981 // <http://www.gnu.org/licenses/>. 6982 6983 // ISO C Standard: 7.15 Variable arguments <stdarg.h> 6984 6985 // -- see zlib.h -- 6986 func Xgzvprintf(tls *libc.TLS, file GzFile, format uintptr, va Va_list) int32 { /* gzwrite.c:379:15: */ 6987 var len int32 6988 var left uint32 6989 var next uintptr 6990 var state Gz_statep 6991 var strm Z_streamp 6992 6993 // get internal structure 6994 if file == (uintptr(0)) { 6995 return -2 6996 } 6997 state = file 6998 strm = (state + 112 /* &.strm */) 6999 7000 // check that we're writing and that there's no error 7001 if ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE) || ((*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK) { 7002 return -2 7003 } 7004 7005 // make sure we have some buffer space 7006 if ((*Gz_state)(unsafe.Pointer(state)).Fsize == uint32(0)) && (gz_init(tls, state) == -1) { 7007 return (*Gz_state)(unsafe.Pointer(state)).Ferr 7008 } 7009 7010 // check for seek request 7011 if (*Gz_state)(unsafe.Pointer(state)).Fseek != 0 { 7012 (*Gz_state)(unsafe.Pointer(state)).Fseek = 0 7013 if gz_zero(tls, state, (*Gz_state)(unsafe.Pointer(state)).Fskip) == -1 { 7014 return (*Gz_state)(unsafe.Pointer(state)).Ferr 7015 } 7016 } 7017 7018 // do the printf() into the input buffer, put length in len -- the input 7019 // buffer is double-sized just for this function, so there is guaranteed to 7020 // be state->size bytes available after the current contents 7021 if (*Z_stream)(unsafe.Pointer(strm)).Favail_in == UInt(0) { 7022 (*Z_stream)(unsafe.Pointer(strm)).Fnext_in = (*Gz_state)(unsafe.Pointer(state)).Fin 7023 } 7024 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)) 7025 *(*int8)(unsafe.Pointer(next + uintptr(((*Gz_state)(unsafe.Pointer(state)).Fsize - uint32(1))))) = int8(0) 7026 len = vsnprintf(tls, next, uint64((*Gz_state)(unsafe.Pointer(state)).Fsize), format, va) 7027 7028 // check that printf() results fit in buffer 7029 if ((len == 0) || (uint32(len) >= (*Gz_state)(unsafe.Pointer(state)).Fsize)) || (int32(*(*int8)(unsafe.Pointer(next + uintptr(((*Gz_state)(unsafe.Pointer(state)).Fsize - uint32(1)))))) != 0) { 7030 return 0 7031 } 7032 7033 // update buffer and position, compress first half if past that 7034 *(*UInt)(unsafe.Pointer(strm + 8 /* &.avail_in */)) += (uint32(len)) 7035 *(*int32)(unsafe.Pointer(state /* &.x */ + 16 /* &.pos */)) += (int32(len)) 7036 if (*Z_stream)(unsafe.Pointer(strm)).Favail_in >= (*Gz_state)(unsafe.Pointer(state)).Fsize { 7037 left = ((*Z_stream)(unsafe.Pointer(strm)).Favail_in - (*Gz_state)(unsafe.Pointer(state)).Fsize) 7038 (*Z_stream)(unsafe.Pointer(strm)).Favail_in = (*Gz_state)(unsafe.Pointer(state)).Fsize 7039 if gz_comp(tls, state, Z_NO_FLUSH) == -1 { 7040 return (*Gz_state)(unsafe.Pointer(state)).Ferr 7041 } 7042 libc.Xmemcpy(tls, (*Gz_state)(unsafe.Pointer(state)).Fin, ((*Gz_state)(unsafe.Pointer(state)).Fin + uintptr((*Gz_state)(unsafe.Pointer(state)).Fsize)), uint64(left)) 7043 (*Z_stream)(unsafe.Pointer(strm)).Fnext_in = (*Gz_state)(unsafe.Pointer(state)).Fin 7044 (*Z_stream)(unsafe.Pointer(strm)).Favail_in = left 7045 } 7046 return len 7047 } 7048 7049 func Xgzprintf(tls *libc.TLS, file GzFile, format uintptr, va uintptr) int32 { /* gzwrite.c:451:15: */ 7050 var va1 Va_list 7051 _ = va1 7052 var ret int32 7053 7054 va1 = va 7055 ret = Xgzvprintf(tls, file, format, va1) 7056 _ = va1 7057 return ret 7058 } 7059 7060 // -- see zlib.h -- 7061 func Xgzflush(tls *libc.TLS, file GzFile, flush int32) int32 { /* gzwrite.c:553:13: */ 7062 var state Gz_statep 7063 7064 // get internal structure 7065 if file == (uintptr(0)) { 7066 return -2 7067 } 7068 state = file 7069 7070 // check that we're writing and that there's no error 7071 if ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE) || ((*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK) { 7072 return -2 7073 } 7074 7075 // check flush parameter 7076 if (flush < 0) || (flush > Z_FINISH) { 7077 return -2 7078 } 7079 7080 // check for seek request 7081 if (*Gz_state)(unsafe.Pointer(state)).Fseek != 0 { 7082 (*Gz_state)(unsafe.Pointer(state)).Fseek = 0 7083 if gz_zero(tls, state, (*Gz_state)(unsafe.Pointer(state)).Fskip) == -1 { 7084 return (*Gz_state)(unsafe.Pointer(state)).Ferr 7085 } 7086 } 7087 7088 // compress remaining data with requested flush 7089 gz_comp(tls, state, flush) 7090 return (*Gz_state)(unsafe.Pointer(state)).Ferr 7091 } 7092 7093 // -- see zlib.h -- 7094 func Xgzsetparams(tls *libc.TLS, file GzFile, level int32, strategy int32) int32 { /* gzwrite.c:585:13: */ 7095 var state Gz_statep 7096 var strm Z_streamp 7097 7098 // get internal structure 7099 if file == (uintptr(0)) { 7100 return -2 7101 } 7102 state = file 7103 strm = (state + 112 /* &.strm */) 7104 7105 // check that we're writing and that there's no error 7106 if ((*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE) || ((*Gz_state)(unsafe.Pointer(state)).Ferr != Z_OK) { 7107 return -2 7108 } 7109 7110 // if no change is requested, then do nothing 7111 if (level == (*Gz_state)(unsafe.Pointer(state)).Flevel) && (strategy == (*Gz_state)(unsafe.Pointer(state)).Fstrategy) { 7112 return Z_OK 7113 } 7114 7115 // check for seek request 7116 if (*Gz_state)(unsafe.Pointer(state)).Fseek != 0 { 7117 (*Gz_state)(unsafe.Pointer(state)).Fseek = 0 7118 if gz_zero(tls, state, (*Gz_state)(unsafe.Pointer(state)).Fskip) == -1 { 7119 return (*Gz_state)(unsafe.Pointer(state)).Ferr 7120 } 7121 } 7122 7123 // change compression parameters for subsequent input 7124 if (*Gz_state)(unsafe.Pointer(state)).Fsize != 0 { 7125 // flush previous input with previous parameters before changing 7126 if ((*Z_stream)(unsafe.Pointer(strm)).Favail_in != 0) && (gz_comp(tls, state, Z_BLOCK) == -1) { 7127 return (*Gz_state)(unsafe.Pointer(state)).Ferr 7128 } 7129 XdeflateParams(tls, strm, level, strategy) 7130 } 7131 (*Gz_state)(unsafe.Pointer(state)).Flevel = level 7132 (*Gz_state)(unsafe.Pointer(state)).Fstrategy = strategy 7133 return Z_OK 7134 } 7135 7136 // -- see zlib.h -- 7137 func Xgzclose_w(tls *libc.TLS, file GzFile) int32 { /* gzwrite.c:627:13: */ 7138 var ret int32 = Z_OK 7139 var state Gz_statep 7140 7141 // get internal structure 7142 if file == (uintptr(0)) { 7143 return -2 7144 } 7145 state = file 7146 7147 // check that we're writing 7148 if (*Gz_state)(unsafe.Pointer(state)).Fmode != GZ_WRITE { 7149 return -2 7150 } 7151 7152 // check for seek request 7153 if (*Gz_state)(unsafe.Pointer(state)).Fseek != 0 { 7154 (*Gz_state)(unsafe.Pointer(state)).Fseek = 0 7155 if gz_zero(tls, state, (*Gz_state)(unsafe.Pointer(state)).Fskip) == -1 { 7156 ret = (*Gz_state)(unsafe.Pointer(state)).Ferr 7157 } 7158 } 7159 7160 // flush, free memory, and close file 7161 if gz_comp(tls, state, Z_FINISH) == -1 { 7162 ret = (*Gz_state)(unsafe.Pointer(state)).Ferr 7163 } 7164 if (*Gz_state)(unsafe.Pointer(state)).Fsize != 0 { 7165 if !((*Gz_state)(unsafe.Pointer(state)).Fdirect != 0) { 7166 XdeflateEnd(tls, (state + 112 /* &.strm */)) 7167 libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fout) 7168 } 7169 libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fin) 7170 } 7171 Xgz_error(tls, state, Z_OK, uintptr(0)) 7172 libc.Xfree(tls, (*Gz_state)(unsafe.Pointer(state)).Fpath) 7173 if libc.Xclose(tls, (*Gz_state)(unsafe.Pointer(state)).Ffd) == -1 { 7174 ret = -1 7175 } 7176 libc.Xfree(tls, state) 7177 return ret 7178 } 7179 7180 // Reverse the bytes in a 32-bit value 7181 7182 // inftrees.h -- header to use inftrees.c 7183 // Copyright (C) 1995-2005, 2010 Mark Adler 7184 // For conditions of distribution and use, see copyright notice in zlib.h 7185 7186 // WARNING: this file should *not* be used by applications. It is 7187 // part of the implementation of the compression library and is 7188 // subject to change. Applications should only use zlib.h. 7189 // 7190 7191 // Structure for decoding tables. Each entry provides either the 7192 // information needed to do the operation requested by the code that 7193 // indexed that table entry, or it provides a pointer to another 7194 // table that indexes more bits of the code. op indicates whether 7195 // the entry is a pointer to another table, a literal, a length or 7196 // distance, an end-of-block, or an invalid code. For a table 7197 // pointer, the low four bits of op is the number of index bits of 7198 // that table. For a length or distance, the low four bits of op 7199 // is the number of extra bits to get after the code. bits is 7200 // the number of bits in this code or part of the code to drop off 7201 // of the bit buffer. val is the actual byte to output in the case 7202 // of a literal, the base length or distance, or the offset from 7203 // the current table to the next table. Each entry is four bytes. 7204 type Code = struct { 7205 Fop uint8 7206 Fbits uint8 7207 Fval uint16 7208 } /* inftrees.h:28:3 */ 7209 7210 // op values as set by inflate_table(): 7211 // 00000000 - literal 7212 // 0000tttt - table link, tttt != 0 is the number of table index bits 7213 // 0001eeee - length or distance, eeee is the number of extra bits 7214 // 01100000 - end of block 7215 // 01000000 - invalid code 7216 // 7217 7218 // Maximum size of the dynamic table. The maximum number of code structures is 7219 // 1444, which is the sum of 852 for literal/length codes and 592 for distance 7220 // codes. These values were found by exhaustive searches using the program 7221 // examples/enough.c found in the zlib distribtution. The arguments to that 7222 // program are the number of symbols, the initial root table size, and the 7223 // maximum bit length of a code. "enough 286 9 15" for literal/length codes 7224 // returns returns 852, and "enough 30 6 15" for distance codes returns 592. 7225 // The initial root table size (9 or 6) is found in the fifth argument of the 7226 // inflate_table() calls in inflate.c and infback.c. If the root table size is 7227 // changed, then these maximum sizes would be need to be recalculated and 7228 // updated. 7229 7230 // Type of code to build for inflate_table() 7231 type Codetype = uint32 /* inftrees.h:58:3 */ 7232 // inflate.h -- internal inflate state definition 7233 // Copyright (C) 1995-2016 Mark Adler 7234 // For conditions of distribution and use, see copyright notice in zlib.h 7235 7236 // WARNING: this file should *not* be used by applications. It is 7237 // part of the implementation of the compression library and is 7238 // subject to change. Applications should only use zlib.h. 7239 // 7240 7241 // define NO_GZIP when compiling if you want to disable gzip header and 7242 // trailer decoding by inflate(). NO_GZIP would be used to avoid linking in 7243 // the crc code when it is not needed. For shared libraries, gzip decoding 7244 // should be left enabled. 7245 7246 // Possible inflate modes between inflate() calls 7247 type Inflate_mode = uint32 /* inflate.h:53:3 */ 7248 7249 // 7250 // State transitions between above modes - 7251 // 7252 // (most modes can go to BAD or MEM on error -- not shown for clarity) 7253 // 7254 // Process header: 7255 // HEAD -> (gzip) or (zlib) or (raw) 7256 // (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME -> COMMENT -> 7257 // HCRC -> TYPE 7258 // (zlib) -> DICTID or TYPE 7259 // DICTID -> DICT -> TYPE 7260 // (raw) -> TYPEDO 7261 // Read deflate blocks: 7262 // TYPE -> TYPEDO -> STORED or TABLE or LEN_ or CHECK 7263 // STORED -> COPY_ -> COPY -> TYPE 7264 // TABLE -> LENLENS -> CODELENS -> LEN_ 7265 // LEN_ -> LEN 7266 // Read deflate codes in fixed or dynamic block: 7267 // LEN -> LENEXT or LIT or TYPE 7268 // LENEXT -> DIST -> DISTEXT -> MATCH -> LEN 7269 // LIT -> LEN 7270 // Process trailer: 7271 // CHECK -> LENGTH -> DONE 7272 // 7273 7274 // State maintained between inflate() calls -- approximately 7K bytes, not 7275 // including the allocated sliding window, which is up to 32K bytes. 7276 type Inflate_state = struct { 7277 Fstrm Z_streamp 7278 Fmode Inflate_mode 7279 Flast int32 7280 Fwrap int32 7281 Fhavedict int32 7282 Fflags int32 7283 Fdmax uint32 7284 Fcheck uint32 7285 Ftotal uint32 7286 Fhead Gz_headerp 7287 Fwbits uint32 7288 Fwsize uint32 7289 Fwhave uint32 7290 Fwnext uint32 7291 Fwindow uintptr 7292 Fhold uint32 7293 Fbits uint32 7294 Flength uint32 7295 Foffset uint32 7296 Fextra uint32 7297 F__ccgo_pad1 [4]byte 7298 Flencode uintptr 7299 Fdistcode uintptr 7300 Flenbits uint32 7301 Fdistbits uint32 7302 Fncode uint32 7303 Fnlen uint32 7304 Fndist uint32 7305 Fhave uint32 7306 Fnext uintptr 7307 Flens [320]uint16 7308 Fwork [288]uint16 7309 Fcodes [1444]Code 7310 Fsane int32 7311 Fback int32 7312 Fwas uint32 7313 F__ccgo_pad2 [4]byte 7314 } /* inflate.h:82:1 */ 7315 7316 // 7317 // strm provides memory allocation functions in zalloc and zfree, or 7318 // Z_NULL to use the library memory allocation functions. 7319 // 7320 // windowBits is in the range 8..15, and window is a user-supplied 7321 // window and output buffer that is 2**windowBits bytes. 7322 // 7323 func XinflateBackInit_(tls *libc.TLS, strm Z_streamp, windowBits int32, window uintptr, version uintptr, stream_size int32) int32 { /* infback.c:28:13: */ 7324 var state uintptr 7325 7326 if ((version == uintptr(Z_NULL)) || (int32(*(*int8)(unsafe.Pointer(version))) != int32(*(*int8)(unsafe.Pointer(ts /* "1.2.11" */))))) || (stream_size != (int32(unsafe.Sizeof(Z_stream{})))) { 7327 return -6 7328 } 7329 if (((strm == uintptr(Z_NULL)) || (window == uintptr(Z_NULL))) || (windowBits < 8)) || (windowBits > 15) { 7330 return -2 7331 } 7332 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = uintptr(Z_NULL) // in case we return an error 7333 if (*Z_stream)(unsafe.Pointer(strm)).Fzalloc == uintptr(0) { 7334 (*Z_stream)(unsafe.Pointer(strm)).Fzalloc = *(*uintptr)(unsafe.Pointer(&struct { 7335 f func(*libc.TLS, Voidpf, uint32, uint32) Voidpf 7336 }{Xzcalloc})) 7337 (*Z_stream)(unsafe.Pointer(strm)).Fopaque = uintptr(0) 7338 } 7339 if (*Z_stream)(unsafe.Pointer(strm)).Fzfree == uintptr(0) { 7340 (*Z_stream)(unsafe.Pointer(strm)).Fzfree = *(*uintptr)(unsafe.Pointer(&struct { 7341 f func(*libc.TLS, Voidpf, Voidpf) 7342 }{Xzcfree})) 7343 } 7344 state = (*struct { 7345 f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf 7346 })(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{}))) 7347 if state == uintptr(Z_NULL) { 7348 return -4 7349 } 7350 7351 (*Z_stream)(unsafe.Pointer(strm)).Fstate = state 7352 (*Inflate_state)(unsafe.Pointer(state)).Fdmax = 32768 7353 (*Inflate_state)(unsafe.Pointer(state)).Fwbits = UInt(windowBits) 7354 (*Inflate_state)(unsafe.Pointer(state)).Fwsize = (uint32(1) << windowBits) 7355 (*Inflate_state)(unsafe.Pointer(state)).Fwindow = window 7356 (*Inflate_state)(unsafe.Pointer(state)).Fwnext = uint32(0) 7357 (*Inflate_state)(unsafe.Pointer(state)).Fwhave = uint32(0) 7358 return Z_OK 7359 } 7360 7361 // 7362 // Return state with length and distance decoding tables and index sizes set to 7363 // fixed code decoding. Normally this returns fixed tables from inffixed.h. 7364 // If BUILDFIXED is defined, then instead this routine builds the tables the 7365 // first time it's called, and returns those tables the first time and 7366 // thereafter. This reduces the size of the code by about 2K bytes, in 7367 // exchange for a little execution time. However, BUILDFIXED should not be 7368 // used for threaded applications, since the rewriting of the tables and virgin 7369 // may not be thread-safe. 7370 // 7371 func fixedtables(tls *libc.TLS, state uintptr) { /* infback.c:82:12: */ 7372 (*Inflate_state)(unsafe.Pointer(state)).Flencode = uintptr(unsafe.Pointer(&lenfix)) 7373 (*Inflate_state)(unsafe.Pointer(state)).Flenbits = uint32(9) 7374 (*Inflate_state)(unsafe.Pointer(state)).Fdistcode = uintptr(unsafe.Pointer(&distfix)) 7375 (*Inflate_state)(unsafe.Pointer(state)).Fdistbits = uint32(5) 7376 } 7377 7378 var lenfix = [512]Code{ 7379 {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)}, 7380 {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)}, 7381 {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)}, 7382 {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)}, 7383 {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)}, 7384 {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)}, 7385 {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)}, 7386 {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)}, 7387 {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)}, 7388 {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)}, 7389 {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)}, 7390 {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)}, 7391 {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)}, 7392 {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)}, 7393 {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)}, 7394 {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)}, 7395 {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)}, 7396 {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)}, 7397 {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)}, 7398 {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)}, 7399 {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)}, 7400 {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)}, 7401 {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)}, 7402 {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)}, 7403 {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)}, 7404 {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)}, 7405 {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)}, 7406 {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)}, 7407 {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)}, 7408 {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)}, 7409 {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)}, 7410 {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)}, 7411 {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)}, 7412 {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)}, 7413 {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)}, 7414 {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)}, 7415 {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)}, 7416 {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)}, 7417 {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)}, 7418 {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)}, 7419 {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)}, 7420 {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)}, 7421 {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)}, 7422 {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)}, 7423 {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)}, 7424 {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)}, 7425 {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)}, 7426 {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)}, 7427 {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)}, 7428 {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)}, 7429 {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)}, 7430 {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)}, 7431 {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)}, 7432 {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)}, 7433 {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)}, 7434 {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)}, 7435 {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)}, 7436 {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)}, 7437 {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)}, 7438 {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)}, 7439 {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)}, 7440 {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)}, 7441 {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)}, 7442 {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)}, 7443 {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)}, 7444 {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)}, 7445 {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)}, 7446 {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)}, 7447 {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)}, 7448 {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)}, 7449 {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)}, 7450 {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)}, 7451 {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)}, 7452 {Fbits: uint8(9), Fval: uint16(255)}, 7453 } /* inffixed.h:10:23 */ 7454 var distfix = [32]Code{ 7455 {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)}, 7456 {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)}, 7457 {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)}, 7458 {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)}, 7459 {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)}, 7460 {Fop: uint8(22), Fbits: uint8(5), Fval: uint16(193)}, {Fop: uint8(64), Fbits: uint8(5)}, 7461 } /* inffixed.h:87:23 */ 7462 7463 // Macros for inflateBack(): 7464 7465 // Load returned state from inflate_fast() 7466 7467 // Set state from registers for inflate_fast() 7468 7469 // Clear the input bit accumulator 7470 7471 // Assure that some input is available. If input is requested, but denied, 7472 // then return a Z_BUF_ERROR from inflateBack(). 7473 7474 // Get a byte of input into the bit accumulator, or return from inflateBack() 7475 // with an error if there is no input available. 7476 7477 // Assure that there are at least n bits in the bit accumulator. If there is 7478 // not enough available input to do that, then return from inflateBack() with 7479 // an error. 7480 7481 // Return the low n bits of the bit accumulator (n < 16) 7482 7483 // Remove n bits from the bit accumulator 7484 7485 // Remove zero to seven bits as needed to go to a byte boundary 7486 7487 // Assure that some output space is available, by writing out the window 7488 // if it's full. If the write fails, return from inflateBack() with a 7489 // Z_BUF_ERROR. 7490 7491 // 7492 // strm provides the memory allocation functions and window buffer on input, 7493 // and provides information on the unused input on return. For Z_DATA_ERROR 7494 // returns, strm will also provide an error message. 7495 // 7496 // in() and out() are the call-back input and output functions. When 7497 // inflateBack() needs more input, it calls in(). When inflateBack() has 7498 // filled the window with output, or when it completes with data in the 7499 // window, it calls out() to write out the data. The application must not 7500 // change the provided input until in() is called again or inflateBack() 7501 // returns. The application must not change the window/output buffer until 7502 // inflateBack() returns. 7503 // 7504 // in() and out() are called with a descriptor parameter provided in the 7505 // inflateBack() call. This parameter can be a structure that provides the 7506 // information required to do the read or write, as well as accumulated 7507 // information on the input and output such as totals and check values. 7508 // 7509 // in() should return zero on failure. out() should return non-zero on 7510 // failure. If either in() or out() fails, than inflateBack() returns a 7511 // Z_BUF_ERROR. strm->next_in can be checked for Z_NULL to see whether it 7512 // was in() or out() that caused in the error. Otherwise, inflateBack() 7513 // returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format 7514 // error, or Z_MEM_ERROR if it could not allocate memory for the state. 7515 // inflateBack() can also return Z_STREAM_ERROR if the input parameters 7516 // are not correct, i.e. strm is Z_NULL or the state was not initialized. 7517 // 7518 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: */ 7519 bp := tls.Alloc(8) 7520 defer tls.Free(8) 7521 7522 var state uintptr 7523 // var next uintptr at bp, 8 7524 // next input 7525 var put uintptr // next output 7526 var have uint32 7527 var left uint32 // available input and output 7528 var hold uint32 // bit buffer 7529 var bits uint32 // bits in bit buffer 7530 var copy uint32 // number of stored or match bytes to copy 7531 var from uintptr // where to copy match bytes from 7532 var here Code // current decoding table entry 7533 var last Code // parent table entry 7534 var len uint32 // length to copy for repeats, bits to drop 7535 var ret int32 7536 7537 // Check that the strm exists and that the state was initialized 7538 if !((strm == uintptr(Z_NULL)) || ((*Z_stream)(unsafe.Pointer(strm)).Fstate == uintptr(Z_NULL))) { 7539 goto __1 7540 } 7541 return -2 7542 __1: 7543 ; 7544 state = (*Z_stream)(unsafe.Pointer(strm)).Fstate 7545 7546 // Reset the state 7547 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = uintptr(Z_NULL) 7548 (*Inflate_state)(unsafe.Pointer(state)).Fmode = TYPE 7549 (*Inflate_state)(unsafe.Pointer(state)).Flast = 0 7550 (*Inflate_state)(unsafe.Pointer(state)).Fwhave = uint32(0) 7551 *(*uintptr)(unsafe.Pointer(bp /* next */)) = (*Z_stream)(unsafe.Pointer(strm)).Fnext_in 7552 if *(*uintptr)(unsafe.Pointer(bp /* next */)) != uintptr(Z_NULL) { 7553 have = (*Z_stream)(unsafe.Pointer(strm)).Favail_in 7554 } else { 7555 have = uint32(0) 7556 } 7557 hold = uint32(0) 7558 bits = uint32(0) 7559 put = (*Inflate_state)(unsafe.Pointer(state)).Fwindow 7560 left = (*Inflate_state)(unsafe.Pointer(state)).Fwsize 7561 7562 // Inflate until end of block marked as last 7563 __2: 7564 switch (*Inflate_state)(unsafe.Pointer(state)).Fmode { 7565 case TYPE: 7566 goto __6 7567 7568 case STORED: 7569 goto __7 7570 7571 case TABLE: 7572 goto __8 7573 7574 case LEN: 7575 goto __9 7576 7577 case DONE: 7578 goto __10 7579 7580 case BAD: 7581 goto __11 7582 7583 default: 7584 goto __12 7585 } 7586 goto __5 7587 __6: 7588 // determine and dispatch block type 7589 if !((*Inflate_state)(unsafe.Pointer(state)).Flast != 0) { 7590 goto __13 7591 } 7592 __14: 7593 hold >>= (bits & uint32(7)) 7594 bits = bits - (bits & uint32(7)) 7595 goto __15 7596 __15: 7597 if 0 != 0 { 7598 goto __14 7599 } 7600 goto __16 7601 __16: 7602 ; 7603 (*Inflate_state)(unsafe.Pointer(state)).Fmode = DONE 7604 goto __5 7605 __13: 7606 ; 7607 __17: 7608 __20: 7609 if !(bits < (uint32(3))) { 7610 goto __21 7611 } 7612 __22: 7613 __25: 7614 if !(have == uint32(0)) { 7615 goto __28 7616 } 7617 have = (*struct { 7618 f func(*libc.TLS, uintptr, uintptr) uint32 7619 })(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */) 7620 if !(have == uint32(0)) { 7621 goto __29 7622 } 7623 *(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL) 7624 ret = -5 7625 goto inf_leave 7626 __29: 7627 ; 7628 __28: 7629 ; 7630 goto __26 7631 __26: 7632 if 0 != 0 { 7633 goto __25 7634 } 7635 goto __27 7636 __27: 7637 ; 7638 have-- 7639 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))) << bits) 7640 bits = bits + (uint32(8)) 7641 goto __23 7642 __23: 7643 if 0 != 0 { 7644 goto __22 7645 } 7646 goto __24 7647 __24: 7648 ; 7649 goto __20 7650 __21: 7651 ; 7652 goto __18 7653 __18: 7654 if 0 != 0 { 7655 goto __17 7656 } 7657 goto __19 7658 __19: 7659 ; 7660 (*Inflate_state)(unsafe.Pointer(state)).Flast = (int32(uint32(hold) & ((uint32(1) << (1)) - uint32(1)))) 7661 __30: 7662 hold >>= 1 7663 bits = bits - (uint32(1)) 7664 goto __31 7665 __31: 7666 if 0 != 0 { 7667 goto __30 7668 } 7669 goto __32 7670 __32: 7671 ; 7672 switch uint32(hold) & ((uint32(1) << (2)) - uint32(1)) { 7673 case uint32(0): 7674 goto __34 7675 case uint32(1): 7676 goto __35 7677 case uint32(2): 7678 goto __36 7679 case uint32(3): 7680 goto __37 7681 } 7682 goto __33 7683 __34: // stored block 7684 ; 7685 (*Inflate_state)(unsafe.Pointer(state)).Fmode = STORED 7686 goto __33 7687 __35: // fixed block 7688 fixedtables(tls, state) 7689 7690 (*Inflate_state)(unsafe.Pointer(state)).Fmode = LEN // decode codes 7691 goto __33 7692 __36: // dynamic block 7693 ; 7694 (*Inflate_state)(unsafe.Pointer(state)).Fmode = TABLE 7695 goto __33 7696 __37: 7697 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 367 /* "invalid block ty..." */ 7698 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 7699 __33: 7700 ; 7701 __38: 7702 hold >>= 2 7703 bits = bits - (uint32(2)) 7704 goto __39 7705 __39: 7706 if 0 != 0 { 7707 goto __38 7708 } 7709 goto __40 7710 __40: 7711 ; 7712 goto __5 7713 7714 __7: 7715 // get and verify stored block length 7716 __41: 7717 hold >>= (bits & uint32(7)) 7718 bits = bits - (bits & uint32(7)) 7719 goto __42 7720 __42: 7721 if 0 != 0 { 7722 goto __41 7723 } 7724 goto __43 7725 __43: 7726 ; // go to byte boundary 7727 __44: 7728 __47: 7729 if !(bits < (uint32(32))) { 7730 goto __48 7731 } 7732 __49: 7733 __52: 7734 if !(have == uint32(0)) { 7735 goto __55 7736 } 7737 have = (*struct { 7738 f func(*libc.TLS, uintptr, uintptr) uint32 7739 })(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */) 7740 if !(have == uint32(0)) { 7741 goto __56 7742 } 7743 *(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL) 7744 ret = -5 7745 goto inf_leave 7746 __56: 7747 ; 7748 __55: 7749 ; 7750 goto __53 7751 __53: 7752 if 0 != 0 { 7753 goto __52 7754 } 7755 goto __54 7756 __54: 7757 ; 7758 have-- 7759 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))) << bits) 7760 bits = bits + (uint32(8)) 7761 goto __50 7762 __50: 7763 if 0 != 0 { 7764 goto __49 7765 } 7766 goto __51 7767 __51: 7768 ; 7769 goto __47 7770 __48: 7771 ; 7772 goto __45 7773 __45: 7774 if 0 != 0 { 7775 goto __44 7776 } 7777 goto __46 7778 __46: 7779 ; 7780 if !((hold & uint32(0xffff)) != ((hold >> 16) ^ uint32(0xffff))) { 7781 goto __57 7782 } 7783 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 386 /* "invalid stored b..." */ 7784 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 7785 goto __5 7786 __57: 7787 ; 7788 (*Inflate_state)(unsafe.Pointer(state)).Flength = (uint32(hold) & uint32(0xffff)) 7789 7790 __58: 7791 hold = uint32(0) 7792 bits = uint32(0) 7793 goto __59 7794 __59: 7795 if 0 != 0 { 7796 goto __58 7797 } 7798 goto __60 7799 __60: 7800 ; 7801 7802 // copy stored block from input to output 7803 __61: 7804 if !((*Inflate_state)(unsafe.Pointer(state)).Flength != uint32(0)) { 7805 goto __62 7806 } 7807 copy = (*Inflate_state)(unsafe.Pointer(state)).Flength 7808 __63: 7809 if !(have == uint32(0)) { 7810 goto __66 7811 } 7812 have = (*struct { 7813 f func(*libc.TLS, uintptr, uintptr) uint32 7814 })(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */) 7815 if !(have == uint32(0)) { 7816 goto __67 7817 } 7818 *(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL) 7819 ret = -5 7820 goto inf_leave 7821 __67: 7822 ; 7823 __66: 7824 ; 7825 goto __64 7826 __64: 7827 if 0 != 0 { 7828 goto __63 7829 } 7830 goto __65 7831 __65: 7832 ; 7833 __68: 7834 if !(left == uint32(0)) { 7835 goto __71 7836 } 7837 put = (*Inflate_state)(unsafe.Pointer(state)).Fwindow 7838 left = (*Inflate_state)(unsafe.Pointer(state)).Fwsize 7839 (*Inflate_state)(unsafe.Pointer(state)).Fwhave = left 7840 if !((*struct { 7841 f func(*libc.TLS, uintptr, uintptr, uint32) int32 7842 })(unsafe.Pointer(&struct{ uintptr }{out})).f(tls, out_desc, put, left) != 0) { 7843 goto __72 7844 } 7845 ret = -5 7846 goto inf_leave 7847 __72: 7848 ; 7849 __71: 7850 ; 7851 goto __69 7852 __69: 7853 if 0 != 0 { 7854 goto __68 7855 } 7856 goto __70 7857 __70: 7858 ; 7859 if !(copy > have) { 7860 goto __73 7861 } 7862 copy = have 7863 __73: 7864 ; 7865 if !(copy > left) { 7866 goto __74 7867 } 7868 copy = left 7869 __74: 7870 ; 7871 libc.Xmemcpy(tls, put, *(*uintptr)(unsafe.Pointer(bp /* next */)), uint64(copy)) 7872 have = have - (copy) 7873 *(*uintptr)(unsafe.Pointer(bp /* next */)) += uintptr(copy) 7874 left = left - (copy) 7875 put += uintptr(copy) 7876 *(*uint32)(unsafe.Pointer(state + 80 /* &.length */)) -= (copy) 7877 goto __61 7878 __62: 7879 ; 7880 7881 (*Inflate_state)(unsafe.Pointer(state)).Fmode = TYPE 7882 goto __5 7883 7884 __8: 7885 // get dynamic table entries descriptor 7886 __75: 7887 __78: 7888 if !(bits < (uint32(14))) { 7889 goto __79 7890 } 7891 __80: 7892 __83: 7893 if !(have == uint32(0)) { 7894 goto __86 7895 } 7896 have = (*struct { 7897 f func(*libc.TLS, uintptr, uintptr) uint32 7898 })(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */) 7899 if !(have == uint32(0)) { 7900 goto __87 7901 } 7902 *(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL) 7903 ret = -5 7904 goto inf_leave 7905 __87: 7906 ; 7907 __86: 7908 ; 7909 goto __84 7910 __84: 7911 if 0 != 0 { 7912 goto __83 7913 } 7914 goto __85 7915 __85: 7916 ; 7917 have-- 7918 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))) << bits) 7919 bits = bits + (uint32(8)) 7920 goto __81 7921 __81: 7922 if 0 != 0 { 7923 goto __80 7924 } 7925 goto __82 7926 __82: 7927 ; 7928 goto __78 7929 __79: 7930 ; 7931 goto __76 7932 __76: 7933 if 0 != 0 { 7934 goto __75 7935 } 7936 goto __77 7937 __77: 7938 ; 7939 (*Inflate_state)(unsafe.Pointer(state)).Fnlen = ((uint32(hold) & ((uint32(1) << (5)) - uint32(1))) + uint32(257)) 7940 __88: 7941 hold >>= 5 7942 bits = bits - (uint32(5)) 7943 goto __89 7944 __89: 7945 if 0 != 0 { 7946 goto __88 7947 } 7948 goto __90 7949 __90: 7950 ; 7951 (*Inflate_state)(unsafe.Pointer(state)).Fndist = ((uint32(hold) & ((uint32(1) << (5)) - uint32(1))) + uint32(1)) 7952 __91: 7953 hold >>= 5 7954 bits = bits - (uint32(5)) 7955 goto __92 7956 __92: 7957 if 0 != 0 { 7958 goto __91 7959 } 7960 goto __93 7961 __93: 7962 ; 7963 (*Inflate_state)(unsafe.Pointer(state)).Fncode = ((uint32(hold) & ((uint32(1) << (4)) - uint32(1))) + uint32(4)) 7964 __94: 7965 hold >>= 4 7966 bits = bits - (uint32(4)) 7967 goto __95 7968 __95: 7969 if 0 != 0 { 7970 goto __94 7971 } 7972 goto __96 7973 __96: 7974 ; 7975 if !(((*Inflate_state)(unsafe.Pointer(state)).Fnlen > uint32(286)) || ((*Inflate_state)(unsafe.Pointer(state)).Fndist > uint32(30))) { 7976 goto __97 7977 } 7978 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 415 /* "too many length ..." */ 7979 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 7980 goto __5 7981 __97: 7982 ; 7983 7984 // get code length code lengths (not a typo) 7985 (*Inflate_state)(unsafe.Pointer(state)).Fhave = uint32(0) 7986 __98: 7987 if !((*Inflate_state)(unsafe.Pointer(state)).Fhave < (*Inflate_state)(unsafe.Pointer(state)).Fncode) { 7988 goto __99 7989 } 7990 __100: 7991 __103: 7992 if !(bits < (uint32(3))) { 7993 goto __104 7994 } 7995 __105: 7996 __108: 7997 if !(have == uint32(0)) { 7998 goto __111 7999 } 8000 have = (*struct { 8001 f func(*libc.TLS, uintptr, uintptr) uint32 8002 })(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */) 8003 if !(have == uint32(0)) { 8004 goto __112 8005 } 8006 *(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL) 8007 ret = -5 8008 goto inf_leave 8009 __112: 8010 ; 8011 __111: 8012 ; 8013 goto __109 8014 __109: 8015 if 0 != 0 { 8016 goto __108 8017 } 8018 goto __110 8019 __110: 8020 ; 8021 have-- 8022 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))) << bits) 8023 bits = bits + (uint32(8)) 8024 goto __106 8025 __106: 8026 if 0 != 0 { 8027 goto __105 8028 } 8029 goto __107 8030 __107: 8031 ; 8032 goto __103 8033 __104: 8034 ; 8035 goto __101 8036 __101: 8037 if 0 != 0 { 8038 goto __100 8039 } 8040 goto __102 8041 __102: 8042 ; 8043 *(*uint16)(unsafe.Pointer((state + 144 /* &.lens */) + uintptr(order[libc.PostIncUint32(&(*Inflate_state)(unsafe.Pointer(state)).Fhave, 1)])*2)) = (uint16(uint32(hold) & ((uint32(1) << (3)) - uint32(1)))) 8044 __113: 8045 hold >>= 3 8046 bits = bits - (uint32(3)) 8047 goto __114 8048 __114: 8049 if 0 != 0 { 8050 goto __113 8051 } 8052 goto __115 8053 __115: 8054 ; 8055 goto __98 8056 __99: 8057 ; 8058 __116: 8059 if !((*Inflate_state)(unsafe.Pointer(state)).Fhave < uint32(19)) { 8060 goto __117 8061 } 8062 *(*uint16)(unsafe.Pointer((state + 144 /* &.lens */) + uintptr(order[libc.PostIncUint32(&(*Inflate_state)(unsafe.Pointer(state)).Fhave, 1)])*2)) = uint16(0) 8063 goto __116 8064 __117: 8065 ; 8066 (*Inflate_state)(unsafe.Pointer(state)).Fnext = state + 1360 /* &.codes */ 8067 (*Inflate_state)(unsafe.Pointer(state)).Flencode = (*Inflate_state)(unsafe.Pointer(state)).Fnext 8068 (*Inflate_state)(unsafe.Pointer(state)).Flenbits = uint32(7) 8069 ret = Xinflate_table(tls, CODES, state+144 /* &.lens */, uint32(19), (state + 136 /* &.next */), 8070 (state + 112 /* &.lenbits */), state+784 /* &.work */) 8071 if !(ret != 0) { 8072 goto __118 8073 } 8074 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 451 /* "invalid code len..." */ 8075 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 8076 goto __5 8077 __118: 8078 ; 8079 8080 // get length and distance code code lengths 8081 (*Inflate_state)(unsafe.Pointer(state)).Fhave = uint32(0) 8082 __119: 8083 if !((*Inflate_state)(unsafe.Pointer(state)).Fhave < ((*Inflate_state)(unsafe.Pointer(state)).Fnlen + (*Inflate_state)(unsafe.Pointer(state)).Fndist)) { 8084 goto __120 8085 } 8086 __121: 8087 here = *(*Code)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Flencode + uintptr((uint32(hold)&((uint32(1)<<((*Inflate_state)(unsafe.Pointer(state)).Flenbits))-uint32(1))))*4)) 8088 if !((uint32(here.Fbits)) <= bits) { 8089 goto __124 8090 } 8091 goto __123 8092 __124: 8093 ; 8094 __125: 8095 __128: 8096 if !(have == uint32(0)) { 8097 goto __131 8098 } 8099 have = (*struct { 8100 f func(*libc.TLS, uintptr, uintptr) uint32 8101 })(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */) 8102 if !(have == uint32(0)) { 8103 goto __132 8104 } 8105 *(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL) 8106 ret = -5 8107 goto inf_leave 8108 __132: 8109 ; 8110 __131: 8111 ; 8112 goto __129 8113 __129: 8114 if 0 != 0 { 8115 goto __128 8116 } 8117 goto __130 8118 __130: 8119 ; 8120 have-- 8121 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))) << bits) 8122 bits = bits + (uint32(8)) 8123 goto __126 8124 __126: 8125 if 0 != 0 { 8126 goto __125 8127 } 8128 goto __127 8129 __127: 8130 ; 8131 goto __122 8132 __122: 8133 goto __121 8134 goto __123 8135 __123: 8136 ; 8137 if !(int32(here.Fval) < 16) { 8138 goto __133 8139 } 8140 __135: 8141 hold >>= int32(here.Fbits) 8142 bits = bits - (uint32(here.Fbits)) 8143 goto __136 8144 __136: 8145 if 0 != 0 { 8146 goto __135 8147 } 8148 goto __137 8149 __137: 8150 ; 8151 *(*uint16)(unsafe.Pointer((state + 144 /* &.lens */) + uintptr(libc.PostIncUint32(&(*Inflate_state)(unsafe.Pointer(state)).Fhave, 1))*2)) = here.Fval 8152 goto __134 8153 __133: 8154 if !(int32(here.Fval) == 16) { 8155 goto __138 8156 } 8157 __140: 8158 __143: 8159 if !(bits < (uint32(int32(here.Fbits) + 2))) { 8160 goto __144 8161 } 8162 __145: 8163 __148: 8164 if !(have == uint32(0)) { 8165 goto __151 8166 } 8167 have = (*struct { 8168 f func(*libc.TLS, uintptr, uintptr) uint32 8169 })(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */) 8170 if !(have == uint32(0)) { 8171 goto __152 8172 } 8173 *(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL) 8174 ret = -5 8175 goto inf_leave 8176 __152: 8177 ; 8178 __151: 8179 ; 8180 goto __149 8181 __149: 8182 if 0 != 0 { 8183 goto __148 8184 } 8185 goto __150 8186 __150: 8187 ; 8188 have-- 8189 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))) << bits) 8190 bits = bits + (uint32(8)) 8191 goto __146 8192 __146: 8193 if 0 != 0 { 8194 goto __145 8195 } 8196 goto __147 8197 __147: 8198 ; 8199 goto __143 8200 __144: 8201 ; 8202 goto __141 8203 __141: 8204 if 0 != 0 { 8205 goto __140 8206 } 8207 goto __142 8208 __142: 8209 ; 8210 __153: 8211 hold >>= int32(here.Fbits) 8212 bits = bits - (uint32(here.Fbits)) 8213 goto __154 8214 __154: 8215 if 0 != 0 { 8216 goto __153 8217 } 8218 goto __155 8219 __155: 8220 ; 8221 if !((*Inflate_state)(unsafe.Pointer(state)).Fhave == uint32(0)) { 8222 goto __156 8223 } 8224 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 476 /* "invalid bit leng..." */ 8225 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 8226 goto __120 8227 __156: 8228 ; 8229 len = uint32(*(*uint16)(unsafe.Pointer((state + 144 /* &.lens */) + uintptr(((*Inflate_state)(unsafe.Pointer(state)).Fhave-uint32(1)))*2))) 8230 copy = (uint32(3) + (uint32(hold) & ((uint32(1) << (2)) - uint32(1)))) 8231 __157: 8232 hold >>= 2 8233 bits = bits - (uint32(2)) 8234 goto __158 8235 __158: 8236 if 0 != 0 { 8237 goto __157 8238 } 8239 goto __159 8240 __159: 8241 ; 8242 goto __139 8243 __138: 8244 if !(int32(here.Fval) == 17) { 8245 goto __160 8246 } 8247 __162: 8248 __165: 8249 if !(bits < (uint32(int32(here.Fbits) + 3))) { 8250 goto __166 8251 } 8252 __167: 8253 __170: 8254 if !(have == uint32(0)) { 8255 goto __173 8256 } 8257 have = (*struct { 8258 f func(*libc.TLS, uintptr, uintptr) uint32 8259 })(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */) 8260 if !(have == uint32(0)) { 8261 goto __174 8262 } 8263 *(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL) 8264 ret = -5 8265 goto inf_leave 8266 __174: 8267 ; 8268 __173: 8269 ; 8270 goto __171 8271 __171: 8272 if 0 != 0 { 8273 goto __170 8274 } 8275 goto __172 8276 __172: 8277 ; 8278 have-- 8279 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))) << bits) 8280 bits = bits + (uint32(8)) 8281 goto __168 8282 __168: 8283 if 0 != 0 { 8284 goto __167 8285 } 8286 goto __169 8287 __169: 8288 ; 8289 goto __165 8290 __166: 8291 ; 8292 goto __163 8293 __163: 8294 if 0 != 0 { 8295 goto __162 8296 } 8297 goto __164 8298 __164: 8299 ; 8300 __175: 8301 hold >>= int32(here.Fbits) 8302 bits = bits - (uint32(here.Fbits)) 8303 goto __176 8304 __176: 8305 if 0 != 0 { 8306 goto __175 8307 } 8308 goto __177 8309 __177: 8310 ; 8311 len = uint32(0) 8312 copy = (uint32(3) + (uint32(hold) & ((uint32(1) << (3)) - uint32(1)))) 8313 __178: 8314 hold >>= 3 8315 bits = bits - (uint32(3)) 8316 goto __179 8317 __179: 8318 if 0 != 0 { 8319 goto __178 8320 } 8321 goto __180 8322 __180: 8323 ; 8324 goto __161 8325 __160: 8326 __181: 8327 __184: 8328 if !(bits < (uint32(int32(here.Fbits) + 7))) { 8329 goto __185 8330 } 8331 __186: 8332 __189: 8333 if !(have == uint32(0)) { 8334 goto __192 8335 } 8336 have = (*struct { 8337 f func(*libc.TLS, uintptr, uintptr) uint32 8338 })(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */) 8339 if !(have == uint32(0)) { 8340 goto __193 8341 } 8342 *(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL) 8343 ret = -5 8344 goto inf_leave 8345 __193: 8346 ; 8347 __192: 8348 ; 8349 goto __190 8350 __190: 8351 if 0 != 0 { 8352 goto __189 8353 } 8354 goto __191 8355 __191: 8356 ; 8357 have-- 8358 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))) << bits) 8359 bits = bits + (uint32(8)) 8360 goto __187 8361 __187: 8362 if 0 != 0 { 8363 goto __186 8364 } 8365 goto __188 8366 __188: 8367 ; 8368 goto __184 8369 __185: 8370 ; 8371 goto __182 8372 __182: 8373 if 0 != 0 { 8374 goto __181 8375 } 8376 goto __183 8377 __183: 8378 ; 8379 __194: 8380 hold >>= int32(here.Fbits) 8381 bits = bits - (uint32(here.Fbits)) 8382 goto __195 8383 __195: 8384 if 0 != 0 { 8385 goto __194 8386 } 8387 goto __196 8388 __196: 8389 ; 8390 len = uint32(0) 8391 copy = (uint32(11) + (uint32(hold) & ((uint32(1) << (7)) - uint32(1)))) 8392 __197: 8393 hold >>= 7 8394 bits = bits - (uint32(7)) 8395 goto __198 8396 __198: 8397 if 0 != 0 { 8398 goto __197 8399 } 8400 goto __199 8401 __199: 8402 ; 8403 __161: 8404 ; 8405 __139: 8406 ; 8407 if !(((*Inflate_state)(unsafe.Pointer(state)).Fhave + copy) > ((*Inflate_state)(unsafe.Pointer(state)).Fnlen + (*Inflate_state)(unsafe.Pointer(state)).Fndist)) { 8408 goto __200 8409 } 8410 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 476 /* "invalid bit leng..." */ 8411 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 8412 goto __120 8413 __200: 8414 ; 8415 __201: 8416 if !(libc.PostDecUint32(©, 1) != 0) { 8417 goto __202 8418 } 8419 *(*uint16)(unsafe.Pointer((state + 144 /* &.lens */) + uintptr(libc.PostIncUint32(&(*Inflate_state)(unsafe.Pointer(state)).Fhave, 1))*2)) = uint16(len) 8420 goto __201 8421 __202: 8422 ; 8423 __134: 8424 ; 8425 goto __119 8426 __120: 8427 ; 8428 8429 // handle error breaks in while 8430 if !((*Inflate_state)(unsafe.Pointer(state)).Fmode == BAD) { 8431 goto __203 8432 } 8433 goto __5 8434 __203: 8435 ; 8436 8437 // check for end-of-block code (better have one) 8438 if !(int32(*(*uint16)(unsafe.Pointer((state + 144 /* &.lens */) + 256*2))) == 0) { 8439 goto __204 8440 } 8441 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 502 /* "invalid code -- ..." */ 8442 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 8443 goto __5 8444 __204: 8445 ; 8446 8447 // build code tables -- note: do not change the lenbits or distbits 8448 // values here (9 and 6) without reading the comments in inftrees.h 8449 // concerning the ENOUGH constants, which depend on those values 8450 (*Inflate_state)(unsafe.Pointer(state)).Fnext = state + 1360 /* &.codes */ 8451 (*Inflate_state)(unsafe.Pointer(state)).Flencode = (*Inflate_state)(unsafe.Pointer(state)).Fnext 8452 (*Inflate_state)(unsafe.Pointer(state)).Flenbits = uint32(9) 8453 ret = Xinflate_table(tls, LENS, state+144 /* &.lens */, (*Inflate_state)(unsafe.Pointer(state)).Fnlen, (state + 136 /* &.next */), 8454 (state + 112 /* &.lenbits */), state+784 /* &.work */) 8455 if !(ret != 0) { 8456 goto __205 8457 } 8458 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 539 /* "invalid literal/..." */ 8459 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 8460 goto __5 8461 __205: 8462 ; 8463 (*Inflate_state)(unsafe.Pointer(state)).Fdistcode = (*Inflate_state)(unsafe.Pointer(state)).Fnext 8464 (*Inflate_state)(unsafe.Pointer(state)).Fdistbits = uint32(6) 8465 ret = Xinflate_table(tls, DISTS, ((state + 144 /* &.lens */) + uintptr((*Inflate_state)(unsafe.Pointer(state)).Fnlen)*2), (*Inflate_state)(unsafe.Pointer(state)).Fndist, 8466 (state + 136 /* &.next */), (state + 116 /* &.distbits */), state+784 /* &.work */) 8467 if !(ret != 0) { 8468 goto __206 8469 } 8470 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 567 /* "invalid distance..." */ 8471 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 8472 goto __5 8473 __206: 8474 ; 8475 8476 (*Inflate_state)(unsafe.Pointer(state)).Fmode = LEN 8477 8478 __9: 8479 // use inflate_fast() if we have enough input and output 8480 if !((have >= uint32(6)) && (left >= uint32(258))) { 8481 goto __207 8482 } 8483 __208: 8484 (*Z_stream)(unsafe.Pointer(strm)).Fnext_out = put 8485 (*Z_stream)(unsafe.Pointer(strm)).Favail_out = left 8486 (*Z_stream)(unsafe.Pointer(strm)).Fnext_in = *(*uintptr)(unsafe.Pointer(bp /* next */)) 8487 (*Z_stream)(unsafe.Pointer(strm)).Favail_in = have 8488 (*Inflate_state)(unsafe.Pointer(state)).Fhold = hold 8489 (*Inflate_state)(unsafe.Pointer(state)).Fbits = bits 8490 goto __209 8491 __209: 8492 if 0 != 0 { 8493 goto __208 8494 } 8495 goto __210 8496 __210: 8497 ; 8498 if !((*Inflate_state)(unsafe.Pointer(state)).Fwhave < (*Inflate_state)(unsafe.Pointer(state)).Fwsize) { 8499 goto __211 8500 } 8501 (*Inflate_state)(unsafe.Pointer(state)).Fwhave = ((*Inflate_state)(unsafe.Pointer(state)).Fwsize - left) 8502 __211: 8503 ; 8504 Xinflate_fast(tls, strm, (*Inflate_state)(unsafe.Pointer(state)).Fwsize) 8505 __212: 8506 put = (*Z_stream)(unsafe.Pointer(strm)).Fnext_out 8507 left = (*Z_stream)(unsafe.Pointer(strm)).Favail_out 8508 *(*uintptr)(unsafe.Pointer(bp /* next */)) = (*Z_stream)(unsafe.Pointer(strm)).Fnext_in 8509 have = (*Z_stream)(unsafe.Pointer(strm)).Favail_in 8510 hold = (*Inflate_state)(unsafe.Pointer(state)).Fhold 8511 bits = (*Inflate_state)(unsafe.Pointer(state)).Fbits 8512 goto __213 8513 __213: 8514 if 0 != 0 { 8515 goto __212 8516 } 8517 goto __214 8518 __214: 8519 ; 8520 goto __5 8521 __207: 8522 ; 8523 8524 // get a literal, length, or end-of-block code 8525 __215: 8526 here = *(*Code)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Flencode + uintptr((uint32(hold)&((uint32(1)<<((*Inflate_state)(unsafe.Pointer(state)).Flenbits))-uint32(1))))*4)) 8527 if !((uint32(here.Fbits)) <= bits) { 8528 goto __218 8529 } 8530 goto __217 8531 __218: 8532 ; 8533 __219: 8534 __222: 8535 if !(have == uint32(0)) { 8536 goto __225 8537 } 8538 have = (*struct { 8539 f func(*libc.TLS, uintptr, uintptr) uint32 8540 })(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */) 8541 if !(have == uint32(0)) { 8542 goto __226 8543 } 8544 *(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL) 8545 ret = -5 8546 goto inf_leave 8547 __226: 8548 ; 8549 __225: 8550 ; 8551 goto __223 8552 __223: 8553 if 0 != 0 { 8554 goto __222 8555 } 8556 goto __224 8557 __224: 8558 ; 8559 have-- 8560 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))) << bits) 8561 bits = bits + (uint32(8)) 8562 goto __220 8563 __220: 8564 if 0 != 0 { 8565 goto __219 8566 } 8567 goto __221 8568 __221: 8569 ; 8570 goto __216 8571 __216: 8572 goto __215 8573 goto __217 8574 __217: 8575 ; 8576 if !((here.Fop != 0) && ((int32(here.Fop) & 0xf0) == 0)) { 8577 goto __227 8578 } 8579 last = here 8580 __228: 8581 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)) 8582 if !((uint32(int32(last.Fbits) + int32(here.Fbits))) <= bits) { 8583 goto __231 8584 } 8585 goto __230 8586 __231: 8587 ; 8588 __232: 8589 __235: 8590 if !(have == uint32(0)) { 8591 goto __238 8592 } 8593 have = (*struct { 8594 f func(*libc.TLS, uintptr, uintptr) uint32 8595 })(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */) 8596 if !(have == uint32(0)) { 8597 goto __239 8598 } 8599 *(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL) 8600 ret = -5 8601 goto inf_leave 8602 __239: 8603 ; 8604 __238: 8605 ; 8606 goto __236 8607 __236: 8608 if 0 != 0 { 8609 goto __235 8610 } 8611 goto __237 8612 __237: 8613 ; 8614 have-- 8615 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))) << bits) 8616 bits = bits + (uint32(8)) 8617 goto __233 8618 __233: 8619 if 0 != 0 { 8620 goto __232 8621 } 8622 goto __234 8623 __234: 8624 ; 8625 goto __229 8626 __229: 8627 goto __228 8628 goto __230 8629 __230: 8630 ; 8631 __240: 8632 hold >>= int32(last.Fbits) 8633 bits = bits - (uint32(last.Fbits)) 8634 goto __241 8635 __241: 8636 if 0 != 0 { 8637 goto __240 8638 } 8639 goto __242 8640 __242: 8641 ; 8642 __227: 8643 ; 8644 __243: 8645 hold >>= int32(here.Fbits) 8646 bits = bits - (uint32(here.Fbits)) 8647 goto __244 8648 __244: 8649 if 0 != 0 { 8650 goto __243 8651 } 8652 goto __245 8653 __245: 8654 ; 8655 (*Inflate_state)(unsafe.Pointer(state)).Flength = uint32(here.Fval) 8656 8657 // process literal 8658 if !(int32(here.Fop) == 0) { 8659 goto __246 8660 } 8661 8662 __247: 8663 if !(left == uint32(0)) { 8664 goto __250 8665 } 8666 put = (*Inflate_state)(unsafe.Pointer(state)).Fwindow 8667 left = (*Inflate_state)(unsafe.Pointer(state)).Fwsize 8668 (*Inflate_state)(unsafe.Pointer(state)).Fwhave = left 8669 if !((*struct { 8670 f func(*libc.TLS, uintptr, uintptr, uint32) int32 8671 })(unsafe.Pointer(&struct{ uintptr }{out})).f(tls, out_desc, put, left) != 0) { 8672 goto __251 8673 } 8674 ret = -5 8675 goto inf_leave 8676 __251: 8677 ; 8678 __250: 8679 ; 8680 goto __248 8681 __248: 8682 if 0 != 0 { 8683 goto __247 8684 } 8685 goto __249 8686 __249: 8687 ; 8688 *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&put, 1))) = uint8((*Inflate_state)(unsafe.Pointer(state)).Flength) 8689 left-- 8690 (*Inflate_state)(unsafe.Pointer(state)).Fmode = LEN 8691 goto __5 8692 __246: 8693 ; 8694 8695 // process end of block 8696 if !((int32(here.Fop) & 32) != 0) { 8697 goto __252 8698 } 8699 8700 (*Inflate_state)(unsafe.Pointer(state)).Fmode = TYPE 8701 goto __5 8702 __252: 8703 ; 8704 8705 // invalid code 8706 if !((int32(here.Fop) & 64) != 0) { 8707 goto __253 8708 } 8709 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 589 /* "invalid literal/..." */ 8710 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 8711 goto __5 8712 __253: 8713 ; 8714 8715 // length code -- get extra bits, if any 8716 (*Inflate_state)(unsafe.Pointer(state)).Fextra = ((uint32(here.Fop)) & uint32(15)) 8717 if !((*Inflate_state)(unsafe.Pointer(state)).Fextra != uint32(0)) { 8718 goto __254 8719 } 8720 __255: 8721 __258: 8722 if !(bits < ((*Inflate_state)(unsafe.Pointer(state)).Fextra)) { 8723 goto __259 8724 } 8725 __260: 8726 __263: 8727 if !(have == uint32(0)) { 8728 goto __266 8729 } 8730 have = (*struct { 8731 f func(*libc.TLS, uintptr, uintptr) uint32 8732 })(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */) 8733 if !(have == uint32(0)) { 8734 goto __267 8735 } 8736 *(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL) 8737 ret = -5 8738 goto inf_leave 8739 __267: 8740 ; 8741 __266: 8742 ; 8743 goto __264 8744 __264: 8745 if 0 != 0 { 8746 goto __263 8747 } 8748 goto __265 8749 __265: 8750 ; 8751 have-- 8752 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))) << bits) 8753 bits = bits + (uint32(8)) 8754 goto __261 8755 __261: 8756 if 0 != 0 { 8757 goto __260 8758 } 8759 goto __262 8760 __262: 8761 ; 8762 goto __258 8763 __259: 8764 ; 8765 goto __256 8766 __256: 8767 if 0 != 0 { 8768 goto __255 8769 } 8770 goto __257 8771 __257: 8772 ; 8773 *(*uint32)(unsafe.Pointer(state + 80 /* &.length */)) += (uint32(hold) & ((uint32(1) << ((*Inflate_state)(unsafe.Pointer(state)).Fextra)) - uint32(1))) 8774 __268: 8775 hold >>= (*Inflate_state)(unsafe.Pointer(state)).Fextra 8776 bits = bits - ((*Inflate_state)(unsafe.Pointer(state)).Fextra) 8777 goto __269 8778 __269: 8779 if 0 != 0 { 8780 goto __268 8781 } 8782 goto __270 8783 __270: 8784 ; 8785 __254: 8786 ; 8787 8788 // get distance code 8789 __271: 8790 here = *(*Code)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fdistcode + uintptr((uint32(hold)&((uint32(1)<<((*Inflate_state)(unsafe.Pointer(state)).Fdistbits))-uint32(1))))*4)) 8791 if !((uint32(here.Fbits)) <= bits) { 8792 goto __274 8793 } 8794 goto __273 8795 __274: 8796 ; 8797 __275: 8798 __278: 8799 if !(have == uint32(0)) { 8800 goto __281 8801 } 8802 have = (*struct { 8803 f func(*libc.TLS, uintptr, uintptr) uint32 8804 })(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */) 8805 if !(have == uint32(0)) { 8806 goto __282 8807 } 8808 *(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL) 8809 ret = -5 8810 goto inf_leave 8811 __282: 8812 ; 8813 __281: 8814 ; 8815 goto __279 8816 __279: 8817 if 0 != 0 { 8818 goto __278 8819 } 8820 goto __280 8821 __280: 8822 ; 8823 have-- 8824 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))) << bits) 8825 bits = bits + (uint32(8)) 8826 goto __276 8827 __276: 8828 if 0 != 0 { 8829 goto __275 8830 } 8831 goto __277 8832 __277: 8833 ; 8834 goto __272 8835 __272: 8836 goto __271 8837 goto __273 8838 __273: 8839 ; 8840 if !((int32(here.Fop) & 0xf0) == 0) { 8841 goto __283 8842 } 8843 last = here 8844 __284: 8845 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)) 8846 if !((uint32(int32(last.Fbits) + int32(here.Fbits))) <= bits) { 8847 goto __287 8848 } 8849 goto __286 8850 __287: 8851 ; 8852 __288: 8853 __291: 8854 if !(have == uint32(0)) { 8855 goto __294 8856 } 8857 have = (*struct { 8858 f func(*libc.TLS, uintptr, uintptr) uint32 8859 })(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */) 8860 if !(have == uint32(0)) { 8861 goto __295 8862 } 8863 *(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL) 8864 ret = -5 8865 goto inf_leave 8866 __295: 8867 ; 8868 __294: 8869 ; 8870 goto __292 8871 __292: 8872 if 0 != 0 { 8873 goto __291 8874 } 8875 goto __293 8876 __293: 8877 ; 8878 have-- 8879 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))) << bits) 8880 bits = bits + (uint32(8)) 8881 goto __289 8882 __289: 8883 if 0 != 0 { 8884 goto __288 8885 } 8886 goto __290 8887 __290: 8888 ; 8889 goto __285 8890 __285: 8891 goto __284 8892 goto __286 8893 __286: 8894 ; 8895 __296: 8896 hold >>= int32(last.Fbits) 8897 bits = bits - (uint32(last.Fbits)) 8898 goto __297 8899 __297: 8900 if 0 != 0 { 8901 goto __296 8902 } 8903 goto __298 8904 __298: 8905 ; 8906 __283: 8907 ; 8908 __299: 8909 hold >>= int32(here.Fbits) 8910 bits = bits - (uint32(here.Fbits)) 8911 goto __300 8912 __300: 8913 if 0 != 0 { 8914 goto __299 8915 } 8916 goto __301 8917 __301: 8918 ; 8919 if !((int32(here.Fop) & 64) != 0) { 8920 goto __302 8921 } 8922 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 617 /* "invalid distance..." */ 8923 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 8924 goto __5 8925 __302: 8926 ; 8927 (*Inflate_state)(unsafe.Pointer(state)).Foffset = uint32(here.Fval) 8928 8929 // get distance extra bits, if any 8930 (*Inflate_state)(unsafe.Pointer(state)).Fextra = ((uint32(here.Fop)) & uint32(15)) 8931 if !((*Inflate_state)(unsafe.Pointer(state)).Fextra != uint32(0)) { 8932 goto __303 8933 } 8934 __304: 8935 __307: 8936 if !(bits < ((*Inflate_state)(unsafe.Pointer(state)).Fextra)) { 8937 goto __308 8938 } 8939 __309: 8940 __312: 8941 if !(have == uint32(0)) { 8942 goto __315 8943 } 8944 have = (*struct { 8945 f func(*libc.TLS, uintptr, uintptr) uint32 8946 })(unsafe.Pointer(&struct{ uintptr }{in})).f(tls, in_desc, bp /* &next */) 8947 if !(have == uint32(0)) { 8948 goto __316 8949 } 8950 *(*uintptr)(unsafe.Pointer(bp /* next */)) = uintptr(Z_NULL) 8951 ret = -5 8952 goto inf_leave 8953 __316: 8954 ; 8955 __315: 8956 ; 8957 goto __313 8958 __313: 8959 if 0 != 0 { 8960 goto __312 8961 } 8962 goto __314 8963 __314: 8964 ; 8965 have-- 8966 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&*(*uintptr)(unsafe.Pointer(bp /* next */)), 1))))) << bits) 8967 bits = bits + (uint32(8)) 8968 goto __310 8969 __310: 8970 if 0 != 0 { 8971 goto __309 8972 } 8973 goto __311 8974 __311: 8975 ; 8976 goto __307 8977 __308: 8978 ; 8979 goto __305 8980 __305: 8981 if 0 != 0 { 8982 goto __304 8983 } 8984 goto __306 8985 __306: 8986 ; 8987 *(*uint32)(unsafe.Pointer(state + 84 /* &.offset */)) += (uint32(hold) & ((uint32(1) << ((*Inflate_state)(unsafe.Pointer(state)).Fextra)) - uint32(1))) 8988 __317: 8989 hold >>= (*Inflate_state)(unsafe.Pointer(state)).Fextra 8990 bits = bits - ((*Inflate_state)(unsafe.Pointer(state)).Fextra) 8991 goto __318 8992 __318: 8993 if 0 != 0 { 8994 goto __317 8995 } 8996 goto __319 8997 __319: 8998 ; 8999 __303: 9000 ; 9001 if !((*Inflate_state)(unsafe.Pointer(state)).Foffset > ((*Inflate_state)(unsafe.Pointer(state)).Fwsize - (func() uint32 { 9002 if (*Inflate_state)(unsafe.Pointer(state)).Fwhave < (*Inflate_state)(unsafe.Pointer(state)).Fwsize { 9003 return left 9004 } 9005 return uint32(0) 9006 }()))) { 9007 goto __320 9008 } 9009 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 639 /* "invalid distance..." */ 9010 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 9011 goto __5 9012 __320: 9013 ; 9014 9015 // copy match from window to output 9016 __321: 9017 __324: 9018 if !(left == uint32(0)) { 9019 goto __327 9020 } 9021 put = (*Inflate_state)(unsafe.Pointer(state)).Fwindow 9022 left = (*Inflate_state)(unsafe.Pointer(state)).Fwsize 9023 (*Inflate_state)(unsafe.Pointer(state)).Fwhave = left 9024 if !((*struct { 9025 f func(*libc.TLS, uintptr, uintptr, uint32) int32 9026 })(unsafe.Pointer(&struct{ uintptr }{out})).f(tls, out_desc, put, left) != 0) { 9027 goto __328 9028 } 9029 ret = -5 9030 goto inf_leave 9031 __328: 9032 ; 9033 __327: 9034 ; 9035 goto __325 9036 __325: 9037 if 0 != 0 { 9038 goto __324 9039 } 9040 goto __326 9041 __326: 9042 ; 9043 copy = ((*Inflate_state)(unsafe.Pointer(state)).Fwsize - (*Inflate_state)(unsafe.Pointer(state)).Foffset) 9044 if !(copy < left) { 9045 goto __329 9046 } 9047 from = (put + uintptr(copy)) 9048 copy = (left - copy) 9049 goto __330 9050 __329: 9051 from = (put - uintptr((*Inflate_state)(unsafe.Pointer(state)).Foffset)) 9052 copy = left 9053 __330: 9054 ; 9055 if !(copy > (*Inflate_state)(unsafe.Pointer(state)).Flength) { 9056 goto __331 9057 } 9058 copy = (*Inflate_state)(unsafe.Pointer(state)).Flength 9059 __331: 9060 ; 9061 *(*uint32)(unsafe.Pointer(state + 80 /* &.length */)) -= (copy) 9062 left = left - (copy) 9063 __332: 9064 *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&put, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1))) 9065 goto __333 9066 __333: 9067 if libc.PreDecUint32(©, 1) != 0 { 9068 goto __332 9069 } 9070 goto __334 9071 __334: 9072 ; 9073 goto __322 9074 __322: 9075 if (*Inflate_state)(unsafe.Pointer(state)).Flength != uint32(0) { 9076 goto __321 9077 } 9078 goto __323 9079 __323: 9080 ; 9081 goto __5 9082 9083 __10: 9084 // inflate stream terminated properly -- write leftover output 9085 ret = Z_STREAM_END 9086 if !(left < (*Inflate_state)(unsafe.Pointer(state)).Fwsize) { 9087 goto __335 9088 } 9089 if !((*struct { 9090 f func(*libc.TLS, uintptr, uintptr, uint32) int32 9091 })(unsafe.Pointer(&struct{ uintptr }{out})).f(tls, out_desc, (*Inflate_state)(unsafe.Pointer(state)).Fwindow, ((*Inflate_state)(unsafe.Pointer(state)).Fwsize-left)) != 0) { 9092 goto __336 9093 } 9094 ret = -5 9095 __336: 9096 ; 9097 __335: 9098 ; 9099 goto inf_leave 9100 9101 __11: 9102 ret = -3 9103 goto inf_leave 9104 9105 __12: // can't happen, but makes compilers happy 9106 ret = -2 9107 goto inf_leave 9108 __5: 9109 ; 9110 goto __3 9111 __3: 9112 goto __2 9113 goto __4 9114 __4: 9115 ; 9116 9117 // Return unused input 9118 inf_leave: 9119 (*Z_stream)(unsafe.Pointer(strm)).Fnext_in = *(*uintptr)(unsafe.Pointer(bp /* next */)) 9120 (*Z_stream)(unsafe.Pointer(strm)).Favail_in = have 9121 return ret 9122 } 9123 9124 var order = // permutation of code lengths 9125 [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 */ 9126 9127 func XinflateBackEnd(tls *libc.TLS, strm Z_streamp) int32 { /* infback.c:631:13: */ 9128 if ((strm == uintptr(Z_NULL)) || ((*Z_stream)(unsafe.Pointer(strm)).Fstate == uintptr(Z_NULL))) || ((*Z_stream)(unsafe.Pointer(strm)).Fzfree == uintptr(0)) { 9129 return -2 9130 } 9131 (*struct { 9132 f func(*libc.TLS, Voidpf, Voidpf) 9133 })(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer((strm))).Fzfree})).f(tls, (*Z_stream)(unsafe.Pointer(strm)).Fopaque, (*Z_stream)(unsafe.Pointer(strm)).Fstate) 9134 (*Z_stream)(unsafe.Pointer(strm)).Fstate = uintptr(Z_NULL) 9135 9136 return Z_OK 9137 } 9138 9139 // 9140 // Decode literal, length, and distance codes and write out the resulting 9141 // literal and match bytes until either not enough input or output is 9142 // available, an end-of-block is encountered, or a data error is encountered. 9143 // When large enough input and output buffers are supplied to inflate(), for 9144 // example, a 16K input buffer and a 64K output buffer, more than 95% of the 9145 // inflate execution time is spent in this routine. 9146 // 9147 // Entry assumptions: 9148 // 9149 // state->mode == LEN 9150 // strm->avail_in >= 6 9151 // strm->avail_out >= 258 9152 // start >= strm->avail_out 9153 // state->bits < 8 9154 // 9155 // On return, state->mode is one of: 9156 // 9157 // LEN -- ran out of enough output space or enough available input 9158 // TYPE -- reached end of block code, inflate() to interpret next block 9159 // BAD -- error in block data 9160 // 9161 // Notes: 9162 // 9163 // - The maximum input bits used by a length/distance pair is 15 bits for the 9164 // length code, 5 bits for the length extra, 15 bits for the distance code, 9165 // and 13 bits for the distance extra. This totals 48 bits, or six bytes. 9166 // Therefore if strm->avail_in >= 6, then there is enough input to avoid 9167 // checking for available input while decoding. 9168 // 9169 // - The maximum bytes that a single length/distance pair can output is 258 9170 // bytes, which is the maximum length that can be coded. inflate_fast() 9171 // requires strm->avail_out >= 258 for each loop to avoid checking for 9172 // output space. 9173 // 9174 func Xinflate_fast(tls *libc.TLS, strm Z_streamp, start uint32) { /* inffast.c:50:20: */ 9175 var state uintptr 9176 var in uintptr // local strm->next_in 9177 var last uintptr // have enough input while in < last 9178 var out uintptr // local strm->next_out 9179 var beg uintptr // inflate()'s initial strm->next_out 9180 var end uintptr // while out < end, enough space available 9181 var wsize uint32 // window size or zero if not using window 9182 var whave uint32 // valid bytes in the window 9183 var wnext uint32 // window write index 9184 var window uintptr // allocated sliding window, if wsize != 0 9185 var hold uint32 // local strm->hold 9186 var bits uint32 // local strm->bits 9187 var lcode uintptr // local strm->lencode 9188 var dcode uintptr // local strm->distcode 9189 var lmask uint32 // mask for first level of length codes 9190 var dmask uint32 // mask for first level of distance codes 9191 var here Code // retrieved table entry 9192 var op uint32 // code bits, operation, extra bits, or 9193 // window position, window bytes to copy 9194 var len uint32 // match length, unused bytes 9195 var dist uint32 // match distance 9196 var from uintptr // where to copy match from 9197 9198 // copy state to local variables 9199 state = (*Z_stream)(unsafe.Pointer(strm)).Fstate 9200 in = (*Z_stream)(unsafe.Pointer(strm)).Fnext_in 9201 last = (in + uintptr(((*Z_stream)(unsafe.Pointer(strm)).Favail_in - UInt(5)))) 9202 out = (*Z_stream)(unsafe.Pointer(strm)).Fnext_out 9203 beg = (out - uintptr((start - (*Z_stream)(unsafe.Pointer(strm)).Favail_out))) 9204 end = (out + uintptr(((*Z_stream)(unsafe.Pointer(strm)).Favail_out - UInt(257)))) 9205 wsize = (*Inflate_state)(unsafe.Pointer(state)).Fwsize 9206 whave = (*Inflate_state)(unsafe.Pointer(state)).Fwhave 9207 wnext = (*Inflate_state)(unsafe.Pointer(state)).Fwnext 9208 window = (*Inflate_state)(unsafe.Pointer(state)).Fwindow 9209 hold = (*Inflate_state)(unsafe.Pointer(state)).Fhold 9210 bits = (*Inflate_state)(unsafe.Pointer(state)).Fbits 9211 lcode = (*Inflate_state)(unsafe.Pointer(state)).Flencode 9212 dcode = (*Inflate_state)(unsafe.Pointer(state)).Fdistcode 9213 lmask = ((uint32(1) << (*Inflate_state)(unsafe.Pointer(state)).Flenbits) - uint32(1)) 9214 dmask = ((uint32(1) << (*Inflate_state)(unsafe.Pointer(state)).Fdistbits) - uint32(1)) 9215 9216 // decode literals and length/distances until end-of-block or not enough 9217 // input data or output space 9218 __1: 9219 if !(bits < uint32(15)) { 9220 goto __4 9221 } 9222 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&in, 1))))) << bits) 9223 bits = bits + (uint32(8)) 9224 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&in, 1))))) << bits) 9225 bits = bits + (uint32(8)) 9226 __4: 9227 ; 9228 here = *(*Code)(unsafe.Pointer(lcode + uintptr((hold&uint32(lmask)))*4)) 9229 dolen: 9230 op = uint32(here.Fbits) 9231 hold >>= op 9232 bits = bits - (op) 9233 op = uint32(here.Fop) 9234 if !(op == uint32(0)) { 9235 goto __5 9236 } // literal 9237 9238 *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = uint8(here.Fval) 9239 goto __6 9240 __5: 9241 if !((op & uint32(16)) != 0) { 9242 goto __7 9243 } // length base 9244 len = uint32(here.Fval) 9245 op = op & (uint32(15)) // number of extra bits 9246 if !(op != 0) { 9247 goto __9 9248 } 9249 if !(bits < op) { 9250 goto __10 9251 } 9252 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&in, 1))))) << bits) 9253 bits = bits + (uint32(8)) 9254 __10: 9255 ; 9256 len = len + (uint32(hold) & ((uint32(1) << op) - uint32(1))) 9257 hold >>= op 9258 bits = bits - (op) 9259 __9: 9260 ; 9261 9262 if !(bits < uint32(15)) { 9263 goto __11 9264 } 9265 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&in, 1))))) << bits) 9266 bits = bits + (uint32(8)) 9267 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&in, 1))))) << bits) 9268 bits = bits + (uint32(8)) 9269 __11: 9270 ; 9271 here = *(*Code)(unsafe.Pointer(dcode + uintptr((hold&uint32(dmask)))*4)) 9272 dodist: 9273 op = uint32(here.Fbits) 9274 hold >>= op 9275 bits = bits - (op) 9276 op = uint32(here.Fop) 9277 if !((op & uint32(16)) != 0) { 9278 goto __12 9279 } // distance base 9280 dist = uint32(here.Fval) 9281 op = op & (uint32(15)) // number of extra bits 9282 if !(bits < op) { 9283 goto __14 9284 } 9285 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&in, 1))))) << bits) 9286 bits = bits + (uint32(8)) 9287 if !(bits < op) { 9288 goto __15 9289 } 9290 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&in, 1))))) << bits) 9291 bits = bits + (uint32(8)) 9292 __15: 9293 ; 9294 __14: 9295 ; 9296 dist = dist + (uint32(hold) & ((uint32(1) << op) - uint32(1))) 9297 hold >>= op 9298 bits = bits - (op) 9299 9300 op = (uint32((int64(out) - int64(beg)) / 1)) // max distance in output 9301 if !(dist > op) { 9302 goto __16 9303 } // see if copy from window 9304 op = (dist - op) // distance back in window 9305 if !(op > whave) { 9306 goto __18 9307 } 9308 if !((*Inflate_state)(unsafe.Pointer(state)).Fsane != 0) { 9309 goto __19 9310 } 9311 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 639 /* "invalid distance..." */ 9312 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 9313 goto __3 9314 __19: 9315 ; 9316 __18: 9317 ; 9318 from = window 9319 if !(wnext == uint32(0)) { 9320 goto __20 9321 } // very common case 9322 from += (uintptr(wsize - op)) 9323 if !(op < len) { 9324 goto __22 9325 } // some from window 9326 len = len - (op) 9327 __23: 9328 *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1))) 9329 goto __24 9330 __24: 9331 if libc.PreDecUint32(&op, 1) != 0 { 9332 goto __23 9333 } 9334 goto __25 9335 __25: 9336 ; 9337 from = (out - uintptr(dist)) // rest from output 9338 __22: 9339 ; 9340 goto __21 9341 __20: 9342 if !(wnext < op) { 9343 goto __26 9344 } // wrap around window 9345 from += (uintptr((wsize + wnext) - op)) 9346 op = op - (wnext) 9347 if !(op < len) { 9348 goto __28 9349 } // some from end of window 9350 len = len - (op) 9351 __29: 9352 *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1))) 9353 goto __30 9354 __30: 9355 if libc.PreDecUint32(&op, 1) != 0 { 9356 goto __29 9357 } 9358 goto __31 9359 __31: 9360 ; 9361 from = window 9362 if !(wnext < len) { 9363 goto __32 9364 } // some from start of window 9365 op = wnext 9366 len = len - (op) 9367 __33: 9368 *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1))) 9369 goto __34 9370 __34: 9371 if libc.PreDecUint32(&op, 1) != 0 { 9372 goto __33 9373 } 9374 goto __35 9375 __35: 9376 ; 9377 from = (out - uintptr(dist)) // rest from output 9378 __32: 9379 ; 9380 __28: 9381 ; 9382 goto __27 9383 __26: // contiguous in window 9384 from += (uintptr(wnext - op)) 9385 if !(op < len) { 9386 goto __36 9387 } // some from window 9388 len = len - (op) 9389 __37: 9390 *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1))) 9391 goto __38 9392 __38: 9393 if libc.PreDecUint32(&op, 1) != 0 { 9394 goto __37 9395 } 9396 goto __39 9397 __39: 9398 ; 9399 from = (out - uintptr(dist)) // rest from output 9400 __36: 9401 ; 9402 __27: 9403 ; 9404 __21: 9405 ; 9406 __40: 9407 if !(len > uint32(2)) { 9408 goto __41 9409 } 9410 *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1))) 9411 *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1))) 9412 *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1))) 9413 len = len - (uint32(3)) 9414 goto __40 9415 __41: 9416 ; 9417 if !(len != 0) { 9418 goto __42 9419 } 9420 *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1))) 9421 if !(len > uint32(1)) { 9422 goto __43 9423 } 9424 *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1))) 9425 __43: 9426 ; 9427 __42: 9428 ; 9429 goto __17 9430 __16: 9431 from = (out - uintptr(dist)) // copy direct from output 9432 __44: // minimum length is three 9433 *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1))) 9434 *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1))) 9435 *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1))) 9436 len = len - (uint32(3)) 9437 goto __45 9438 __45: 9439 if len > uint32(2) { 9440 goto __44 9441 } 9442 goto __46 9443 __46: 9444 ; 9445 if !(len != 0) { 9446 goto __47 9447 } 9448 *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1))) 9449 if !(len > uint32(1)) { 9450 goto __48 9451 } 9452 *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&out, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1))) 9453 __48: 9454 ; 9455 __47: 9456 ; 9457 __17: 9458 ; 9459 goto __13 9460 __12: 9461 if !((op & uint32(64)) == uint32(0)) { 9462 goto __49 9463 } // 2nd level distance code 9464 here = *(*Code)(unsafe.Pointer(dcode + uintptr((uint32(here.Fval)+(hold&(uint32((uint32(1)<<op)-uint32(1))))))*4)) 9465 goto dodist 9466 goto __50 9467 __49: 9468 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 617 /* "invalid distance..." */ 9469 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 9470 goto __3 9471 __50: 9472 ; 9473 __13: 9474 ; 9475 goto __8 9476 __7: 9477 if !((op & uint32(64)) == uint32(0)) { 9478 goto __51 9479 } // 2nd level length code 9480 here = *(*Code)(unsafe.Pointer(lcode + uintptr((uint32(here.Fval)+(hold&(uint32((uint32(1)<<op)-uint32(1))))))*4)) 9481 goto dolen 9482 goto __52 9483 __51: 9484 if !((op & uint32(32)) != 0) { 9485 goto __53 9486 } // end-of-block 9487 9488 (*Inflate_state)(unsafe.Pointer(state)).Fmode = TYPE 9489 goto __3 9490 goto __54 9491 __53: 9492 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 589 /* "invalid literal/..." */ 9493 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 9494 goto __3 9495 __54: 9496 ; 9497 __52: 9498 ; 9499 __8: 9500 ; 9501 __6: 9502 ; 9503 goto __2 9504 __2: 9505 if (in < last) && (out < end) { 9506 goto __1 9507 } 9508 goto __3 9509 __3: 9510 ; 9511 9512 // return unused bytes (on entry, bits < 8, so in won't go too far back) 9513 len = (bits >> 3) 9514 in -= uintptr(len) 9515 bits = bits - (len << 3) 9516 hold = hold & (uint32((uint32(1) << bits) - uint32(1))) 9517 9518 // update state and return 9519 (*Z_stream)(unsafe.Pointer(strm)).Fnext_in = in 9520 (*Z_stream)(unsafe.Pointer(strm)).Fnext_out = out 9521 (*Z_stream)(unsafe.Pointer(strm)).Favail_in = func() uint32 { 9522 if in < last { 9523 return (uint32(int64(5) + ((int64(last) - int64(in)) / 1))) 9524 } 9525 return (uint32(int64(5) - ((int64(in) - int64(last)) / 1))) 9526 }() 9527 (*Z_stream)(unsafe.Pointer(strm)).Favail_out = func() uint32 { 9528 if out < end { 9529 return (uint32(int64(257) + ((int64(end) - int64(out)) / 1))) 9530 } 9531 return (uint32(int64(257) - ((int64(out) - int64(end)) / 1))) 9532 }() 9533 (*Inflate_state)(unsafe.Pointer(state)).Fhold = hold 9534 (*Inflate_state)(unsafe.Pointer(state)).Fbits = bits 9535 return 9536 } 9537 9538 // 9539 // inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe): 9540 // - Using bit fields for code structure 9541 // - Different op definition to avoid & for extra bits (do & for table bits) 9542 // - Three separate decoding do-loops for direct, window, and wnext == 0 9543 // - Special case for distance > 1 copies to do overlapped load and store copy 9544 // - Explicit branch predictions (based on measured branch probabilities) 9545 // - Deferring match copy and interspersed it with decoding subsequent codes 9546 // - Swapping literal/length else 9547 // - Swapping window/direct else 9548 // - Larger unrolled copy loops (three is about right) 9549 // - Moving len -= 3 statement into middle of loop 9550 // 9551 9552 func inflateStateCheck(tls *libc.TLS, strm Z_streamp) int32 { /* inflate.c:105:11: */ 9553 var state uintptr 9554 if ((strm == uintptr(Z_NULL)) || ((*Z_stream)(unsafe.Pointer(strm)).Fzalloc == uintptr(0))) || ((*Z_stream)(unsafe.Pointer(strm)).Fzfree == uintptr(0)) { 9555 return 1 9556 } 9557 state = (*Z_stream)(unsafe.Pointer(strm)).Fstate 9558 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) { 9559 return 1 9560 } 9561 return 0 9562 } 9563 9564 func XinflateResetKeep(tls *libc.TLS, strm Z_streamp) int32 { /* inflate.c:119:13: */ 9565 var state uintptr 9566 9567 if inflateStateCheck(tls, strm) != 0 { 9568 return -2 9569 } 9570 state = (*Z_stream)(unsafe.Pointer(strm)).Fstate 9571 (*Z_stream)(unsafe.Pointer(strm)).Ftotal_in = libc.AssignPtrUint32(strm+28 /* &.total_out */, libc.AssignPtrUint32(state+36 /* &.total */, uint32(0))) 9572 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = uintptr(Z_NULL) 9573 if (*Inflate_state)(unsafe.Pointer(state)).Fwrap != 0 { // to support ill-conceived Java test suite 9574 (*Z_stream)(unsafe.Pointer(strm)).Fadler = (ULong((*Inflate_state)(unsafe.Pointer(state)).Fwrap & 1)) 9575 } 9576 (*Inflate_state)(unsafe.Pointer(state)).Fmode = HEAD 9577 (*Inflate_state)(unsafe.Pointer(state)).Flast = 0 9578 (*Inflate_state)(unsafe.Pointer(state)).Fhavedict = 0 9579 (*Inflate_state)(unsafe.Pointer(state)).Fdmax = 32768 9580 (*Inflate_state)(unsafe.Pointer(state)).Fhead = Gz_headerp(Z_NULL) 9581 (*Inflate_state)(unsafe.Pointer(state)).Fhold = uint32(0) 9582 (*Inflate_state)(unsafe.Pointer(state)).Fbits = uint32(0) 9583 (*Inflate_state)(unsafe.Pointer(state)).Flencode = libc.AssignPtrUintptr(state+104 /* &.distcode */, libc.AssignPtrUintptr(state+136 /* &.next */, state+1360 /* &.codes */)) 9584 (*Inflate_state)(unsafe.Pointer(state)).Fsane = 1 9585 (*Inflate_state)(unsafe.Pointer(state)).Fback = -1 9586 9587 return Z_OK 9588 } 9589 9590 func XinflateReset(tls *libc.TLS, strm Z_streamp) int32 { /* inflate.c:144:13: */ 9591 var state uintptr 9592 9593 if inflateStateCheck(tls, strm) != 0 { 9594 return -2 9595 } 9596 state = (*Z_stream)(unsafe.Pointer(strm)).Fstate 9597 (*Inflate_state)(unsafe.Pointer(state)).Fwsize = uint32(0) 9598 (*Inflate_state)(unsafe.Pointer(state)).Fwhave = uint32(0) 9599 (*Inflate_state)(unsafe.Pointer(state)).Fwnext = uint32(0) 9600 return XinflateResetKeep(tls, strm) 9601 } 9602 9603 func XinflateReset2(tls *libc.TLS, strm Z_streamp, windowBits int32) int32 { /* inflate.c:157:13: */ 9604 var wrap int32 9605 var state uintptr 9606 9607 // get the state 9608 if inflateStateCheck(tls, strm) != 0 { 9609 return -2 9610 } 9611 state = (*Z_stream)(unsafe.Pointer(strm)).Fstate 9612 9613 // extract wrap request from windowBits parameter 9614 if windowBits < 0 { 9615 wrap = 0 9616 windowBits = -windowBits 9617 } else { 9618 wrap = ((windowBits >> 4) + 5) 9619 if windowBits < 48 { 9620 windowBits = windowBits & (15) 9621 } 9622 } 9623 9624 // set number of window bits, free window if different 9625 if (windowBits != 0) && ((windowBits < 8) || (windowBits > 15)) { 9626 return -2 9627 } 9628 if ((*Inflate_state)(unsafe.Pointer(state)).Fwindow != uintptr(Z_NULL)) && ((*Inflate_state)(unsafe.Pointer(state)).Fwbits != uint32(windowBits)) { 9629 (*struct { 9630 f func(*libc.TLS, Voidpf, Voidpf) 9631 })(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer((strm))).Fzfree})).f(tls, (*Z_stream)(unsafe.Pointer(strm)).Fopaque, (*Inflate_state)(unsafe.Pointer(state)).Fwindow) 9632 (*Inflate_state)(unsafe.Pointer(state)).Fwindow = uintptr(Z_NULL) 9633 } 9634 9635 // update state and reset the rest of it 9636 (*Inflate_state)(unsafe.Pointer(state)).Fwrap = wrap 9637 (*Inflate_state)(unsafe.Pointer(state)).Fwbits = uint32(windowBits) 9638 return XinflateReset(tls, strm) 9639 } 9640 9641 func XinflateInit2_(tls *libc.TLS, strm Z_streamp, windowBits int32, version uintptr, stream_size int32) int32 { /* inflate.c:195:13: */ 9642 var ret int32 9643 var state uintptr 9644 9645 if ((version == uintptr(Z_NULL)) || (int32(*(*int8)(unsafe.Pointer(version))) != int32(*(*int8)(unsafe.Pointer(ts /* "1.2.11" */))))) || (stream_size != (int32(unsafe.Sizeof(Z_stream{})))) { 9646 return -6 9647 } 9648 if strm == uintptr(Z_NULL) { 9649 return -2 9650 } 9651 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = uintptr(Z_NULL) // in case we return an error 9652 if (*Z_stream)(unsafe.Pointer(strm)).Fzalloc == uintptr(0) { 9653 (*Z_stream)(unsafe.Pointer(strm)).Fzalloc = *(*uintptr)(unsafe.Pointer(&struct { 9654 f func(*libc.TLS, Voidpf, uint32, uint32) Voidpf 9655 }{Xzcalloc})) 9656 (*Z_stream)(unsafe.Pointer(strm)).Fopaque = uintptr(0) 9657 } 9658 if (*Z_stream)(unsafe.Pointer(strm)).Fzfree == uintptr(0) { 9659 (*Z_stream)(unsafe.Pointer(strm)).Fzfree = *(*uintptr)(unsafe.Pointer(&struct { 9660 f func(*libc.TLS, Voidpf, Voidpf) 9661 }{Xzcfree})) 9662 } 9663 state = (*struct { 9664 f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf 9665 })(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{}))) 9666 if state == uintptr(Z_NULL) { 9667 return -4 9668 } 9669 9670 (*Z_stream)(unsafe.Pointer(strm)).Fstate = state 9671 (*Inflate_state)(unsafe.Pointer(state)).Fstrm = strm 9672 (*Inflate_state)(unsafe.Pointer(state)).Fwindow = uintptr(Z_NULL) 9673 (*Inflate_state)(unsafe.Pointer(state)).Fmode = HEAD // to pass state test in inflateReset2() 9674 ret = XinflateReset2(tls, strm, windowBits) 9675 if ret != Z_OK { 9676 (*struct { 9677 f func(*libc.TLS, Voidpf, Voidpf) 9678 })(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer((strm))).Fzfree})).f(tls, (*Z_stream)(unsafe.Pointer(strm)).Fopaque, state) 9679 (*Z_stream)(unsafe.Pointer(strm)).Fstate = uintptr(Z_NULL) 9680 } 9681 return ret 9682 } 9683 9684 func XinflateInit_(tls *libc.TLS, strm Z_streamp, version uintptr, stream_size int32) int32 { /* inflate.c:239:13: */ 9685 return XinflateInit2_(tls, strm, MAX_WBITS, version, stream_size) 9686 } 9687 9688 func XinflatePrime(tls *libc.TLS, strm Z_streamp, bits int32, value int32) int32 { /* inflate.c:247:13: */ 9689 var state uintptr 9690 9691 if inflateStateCheck(tls, strm) != 0 { 9692 return -2 9693 } 9694 state = (*Z_stream)(unsafe.Pointer(strm)).Fstate 9695 if bits < 0 { 9696 (*Inflate_state)(unsafe.Pointer(state)).Fhold = uint32(0) 9697 (*Inflate_state)(unsafe.Pointer(state)).Fbits = uint32(0) 9698 return Z_OK 9699 } 9700 if (bits > 16) || (((*Inflate_state)(unsafe.Pointer(state)).Fbits + UInt(bits)) > uint32(32)) { 9701 return -2 9702 } 9703 value = int32(int32(value) & ((int32(1) << bits) - 1)) 9704 *(*uint32)(unsafe.Pointer(state + 72 /* &.hold */)) += (uint32(uint32(value) << (*Inflate_state)(unsafe.Pointer(state)).Fbits)) 9705 *(*uint32)(unsafe.Pointer(state + 76 /* &.bits */)) += (UInt(bits)) 9706 return Z_OK 9707 } 9708 9709 // 9710 // Return state with length and distance decoding tables and index sizes set to 9711 // fixed code decoding. Normally this returns fixed tables from inffixed.h. 9712 // If BUILDFIXED is defined, then instead this routine builds the tables the 9713 // first time it's called, and returns those tables the first time and 9714 // thereafter. This reduces the size of the code by about 2K bytes, in 9715 // exchange for a little execution time. However, BUILDFIXED should not be 9716 // used for threaded applications, since the rewriting of the tables and virgin 9717 // may not be thread-safe. 9718 // 9719 func fixedtables1(tls *libc.TLS, state uintptr) { /* inflate.c:278:12: */ 9720 (*Inflate_state)(unsafe.Pointer(state)).Flencode = uintptr(unsafe.Pointer(&lenfix1)) 9721 (*Inflate_state)(unsafe.Pointer(state)).Flenbits = uint32(9) 9722 (*Inflate_state)(unsafe.Pointer(state)).Fdistcode = uintptr(unsafe.Pointer(&distfix1)) 9723 (*Inflate_state)(unsafe.Pointer(state)).Fdistbits = uint32(5) 9724 } 9725 9726 var lenfix1 = [512]Code{ 9727 {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)}, 9728 {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)}, 9729 {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)}, 9730 {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)}, 9731 {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)}, 9732 {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)}, 9733 {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)}, 9734 {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)}, 9735 {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)}, 9736 {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)}, 9737 {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)}, 9738 {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)}, 9739 {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)}, 9740 {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)}, 9741 {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)}, 9742 {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)}, 9743 {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)}, 9744 {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)}, 9745 {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)}, 9746 {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)}, 9747 {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)}, 9748 {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)}, 9749 {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)}, 9750 {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)}, 9751 {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)}, 9752 {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)}, 9753 {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)}, 9754 {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)}, 9755 {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)}, 9756 {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)}, 9757 {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)}, 9758 {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)}, 9759 {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)}, 9760 {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)}, 9761 {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)}, 9762 {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)}, 9763 {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)}, 9764 {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)}, 9765 {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)}, 9766 {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)}, 9767 {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)}, 9768 {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)}, 9769 {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)}, 9770 {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)}, 9771 {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)}, 9772 {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)}, 9773 {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)}, 9774 {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)}, 9775 {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)}, 9776 {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)}, 9777 {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)}, 9778 {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)}, 9779 {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)}, 9780 {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)}, 9781 {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)}, 9782 {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)}, 9783 {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)}, 9784 {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)}, 9785 {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)}, 9786 {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)}, 9787 {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)}, 9788 {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)}, 9789 {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)}, 9790 {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)}, 9791 {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)}, 9792 {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)}, 9793 {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)}, 9794 {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)}, 9795 {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)}, 9796 {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)}, 9797 {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)}, 9798 {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)}, 9799 {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)}, 9800 {Fbits: uint8(9), Fval: uint16(255)}, 9801 } /* inffixed.h:10:23 */ 9802 var distfix1 = [32]Code{ 9803 {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)}, 9804 {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)}, 9805 {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)}, 9806 {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)}, 9807 {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)}, 9808 {Fop: uint8(22), Fbits: uint8(5), Fval: uint16(193)}, {Fop: uint8(64), Fbits: uint8(5)}, 9809 } /* inffixed.h:87:23 */ 9810 9811 // 9812 // Update the window with the last wsize (normally 32K) bytes written before 9813 // returning. If window does not exist yet, create it. This is only called 9814 // when a window is already in use, or when output has been written during this 9815 // inflate call, but the end of the deflate stream has not been reached yet. 9816 // It is also called to create a window for dictionary data when a dictionary 9817 // is loaded. 9818 // 9819 // Providing output buffers larger than 32K to inflate() should provide a speed 9820 // advantage, since only the last 32K of output is copied to the sliding window 9821 // upon return from inflate(), and since all distances after the first 32K of 9822 // output will fall in the output data, making match copies simpler and faster. 9823 // The advantage may be dependent on the size of the processor's data caches. 9824 // 9825 func updatewindow(tls *libc.TLS, strm Z_streamp, end uintptr, copy uint32) int32 { /* inflate.c:396:11: */ 9826 var state uintptr 9827 var dist uint32 9828 9829 state = (*Z_stream)(unsafe.Pointer(strm)).Fstate 9830 9831 // if it hasn't been done already, allocate space for the window 9832 if (*Inflate_state)(unsafe.Pointer(state)).Fwindow == uintptr(Z_NULL) { 9833 (*Inflate_state)(unsafe.Pointer(state)).Fwindow = (*struct { 9834 f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf 9835 })(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)))) 9836 if (*Inflate_state)(unsafe.Pointer(state)).Fwindow == uintptr(Z_NULL) { 9837 return 1 9838 } 9839 } 9840 9841 // if window not in use yet, initialize 9842 if (*Inflate_state)(unsafe.Pointer(state)).Fwsize == uint32(0) { 9843 (*Inflate_state)(unsafe.Pointer(state)).Fwsize = (uint32(1) << (*Inflate_state)(unsafe.Pointer(state)).Fwbits) 9844 (*Inflate_state)(unsafe.Pointer(state)).Fwnext = uint32(0) 9845 (*Inflate_state)(unsafe.Pointer(state)).Fwhave = uint32(0) 9846 } 9847 9848 // copy state->wsize or less output bytes into the circular window 9849 if copy >= (*Inflate_state)(unsafe.Pointer(state)).Fwsize { 9850 libc.Xmemcpy(tls, (*Inflate_state)(unsafe.Pointer(state)).Fwindow, (end - uintptr((*Inflate_state)(unsafe.Pointer(state)).Fwsize)), uint64((*Inflate_state)(unsafe.Pointer(state)).Fwsize)) 9851 (*Inflate_state)(unsafe.Pointer(state)).Fwnext = uint32(0) 9852 (*Inflate_state)(unsafe.Pointer(state)).Fwhave = (*Inflate_state)(unsafe.Pointer(state)).Fwsize 9853 } else { 9854 dist = ((*Inflate_state)(unsafe.Pointer(state)).Fwsize - (*Inflate_state)(unsafe.Pointer(state)).Fwnext) 9855 if dist > copy { 9856 dist = copy 9857 } 9858 libc.Xmemcpy(tls, ((*Inflate_state)(unsafe.Pointer(state)).Fwindow + uintptr((*Inflate_state)(unsafe.Pointer(state)).Fwnext)), (end - uintptr(copy)), uint64(dist)) 9859 copy = copy - (dist) 9860 if copy != 0 { 9861 libc.Xmemcpy(tls, (*Inflate_state)(unsafe.Pointer(state)).Fwindow, (end - uintptr(copy)), uint64(copy)) 9862 (*Inflate_state)(unsafe.Pointer(state)).Fwnext = copy 9863 (*Inflate_state)(unsafe.Pointer(state)).Fwhave = (*Inflate_state)(unsafe.Pointer(state)).Fwsize 9864 } else { 9865 *(*uint32)(unsafe.Pointer(state + 60 /* &.wnext */)) += (dist) 9866 if (*Inflate_state)(unsafe.Pointer(state)).Fwnext == (*Inflate_state)(unsafe.Pointer(state)).Fwsize { 9867 (*Inflate_state)(unsafe.Pointer(state)).Fwnext = uint32(0) 9868 } 9869 if (*Inflate_state)(unsafe.Pointer(state)).Fwhave < (*Inflate_state)(unsafe.Pointer(state)).Fwsize { 9870 *(*uint32)(unsafe.Pointer(state + 56 /* &.whave */)) += (dist) 9871 } 9872 } 9873 } 9874 return 0 9875 } 9876 9877 // Macros for inflate(): 9878 9879 // check function to use adler32() for zlib or crc32() for gzip 9880 9881 // check macros for header crc 9882 9883 // Load registers with state in inflate() for speed 9884 9885 // Restore state from registers in inflate() 9886 9887 // Clear the input bit accumulator 9888 9889 // Get a byte of input into the bit accumulator, or return from inflate() 9890 // if there is no input available. 9891 9892 // Assure that there are at least n bits in the bit accumulator. If there is 9893 // not enough available input to do that, then return from inflate(). 9894 9895 // Return the low n bits of the bit accumulator (n < 16) 9896 9897 // Remove n bits from the bit accumulator 9898 9899 // Remove zero to seven bits as needed to go to a byte boundary 9900 9901 // 9902 // inflate() uses a state machine to process as much input data and generate as 9903 // much output data as possible before returning. The state machine is 9904 // structured roughly as follows: 9905 // 9906 // for (;;) switch (state) { 9907 // ... 9908 // case STATEn: 9909 // if (not enough input data or output space to make progress) 9910 // return; 9911 // ... make progress ... 9912 // state = STATEm; 9913 // break; 9914 // ... 9915 // } 9916 // 9917 // so when inflate() is called again, the same case is attempted again, and 9918 // if the appropriate resources are provided, the machine proceeds to the 9919 // next state. The NEEDBITS() macro is usually the way the state evaluates 9920 // whether it can proceed or should return. NEEDBITS() does the return if 9921 // the requested bits are not available. The typical use of the BITS macros 9922 // is: 9923 // 9924 // NEEDBITS(n); 9925 // ... do something with BITS(n) ... 9926 // DROPBITS(n); 9927 // 9928 // where NEEDBITS(n) either returns from inflate() if there isn't enough 9929 // input left to load n bits into the accumulator, or it continues. BITS(n) 9930 // gives the low n bits in the accumulator. When done, DROPBITS(n) drops 9931 // the low n bits off the accumulator. INITBITS() clears the accumulator 9932 // and sets the number of available bits to zero. BYTEBITS() discards just 9933 // enough bits to put the accumulator on a byte boundary. After BYTEBITS() 9934 // and a NEEDBITS(8), then BITS(8) would return the next byte in the stream. 9935 // 9936 // NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return 9937 // if there is no input available. The decoding of variable length codes uses 9938 // PULLBYTE() directly in order to pull just enough bytes to decode the next 9939 // code, and no more. 9940 // 9941 // Some states loop until they get enough input, making sure that enough 9942 // state information is maintained to continue the loop where it left off 9943 // if NEEDBITS() returns in the loop. For example, want, need, and keep 9944 // would all have to actually be part of the saved state in case NEEDBITS() 9945 // returns: 9946 // 9947 // case STATEw: 9948 // while (want < need) { 9949 // NEEDBITS(n); 9950 // keep[want++] = BITS(n); 9951 // DROPBITS(n); 9952 // } 9953 // state = STATEx; 9954 // case STATEx: 9955 // 9956 // As shown above, if the next state is also the next case, then the break 9957 // is omitted. 9958 // 9959 // A state may also return if there is not enough output space available to 9960 // complete that state. Those states are copying stored data, writing a 9961 // literal byte, and copying a matching string. 9962 // 9963 // When returning, a "goto inf_leave" is used to update the total counters, 9964 // update the check value, and determine whether any progress has been made 9965 // during that inflate() call in order to return the proper return code. 9966 // Progress is defined as a change in either strm->avail_in or strm->avail_out. 9967 // When there is a window, goto inf_leave will update the window with the last 9968 // output written. If a goto inf_leave occurs in the middle of decompression 9969 // and there is no window currently, goto inf_leave will create one and copy 9970 // output to the window for the next call of inflate(). 9971 // 9972 // In this implementation, the flush parameter of inflate() only affects the 9973 // return code (per zlib.h). inflate() always writes as much as possible to 9974 // strm->next_out, given the space available and the provided input--the effect 9975 // documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers 9976 // the allocation of and copying into a sliding window until necessary, which 9977 // provides the effect documented in zlib.h for Z_FINISH when the entire input 9978 // stream available. So the only thing the flush parameter actually does is: 9979 // when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it 9980 // will return Z_BUF_ERROR if it has not reached the end of the stream. 9981 // 9982 9983 func Xinflate(tls *libc.TLS, strm Z_streamp, flush int32) int32 { /* inflate.c:622:13: */ 9984 bp := tls.Alloc(4) 9985 defer tls.Free(4) 9986 9987 var state uintptr 9988 var next uintptr // next input 9989 var put uintptr // next output 9990 var have uint32 9991 var left uint32 // available input and output 9992 var hold uint32 // bit buffer 9993 var bits uint32 // bits in bit buffer 9994 var in uint32 9995 var out uint32 // save starting available input and output 9996 var copy uint32 // number of stored or match bytes to copy 9997 var from uintptr // where to copy match bytes from 9998 var here Code // current decoding table entry 9999 var last Code // parent table entry 10000 var len uint32 // length to copy for repeats, bits to drop 10001 var ret int32 // return code 10002 // var hbuf [4]uint8 at bp, 4 10003 10004 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)))) { 10005 goto __1 10006 } 10007 return -2 10008 __1: 10009 ; 10010 10011 state = (*Z_stream)(unsafe.Pointer(strm)).Fstate 10012 if !((*Inflate_state)(unsafe.Pointer(state)).Fmode == TYPE) { 10013 goto __2 10014 } 10015 (*Inflate_state)(unsafe.Pointer(state)).Fmode = TYPEDO 10016 __2: 10017 ; // skip check 10018 __3: 10019 put = (*Z_stream)(unsafe.Pointer(strm)).Fnext_out 10020 left = (*Z_stream)(unsafe.Pointer(strm)).Favail_out 10021 next = (*Z_stream)(unsafe.Pointer(strm)).Fnext_in 10022 have = (*Z_stream)(unsafe.Pointer(strm)).Favail_in 10023 hold = (*Inflate_state)(unsafe.Pointer(state)).Fhold 10024 bits = (*Inflate_state)(unsafe.Pointer(state)).Fbits 10025 goto __4 10026 __4: 10027 if 0 != 0 { 10028 goto __3 10029 } 10030 goto __5 10031 __5: 10032 ; 10033 in = have 10034 out = left 10035 ret = Z_OK 10036 __6: 10037 switch (*Inflate_state)(unsafe.Pointer(state)).Fmode { 10038 case HEAD: 10039 goto __10 10040 case FLAGS: 10041 goto __11 10042 case TIME: 10043 goto __12 10044 case OS: 10045 goto __13 10046 case EXLEN: 10047 goto __14 10048 case EXTRA: 10049 goto __15 10050 case NAME: 10051 goto __16 10052 case COMMENT: 10053 goto __17 10054 case HCRC: 10055 goto __18 10056 case DICTID: 10057 goto __19 10058 case DICT: 10059 goto __20 10060 case TYPE: 10061 goto __21 10062 case TYPEDO: 10063 goto __22 10064 case STORED: 10065 goto __23 10066 case COPY_: 10067 goto __24 10068 case COPY: 10069 goto __25 10070 case TABLE: 10071 goto __26 10072 case LENLENS: 10073 goto __27 10074 case CODELENS: 10075 goto __28 10076 case LEN_: 10077 goto __29 10078 case LEN: 10079 goto __30 10080 case LENEXT: 10081 goto __31 10082 case DIST: 10083 goto __32 10084 case DISTEXT: 10085 goto __33 10086 case MATCH: 10087 goto __34 10088 case LIT: 10089 goto __35 10090 case CHECK: 10091 goto __36 10092 case LENGTH: 10093 goto __37 10094 case DONE: 10095 goto __38 10096 case BAD: 10097 goto __39 10098 case MEM: 10099 goto __40 10100 case SYNC: 10101 goto __41 10102 default: 10103 goto __42 10104 } 10105 goto __9 10106 __10: 10107 if !((*Inflate_state)(unsafe.Pointer(state)).Fwrap == 0) { 10108 goto __43 10109 } 10110 (*Inflate_state)(unsafe.Pointer(state)).Fmode = TYPEDO 10111 goto __9 10112 __43: 10113 ; 10114 __44: 10115 __47: 10116 if !(bits < (uint32(16))) { 10117 goto __48 10118 } 10119 __49: 10120 if !(have == uint32(0)) { 10121 goto __52 10122 } 10123 goto inf_leave 10124 __52: 10125 ; 10126 have-- 10127 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))) << bits) 10128 bits = bits + (uint32(8)) 10129 goto __50 10130 __50: 10131 if 0 != 0 { 10132 goto __49 10133 } 10134 goto __51 10135 __51: 10136 ; 10137 goto __47 10138 __48: 10139 ; 10140 goto __45 10141 __45: 10142 if 0 != 0 { 10143 goto __44 10144 } 10145 goto __46 10146 __46: 10147 ; 10148 if !((((*Inflate_state)(unsafe.Pointer(state)).Fwrap & 2) != 0) && (hold == uint32(0x8b1f))) { 10149 goto __53 10150 } // gzip header 10151 if !((*Inflate_state)(unsafe.Pointer(state)).Fwbits == uint32(0)) { 10152 goto __54 10153 } 10154 (*Inflate_state)(unsafe.Pointer(state)).Fwbits = uint32(15) 10155 __54: 10156 ; 10157 (*Inflate_state)(unsafe.Pointer(state)).Fcheck = Xcrc32(tls, uint32(0), uintptr(Z_NULL), uint32(0)) 10158 __55: 10159 *(*uint8)(unsafe.Pointer(bp /* &hbuf[0] */)) = uint8(hold) 10160 *(*uint8)(unsafe.Pointer(bp /* &hbuf[0] */ + 1)) = (uint8((hold) >> 8)) 10161 (*Inflate_state)(unsafe.Pointer(state)).Fcheck = Xcrc32(tls, (*Inflate_state)(unsafe.Pointer(state)).Fcheck, bp /* &hbuf[0] */, uint32(2)) 10162 goto __56 10163 __56: 10164 if 0 != 0 { 10165 goto __55 10166 } 10167 goto __57 10168 __57: 10169 ; 10170 __58: 10171 hold = uint32(0) 10172 bits = uint32(0) 10173 goto __59 10174 __59: 10175 if 0 != 0 { 10176 goto __58 10177 } 10178 goto __60 10179 __60: 10180 ; 10181 (*Inflate_state)(unsafe.Pointer(state)).Fmode = FLAGS 10182 goto __9 10183 __53: 10184 ; 10185 (*Inflate_state)(unsafe.Pointer(state)).Fflags = 0 // expect zlib header 10186 if !((*Inflate_state)(unsafe.Pointer(state)).Fhead != uintptr(Z_NULL)) { 10187 goto __61 10188 } 10189 (*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fdone = -1 10190 __61: 10191 ; 10192 if !(!(((*Inflate_state)(unsafe.Pointer(state)).Fwrap & 1) != 0) || ((((uint32((uint32(hold) & ((uint32(1) << (8)) - uint32(1))) << 8)) + (hold >> 8)) % uint32(31)) != 0)) { 10193 goto __62 10194 } 10195 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 669 /* "incorrect header..." */ 10196 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 10197 goto __9 10198 __62: 10199 ; 10200 if !((uint32(hold) & ((uint32(1) << (4)) - uint32(1))) != uint32(Z_DEFLATED)) { 10201 goto __63 10202 } 10203 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 692 /* "unknown compress..." */ 10204 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 10205 goto __9 10206 __63: 10207 ; 10208 __64: 10209 hold >>= 4 10210 bits = bits - (uint32(4)) 10211 goto __65 10212 __65: 10213 if 0 != 0 { 10214 goto __64 10215 } 10216 goto __66 10217 __66: 10218 ; 10219 len = ((uint32(hold) & ((uint32(1) << (4)) - uint32(1))) + uint32(8)) 10220 if !((*Inflate_state)(unsafe.Pointer(state)).Fwbits == uint32(0)) { 10221 goto __67 10222 } 10223 (*Inflate_state)(unsafe.Pointer(state)).Fwbits = len 10224 __67: 10225 ; 10226 if !((len > uint32(15)) || (len > (*Inflate_state)(unsafe.Pointer(state)).Fwbits)) { 10227 goto __68 10228 } 10229 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 719 /* "invalid window s..." */ 10230 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 10231 goto __9 10232 __68: 10233 ; 10234 (*Inflate_state)(unsafe.Pointer(state)).Fdmax = (uint32(1) << len) 10235 10236 (*Z_stream)(unsafe.Pointer(strm)).Fadler = libc.AssignPtrUint32(state+32 /* &.check */, Xadler32(tls, uint32(0), uintptr(Z_NULL), uint32(0))) 10237 (*Inflate_state)(unsafe.Pointer(state)).Fmode = func() uint32 { 10238 if (hold & uint32(0x200)) != 0 { 10239 return DICTID 10240 } 10241 return TYPE 10242 }() 10243 __69: 10244 hold = uint32(0) 10245 bits = uint32(0) 10246 goto __70 10247 __70: 10248 if 0 != 0 { 10249 goto __69 10250 } 10251 goto __71 10252 __71: 10253 ; 10254 goto __9 10255 __11: 10256 __72: 10257 __75: 10258 if !(bits < (uint32(16))) { 10259 goto __76 10260 } 10261 __77: 10262 if !(have == uint32(0)) { 10263 goto __80 10264 } 10265 goto inf_leave 10266 __80: 10267 ; 10268 have-- 10269 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))) << bits) 10270 bits = bits + (uint32(8)) 10271 goto __78 10272 __78: 10273 if 0 != 0 { 10274 goto __77 10275 } 10276 goto __79 10277 __79: 10278 ; 10279 goto __75 10280 __76: 10281 ; 10282 goto __73 10283 __73: 10284 if 0 != 0 { 10285 goto __72 10286 } 10287 goto __74 10288 __74: 10289 ; 10290 (*Inflate_state)(unsafe.Pointer(state)).Fflags = int32(hold) 10291 if !(((*Inflate_state)(unsafe.Pointer(state)).Fflags & 0xff) != Z_DEFLATED) { 10292 goto __81 10293 } 10294 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 692 /* "unknown compress..." */ 10295 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 10296 goto __9 10297 __81: 10298 ; 10299 if !(((*Inflate_state)(unsafe.Pointer(state)).Fflags & 0xe000) != 0) { 10300 goto __82 10301 } 10302 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 739 /* "unknown header f..." */ 10303 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 10304 goto __9 10305 __82: 10306 ; 10307 if !((*Inflate_state)(unsafe.Pointer(state)).Fhead != uintptr(Z_NULL)) { 10308 goto __83 10309 } 10310 (*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Ftext = (int32((hold >> 8) & uint32(1))) 10311 __83: 10312 ; 10313 if !((((*Inflate_state)(unsafe.Pointer(state)).Fflags & 0x0200) != 0) && (((*Inflate_state)(unsafe.Pointer(state)).Fwrap & 4) != 0)) { 10314 goto __84 10315 } 10316 __85: 10317 *(*uint8)(unsafe.Pointer(bp /* &hbuf[0] */)) = uint8(hold) 10318 *(*uint8)(unsafe.Pointer(bp /* &hbuf[0] */ + 1)) = (uint8((hold) >> 8)) 10319 (*Inflate_state)(unsafe.Pointer(state)).Fcheck = Xcrc32(tls, (*Inflate_state)(unsafe.Pointer(state)).Fcheck, bp /* &hbuf[0] */, uint32(2)) 10320 goto __86 10321 __86: 10322 if 0 != 0 { 10323 goto __85 10324 } 10325 goto __87 10326 __87: 10327 ; 10328 __84: 10329 ; 10330 __88: 10331 hold = uint32(0) 10332 bits = uint32(0) 10333 goto __89 10334 __89: 10335 if 0 != 0 { 10336 goto __88 10337 } 10338 goto __90 10339 __90: 10340 ; 10341 (*Inflate_state)(unsafe.Pointer(state)).Fmode = TIME 10342 __12: 10343 __91: 10344 __94: 10345 if !(bits < (uint32(32))) { 10346 goto __95 10347 } 10348 __96: 10349 if !(have == uint32(0)) { 10350 goto __99 10351 } 10352 goto inf_leave 10353 __99: 10354 ; 10355 have-- 10356 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))) << bits) 10357 bits = bits + (uint32(8)) 10358 goto __97 10359 __97: 10360 if 0 != 0 { 10361 goto __96 10362 } 10363 goto __98 10364 __98: 10365 ; 10366 goto __94 10367 __95: 10368 ; 10369 goto __92 10370 __92: 10371 if 0 != 0 { 10372 goto __91 10373 } 10374 goto __93 10375 __93: 10376 ; 10377 if !((*Inflate_state)(unsafe.Pointer(state)).Fhead != uintptr(Z_NULL)) { 10378 goto __100 10379 } 10380 (*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Ftime = hold 10381 __100: 10382 ; 10383 if !((((*Inflate_state)(unsafe.Pointer(state)).Fflags & 0x0200) != 0) && (((*Inflate_state)(unsafe.Pointer(state)).Fwrap & 4) != 0)) { 10384 goto __101 10385 } 10386 __102: 10387 *(*uint8)(unsafe.Pointer(bp /* &hbuf[0] */)) = uint8(hold) 10388 *(*uint8)(unsafe.Pointer(bp /* &hbuf[0] */ + 1)) = (uint8((hold) >> 8)) 10389 *(*uint8)(unsafe.Pointer(bp /* &hbuf[0] */ + 2)) = (uint8((hold) >> 16)) 10390 *(*uint8)(unsafe.Pointer(bp /* &hbuf[0] */ + 3)) = (uint8((hold) >> 24)) 10391 (*Inflate_state)(unsafe.Pointer(state)).Fcheck = Xcrc32(tls, (*Inflate_state)(unsafe.Pointer(state)).Fcheck, bp /* &hbuf[0] */, uint32(4)) 10392 goto __103 10393 __103: 10394 if 0 != 0 { 10395 goto __102 10396 } 10397 goto __104 10398 __104: 10399 ; 10400 __101: 10401 ; 10402 __105: 10403 hold = uint32(0) 10404 bits = uint32(0) 10405 goto __106 10406 __106: 10407 if 0 != 0 { 10408 goto __105 10409 } 10410 goto __107 10411 __107: 10412 ; 10413 (*Inflate_state)(unsafe.Pointer(state)).Fmode = OS 10414 __13: 10415 __108: 10416 __111: 10417 if !(bits < (uint32(16))) { 10418 goto __112 10419 } 10420 __113: 10421 if !(have == uint32(0)) { 10422 goto __116 10423 } 10424 goto inf_leave 10425 __116: 10426 ; 10427 have-- 10428 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))) << bits) 10429 bits = bits + (uint32(8)) 10430 goto __114 10431 __114: 10432 if 0 != 0 { 10433 goto __113 10434 } 10435 goto __115 10436 __115: 10437 ; 10438 goto __111 10439 __112: 10440 ; 10441 goto __109 10442 __109: 10443 if 0 != 0 { 10444 goto __108 10445 } 10446 goto __110 10447 __110: 10448 ; 10449 if !((*Inflate_state)(unsafe.Pointer(state)).Fhead != uintptr(Z_NULL)) { 10450 goto __117 10451 } 10452 (*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fxflags = (int32(hold & uint32(0xff))) 10453 (*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fos = (int32(hold >> 8)) 10454 __117: 10455 ; 10456 if !((((*Inflate_state)(unsafe.Pointer(state)).Fflags & 0x0200) != 0) && (((*Inflate_state)(unsafe.Pointer(state)).Fwrap & 4) != 0)) { 10457 goto __118 10458 } 10459 __119: 10460 *(*uint8)(unsafe.Pointer(bp /* &hbuf[0] */)) = uint8(hold) 10461 *(*uint8)(unsafe.Pointer(bp /* &hbuf[0] */ + 1)) = (uint8((hold) >> 8)) 10462 (*Inflate_state)(unsafe.Pointer(state)).Fcheck = Xcrc32(tls, (*Inflate_state)(unsafe.Pointer(state)).Fcheck, bp /* &hbuf[0] */, uint32(2)) 10463 goto __120 10464 __120: 10465 if 0 != 0 { 10466 goto __119 10467 } 10468 goto __121 10469 __121: 10470 ; 10471 __118: 10472 ; 10473 __122: 10474 hold = uint32(0) 10475 bits = uint32(0) 10476 goto __123 10477 __123: 10478 if 0 != 0 { 10479 goto __122 10480 } 10481 goto __124 10482 __124: 10483 ; 10484 (*Inflate_state)(unsafe.Pointer(state)).Fmode = EXLEN 10485 __14: 10486 if !(((*Inflate_state)(unsafe.Pointer(state)).Fflags & 0x0400) != 0) { 10487 goto __125 10488 } 10489 __127: 10490 __130: 10491 if !(bits < (uint32(16))) { 10492 goto __131 10493 } 10494 __132: 10495 if !(have == uint32(0)) { 10496 goto __135 10497 } 10498 goto inf_leave 10499 __135: 10500 ; 10501 have-- 10502 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))) << bits) 10503 bits = bits + (uint32(8)) 10504 goto __133 10505 __133: 10506 if 0 != 0 { 10507 goto __132 10508 } 10509 goto __134 10510 __134: 10511 ; 10512 goto __130 10513 __131: 10514 ; 10515 goto __128 10516 __128: 10517 if 0 != 0 { 10518 goto __127 10519 } 10520 goto __129 10521 __129: 10522 ; 10523 (*Inflate_state)(unsafe.Pointer(state)).Flength = uint32(hold) 10524 if !((*Inflate_state)(unsafe.Pointer(state)).Fhead != uintptr(Z_NULL)) { 10525 goto __136 10526 } 10527 (*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fextra_len = uint32(hold) 10528 __136: 10529 ; 10530 if !((((*Inflate_state)(unsafe.Pointer(state)).Fflags & 0x0200) != 0) && (((*Inflate_state)(unsafe.Pointer(state)).Fwrap & 4) != 0)) { 10531 goto __137 10532 } 10533 __138: 10534 *(*uint8)(unsafe.Pointer(bp /* &hbuf[0] */)) = uint8(hold) 10535 *(*uint8)(unsafe.Pointer(bp /* &hbuf[0] */ + 1)) = (uint8((hold) >> 8)) 10536 (*Inflate_state)(unsafe.Pointer(state)).Fcheck = Xcrc32(tls, (*Inflate_state)(unsafe.Pointer(state)).Fcheck, bp /* &hbuf[0] */, uint32(2)) 10537 goto __139 10538 __139: 10539 if 0 != 0 { 10540 goto __138 10541 } 10542 goto __140 10543 __140: 10544 ; 10545 __137: 10546 ; 10547 __141: 10548 hold = uint32(0) 10549 bits = uint32(0) 10550 goto __142 10551 __142: 10552 if 0 != 0 { 10553 goto __141 10554 } 10555 goto __143 10556 __143: 10557 ; 10558 goto __126 10559 __125: 10560 if !((*Inflate_state)(unsafe.Pointer(state)).Fhead != uintptr(Z_NULL)) { 10561 goto __144 10562 } 10563 (*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fextra = uintptr(Z_NULL) 10564 __144: 10565 ; 10566 __126: 10567 ; 10568 (*Inflate_state)(unsafe.Pointer(state)).Fmode = EXTRA 10569 __15: 10570 if !(((*Inflate_state)(unsafe.Pointer(state)).Fflags & 0x0400) != 0) { 10571 goto __145 10572 } 10573 copy = (*Inflate_state)(unsafe.Pointer(state)).Flength 10574 if !(copy > have) { 10575 goto __146 10576 } 10577 copy = have 10578 __146: 10579 ; 10580 if !(copy != 0) { 10581 goto __147 10582 } 10583 if !(((*Inflate_state)(unsafe.Pointer(state)).Fhead != uintptr(Z_NULL)) && ((*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fextra != uintptr(Z_NULL))) { 10584 goto __148 10585 } 10586 len = ((*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fextra_len - (*Inflate_state)(unsafe.Pointer(state)).Flength) 10587 libc.Xmemcpy(tls, ((*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fextra + uintptr(len)), next, 10588 func() uint64 { 10589 if (len + copy) > (*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fextra_max { 10590 return (uint64((*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fextra_max - len)) 10591 } 10592 return uint64(copy) 10593 }()) 10594 __148: 10595 ; 10596 if !((((*Inflate_state)(unsafe.Pointer(state)).Fflags & 0x0200) != 0) && (((*Inflate_state)(unsafe.Pointer(state)).Fwrap & 4) != 0)) { 10597 goto __149 10598 } 10599 (*Inflate_state)(unsafe.Pointer(state)).Fcheck = Xcrc32(tls, (*Inflate_state)(unsafe.Pointer(state)).Fcheck, next, copy) 10600 __149: 10601 ; 10602 have = have - (copy) 10603 next += uintptr(copy) 10604 *(*uint32)(unsafe.Pointer(state + 80 /* &.length */)) -= (copy) 10605 __147: 10606 ; 10607 if !((*Inflate_state)(unsafe.Pointer(state)).Flength != 0) { 10608 goto __150 10609 } 10610 goto inf_leave 10611 __150: 10612 ; 10613 __145: 10614 ; 10615 (*Inflate_state)(unsafe.Pointer(state)).Flength = uint32(0) 10616 (*Inflate_state)(unsafe.Pointer(state)).Fmode = NAME 10617 __16: 10618 if !(((*Inflate_state)(unsafe.Pointer(state)).Fflags & 0x0800) != 0) { 10619 goto __151 10620 } 10621 if !(have == uint32(0)) { 10622 goto __153 10623 } 10624 goto inf_leave 10625 __153: 10626 ; 10627 copy = uint32(0) 10628 __154: 10629 len = uint32(*(*uint8)(unsafe.Pointer(next + uintptr(libc.PostIncUint32(©, 1))))) 10630 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)) { 10631 goto __157 10632 } 10633 *(*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) 10634 __157: 10635 ; 10636 goto __155 10637 __155: 10638 if (len != 0) && (copy < have) { 10639 goto __154 10640 } 10641 goto __156 10642 __156: 10643 ; 10644 if !((((*Inflate_state)(unsafe.Pointer(state)).Fflags & 0x0200) != 0) && (((*Inflate_state)(unsafe.Pointer(state)).Fwrap & 4) != 0)) { 10645 goto __158 10646 } 10647 (*Inflate_state)(unsafe.Pointer(state)).Fcheck = Xcrc32(tls, (*Inflate_state)(unsafe.Pointer(state)).Fcheck, next, copy) 10648 __158: 10649 ; 10650 have = have - (copy) 10651 next += uintptr(copy) 10652 if !(len != 0) { 10653 goto __159 10654 } 10655 goto inf_leave 10656 __159: 10657 ; 10658 goto __152 10659 __151: 10660 if !((*Inflate_state)(unsafe.Pointer(state)).Fhead != uintptr(Z_NULL)) { 10661 goto __160 10662 } 10663 (*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fname = uintptr(Z_NULL) 10664 __160: 10665 ; 10666 __152: 10667 ; 10668 (*Inflate_state)(unsafe.Pointer(state)).Flength = uint32(0) 10669 (*Inflate_state)(unsafe.Pointer(state)).Fmode = COMMENT 10670 __17: 10671 if !(((*Inflate_state)(unsafe.Pointer(state)).Fflags & 0x1000) != 0) { 10672 goto __161 10673 } 10674 if !(have == uint32(0)) { 10675 goto __163 10676 } 10677 goto inf_leave 10678 __163: 10679 ; 10680 copy = uint32(0) 10681 __164: 10682 len = uint32(*(*uint8)(unsafe.Pointer(next + uintptr(libc.PostIncUint32(©, 1))))) 10683 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)) { 10684 goto __167 10685 } 10686 *(*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) 10687 __167: 10688 ; 10689 goto __165 10690 __165: 10691 if (len != 0) && (copy < have) { 10692 goto __164 10693 } 10694 goto __166 10695 __166: 10696 ; 10697 if !((((*Inflate_state)(unsafe.Pointer(state)).Fflags & 0x0200) != 0) && (((*Inflate_state)(unsafe.Pointer(state)).Fwrap & 4) != 0)) { 10698 goto __168 10699 } 10700 (*Inflate_state)(unsafe.Pointer(state)).Fcheck = Xcrc32(tls, (*Inflate_state)(unsafe.Pointer(state)).Fcheck, next, copy) 10701 __168: 10702 ; 10703 have = have - (copy) 10704 next += uintptr(copy) 10705 if !(len != 0) { 10706 goto __169 10707 } 10708 goto inf_leave 10709 __169: 10710 ; 10711 goto __162 10712 __161: 10713 if !((*Inflate_state)(unsafe.Pointer(state)).Fhead != uintptr(Z_NULL)) { 10714 goto __170 10715 } 10716 (*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fcomment = uintptr(Z_NULL) 10717 __170: 10718 ; 10719 __162: 10720 ; 10721 (*Inflate_state)(unsafe.Pointer(state)).Fmode = HCRC 10722 __18: 10723 if !(((*Inflate_state)(unsafe.Pointer(state)).Fflags & 0x0200) != 0) { 10724 goto __171 10725 } 10726 __172: 10727 __175: 10728 if !(bits < (uint32(16))) { 10729 goto __176 10730 } 10731 __177: 10732 if !(have == uint32(0)) { 10733 goto __180 10734 } 10735 goto inf_leave 10736 __180: 10737 ; 10738 have-- 10739 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))) << bits) 10740 bits = bits + (uint32(8)) 10741 goto __178 10742 __178: 10743 if 0 != 0 { 10744 goto __177 10745 } 10746 goto __179 10747 __179: 10748 ; 10749 goto __175 10750 __176: 10751 ; 10752 goto __173 10753 __173: 10754 if 0 != 0 { 10755 goto __172 10756 } 10757 goto __174 10758 __174: 10759 ; 10760 if !((((*Inflate_state)(unsafe.Pointer(state)).Fwrap & 4) != 0) && (hold != ((*Inflate_state)(unsafe.Pointer(state)).Fcheck & uint32(0xffff)))) { 10761 goto __181 10762 } 10763 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 764 /* "header crc misma..." */ 10764 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 10765 goto __9 10766 __181: 10767 ; 10768 __182: 10769 hold = uint32(0) 10770 bits = uint32(0) 10771 goto __183 10772 __183: 10773 if 0 != 0 { 10774 goto __182 10775 } 10776 goto __184 10777 __184: 10778 ; 10779 __171: 10780 ; 10781 if !((*Inflate_state)(unsafe.Pointer(state)).Fhead != uintptr(Z_NULL)) { 10782 goto __185 10783 } 10784 (*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fhcrc = (((*Inflate_state)(unsafe.Pointer(state)).Fflags >> 9) & 1) 10785 (*Gz_header)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fhead)).Fdone = 1 10786 __185: 10787 ; 10788 (*Z_stream)(unsafe.Pointer(strm)).Fadler = libc.AssignPtrUint32(state+32 /* &.check */, Xcrc32(tls, uint32(0), uintptr(Z_NULL), uint32(0))) 10789 (*Inflate_state)(unsafe.Pointer(state)).Fmode = TYPE 10790 goto __9 10791 __19: 10792 __186: 10793 __189: 10794 if !(bits < (uint32(32))) { 10795 goto __190 10796 } 10797 __191: 10798 if !(have == uint32(0)) { 10799 goto __194 10800 } 10801 goto inf_leave 10802 __194: 10803 ; 10804 have-- 10805 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))) << bits) 10806 bits = bits + (uint32(8)) 10807 goto __192 10808 __192: 10809 if 0 != 0 { 10810 goto __191 10811 } 10812 goto __193 10813 __193: 10814 ; 10815 goto __189 10816 __190: 10817 ; 10818 goto __187 10819 __187: 10820 if 0 != 0 { 10821 goto __186 10822 } 10823 goto __188 10824 __188: 10825 ; 10826 (*Z_stream)(unsafe.Pointer(strm)).Fadler = libc.AssignPtrUint32(state+32 /* &.check */, ((((((hold) >> 24) & uint32(0xff)) + (((hold) >> 8) & uint32(0xff00))) + (((hold) & uint32(0xff00)) << 8)) + (((hold) & uint32(0xff)) << 24))) 10827 __195: 10828 hold = uint32(0) 10829 bits = uint32(0) 10830 goto __196 10831 __196: 10832 if 0 != 0 { 10833 goto __195 10834 } 10835 goto __197 10836 __197: 10837 ; 10838 (*Inflate_state)(unsafe.Pointer(state)).Fmode = DICT 10839 __20: 10840 if !((*Inflate_state)(unsafe.Pointer(state)).Fhavedict == 0) { 10841 goto __198 10842 } 10843 __199: 10844 (*Z_stream)(unsafe.Pointer(strm)).Fnext_out = put 10845 (*Z_stream)(unsafe.Pointer(strm)).Favail_out = left 10846 (*Z_stream)(unsafe.Pointer(strm)).Fnext_in = next 10847 (*Z_stream)(unsafe.Pointer(strm)).Favail_in = have 10848 (*Inflate_state)(unsafe.Pointer(state)).Fhold = hold 10849 (*Inflate_state)(unsafe.Pointer(state)).Fbits = bits 10850 goto __200 10851 __200: 10852 if 0 != 0 { 10853 goto __199 10854 } 10855 goto __201 10856 __201: 10857 ; 10858 return Z_NEED_DICT 10859 __198: 10860 ; 10861 (*Z_stream)(unsafe.Pointer(strm)).Fadler = libc.AssignPtrUint32(state+32 /* &.check */, Xadler32(tls, uint32(0), uintptr(Z_NULL), uint32(0))) 10862 (*Inflate_state)(unsafe.Pointer(state)).Fmode = TYPE 10863 __21: 10864 if !((flush == Z_BLOCK) || (flush == Z_TREES)) { 10865 goto __202 10866 } 10867 goto inf_leave 10868 __202: 10869 ; 10870 __22: 10871 if !((*Inflate_state)(unsafe.Pointer(state)).Flast != 0) { 10872 goto __203 10873 } 10874 __204: 10875 hold >>= (bits & uint32(7)) 10876 bits = bits - (bits & uint32(7)) 10877 goto __205 10878 __205: 10879 if 0 != 0 { 10880 goto __204 10881 } 10882 goto __206 10883 __206: 10884 ; 10885 (*Inflate_state)(unsafe.Pointer(state)).Fmode = CHECK 10886 goto __9 10887 __203: 10888 ; 10889 __207: 10890 __210: 10891 if !(bits < (uint32(3))) { 10892 goto __211 10893 } 10894 __212: 10895 if !(have == uint32(0)) { 10896 goto __215 10897 } 10898 goto inf_leave 10899 __215: 10900 ; 10901 have-- 10902 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))) << bits) 10903 bits = bits + (uint32(8)) 10904 goto __213 10905 __213: 10906 if 0 != 0 { 10907 goto __212 10908 } 10909 goto __214 10910 __214: 10911 ; 10912 goto __210 10913 __211: 10914 ; 10915 goto __208 10916 __208: 10917 if 0 != 0 { 10918 goto __207 10919 } 10920 goto __209 10921 __209: 10922 ; 10923 (*Inflate_state)(unsafe.Pointer(state)).Flast = (int32(uint32(hold) & ((uint32(1) << (1)) - uint32(1)))) 10924 __216: 10925 hold >>= 1 10926 bits = bits - (uint32(1)) 10927 goto __217 10928 __217: 10929 if 0 != 0 { 10930 goto __216 10931 } 10932 goto __218 10933 __218: 10934 ; 10935 switch uint32(hold) & ((uint32(1) << (2)) - uint32(1)) { 10936 case uint32(0): 10937 goto __220 10938 case uint32(1): 10939 goto __221 10940 case uint32(2): 10941 goto __222 10942 case uint32(3): 10943 goto __223 10944 } 10945 goto __219 10946 __220: // stored block 10947 ; 10948 (*Inflate_state)(unsafe.Pointer(state)).Fmode = STORED 10949 goto __219 10950 __221: // fixed block 10951 fixedtables1(tls, state) 10952 10953 (*Inflate_state)(unsafe.Pointer(state)).Fmode = LEN_ // decode codes 10954 if !(flush == Z_TREES) { 10955 goto __224 10956 } 10957 __225: 10958 hold >>= 2 10959 bits = bits - (uint32(2)) 10960 goto __226 10961 __226: 10962 if 0 != 0 { 10963 goto __225 10964 } 10965 goto __227 10966 __227: 10967 ; 10968 goto inf_leave 10969 __224: 10970 ; 10971 goto __219 10972 __222: // dynamic block 10973 ; 10974 (*Inflate_state)(unsafe.Pointer(state)).Fmode = TABLE 10975 goto __219 10976 __223: 10977 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 367 /* "invalid block ty..." */ 10978 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 10979 __219: 10980 ; 10981 __228: 10982 hold >>= 2 10983 bits = bits - (uint32(2)) 10984 goto __229 10985 __229: 10986 if 0 != 0 { 10987 goto __228 10988 } 10989 goto __230 10990 __230: 10991 ; 10992 goto __9 10993 __23: 10994 __231: 10995 hold >>= (bits & uint32(7)) 10996 bits = bits - (bits & uint32(7)) 10997 goto __232 10998 __232: 10999 if 0 != 0 { 11000 goto __231 11001 } 11002 goto __233 11003 __233: 11004 ; // go to byte boundary 11005 __234: 11006 __237: 11007 if !(bits < (uint32(32))) { 11008 goto __238 11009 } 11010 __239: 11011 if !(have == uint32(0)) { 11012 goto __242 11013 } 11014 goto inf_leave 11015 __242: 11016 ; 11017 have-- 11018 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))) << bits) 11019 bits = bits + (uint32(8)) 11020 goto __240 11021 __240: 11022 if 0 != 0 { 11023 goto __239 11024 } 11025 goto __241 11026 __241: 11027 ; 11028 goto __237 11029 __238: 11030 ; 11031 goto __235 11032 __235: 11033 if 0 != 0 { 11034 goto __234 11035 } 11036 goto __236 11037 __236: 11038 ; 11039 if !((hold & uint32(0xffff)) != ((hold >> 16) ^ uint32(0xffff))) { 11040 goto __243 11041 } 11042 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 386 /* "invalid stored b..." */ 11043 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 11044 goto __9 11045 __243: 11046 ; 11047 (*Inflate_state)(unsafe.Pointer(state)).Flength = (uint32(hold) & uint32(0xffff)) 11048 11049 __244: 11050 hold = uint32(0) 11051 bits = uint32(0) 11052 goto __245 11053 __245: 11054 if 0 != 0 { 11055 goto __244 11056 } 11057 goto __246 11058 __246: 11059 ; 11060 (*Inflate_state)(unsafe.Pointer(state)).Fmode = COPY_ 11061 if !(flush == Z_TREES) { 11062 goto __247 11063 } 11064 goto inf_leave 11065 __247: 11066 ; 11067 __24: 11068 (*Inflate_state)(unsafe.Pointer(state)).Fmode = COPY 11069 __25: 11070 copy = (*Inflate_state)(unsafe.Pointer(state)).Flength 11071 if !(copy != 0) { 11072 goto __248 11073 } 11074 if !(copy > have) { 11075 goto __249 11076 } 11077 copy = have 11078 __249: 11079 ; 11080 if !(copy > left) { 11081 goto __250 11082 } 11083 copy = left 11084 __250: 11085 ; 11086 if !(copy == uint32(0)) { 11087 goto __251 11088 } 11089 goto inf_leave 11090 __251: 11091 ; 11092 libc.Xmemcpy(tls, put, next, uint64(copy)) 11093 have = have - (copy) 11094 next += uintptr(copy) 11095 left = left - (copy) 11096 put += uintptr(copy) 11097 *(*uint32)(unsafe.Pointer(state + 80 /* &.length */)) -= (copy) 11098 goto __9 11099 __248: 11100 ; 11101 11102 (*Inflate_state)(unsafe.Pointer(state)).Fmode = TYPE 11103 goto __9 11104 __26: 11105 __252: 11106 __255: 11107 if !(bits < (uint32(14))) { 11108 goto __256 11109 } 11110 __257: 11111 if !(have == uint32(0)) { 11112 goto __260 11113 } 11114 goto inf_leave 11115 __260: 11116 ; 11117 have-- 11118 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))) << bits) 11119 bits = bits + (uint32(8)) 11120 goto __258 11121 __258: 11122 if 0 != 0 { 11123 goto __257 11124 } 11125 goto __259 11126 __259: 11127 ; 11128 goto __255 11129 __256: 11130 ; 11131 goto __253 11132 __253: 11133 if 0 != 0 { 11134 goto __252 11135 } 11136 goto __254 11137 __254: 11138 ; 11139 (*Inflate_state)(unsafe.Pointer(state)).Fnlen = ((uint32(hold) & ((uint32(1) << (5)) - uint32(1))) + uint32(257)) 11140 __261: 11141 hold >>= 5 11142 bits = bits - (uint32(5)) 11143 goto __262 11144 __262: 11145 if 0 != 0 { 11146 goto __261 11147 } 11148 goto __263 11149 __263: 11150 ; 11151 (*Inflate_state)(unsafe.Pointer(state)).Fndist = ((uint32(hold) & ((uint32(1) << (5)) - uint32(1))) + uint32(1)) 11152 __264: 11153 hold >>= 5 11154 bits = bits - (uint32(5)) 11155 goto __265 11156 __265: 11157 if 0 != 0 { 11158 goto __264 11159 } 11160 goto __266 11161 __266: 11162 ; 11163 (*Inflate_state)(unsafe.Pointer(state)).Fncode = ((uint32(hold) & ((uint32(1) << (4)) - uint32(1))) + uint32(4)) 11164 __267: 11165 hold >>= 4 11166 bits = bits - (uint32(4)) 11167 goto __268 11168 __268: 11169 if 0 != 0 { 11170 goto __267 11171 } 11172 goto __269 11173 __269: 11174 ; 11175 if !(((*Inflate_state)(unsafe.Pointer(state)).Fnlen > uint32(286)) || ((*Inflate_state)(unsafe.Pointer(state)).Fndist > uint32(30))) { 11176 goto __270 11177 } 11178 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 415 /* "too many length ..." */ 11179 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 11180 goto __9 11181 __270: 11182 ; 11183 11184 (*Inflate_state)(unsafe.Pointer(state)).Fhave = uint32(0) 11185 (*Inflate_state)(unsafe.Pointer(state)).Fmode = LENLENS 11186 __27: 11187 __271: 11188 if !((*Inflate_state)(unsafe.Pointer(state)).Fhave < (*Inflate_state)(unsafe.Pointer(state)).Fncode) { 11189 goto __272 11190 } 11191 __273: 11192 __276: 11193 if !(bits < (uint32(3))) { 11194 goto __277 11195 } 11196 __278: 11197 if !(have == uint32(0)) { 11198 goto __281 11199 } 11200 goto inf_leave 11201 __281: 11202 ; 11203 have-- 11204 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))) << bits) 11205 bits = bits + (uint32(8)) 11206 goto __279 11207 __279: 11208 if 0 != 0 { 11209 goto __278 11210 } 11211 goto __280 11212 __280: 11213 ; 11214 goto __276 11215 __277: 11216 ; 11217 goto __274 11218 __274: 11219 if 0 != 0 { 11220 goto __273 11221 } 11222 goto __275 11223 __275: 11224 ; 11225 *(*uint16)(unsafe.Pointer((state + 144 /* &.lens */) + uintptr(order1[libc.PostIncUint32(&(*Inflate_state)(unsafe.Pointer(state)).Fhave, 1)])*2)) = (uint16(uint32(hold) & ((uint32(1) << (3)) - uint32(1)))) 11226 __282: 11227 hold >>= 3 11228 bits = bits - (uint32(3)) 11229 goto __283 11230 __283: 11231 if 0 != 0 { 11232 goto __282 11233 } 11234 goto __284 11235 __284: 11236 ; 11237 goto __271 11238 __272: 11239 ; 11240 __285: 11241 if !((*Inflate_state)(unsafe.Pointer(state)).Fhave < uint32(19)) { 11242 goto __286 11243 } 11244 *(*uint16)(unsafe.Pointer((state + 144 /* &.lens */) + uintptr(order1[libc.PostIncUint32(&(*Inflate_state)(unsafe.Pointer(state)).Fhave, 1)])*2)) = uint16(0) 11245 goto __285 11246 __286: 11247 ; 11248 (*Inflate_state)(unsafe.Pointer(state)).Fnext = state + 1360 /* &.codes */ 11249 (*Inflate_state)(unsafe.Pointer(state)).Flencode = (*Inflate_state)(unsafe.Pointer(state)).Fnext 11250 (*Inflate_state)(unsafe.Pointer(state)).Flenbits = uint32(7) 11251 ret = Xinflate_table(tls, CODES, state+144 /* &.lens */, uint32(19), (state + 136 /* &.next */), 11252 (state + 112 /* &.lenbits */), state+784 /* &.work */) 11253 if !(ret != 0) { 11254 goto __287 11255 } 11256 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 451 /* "invalid code len..." */ 11257 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 11258 goto __9 11259 __287: 11260 ; 11261 11262 (*Inflate_state)(unsafe.Pointer(state)).Fhave = uint32(0) 11263 (*Inflate_state)(unsafe.Pointer(state)).Fmode = CODELENS 11264 __28: 11265 __288: 11266 if !((*Inflate_state)(unsafe.Pointer(state)).Fhave < ((*Inflate_state)(unsafe.Pointer(state)).Fnlen + (*Inflate_state)(unsafe.Pointer(state)).Fndist)) { 11267 goto __289 11268 } 11269 __290: 11270 here = *(*Code)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Flencode + uintptr((uint32(hold)&((uint32(1)<<((*Inflate_state)(unsafe.Pointer(state)).Flenbits))-uint32(1))))*4)) 11271 if !((uint32(here.Fbits)) <= bits) { 11272 goto __293 11273 } 11274 goto __292 11275 __293: 11276 ; 11277 __294: 11278 if !(have == uint32(0)) { 11279 goto __297 11280 } 11281 goto inf_leave 11282 __297: 11283 ; 11284 have-- 11285 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))) << bits) 11286 bits = bits + (uint32(8)) 11287 goto __295 11288 __295: 11289 if 0 != 0 { 11290 goto __294 11291 } 11292 goto __296 11293 __296: 11294 ; 11295 goto __291 11296 __291: 11297 goto __290 11298 goto __292 11299 __292: 11300 ; 11301 if !(int32(here.Fval) < 16) { 11302 goto __298 11303 } 11304 __300: 11305 hold >>= int32(here.Fbits) 11306 bits = bits - (uint32(here.Fbits)) 11307 goto __301 11308 __301: 11309 if 0 != 0 { 11310 goto __300 11311 } 11312 goto __302 11313 __302: 11314 ; 11315 *(*uint16)(unsafe.Pointer((state + 144 /* &.lens */) + uintptr(libc.PostIncUint32(&(*Inflate_state)(unsafe.Pointer(state)).Fhave, 1))*2)) = here.Fval 11316 goto __299 11317 __298: 11318 if !(int32(here.Fval) == 16) { 11319 goto __303 11320 } 11321 __305: 11322 __308: 11323 if !(bits < (uint32(int32(here.Fbits) + 2))) { 11324 goto __309 11325 } 11326 __310: 11327 if !(have == uint32(0)) { 11328 goto __313 11329 } 11330 goto inf_leave 11331 __313: 11332 ; 11333 have-- 11334 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))) << bits) 11335 bits = bits + (uint32(8)) 11336 goto __311 11337 __311: 11338 if 0 != 0 { 11339 goto __310 11340 } 11341 goto __312 11342 __312: 11343 ; 11344 goto __308 11345 __309: 11346 ; 11347 goto __306 11348 __306: 11349 if 0 != 0 { 11350 goto __305 11351 } 11352 goto __307 11353 __307: 11354 ; 11355 __314: 11356 hold >>= int32(here.Fbits) 11357 bits = bits - (uint32(here.Fbits)) 11358 goto __315 11359 __315: 11360 if 0 != 0 { 11361 goto __314 11362 } 11363 goto __316 11364 __316: 11365 ; 11366 if !((*Inflate_state)(unsafe.Pointer(state)).Fhave == uint32(0)) { 11367 goto __317 11368 } 11369 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 476 /* "invalid bit leng..." */ 11370 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 11371 goto __289 11372 __317: 11373 ; 11374 len = uint32(*(*uint16)(unsafe.Pointer((state + 144 /* &.lens */) + uintptr(((*Inflate_state)(unsafe.Pointer(state)).Fhave-uint32(1)))*2))) 11375 copy = (uint32(3) + (uint32(hold) & ((uint32(1) << (2)) - uint32(1)))) 11376 __318: 11377 hold >>= 2 11378 bits = bits - (uint32(2)) 11379 goto __319 11380 __319: 11381 if 0 != 0 { 11382 goto __318 11383 } 11384 goto __320 11385 __320: 11386 ; 11387 goto __304 11388 __303: 11389 if !(int32(here.Fval) == 17) { 11390 goto __321 11391 } 11392 __323: 11393 __326: 11394 if !(bits < (uint32(int32(here.Fbits) + 3))) { 11395 goto __327 11396 } 11397 __328: 11398 if !(have == uint32(0)) { 11399 goto __331 11400 } 11401 goto inf_leave 11402 __331: 11403 ; 11404 have-- 11405 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))) << bits) 11406 bits = bits + (uint32(8)) 11407 goto __329 11408 __329: 11409 if 0 != 0 { 11410 goto __328 11411 } 11412 goto __330 11413 __330: 11414 ; 11415 goto __326 11416 __327: 11417 ; 11418 goto __324 11419 __324: 11420 if 0 != 0 { 11421 goto __323 11422 } 11423 goto __325 11424 __325: 11425 ; 11426 __332: 11427 hold >>= int32(here.Fbits) 11428 bits = bits - (uint32(here.Fbits)) 11429 goto __333 11430 __333: 11431 if 0 != 0 { 11432 goto __332 11433 } 11434 goto __334 11435 __334: 11436 ; 11437 len = uint32(0) 11438 copy = (uint32(3) + (uint32(hold) & ((uint32(1) << (3)) - uint32(1)))) 11439 __335: 11440 hold >>= 3 11441 bits = bits - (uint32(3)) 11442 goto __336 11443 __336: 11444 if 0 != 0 { 11445 goto __335 11446 } 11447 goto __337 11448 __337: 11449 ; 11450 goto __322 11451 __321: 11452 __338: 11453 __341: 11454 if !(bits < (uint32(int32(here.Fbits) + 7))) { 11455 goto __342 11456 } 11457 __343: 11458 if !(have == uint32(0)) { 11459 goto __346 11460 } 11461 goto inf_leave 11462 __346: 11463 ; 11464 have-- 11465 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))) << bits) 11466 bits = bits + (uint32(8)) 11467 goto __344 11468 __344: 11469 if 0 != 0 { 11470 goto __343 11471 } 11472 goto __345 11473 __345: 11474 ; 11475 goto __341 11476 __342: 11477 ; 11478 goto __339 11479 __339: 11480 if 0 != 0 { 11481 goto __338 11482 } 11483 goto __340 11484 __340: 11485 ; 11486 __347: 11487 hold >>= int32(here.Fbits) 11488 bits = bits - (uint32(here.Fbits)) 11489 goto __348 11490 __348: 11491 if 0 != 0 { 11492 goto __347 11493 } 11494 goto __349 11495 __349: 11496 ; 11497 len = uint32(0) 11498 copy = (uint32(11) + (uint32(hold) & ((uint32(1) << (7)) - uint32(1)))) 11499 __350: 11500 hold >>= 7 11501 bits = bits - (uint32(7)) 11502 goto __351 11503 __351: 11504 if 0 != 0 { 11505 goto __350 11506 } 11507 goto __352 11508 __352: 11509 ; 11510 __322: 11511 ; 11512 __304: 11513 ; 11514 if !(((*Inflate_state)(unsafe.Pointer(state)).Fhave + copy) > ((*Inflate_state)(unsafe.Pointer(state)).Fnlen + (*Inflate_state)(unsafe.Pointer(state)).Fndist)) { 11515 goto __353 11516 } 11517 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 476 /* "invalid bit leng..." */ 11518 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 11519 goto __289 11520 __353: 11521 ; 11522 __354: 11523 if !(libc.PostDecUint32(©, 1) != 0) { 11524 goto __355 11525 } 11526 *(*uint16)(unsafe.Pointer((state + 144 /* &.lens */) + uintptr(libc.PostIncUint32(&(*Inflate_state)(unsafe.Pointer(state)).Fhave, 1))*2)) = uint16(len) 11527 goto __354 11528 __355: 11529 ; 11530 __299: 11531 ; 11532 goto __288 11533 __289: 11534 ; 11535 11536 // handle error breaks in while 11537 if !((*Inflate_state)(unsafe.Pointer(state)).Fmode == BAD) { 11538 goto __356 11539 } 11540 goto __9 11541 __356: 11542 ; 11543 11544 // check for end-of-block code (better have one) 11545 if !(int32(*(*uint16)(unsafe.Pointer((state + 144 /* &.lens */) + 256*2))) == 0) { 11546 goto __357 11547 } 11548 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 502 /* "invalid code -- ..." */ 11549 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 11550 goto __9 11551 __357: 11552 ; 11553 11554 // build code tables -- note: do not change the lenbits or distbits 11555 // values here (9 and 6) without reading the comments in inftrees.h 11556 // concerning the ENOUGH constants, which depend on those values 11557 (*Inflate_state)(unsafe.Pointer(state)).Fnext = state + 1360 /* &.codes */ 11558 (*Inflate_state)(unsafe.Pointer(state)).Flencode = (*Inflate_state)(unsafe.Pointer(state)).Fnext 11559 (*Inflate_state)(unsafe.Pointer(state)).Flenbits = uint32(9) 11560 ret = Xinflate_table(tls, LENS, state+144 /* &.lens */, (*Inflate_state)(unsafe.Pointer(state)).Fnlen, (state + 136 /* &.next */), 11561 (state + 112 /* &.lenbits */), state+784 /* &.work */) 11562 if !(ret != 0) { 11563 goto __358 11564 } 11565 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 539 /* "invalid literal/..." */ 11566 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 11567 goto __9 11568 __358: 11569 ; 11570 (*Inflate_state)(unsafe.Pointer(state)).Fdistcode = (*Inflate_state)(unsafe.Pointer(state)).Fnext 11571 (*Inflate_state)(unsafe.Pointer(state)).Fdistbits = uint32(6) 11572 ret = Xinflate_table(tls, DISTS, ((state + 144 /* &.lens */) + uintptr((*Inflate_state)(unsafe.Pointer(state)).Fnlen)*2), (*Inflate_state)(unsafe.Pointer(state)).Fndist, 11573 (state + 136 /* &.next */), (state + 116 /* &.distbits */), state+784 /* &.work */) 11574 if !(ret != 0) { 11575 goto __359 11576 } 11577 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 567 /* "invalid distance..." */ 11578 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 11579 goto __9 11580 __359: 11581 ; 11582 11583 (*Inflate_state)(unsafe.Pointer(state)).Fmode = LEN_ 11584 if !(flush == Z_TREES) { 11585 goto __360 11586 } 11587 goto inf_leave 11588 __360: 11589 ; 11590 __29: 11591 (*Inflate_state)(unsafe.Pointer(state)).Fmode = LEN 11592 __30: 11593 if !((have >= uint32(6)) && (left >= uint32(258))) { 11594 goto __361 11595 } 11596 __362: 11597 (*Z_stream)(unsafe.Pointer(strm)).Fnext_out = put 11598 (*Z_stream)(unsafe.Pointer(strm)).Favail_out = left 11599 (*Z_stream)(unsafe.Pointer(strm)).Fnext_in = next 11600 (*Z_stream)(unsafe.Pointer(strm)).Favail_in = have 11601 (*Inflate_state)(unsafe.Pointer(state)).Fhold = hold 11602 (*Inflate_state)(unsafe.Pointer(state)).Fbits = bits 11603 goto __363 11604 __363: 11605 if 0 != 0 { 11606 goto __362 11607 } 11608 goto __364 11609 __364: 11610 ; 11611 Xinflate_fast(tls, strm, out) 11612 __365: 11613 put = (*Z_stream)(unsafe.Pointer(strm)).Fnext_out 11614 left = (*Z_stream)(unsafe.Pointer(strm)).Favail_out 11615 next = (*Z_stream)(unsafe.Pointer(strm)).Fnext_in 11616 have = (*Z_stream)(unsafe.Pointer(strm)).Favail_in 11617 hold = (*Inflate_state)(unsafe.Pointer(state)).Fhold 11618 bits = (*Inflate_state)(unsafe.Pointer(state)).Fbits 11619 goto __366 11620 __366: 11621 if 0 != 0 { 11622 goto __365 11623 } 11624 goto __367 11625 __367: 11626 ; 11627 if !((*Inflate_state)(unsafe.Pointer(state)).Fmode == TYPE) { 11628 goto __368 11629 } 11630 (*Inflate_state)(unsafe.Pointer(state)).Fback = -1 11631 __368: 11632 ; 11633 goto __9 11634 __361: 11635 ; 11636 (*Inflate_state)(unsafe.Pointer(state)).Fback = 0 11637 __369: 11638 here = *(*Code)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Flencode + uintptr((uint32(hold)&((uint32(1)<<((*Inflate_state)(unsafe.Pointer(state)).Flenbits))-uint32(1))))*4)) 11639 if !((uint32(here.Fbits)) <= bits) { 11640 goto __372 11641 } 11642 goto __371 11643 __372: 11644 ; 11645 __373: 11646 if !(have == uint32(0)) { 11647 goto __376 11648 } 11649 goto inf_leave 11650 __376: 11651 ; 11652 have-- 11653 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))) << bits) 11654 bits = bits + (uint32(8)) 11655 goto __374 11656 __374: 11657 if 0 != 0 { 11658 goto __373 11659 } 11660 goto __375 11661 __375: 11662 ; 11663 goto __370 11664 __370: 11665 goto __369 11666 goto __371 11667 __371: 11668 ; 11669 if !((here.Fop != 0) && ((int32(here.Fop) & 0xf0) == 0)) { 11670 goto __377 11671 } 11672 last = here 11673 __378: 11674 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)) 11675 if !((uint32(int32(last.Fbits) + int32(here.Fbits))) <= bits) { 11676 goto __381 11677 } 11678 goto __380 11679 __381: 11680 ; 11681 __382: 11682 if !(have == uint32(0)) { 11683 goto __385 11684 } 11685 goto inf_leave 11686 __385: 11687 ; 11688 have-- 11689 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))) << bits) 11690 bits = bits + (uint32(8)) 11691 goto __383 11692 __383: 11693 if 0 != 0 { 11694 goto __382 11695 } 11696 goto __384 11697 __384: 11698 ; 11699 goto __379 11700 __379: 11701 goto __378 11702 goto __380 11703 __380: 11704 ; 11705 __386: 11706 hold >>= int32(last.Fbits) 11707 bits = bits - (uint32(last.Fbits)) 11708 goto __387 11709 __387: 11710 if 0 != 0 { 11711 goto __386 11712 } 11713 goto __388 11714 __388: 11715 ; 11716 *(*int32)(unsafe.Pointer(state + 7140 /* &.back */)) += (int32(last.Fbits)) 11717 __377: 11718 ; 11719 __389: 11720 hold >>= int32(here.Fbits) 11721 bits = bits - (uint32(here.Fbits)) 11722 goto __390 11723 __390: 11724 if 0 != 0 { 11725 goto __389 11726 } 11727 goto __391 11728 __391: 11729 ; 11730 *(*int32)(unsafe.Pointer(state + 7140 /* &.back */)) += (int32(here.Fbits)) 11731 (*Inflate_state)(unsafe.Pointer(state)).Flength = uint32(here.Fval) 11732 if !((int32(here.Fop)) == 0) { 11733 goto __392 11734 } 11735 11736 (*Inflate_state)(unsafe.Pointer(state)).Fmode = LIT 11737 goto __9 11738 __392: 11739 ; 11740 if !((int32(here.Fop) & 32) != 0) { 11741 goto __393 11742 } 11743 11744 (*Inflate_state)(unsafe.Pointer(state)).Fback = -1 11745 (*Inflate_state)(unsafe.Pointer(state)).Fmode = TYPE 11746 goto __9 11747 __393: 11748 ; 11749 if !((int32(here.Fop) & 64) != 0) { 11750 goto __394 11751 } 11752 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 589 /* "invalid literal/..." */ 11753 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 11754 goto __9 11755 __394: 11756 ; 11757 (*Inflate_state)(unsafe.Pointer(state)).Fextra = ((uint32(here.Fop)) & uint32(15)) 11758 (*Inflate_state)(unsafe.Pointer(state)).Fmode = LENEXT 11759 __31: 11760 if !((*Inflate_state)(unsafe.Pointer(state)).Fextra != 0) { 11761 goto __395 11762 } 11763 __396: 11764 __399: 11765 if !(bits < ((*Inflate_state)(unsafe.Pointer(state)).Fextra)) { 11766 goto __400 11767 } 11768 __401: 11769 if !(have == uint32(0)) { 11770 goto __404 11771 } 11772 goto inf_leave 11773 __404: 11774 ; 11775 have-- 11776 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))) << bits) 11777 bits = bits + (uint32(8)) 11778 goto __402 11779 __402: 11780 if 0 != 0 { 11781 goto __401 11782 } 11783 goto __403 11784 __403: 11785 ; 11786 goto __399 11787 __400: 11788 ; 11789 goto __397 11790 __397: 11791 if 0 != 0 { 11792 goto __396 11793 } 11794 goto __398 11795 __398: 11796 ; 11797 *(*uint32)(unsafe.Pointer(state + 80 /* &.length */)) += (uint32(hold) & ((uint32(1) << ((*Inflate_state)(unsafe.Pointer(state)).Fextra)) - uint32(1))) 11798 __405: 11799 hold >>= (*Inflate_state)(unsafe.Pointer(state)).Fextra 11800 bits = bits - ((*Inflate_state)(unsafe.Pointer(state)).Fextra) 11801 goto __406 11802 __406: 11803 if 0 != 0 { 11804 goto __405 11805 } 11806 goto __407 11807 __407: 11808 ; 11809 *(*int32)(unsafe.Pointer(state + 7140 /* &.back */)) += int32(((*Inflate_state)(unsafe.Pointer(state)).Fextra)) 11810 __395: 11811 ; 11812 11813 (*Inflate_state)(unsafe.Pointer(state)).Fwas = (*Inflate_state)(unsafe.Pointer(state)).Flength 11814 (*Inflate_state)(unsafe.Pointer(state)).Fmode = DIST 11815 __32: 11816 __408: 11817 here = *(*Code)(unsafe.Pointer((*Inflate_state)(unsafe.Pointer(state)).Fdistcode + uintptr((uint32(hold)&((uint32(1)<<((*Inflate_state)(unsafe.Pointer(state)).Fdistbits))-uint32(1))))*4)) 11818 if !((uint32(here.Fbits)) <= bits) { 11819 goto __411 11820 } 11821 goto __410 11822 __411: 11823 ; 11824 __412: 11825 if !(have == uint32(0)) { 11826 goto __415 11827 } 11828 goto inf_leave 11829 __415: 11830 ; 11831 have-- 11832 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))) << bits) 11833 bits = bits + (uint32(8)) 11834 goto __413 11835 __413: 11836 if 0 != 0 { 11837 goto __412 11838 } 11839 goto __414 11840 __414: 11841 ; 11842 goto __409 11843 __409: 11844 goto __408 11845 goto __410 11846 __410: 11847 ; 11848 if !((int32(here.Fop) & 0xf0) == 0) { 11849 goto __416 11850 } 11851 last = here 11852 __417: 11853 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)) 11854 if !((uint32(int32(last.Fbits) + int32(here.Fbits))) <= bits) { 11855 goto __420 11856 } 11857 goto __419 11858 __420: 11859 ; 11860 __421: 11861 if !(have == uint32(0)) { 11862 goto __424 11863 } 11864 goto inf_leave 11865 __424: 11866 ; 11867 have-- 11868 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))) << bits) 11869 bits = bits + (uint32(8)) 11870 goto __422 11871 __422: 11872 if 0 != 0 { 11873 goto __421 11874 } 11875 goto __423 11876 __423: 11877 ; 11878 goto __418 11879 __418: 11880 goto __417 11881 goto __419 11882 __419: 11883 ; 11884 __425: 11885 hold >>= int32(last.Fbits) 11886 bits = bits - (uint32(last.Fbits)) 11887 goto __426 11888 __426: 11889 if 0 != 0 { 11890 goto __425 11891 } 11892 goto __427 11893 __427: 11894 ; 11895 *(*int32)(unsafe.Pointer(state + 7140 /* &.back */)) += (int32(last.Fbits)) 11896 __416: 11897 ; 11898 __428: 11899 hold >>= int32(here.Fbits) 11900 bits = bits - (uint32(here.Fbits)) 11901 goto __429 11902 __429: 11903 if 0 != 0 { 11904 goto __428 11905 } 11906 goto __430 11907 __430: 11908 ; 11909 *(*int32)(unsafe.Pointer(state + 7140 /* &.back */)) += (int32(here.Fbits)) 11910 if !((int32(here.Fop) & 64) != 0) { 11911 goto __431 11912 } 11913 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 617 /* "invalid distance..." */ 11914 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 11915 goto __9 11916 __431: 11917 ; 11918 (*Inflate_state)(unsafe.Pointer(state)).Foffset = uint32(here.Fval) 11919 (*Inflate_state)(unsafe.Pointer(state)).Fextra = ((uint32(here.Fop)) & uint32(15)) 11920 (*Inflate_state)(unsafe.Pointer(state)).Fmode = DISTEXT 11921 __33: 11922 if !((*Inflate_state)(unsafe.Pointer(state)).Fextra != 0) { 11923 goto __432 11924 } 11925 __433: 11926 __436: 11927 if !(bits < ((*Inflate_state)(unsafe.Pointer(state)).Fextra)) { 11928 goto __437 11929 } 11930 __438: 11931 if !(have == uint32(0)) { 11932 goto __441 11933 } 11934 goto inf_leave 11935 __441: 11936 ; 11937 have-- 11938 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))) << bits) 11939 bits = bits + (uint32(8)) 11940 goto __439 11941 __439: 11942 if 0 != 0 { 11943 goto __438 11944 } 11945 goto __440 11946 __440: 11947 ; 11948 goto __436 11949 __437: 11950 ; 11951 goto __434 11952 __434: 11953 if 0 != 0 { 11954 goto __433 11955 } 11956 goto __435 11957 __435: 11958 ; 11959 *(*uint32)(unsafe.Pointer(state + 84 /* &.offset */)) += (uint32(hold) & ((uint32(1) << ((*Inflate_state)(unsafe.Pointer(state)).Fextra)) - uint32(1))) 11960 __442: 11961 hold >>= (*Inflate_state)(unsafe.Pointer(state)).Fextra 11962 bits = bits - ((*Inflate_state)(unsafe.Pointer(state)).Fextra) 11963 goto __443 11964 __443: 11965 if 0 != 0 { 11966 goto __442 11967 } 11968 goto __444 11969 __444: 11970 ; 11971 *(*int32)(unsafe.Pointer(state + 7140 /* &.back */)) += int32(((*Inflate_state)(unsafe.Pointer(state)).Fextra)) 11972 __432: 11973 ; 11974 11975 (*Inflate_state)(unsafe.Pointer(state)).Fmode = MATCH 11976 __34: 11977 if !(left == uint32(0)) { 11978 goto __445 11979 } 11980 goto inf_leave 11981 __445: 11982 ; 11983 copy = (out - left) 11984 if !((*Inflate_state)(unsafe.Pointer(state)).Foffset > copy) { 11985 goto __446 11986 } // copy from window 11987 copy = ((*Inflate_state)(unsafe.Pointer(state)).Foffset - copy) 11988 if !(copy > (*Inflate_state)(unsafe.Pointer(state)).Fwhave) { 11989 goto __448 11990 } 11991 if !((*Inflate_state)(unsafe.Pointer(state)).Fsane != 0) { 11992 goto __449 11993 } 11994 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 639 /* "invalid distance..." */ 11995 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 11996 goto __9 11997 __449: 11998 ; 11999 __448: 12000 ; 12001 if !(copy > (*Inflate_state)(unsafe.Pointer(state)).Fwnext) { 12002 goto __450 12003 } 12004 copy = copy - ((*Inflate_state)(unsafe.Pointer(state)).Fwnext) 12005 from = ((*Inflate_state)(unsafe.Pointer(state)).Fwindow + uintptr(((*Inflate_state)(unsafe.Pointer(state)).Fwsize - copy))) 12006 goto __451 12007 __450: 12008 from = ((*Inflate_state)(unsafe.Pointer(state)).Fwindow + uintptr(((*Inflate_state)(unsafe.Pointer(state)).Fwnext - copy))) 12009 __451: 12010 ; 12011 if !(copy > (*Inflate_state)(unsafe.Pointer(state)).Flength) { 12012 goto __452 12013 } 12014 copy = (*Inflate_state)(unsafe.Pointer(state)).Flength 12015 __452: 12016 ; 12017 goto __447 12018 __446: // copy from output 12019 from = (put - uintptr((*Inflate_state)(unsafe.Pointer(state)).Foffset)) 12020 copy = (*Inflate_state)(unsafe.Pointer(state)).Flength 12021 __447: 12022 ; 12023 if !(copy > left) { 12024 goto __453 12025 } 12026 copy = left 12027 __453: 12028 ; 12029 left = left - (copy) 12030 *(*uint32)(unsafe.Pointer(state + 80 /* &.length */)) -= (copy) 12031 __454: 12032 *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&put, 1))) = *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&from, 1))) 12033 goto __455 12034 __455: 12035 if libc.PreDecUint32(©, 1) != 0 { 12036 goto __454 12037 } 12038 goto __456 12039 __456: 12040 ; 12041 if !((*Inflate_state)(unsafe.Pointer(state)).Flength == uint32(0)) { 12042 goto __457 12043 } 12044 (*Inflate_state)(unsafe.Pointer(state)).Fmode = LEN 12045 __457: 12046 ; 12047 goto __9 12048 __35: 12049 if !(left == uint32(0)) { 12050 goto __458 12051 } 12052 goto inf_leave 12053 __458: 12054 ; 12055 *(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&put, 1))) = uint8((*Inflate_state)(unsafe.Pointer(state)).Flength) 12056 left-- 12057 (*Inflate_state)(unsafe.Pointer(state)).Fmode = LEN 12058 goto __9 12059 __36: 12060 if !((*Inflate_state)(unsafe.Pointer(state)).Fwrap != 0) { 12061 goto __459 12062 } 12063 __460: 12064 __463: 12065 if !(bits < (uint32(32))) { 12066 goto __464 12067 } 12068 __465: 12069 if !(have == uint32(0)) { 12070 goto __468 12071 } 12072 goto inf_leave 12073 __468: 12074 ; 12075 have-- 12076 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))) << bits) 12077 bits = bits + (uint32(8)) 12078 goto __466 12079 __466: 12080 if 0 != 0 { 12081 goto __465 12082 } 12083 goto __467 12084 __467: 12085 ; 12086 goto __463 12087 __464: 12088 ; 12089 goto __461 12090 __461: 12091 if 0 != 0 { 12092 goto __460 12093 } 12094 goto __462 12095 __462: 12096 ; 12097 out = out - (left) 12098 *(*ULong)(unsafe.Pointer(strm + 28 /* &.total_out */)) += (ULong(out)) 12099 *(*uint32)(unsafe.Pointer(state + 36 /* &.total */)) += (uint32(out)) 12100 if !((((*Inflate_state)(unsafe.Pointer(state)).Fwrap & 4) != 0) && (out != 0)) { 12101 goto __469 12102 } 12103 (*Z_stream)(unsafe.Pointer(strm)).Fadler = libc.AssignPtrUint32(state+32 /* &.check */, func() uint32 { 12104 if (*Inflate_state)(unsafe.Pointer(state)).Fflags != 0 { 12105 return Xcrc32(tls, (*Inflate_state)(unsafe.Pointer(state)).Fcheck, (put - uintptr(out)), out) 12106 } 12107 return Xadler32(tls, (*Inflate_state)(unsafe.Pointer(state)).Fcheck, (put - uintptr(out)), out) 12108 }()) 12109 __469: 12110 ; 12111 out = left 12112 if !((((*Inflate_state)(unsafe.Pointer(state)).Fwrap & 4) != 0) && ((func() uint32 { 12113 if (*Inflate_state)(unsafe.Pointer(state)).Fflags != 0 { 12114 return hold 12115 } 12116 return ((((((hold) >> 24) & uint32(0xff)) + (((hold) >> 8) & uint32(0xff00))) + (((hold) & uint32(0xff00)) << 8)) + (((hold) & uint32(0xff)) << 24)) 12117 }()) != (*Inflate_state)(unsafe.Pointer(state)).Fcheck)) { 12118 goto __470 12119 } 12120 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 784 /* "incorrect data c..." */ 12121 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 12122 goto __9 12123 __470: 12124 ; 12125 __471: 12126 hold = uint32(0) 12127 bits = uint32(0) 12128 goto __472 12129 __472: 12130 if 0 != 0 { 12131 goto __471 12132 } 12133 goto __473 12134 __473: 12135 ; 12136 12137 __459: 12138 ; 12139 (*Inflate_state)(unsafe.Pointer(state)).Fmode = LENGTH 12140 __37: 12141 if !(((*Inflate_state)(unsafe.Pointer(state)).Fwrap != 0) && ((*Inflate_state)(unsafe.Pointer(state)).Fflags != 0)) { 12142 goto __474 12143 } 12144 __475: 12145 __478: 12146 if !(bits < (uint32(32))) { 12147 goto __479 12148 } 12149 __480: 12150 if !(have == uint32(0)) { 12151 goto __483 12152 } 12153 goto inf_leave 12154 __483: 12155 ; 12156 have-- 12157 hold = hold + ((uint32(*(*uint8)(unsafe.Pointer(libc.PostIncUintptr(&next, 1))))) << bits) 12158 bits = bits + (uint32(8)) 12159 goto __481 12160 __481: 12161 if 0 != 0 { 12162 goto __480 12163 } 12164 goto __482 12165 __482: 12166 ; 12167 goto __478 12168 __479: 12169 ; 12170 goto __476 12171 __476: 12172 if 0 != 0 { 12173 goto __475 12174 } 12175 goto __477 12176 __477: 12177 ; 12178 if !(hold != ((*Inflate_state)(unsafe.Pointer(state)).Ftotal & 0xffffffff)) { 12179 goto __484 12180 } 12181 (*Z_stream)(unsafe.Pointer(strm)).Fmsg = ts + 805 /* "incorrect length..." */ 12182 (*Inflate_state)(unsafe.Pointer(state)).Fmode = BAD 12183 goto __9 12184 __484: 12185 ; 12186 __485: 12187 hold = uint32(0) 12188 bits = uint32(0) 12189 goto __486 12190 __486: 12191 if 0 != 0 { 12192 goto __485 12193 } 12194 goto __487 12195 __487: 12196 ; 12197 12198 __474: 12199 ; 12200 (*Inflate_state)(unsafe.Pointer(state)).Fmode = DONE 12201 __38: 12202 ret = Z_STREAM_END 12203 goto inf_leave 12204 __39: 12205 ret = -3 12206 goto inf_leave 12207 __40: 12208 return -4 12209 __41: 12210 __42: 12211 return -2 12212 __9: 12213 ; 12214 goto __7 12215 __7: 12216 goto __6 12217 goto __8 12218 __8: 12219 ; 12220 12221 // 12222 // Return from inflate(), updating the total counts and the check value. 12223 // If there was no progress during the inflate() call, return a buffer 12224 // error. Call updatewindow() to create and/or update the window state. 12225 // Note: a memory error from inflate() is non-recoverable. 12226 // 12227 inf_leave: 12228 __488: 12229 (*Z_stream)(unsafe.Pointer(strm)).Fnext_out = put 12230 (*Z_stream)(unsafe.Pointer(strm)).Favail_out = left 12231 (*Z_stream)(unsafe.Pointer(strm)).Fnext_in = next 12232 (*Z_stream)(unsafe.Pointer(strm)).Favail_in = have 12233 (*Inflate_state)(unsafe.Pointer(state)).Fhold = hold 12234 (*Inflate_state)(unsafe.Pointer(state)).Fbits = bits 12235 goto __489 12236 __489: 12237 if 0 != 0 { 12238 goto __488 12239 } 12240 goto __490 12241 __490: 12242 ; 12243 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)))) { 12244 goto __491 12245 } 12246 if !(updatewindow(tls, strm, (*Z_stream)(unsafe.Pointer(strm)).Fnext_out, (out-(*Z_stream)(unsafe.Pointer(strm)).Favail_out)) != 0) { 12247 goto __492 12248 } 12249 (*Inflate_state)(unsafe.Pointer(state)).Fmode = MEM 12250 return -4 12251 __492: 12252 ; 12253 __491: 12254 ; 12255 in = in - ((*Z_stream)(unsafe.Pointer(strm)).Favail_in) 12256 out = out - ((*Z_stream)(unsafe.Pointer(strm)).Favail_out) 12257 *(*ULong)(unsafe.Pointer(strm + 12 /* &.total_in */)) += (ULong(in)) 12258 *(*ULong)(unsafe.Pointer(strm + 28 /* &.total_out */)) += (ULong(out)) 12259 *(*uint32)(unsafe.Pointer(state + 36 /* &.total */)) += (uint32(out)) 12260 if !((((*Inflate_state)(unsafe.Pointer(state)).Fwrap & 4) != 0) && (out != 0)) { 12261 goto __493 12262 } 12263 (*Z_stream)(unsafe.Pointer(strm)).Fadler = libc.AssignPtrUint32(state+32 /* &.check */, func() uint32 { 12264 if (*Inflate_state)(unsafe.Pointer(state)).Fflags != 0 { 12265 return Xcrc32(tls, (*Inflate_state)(unsafe.Pointer(state)).Fcheck, ((*Z_stream)(unsafe.Pointer(strm)).Fnext_out - uintptr(out)), out) 12266 } 12267 return Xadler32(tls, (*Inflate_state)(unsafe.Pointer(state)).Fcheck, ((*Z_stream)(unsafe.Pointer(strm)).Fnext_out - uintptr(out)), out) 12268 }()) 12269 __493: 12270 ; 12271 (*Z_stream)(unsafe.Pointer(strm)).Fdata_type = (((int32((*Inflate_state)(unsafe.Pointer(state)).Fbits) + (func() int32 { 12272 if (*Inflate_state)(unsafe.Pointer(state)).Flast != 0 { 12273 return 64 12274 } 12275 return 0 12276 }())) + (func() int32 { 12277 if (*Inflate_state)(unsafe.Pointer(state)).Fmode == TYPE { 12278 return 128 12279 } 12280 return 0 12281 }())) + (func() int32 { 12282 if ((*Inflate_state)(unsafe.Pointer(state)).Fmode == LEN_) || ((*Inflate_state)(unsafe.Pointer(state)).Fmode == COPY_) { 12283 return 256 12284 } 12285 return 0 12286 }())) 12287 if !((((in == uint32(0)) && (out == uint32(0))) || (flush == Z_FINISH)) && (ret == Z_OK)) { 12288 goto __494 12289 } 12290 ret = -5 12291 __494: 12292 ; 12293 return ret 12294 } 12295 12296 var order1 = // permutation of code lengths 12297 [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 */ 12298 12299 func XinflateEnd(tls *libc.TLS, strm Z_streamp) int32 { /* inflate.c:1277:13: */ 12300 var state uintptr 12301 if inflateStateCheck(tls, strm) != 0 { 12302 return -2 12303 } 12304 state = (*Z_stream)(unsafe.Pointer(strm)).Fstate 12305 if (*Inflate_state)(unsafe.Pointer(state)).Fwindow != uintptr(Z_NULL) { 12306 (*struct { 12307 f func(*libc.TLS, Voidpf, Voidpf) 12308 })(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer((strm))).Fzfree})).f(tls, (*Z_stream)(unsafe.Pointer(strm)).Fopaque, (*Inflate_state)(unsafe.Pointer(state)).Fwindow) 12309 } 12310 (*struct { 12311 f func(*libc.TLS, Voidpf, Voidpf) 12312 })(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer((strm))).Fzfree})).f(tls, (*Z_stream)(unsafe.Pointer(strm)).Fopaque, (*Z_stream)(unsafe.Pointer(strm)).Fstate) 12313 (*Z_stream)(unsafe.Pointer(strm)).Fstate = uintptr(Z_NULL) 12314 12315 return Z_OK 12316 } 12317 12318 func XinflateGetDictionary(tls *libc.TLS, strm Z_streamp, dictionary uintptr, dictLength uintptr) int32 { /* inflate.c:1291:13: */ 12319 var state uintptr 12320 12321 // check state 12322 if inflateStateCheck(tls, strm) != 0 { 12323 return -2 12324 } 12325 state = (*Z_stream)(unsafe.Pointer(strm)).Fstate 12326 12327 // copy dictionary 12328 if ((*Inflate_state)(unsafe.Pointer(state)).Fwhave != 0) && (dictionary != uintptr(Z_NULL)) { 12329 libc.Xmemcpy(tls, dictionary, ((*Inflate_state)(unsafe.Pointer(state)).Fwindow + uintptr((*Inflate_state)(unsafe.Pointer(state)).Fwnext)), 12330 (uint64((*Inflate_state)(unsafe.Pointer(state)).Fwhave - (*Inflate_state)(unsafe.Pointer(state)).Fwnext))) 12331 libc.Xmemcpy(tls, ((dictionary + uintptr((*Inflate_state)(unsafe.Pointer(state)).Fwhave)) - uintptr((*Inflate_state)(unsafe.Pointer(state)).Fwnext)), 12332 (*Inflate_state)(unsafe.Pointer(state)).Fwindow, uint64((*Inflate_state)(unsafe.Pointer(state)).Fwnext)) 12333 } 12334 if dictLength != uintptr(Z_NULL) { 12335 *(*UInt)(unsafe.Pointer(dictLength)) = (*Inflate_state)(unsafe.Pointer(state)).Fwhave 12336 } 12337 return Z_OK 12338 } 12339 12340 func XinflateSetDictionary(tls *libc.TLS, strm Z_streamp, dictionary uintptr, dictLength UInt) int32 { /* inflate.c:1314:13: */ 12341 var state uintptr 12342 var dictid uint32 12343 var ret int32 12344 12345 // check state 12346 if inflateStateCheck(tls, strm) != 0 { 12347 return -2 12348 } 12349 state = (*Z_stream)(unsafe.Pointer(strm)).Fstate 12350 if ((*Inflate_state)(unsafe.Pointer(state)).Fwrap != 0) && ((*Inflate_state)(unsafe.Pointer(state)).Fmode != DICT) { 12351 return -2 12352 } 12353 12354 // check for correct dictionary identifier 12355 if (*Inflate_state)(unsafe.Pointer(state)).Fmode == DICT { 12356 dictid = Xadler32(tls, uint32(0), uintptr(Z_NULL), uint32(0)) 12357 dictid = Xadler32(tls, dictid, dictionary, dictLength) 12358 if dictid != (*Inflate_state)(unsafe.Pointer(state)).Fcheck { 12359 return -3 12360 } 12361 } 12362 12363 // copy dictionary to window using updatewindow(), which will amend the 12364 // existing dictionary if appropriate 12365 ret = updatewindow(tls, strm, (dictionary + uintptr(dictLength)), dictLength) 12366 if ret != 0 { 12367 (*Inflate_state)(unsafe.Pointer(state)).Fmode = MEM 12368 return -4 12369 } 12370 (*Inflate_state)(unsafe.Pointer(state)).Fhavedict = 1 12371 12372 return Z_OK 12373 } 12374 12375 func XinflateGetHeader(tls *libc.TLS, strm Z_streamp, head Gz_headerp) int32 { /* inflate.c:1349:13: */ 12376 var state uintptr 12377 12378 // check state 12379 if inflateStateCheck(tls, strm) != 0 { 12380 return -2 12381 } 12382 state = (*Z_stream)(unsafe.Pointer(strm)).Fstate 12383 if ((*Inflate_state)(unsafe.Pointer(state)).Fwrap & 2) == 0 { 12384 return -2 12385 } 12386 12387 // save header structure 12388 (*Inflate_state)(unsafe.Pointer(state)).Fhead = head 12389 (*Gz_header)(unsafe.Pointer(head)).Fdone = 0 12390 return Z_OK 12391 } 12392 12393 // 12394 // Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found 12395 // or when out of input. When called, *have is the number of pattern bytes 12396 // found in order so far, in 0..3. On return *have is updated to the new 12397 // state. If on return *have equals four, then the pattern was found and the 12398 // return value is how many bytes were read including the last byte of the 12399 // pattern. If *have is less than four, then the pattern has not been found 12400 // yet and the return value is len. In the latter case, syncsearch() can be 12401 // called again with more data and the *have state. *have is initialized to 12402 // zero for the first call. 12403 // 12404 func syncsearch(tls *libc.TLS, have uintptr, buf uintptr, len uint32) uint32 { /* inflate.c:1377:16: */ 12405 var got uint32 12406 var next uint32 12407 12408 got = *(*uint32)(unsafe.Pointer(have)) 12409 next = uint32(0) 12410 for (next < len) && (got < uint32(4)) { 12411 if (int32(*(*uint8)(unsafe.Pointer(buf + uintptr(next))))) == (func() int32 { 12412 if got < uint32(2) { 12413 return 0 12414 } 12415 return 0xff 12416 }()) { 12417 got++ 12418 } else if *(*uint8)(unsafe.Pointer(buf + uintptr(next))) != 0 { 12419 got = uint32(0) 12420 } else { 12421 got = (uint32(4) - got) 12422 } 12423 next++ 12424 } 12425 *(*uint32)(unsafe.Pointer(have)) = got 12426 return next 12427 } 12428 12429 func XinflateSync(tls *libc.TLS, strm Z_streamp) int32 { /* inflate.c:1400:13: */ 12430 bp := tls.Alloc(4) 12431 defer tls.Free(4) 12432 12433 var len uint32 // number of bytes to look at or looked at 12434 var in uint32 12435 var out uint32 // temporary to save total_in and total_out 12436 // var buf [4]uint8 at bp, 4 12437 // to restore bit buffer to byte string 12438 var state uintptr 12439 12440 // check parameters 12441 if inflateStateCheck(tls, strm) != 0 { 12442 return -2 12443 } 12444 state = (*Z_stream)(unsafe.Pointer(strm)).Fstate 12445 if ((*Z_stream)(unsafe.Pointer(strm)).Favail_in == UInt(0)) && ((*Inflate_state)(unsafe.Pointer(state)).Fbits < uint32(8)) { 12446 return -5 12447 } 12448 12449 // if first time, start search in bit buffer 12450 if (*Inflate_state)(unsafe.Pointer(state)).Fmode != SYNC { 12451 (*Inflate_state)(unsafe.Pointer(state)).Fmode = SYNC 12452 libc.AssignShlPtrUint32(state+72 /* &.hold */, int(((*Inflate_state)(unsafe.Pointer(state)).Fbits & uint32(7)))) 12453 *(*uint32)(unsafe.Pointer(state + 76 /* &.bits */)) -= ((*Inflate_state)(unsafe.Pointer(state)).Fbits & uint32(7)) 12454 len = uint32(0) 12455 for (*Inflate_state)(unsafe.Pointer(state)).Fbits >= uint32(8) { 12456 *(*uint8)(unsafe.Pointer(bp /* &buf[0] */ + uintptr(libc.PostIncUint32(&len, 1)))) = uint8((*Inflate_state)(unsafe.Pointer(state)).Fhold) 12457 libc.AssignShrPtrUint32(state+72 /* &.hold */, int(8)) 12458 *(*uint32)(unsafe.Pointer(state + 76 /* &.bits */)) -= (uint32(8)) 12459 } 12460 (*Inflate_state)(unsafe.Pointer(state)).Fhave = uint32(0) 12461 syncsearch(tls, (state + 132 /* &.have */), bp /* &buf[0] */, len) 12462 } 12463 12464 // search available input 12465 len = syncsearch(tls, (state + 132 /* &.have */), (*Z_stream)(unsafe.Pointer(strm)).Fnext_in, (*Z_stream)(unsafe.Pointer(strm)).Favail_in) 12466 *(*UInt)(unsafe.Pointer(strm + 8 /* &.avail_in */)) -= (len) 12467 *(*uintptr)(unsafe.Pointer(strm /* &.next_in */)) += (uintptr(len)) 12468 *(*ULong)(unsafe.Pointer(strm + 12 /* &.total_in */)) += (ULong(len)) 12469 12470 // return no joy or set up to restart inflate() on a new block 12471 if (*Inflate_state)(unsafe.Pointer(state)).Fhave != uint32(4) { 12472 return -3 12473 } 12474 in = (*Z_stream)(unsafe.Pointer(strm)).Ftotal_in 12475 out = (*Z_stream)(unsafe.Pointer(strm)).Ftotal_out 12476 XinflateReset(tls, strm) 12477 (*Z_stream)(unsafe.Pointer(strm)).Ftotal_in = in 12478 (*Z_stream)(unsafe.Pointer(strm)).Ftotal_out = out 12479 (*Inflate_state)(unsafe.Pointer(state)).Fmode = TYPE 12480 return Z_OK 12481 } 12482 12483 // 12484 // Returns true if inflate is currently at the end of a block generated by 12485 // Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP 12486 // implementation to provide an additional safety check. PPP uses 12487 // Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored 12488 // block. When decompressing, PPP checks that at the end of input packet, 12489 // inflate is waiting for these length bytes. 12490 // 12491 func XinflateSyncPoint(tls *libc.TLS, strm Z_streamp) int32 { /* inflate.c:1451:13: */ 12492 var state uintptr 12493 12494 if inflateStateCheck(tls, strm) != 0 { 12495 return -2 12496 } 12497 state = (*Z_stream)(unsafe.Pointer(strm)).Fstate 12498 return (libc.Bool32(((*Inflate_state)(unsafe.Pointer(state)).Fmode == STORED) && ((*Inflate_state)(unsafe.Pointer(state)).Fbits == uint32(0)))) 12499 } 12500 12501 func XinflateCopy(tls *libc.TLS, dest Z_streamp, source Z_streamp) int32 { /* inflate.c:1461:13: */ 12502 var state uintptr 12503 var copy uintptr 12504 var window uintptr 12505 var wsize uint32 12506 12507 // check input 12508 if (inflateStateCheck(tls, source) != 0) || (dest == uintptr(Z_NULL)) { 12509 return -2 12510 } 12511 state = (*Z_stream)(unsafe.Pointer(source)).Fstate 12512 12513 // allocate space 12514 copy = (*struct { 12515 f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf 12516 })(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{}))) 12517 if copy == uintptr(Z_NULL) { 12518 return -4 12519 } 12520 window = uintptr(Z_NULL) 12521 if (*Inflate_state)(unsafe.Pointer(state)).Fwindow != uintptr(Z_NULL) { 12522 window = (*struct { 12523 f func(*libc.TLS, Voidpf, UInt, UInt) Voidpf 12524 })(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)))) 12525 if window == uintptr(Z_NULL) { 12526 (*struct { 12527 f func(*libc.TLS, Voidpf, Voidpf) 12528 })(unsafe.Pointer(&struct{ uintptr }{(*Z_stream)(unsafe.Pointer((source))).Fzfree})).f(tls, (*Z_stream)(unsafe.Pointer(source)).Fopaque, copy) 12529 return -4 12530 } 12531 } 12532 12533 // copy state 12534 libc.Xmemcpy(tls, dest, source, uint64(unsafe.Sizeof(Z_stream{}))) 12535 libc.Xmemcpy(tls, copy, state, uint64(unsafe.Sizeof(Inflate_state{}))) 12536 (*Inflate_state)(unsafe.Pointer(copy)).Fstrm = dest 12537 if ((*Inflate_state)(unsafe.Pointer(state)).Flencode >= state+1360 /* &.codes */) && ((*Inflate_state)(unsafe.Pointer(state)).Flencode <= (((state + 1360 /* &.codes */) + uintptr((ENOUGH_LENS+ENOUGH_DISTS))*4) - uintptr(1)*4)) { 12538 (*Inflate_state)(unsafe.Pointer(copy)).Flencode = ((copy + 1360 /* &.codes */) + uintptr((int64(((*Inflate_state)(unsafe.Pointer(state)).Flencode-(state+1360 /* &.codes */))/4)))*4) 12539 (*Inflate_state)(unsafe.Pointer(copy)).Fdistcode = ((copy + 1360 /* &.codes */) + uintptr((int64(((*Inflate_state)(unsafe.Pointer(state)).Fdistcode-(state+1360 /* &.codes */))/4)))*4) 12540 } 12541 (*Inflate_state)(unsafe.Pointer(copy)).Fnext = ((copy + 1360 /* &.codes */) + uintptr((int64(((*Inflate_state)(unsafe.Pointer(state)).Fnext-(state+1360 /* &.codes */))/4)))*4) 12542 if window != uintptr(Z_NULL) { 12543 wsize = (uint32(1) << (*Inflate_state)(unsafe.Pointer(state)).Fwbits) 12544 libc.Xmemcpy(tls, window, (*Inflate_state)(unsafe.Pointer(state)).Fwindow, uint64(wsize)) 12545 } 12546 (*Inflate_state)(unsafe.Pointer(copy)).Fwindow = window 12547 (*Z_stream)(unsafe.Pointer(dest)).Fstate = copy 12548 return Z_OK 12549 } 12550 12551 func XinflateUndermine(tls *libc.TLS, strm Z_streamp, subvert int32) int32 { /* inflate.c:1508:13: */ 12552 var state uintptr 12553 12554 if inflateStateCheck(tls, strm) != 0 { 12555 return -2 12556 } 12557 state = (*Z_stream)(unsafe.Pointer(strm)).Fstate 12558 _ = subvert 12559 (*Inflate_state)(unsafe.Pointer(state)).Fsane = 1 12560 return -3 12561 } 12562 12563 func XinflateValidate(tls *libc.TLS, strm Z_streamp, check int32) int32 { /* inflate.c:1526:13: */ 12564 var state uintptr 12565 12566 if inflateStateCheck(tls, strm) != 0 { 12567 return -2 12568 } 12569 state = (*Z_stream)(unsafe.Pointer(strm)).Fstate 12570 if check != 0 { 12571 *(*int32)(unsafe.Pointer(state + 16 /* &.wrap */)) |= (4) 12572 } else { 12573 *(*int32)(unsafe.Pointer(state + 16 /* &.wrap */)) &= (libc.CplInt32(4)) 12574 } 12575 return Z_OK 12576 } 12577 12578 func XinflateMark(tls *libc.TLS, strm Z_streamp) int32 { /* inflate.c:1541:14: */ 12579 var state uintptr 12580 12581 if inflateStateCheck(tls, strm) != 0 { 12582 return -(int32(1) << 16) 12583 } 12584 state = (*Z_stream)(unsafe.Pointer(strm)).Fstate 12585 return (int32(uint32((int32((uint32(int32((*Inflate_state)(unsafe.Pointer(state)).Fback))) << 16))) + (func() uint32 { 12586 if (*Inflate_state)(unsafe.Pointer(state)).Fmode == COPY { 12587 return uint32((*Inflate_state)(unsafe.Pointer(state)).Flength) 12588 } 12589 return func() uint32 { 12590 if (*Inflate_state)(unsafe.Pointer(state)).Fmode == MATCH { 12591 return (uint32((*Inflate_state)(unsafe.Pointer(state)).Fwas - (*Inflate_state)(unsafe.Pointer(state)).Flength)) 12592 } 12593 return uint32(0) 12594 }() 12595 }()))) 12596 } 12597 12598 func XinflateCodesUsed(tls *libc.TLS, strm Z_streamp) uint32 { /* inflate.c:1554:23: */ 12599 var state uintptr 12600 if inflateStateCheck(tls, strm) != 0 { 12601 return libc.Uint32(libc.Uint32FromInt32(-1)) 12602 } 12603 state = (*Z_stream)(unsafe.Pointer(strm)).Fstate 12604 return (uint32(int64(((*Inflate_state)(unsafe.Pointer(state)).Fnext - (state + 1360 /* &.codes */)) / 4))) 12605 } 12606 12607 var Xinflate_copyright = *(*[48]int8)(unsafe.Pointer(ts + 828 /* " inflate 1.2.11 ..." */)) /* inftrees.c:11:12 */ 12608 12609 // 12610 // If you use the zlib library in a product, an acknowledgment is welcome 12611 // in the documentation of your product. If for some reason you cannot 12612 // include such an acknowledgment, I would appreciate that you keep this 12613 // copyright string in the executable of your product. 12614 // 12615 12616 // 12617 // Build a set of tables to decode the provided canonical Huffman code. 12618 // The code lengths are lens[0..codes-1]. The result starts at *table, 12619 // whose indices are 0..2^bits-1. work is a writable array of at least 12620 // lens shorts, which is used as a work area. type is the type of code 12621 // to be generated, CODES, LENS, or DISTS. On return, zero is success, 12622 // -1 is an invalid code, and +1 means that ENOUGH isn't enough. table 12623 // on return points to the next available entry's address. bits is the 12624 // requested root table index bits, and on return it is the actual root 12625 // table index bits. It will differ if the request is greater than the 12626 // longest code or if it is less than the shortest code. 12627 // 12628 func Xinflate_table(tls *libc.TLS, type1 Codetype, lens uintptr, codes uint32, table uintptr, bits uintptr, work uintptr) int32 { /* inftrees.c:32:19: */ 12629 bp := tls.Alloc(64) 12630 defer tls.Free(64) 12631 12632 var len uint32 // a code's length in bits 12633 var sym uint32 // index of code symbols 12634 var min uint32 12635 var max uint32 // minimum and maximum code lengths 12636 var root uint32 // number of index bits for root table 12637 var curr uint32 // number of index bits for current table 12638 var drop uint32 // code bits to drop for sub-table 12639 var left int32 // number of prefix codes available 12640 var used uint32 // code entries in table used 12641 var huff uint32 // Huffman code 12642 var incr uint32 // for incrementing code, index 12643 var fill uint32 // index for replicating entries 12644 var low uint32 // low bits for current root entry 12645 var mask uint32 // mask for low root bits 12646 var here Code // table entry for duplication 12647 var next uintptr // next available space in table 12648 var base uintptr // base value table to use 12649 var extra uintptr // extra bits table to use 12650 var match uint32 // use base and extra for symbol >= match 12651 // var count [16]uint16 at bp, 32 12652 // number of codes of each length 12653 // var offs [16]uint16 at bp+32, 32 12654 12655 // 12656 // Process a set of code lengths to create a canonical Huffman code. The 12657 // code lengths are lens[0..codes-1]. Each length corresponds to the 12658 // symbols 0..codes-1. The Huffman code is generated by first sorting the 12659 // symbols by length from short to long, and retaining the symbol order 12660 // for codes with equal lengths. Then the code starts with all zero bits 12661 // for the first code of the shortest length, and the codes are integer 12662 // increments for the same length, and zeros are appended as the length 12663 // increases. For the deflate format, these bits are stored backwards 12664 // from their more natural integer increment ordering, and so when the 12665 // decoding tables are built in the large loop below, the integer codes 12666 // are incremented backwards. 12667 // 12668 // This routine assumes, but does not check, that all of the entries in 12669 // lens[] are in the range 0..MAXBITS. The caller must assure this. 12670 // 1..MAXBITS is interpreted as that code length. zero means that that 12671 // symbol does not occur in this code. 12672 // 12673 // The codes are sorted by computing a count of codes for each length, 12674 // creating from that a table of starting indices for each length in the 12675 // sorted table, and then entering the symbols in order in the sorted 12676 // table. The sorted table is work[], with that space being provided by 12677 // the caller. 12678 // 12679 // The length counts are used for other purposes as well, i.e. finding 12680 // the minimum and maximum length codes, determining if there are any 12681 // codes at all, checking for a valid set of lengths, and looking ahead 12682 // at length counts to determine sub-table sizes when building the 12683 // decoding tables. 12684 // 12685 12686 // accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) 12687 for len = uint32(0); len <= uint32(MAXBITS); len++ { 12688 *(*uint16)(unsafe.Pointer(bp /* &count[0] */ + uintptr(len)*2)) = uint16(0) 12689 } 12690 for sym = uint32(0); sym < codes; sym++ { 12691 *(*uint16)(unsafe.Pointer(bp /* &count[0] */ + uintptr(*(*uint16)(unsafe.Pointer(lens + uintptr(sym)*2)))*2))++ 12692 } 12693 12694 // bound code lengths, force root to be within code lengths 12695 root = *(*uint32)(unsafe.Pointer(bits)) 12696 for max = uint32(MAXBITS); max >= uint32(1); max-- { 12697 if int32(*(*uint16)(unsafe.Pointer(bp /* &count[0] */ + uintptr(max)*2))) != 0 { 12698 break 12699 } 12700 } 12701 if root > max { 12702 root = max 12703 } 12704 if max == uint32(0) { // no symbols to code at all 12705 here.Fop = uint8(64) // invalid code marker 12706 here.Fbits = uint8(1) 12707 here.Fval = uint16(0) 12708 *(*Code)(unsafe.Pointer(libc.PostIncUintptr(&(*(*uintptr)(unsafe.Pointer(table))), 4))) = here // make a table to force an error 12709 *(*Code)(unsafe.Pointer(libc.PostIncUintptr(&(*(*uintptr)(unsafe.Pointer(table))), 4))) = here 12710 *(*uint32)(unsafe.Pointer(bits)) = uint32(1) 12711 return 0 // no symbols, but wait for decoding to report error 12712 } 12713 for min = uint32(1); min < max; min++ { 12714 if int32(*(*uint16)(unsafe.Pointer(bp /* &count[0] */ + uintptr(min)*2))) != 0 { 12715 break 12716 } 12717 } 12718 if root < min { 12719 root = min 12720 } 12721 12722 // check for an over-subscribed or incomplete set of lengths 12723 left = 1 12724 for len = uint32(1); len <= uint32(MAXBITS); len++ { 12725 left <<= 1 12726 left = left - (int32(*(*uint16)(unsafe.Pointer(bp /* &count[0] */ + uintptr(len)*2)))) 12727 if left < 0 { 12728 return -1 12729 } // over-subscribed 12730 } 12731 if (left > 0) && ((type1 == CODES) || (max != uint32(1))) { 12732 return -1 12733 } // incomplete set 12734 12735 // generate offsets into symbol table for each length for sorting 12736 *(*uint16)(unsafe.Pointer(bp + 32 /* &offs[0] */ + 1*2)) = uint16(0) 12737 for len = uint32(1); len < uint32(MAXBITS); len++ { 12738 *(*uint16)(unsafe.Pointer(bp + 32 /* &offs[0] */ + uintptr((len+uint32(1)))*2)) = (uint16(int32(*(*uint16)(unsafe.Pointer(bp + 32 /* &offs[0] */ + uintptr(len)*2))) + int32(*(*uint16)(unsafe.Pointer(bp /* &count[0] */ + uintptr(len)*2))))) 12739 } 12740 12741 // sort symbols by length, by symbol order within each length 12742 for sym = uint32(0); sym < codes; sym++ { 12743 if int32(*(*uint16)(unsafe.Pointer(lens + uintptr(sym)*2))) != 0 { 12744 *(*uint16)(unsafe.Pointer(work + uintptr(libc.PostIncUint16(&*(*uint16)(unsafe.Pointer(bp + 32 /* &offs[0] */ + uintptr(*(*uint16)(unsafe.Pointer(lens + uintptr(sym)*2)))*2)), 1))*2)) = uint16(sym) 12745 } 12746 } 12747 12748 // 12749 // Create and fill in decoding tables. In this loop, the table being 12750 // filled is at next and has curr index bits. The code being used is huff 12751 // with length len. That code is converted to an index by dropping drop 12752 // bits off of the bottom. For codes where len is less than drop + curr, 12753 // those top drop + curr - len bits are incremented through all values to 12754 // fill the table with replicated entries. 12755 // 12756 // root is the number of index bits for the root table. When len exceeds 12757 // root, sub-tables are created pointed to by the root entry with an index 12758 // of the low root bits of huff. This is saved in low to check for when a 12759 // new sub-table should be started. drop is zero when the root table is 12760 // being filled, and drop is root when sub-tables are being filled. 12761 // 12762 // When a new sub-table is needed, it is necessary to look ahead in the 12763 // code lengths to determine what size sub-table is needed. The length 12764 // counts are used for this, and so count[] is decremented as codes are 12765 // entered in the tables. 12766 // 12767 // used keeps track of how many table entries have been allocated from the 12768 // provided *table space. It is checked for LENS and DIST tables against 12769 // the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in 12770 // the initial root table size constants. See the comments in inftrees.h 12771 // for more information. 12772 // 12773 // sym increments through all symbols, and the loop terminates when 12774 // all codes of length max, i.e. all codes, have been processed. This 12775 // routine permits incomplete codes, so another loop after this one fills 12776 // in the rest of the decoding tables with invalid code markers. 12777 // 12778 12779 // set up for code type 12780 switch type1 { 12781 case CODES: 12782 base = libc.AssignUintptr(&extra, work) // dummy value--not used 12783 match = uint32(20) 12784 break 12785 case LENS: 12786 base = uintptr(unsafe.Pointer(&lbase)) 12787 extra = uintptr(unsafe.Pointer(&lext)) 12788 match = uint32(257) 12789 break 12790 default: // DISTS 12791 base = uintptr(unsafe.Pointer(&dbase)) 12792 extra = uintptr(unsafe.Pointer(&dext)) 12793 match = uint32(0) 12794 } 12795 12796 // initialize state for loop 12797 huff = uint32(0) // starting code 12798 sym = uint32(0) // starting code symbol 12799 len = min // starting code length 12800 next = *(*uintptr)(unsafe.Pointer(table)) // current table to fill in 12801 curr = root // current table index bits 12802 drop = uint32(0) // current bits to drop from code for index 12803 low = libc.Uint32(libc.Uint32FromInt32(-1)) // trigger new sub-table when len > root 12804 used = (uint32(1) << root) // use root table entries 12805 mask = (used - uint32(1)) // mask for comparing low 12806 12807 // check available table space 12808 if ((type1 == LENS) && (used > uint32(ENOUGH_LENS))) || ((type1 == DISTS) && (used > uint32(ENOUGH_DISTS))) { 12809 return 1 12810 } 12811 12812 // process all codes and make table entries 12813 for { 12814 // create table entry 12815 here.Fbits = (uint8(len - drop)) 12816 if (uint32(*(*uint16)(unsafe.Pointer(work + uintptr(sym)*2))) + 1) < match { 12817 here.Fop = uint8(0) 12818 here.Fval = *(*uint16)(unsafe.Pointer(work + uintptr(sym)*2)) 12819 } else if uint32(*(*uint16)(unsafe.Pointer(work + uintptr(sym)*2))) >= match { 12820 here.Fop = uint8(*(*uint16)(unsafe.Pointer(extra + uintptr((uint32(*(*uint16)(unsafe.Pointer(work + uintptr(sym)*2)))-match))*2))) 12821 here.Fval = *(*uint16)(unsafe.Pointer(base + uintptr((uint32(*(*uint16)(unsafe.Pointer(work + uintptr(sym)*2)))-match))*2)) 12822 } else { 12823 here.Fop = (uint8(32 + 64)) // end of block 12824 here.Fval = uint16(0) 12825 } 12826 12827 // replicate for those indices with low len bits equal to huff 12828 incr = (uint32(1) << (len - drop)) 12829 fill = (uint32(1) << curr) 12830 min = fill // save offset to next table 12831 for ok := true; ok; ok = (fill != uint32(0)) { 12832 fill = fill - (incr) 12833 *(*Code)(unsafe.Pointer(next + uintptr(((huff>>drop)+fill))*4)) = here 12834 } 12835 12836 // backwards increment the len-bit code huff 12837 incr = (uint32(1) << (len - uint32(1))) 12838 for (huff & incr) != 0 { 12839 incr >>= 1 12840 } 12841 if incr != uint32(0) { 12842 huff = huff & (incr - uint32(1)) 12843 huff = huff + (incr) 12844 } else { 12845 huff = uint32(0) 12846 } 12847 12848 // go to next symbol, update count, len 12849 sym++ 12850 if int32(libc.PreDecUint16(&(*(*uint16)(unsafe.Pointer(bp /* &count[0] */ + uintptr(len)*2))), 1)) == 0 { 12851 if len == max { 12852 break 12853 } 12854 len = uint32(*(*uint16)(unsafe.Pointer(lens + uintptr(*(*uint16)(unsafe.Pointer(work + uintptr(sym)*2)))*2))) 12855 } 12856 12857 // create new sub-table if needed 12858 if (len > root) && ((huff & mask) != low) { 12859 // if first time, transition to sub-tables 12860 if drop == uint32(0) { 12861 drop = root 12862 } 12863 12864 // increment past last table 12865 next += 4 * (uintptr(min)) // here min is 1 << curr 12866 12867 // determine length of next table 12868 curr = (len - drop) 12869 left = (int32(1) << curr) 12870 for (curr + drop) < max { 12871 left = left - (int32(*(*uint16)(unsafe.Pointer(bp /* &count[0] */ + uintptr((curr+drop))*2)))) 12872 if left <= 0 { 12873 break 12874 } 12875 curr++ 12876 left <<= 1 12877 } 12878 12879 // check for enough space 12880 used = used + (uint32(1) << curr) 12881 if ((type1 == LENS) && (used > uint32(ENOUGH_LENS))) || ((type1 == DISTS) && (used > uint32(ENOUGH_DISTS))) { 12882 return 1 12883 } 12884 12885 // point entry in root table to sub-table 12886 low = (huff & mask) 12887 (*Code)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer(table))) + uintptr(low)*4)).Fop = uint8(curr) 12888 (*Code)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer(table))) + uintptr(low)*4)).Fbits = uint8(root) 12889 (*Code)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer(table))) + uintptr(low)*4)).Fval = (uint16((int64(next) - int64(*(*uintptr)(unsafe.Pointer(table)))) / 4)) 12890 } 12891 } 12892 12893 // fill in remaining table entry if code is incomplete (guaranteed to have 12894 // at most one remaining entry, since if the code is incomplete, the 12895 // maximum code length that was allowed to get this far is one bit) 12896 if huff != uint32(0) { 12897 here.Fop = uint8(64) // invalid code marker 12898 here.Fbits = (uint8(len - drop)) 12899 here.Fval = uint16(0) 12900 *(*Code)(unsafe.Pointer(next + uintptr(huff)*4)) = here 12901 } 12902 12903 // set return parameters 12904 *(*uintptr)(unsafe.Pointer(table)) += (uintptr(used)) * 4 12905 *(*uint32)(unsafe.Pointer(bits)) = root 12906 return 0 12907 } 12908 12909 var lbase = [31]uint16{ // Length codes 257..285 base 12910 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), 12911 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 */ 12912 var lext = [31]uint16{ // Length codes 257..285 extra 12913 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), 12914 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 */ 12915 var dbase = [32]uint16{ // Distance codes 0..29 base 12916 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), 12917 uint16(257), uint16(385), uint16(513), uint16(769), uint16(1025), uint16(1537), uint16(2049), uint16(3073), uint16(4097), uint16(6145), 12918 uint16(8193), uint16(12289), uint16(16385), uint16(24577), uint16(0), uint16(0)} /* inftrees.c:66:33 */ 12919 var dext = [32]uint16{ // Distance codes 0..29 extra 12920 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), 12921 uint16(23), uint16(23), uint16(24), uint16(24), uint16(25), uint16(25), uint16(26), uint16(26), uint16(27), uint16(27), 12922 uint16(28), uint16(28), uint16(29), uint16(29), uint16(64), uint16(64)} /* inftrees.c:70:33 */ 12923 12924 type Static_tree_desc = Static_tree_desc_s /* deflate.h:84:36 */ 12925 12926 // =========================================================================== 12927 // Constants 12928 12929 // Bit length codes must not exceed MAX_BL_BITS bits 12930 12931 // end of block literal code 12932 12933 // repeat previous bit length 3-6 times (2 bits of repeat count) 12934 12935 // repeat a zero length 3-10 times (3 bits of repeat count) 12936 12937 // repeat a zero length 11-138 times (7 bits of repeat count) 12938 12939 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 */ 12940 12941 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 */ 12942 12943 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 */ 12944 12945 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 */ 12946 // The lengths of the bit length codes are sent in order of decreasing 12947 // probability, to avoid transmitting the lengths for unused bit length codes. 12948 12949 // =========================================================================== 12950 // Local data. These are initialized only once. 12951 12952 // header created automatically with -DGEN_TREES_H 12953 12954 var static_ltree = [288]Ct_data{{Ffc: func() (r struct{ Ffreq Ush }) { 12955 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(12) 12956 return r 12957 }(), Fdl: func() (r struct{ Fdad Ush }) { 12958 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 12959 return r 12960 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 12961 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(140) 12962 return r 12963 }(), Fdl: func() (r struct{ Fdad Ush }) { 12964 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 12965 return r 12966 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 12967 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(76) 12968 return r 12969 }(), Fdl: func() (r struct{ Fdad Ush }) { 12970 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 12971 return r 12972 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 12973 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(204) 12974 return r 12975 }(), Fdl: func() (r struct{ Fdad Ush }) { 12976 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 12977 return r 12978 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 12979 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(44) 12980 return r 12981 }(), Fdl: func() (r struct{ Fdad Ush }) { 12982 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 12983 return r 12984 }()}, 12985 {Ffc: func() (r struct{ Ffreq Ush }) { 12986 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(172) 12987 return r 12988 }(), Fdl: func() (r struct{ Fdad Ush }) { 12989 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 12990 return r 12991 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 12992 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(108) 12993 return r 12994 }(), Fdl: func() (r struct{ Fdad Ush }) { 12995 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 12996 return r 12997 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 12998 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(236) 12999 return r 13000 }(), Fdl: func() (r struct{ Fdad Ush }) { 13001 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13002 return r 13003 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13004 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(28) 13005 return r 13006 }(), Fdl: func() (r struct{ Fdad Ush }) { 13007 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13008 return r 13009 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13010 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(156) 13011 return r 13012 }(), Fdl: func() (r struct{ Fdad Ush }) { 13013 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13014 return r 13015 }()}, 13016 {Ffc: func() (r struct{ Ffreq Ush }) { 13017 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(92) 13018 return r 13019 }(), Fdl: func() (r struct{ Fdad Ush }) { 13020 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13021 return r 13022 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13023 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(220) 13024 return r 13025 }(), Fdl: func() (r struct{ Fdad Ush }) { 13026 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13027 return r 13028 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13029 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(60) 13030 return r 13031 }(), Fdl: func() (r struct{ Fdad Ush }) { 13032 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13033 return r 13034 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13035 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(188) 13036 return r 13037 }(), Fdl: func() (r struct{ Fdad Ush }) { 13038 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13039 return r 13040 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13041 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(124) 13042 return r 13043 }(), Fdl: func() (r struct{ Fdad Ush }) { 13044 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13045 return r 13046 }()}, 13047 {Ffc: func() (r struct{ Ffreq Ush }) { 13048 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(252) 13049 return r 13050 }(), Fdl: func() (r struct{ Fdad Ush }) { 13051 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13052 return r 13053 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13054 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(2) 13055 return r 13056 }(), Fdl: func() (r struct{ Fdad Ush }) { 13057 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13058 return r 13059 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13060 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(130) 13061 return r 13062 }(), Fdl: func() (r struct{ Fdad Ush }) { 13063 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13064 return r 13065 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13066 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(66) 13067 return r 13068 }(), Fdl: func() (r struct{ Fdad Ush }) { 13069 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13070 return r 13071 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13072 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(194) 13073 return r 13074 }(), Fdl: func() (r struct{ Fdad Ush }) { 13075 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13076 return r 13077 }()}, 13078 {Ffc: func() (r struct{ Ffreq Ush }) { 13079 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(34) 13080 return r 13081 }(), Fdl: func() (r struct{ Fdad Ush }) { 13082 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13083 return r 13084 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13085 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(162) 13086 return r 13087 }(), Fdl: func() (r struct{ Fdad Ush }) { 13088 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13089 return r 13090 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13091 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(98) 13092 return r 13093 }(), Fdl: func() (r struct{ Fdad Ush }) { 13094 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13095 return r 13096 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13097 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(226) 13098 return r 13099 }(), Fdl: func() (r struct{ Fdad Ush }) { 13100 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13101 return r 13102 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13103 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(18) 13104 return r 13105 }(), Fdl: func() (r struct{ Fdad Ush }) { 13106 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13107 return r 13108 }()}, 13109 {Ffc: func() (r struct{ Ffreq Ush }) { 13110 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(146) 13111 return r 13112 }(), Fdl: func() (r struct{ Fdad Ush }) { 13113 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13114 return r 13115 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13116 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(82) 13117 return r 13118 }(), Fdl: func() (r struct{ Fdad Ush }) { 13119 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13120 return r 13121 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13122 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(210) 13123 return r 13124 }(), Fdl: func() (r struct{ Fdad Ush }) { 13125 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13126 return r 13127 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13128 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(50) 13129 return r 13130 }(), Fdl: func() (r struct{ Fdad Ush }) { 13131 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13132 return r 13133 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13134 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(178) 13135 return r 13136 }(), Fdl: func() (r struct{ Fdad Ush }) { 13137 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13138 return r 13139 }()}, 13140 {Ffc: func() (r struct{ Ffreq Ush }) { 13141 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(114) 13142 return r 13143 }(), Fdl: func() (r struct{ Fdad Ush }) { 13144 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13145 return r 13146 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13147 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(242) 13148 return r 13149 }(), Fdl: func() (r struct{ Fdad Ush }) { 13150 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13151 return r 13152 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13153 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(10) 13154 return r 13155 }(), Fdl: func() (r struct{ Fdad Ush }) { 13156 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13157 return r 13158 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13159 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(138) 13160 return r 13161 }(), Fdl: func() (r struct{ Fdad Ush }) { 13162 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13163 return r 13164 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13165 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(74) 13166 return r 13167 }(), Fdl: func() (r struct{ Fdad Ush }) { 13168 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13169 return r 13170 }()}, 13171 {Ffc: func() (r struct{ Ffreq Ush }) { 13172 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(202) 13173 return r 13174 }(), Fdl: func() (r struct{ Fdad Ush }) { 13175 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13176 return r 13177 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13178 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(42) 13179 return r 13180 }(), Fdl: func() (r struct{ Fdad Ush }) { 13181 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13182 return r 13183 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13184 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(170) 13185 return r 13186 }(), Fdl: func() (r struct{ Fdad Ush }) { 13187 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13188 return r 13189 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13190 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(106) 13191 return r 13192 }(), Fdl: func() (r struct{ Fdad Ush }) { 13193 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13194 return r 13195 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13196 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(234) 13197 return r 13198 }(), Fdl: func() (r struct{ Fdad Ush }) { 13199 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13200 return r 13201 }()}, 13202 {Ffc: func() (r struct{ Ffreq Ush }) { 13203 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(26) 13204 return r 13205 }(), Fdl: func() (r struct{ Fdad Ush }) { 13206 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13207 return r 13208 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13209 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(154) 13210 return r 13211 }(), Fdl: func() (r struct{ Fdad Ush }) { 13212 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13213 return r 13214 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13215 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(90) 13216 return r 13217 }(), Fdl: func() (r struct{ Fdad Ush }) { 13218 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13219 return r 13220 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13221 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(218) 13222 return r 13223 }(), Fdl: func() (r struct{ Fdad Ush }) { 13224 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13225 return r 13226 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13227 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(58) 13228 return r 13229 }(), Fdl: func() (r struct{ Fdad Ush }) { 13230 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13231 return r 13232 }()}, 13233 {Ffc: func() (r struct{ Ffreq Ush }) { 13234 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(186) 13235 return r 13236 }(), Fdl: func() (r struct{ Fdad Ush }) { 13237 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13238 return r 13239 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13240 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(122) 13241 return r 13242 }(), Fdl: func() (r struct{ Fdad Ush }) { 13243 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13244 return r 13245 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13246 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(250) 13247 return r 13248 }(), Fdl: func() (r struct{ Fdad Ush }) { 13249 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13250 return r 13251 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13252 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(6) 13253 return r 13254 }(), Fdl: func() (r struct{ Fdad Ush }) { 13255 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13256 return r 13257 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13258 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(134) 13259 return r 13260 }(), Fdl: func() (r struct{ Fdad Ush }) { 13261 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13262 return r 13263 }()}, 13264 {Ffc: func() (r struct{ Ffreq Ush }) { 13265 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(70) 13266 return r 13267 }(), Fdl: func() (r struct{ Fdad Ush }) { 13268 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13269 return r 13270 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13271 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(198) 13272 return r 13273 }(), Fdl: func() (r struct{ Fdad Ush }) { 13274 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13275 return r 13276 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13277 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(38) 13278 return r 13279 }(), Fdl: func() (r struct{ Fdad Ush }) { 13280 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13281 return r 13282 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13283 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(166) 13284 return r 13285 }(), Fdl: func() (r struct{ Fdad Ush }) { 13286 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13287 return r 13288 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13289 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(102) 13290 return r 13291 }(), Fdl: func() (r struct{ Fdad Ush }) { 13292 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13293 return r 13294 }()}, 13295 {Ffc: func() (r struct{ Ffreq Ush }) { 13296 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(230) 13297 return r 13298 }(), Fdl: func() (r struct{ Fdad Ush }) { 13299 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13300 return r 13301 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13302 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(22) 13303 return r 13304 }(), Fdl: func() (r struct{ Fdad Ush }) { 13305 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13306 return r 13307 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13308 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(150) 13309 return r 13310 }(), Fdl: func() (r struct{ Fdad Ush }) { 13311 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13312 return r 13313 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13314 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(86) 13315 return r 13316 }(), Fdl: func() (r struct{ Fdad Ush }) { 13317 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13318 return r 13319 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13320 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(214) 13321 return r 13322 }(), Fdl: func() (r struct{ Fdad Ush }) { 13323 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13324 return r 13325 }()}, 13326 {Ffc: func() (r struct{ Ffreq Ush }) { 13327 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(54) 13328 return r 13329 }(), Fdl: func() (r struct{ Fdad Ush }) { 13330 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13331 return r 13332 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13333 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(182) 13334 return r 13335 }(), Fdl: func() (r struct{ Fdad Ush }) { 13336 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13337 return r 13338 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13339 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(118) 13340 return r 13341 }(), Fdl: func() (r struct{ Fdad Ush }) { 13342 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13343 return r 13344 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13345 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(246) 13346 return r 13347 }(), Fdl: func() (r struct{ Fdad Ush }) { 13348 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13349 return r 13350 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13351 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(14) 13352 return r 13353 }(), Fdl: func() (r struct{ Fdad Ush }) { 13354 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13355 return r 13356 }()}, 13357 {Ffc: func() (r struct{ Ffreq Ush }) { 13358 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(142) 13359 return r 13360 }(), Fdl: func() (r struct{ Fdad Ush }) { 13361 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13362 return r 13363 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13364 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(78) 13365 return r 13366 }(), Fdl: func() (r struct{ Fdad Ush }) { 13367 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13368 return r 13369 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13370 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(206) 13371 return r 13372 }(), Fdl: func() (r struct{ Fdad Ush }) { 13373 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13374 return r 13375 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13376 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(46) 13377 return r 13378 }(), Fdl: func() (r struct{ Fdad Ush }) { 13379 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13380 return r 13381 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13382 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(174) 13383 return r 13384 }(), Fdl: func() (r struct{ Fdad Ush }) { 13385 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13386 return r 13387 }()}, 13388 {Ffc: func() (r struct{ Ffreq Ush }) { 13389 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(110) 13390 return r 13391 }(), Fdl: func() (r struct{ Fdad Ush }) { 13392 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13393 return r 13394 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13395 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(238) 13396 return r 13397 }(), Fdl: func() (r struct{ Fdad Ush }) { 13398 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13399 return r 13400 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13401 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(30) 13402 return r 13403 }(), Fdl: func() (r struct{ Fdad Ush }) { 13404 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13405 return r 13406 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13407 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(158) 13408 return r 13409 }(), Fdl: func() (r struct{ Fdad Ush }) { 13410 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13411 return r 13412 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13413 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(94) 13414 return r 13415 }(), Fdl: func() (r struct{ Fdad Ush }) { 13416 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13417 return r 13418 }()}, 13419 {Ffc: func() (r struct{ Ffreq Ush }) { 13420 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(222) 13421 return r 13422 }(), Fdl: func() (r struct{ Fdad Ush }) { 13423 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13424 return r 13425 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13426 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(62) 13427 return r 13428 }(), Fdl: func() (r struct{ Fdad Ush }) { 13429 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13430 return r 13431 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13432 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(190) 13433 return r 13434 }(), Fdl: func() (r struct{ Fdad Ush }) { 13435 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13436 return r 13437 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13438 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(126) 13439 return r 13440 }(), Fdl: func() (r struct{ Fdad Ush }) { 13441 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13442 return r 13443 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13444 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(254) 13445 return r 13446 }(), Fdl: func() (r struct{ Fdad Ush }) { 13447 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13448 return r 13449 }()}, 13450 {Ffc: func() (r struct{ Ffreq Ush }) { 13451 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(1) 13452 return r 13453 }(), Fdl: func() (r struct{ Fdad Ush }) { 13454 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13455 return r 13456 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13457 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(129) 13458 return r 13459 }(), Fdl: func() (r struct{ Fdad Ush }) { 13460 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13461 return r 13462 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13463 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(65) 13464 return r 13465 }(), Fdl: func() (r struct{ Fdad Ush }) { 13466 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13467 return r 13468 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13469 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(193) 13470 return r 13471 }(), Fdl: func() (r struct{ Fdad Ush }) { 13472 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13473 return r 13474 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13475 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(33) 13476 return r 13477 }(), Fdl: func() (r struct{ Fdad Ush }) { 13478 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13479 return r 13480 }()}, 13481 {Ffc: func() (r struct{ Ffreq Ush }) { 13482 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(161) 13483 return r 13484 }(), Fdl: func() (r struct{ Fdad Ush }) { 13485 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13486 return r 13487 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13488 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(97) 13489 return r 13490 }(), Fdl: func() (r struct{ Fdad Ush }) { 13491 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13492 return r 13493 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13494 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(225) 13495 return r 13496 }(), Fdl: func() (r struct{ Fdad Ush }) { 13497 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13498 return r 13499 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13500 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(17) 13501 return r 13502 }(), Fdl: func() (r struct{ Fdad Ush }) { 13503 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13504 return r 13505 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13506 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(145) 13507 return r 13508 }(), Fdl: func() (r struct{ Fdad Ush }) { 13509 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13510 return r 13511 }()}, 13512 {Ffc: func() (r struct{ Ffreq Ush }) { 13513 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(81) 13514 return r 13515 }(), Fdl: func() (r struct{ Fdad Ush }) { 13516 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13517 return r 13518 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13519 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(209) 13520 return r 13521 }(), Fdl: func() (r struct{ Fdad Ush }) { 13522 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13523 return r 13524 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13525 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(49) 13526 return r 13527 }(), Fdl: func() (r struct{ Fdad Ush }) { 13528 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13529 return r 13530 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13531 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(177) 13532 return r 13533 }(), Fdl: func() (r struct{ Fdad Ush }) { 13534 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13535 return r 13536 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13537 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(113) 13538 return r 13539 }(), Fdl: func() (r struct{ Fdad Ush }) { 13540 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13541 return r 13542 }()}, 13543 {Ffc: func() (r struct{ Ffreq Ush }) { 13544 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(241) 13545 return r 13546 }(), Fdl: func() (r struct{ Fdad Ush }) { 13547 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13548 return r 13549 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13550 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 13551 return r 13552 }(), Fdl: func() (r struct{ Fdad Ush }) { 13553 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13554 return r 13555 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13556 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(137) 13557 return r 13558 }(), Fdl: func() (r struct{ Fdad Ush }) { 13559 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13560 return r 13561 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13562 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(73) 13563 return r 13564 }(), Fdl: func() (r struct{ Fdad Ush }) { 13565 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13566 return r 13567 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13568 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(201) 13569 return r 13570 }(), Fdl: func() (r struct{ Fdad Ush }) { 13571 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13572 return r 13573 }()}, 13574 {Ffc: func() (r struct{ Ffreq Ush }) { 13575 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(41) 13576 return r 13577 }(), Fdl: func() (r struct{ Fdad Ush }) { 13578 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13579 return r 13580 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13581 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(169) 13582 return r 13583 }(), Fdl: func() (r struct{ Fdad Ush }) { 13584 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13585 return r 13586 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13587 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(105) 13588 return r 13589 }(), Fdl: func() (r struct{ Fdad Ush }) { 13590 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13591 return r 13592 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13593 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(233) 13594 return r 13595 }(), Fdl: func() (r struct{ Fdad Ush }) { 13596 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13597 return r 13598 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13599 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(25) 13600 return r 13601 }(), Fdl: func() (r struct{ Fdad Ush }) { 13602 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13603 return r 13604 }()}, 13605 {Ffc: func() (r struct{ Ffreq Ush }) { 13606 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(153) 13607 return r 13608 }(), Fdl: func() (r struct{ Fdad Ush }) { 13609 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13610 return r 13611 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13612 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(89) 13613 return r 13614 }(), Fdl: func() (r struct{ Fdad Ush }) { 13615 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13616 return r 13617 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13618 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(217) 13619 return r 13620 }(), Fdl: func() (r struct{ Fdad Ush }) { 13621 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13622 return r 13623 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13624 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(57) 13625 return r 13626 }(), Fdl: func() (r struct{ Fdad Ush }) { 13627 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13628 return r 13629 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13630 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(185) 13631 return r 13632 }(), Fdl: func() (r struct{ Fdad Ush }) { 13633 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13634 return r 13635 }()}, 13636 {Ffc: func() (r struct{ Ffreq Ush }) { 13637 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(121) 13638 return r 13639 }(), Fdl: func() (r struct{ Fdad Ush }) { 13640 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13641 return r 13642 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13643 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(249) 13644 return r 13645 }(), Fdl: func() (r struct{ Fdad Ush }) { 13646 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13647 return r 13648 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13649 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 13650 return r 13651 }(), Fdl: func() (r struct{ Fdad Ush }) { 13652 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13653 return r 13654 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13655 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(133) 13656 return r 13657 }(), Fdl: func() (r struct{ Fdad Ush }) { 13658 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13659 return r 13660 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13661 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(69) 13662 return r 13663 }(), Fdl: func() (r struct{ Fdad Ush }) { 13664 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13665 return r 13666 }()}, 13667 {Ffc: func() (r struct{ Ffreq Ush }) { 13668 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(197) 13669 return r 13670 }(), Fdl: func() (r struct{ Fdad Ush }) { 13671 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13672 return r 13673 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13674 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(37) 13675 return r 13676 }(), Fdl: func() (r struct{ Fdad Ush }) { 13677 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13678 return r 13679 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13680 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(165) 13681 return r 13682 }(), Fdl: func() (r struct{ Fdad Ush }) { 13683 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13684 return r 13685 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13686 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(101) 13687 return r 13688 }(), Fdl: func() (r struct{ Fdad Ush }) { 13689 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13690 return r 13691 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13692 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(229) 13693 return r 13694 }(), Fdl: func() (r struct{ Fdad Ush }) { 13695 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13696 return r 13697 }()}, 13698 {Ffc: func() (r struct{ Ffreq Ush }) { 13699 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(21) 13700 return r 13701 }(), Fdl: func() (r struct{ Fdad Ush }) { 13702 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13703 return r 13704 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13705 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(149) 13706 return r 13707 }(), Fdl: func() (r struct{ Fdad Ush }) { 13708 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13709 return r 13710 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13711 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(85) 13712 return r 13713 }(), Fdl: func() (r struct{ Fdad Ush }) { 13714 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13715 return r 13716 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13717 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(213) 13718 return r 13719 }(), Fdl: func() (r struct{ Fdad Ush }) { 13720 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13721 return r 13722 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13723 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(53) 13724 return r 13725 }(), Fdl: func() (r struct{ Fdad Ush }) { 13726 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13727 return r 13728 }()}, 13729 {Ffc: func() (r struct{ Ffreq Ush }) { 13730 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(181) 13731 return r 13732 }(), Fdl: func() (r struct{ Fdad Ush }) { 13733 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13734 return r 13735 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13736 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(117) 13737 return r 13738 }(), Fdl: func() (r struct{ Fdad Ush }) { 13739 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13740 return r 13741 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13742 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(245) 13743 return r 13744 }(), Fdl: func() (r struct{ Fdad Ush }) { 13745 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13746 return r 13747 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13748 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(13) 13749 return r 13750 }(), Fdl: func() (r struct{ Fdad Ush }) { 13751 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13752 return r 13753 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13754 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(141) 13755 return r 13756 }(), Fdl: func() (r struct{ Fdad Ush }) { 13757 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13758 return r 13759 }()}, 13760 {Ffc: func() (r struct{ Ffreq Ush }) { 13761 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(77) 13762 return r 13763 }(), Fdl: func() (r struct{ Fdad Ush }) { 13764 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13765 return r 13766 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13767 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(205) 13768 return r 13769 }(), Fdl: func() (r struct{ Fdad Ush }) { 13770 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13771 return r 13772 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13773 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(45) 13774 return r 13775 }(), Fdl: func() (r struct{ Fdad Ush }) { 13776 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13777 return r 13778 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13779 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(173) 13780 return r 13781 }(), Fdl: func() (r struct{ Fdad Ush }) { 13782 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13783 return r 13784 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13785 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(109) 13786 return r 13787 }(), Fdl: func() (r struct{ Fdad Ush }) { 13788 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13789 return r 13790 }()}, 13791 {Ffc: func() (r struct{ Ffreq Ush }) { 13792 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(237) 13793 return r 13794 }(), Fdl: func() (r struct{ Fdad Ush }) { 13795 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13796 return r 13797 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13798 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(29) 13799 return r 13800 }(), Fdl: func() (r struct{ Fdad Ush }) { 13801 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13802 return r 13803 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13804 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(157) 13805 return r 13806 }(), Fdl: func() (r struct{ Fdad Ush }) { 13807 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13808 return r 13809 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13810 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(93) 13811 return r 13812 }(), Fdl: func() (r struct{ Fdad Ush }) { 13813 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13814 return r 13815 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13816 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(221) 13817 return r 13818 }(), Fdl: func() (r struct{ Fdad Ush }) { 13819 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13820 return r 13821 }()}, 13822 {Ffc: func() (r struct{ Ffreq Ush }) { 13823 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(61) 13824 return r 13825 }(), Fdl: func() (r struct{ Fdad Ush }) { 13826 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13827 return r 13828 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13829 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(189) 13830 return r 13831 }(), Fdl: func() (r struct{ Fdad Ush }) { 13832 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13833 return r 13834 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13835 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(125) 13836 return r 13837 }(), Fdl: func() (r struct{ Fdad Ush }) { 13838 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13839 return r 13840 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13841 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(253) 13842 return r 13843 }(), Fdl: func() (r struct{ Fdad Ush }) { 13844 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 13845 return r 13846 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13847 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(19) 13848 return r 13849 }(), Fdl: func() (r struct{ Fdad Ush }) { 13850 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 13851 return r 13852 }()}, 13853 {Ffc: func() (r struct{ Ffreq Ush }) { 13854 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(275) 13855 return r 13856 }(), Fdl: func() (r struct{ Fdad Ush }) { 13857 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 13858 return r 13859 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13860 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(147) 13861 return r 13862 }(), Fdl: func() (r struct{ Fdad Ush }) { 13863 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 13864 return r 13865 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13866 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(403) 13867 return r 13868 }(), Fdl: func() (r struct{ Fdad Ush }) { 13869 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 13870 return r 13871 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13872 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(83) 13873 return r 13874 }(), Fdl: func() (r struct{ Fdad Ush }) { 13875 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 13876 return r 13877 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13878 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(339) 13879 return r 13880 }(), Fdl: func() (r struct{ Fdad Ush }) { 13881 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 13882 return r 13883 }()}, 13884 {Ffc: func() (r struct{ Ffreq Ush }) { 13885 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(211) 13886 return r 13887 }(), Fdl: func() (r struct{ Fdad Ush }) { 13888 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 13889 return r 13890 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13891 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(467) 13892 return r 13893 }(), Fdl: func() (r struct{ Fdad Ush }) { 13894 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 13895 return r 13896 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13897 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(51) 13898 return r 13899 }(), Fdl: func() (r struct{ Fdad Ush }) { 13900 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 13901 return r 13902 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13903 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(307) 13904 return r 13905 }(), Fdl: func() (r struct{ Fdad Ush }) { 13906 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 13907 return r 13908 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13909 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(179) 13910 return r 13911 }(), Fdl: func() (r struct{ Fdad Ush }) { 13912 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 13913 return r 13914 }()}, 13915 {Ffc: func() (r struct{ Ffreq Ush }) { 13916 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(435) 13917 return r 13918 }(), Fdl: func() (r struct{ Fdad Ush }) { 13919 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 13920 return r 13921 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13922 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(115) 13923 return r 13924 }(), Fdl: func() (r struct{ Fdad Ush }) { 13925 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 13926 return r 13927 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13928 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(371) 13929 return r 13930 }(), Fdl: func() (r struct{ Fdad Ush }) { 13931 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 13932 return r 13933 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13934 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(243) 13935 return r 13936 }(), Fdl: func() (r struct{ Fdad Ush }) { 13937 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 13938 return r 13939 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13940 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(499) 13941 return r 13942 }(), Fdl: func() (r struct{ Fdad Ush }) { 13943 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 13944 return r 13945 }()}, 13946 {Ffc: func() (r struct{ Ffreq Ush }) { 13947 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(11) 13948 return r 13949 }(), Fdl: func() (r struct{ Fdad Ush }) { 13950 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 13951 return r 13952 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13953 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(267) 13954 return r 13955 }(), Fdl: func() (r struct{ Fdad Ush }) { 13956 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 13957 return r 13958 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13959 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(139) 13960 return r 13961 }(), Fdl: func() (r struct{ Fdad Ush }) { 13962 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 13963 return r 13964 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13965 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(395) 13966 return r 13967 }(), Fdl: func() (r struct{ Fdad Ush }) { 13968 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 13969 return r 13970 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13971 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(75) 13972 return r 13973 }(), Fdl: func() (r struct{ Fdad Ush }) { 13974 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 13975 return r 13976 }()}, 13977 {Ffc: func() (r struct{ Ffreq Ush }) { 13978 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(331) 13979 return r 13980 }(), Fdl: func() (r struct{ Fdad Ush }) { 13981 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 13982 return r 13983 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13984 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(203) 13985 return r 13986 }(), Fdl: func() (r struct{ Fdad Ush }) { 13987 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 13988 return r 13989 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13990 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(459) 13991 return r 13992 }(), Fdl: func() (r struct{ Fdad Ush }) { 13993 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 13994 return r 13995 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 13996 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(43) 13997 return r 13998 }(), Fdl: func() (r struct{ Fdad Ush }) { 13999 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14000 return r 14001 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14002 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(299) 14003 return r 14004 }(), Fdl: func() (r struct{ Fdad Ush }) { 14005 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14006 return r 14007 }()}, 14008 {Ffc: func() (r struct{ Ffreq Ush }) { 14009 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(171) 14010 return r 14011 }(), Fdl: func() (r struct{ Fdad Ush }) { 14012 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14013 return r 14014 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14015 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(427) 14016 return r 14017 }(), Fdl: func() (r struct{ Fdad Ush }) { 14018 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14019 return r 14020 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14021 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(107) 14022 return r 14023 }(), Fdl: func() (r struct{ Fdad Ush }) { 14024 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14025 return r 14026 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14027 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(363) 14028 return r 14029 }(), Fdl: func() (r struct{ Fdad Ush }) { 14030 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14031 return r 14032 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14033 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(235) 14034 return r 14035 }(), Fdl: func() (r struct{ Fdad Ush }) { 14036 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14037 return r 14038 }()}, 14039 {Ffc: func() (r struct{ Ffreq Ush }) { 14040 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(491) 14041 return r 14042 }(), Fdl: func() (r struct{ Fdad Ush }) { 14043 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14044 return r 14045 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14046 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(27) 14047 return r 14048 }(), Fdl: func() (r struct{ Fdad Ush }) { 14049 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14050 return r 14051 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14052 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(283) 14053 return r 14054 }(), Fdl: func() (r struct{ Fdad Ush }) { 14055 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14056 return r 14057 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14058 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(155) 14059 return r 14060 }(), Fdl: func() (r struct{ Fdad Ush }) { 14061 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14062 return r 14063 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14064 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(411) 14065 return r 14066 }(), Fdl: func() (r struct{ Fdad Ush }) { 14067 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14068 return r 14069 }()}, 14070 {Ffc: func() (r struct{ Ffreq Ush }) { 14071 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(91) 14072 return r 14073 }(), Fdl: func() (r struct{ Fdad Ush }) { 14074 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14075 return r 14076 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14077 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(347) 14078 return r 14079 }(), Fdl: func() (r struct{ Fdad Ush }) { 14080 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14081 return r 14082 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14083 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(219) 14084 return r 14085 }(), Fdl: func() (r struct{ Fdad Ush }) { 14086 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14087 return r 14088 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14089 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(475) 14090 return r 14091 }(), Fdl: func() (r struct{ Fdad Ush }) { 14092 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14093 return r 14094 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14095 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(59) 14096 return r 14097 }(), Fdl: func() (r struct{ Fdad Ush }) { 14098 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14099 return r 14100 }()}, 14101 {Ffc: func() (r struct{ Ffreq Ush }) { 14102 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(315) 14103 return r 14104 }(), Fdl: func() (r struct{ Fdad Ush }) { 14105 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14106 return r 14107 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14108 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(187) 14109 return r 14110 }(), Fdl: func() (r struct{ Fdad Ush }) { 14111 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14112 return r 14113 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14114 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(443) 14115 return r 14116 }(), Fdl: func() (r struct{ Fdad Ush }) { 14117 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14118 return r 14119 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14120 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(123) 14121 return r 14122 }(), Fdl: func() (r struct{ Fdad Ush }) { 14123 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14124 return r 14125 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14126 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(379) 14127 return r 14128 }(), Fdl: func() (r struct{ Fdad Ush }) { 14129 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14130 return r 14131 }()}, 14132 {Ffc: func() (r struct{ Ffreq Ush }) { 14133 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(251) 14134 return r 14135 }(), Fdl: func() (r struct{ Fdad Ush }) { 14136 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14137 return r 14138 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14139 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(507) 14140 return r 14141 }(), Fdl: func() (r struct{ Fdad Ush }) { 14142 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14143 return r 14144 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14145 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7) 14146 return r 14147 }(), Fdl: func() (r struct{ Fdad Ush }) { 14148 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14149 return r 14150 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14151 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(263) 14152 return r 14153 }(), Fdl: func() (r struct{ Fdad Ush }) { 14154 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14155 return r 14156 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14157 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(135) 14158 return r 14159 }(), Fdl: func() (r struct{ Fdad Ush }) { 14160 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14161 return r 14162 }()}, 14163 {Ffc: func() (r struct{ Ffreq Ush }) { 14164 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(391) 14165 return r 14166 }(), Fdl: func() (r struct{ Fdad Ush }) { 14167 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14168 return r 14169 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14170 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(71) 14171 return r 14172 }(), Fdl: func() (r struct{ Fdad Ush }) { 14173 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14174 return r 14175 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14176 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(327) 14177 return r 14178 }(), Fdl: func() (r struct{ Fdad Ush }) { 14179 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14180 return r 14181 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14182 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(199) 14183 return r 14184 }(), Fdl: func() (r struct{ Fdad Ush }) { 14185 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14186 return r 14187 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14188 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(455) 14189 return r 14190 }(), Fdl: func() (r struct{ Fdad Ush }) { 14191 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14192 return r 14193 }()}, 14194 {Ffc: func() (r struct{ Ffreq Ush }) { 14195 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(39) 14196 return r 14197 }(), Fdl: func() (r struct{ Fdad Ush }) { 14198 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14199 return r 14200 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14201 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(295) 14202 return r 14203 }(), Fdl: func() (r struct{ Fdad Ush }) { 14204 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14205 return r 14206 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14207 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(167) 14208 return r 14209 }(), Fdl: func() (r struct{ Fdad Ush }) { 14210 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14211 return r 14212 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14213 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(423) 14214 return r 14215 }(), Fdl: func() (r struct{ Fdad Ush }) { 14216 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14217 return r 14218 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14219 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(103) 14220 return r 14221 }(), Fdl: func() (r struct{ Fdad Ush }) { 14222 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14223 return r 14224 }()}, 14225 {Ffc: func() (r struct{ Ffreq Ush }) { 14226 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(359) 14227 return r 14228 }(), Fdl: func() (r struct{ Fdad Ush }) { 14229 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14230 return r 14231 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14232 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(231) 14233 return r 14234 }(), Fdl: func() (r struct{ Fdad Ush }) { 14235 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14236 return r 14237 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14238 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(487) 14239 return r 14240 }(), Fdl: func() (r struct{ Fdad Ush }) { 14241 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14242 return r 14243 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14244 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(23) 14245 return r 14246 }(), Fdl: func() (r struct{ Fdad Ush }) { 14247 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14248 return r 14249 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14250 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(279) 14251 return r 14252 }(), Fdl: func() (r struct{ Fdad Ush }) { 14253 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14254 return r 14255 }()}, 14256 {Ffc: func() (r struct{ Ffreq Ush }) { 14257 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(151) 14258 return r 14259 }(), Fdl: func() (r struct{ Fdad Ush }) { 14260 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14261 return r 14262 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14263 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(407) 14264 return r 14265 }(), Fdl: func() (r struct{ Fdad Ush }) { 14266 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14267 return r 14268 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14269 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(87) 14270 return r 14271 }(), Fdl: func() (r struct{ Fdad Ush }) { 14272 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14273 return r 14274 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14275 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(343) 14276 return r 14277 }(), Fdl: func() (r struct{ Fdad Ush }) { 14278 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14279 return r 14280 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14281 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(215) 14282 return r 14283 }(), Fdl: func() (r struct{ Fdad Ush }) { 14284 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14285 return r 14286 }()}, 14287 {Ffc: func() (r struct{ Ffreq Ush }) { 14288 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(471) 14289 return r 14290 }(), Fdl: func() (r struct{ Fdad Ush }) { 14291 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14292 return r 14293 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14294 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(55) 14295 return r 14296 }(), Fdl: func() (r struct{ Fdad Ush }) { 14297 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14298 return r 14299 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14300 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(311) 14301 return r 14302 }(), Fdl: func() (r struct{ Fdad Ush }) { 14303 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14304 return r 14305 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14306 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(183) 14307 return r 14308 }(), Fdl: func() (r struct{ Fdad Ush }) { 14309 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14310 return r 14311 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14312 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(439) 14313 return r 14314 }(), Fdl: func() (r struct{ Fdad Ush }) { 14315 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14316 return r 14317 }()}, 14318 {Ffc: func() (r struct{ Ffreq Ush }) { 14319 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(119) 14320 return r 14321 }(), Fdl: func() (r struct{ Fdad Ush }) { 14322 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14323 return r 14324 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14325 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(375) 14326 return r 14327 }(), Fdl: func() (r struct{ Fdad Ush }) { 14328 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14329 return r 14330 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14331 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(247) 14332 return r 14333 }(), Fdl: func() (r struct{ Fdad Ush }) { 14334 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14335 return r 14336 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14337 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(503) 14338 return r 14339 }(), Fdl: func() (r struct{ Fdad Ush }) { 14340 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14341 return r 14342 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14343 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(15) 14344 return r 14345 }(), Fdl: func() (r struct{ Fdad Ush }) { 14346 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14347 return r 14348 }()}, 14349 {Ffc: func() (r struct{ Ffreq Ush }) { 14350 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(271) 14351 return r 14352 }(), Fdl: func() (r struct{ Fdad Ush }) { 14353 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14354 return r 14355 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14356 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(143) 14357 return r 14358 }(), Fdl: func() (r struct{ Fdad Ush }) { 14359 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14360 return r 14361 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14362 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(399) 14363 return r 14364 }(), Fdl: func() (r struct{ Fdad Ush }) { 14365 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14366 return r 14367 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14368 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(79) 14369 return r 14370 }(), Fdl: func() (r struct{ Fdad Ush }) { 14371 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14372 return r 14373 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14374 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(335) 14375 return r 14376 }(), Fdl: func() (r struct{ Fdad Ush }) { 14377 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14378 return r 14379 }()}, 14380 {Ffc: func() (r struct{ Ffreq Ush }) { 14381 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(207) 14382 return r 14383 }(), Fdl: func() (r struct{ Fdad Ush }) { 14384 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14385 return r 14386 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14387 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(463) 14388 return r 14389 }(), Fdl: func() (r struct{ Fdad Ush }) { 14390 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14391 return r 14392 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14393 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(47) 14394 return r 14395 }(), Fdl: func() (r struct{ Fdad Ush }) { 14396 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14397 return r 14398 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14399 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(303) 14400 return r 14401 }(), Fdl: func() (r struct{ Fdad Ush }) { 14402 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14403 return r 14404 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14405 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(175) 14406 return r 14407 }(), Fdl: func() (r struct{ Fdad Ush }) { 14408 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14409 return r 14410 }()}, 14411 {Ffc: func() (r struct{ Ffreq Ush }) { 14412 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(431) 14413 return r 14414 }(), Fdl: func() (r struct{ Fdad Ush }) { 14415 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14416 return r 14417 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14418 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(111) 14419 return r 14420 }(), Fdl: func() (r struct{ Fdad Ush }) { 14421 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14422 return r 14423 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14424 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(367) 14425 return r 14426 }(), Fdl: func() (r struct{ Fdad Ush }) { 14427 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14428 return r 14429 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14430 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(239) 14431 return r 14432 }(), Fdl: func() (r struct{ Fdad Ush }) { 14433 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14434 return r 14435 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14436 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(495) 14437 return r 14438 }(), Fdl: func() (r struct{ Fdad Ush }) { 14439 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14440 return r 14441 }()}, 14442 {Ffc: func() (r struct{ Ffreq Ush }) { 14443 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(31) 14444 return r 14445 }(), Fdl: func() (r struct{ Fdad Ush }) { 14446 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14447 return r 14448 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14449 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(287) 14450 return r 14451 }(), Fdl: func() (r struct{ Fdad Ush }) { 14452 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14453 return r 14454 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14455 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(159) 14456 return r 14457 }(), Fdl: func() (r struct{ Fdad Ush }) { 14458 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14459 return r 14460 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14461 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(415) 14462 return r 14463 }(), Fdl: func() (r struct{ Fdad Ush }) { 14464 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14465 return r 14466 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14467 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(95) 14468 return r 14469 }(), Fdl: func() (r struct{ Fdad Ush }) { 14470 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14471 return r 14472 }()}, 14473 {Ffc: func() (r struct{ Ffreq Ush }) { 14474 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(351) 14475 return r 14476 }(), Fdl: func() (r struct{ Fdad Ush }) { 14477 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14478 return r 14479 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14480 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(223) 14481 return r 14482 }(), Fdl: func() (r struct{ Fdad Ush }) { 14483 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14484 return r 14485 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14486 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(479) 14487 return r 14488 }(), Fdl: func() (r struct{ Fdad Ush }) { 14489 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14490 return r 14491 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14492 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(63) 14493 return r 14494 }(), Fdl: func() (r struct{ Fdad Ush }) { 14495 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14496 return r 14497 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14498 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(319) 14499 return r 14500 }(), Fdl: func() (r struct{ Fdad Ush }) { 14501 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14502 return r 14503 }()}, 14504 {Ffc: func() (r struct{ Ffreq Ush }) { 14505 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(191) 14506 return r 14507 }(), Fdl: func() (r struct{ Fdad Ush }) { 14508 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14509 return r 14510 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14511 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(447) 14512 return r 14513 }(), Fdl: func() (r struct{ Fdad Ush }) { 14514 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14515 return r 14516 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14517 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(127) 14518 return r 14519 }(), Fdl: func() (r struct{ Fdad Ush }) { 14520 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14521 return r 14522 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14523 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(383) 14524 return r 14525 }(), Fdl: func() (r struct{ Fdad Ush }) { 14526 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14527 return r 14528 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14529 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(255) 14530 return r 14531 }(), Fdl: func() (r struct{ Fdad Ush }) { 14532 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14533 return r 14534 }()}, 14535 {Ffc: func() (r struct{ Ffreq Ush }) { 14536 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(511) 14537 return r 14538 }(), Fdl: func() (r struct{ Fdad Ush }) { 14539 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14540 return r 14541 }()}, {Fdl: func() (r struct{ Fdad Ush }) { 14542 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7) 14543 return r 14544 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14545 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(64) 14546 return r 14547 }(), Fdl: func() (r struct{ Fdad Ush }) { 14548 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7) 14549 return r 14550 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14551 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(32) 14552 return r 14553 }(), Fdl: func() (r struct{ Fdad Ush }) { 14554 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7) 14555 return r 14556 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14557 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(96) 14558 return r 14559 }(), Fdl: func() (r struct{ Fdad Ush }) { 14560 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7) 14561 return r 14562 }()}, 14563 {Ffc: func() (r struct{ Ffreq Ush }) { 14564 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(16) 14565 return r 14566 }(), Fdl: func() (r struct{ Fdad Ush }) { 14567 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7) 14568 return r 14569 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14570 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(80) 14571 return r 14572 }(), Fdl: func() (r struct{ Fdad Ush }) { 14573 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7) 14574 return r 14575 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14576 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(48) 14577 return r 14578 }(), Fdl: func() (r struct{ Fdad Ush }) { 14579 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7) 14580 return r 14581 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14582 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(112) 14583 return r 14584 }(), Fdl: func() (r struct{ Fdad Ush }) { 14585 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7) 14586 return r 14587 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14588 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 14589 return r 14590 }(), Fdl: func() (r struct{ Fdad Ush }) { 14591 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7) 14592 return r 14593 }()}, 14594 {Ffc: func() (r struct{ Ffreq Ush }) { 14595 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(72) 14596 return r 14597 }(), Fdl: func() (r struct{ Fdad Ush }) { 14598 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7) 14599 return r 14600 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14601 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(40) 14602 return r 14603 }(), Fdl: func() (r struct{ Fdad Ush }) { 14604 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7) 14605 return r 14606 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14607 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(104) 14608 return r 14609 }(), Fdl: func() (r struct{ Fdad Ush }) { 14610 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7) 14611 return r 14612 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14613 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(24) 14614 return r 14615 }(), Fdl: func() (r struct{ Fdad Ush }) { 14616 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7) 14617 return r 14618 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14619 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(88) 14620 return r 14621 }(), Fdl: func() (r struct{ Fdad Ush }) { 14622 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7) 14623 return r 14624 }()}, 14625 {Ffc: func() (r struct{ Ffreq Ush }) { 14626 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(56) 14627 return r 14628 }(), Fdl: func() (r struct{ Fdad Ush }) { 14629 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7) 14630 return r 14631 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14632 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(120) 14633 return r 14634 }(), Fdl: func() (r struct{ Fdad Ush }) { 14635 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7) 14636 return r 14637 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14638 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(4) 14639 return r 14640 }(), Fdl: func() (r struct{ Fdad Ush }) { 14641 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7) 14642 return r 14643 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14644 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(68) 14645 return r 14646 }(), Fdl: func() (r struct{ Fdad Ush }) { 14647 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7) 14648 return r 14649 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14650 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(36) 14651 return r 14652 }(), Fdl: func() (r struct{ Fdad Ush }) { 14653 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7) 14654 return r 14655 }()}, 14656 {Ffc: func() (r struct{ Ffreq Ush }) { 14657 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(100) 14658 return r 14659 }(), Fdl: func() (r struct{ Fdad Ush }) { 14660 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7) 14661 return r 14662 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14663 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(20) 14664 return r 14665 }(), Fdl: func() (r struct{ Fdad Ush }) { 14666 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7) 14667 return r 14668 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14669 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(84) 14670 return r 14671 }(), Fdl: func() (r struct{ Fdad Ush }) { 14672 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7) 14673 return r 14674 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14675 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(52) 14676 return r 14677 }(), Fdl: func() (r struct{ Fdad Ush }) { 14678 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7) 14679 return r 14680 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14681 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(116) 14682 return r 14683 }(), Fdl: func() (r struct{ Fdad Ush }) { 14684 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7) 14685 return r 14686 }()}, 14687 {Ffc: func() (r struct{ Ffreq Ush }) { 14688 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(3) 14689 return r 14690 }(), Fdl: func() (r struct{ Fdad Ush }) { 14691 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 14692 return r 14693 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14694 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(131) 14695 return r 14696 }(), Fdl: func() (r struct{ Fdad Ush }) { 14697 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 14698 return r 14699 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14700 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(67) 14701 return r 14702 }(), Fdl: func() (r struct{ Fdad Ush }) { 14703 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 14704 return r 14705 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14706 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(195) 14707 return r 14708 }(), Fdl: func() (r struct{ Fdad Ush }) { 14709 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 14710 return r 14711 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14712 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(35) 14713 return r 14714 }(), Fdl: func() (r struct{ Fdad Ush }) { 14715 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 14716 return r 14717 }()}, 14718 {Ffc: func() (r struct{ Ffreq Ush }) { 14719 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(163) 14720 return r 14721 }(), Fdl: func() (r struct{ Fdad Ush }) { 14722 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 14723 return r 14724 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14725 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(99) 14726 return r 14727 }(), Fdl: func() (r struct{ Fdad Ush }) { 14728 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 14729 return r 14730 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14731 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(227) 14732 return r 14733 }(), Fdl: func() (r struct{ Fdad Ush }) { 14734 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 14735 return r 14736 }()}} /* trees.h:3:21 */ 14737 14738 var static_dtree = [30]Ct_data{{Fdl: func() (r struct{ Fdad Ush }) { 14739 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14740 return r 14741 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14742 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(16) 14743 return r 14744 }(), Fdl: func() (r struct{ Fdad Ush }) { 14745 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14746 return r 14747 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14748 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(8) 14749 return r 14750 }(), Fdl: func() (r struct{ Fdad Ush }) { 14751 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14752 return r 14753 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14754 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(24) 14755 return r 14756 }(), Fdl: func() (r struct{ Fdad Ush }) { 14757 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14758 return r 14759 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14760 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(4) 14761 return r 14762 }(), Fdl: func() (r struct{ Fdad Ush }) { 14763 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14764 return r 14765 }()}, 14766 {Ffc: func() (r struct{ Ffreq Ush }) { 14767 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(20) 14768 return r 14769 }(), Fdl: func() (r struct{ Fdad Ush }) { 14770 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14771 return r 14772 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14773 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(12) 14774 return r 14775 }(), Fdl: func() (r struct{ Fdad Ush }) { 14776 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14777 return r 14778 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14779 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(28) 14780 return r 14781 }(), Fdl: func() (r struct{ Fdad Ush }) { 14782 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14783 return r 14784 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14785 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(2) 14786 return r 14787 }(), Fdl: func() (r struct{ Fdad Ush }) { 14788 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14789 return r 14790 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14791 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(18) 14792 return r 14793 }(), Fdl: func() (r struct{ Fdad Ush }) { 14794 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14795 return r 14796 }()}, 14797 {Ffc: func() (r struct{ Ffreq Ush }) { 14798 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(10) 14799 return r 14800 }(), Fdl: func() (r struct{ Fdad Ush }) { 14801 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14802 return r 14803 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14804 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(26) 14805 return r 14806 }(), Fdl: func() (r struct{ Fdad Ush }) { 14807 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14808 return r 14809 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14810 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(6) 14811 return r 14812 }(), Fdl: func() (r struct{ Fdad Ush }) { 14813 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14814 return r 14815 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14816 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(22) 14817 return r 14818 }(), Fdl: func() (r struct{ Fdad Ush }) { 14819 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14820 return r 14821 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14822 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(14) 14823 return r 14824 }(), Fdl: func() (r struct{ Fdad Ush }) { 14825 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14826 return r 14827 }()}, 14828 {Ffc: func() (r struct{ Ffreq Ush }) { 14829 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(30) 14830 return r 14831 }(), Fdl: func() (r struct{ Fdad Ush }) { 14832 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14833 return r 14834 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14835 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(1) 14836 return r 14837 }(), Fdl: func() (r struct{ Fdad Ush }) { 14838 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14839 return r 14840 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14841 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(17) 14842 return r 14843 }(), Fdl: func() (r struct{ Fdad Ush }) { 14844 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14845 return r 14846 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14847 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(9) 14848 return r 14849 }(), Fdl: func() (r struct{ Fdad Ush }) { 14850 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14851 return r 14852 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14853 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(25) 14854 return r 14855 }(), Fdl: func() (r struct{ Fdad Ush }) { 14856 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14857 return r 14858 }()}, 14859 {Ffc: func() (r struct{ Ffreq Ush }) { 14860 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14861 return r 14862 }(), Fdl: func() (r struct{ Fdad Ush }) { 14863 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14864 return r 14865 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14866 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(21) 14867 return r 14868 }(), Fdl: func() (r struct{ Fdad Ush }) { 14869 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14870 return r 14871 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14872 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(13) 14873 return r 14874 }(), Fdl: func() (r struct{ Fdad Ush }) { 14875 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14876 return r 14877 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14878 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(29) 14879 return r 14880 }(), Fdl: func() (r struct{ Fdad Ush }) { 14881 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14882 return r 14883 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14884 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(3) 14885 return r 14886 }(), Fdl: func() (r struct{ Fdad Ush }) { 14887 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14888 return r 14889 }()}, 14890 {Ffc: func() (r struct{ Ffreq Ush }) { 14891 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(19) 14892 return r 14893 }(), Fdl: func() (r struct{ Fdad Ush }) { 14894 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14895 return r 14896 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14897 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(11) 14898 return r 14899 }(), Fdl: func() (r struct{ Fdad Ush }) { 14900 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14901 return r 14902 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14903 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(27) 14904 return r 14905 }(), Fdl: func() (r struct{ Fdad Ush }) { 14906 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14907 return r 14908 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14909 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(7) 14910 return r 14911 }(), Fdl: func() (r struct{ Fdad Ush }) { 14912 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14913 return r 14914 }()}, {Ffc: func() (r struct{ Ffreq Ush }) { 14915 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(23) 14916 return r 14917 }(), Fdl: func() (r struct{ Fdad Ush }) { 14918 *(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = Ush(5) 14919 return r 14920 }()}} /* trees.h:64:21 */ 14921 14922 var X_dist_code = [512]Uch{ 14923 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), 14924 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), 14925 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), 14926 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), 14927 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), 14928 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), 14929 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), 14930 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), 14931 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), 14932 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), 14933 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), 14934 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), 14935 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), 14936 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), 14937 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), 14938 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), 14939 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), 14940 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), 14941 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), 14942 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), 14943 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), 14944 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), 14945 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), 14946 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), 14947 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), 14948 Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), Uch(29), 14949 } /* trees.h:73:25 */ 14950 14951 var X_length_code = [256]Uch{ 14952 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), 14953 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), 14954 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), 14955 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), 14956 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), 14957 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), 14958 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), 14959 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), 14960 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), 14961 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), 14962 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), 14963 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), 14964 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), 14965 } /* trees.h:102:25 */ 14966 14967 var base_length = [29]int32{ 14968 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, 14969 64, 80, 96, 112, 128, 160, 192, 224, 0, 14970 } /* trees.h:118:17 */ 14971 14972 var base_dist = [30]int32{ 14973 0, 1, 2, 3, 4, 6, 8, 12, 16, 24, 14974 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, 14975 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576, 14976 } /* trees.h:123:17 */ 14977 14978 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 */ 14979 14980 var static_d_desc = Static_tree_desc{Fstatic_tree: 0, Fextra_bits: 0, Felems: D_CODES, Fmax_length: MAX_BITS} /* trees.c:128:31 */ 14981 14982 var static_bl_desc = Static_tree_desc{Fextra_bits: 0, Felems: BL_CODES, Fmax_length: MAX_BL_BITS} /* trees.c:131:31 */ 14983 14984 // Send a code of the given tree. c and tree must not have side effects 14985 14986 // =========================================================================== 14987 // Output a short LSB first on the stream. 14988 // IN assertion: there is enough room in pendingBuf. 14989 14990 // =========================================================================== 14991 // Send a value on a given number of bits. 14992 // IN assertion: length <= 16 and value fits in length bits. 14993 14994 // the arguments must not have side effects 14995 14996 // =========================================================================== 14997 // Initialize the various 'constant' tables. 14998 func tr_static_init(tls *libc.TLS) { /* trees.c:232:12: */ 14999 } 15000 15001 // =========================================================================== 15002 // Genererate the file trees.h describing the static trees. 15003 15004 // =========================================================================== 15005 // Initialize the tree data structures for a new zlib stream. 15006 func X_tr_init(tls *libc.TLS, s uintptr) { /* trees.c:379:20: */ 15007 tr_static_init(tls) 15008 15009 (*Deflate_state)(unsafe.Pointer(s)).Fl_desc.Fdyn_tree = s + 188 /* &.dyn_ltree */ 15010 (*Deflate_state)(unsafe.Pointer(s)).Fl_desc.Fstat_desc = uintptr(unsafe.Pointer(&static_l_desc)) 15011 15012 (*Deflate_state)(unsafe.Pointer(s)).Fd_desc.Fdyn_tree = s + 2480 /* &.dyn_dtree */ 15013 (*Deflate_state)(unsafe.Pointer(s)).Fd_desc.Fstat_desc = uintptr(unsafe.Pointer(&static_d_desc)) 15014 15015 (*Deflate_state)(unsafe.Pointer(s)).Fbl_desc.Fdyn_tree = s + 2724 /* &.bl_tree */ 15016 (*Deflate_state)(unsafe.Pointer(s)).Fbl_desc.Fstat_desc = uintptr(unsafe.Pointer(&static_bl_desc)) 15017 15018 (*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(0) 15019 (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid = 0 15020 15021 // Initialize the first block of the first file: 15022 init_block(tls, s) 15023 } 15024 15025 // =========================================================================== 15026 // Initialize a new block. 15027 func init_block(tls *libc.TLS, s uintptr) { /* trees.c:407:12: */ 15028 var n int32 // iterates over tree elements 15029 15030 // Initialize the trees. 15031 for n = 0; n < ((LITERALS + 1) + LENGTH_CODES); n++ { 15032 *(*Ush)(unsafe.Pointer((s + 188 /* &.dyn_ltree */) + uintptr(n)*4 /* &.fc */)) = Ush(0) 15033 } 15034 for n = 0; n < D_CODES; n++ { 15035 *(*Ush)(unsafe.Pointer((s + 2480 /* &.dyn_dtree */) + uintptr(n)*4 /* &.fc */)) = Ush(0) 15036 } 15037 for n = 0; n < BL_CODES; n++ { 15038 *(*Ush)(unsafe.Pointer((s + 2724 /* &.bl_tree */) + uintptr(n)*4 /* &.fc */)) = Ush(0) 15039 } 15040 15041 *(*Ush)(unsafe.Pointer((s + 188 /* &.dyn_ltree */) + 256*4 /* &.fc */)) = Ush(1) 15042 (*Deflate_state)(unsafe.Pointer(s)).Fopt_len = libc.AssignPtrUint32(s+5892 /* &.static_len */, Ulg(0)) 15043 (*Deflate_state)(unsafe.Pointer(s)).Flast_lit = libc.AssignPtrUint32(s+5896 /* &.matches */, UInt(0)) 15044 } 15045 15046 // Index within the heap array of least frequent node in the Huffman tree 15047 15048 // =========================================================================== 15049 // Remove the smallest element from the heap and recreate the heap with 15050 // one less element. Updates heap and heap_len. 15051 15052 // =========================================================================== 15053 // Compares to subtrees, using the tree depth as tie breaker when 15054 // the subtrees have equal frequency. This minimizes the worst case length. 15055 15056 // =========================================================================== 15057 // Restore the heap property by moving down the tree starting at node k, 15058 // exchanging a node with the smallest of its two sons if necessary, stopping 15059 // when the heap property is re-established (each father smaller than its 15060 // two sons). 15061 func pqdownheap(tls *libc.TLS, s uintptr, tree uintptr, k int32) { /* trees.c:451:12: */ 15062 var v int32 = *(*int32)(unsafe.Pointer((s + 2984 /* &.heap */) + uintptr(k)*4)) 15063 var j int32 = (k << 1) // left son of k 15064 for j <= (*Deflate_state)(unsafe.Pointer(s)).Fheap_len { 15065 // Set j to the smallest of the two sons: 15066 if (j < (*Deflate_state)(unsafe.Pointer(s)).Fheap_len) && ((int32(*(*Ush)(unsafe.Pointer(tree + uintptr(*(*int32)(unsafe.Pointer((s + 2984 /* &.heap */) + uintptr((j+1))*4)))*4 /* &.fc */))) < int32(*(*Ush)(unsafe.Pointer(tree + uintptr(*(*int32)(unsafe.Pointer((s + 2984 /* &.heap */) + uintptr(j)*4)))*4 /* &.fc */)))) || ((int32(*(*Ush)(unsafe.Pointer(tree + uintptr(*(*int32)(unsafe.Pointer((s + 2984 /* &.heap */) + uintptr((j+1))*4)))*4 /* &.fc */))) == int32(*(*Ush)(unsafe.Pointer(tree + uintptr(*(*int32)(unsafe.Pointer((s + 2984 /* &.heap */) + uintptr(j)*4)))*4 /* &.fc */)))) && (int32(*(*Uch)(unsafe.Pointer((s + 5284 /* &.depth */) + uintptr(*(*int32)(unsafe.Pointer((s + 2984 /* &.heap */) + uintptr((j+1))*4)))))) <= int32(*(*Uch)(unsafe.Pointer((s + 5284 /* &.depth */) + uintptr(*(*int32)(unsafe.Pointer((s + 2984 /* &.heap */) + uintptr(j)*4))))))))) { 15067 j++ 15068 } 15069 // Exit if v is smaller than both sons 15070 if (int32(*(*Ush)(unsafe.Pointer(tree + uintptr(v)*4 /* &.fc */))) < int32(*(*Ush)(unsafe.Pointer(tree + uintptr(*(*int32)(unsafe.Pointer((s + 2984 /* &.heap */) + uintptr(j)*4)))*4 /* &.fc */)))) || ((int32(*(*Ush)(unsafe.Pointer(tree + uintptr(v)*4 /* &.fc */))) == int32(*(*Ush)(unsafe.Pointer(tree + uintptr(*(*int32)(unsafe.Pointer((s + 2984 /* &.heap */) + uintptr(j)*4)))*4 /* &.fc */)))) && (int32(*(*Uch)(unsafe.Pointer((s + 5284 /* &.depth */) + uintptr(v)))) <= int32(*(*Uch)(unsafe.Pointer((s + 5284 /* &.depth */) + uintptr(*(*int32)(unsafe.Pointer((s + 2984 /* &.heap */) + uintptr(j)*4)))))))) { 15071 break 15072 } 15073 15074 // Exchange v with the smallest son 15075 *(*int32)(unsafe.Pointer((s + 2984 /* &.heap */) + uintptr(k)*4)) = *(*int32)(unsafe.Pointer((s + 2984 /* &.heap */) + uintptr(j)*4)) 15076 k = j 15077 15078 // And continue down the tree, setting j to the left son of k 15079 j <<= 1 15080 } 15081 *(*int32)(unsafe.Pointer((s + 2984 /* &.heap */) + uintptr(k)*4)) = v 15082 } 15083 15084 // =========================================================================== 15085 // Compute the optimal bit lengths for a tree and update the total bit length 15086 // for the current block. 15087 // IN assertion: the fields freq and dad are set, heap[heap_max] and 15088 // above are the tree nodes sorted by increasing frequency. 15089 // OUT assertions: the field len is set to the optimal bit length, the 15090 // array bl_count contains the frequencies for each bit length. 15091 // The length opt_len is updated; static_len is also updated if stree is 15092 // not null. 15093 func gen_bitlen(tls *libc.TLS, s uintptr, desc uintptr) { /* trees.c:486:12: */ 15094 var tree uintptr = (*Tree_desc)(unsafe.Pointer(desc)).Fdyn_tree 15095 var max_code int32 = (*Tree_desc)(unsafe.Pointer(desc)).Fmax_code 15096 var stree uintptr = (*Static_tree_desc)(unsafe.Pointer((*Tree_desc)(unsafe.Pointer(desc)).Fstat_desc)).Fstatic_tree 15097 var extra uintptr = (*Static_tree_desc)(unsafe.Pointer((*Tree_desc)(unsafe.Pointer(desc)).Fstat_desc)).Fextra_bits 15098 var base int32 = (*Static_tree_desc)(unsafe.Pointer((*Tree_desc)(unsafe.Pointer(desc)).Fstat_desc)).Fextra_base 15099 var max_length int32 = (*Static_tree_desc)(unsafe.Pointer((*Tree_desc)(unsafe.Pointer(desc)).Fstat_desc)).Fmax_length 15100 var h int32 // heap index 15101 var n int32 15102 var m int32 // iterate over the tree elements 15103 var bits int32 // bit length 15104 var xbits int32 // extra bits 15105 var f Ush // frequency 15106 var overflow int32 = 0 // number of elements with bit length too large 15107 15108 for bits = 0; bits <= MAX_BITS; bits++ { 15109 *(*Ush)(unsafe.Pointer((s + 2952 /* &.bl_count */) + uintptr(bits)*2)) = Ush(0) 15110 } 15111 15112 // In a first pass, compute the optimal bit lengths (which may 15113 // overflow in the case of the bit length tree). 15114 *(*Ush)(unsafe.Pointer(tree + uintptr(*(*int32)(unsafe.Pointer((s + 2984 /* &.heap */) + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fheap_max)*4)))*4 + 2 /* &.dl */)) = Ush(0) // root of the heap 15115 15116 for h = ((*Deflate_state)(unsafe.Pointer(s)).Fheap_max + 1); h < ((2 * ((LITERALS + 1) + LENGTH_CODES)) + 1); h++ { 15117 n = *(*int32)(unsafe.Pointer((s + 2984 /* &.heap */) + uintptr(h)*4)) 15118 bits = (int32(*(*Ush)(unsafe.Pointer(tree + uintptr(*(*Ush)(unsafe.Pointer(tree + uintptr(n)*4 + 2 /* &.dl */)))*4 + 2 /* &.dl */))) + 1) 15119 if bits > max_length { 15120 bits = max_length 15121 overflow++ 15122 } 15123 *(*Ush)(unsafe.Pointer(tree + uintptr(n)*4 + 2 /* &.dl */)) = Ush(bits) 15124 // We overwrite tree[n].Dad which is no longer needed 15125 15126 if n > max_code { 15127 continue 15128 } // not a leaf node 15129 15130 *(*Ush)(unsafe.Pointer((s + 2952 /* &.bl_count */) + uintptr(bits)*2))++ 15131 xbits = 0 15132 if n >= base { 15133 xbits = *(*Intf)(unsafe.Pointer(extra + uintptr((n-base))*4)) 15134 } 15135 f = *(*Ush)(unsafe.Pointer(tree + uintptr(n)*4 /* &.fc */)) 15136 *(*Ulg)(unsafe.Pointer(s + 5888 /* &.opt_len */)) += (Ulg(f) * Ulg((uint32(bits + xbits)))) 15137 if stree != 0 { 15138 *(*Ulg)(unsafe.Pointer(s + 5892 /* &.static_len */)) += (Ulg(f) * Ulg((uint32(int32(*(*Ush)(unsafe.Pointer(stree + uintptr(n)*4 + 2 /* &.dl */))) + xbits)))) 15139 } 15140 } 15141 if overflow == 0 { 15142 return 15143 } 15144 15145 // This happens for example on obj2 and pic of the Calgary corpus 15146 15147 // Find the first bit length which could increase: 15148 for ok := true; ok; ok = (overflow > 0) { 15149 bits = (max_length - 1) 15150 for int32(*(*Ush)(unsafe.Pointer((s + 2952 /* &.bl_count */) + uintptr(bits)*2))) == 0 { 15151 bits-- 15152 } 15153 *(*Ush)(unsafe.Pointer((s + 2952 /* &.bl_count */) + uintptr(bits)*2))-- // move one leaf down the tree 15154 *(*Ush)(unsafe.Pointer((s + 2952 /* &.bl_count */) + uintptr((bits+1))*2)) += Ush((2)) // move one overflow item as its brother 15155 *(*Ush)(unsafe.Pointer((s + 2952 /* &.bl_count */) + uintptr(max_length)*2))-- 15156 // The brother of the overflow item also moves one step up, 15157 // but this does not affect bl_count[max_length] 15158 overflow = overflow - (2) 15159 } 15160 15161 // Now recompute all bit lengths, scanning in increasing frequency. 15162 // h is still equal to HEAP_SIZE. (It is simpler to reconstruct all 15163 // lengths instead of fixing only the wrong ones. This idea is taken 15164 // from 'ar' written by Haruhiko Okumura.) 15165 for bits = max_length; bits != 0; bits-- { 15166 n = int32(*(*Ush)(unsafe.Pointer((s + 2952 /* &.bl_count */) + uintptr(bits)*2))) 15167 for n != 0 { 15168 m = *(*int32)(unsafe.Pointer((s + 2984 /* &.heap */) + uintptr(libc.PreDecInt32(&h, 1))*4)) 15169 if m > max_code { 15170 continue 15171 } 15172 if uint32(*(*Ush)(unsafe.Pointer(tree + uintptr(m)*4 + 2 /* &.dl */))) != uint32(bits) { 15173 15174 *(*Ulg)(unsafe.Pointer(s + 5888 /* &.opt_len */)) += ((Ulg(bits) - Ulg(*(*Ush)(unsafe.Pointer(tree + uintptr(m)*4 + 2 /* &.dl */)))) * Ulg(*(*Ush)(unsafe.Pointer(tree + uintptr(m)*4 /* &.fc */)))) 15175 *(*Ush)(unsafe.Pointer(tree + uintptr(m)*4 + 2 /* &.dl */)) = Ush(bits) 15176 } 15177 n-- 15178 } 15179 } 15180 } 15181 15182 // =========================================================================== 15183 // Generate the codes for a given tree and bit counts (which need not be 15184 // optimal). 15185 // IN assertion: the array bl_count contains the bit length statistics for 15186 // the given tree and the field len is set for all tree elements. 15187 // OUT assertion: the field code is set for all tree elements of non 15188 // zero code length. 15189 func gen_codes(tls *libc.TLS, tree uintptr, max_code int32, bl_count uintptr) { /* trees.c:572:12: */ 15190 bp := tls.Alloc(32) 15191 defer tls.Free(32) 15192 15193 // var next_code [16]Ush at bp, 32 15194 // next code value for each bit length 15195 var code uint32 = uint32(0) // running code value 15196 var bits int32 // bit index 15197 var n int32 // code index 15198 15199 // The distribution counts are first used to generate the code values 15200 // without bit reversal. 15201 for bits = 1; bits <= MAX_BITS; bits++ { 15202 code = ((code + uint32(*(*Ushf)(unsafe.Pointer(bl_count + uintptr((bits-1))*2)))) << 1) 15203 *(*Ush)(unsafe.Pointer(bp /* &next_code[0] */ + uintptr(bits)*2)) = Ush(code) 15204 } 15205 // Check that the bit counts in bl_count are consistent. The last code 15206 // must be all ones. 15207 15208 for n = 0; n <= max_code; n++ { 15209 var len int32 = int32(*(*Ush)(unsafe.Pointer(tree + uintptr(n)*4 + 2 /* &.dl */))) 15210 if len == 0 { 15211 continue 15212 } 15213 // Now reverse the bits 15214 *(*Ush)(unsafe.Pointer(tree + uintptr(n)*4 /* &.fc */)) = Ush(bi_reverse(tls, uint32(libc.PostIncUint16(&*(*Ush)(unsafe.Pointer(bp /* &next_code[0] */ + uintptr(len)*2)), 1)), len)) 15215 15216 } 15217 } 15218 15219 // =========================================================================== 15220 // Construct one Huffman tree and assigns the code bit strings and lengths. 15221 // Update the total bit length for the current block. 15222 // IN assertion: the field freq is set for all tree elements. 15223 // OUT assertions: the fields len and code are set to the optimal bit length 15224 // and corresponding code. The length opt_len is updated; static_len is 15225 // also updated if stree is not null. The field max_code is set. 15226 func build_tree(tls *libc.TLS, s uintptr, desc uintptr) { /* trees.c:615:12: */ 15227 var tree uintptr = (*Tree_desc)(unsafe.Pointer(desc)).Fdyn_tree 15228 var stree uintptr = (*Static_tree_desc)(unsafe.Pointer((*Tree_desc)(unsafe.Pointer(desc)).Fstat_desc)).Fstatic_tree 15229 var elems int32 = (*Static_tree_desc)(unsafe.Pointer((*Tree_desc)(unsafe.Pointer(desc)).Fstat_desc)).Felems 15230 var n int32 15231 var m int32 // iterate over heap elements 15232 var max_code int32 = -1 // largest code with non zero frequency 15233 var node int32 // new node being created 15234 15235 // Construct the initial heap, with least frequent element in 15236 // heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. 15237 // heap[0] is not used. 15238 (*Deflate_state)(unsafe.Pointer(s)).Fheap_len = 0 15239 (*Deflate_state)(unsafe.Pointer(s)).Fheap_max = ((2 * ((LITERALS + 1) + LENGTH_CODES)) + 1) 15240 15241 for n = 0; n < elems; n++ { 15242 if int32(*(*Ush)(unsafe.Pointer(tree + uintptr(n)*4 /* &.fc */))) != 0 { 15243 *(*int32)(unsafe.Pointer((s + 2984 /* &.heap */) + uintptr(libc.PreIncInt32(&((*Deflate_state)(unsafe.Pointer(s)).Fheap_len), 1))*4)) = libc.AssignInt32(&max_code, n) 15244 *(*Uch)(unsafe.Pointer((s + 5284 /* &.depth */) + uintptr(n))) = Uch(0) 15245 } else { 15246 *(*Ush)(unsafe.Pointer(tree + uintptr(n)*4 + 2 /* &.dl */)) = Ush(0) 15247 } 15248 } 15249 15250 // The pkzip format requires that at least one distance code exists, 15251 // and that at least one bit should be sent even if there is only one 15252 // possible code. So to avoid special checks later on we force at least 15253 // two codes of non zero frequency. 15254 for (*Deflate_state)(unsafe.Pointer(s)).Fheap_len < 2 { 15255 node = libc.AssignPtrInt32((s+2984 /* &.heap */)+uintptr(libc.PreIncInt32(&((*Deflate_state)(unsafe.Pointer(s)).Fheap_len), 1))*4, func() int32 { 15256 if max_code < 2 { 15257 return libc.PreIncInt32(&max_code, 1) 15258 } 15259 return 0 15260 }()) 15261 *(*Ush)(unsafe.Pointer(tree + uintptr(node)*4 /* &.fc */)) = Ush(1) 15262 *(*Uch)(unsafe.Pointer((s + 5284 /* &.depth */) + uintptr(node))) = Uch(0) 15263 (*Deflate_state)(unsafe.Pointer(s)).Fopt_len-- 15264 if stree != 0 { 15265 *(*Ulg)(unsafe.Pointer(s + 5892 /* &.static_len */)) -= (Ulg(*(*Ush)(unsafe.Pointer(stree + uintptr(node)*4 + 2 /* &.dl */)))) 15266 } 15267 // node is 0 or 1 so it does not have extra bits 15268 } 15269 (*Tree_desc)(unsafe.Pointer(desc)).Fmax_code = max_code 15270 15271 // The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree, 15272 // establish sub-heaps of increasing lengths: 15273 for n = ((*Deflate_state)(unsafe.Pointer(s)).Fheap_len / 2); n >= 1; n-- { 15274 pqdownheap(tls, s, tree, n) 15275 } 15276 15277 // Construct the Huffman tree by repeatedly combining the least two 15278 // frequent nodes. 15279 node = elems // next internal node of the tree 15280 for ok := true; ok; ok = ((*Deflate_state)(unsafe.Pointer(s)).Fheap_len >= 2) { 15281 { 15282 n = *(*int32)(unsafe.Pointer((s + 2984 /* &.heap */) + 1*4)) 15283 *(*int32)(unsafe.Pointer((s + 2984 /* &.heap */) + 1*4)) = *(*int32)(unsafe.Pointer((s + 2984 /* &.heap */) + uintptr(libc.PostDecInt32(&(*Deflate_state)(unsafe.Pointer(s)).Fheap_len, 1))*4)) 15284 pqdownheap(tls, s, tree, SMALLEST) 15285 } 15286 // n = node of least frequency 15287 m = *(*int32)(unsafe.Pointer((s + 2984 /* &.heap */) + 1*4)) // m = node of next least frequency 15288 15289 *(*int32)(unsafe.Pointer((s + 2984 /* &.heap */) + uintptr(libc.PreDecInt32(&((*Deflate_state)(unsafe.Pointer(s)).Fheap_max), 1))*4)) = n // keep the nodes sorted by frequency 15290 *(*int32)(unsafe.Pointer((s + 2984 /* &.heap */) + uintptr(libc.PreDecInt32(&((*Deflate_state)(unsafe.Pointer(s)).Fheap_max), 1))*4)) = m 15291 15292 // Create a new node father of n and m 15293 *(*Ush)(unsafe.Pointer(tree + uintptr(node)*4 /* &.fc */)) = (Ush(int32(*(*Ush)(unsafe.Pointer(tree + uintptr(n)*4 /* &.fc */))) + int32(*(*Ush)(unsafe.Pointer(tree + uintptr(m)*4 /* &.fc */))))) 15294 *(*Uch)(unsafe.Pointer((s + 5284 /* &.depth */) + uintptr(node))) = (Uch((func() int32 { 15295 if int32(*(*Uch)(unsafe.Pointer((s + 5284 /* &.depth */) + uintptr(n)))) >= int32(*(*Uch)(unsafe.Pointer((s + 5284 /* &.depth */) + uintptr(m)))) { 15296 return int32(*(*Uch)(unsafe.Pointer((s + 5284 /* &.depth */) + uintptr(n)))) 15297 } 15298 return int32(*(*Uch)(unsafe.Pointer((s + 5284 /* &.depth */) + uintptr(m)))) 15299 }()) + 1)) 15300 *(*Ush)(unsafe.Pointer(tree + uintptr(n)*4 + 2 /* &.dl */)) = libc.AssignPtrUint16(tree+uintptr(m)*4+2 /* &.dl */ /* &.dad */, Ush(node)) 15301 // and insert the new node in the heap 15302 *(*int32)(unsafe.Pointer((s + 2984 /* &.heap */) + 1*4)) = libc.PostIncInt32(&node, 1) 15303 pqdownheap(tls, s, tree, SMALLEST) 15304 15305 } 15306 15307 *(*int32)(unsafe.Pointer((s + 2984 /* &.heap */) + uintptr(libc.PreDecInt32(&((*Deflate_state)(unsafe.Pointer(s)).Fheap_max), 1))*4)) = *(*int32)(unsafe.Pointer((s + 2984 /* &.heap */) + 1*4)) 15308 15309 // At this point, the fields freq and dad are set. We can now 15310 // generate the bit lengths. 15311 gen_bitlen(tls, s, desc) 15312 15313 // The field len is now set, we can generate the bit codes 15314 gen_codes(tls, tree, max_code, s+2952 /* &.bl_count */) 15315 } 15316 15317 // =========================================================================== 15318 // Scan a literal or distance tree to determine the frequencies of the codes 15319 // in the bit length tree. 15320 func scan_tree(tls *libc.TLS, s uintptr, tree uintptr, max_code int32) { /* trees.c:703:12: */ 15321 var n int32 // iterates over all tree elements 15322 var prevlen int32 = -1 // last emitted length 15323 var curlen int32 // length of current code 15324 var nextlen int32 = int32(*(*Ush)(unsafe.Pointer(tree + 2 /* &.dl */))) // length of next code 15325 var count int32 = 0 // repeat count of the current code 15326 var max_count int32 = 7 // max repeat count 15327 var min_count int32 = 4 // min repeat count 15328 15329 if nextlen == 0 { 15330 max_count = 138 15331 min_count = 3 15332 } 15333 *(*Ush)(unsafe.Pointer(tree + uintptr((max_code+1))*4 + 2 /* &.dl */)) = Ush(0xffff) // guard 15334 15335 for n = 0; n <= max_code; n++ { 15336 curlen = nextlen 15337 nextlen = int32(*(*Ush)(unsafe.Pointer(tree + uintptr((n+1))*4 + 2 /* &.dl */))) 15338 if (libc.PreIncInt32(&count, 1) < max_count) && (curlen == nextlen) { 15339 continue 15340 } else if count < min_count { 15341 *(*Ush)(unsafe.Pointer((s + 2724 /* &.bl_tree */) + uintptr(curlen)*4 /* &.fc */ /* &.freq */)) += Ush((count)) 15342 } else if curlen != 0 { 15343 if curlen != prevlen { 15344 *(*Ush)(unsafe.Pointer((s + 2724 /* &.bl_tree */) + uintptr(curlen)*4 /* &.fc */))++ 15345 } 15346 *(*Ush)(unsafe.Pointer((s + 2724 /* &.bl_tree */) + 16*4 /* &.fc */))++ 15347 } else if count <= 10 { 15348 *(*Ush)(unsafe.Pointer((s + 2724 /* &.bl_tree */) + 17*4 /* &.fc */))++ 15349 } else { 15350 *(*Ush)(unsafe.Pointer((s + 2724 /* &.bl_tree */) + 18*4 /* &.fc */))++ 15351 } 15352 count = 0 15353 prevlen = curlen 15354 if nextlen == 0 { 15355 max_count = 138 15356 min_count = 3 15357 } else if curlen == nextlen { 15358 max_count = 6 15359 min_count = 3 15360 } else { 15361 max_count = 7 15362 min_count = 4 15363 } 15364 } 15365 } 15366 15367 // =========================================================================== 15368 // Send a literal or distance tree in compressed form, using the codes in 15369 // bl_tree. 15370 func send_tree(tls *libc.TLS, s uintptr, tree uintptr, max_code int32) { /* trees.c:748:12: */ 15371 var n int32 // iterates over all tree elements 15372 var prevlen int32 = -1 // last emitted length 15373 var curlen int32 // length of current code 15374 var nextlen int32 = int32(*(*Ush)(unsafe.Pointer(tree + 2 /* &.dl */))) // length of next code 15375 var count int32 = 0 // repeat count of the current code 15376 var max_count int32 = 7 // max repeat count 15377 var min_count int32 = 4 // min repeat count 15378 15379 /* tree[max_code+1].Len = -1; */ // guard already set 15380 if nextlen == 0 { 15381 max_count = 138 15382 min_count = 3 15383 } 15384 15385 for n = 0; n <= max_code; n++ { 15386 curlen = nextlen 15387 nextlen = int32(*(*Ush)(unsafe.Pointer(tree + uintptr((n+1))*4 + 2 /* &.dl */))) 15388 if (libc.PreIncInt32(&count, 1) < max_count) && (curlen == nextlen) { 15389 continue 15390 } else if count < min_count { 15391 for ok := true; ok; ok = (libc.PreDecInt32(&count, 1) != 0) { 15392 { 15393 var len int32 = int32(*(*Ush)(unsafe.Pointer((s + 2724 /* &.bl_tree */) + uintptr(curlen)*4 + 2 /* &.dl */))) 15394 if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > (Buf_size - len) { 15395 var val int32 = int32(*(*Ush)(unsafe.Pointer((s + 2724 /* &.bl_tree */) + uintptr(curlen)*4 /* &.fc */))) 15396 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15397 { 15398 { 15399 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) & 0xff)) 15400 } 15401 { 15402 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) >> 8)) 15403 } 15404 15405 } 15406 (*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = (Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))) 15407 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len - Buf_size) 15408 } else { 15409 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32((*(*Ush)(unsafe.Pointer((s + 2724 /* &.bl_tree */) + uintptr(curlen)*4 /* &.fc */)))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15410 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len) 15411 } 15412 } 15413 } 15414 15415 } else if curlen != 0 { 15416 if curlen != prevlen { 15417 { 15418 var len int32 = int32(*(*Ush)(unsafe.Pointer((s + 2724 /* &.bl_tree */) + uintptr(curlen)*4 + 2 /* &.dl */))) 15419 if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > (Buf_size - len) { 15420 var val int32 = int32(*(*Ush)(unsafe.Pointer((s + 2724 /* &.bl_tree */) + uintptr(curlen)*4 /* &.fc */))) 15421 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15422 { 15423 { 15424 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) & 0xff)) 15425 } 15426 { 15427 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) >> 8)) 15428 } 15429 15430 } 15431 (*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = (Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))) 15432 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len - Buf_size) 15433 } else { 15434 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32((*(*Ush)(unsafe.Pointer((s + 2724 /* &.bl_tree */) + uintptr(curlen)*4 /* &.fc */)))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15435 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len) 15436 } 15437 } 15438 count-- 15439 } 15440 15441 { 15442 var len int32 = int32(*(*Ush)(unsafe.Pointer((s + 2724 /* &.bl_tree */) + 16*4 + 2 /* &.dl */))) 15443 if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > (Buf_size - len) { 15444 var val int32 = int32(*(*Ush)(unsafe.Pointer((s + 2724 /* &.bl_tree */) + 16*4 /* &.fc */))) 15445 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15446 { 15447 { 15448 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) & 0xff)) 15449 } 15450 { 15451 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) >> 8)) 15452 } 15453 15454 } 15455 (*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = (Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))) 15456 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len - Buf_size) 15457 } else { 15458 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32((*(*Ush)(unsafe.Pointer((s + 2724 /* &.bl_tree */) + 16*4 /* &.fc */)))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15459 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len) 15460 } 15461 } 15462 { 15463 var len int32 = 2 15464 if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > (Buf_size - len) { 15465 var val int32 = (count - 3) 15466 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15467 { 15468 { 15469 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) & 0xff)) 15470 } 15471 { 15472 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) >> 8)) 15473 } 15474 15475 } 15476 (*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = (Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))) 15477 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len - Buf_size) 15478 } else { 15479 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32((Ush(count - 3))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15480 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len) 15481 } 15482 } 15483 15484 } else if count <= 10 { 15485 { 15486 var len int32 = int32(*(*Ush)(unsafe.Pointer((s + 2724 /* &.bl_tree */) + 17*4 + 2 /* &.dl */))) 15487 if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > (Buf_size - len) { 15488 var val int32 = int32(*(*Ush)(unsafe.Pointer((s + 2724 /* &.bl_tree */) + 17*4 /* &.fc */))) 15489 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15490 { 15491 { 15492 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) & 0xff)) 15493 } 15494 { 15495 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) >> 8)) 15496 } 15497 15498 } 15499 (*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = (Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))) 15500 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len - Buf_size) 15501 } else { 15502 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32((*(*Ush)(unsafe.Pointer((s + 2724 /* &.bl_tree */) + 17*4 /* &.fc */)))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15503 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len) 15504 } 15505 } 15506 { 15507 var len int32 = 3 15508 if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > (Buf_size - len) { 15509 var val int32 = (count - 3) 15510 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15511 { 15512 { 15513 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) & 0xff)) 15514 } 15515 { 15516 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) >> 8)) 15517 } 15518 15519 } 15520 (*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = (Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))) 15521 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len - Buf_size) 15522 } else { 15523 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32((Ush(count - 3))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15524 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len) 15525 } 15526 } 15527 15528 } else { 15529 { 15530 var len int32 = int32(*(*Ush)(unsafe.Pointer((s + 2724 /* &.bl_tree */) + 18*4 + 2 /* &.dl */))) 15531 if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > (Buf_size - len) { 15532 var val int32 = int32(*(*Ush)(unsafe.Pointer((s + 2724 /* &.bl_tree */) + 18*4 /* &.fc */))) 15533 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15534 { 15535 { 15536 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) & 0xff)) 15537 } 15538 { 15539 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) >> 8)) 15540 } 15541 15542 } 15543 (*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = (Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))) 15544 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len - Buf_size) 15545 } else { 15546 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32((*(*Ush)(unsafe.Pointer((s + 2724 /* &.bl_tree */) + 18*4 /* &.fc */)))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15547 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len) 15548 } 15549 } 15550 { 15551 var len int32 = 7 15552 if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > (Buf_size - len) { 15553 var val int32 = (count - 11) 15554 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15555 { 15556 { 15557 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) & 0xff)) 15558 } 15559 { 15560 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) >> 8)) 15561 } 15562 15563 } 15564 (*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = (Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))) 15565 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len - Buf_size) 15566 } else { 15567 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32((Ush(count - 11))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15568 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len) 15569 } 15570 } 15571 15572 } 15573 count = 0 15574 prevlen = curlen 15575 if nextlen == 0 { 15576 max_count = 138 15577 min_count = 3 15578 } else if curlen == nextlen { 15579 max_count = 6 15580 min_count = 3 15581 } else { 15582 max_count = 7 15583 min_count = 4 15584 } 15585 } 15586 } 15587 15588 // =========================================================================== 15589 // Construct the Huffman tree for the bit lengths and return the index in 15590 // bl_order of the last bit length code to send. 15591 func build_bl_tree(tls *libc.TLS, s uintptr) int32 { /* trees.c:799:11: */ 15592 var max_blindex int32 // index of last bit length code of non zero freq 15593 15594 // Determine the bit length frequencies for literal and distance trees 15595 scan_tree(tls, s, s+188 /* &.dyn_ltree */, (*Deflate_state)(unsafe.Pointer(s)).Fl_desc.Fmax_code) 15596 scan_tree(tls, s, s+2480 /* &.dyn_dtree */, (*Deflate_state)(unsafe.Pointer(s)).Fd_desc.Fmax_code) 15597 15598 // Build the bit length tree: 15599 build_tree(tls, s, (s + 2928 /* &.bl_desc */)) 15600 // opt_len now includes the length of the tree representations, except 15601 // the lengths of the bit lengths codes and the 5+5+4 bits for the counts. 15602 15603 // Determine the number of bit length codes to send. The pkzip format 15604 // requires that at least 4 bit length codes be sent. (appnote.txt says 15605 // 3 but the actual value used is 4.) 15606 for max_blindex = (BL_CODES - 1); max_blindex >= 3; max_blindex-- { 15607 if int32(*(*Ush)(unsafe.Pointer((s + 2724 /* &.bl_tree */) + uintptr(bl_order[max_blindex])*4 + 2 /* &.dl */))) != 0 { 15608 break 15609 } 15610 } 15611 // Update opt_len to include the bit length tree and counts 15612 *(*Ulg)(unsafe.Pointer(s + 5888 /* &.opt_len */)) += ((((Ulg(3) * (Ulg(max_blindex) + Ulg(1))) + Ulg(5)) + Ulg(5)) + Ulg(4)) 15613 15614 return max_blindex 15615 } 15616 15617 // =========================================================================== 15618 // Send the header for a block using dynamic Huffman trees: the counts, the 15619 // lengths of the bit length codes, the literal tree and the distance tree. 15620 // IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. 15621 func send_all_trees(tls *libc.TLS, s uintptr, lcodes int32, dcodes int32, blcodes int32) { /* trees.c:834:12: */ 15622 var rank int32 // index in bl_order 15623 15624 { 15625 var len int32 = 5 15626 if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > (Buf_size - len) { 15627 var val int32 = (lcodes - 257) 15628 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15629 { 15630 { 15631 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) & 0xff)) 15632 } 15633 { 15634 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) >> 8)) 15635 } 15636 15637 } 15638 (*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = (Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))) 15639 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len - Buf_size) 15640 } else { 15641 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32((Ush(lcodes - 257))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15642 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len) 15643 } 15644 } 15645 /* not +255 as stated in appnote.txt */ 15646 { 15647 var len int32 = 5 15648 if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > (Buf_size - len) { 15649 var val int32 = (dcodes - 1) 15650 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15651 { 15652 { 15653 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) & 0xff)) 15654 } 15655 { 15656 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) >> 8)) 15657 } 15658 15659 } 15660 (*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = (Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))) 15661 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len - Buf_size) 15662 } else { 15663 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32((Ush(dcodes - 1))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15664 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len) 15665 } 15666 } 15667 15668 { 15669 var len int32 = 4 15670 if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > (Buf_size - len) { 15671 var val int32 = (blcodes - 4) 15672 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15673 { 15674 { 15675 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) & 0xff)) 15676 } 15677 { 15678 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) >> 8)) 15679 } 15680 15681 } 15682 (*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = (Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))) 15683 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len - Buf_size) 15684 } else { 15685 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32((Ush(blcodes - 4))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15686 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len) 15687 } 15688 } 15689 // not -3 as stated in appnote.txt 15690 for rank = 0; rank < blcodes; rank++ { 15691 15692 { 15693 var len int32 = 3 15694 if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > (Buf_size - len) { 15695 var val int32 = int32(*(*Ush)(unsafe.Pointer((s + 2724 /* &.bl_tree */) + uintptr(bl_order[rank])*4 + 2 /* &.dl */))) 15696 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15697 { 15698 { 15699 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) & 0xff)) 15700 } 15701 { 15702 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) >> 8)) 15703 } 15704 15705 } 15706 (*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = (Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))) 15707 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len - Buf_size) 15708 } else { 15709 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32((*(*Ush)(unsafe.Pointer((s + 2724 /* &.bl_tree */) + uintptr(bl_order[rank])*4 + 2 /* &.dl */)))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15710 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len) 15711 } 15712 } 15713 15714 } 15715 15716 send_tree(tls, s, s+188 /* &.dyn_ltree */, (lcodes - 1)) // literal tree 15717 15718 send_tree(tls, s, s+2480 /* &.dyn_dtree */, (dcodes - 1)) // distance tree 15719 15720 } 15721 15722 // =========================================================================== 15723 // Send a stored block 15724 func X_tr_stored_block(tls *libc.TLS, s uintptr, buf uintptr, stored_len Ulg, last int32) { /* trees.c:863:20: */ 15725 { 15726 var len int32 = 3 15727 if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > (Buf_size - len) { 15728 var val int32 = ((int32(STORED_BLOCK) << 1) + last) 15729 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15730 { 15731 { 15732 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) & 0xff)) 15733 } 15734 { 15735 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) >> 8)) 15736 } 15737 15738 } 15739 (*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = (Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))) 15740 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len - Buf_size) 15741 } else { 15742 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32((Ush((int32(STORED_BLOCK) << 1) + last))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15743 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len) 15744 } 15745 } 15746 // send block type 15747 bi_windup(tls, s) /* align on byte boundary */ 15748 { 15749 { 15750 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32(Ush(stored_len))) & 0xff)) 15751 } 15752 { 15753 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32((Ush(stored_len))) >> 8)) 15754 } 15755 15756 } 15757 15758 { 15759 { 15760 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32(Ush(^stored_len))) & 0xff)) 15761 } 15762 { 15763 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32((Ush(^stored_len))) >> 8)) 15764 } 15765 15766 } 15767 15768 libc.Xmemcpy(tls, ((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr((*Deflate_state)(unsafe.Pointer(s)).Fpending)), buf, uint64(stored_len)) 15769 *(*Ulg)(unsafe.Pointer(s + 40 /* &.pending */)) += (stored_len) 15770 } 15771 15772 // =========================================================================== 15773 // Flush the bits in the bit buffer to pending output (leaves at most 7 bits) 15774 func X_tr_flush_bits(tls *libc.TLS, s uintptr) { /* trees.c:886:20: */ 15775 bi_flush(tls, s) 15776 } 15777 15778 // =========================================================================== 15779 // Send one empty static block to give enough lookahead for inflate. 15780 // This takes 10 bits, of which 7 may remain in the bit buffer. 15781 func X_tr_align(tls *libc.TLS, s uintptr) { /* trees.c:896:20: */ 15782 { 15783 var len int32 = 3 15784 if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > (Buf_size - len) { 15785 var val int32 = (int32(STATIC_TREES) << 1) 15786 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15787 { 15788 { 15789 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) & 0xff)) 15790 } 15791 { 15792 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) >> 8)) 15793 } 15794 15795 } 15796 (*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = (Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))) 15797 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len - Buf_size) 15798 } else { 15799 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32(int32((Ush(int32(STATIC_TREES) << 1)))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15800 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len) 15801 } 15802 } 15803 15804 { 15805 var len int32 = int32(*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&static_ltree)) + 256*4 + 2 /* &.dl */))) 15806 if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > (Buf_size - len) { 15807 var val int32 = int32(*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&static_ltree)) + 256*4 /* &.fc */))) 15808 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15809 { 15810 { 15811 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) & 0xff)) 15812 } 15813 { 15814 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) >> 8)) 15815 } 15816 15817 } 15818 (*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = (Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))) 15819 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len - Buf_size) 15820 } else { 15821 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32((*(*Ush)(unsafe.Pointer(uintptr(unsafe.Pointer(&static_ltree)) + 256*4 /* &.fc */)))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15822 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len) 15823 } 15824 } 15825 15826 bi_flush(tls, s) 15827 } 15828 15829 // =========================================================================== 15830 // Determine the best encoding for the current block: dynamic trees, static 15831 // trees or store, and write out the encoded block. 15832 func X_tr_flush_block(tls *libc.TLS, s uintptr, buf uintptr, stored_len Ulg, last int32) { /* trees.c:911:20: */ 15833 var opt_lenb Ulg 15834 var static_lenb Ulg // opt_len and static_len in bytes 15835 var max_blindex int32 = 0 // index of last bit length code of non zero freq 15836 15837 // Build the Huffman trees unless a stored block is forced 15838 if (*Deflate_state)(unsafe.Pointer(s)).Flevel > 0 { 15839 15840 // Check if the file is binary or text 15841 if (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Fdata_type == Z_UNKNOWN { 15842 (*Z_stream)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fstrm)).Fdata_type = detect_data_type(tls, s) 15843 } 15844 15845 // Construct the literal and distance trees 15846 build_tree(tls, s, (s + 2880 /* &.l_desc */)) 15847 15848 build_tree(tls, s, (s + 2904 /* &.d_desc */)) 15849 15850 // At this point, opt_len and static_len are the total bit lengths of 15851 // the compressed block data, excluding the tree representations. 15852 15853 // Build the bit length tree for the above two trees, and get the index 15854 // in bl_order of the last bit length code to send. 15855 max_blindex = build_bl_tree(tls, s) 15856 15857 // Determine the best encoding. Compute the block lengths in bytes. 15858 opt_lenb = ((((*Deflate_state)(unsafe.Pointer(s)).Fopt_len + Ulg(3)) + Ulg(7)) >> 3) 15859 static_lenb = ((((*Deflate_state)(unsafe.Pointer(s)).Fstatic_len + Ulg(3)) + Ulg(7)) >> 3) 15860 15861 if static_lenb <= opt_lenb { 15862 opt_lenb = static_lenb 15863 } 15864 15865 } else { 15866 15867 opt_lenb = libc.AssignUint32(&static_lenb, (stored_len + Ulg(5))) // force a stored block 15868 } 15869 15870 if ((stored_len + Ulg(4)) <= opt_lenb) && (buf != uintptr(0)) { 15871 // 4: two words for the lengths 15872 // The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. 15873 // Otherwise we can't have processed more than WSIZE input bytes since 15874 // the last block flush, because compression would have been 15875 // successful. If LIT_BUFSIZE <= WSIZE, it is never too late to 15876 // transform a block into a stored block. 15877 X_tr_stored_block(tls, s, buf, stored_len, last) 15878 15879 } else if ((*Deflate_state)(unsafe.Pointer(s)).Fstrategy == Z_FIXED) || (static_lenb == opt_lenb) { 15880 { 15881 var len int32 = 3 15882 if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > (Buf_size - len) { 15883 var val int32 = ((int32(STATIC_TREES) << 1) + last) 15884 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15885 { 15886 { 15887 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) & 0xff)) 15888 } 15889 { 15890 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) >> 8)) 15891 } 15892 15893 } 15894 (*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = (Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))) 15895 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len - Buf_size) 15896 } else { 15897 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32((Ush((int32(STATIC_TREES) << 1) + last))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15898 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len) 15899 } 15900 } 15901 15902 compress_block(tls, s, uintptr(uintptr(unsafe.Pointer(&static_ltree))), 15903 uintptr(uintptr(unsafe.Pointer(&static_dtree)))) 15904 } else { 15905 { 15906 var len int32 = 3 15907 if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > (Buf_size - len) { 15908 var val int32 = ((int32(DYN_TREES) << 1) + last) 15909 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15910 { 15911 { 15912 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) & 0xff)) 15913 } 15914 { 15915 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) >> 8)) 15916 } 15917 15918 } 15919 (*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = (Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))) 15920 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len - Buf_size) 15921 } else { 15922 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32((Ush((int32(DYN_TREES) << 1) + last))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15923 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len) 15924 } 15925 } 15926 15927 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), 15928 (max_blindex + 1)) 15929 compress_block(tls, s, s+188, /* &.dyn_ltree */ 15930 s+2480 /* &.dyn_dtree */) 15931 } 15932 15933 // The above check is made mod 2^32, for files larger than 512 MB 15934 // and uLong implemented on 32 bits. 15935 init_block(tls, s) 15936 15937 if last != 0 { 15938 bi_windup(tls, s) 15939 } 15940 15941 } 15942 15943 // =========================================================================== 15944 // Save the match info and tally the frequency counts. Return true if 15945 // the current block must be flushed. 15946 func X_tr_tally(tls *libc.TLS, s uintptr, dist uint32, lc uint32) int32 { /* trees.c:1014:19: */ 15947 *(*Ushf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fd_buf + uintptr((*Deflate_state)(unsafe.Pointer(s)).Flast_lit)*2)) = Ush(dist) 15948 *(*Uchf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fl_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Flast_lit, 1)))) = Uch(lc) 15949 if dist == uint32(0) { 15950 // lc is the unmatched char 15951 *(*Ush)(unsafe.Pointer((s + 188 /* &.dyn_ltree */) + uintptr(lc)*4 /* &.fc */))++ 15952 } else { 15953 (*Deflate_state)(unsafe.Pointer(s)).Fmatches++ 15954 // Here, lc is the match length - MIN_MATCH 15955 dist-- // dist = match distance - 1 15956 15957 *(*Ush)(unsafe.Pointer((s + 188 /* &.dyn_ltree */) + uintptr(((int32(X_length_code[lc])+LITERALS)+1))*4 /* &.fc */))++ 15958 *(*Ush)(unsafe.Pointer((s + 2480 /* &.dyn_dtree */) + uintptr((func() int32 { 15959 if (dist) < uint32(256) { 15960 return int32(X_dist_code[dist]) 15961 } 15962 return int32(X_dist_code[(uint32(256) + ((dist) >> 7))]) 15963 }()))*4 /* &.fc */))++ 15964 } 15965 15966 return (libc.Bool32((*Deflate_state)(unsafe.Pointer(s)).Flast_lit == ((*Deflate_state)(unsafe.Pointer(s)).Flit_bufsize - UInt(1)))) 15967 // We avoid equality with lit_bufsize because of wraparound at 64K 15968 // on 16 bit machines and because stored blocks are restricted to 15969 // 64K-1 bytes. 15970 } 15971 15972 // =========================================================================== 15973 // Send the block data compressed using the given Huffman trees 15974 func compress_block(tls *libc.TLS, s uintptr, ltree uintptr, dtree uintptr) { /* trees.c:1064:12: */ 15975 var dist uint32 // distance of matched string 15976 var lc int32 // match length or unmatched char (if dist == 0) 15977 var lx uint32 = uint32(0) // running index in l_buf 15978 var code uint32 // the code to send 15979 var extra int32 // number of extra bits to send 15980 15981 if (*Deflate_state)(unsafe.Pointer(s)).Flast_lit != UInt(0) { 15982 for ok := true; ok; ok = (lx < (*Deflate_state)(unsafe.Pointer(s)).Flast_lit) { 15983 dist = uint32(*(*Ushf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fd_buf + uintptr(lx)*2))) 15984 lc = int32(*(*Uchf)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fl_buf + uintptr(libc.PostIncUint32(&lx, 1))))) 15985 if dist == uint32(0) { 15986 { 15987 var len int32 = int32(*(*Ush)(unsafe.Pointer(ltree + uintptr(lc)*4 + 2 /* &.dl */))) 15988 if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > (Buf_size - len) { 15989 var val int32 = int32(*(*Ush)(unsafe.Pointer(ltree + uintptr(lc)*4 /* &.fc */))) 15990 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 15991 { 15992 { 15993 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) & 0xff)) 15994 } 15995 { 15996 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) >> 8)) 15997 } 15998 15999 } 16000 (*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = (Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))) 16001 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len - Buf_size) 16002 } else { 16003 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32((*(*Ush)(unsafe.Pointer(ltree + uintptr(lc)*4 /* &.fc */)))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 16004 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len) 16005 } 16006 } 16007 // send a literal byte 16008 16009 } else { 16010 // Here, lc is the match length - MIN_MATCH 16011 code = uint32(X_length_code[lc]) 16012 { 16013 var len int32 = int32(*(*Ush)(unsafe.Pointer(ltree + uintptr(((code+uint32(LITERALS))+uint32(1)))*4 + 2 /* &.dl */))) 16014 if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > (Buf_size - len) { 16015 var val int32 = int32(*(*Ush)(unsafe.Pointer(ltree + uintptr(((code+uint32(LITERALS))+uint32(1)))*4 /* &.fc */))) 16016 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 16017 { 16018 { 16019 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) & 0xff)) 16020 } 16021 { 16022 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) >> 8)) 16023 } 16024 16025 } 16026 (*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = (Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))) 16027 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len - Buf_size) 16028 } else { 16029 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32((*(*Ush)(unsafe.Pointer(ltree + uintptr(((code+uint32(LITERALS))+uint32(1)))*4 /* &.fc */)))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 16030 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len) 16031 } 16032 } 16033 // send the length code 16034 extra = extra_lbits[code] 16035 if extra != 0 { 16036 lc = lc - (base_length[code]) 16037 { 16038 var len int32 = extra 16039 if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > (Buf_size - len) { 16040 var val int32 = lc 16041 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 16042 { 16043 { 16044 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) & 0xff)) 16045 } 16046 { 16047 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) >> 8)) 16048 } 16049 16050 } 16051 (*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = (Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))) 16052 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len - Buf_size) 16053 } else { 16054 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32((Ush(lc))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 16055 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len) 16056 } 16057 } 16058 // send the extra length bits 16059 } 16060 dist-- // dist is now the match distance - 1 16061 code = func() uint32 { 16062 if (dist) < uint32(256) { 16063 return uint32(X_dist_code[dist]) 16064 } 16065 return uint32(X_dist_code[(uint32(256) + ((dist) >> 7))]) 16066 }() 16067 16068 { 16069 var len int32 = int32(*(*Ush)(unsafe.Pointer(dtree + uintptr(code)*4 + 2 /* &.dl */))) 16070 if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > (Buf_size - len) { 16071 var val int32 = int32(*(*Ush)(unsafe.Pointer(dtree + uintptr(code)*4 /* &.fc */))) 16072 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 16073 { 16074 { 16075 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) & 0xff)) 16076 } 16077 { 16078 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) >> 8)) 16079 } 16080 16081 } 16082 (*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = (Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))) 16083 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len - Buf_size) 16084 } else { 16085 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32((*(*Ush)(unsafe.Pointer(dtree + uintptr(code)*4 /* &.fc */)))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 16086 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len) 16087 } 16088 } 16089 // send the distance code 16090 extra = extra_dbits[code] 16091 if extra != 0 { 16092 dist = dist - (uint32(base_dist[code])) 16093 { 16094 var len int32 = extra 16095 if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > (Buf_size - len) { 16096 var val int32 = int32(dist) 16097 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 16098 { 16099 { 16100 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) & 0xff)) 16101 } 16102 { 16103 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) >> 8)) 16104 } 16105 16106 } 16107 (*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = (Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))) 16108 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len - Buf_size) 16109 } else { 16110 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32((Ush(dist))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 16111 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len) 16112 } 16113 } 16114 // send the extra distance bits 16115 } 16116 } // literal or match pair ? 16117 16118 // Check that the overlay between pending_buf and d_buf+l_buf is ok: 16119 16120 } 16121 } 16122 16123 { 16124 var len int32 = int32(*(*Ush)(unsafe.Pointer(ltree + 256*4 + 2 /* &.dl */))) 16125 if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > (Buf_size - len) { 16126 var val int32 = int32(*(*Ush)(unsafe.Pointer(ltree + 256*4 /* &.fc */))) 16127 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32(Ush(val)) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 16128 { 16129 { 16130 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) & 0xff)) 16131 } 16132 { 16133 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) >> 8)) 16134 } 16135 16136 } 16137 (*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = (Ush(int32(Ush(val)) >> (Buf_size - (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid))) 16138 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len - Buf_size) 16139 } else { 16140 *(*Ush)(unsafe.Pointer(s + 5904 /* &.bi_buf */)) |= Ush((int32((*(*Ush)(unsafe.Pointer(ltree + 256*4 /* &.fc */)))) << (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid)) 16141 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) += (len) 16142 } 16143 } 16144 16145 } 16146 16147 // =========================================================================== 16148 // Check if the data type is TEXT or BINARY, using the following algorithm: 16149 // - TEXT if the two conditions below are satisfied: 16150 // a) There are no non-portable control characters belonging to the 16151 // "black list" (0..6, 14..25, 28..31). 16152 // b) There is at least one printable character belonging to the 16153 // "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255). 16154 // - BINARY otherwise. 16155 // - The following partially-portable control characters form a 16156 // "gray list" that is ignored in this detection algorithm: 16157 // (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}). 16158 // IN assertion: the fields Freq of dyn_ltree are set. 16159 func detect_data_type(tls *libc.TLS, s uintptr) int32 { /* trees.c:1124:11: */ 16160 // black_mask is the bit mask of black-listed bytes 16161 // set bits 0..6, 14..25, and 28..31 16162 // 0xf3ffc07f = binary 11110011111111111100000001111111 16163 var black_mask uint32 = 0xf3ffc07f 16164 var n int32 16165 16166 // Check for non-textual ("black-listed") bytes. 16167 n = 0 16168 __1: 16169 if !(n <= 31) { 16170 goto __3 16171 } 16172 if ((black_mask & uint32(1)) != 0) && (int32(*(*Ush)(unsafe.Pointer((s + 188 /* &.dyn_ltree */) + uintptr(n)*4 /* &.fc */))) != 0) { 16173 return Z_BINARY 16174 } 16175 goto __2 16176 __2: 16177 n++ 16178 black_mask >>= 1 16179 goto __1 16180 goto __3 16181 __3: 16182 ; 16183 16184 // Check for textual ("white-listed") bytes. 16185 if ((int32(*(*Ush)(unsafe.Pointer((s + 188 /* &.dyn_ltree */) + 9*4 /* &.fc */))) != 0) || (int32(*(*Ush)(unsafe.Pointer((s + 188 /* &.dyn_ltree */) + 10*4 /* &.fc */))) != 0)) || 16186 (int32(*(*Ush)(unsafe.Pointer((s + 188 /* &.dyn_ltree */) + 13*4 /* &.fc */))) != 0) { 16187 return Z_TEXT 16188 } 16189 for n = 32; n < LITERALS; n++ { 16190 if int32(*(*Ush)(unsafe.Pointer((s + 188 /* &.dyn_ltree */) + uintptr(n)*4 /* &.fc */))) != 0 { 16191 return Z_TEXT 16192 } 16193 } 16194 16195 // There are no "black-listed" or "white-listed" bytes: 16196 // this stream either is empty or has tolerated ("gray-listed") bytes only. 16197 return Z_BINARY 16198 } 16199 16200 // =========================================================================== 16201 // Reverse the first len bits of a code, using straightforward code (a faster 16202 // method would use a table) 16203 // IN assertion: 1 <= len <= 15 16204 func bi_reverse(tls *libc.TLS, code uint32, len int32) uint32 { /* trees.c:1158:16: */ 16205 var res uint32 = uint32(0) 16206 for ok := true; ok; ok = (libc.PreDecInt32(&len, 1) > 0) { 16207 res = res | (code & uint32(1)) 16208 code >>= 1 16209 res <<= 1 16210 } 16211 return (res >> 1) 16212 } 16213 16214 // =========================================================================== 16215 // Flush the bit buffer, keeping at most 7 bits in it. 16216 func bi_flush(tls *libc.TLS, s uintptr) { /* trees.c:1173:12: */ 16217 if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid == 16 { 16218 { 16219 { 16220 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) & 0xff)) 16221 } 16222 { 16223 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) >> 8)) 16224 } 16225 16226 } 16227 16228 (*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(0) 16229 (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid = 0 16230 } else if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid >= 8 { 16231 { 16232 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Byte((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) 16233 } 16234 16235 libc.AssignShrPtrUint16(s+5904 /* &.bi_buf */, int(8)) 16236 *(*int32)(unsafe.Pointer(s + 5908 /* &.bi_valid */)) -= (8) 16237 } 16238 } 16239 16240 // =========================================================================== 16241 // Flush the bit buffer and align the output on a byte boundary 16242 func bi_windup(tls *libc.TLS, s uintptr) { /* trees.c:1190:12: */ 16243 if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > 8 { 16244 { 16245 { 16246 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch((int32((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) & 0xff)) 16247 } 16248 { 16249 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = (Uch(int32(((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf)) >> 8)) 16250 } 16251 16252 } 16253 16254 } else if (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid > 0 { 16255 { 16256 *(*Bytef)(unsafe.Pointer((*Deflate_state)(unsafe.Pointer(s)).Fpending_buf + uintptr(libc.PostIncUint32(&(*Deflate_state)(unsafe.Pointer(s)).Fpending, 1)))) = Byte((*Deflate_state)(unsafe.Pointer(s)).Fbi_buf) 16257 } 16258 16259 } 16260 (*Deflate_state)(unsafe.Pointer(s)).Fbi_buf = Ush(0) 16261 (*Deflate_state)(unsafe.Pointer(s)).Fbi_valid = 0 16262 } 16263 16264 // =========================================================================== 16265 // Decompresses the source buffer into the destination buffer. *sourceLen is 16266 // the byte length of the source buffer. Upon entry, *destLen is the total size 16267 // of the destination buffer, which must be large enough to hold the entire 16268 // uncompressed data. (The size of the uncompressed data must have been saved 16269 // previously by the compressor and transmitted to the decompressor by some 16270 // mechanism outside the scope of this compression library.) Upon exit, 16271 // *destLen is the size of the decompressed data and *sourceLen is the number 16272 // of source bytes consumed. Upon return, source + *sourceLen points to the 16273 // first unused input byte. 16274 // 16275 // uncompress returns Z_OK if success, Z_MEM_ERROR if there was not enough 16276 // memory, Z_BUF_ERROR if there was not enough room in the output buffer, or 16277 // Z_DATA_ERROR if the input data was corrupted, including if the input data is 16278 // an incomplete zlib stream. 16279 func Xuncompress2(tls *libc.TLS, dest uintptr, destLen uintptr, source uintptr, sourceLen uintptr) int32 { /* uncompr.c:27:13: */ 16280 bp := tls.Alloc(96) 16281 defer tls.Free(96) 16282 16283 // var stream Z_stream at bp+8, 88 16284 16285 var err int32 16286 var max UInt = libc.Uint32(libc.Uint32FromInt32(-1)) 16287 var len ULong 16288 var left ULong 16289 // var buf [1]Byte at bp, 1 16290 // for detection of incomplete stream when *destLen == 0 16291 16292 len = *(*ULong)(unsafe.Pointer(sourceLen)) 16293 if *(*ULongf)(unsafe.Pointer(destLen)) != 0 { 16294 left = *(*ULongf)(unsafe.Pointer(destLen)) 16295 *(*ULongf)(unsafe.Pointer(destLen)) = ULongf(0) 16296 } else { 16297 left = ULong(1) 16298 dest = bp /* &buf[0] */ 16299 } 16300 16301 (*Z_stream)(unsafe.Pointer(bp + 8 /* &stream */)).Fnext_in = source 16302 (*Z_stream)(unsafe.Pointer(bp + 8 /* &stream */)).Favail_in = UInt(0) 16303 (*Z_stream)(unsafe.Pointer(bp + 8 /* &stream */)).Fzalloc = uintptr(0) 16304 (*Z_stream)(unsafe.Pointer(bp + 8 /* &stream */)).Fzfree = uintptr(0) 16305 (*Z_stream)(unsafe.Pointer(bp + 8 /* &stream */)).Fopaque = uintptr(0) 16306 16307 err = XinflateInit_(tls, bp+8 /* &stream */, ts /* "1.2.11" */, int32(unsafe.Sizeof(Z_stream{}))) 16308 if err != Z_OK { 16309 return err 16310 } 16311 16312 (*Z_stream)(unsafe.Pointer(bp + 8 /* &stream */)).Fnext_out = dest 16313 (*Z_stream)(unsafe.Pointer(bp + 8 /* &stream */)).Favail_out = UInt(0) 16314 16315 for ok := true; ok; ok = (err == Z_OK) { 16316 if (*Z_stream)(unsafe.Pointer(bp+8 /* &stream */)).Favail_out == UInt(0) { 16317 (*Z_stream)(unsafe.Pointer(bp + 8 /* &stream */)).Favail_out = func() uint32 { 16318 if left > ULong(max) { 16319 return max 16320 } 16321 return UInt(left) 16322 }() 16323 left = left - (ULong((*Z_stream)(unsafe.Pointer(bp + 8 /* &stream */)).Favail_out)) 16324 } 16325 if (*Z_stream)(unsafe.Pointer(bp+8 /* &stream */)).Favail_in == UInt(0) { 16326 (*Z_stream)(unsafe.Pointer(bp + 8 /* &stream */)).Favail_in = func() uint32 { 16327 if len > ULong(max) { 16328 return max 16329 } 16330 return UInt(len) 16331 }() 16332 len = len - (ULong((*Z_stream)(unsafe.Pointer(bp + 8 /* &stream */)).Favail_in)) 16333 } 16334 err = Xinflate(tls, bp+8 /* &stream */, Z_NO_FLUSH) 16335 } 16336 16337 *(*ULong)(unsafe.Pointer(sourceLen)) -= (len + ULong((*Z_stream)(unsafe.Pointer(bp+8 /* &stream */)).Favail_in)) 16338 if dest != bp /* buf */ { 16339 *(*ULongf)(unsafe.Pointer(destLen)) = (*Z_stream)(unsafe.Pointer(bp + 8 /* &stream */)).Ftotal_out 16340 } else if ((*Z_stream)(unsafe.Pointer(bp+8 /* &stream */)).Ftotal_out != 0) && (err == (-5)) { 16341 left = ULong(1) 16342 } 16343 16344 XinflateEnd(tls, bp+8 /* &stream */) 16345 if err == Z_STREAM_END { 16346 return Z_OK 16347 } 16348 if err == Z_NEED_DICT { 16349 return -3 16350 } 16351 if (err == (-5)) && ((left + ULong((*Z_stream)(unsafe.Pointer(bp+8 /* &stream */)).Favail_out)) != 0) { 16352 return -3 16353 } 16354 return err 16355 } 16356 16357 func Xuncompress(tls *libc.TLS, dest uintptr, destLen uintptr, source uintptr, sourceLen ULong) int32 { /* uncompr.c:86:13: */ 16358 bp := tls.Alloc(4) 16359 defer tls.Free(4) 16360 *(*ULong)(unsafe.Pointer(bp)) = sourceLen 16361 16362 return Xuncompress2(tls, dest, destLen, source, bp /* &sourceLen */) 16363 } 16364 16365 // GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t 16366 // value -- needed when comparing unsigned to z_off64_t, which is signed 16367 // (possible z_off64_t types off_t, off64_t, and long are all signed) 16368 16369 var Xz_errmsg = [10]uintptr{ 16370 uintptr(ts + 876 /* "need dictionary" */), // Z_NEED_DICT 2 16371 uintptr(ts + 892 /* "stream end" */), // Z_STREAM_END 1 16372 uintptr(ts + 101 /* "" */), // Z_OK 0 16373 uintptr(ts + 903 /* "file error" */), // Z_ERRNO (-1) 16374 uintptr(ts + 914 /* "stream error" */), // Z_STREAM_ERROR (-2) 16375 uintptr(ts + 927 /* "data error" */), // Z_DATA_ERROR (-3) 16376 uintptr(ts + 938 /* "insufficient mem..." */), // Z_MEM_ERROR (-4) 16377 uintptr(ts + 958 /* "buffer error" */), // Z_BUF_ERROR (-5) 16378 uintptr(ts + 971 /* "incompatible ver..." */), // Z_VERSION_ERROR (-6) 16379 uintptr(ts + 101 /* "" */), 16380 } /* zutil.c:13:14 */ 16381 16382 func XzlibVersion(tls *libc.TLS) uintptr { /* zutil.c:27:12: */ 16383 return ts /* "1.2.11" */ 16384 } 16385 16386 func XzlibCompileFlags(tls *libc.TLS) ULong { /* zutil.c:32:15: */ 16387 var flags ULong 16388 16389 flags = ULong(0) 16390 switch int32(unsafe.Sizeof(UInt(0))) { 16391 case 2: 16392 break 16393 case 4: 16394 flags = flags + (ULong(1)) 16395 break 16396 case 8: 16397 flags = flags + (ULong(2)) 16398 break 16399 default: 16400 flags = flags + (ULong(3)) 16401 } 16402 switch int32(unsafe.Sizeof(ULong(0))) { 16403 case 2: 16404 break 16405 case 4: 16406 flags = flags + (ULong(int32(1) << 2)) 16407 break 16408 case 8: 16409 flags = flags + (ULong(int32(2) << 2)) 16410 break 16411 default: 16412 flags = flags + (ULong(int32(3) << 2)) 16413 } 16414 switch int32(unsafe.Sizeof(Voidpf(0))) { 16415 case 2: 16416 break 16417 case 4: 16418 flags = flags + (ULong(int32(1) << 4)) 16419 break 16420 case 8: 16421 flags = flags + (ULong(int32(2) << 4)) 16422 break 16423 default: 16424 flags = flags + (ULong(int32(3) << 4)) 16425 } 16426 switch int32(unsafe.Sizeof(int32(0))) { 16427 case 2: 16428 break 16429 case 4: 16430 flags = flags + (ULong(int32(1) << 6)) 16431 break 16432 case 8: 16433 flags = flags + (ULong(int32(2) << 6)) 16434 break 16435 default: 16436 flags = flags + (ULong(int32(3) << 6)) 16437 } 16438 return flags 16439 } 16440 16441 // exported to allow conversion of error code to string for compress() and 16442 // uncompress() 16443 func XzError(tls *libc.TLS, err int32) uintptr { /* zutil.c:133:12: */ 16444 return Xz_errmsg[(Z_NEED_DICT - (err))] 16445 } 16446 16447 func Xzcalloc(tls *libc.TLS, opaque Voidpf, items uint32, size uint32) Voidpf { /* zutil.c:305:22: */ 16448 _ = opaque 16449 if uint64(unsafe.Sizeof(UInt(0))) > uint64(2) { 16450 return libc.Xmalloc(tls, (uint64(items * size))) 16451 } 16452 return libc.Xcalloc(tls, uint64(items), uint64(size)) 16453 } 16454 16455 func Xzcfree(tls *libc.TLS, opaque Voidpf, ptr Voidpf) { /* zutil.c:315:20: */ 16456 _ = opaque 16457 libc.Xfree(tls, ptr) 16458 } 16459 16460 func init() { 16461 *(*func(*libc.TLS, uintptr, int32) Block_state)(unsafe.Pointer(uintptr(unsafe.Pointer(&configuration_table)) + 8 /* .func */)) = deflate_stored // deflate.c:136:29: 16462 *(*func(*libc.TLS, uintptr, int32) Block_state)(unsafe.Pointer(uintptr(unsafe.Pointer(&configuration_table)) + 24 /* .func */)) = deflate_fast // deflate.c:137:29: 16463 *(*func(*libc.TLS, uintptr, int32) Block_state)(unsafe.Pointer(uintptr(unsafe.Pointer(&configuration_table)) + 40 /* .func */)) = deflate_fast // deflate.c:138:29: 16464 *(*func(*libc.TLS, uintptr, int32) Block_state)(unsafe.Pointer(uintptr(unsafe.Pointer(&configuration_table)) + 56 /* .func */)) = deflate_fast // deflate.c:139:29: 16465 *(*func(*libc.TLS, uintptr, int32) Block_state)(unsafe.Pointer(uintptr(unsafe.Pointer(&configuration_table)) + 72 /* .func */)) = deflate_slow // deflate.c:141:29: 16466 *(*func(*libc.TLS, uintptr, int32) Block_state)(unsafe.Pointer(uintptr(unsafe.Pointer(&configuration_table)) + 88 /* .func */)) = deflate_slow // deflate.c:142:29: 16467 *(*func(*libc.TLS, uintptr, int32) Block_state)(unsafe.Pointer(uintptr(unsafe.Pointer(&configuration_table)) + 104 /* .func */)) = deflate_slow // deflate.c:143:29: 16468 *(*func(*libc.TLS, uintptr, int32) Block_state)(unsafe.Pointer(uintptr(unsafe.Pointer(&configuration_table)) + 120 /* .func */)) = deflate_slow // deflate.c:144:29: 16469 *(*func(*libc.TLS, uintptr, int32) Block_state)(unsafe.Pointer(uintptr(unsafe.Pointer(&configuration_table)) + 136 /* .func */)) = deflate_slow // deflate.c:145:30: 16470 *(*func(*libc.TLS, uintptr, int32) Block_state)(unsafe.Pointer(uintptr(unsafe.Pointer(&configuration_table)) + 152 /* .func */)) = deflate_slow // deflate.c:146:30: 16471 *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&static_bl_desc)) + 8 /* .extra_bits */)) = uintptr(unsafe.Pointer(&extra_blbits)) // trees.c:132:22: 16472 *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&static_d_desc)) + 0 /* .static_tree */)) = uintptr(unsafe.Pointer(&static_dtree)) // trees.c:129:2: 16473 *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&static_d_desc)) + 8 /* .extra_bits */)) = uintptr(unsafe.Pointer(&extra_dbits)) // trees.c:129:16: 16474 *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&static_l_desc)) + 0 /* .static_tree */)) = uintptr(unsafe.Pointer(&static_ltree)) // trees.c:126:2: 16475 *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&static_l_desc)) + 8 /* .extra_bits */)) = uintptr(unsafe.Pointer(&extra_lbits)) // trees.c:126:16: 16476 } 16477 16478 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" 16479 var ts = (*reflect.StringHeader)(unsafe.Pointer(&ts1)).Data