perf/test_input_for_tinycc.c

   1
   2 typedef unsigned int size_t;
   3
   4 typedef long int wchar_t;
   5
   6
   7 typedef struct
   8   {
   9     int quot;
  10     int rem;
  11   } div_t;
  12
  13
  14
  15 typedef struct
  16   {
  17     long int quot;
  18     long int rem;
  19   } ldiv_t;
  20
  21
  22
  23
  24 extern size_t __ctype_get_mb_cur_max (void) __attribute__ ((__nothrow__));
  25
  26
  27
  28
  29 extern double atof (__const char *__nptr)
  30      __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
  31
  32 extern int atoi (__const char *__nptr)
  33      __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
  34
  35 extern long int atol (__const char *__nptr)
  36      __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
  37
  38
  39
  40
  41
  42 __extension__ extern long long int atoll (__const char *__nptr)
  43      __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
  44
  45
  46
  47
  48
  49 extern double strtod (__const char *__restrict __nptr,
  50         char **__restrict __endptr) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
  51
  52
  53
  54
  55 extern long int strtol (__const char *__restrict __nptr,
  56    char **__restrict __endptr, int __base)
  57      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
  58
  59 extern unsigned long int strtoul (__const char *__restrict __nptr,
  60       char **__restrict __endptr, int __base)
  61      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
  62
  63
  64
  65
  66 __extension__
  67 extern long long int strtoq (__const char *__restrict __nptr,
  68         char **__restrict __endptr, int __base)
  69      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
  70
  71 __extension__
  72 extern unsigned long long int strtouq (__const char *__restrict __nptr,
  73            char **__restrict __endptr, int __base)
  74      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
  75
  76
  77
  78
  79
  80 __extension__
  81 extern long long int strtoll (__const char *__restrict __nptr,
  82          char **__restrict __endptr, int __base)
  83      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
  84
  85 __extension__
  86 extern unsigned long long int strtoull (__const char *__restrict __nptr,
  87      char **__restrict __endptr, int __base)
  88      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
  89
  90
  91 extern double __strtod_internal (__const char *__restrict __nptr,
  92      char **__restrict __endptr, int __group)
  93      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
  94 extern float __strtof_internal (__const char *__restrict __nptr,
  95     char **__restrict __endptr, int __group)
  96      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
  97 extern long double __strtold_internal (__const char *__restrict __nptr,
  98            char **__restrict __endptr,
  99            int __group) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
 100
 101 extern long int __strtol_internal (__const char *__restrict __nptr,
 102        char **__restrict __endptr,
 103        int __base, int __group)
 104      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
 105
 106
 107
 108 extern unsigned long int __strtoul_internal (__const char *__restrict __nptr,
 109           char **__restrict __endptr,
 110           int __base, int __group)
 111      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
 112
 113
 114
 115
 116 __extension__
 117 extern long long int __strtoll_internal (__const char *__restrict __nptr,
 118       char **__restrict __endptr,
 119       int __base, int __group)
 120      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
 121
 122
 123
 124 __extension__
 125 extern unsigned long long int __strtoull_internal (__const char *
 126          __restrict __nptr,
 127          char **__restrict __endptr,
 128          int __base, int __group)
 129      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
 130
 131 extern char *l64a (long int __n) __attribute__ ((__nothrow__));
 132
 133
 134 extern long int a64l (__const char *__s)
 135      __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
 136
 137
 138
 139
 140
 141
 142 typedef unsigned char __u_char;
 143 typedef unsigned short int __u_short;
 144 typedef unsigned int __u_int;
 145 typedef unsigned long int __u_long;
 146
 147
 148 typedef signed char __int8_t;
 149 typedef unsigned char __uint8_t;
 150 typedef signed short int __int16_t;
 151 typedef unsigned short int __uint16_t;
 152 typedef signed int __int32_t;
 153 typedef unsigned int __uint32_t;
 154
 155
 156
 157
 158 __extension__ typedef signed long long int __int64_t;
 159 __extension__ typedef unsigned long long int __uint64_t;
 160
 161
 162
 163
 164
 165
 166
 167 __extension__ typedef long long int __quad_t;
 168 __extension__ typedef unsigned long long int __u_quad_t;
 169
 170
 171
 172
 173
 174
 175 __extension__ typedef __u_quad_t __dev_t;
 176 __extension__ typedef unsigned int __uid_t;
 177 __extension__ typedef unsigned int __gid_t;
 178 __extension__ typedef unsigned long int __ino_t;
 179 __extension__ typedef __u_quad_t __ino64_t;
 180 __extension__ typedef unsigned int __mode_t;
 181 __extension__ typedef unsigned int __nlink_t;
 182 __extension__ typedef long int __off_t;
 183 __extension__ typedef __quad_t __off64_t;
 184 __extension__ typedef int __pid_t;
 185 __extension__ typedef struct { int __val[2]; } __fsid_t;
 186 __extension__ typedef long int __clock_t;
 187 __extension__ typedef unsigned long int __rlim_t;
 188 __extension__ typedef __u_quad_t __rlim64_t;
 189 __extension__ typedef unsigned int __id_t;
 190 __extension__ typedef long int __time_t;
 191 __extension__ typedef unsigned int __useconds_t;
 192 __extension__ typedef long int __suseconds_t;
 193
 194 __extension__ typedef int __daddr_t;
 195 __extension__ typedef long int __swblk_t;
 196 __extension__ typedef int __key_t;
 197
 198
 199 __extension__ typedef int __clockid_t;
 200
 201
 202 __extension__ typedef int __timer_t;
 203
 204
 205 __extension__ typedef long int __blksize_t;
 206
 207
 208
 209
 210 __extension__ typedef long int __blkcnt_t;
 211 __extension__ typedef __quad_t __blkcnt64_t;
 212
 213
 214 __extension__ typedef unsigned long int __fsblkcnt_t;
 215 __extension__ typedef __u_quad_t __fsblkcnt64_t;
 216
 217
 218 __extension__ typedef unsigned long int __fsfilcnt_t;
 219 __extension__ typedef __u_quad_t __fsfilcnt64_t;
 220
 221 __extension__ typedef int __ssize_t;
 222
 223
 224
 225 typedef __off64_t __loff_t;
 226 typedef __quad_t *__qaddr_t;
 227 typedef char *__caddr_t;
 228
 229
 230 __extension__ typedef int __intptr_t;
 231
 232
 233 __extension__ typedef unsigned int __socklen_t;
 234
 235
 236
 237
 238 typedef __u_char u_char;
 239 typedef __u_short u_short;
 240 typedef __u_int u_int;
 241 typedef __u_long u_long;
 242 typedef __quad_t quad_t;
 243 typedef __u_quad_t u_quad_t;
 244 typedef __fsid_t fsid_t;
 245
 246
 247
 248
 249 typedef __loff_t loff_t;
 250
 251
 252
 253 typedef __ino_t ino_t;
 254
 255 typedef __dev_t dev_t;
 256
 257
 258
 259
 260 typedef __gid_t gid_t;
 261
 262
 263
 264
 265 typedef __mode_t mode_t;
 266
 267
 268
 269
 270 typedef __nlink_t nlink_t;
 271
 272
 273
 274
 275 typedef __uid_t uid_t;
 276
 277
 278
 279
 280
 281 typedef __off_t off_t;
 282
 283 typedef __pid_t pid_t;
 284
 285
 286
 287
 288 typedef __id_t id_t;
 289
 290
 291
 292
 293 typedef __ssize_t ssize_t;
 294
 295
 296
 297
 298
 299 typedef __daddr_t daddr_t;
 300 typedef __caddr_t caddr_t;
 301
 302
 303
 304
 305
 306 typedef __key_t key_t;
 307
 308
 309 typedef __time_t time_t;
 310
 311
 312
 313
 314 typedef __clockid_t clockid_t;
 315
 316 typedef __timer_t timer_t;
 317
 318
 319
 320
 321 typedef unsigned long int ulong;
 322 typedef unsigned short int ushort;
 323 typedef unsigned int uint;
 324
 325 typedef int int8_t __attribute__ ((__mode__ (__QI__)));
 326 typedef int int16_t __attribute__ ((__mode__ (__HI__)));
 327 typedef int int32_t __attribute__ ((__mode__ (__SI__)));
 328 typedef int int64_t __attribute__ ((__mode__ (__DI__)));
 329
 330
 331 typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
 332 typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
 333 typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
 334 typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));
 335
 336 typedef int register_t __attribute__ ((__mode__ (__word__)));
 337
 338 typedef int __sig_atomic_t;
 339
 340
 341
 342
 343 typedef struct
 344   {
 345     unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
 346   } __sigset_t;
 347
 348
 349
 350
 351 typedef __sigset_t sigset_t;
 352
 353
 354
 355
 356
 357 struct timespec
 358   {
 359     __time_t tv_sec;
 360     long int tv_nsec;
 361   };
 362
 363 struct timeval
 364   {
 365     __time_t tv_sec;
 366     __suseconds_t tv_usec;
 367   };
 368
 369
 370
 371 typedef __suseconds_t suseconds_t;
 372
 373
 374
 375
 376
 377 typedef long int __fd_mask;
 378
 379 typedef struct
 380   {
 381
 382
 383
 384
 385
 386
 387     __fd_mask __fds_bits[1024 / (8 * sizeof (__fd_mask))];
 388
 389
 390   } fd_set;
 391
 392
 393
 394
 395
 396
 397 typedef __fd_mask fd_mask;
 398
 399
 400
 401 extern int select (int __nfds, fd_set *__restrict __readfds,
 402      fd_set *__restrict __writefds,
 403      fd_set *__restrict __exceptfds,
 404      struct timeval *__restrict __timeout);
 405
 406 __extension__
 407 extern __inline unsigned int gnu_dev_major (unsigned long long int __dev)
 408      __attribute__ ((__nothrow__));
 409 __extension__
 410 extern __inline unsigned int gnu_dev_minor (unsigned long long int __dev)
 411      __attribute__ ((__nothrow__));
 412 __extension__
 413 extern __inline unsigned long long int gnu_dev_makedev (unsigned int __major,
 414        unsigned int __minor)
 415      __attribute__ ((__nothrow__));
 416
 417
 418 __extension__ extern __inline unsigned int
 419 __attribute__ ((__nothrow__)) gnu_dev_major (unsigned long long int __dev)
 420 {
 421   return ((__dev >> 8) & 0xfff) | ((unsigned int) (__dev >> 32) & ~0xfff);
 422 }
 423
 424 __extension__ extern __inline unsigned int
 425 __attribute__ ((__nothrow__)) gnu_dev_minor (unsigned long long int __dev)
 426 {
 427   return (__dev & 0xff) | ((unsigned int) (__dev >> 12) & ~0xff);
 428 }
 429
 430 __extension__ extern __inline unsigned long long int
 431 __attribute__ ((__nothrow__)) gnu_dev_makedev (unsigned int __major, unsigned int __minor)
 432 {
 433   return ((__minor & 0xff) | ((__major & 0xfff) << 8)
 434    | (((unsigned long long int) (__minor & ~0xff)) << 12)
 435    | (((unsigned long long int) (__major & ~0xfff)) << 32));
 436 }
 437
 438 typedef __blkcnt_t blkcnt_t;
 439
 440
 441
 442 typedef __fsblkcnt_t fsblkcnt_t;
 443
 444
 445
 446 typedef __fsfilcnt_t fsfilcnt_t;
 447
 448 struct __sched_param
 449   {
 450     int __sched_priority;
 451   };
 452
 453
 454
 455 struct _pthread_fastlock
 456 {
 457   long int __status;
 458   int __spinlock;
 459
 460 };
 461
 462
 463
 464 typedef struct _pthread_descr_struct *_pthread_descr;
 465
 466
 467
 468
 469
 470 typedef struct __pthread_attr_s
 471 {
 472   int __detachstate;
 473   int __schedpolicy;
 474   struct __sched_param __schedparam;
 475   int __inheritsched;
 476   int __scope;
 477   size_t __guardsize;
 478   int __stackaddr_set;
 479   void *__stackaddr;
 480   size_t __stacksize;
 481 } pthread_attr_t;
 482
 483
 484
 485
 486
 487 __extension__ typedef long long __pthread_cond_align_t;
 488
 489
 490
 491
 492 typedef struct
 493 {
 494   struct _pthread_fastlock __c_lock;
 495   _pthread_descr __c_waiting;
 496   char __padding[48 - sizeof (struct _pthread_fastlock)
 497    - sizeof (_pthread_descr) - sizeof (__pthread_cond_align_t)];
 498   __pthread_cond_align_t __align;
 499 } pthread_cond_t;
 500
 501
 502
 503 typedef struct
 504 {
 505   int __dummy;
 506 } pthread_condattr_t;
 507
 508
 509 typedef unsigned int pthread_key_t;
 510
 511
 512
 513
 514
 515 typedef struct
 516 {
 517   int __m_reserved;
 518   int __m_count;
 519   _pthread_descr __m_owner;
 520   int __m_kind;
 521   struct _pthread_fastlock __m_lock;
 522 } pthread_mutex_t;
 523
 524
 525
 526 typedef struct
 527 {
 528   int __mutexkind;
 529 } pthread_mutexattr_t;
 530
 531
 532
 533 typedef int pthread_once_t;
 534
 535 typedef unsigned long int pthread_t;
 536
 537
 538
 539
 540
 541
 542
 543 extern long int random (void) __attribute__ ((__nothrow__));
 544
 545
 546 extern void srandom (unsigned int __seed) __attribute__ ((__nothrow__));
 547
 548
 549
 550
 551
 552 extern char *initstate (unsigned int __seed, char *__statebuf,
 553    size_t __statelen) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
 554
 555
 556
 557 extern char *setstate (char *__statebuf) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
 558
 559
 560
 561
 562
 563
 564
 565 struct random_data
 566   {
 567     int32_t *fptr;
 568     int32_t *rptr;
 569     int32_t *state;
 570     int rand_type;
 571     int rand_deg;
 572     int rand_sep;
 573     int32_t *end_ptr;
 574   };
 575
 576 extern int random_r (struct random_data *__restrict __buf,
 577        int32_t *__restrict __result) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
 578
 579 extern int srandom_r (unsigned int __seed, struct random_data *__buf)
 580      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
 581
 582 extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
 583    size_t __statelen,
 584    struct random_data *__restrict __buf)
 585      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 4)));
 586
 587 extern int setstate_r (char *__restrict __statebuf,
 588          struct random_data *__restrict __buf)
 589      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
 590
 591
 592
 593
 594
 595
 596 extern int rand (void) __attribute__ ((__nothrow__));
 597
 598 extern void srand (unsigned int __seed) __attribute__ ((__nothrow__));
 599
 600
 601
 602
 603 extern int rand_r (unsigned int *__seed) __attribute__ ((__nothrow__));
 604
 605
 606
 607
 608
 609
 610
 611 extern double drand48 (void) __attribute__ ((__nothrow__));
 612 extern double erand48 (unsigned short int __xsubi[3]) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
 613
 614
 615 extern long int lrand48 (void) __attribute__ ((__nothrow__));
 616 extern long int nrand48 (unsigned short int __xsubi[3])
 617      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
 618
 619
 620 extern long int mrand48 (void) __attribute__ ((__nothrow__));
 621 extern long int jrand48 (unsigned short int __xsubi[3])
 622      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
 623
 624
 625 extern void srand48 (long int __seedval) __attribute__ ((__nothrow__));
 626 extern unsigned short int *seed48 (unsigned short int __seed16v[3])
 627      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
 628 extern void lcong48 (unsigned short int __param[7]) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
 629
 630
 631
 632
 633
 634 struct drand48_data
 635   {
 636     unsigned short int __x[3];
 637     unsigned short int __old_x[3];
 638     unsigned short int __c;
 639     unsigned short int __init;
 640     unsigned long long int __a;
 641   };
 642
 643
 644 extern int drand48_r (struct drand48_data *__restrict __buffer,
 645         double *__restrict __result) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
 646 extern int erand48_r (unsigned short int __xsubi[3],
 647         struct drand48_data *__restrict __buffer,
 648         double *__restrict __result) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
 649
 650
 651 extern int lrand48_r (struct drand48_data *__restrict __buffer,
 652         long int *__restrict __result)
 653      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
 654 extern int nrand48_r (unsigned short int __xsubi[3],
 655         struct drand48_data *__restrict __buffer,
 656         long int *__restrict __result)
 657      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
 658
 659
 660 extern int mrand48_r (struct drand48_data *__restrict __buffer,
 661         long int *__restrict __result)
 662      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
 663 extern int jrand48_r (unsigned short int __xsubi[3],
 664         struct drand48_data *__restrict __buffer,
 665         long int *__restrict __result)
 666      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
 667
 668
 669 extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
 670      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
 671
 672 extern int seed48_r (unsigned short int __seed16v[3],
 673        struct drand48_data *__buffer) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
 674
 675 extern int lcong48_r (unsigned short int __param[7],
 676         struct drand48_data *__buffer)
 677      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
 678
 679
 680
 681
 682
 683
 684
 685
 686
 687 extern void *malloc (size_t __size) __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));
 688
 689 extern void *calloc (size_t __nmemb, size_t __size)
 690      __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));
 691
 692
 693
 694
 695
 696
 697
 698 extern void *realloc (void *__ptr, size_t __size) __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));
 699
 700 extern void free (void *__ptr) __attribute__ ((__nothrow__));
 701
 702
 703
 704
 705 extern void cfree (void *__ptr) __attribute__ ((__nothrow__));
 706
 707
 708
 709
 710 extern void *alloca (size_t __size) __attribute__ ((__nothrow__));
 711
 712
 713
 714
 715
 716
 717 extern void *valloc (size_t __size) __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));
 718
 719 extern void abort (void) __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));
 720
 721
 722
 723 extern int atexit (void (*__func) (void)) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
 724
 725
 726
 727
 728
 729 extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
 730      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
 731
 732
 733
 734
 735
 736
 737 extern void exit (int __status) __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));
 738
 739 extern char *getenv (__const char *__name) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
 740
 741
 742
 743
 744 extern char *__secure_getenv (__const char *__name) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
 745
 746
 747
 748
 749
 750 extern int putenv (char *__string) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
 751
 752
 753
 754
 755
 756 extern int setenv (__const char *__name, __const char *__value, int __replace)
 757      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
 758
 759
 760 extern int unsetenv (__const char *__name) __attribute__ ((__nothrow__));
 761
 762
 763
 764
 765
 766
 767 extern int clearenv (void) __attribute__ ((__nothrow__));
 768
 769 extern char *mktemp (char *__template) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
 770
 771 extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1)));
 772
 773 extern char *mkdtemp (char *__template) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
 774
 775
 776
 777
 778
 779
 780
 781
 782 extern int system (__const char *__command);
 783
 784 extern char *realpath (__const char *__restrict __name,
 785          char *__restrict __resolved) __attribute__ ((__nothrow__));
 786
 787
 788
 789
 790
 791
 792 typedef int (*__compar_fn_t) (__const void *, __const void *);
 793
 794
 795
 796
 797
 798
 799
 800
 801
 802 extern void *bsearch (__const void *__key, __const void *__base,
 803         size_t __nmemb, size_t __size, __compar_fn_t __compar)
 804      __attribute__ ((__nonnull__ (1, 2, 5)));
 805
 806
 807
 808 extern void qsort (void *__base, size_t __nmemb, size_t __size,
 809      __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
 810
 811
 812
 813 extern int abs (int __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
 814 extern long int labs (long int __x) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
 815
 816
 817
 818
 819
 820
 821
 822
 823
 824
 825
 826
 827 extern div_t div (int __numer, int __denom)
 828      __attribute__ ((__nothrow__)) __attribute__ ((__const__));
 829 extern ldiv_t ldiv (long int __numer, long int __denom)
 830      __attribute__ ((__nothrow__)) __attribute__ ((__const__));
 831
 832 extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
 833      int *__restrict __sign) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4)));
 834
 835
 836
 837
 838 extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
 839      int *__restrict __sign) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4)));
 840
 841
 842
 843
 844 extern char *gcvt (double __value, int __ndigit, char *__buf)
 845      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3)));
 846
 847
 848
 849
 850 extern char *qecvt (long double __value, int __ndigit,
 851       int *__restrict __decpt, int *__restrict __sign)
 852      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4)));
 853 extern char *qfcvt (long double __value, int __ndigit,
 854       int *__restrict __decpt, int *__restrict __sign)
 855      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4)));
 856 extern char *qgcvt (long double __value, int __ndigit, char *__buf)
 857      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3)));
 858
 859
 860
 861
 862 extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
 863      int *__restrict __sign, char *__restrict __buf,
 864      size_t __len) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4, 5)));
 865 extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
 866      int *__restrict __sign, char *__restrict __buf,
 867      size_t __len) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4, 5)));
 868
 869 extern int qecvt_r (long double __value, int __ndigit,
 870       int *__restrict __decpt, int *__restrict __sign,
 871       char *__restrict __buf, size_t __len)
 872      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4, 5)));
 873 extern int qfcvt_r (long double __value, int __ndigit,
 874       int *__restrict __decpt, int *__restrict __sign,
 875       char *__restrict __buf, size_t __len)
 876      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (3, 4, 5)));
 877
 878
 879
 880
 881
 882
 883
 884 extern int mblen (__const char *__s, size_t __n) __attribute__ ((__nothrow__));
 885
 886
 887 extern int mbtowc (wchar_t *__restrict __pwc,
 888      __const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__));
 889
 890
 891 extern int wctomb (char *__s, wchar_t __wchar) __attribute__ ((__nothrow__));
 892
 893
 894
 895 extern size_t mbstowcs (wchar_t *__restrict __pwcs,
 896    __const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__));
 897
 898 extern size_t wcstombs (char *__restrict __s,
 899    __const wchar_t *__restrict __pwcs, size_t __n)
 900      __attribute__ ((__nothrow__));
 901
 902
 903
 904
 905
 906
 907
 908
 909 extern int rpmatch (__const char *__response) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
 910 extern int getloadavg (double __loadavg[], int __nelem)
 911      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
 912
 913
 914
 915
 916
 917
 918
 919 typedef
 920    struct {
 921       char *next_in;
 922       unsigned int avail_in;
 923       unsigned int total_in_lo32;
 924       unsigned int total_in_hi32;
 925
 926       char *next_out;
 927       unsigned int avail_out;
 928       unsigned int total_out_lo32;
 929       unsigned int total_out_hi32;
 930
 931       void *state;
 932
 933       void *(*bzalloc)(void *,int,int);
 934       void (*bzfree)(void *,void *);
 935       void *opaque;
 936    }
 937    bz_stream;
 938
 939 extern int BZ2_bzCompressInit (
 940       bz_stream* strm,
 941       int blockSize100k,
 942       int verbosity,
 943       int workFactor
 944    );
 945
 946 extern int BZ2_bzCompress (
 947       bz_stream* strm,
 948       int action
 949    );
 950
 951 extern int BZ2_bzCompressEnd (
 952       bz_stream* strm
 953    );
 954
 955 extern int BZ2_bzDecompressInit (
 956       bz_stream *strm,
 957       int verbosity,
 958       int small
 959    );
 960
 961 extern int BZ2_bzDecompress (
 962       bz_stream* strm
 963    );
 964
 965 extern int BZ2_bzDecompressEnd (
 966       bz_stream *strm
 967    );
 968
 969 extern int BZ2_bzBuffToBuffCompress (
 970       char* dest,
 971       unsigned int* destLen,
 972       char* source,
 973       unsigned int sourceLen,
 974       int blockSize100k,
 975       int verbosity,
 976       int workFactor
 977    );
 978
 979 extern int BZ2_bzBuffToBuffDecompress (
 980       char* dest,
 981       unsigned int* destLen,
 982       char* source,
 983       unsigned int sourceLen,
 984       int small,
 985       int verbosity
 986    );
 987
 988 extern const char * BZ2_bzlibVersion (
 989       void
 990    );
 991
 992 typedef char Char;
 993 typedef unsigned char Bool;
 994 typedef unsigned char UChar;
 995 typedef int Int32;
 996 typedef unsigned int UInt32;
 997 typedef short Int16;
 998 typedef unsigned short UInt16;
 999
1000 extern void bz_internal_error ( int errcode );
1001
1002 extern Int32 BZ2_rNums[512];
1003
1004 extern UInt32 BZ2_crc32Table[256];
1005
1006 typedef
1007    struct {
1008
1009       bz_stream* strm;
1010
1011
1012
1013       Int32 mode;
1014       Int32 state;
1015
1016
1017       UInt32 avail_in_expect;
1018
1019
1020       UInt32* arr1;
1021       UInt32* arr2;
1022       UInt32* ftab;
1023       Int32 origPtr;
1024
1025
1026       UInt32* ptr;
1027       UChar* block;
1028       UInt16* mtfv;
1029       UChar* zbits;
1030
1031
1032       Int32 workFactor;
1033
1034
1035       UInt32 state_in_ch;
1036       Int32 state_in_len;
1037       Int32 rNToGo; Int32 rTPos;
1038
1039
1040       Int32 nblock;
1041       Int32 nblockMAX;
1042       Int32 numZ;
1043       Int32 state_out_pos;
1044
1045
1046       Int32 nInUse;
1047       Bool inUse[256];
1048       UChar unseqToSeq[256];
1049
1050
1051       UInt32 bsBuff;
1052       Int32 bsLive;
1053
1054
1055       UInt32 blockCRC;
1056       UInt32 combinedCRC;
1057
1058
1059       Int32 verbosity;
1060       Int32 blockNo;
1061       Int32 blockSize100k;
1062
1063
1064       Int32 nMTF;
1065       Int32 mtfFreq [258];
1066       UChar selector [(2 + (900000 / 50))];
1067       UChar selectorMtf[(2 + (900000 / 50))];
1068
1069       UChar len [6][258];
1070       Int32 code [6][258];
1071       Int32 rfreq [6][258];
1072
1073       UInt32 len_pack[258][4];
1074
1075    }
1076    EState;
1077
1078
1079
1080
1081
1082 extern void
1083 BZ2_blockSort ( EState* );
1084
1085 extern void
1086 BZ2_compressBlock ( EState*, Bool );
1087
1088 extern void
1089 BZ2_bsInitWrite ( EState* );
1090
1091 extern void
1092 BZ2_hbAssignCodes ( Int32*, UChar*, Int32, Int32, Int32 );
1093
1094 extern void
1095 BZ2_hbMakeCodeLengths ( UChar*, Int32*, Int32, Int32 );
1096
1097 typedef
1098    struct {
1099
1100       bz_stream* strm;
1101
1102
1103       Int32 state;
1104
1105
1106       UChar state_out_ch;
1107       Int32 state_out_len;
1108       Bool blockRandomised;
1109       Int32 rNToGo; Int32 rTPos;
1110
1111
1112       UInt32 bsBuff;
1113       Int32 bsLive;
1114
1115
1116       Int32 blockSize100k;
1117       Bool smallDecompress;
1118       Int32 currBlockNo;
1119       Int32 verbosity;
1120
1121
1122       Int32 origPtr;
1123       UInt32 tPos;
1124       Int32 k0;
1125       Int32 unzftab[256];
1126       Int32 nblock_used;
1127       Int32 cftab[257];
1128       Int32 cftabCopy[257];
1129
1130
1131       UInt32 *tt;
1132
1133
1134       UInt16 *ll16;
1135       UChar *ll4;
1136
1137
1138       UInt32 storedBlockCRC;
1139       UInt32 storedCombinedCRC;
1140       UInt32 calculatedBlockCRC;
1141       UInt32 calculatedCombinedCRC;
1142
1143
1144       Int32 nInUse;
1145       Bool inUse[256];
1146       Bool inUse16[16];
1147       UChar seqToUnseq[256];
1148
1149
1150       UChar mtfa [4096];
1151       Int32 mtfbase[256 / 16];
1152       UChar selector [(2 + (900000 / 50))];
1153       UChar selectorMtf[(2 + (900000 / 50))];
1154       UChar len [6][258];
1155
1156       Int32 limit [6][258];
1157       Int32 base [6][258];
1158       Int32 perm [6][258];
1159       Int32 minLens[6];
1160
1161
1162       Int32 save_i;
1163       Int32 save_j;
1164       Int32 save_t;
1165       Int32 save_alphaSize;
1166       Int32 save_nGroups;
1167       Int32 save_nSelectors;
1168       Int32 save_EOB;
1169       Int32 save_groupNo;
1170       Int32 save_groupPos;
1171       Int32 save_nextSym;
1172       Int32 save_nblockMAX;
1173       Int32 save_nblock;
1174       Int32 save_es;
1175       Int32 save_N;
1176       Int32 save_curr;
1177       Int32 save_zt;
1178       Int32 save_zn;
1179       Int32 save_zvec;
1180       Int32 save_zj;
1181       Int32 save_gSel;
1182       Int32 save_gMinlen;
1183       Int32* save_gLimit;
1184       Int32* save_gBase;
1185       Int32* save_gPerm;
1186
1187    }
1188    DState;
1189
1190 extern Int32
1191 BZ2_indexIntoF ( Int32, Int32* );
1192
1193 extern Int32
1194 BZ2_decompress ( DState* );
1195
1196 extern void
1197 BZ2_hbCreateDecodeTables ( Int32*, Int32*, Int32*, UChar*,
1198                            Int32, Int32, Int32 );
1199
1200 typedef unsigned long HWord;
1201 typedef char HChar;
1202 typedef signed int Int;
1203 typedef unsigned int UInt;
1204
1205 typedef signed long long int Long;
1206 typedef unsigned long long int ULong;
1207
1208
1209
1210
1211
1212 static HWord (*serviceFn)(HWord,HWord) = 0;
1213
1214 char* my_strcat ( char* dest, const char* src )
1215 {
1216    char* dest_orig = dest;
1217    while (*dest) dest++;
1218    while (*src) *dest++ = *src++;
1219    *dest = 0;
1220    return dest_orig;
1221 }
1222
1223
1224
1225
1226 static void vex_log_bytes ( char* p, int n )
1227 {
1228    int i;
1229    for (i = 0; i < n; i++)
1230       (*serviceFn)( 1, (int)p[i] );
1231 }
1232
1233
1234
1235
1236 static HChar vex_toupper ( HChar c )
1237 {
1238    if (c >= 'a' && c <= 'z')
1239       return c + ('A' - 'a');
1240    else
1241       return c;
1242 }
1243
1244 static Int vex_strlen ( const HChar* str )
1245 {
1246    Int i = 0;
1247    while (str[i] != 0) i++;
1248    return i;
1249 }
1250
1251 Bool vex_streq ( const HChar* s1, const HChar* s2 )
1252 {
1253    while (((Bool)1)) {
1254       if (*s1 == 0 && *s2 == 0)
1255          return ((Bool)1);
1256       if (*s1 != *s2)
1257          return ((Bool)0);
1258       s1++;
1259       s2++;
1260    }
1261 }
1262
1263 static UInt
1264 myvprintf_str ( void(*send)(HChar), Int flags, Int width, HChar* str,
1265                 Bool capitalise )
1266 {
1267
1268    UInt ret = 0;
1269    Int i, extra;
1270    Int len = vex_strlen(str);
1271
1272    if (width == 0) {
1273       ret += len;
1274       for (i = 0; i < len; i++)
1275          send((capitalise ? vex_toupper(str[i]) : (str[i])));
1276       return ret;
1277    }
1278
1279    if (len > width) {
1280       ret += width;
1281       for (i = 0; i < width; i++)
1282          send((capitalise ? vex_toupper(str[i]) : (str[i])));
1283       return ret;
1284    }
1285
1286    extra = width - len;
1287    if (flags & 4) {
1288       ret += extra;
1289       for (i = 0; i < extra; i++)
1290          send(' ');
1291    }
1292    ret += len;
1293    for (i = 0; i < len; i++)
1294       send((capitalise ? vex_toupper(str[i]) : (str[i])));
1295    if (!(flags & 4)) {
1296       ret += extra;
1297       for (i = 0; i < extra; i++)
1298          send(' ');
1299    }
1300
1301
1302
1303    return ret;
1304 }
1305
1306
1307
1308
1309
1310
1311
1312 static UInt
1313 myvprintf_int64 ( void(*send)(HChar), Int flags, Int base, Int width, ULong pL)
1314 {
1315    HChar buf[40];
1316    Int ind = 0;
1317    Int i, nc = 0;
1318    Bool neg = ((Bool)0);
1319    HChar *digits = "0123456789ABCDEF";
1320    UInt ret = 0;
1321    UInt p = (UInt)pL;
1322
1323    if (base < 2 || base > 16)
1324       return ret;
1325
1326    if ((flags & 1) && (Int)p < 0) {
1327       p = - (Int)p;
1328       neg = ((Bool)1);
1329    }
1330
1331    if (p == 0)
1332       buf[ind++] = '0';
1333    else {
1334       while (p > 0) {
1335          if ((flags & 16) && 10 == base &&
1336              0 == (ind-nc) % 3 && 0 != ind)
1337          {
1338             buf[ind++] = ',';
1339             nc++;
1340          }
1341          buf[ind++] = digits[p % base];
1342          p /= base;
1343       }
1344    }
1345
1346    if (neg)
1347       buf[ind++] = '-';
1348
1349    if (width > 0 && !(flags & 4)) {
1350       for(; ind < width; ind++) {
1351
1352          buf[ind] = ((flags & 2) ? '0': ' ');
1353       }
1354    }
1355
1356
1357    ret += ind;
1358    for (i = ind -1; i >= 0; i--) {
1359       send(buf[i]);
1360    }
1361    if (width > 0 && (flags & 4)) {
1362       for(; ind < width; ind++) {
1363   ret++;
1364          send(' ');
1365       }
1366    }
1367    return ret;
1368 }
1369
1370
1371
1372 static
1373 UInt vprintf_wrk ( )
1374 {
1375   return 0;
1376 }
1377
1378
1379
1380
1381
1382
1383 static HChar myprintf_buf[1000];
1384 static Int n_myprintf_buf;
1385
1386 static void add_to_myprintf_buf ( HChar c )
1387 {
1388    if (c == '\n' || n_myprintf_buf >= 1000-10 ) {
1389       vex_log_bytes( myprintf_buf, vex_strlen(myprintf_buf) );
1390       n_myprintf_buf = 0;
1391       myprintf_buf[n_myprintf_buf] = 0;
1392    }
1393    myprintf_buf[n_myprintf_buf++] = c;
1394    myprintf_buf[n_myprintf_buf] = 0;
1395 }
1396
1397 static UInt vex_printf ( const char *format, ... )
1398 {
1399   return 0;
1400 }
1401
1402 static
1403 void makeMaps_d ( DState* s )
1404 {
1405    Int32 i;
1406    s->nInUse = 0;
1407    for (i = 0; i < 256; i++)
1408       if (s->inUse[i]) {
1409          s->seqToUnseq[s->nInUse] = i;
1410          s->nInUse++;
1411       }
1412 }
1413
1414 __inline__ Int32 BZ2_indexIntoF ( Int32 indx, Int32 *cftab )
1415 {
1416    Int32 nb, na, mid;
1417    nb = 0;
1418    na = 256;
1419    do {
1420       mid = (nb + na) >> 1;
1421       if (indx >= cftab[mid]) nb = mid; else na = mid;
1422    }
1423    while (na - nb != 1);
1424    return nb;
1425 }
1426
1427
1428 Int32 BZ2_decompress ( DState* s )
1429 {
1430    UChar uc;
1431    Int32 retVal;
1432    Int32 minLen, maxLen;
1433    bz_stream* strm = s->strm;
1434
1435
1436    Int32 i;
1437    Int32 j;
1438    Int32 t;
1439    Int32 alphaSize;
1440    Int32 nGroups;
1441    Int32 nSelectors;
1442    Int32 EOB;
1443    Int32 groupNo;
1444    Int32 groupPos;
1445    Int32 nextSym;
1446    Int32 nblockMAX;
1447    Int32 nblock;
1448    Int32 es;
1449    Int32 N;
1450    Int32 curr;
1451    Int32 zt;
1452    Int32 zn;
1453    Int32 zvec;
1454    Int32 zj;
1455    Int32 gSel;
1456    Int32 gMinlen;
1457    Int32* gLimit;
1458    Int32* gBase;
1459    Int32* gPerm;
1460
1461    if (s->state == 10) {
1462
1463       s->save_i = 0;
1464       s->save_j = 0;
1465       s->save_t = 0;
1466       s->save_alphaSize = 0;
1467       s->save_nGroups = 0;
1468       s->save_nSelectors = 0;
1469       s->save_EOB = 0;
1470       s->save_groupNo = 0;
1471       s->save_groupPos = 0;
1472       s->save_nextSym = 0;
1473       s->save_nblockMAX = 0;
1474       s->save_nblock = 0;
1475       s->save_es = 0;
1476       s->save_N = 0;
1477       s->save_curr = 0;
1478       s->save_zt = 0;
1479       s->save_zn = 0;
1480       s->save_zvec = 0;
1481       s->save_zj = 0;
1482       s->save_gSel = 0;
1483       s->save_gMinlen = 0;
1484       s->save_gLimit = ((void *)0);
1485       s->save_gBase = ((void *)0);
1486       s->save_gPerm = ((void *)0);
1487    }
1488
1489
1490    i = s->save_i;
1491    j = s->save_j;
1492    t = s->save_t;
1493    alphaSize = s->save_alphaSize;
1494    nGroups = s->save_nGroups;
1495    nSelectors = s->save_nSelectors;
1496    EOB = s->save_EOB;
1497    groupNo = s->save_groupNo;
1498    groupPos = s->save_groupPos;
1499    nextSym = s->save_nextSym;
1500    nblockMAX = s->save_nblockMAX;
1501    nblock = s->save_nblock;
1502    es = s->save_es;
1503    N = s->save_N;
1504    curr = s->save_curr;
1505    zt = s->save_zt;
1506    zn = s->save_zn;
1507    zvec = s->save_zvec;
1508    zj = s->save_zj;
1509    gSel = s->save_gSel;
1510    gMinlen = s->save_gMinlen;
1511    gLimit = s->save_gLimit;
1512    gBase = s->save_gBase;
1513    gPerm = s->save_gPerm;
1514
1515    retVal = 0;
1516
1517    switch (s->state) {
1518
1519       case 10: s->state = 10; while (((Bool)1)) { if (s->bsLive >= 8) { UInt32 v; v = (s->bsBuff >> (s->bsLive-8)) & ((1 << 8)-1); s->bsLive -= 8; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1520       if (uc != 0x42) { retVal = (-5); goto save_state_and_return; };;
1521
1522       case 11: s->state = 11; while (((Bool)1)) { if (s->bsLive >= 8) { UInt32 v; v = (s->bsBuff >> (s->bsLive-8)) & ((1 << 8)-1); s->bsLive -= 8; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1523       if (uc != 0x5a) { retVal = (-5); goto save_state_and_return; };;
1524
1525       case 12: s->state = 12; while (((Bool)1)) { if (s->bsLive >= 8) { UInt32 v; v = (s->bsBuff >> (s->bsLive-8)) & ((1 << 8)-1); s->bsLive -= 8; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; }
1526       if (uc != 0x68) { retVal = (-5); goto save_state_and_return; };;
1527
1528       case 13: s->state = 13; while (((Bool)1)) { if (s->bsLive >= 8) { UInt32 v; v = (s->bsBuff >> (s->bsLive-8)) & ((1 << 8)-1); s->bsLive -= 8; s->blockSize100k = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; }
1529       if (s->blockSize100k < (0x30 + 1) ||
1530           s->blockSize100k > (0x30 + 9)) { retVal = (-5); goto save_state_and_return; };;
1531       s->blockSize100k -= 0x30;
1532
1533       if (s->smallDecompress) {
1534          s->ll16 = (strm->bzalloc)(strm->opaque,(s->blockSize100k * 100000 * sizeof(UInt16)),1);
1535          s->ll4 = (strm->bzalloc)(strm->opaque,(((1 + s->blockSize100k * 100000) >> 1) * sizeof(UChar)),1);
1536
1537
1538          if (s->ll16 == ((void *)0) || s->ll4 == ((void *)0)) { retVal = (-3); goto save_state_and_return; };;
1539       } else {
1540          s->tt = (strm->bzalloc)(strm->opaque,(s->blockSize100k * 100000 * sizeof(Int32)),1);
1541          if (s->tt == ((void *)0)) { retVal = (-3); goto save_state_and_return; };;
1542       }
1543
1544       case 14: s->state = 14; while (((Bool)1)) { if (s->bsLive >= 8) { UInt32 v; v = (s->bsBuff >> (s->bsLive-8)) & ((1 << 8)-1); s->bsLive -= 8; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1545
1546       if (uc == 0x17) goto endhdr_2;
1547       if (uc != 0x31) { retVal = (-4); goto save_state_and_return; };;
1548       case 15: s->state = 15; while (((Bool)1)) { if (s->bsLive >= 8) { UInt32 v; v = (s->bsBuff >> (s->bsLive-8)) & ((1 << 8)-1); s->bsLive -= 8; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1549       if (uc != 0x41) { retVal = (-4); goto save_state_and_return; };;
1550       case 16: s->state = 16; while (((Bool)1)) { if (s->bsLive >= 8) { UInt32 v; v = (s->bsBuff >> (s->bsLive-8)) & ((1 << 8)-1); s->bsLive -= 8; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1551       if (uc != 0x59) { retVal = (-4); goto save_state_and_return; };;
1552       case 17: s->state = 17; while (((Bool)1)) { if (s->bsLive >= 8) { UInt32 v; v = (s->bsBuff >> (s->bsLive-8)) & ((1 << 8)-1); s->bsLive -= 8; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1553       if (uc != 0x26) { retVal = (-4); goto save_state_and_return; };;
1554       case 18: s->state = 18; while (((Bool)1)) { if (s->bsLive >= 8) { UInt32 v; v = (s->bsBuff >> (s->bsLive-8)) & ((1 << 8)-1); s->bsLive -= 8; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1555       if (uc != 0x53) { retVal = (-4); goto save_state_and_return; };;
1556       case 19: s->state = 19; while (((Bool)1)) { if (s->bsLive >= 8) { UInt32 v; v = (s->bsBuff >> (s->bsLive-8)) & ((1 << 8)-1); s->bsLive -= 8; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1557       if (uc != 0x59) { retVal = (-4); goto save_state_and_return; };;
1558
1559       s->currBlockNo++;
1560       if (s->verbosity >= 2)
1561          vex_printf("\n    [%d: huff+mtf ",s->currBlockNo);
1562
1563       s->storedBlockCRC = 0;
1564       case 20: s->state = 20; while (((Bool)1)) { if (s->bsLive >= 8) { UInt32 v; v = (s->bsBuff >> (s->bsLive-8)) & ((1 << 8)-1); s->bsLive -= 8; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1565       s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
1566       case 21: s->state = 21; while (((Bool)1)) { if (s->bsLive >= 8) { UInt32 v; v = (s->bsBuff >> (s->bsLive-8)) & ((1 << 8)-1); s->bsLive -= 8; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1567       s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
1568       case 22: s->state = 22; while (((Bool)1)) { if (s->bsLive >= 8) { UInt32 v; v = (s->bsBuff >> (s->bsLive-8)) & ((1 << 8)-1); s->bsLive -= 8; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1569       s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
1570       case 23: s->state = 23; while (((Bool)1)) { if (s->bsLive >= 8) { UInt32 v; v = (s->bsBuff >> (s->bsLive-8)) & ((1 << 8)-1); s->bsLive -= 8; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1571       s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
1572
1573       case 24: s->state = 24; while (((Bool)1)) { if (s->bsLive >= 1) { UInt32 v; v = (s->bsBuff >> (s->bsLive-1)) & ((1 << 1)-1); s->bsLive -= 1; s->blockRandomised = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1574
1575       s->origPtr = 0;
1576       case 25: s->state = 25; while (((Bool)1)) { if (s->bsLive >= 8) { UInt32 v; v = (s->bsBuff >> (s->bsLive-8)) & ((1 << 8)-1); s->bsLive -= 8; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1577       s->origPtr = (s->origPtr << 8) | ((Int32)uc);
1578       case 26: s->state = 26; while (((Bool)1)) { if (s->bsLive >= 8) { UInt32 v; v = (s->bsBuff >> (s->bsLive-8)) & ((1 << 8)-1); s->bsLive -= 8; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1579       s->origPtr = (s->origPtr << 8) | ((Int32)uc);
1580       case 27: s->state = 27; while (((Bool)1)) { if (s->bsLive >= 8) { UInt32 v; v = (s->bsBuff >> (s->bsLive-8)) & ((1 << 8)-1); s->bsLive -= 8; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1581       s->origPtr = (s->origPtr << 8) | ((Int32)uc);
1582
1583       if (s->origPtr < 0)
1584          { retVal = (-4); goto save_state_and_return; };;
1585       if (s->origPtr > 10 + 100000*s->blockSize100k)
1586          { retVal = (-4); goto save_state_and_return; };;
1587
1588
1589       for (i = 0; i < 16; i++) {
1590          case 28: s->state = 28; while (((Bool)1)) { if (s->bsLive >= 1) { UInt32 v; v = (s->bsBuff >> (s->bsLive-1)) & ((1 << 1)-1); s->bsLive -= 1; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1591          if (uc == 1)
1592             s->inUse16[i] = ((Bool)1); else
1593             s->inUse16[i] = ((Bool)0);
1594       }
1595
1596       for (i = 0; i < 256; i++) s->inUse[i] = ((Bool)0);
1597
1598       for (i = 0; i < 16; i++)
1599          if (s->inUse16[i])
1600             for (j = 0; j < 16; j++) {
1601                case 29: s->state = 29; while (((Bool)1)) { if (s->bsLive >= 1) { UInt32 v; v = (s->bsBuff >> (s->bsLive-1)) & ((1 << 1)-1); s->bsLive -= 1; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1602                if (uc == 1) s->inUse[i * 16 + j] = ((Bool)1);
1603             }
1604       makeMaps_d ( s );
1605       if (s->nInUse == 0) { retVal = (-4); goto save_state_and_return; };;
1606       alphaSize = s->nInUse+2;
1607
1608
1609       case 30: s->state = 30; while (((Bool)1)) { if (s->bsLive >= 3) { UInt32 v; v = (s->bsBuff >> (s->bsLive-3)) & ((1 << 3)-1); s->bsLive -= 3; nGroups = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1610       if (nGroups < 2 || nGroups > 6) { retVal = (-4); goto save_state_and_return; };;
1611       case 31: s->state = 31; while (((Bool)1)) { if (s->bsLive >= 15) { UInt32 v; v = (s->bsBuff >> (s->bsLive-15)) & ((1 << 15)-1); s->bsLive -= 15; nSelectors = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1612       if (nSelectors < 1) { retVal = (-4); goto save_state_and_return; };;
1613       for (i = 0; i < nSelectors; i++) {
1614          j = 0;
1615          while (((Bool)1)) {
1616             case 32: s->state = 32; while (((Bool)1)) { if (s->bsLive >= 1) { UInt32 v; v = (s->bsBuff >> (s->bsLive-1)) & ((1 << 1)-1); s->bsLive -= 1; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1617             if (uc == 0) break;
1618             j++;
1619             if (j >= nGroups) { retVal = (-4); goto save_state_and_return; };;
1620          }
1621          s->selectorMtf[i] = j;
1622       }
1623
1624
1625       {
1626          UChar pos[6], tmp, v;
1627          for (v = 0; v < nGroups; v++) pos[v] = v;
1628
1629          for (i = 0; i < nSelectors; i++) {
1630             v = s->selectorMtf[i];
1631             tmp = pos[v];
1632             while (v > 0) { pos[v] = pos[v-1]; v--; }
1633             pos[0] = tmp;
1634             s->selector[i] = tmp;
1635          }
1636       }
1637
1638
1639       for (t = 0; t < nGroups; t++) {
1640          case 33: s->state = 33; while (((Bool)1)) { if (s->bsLive >= 5) { UInt32 v; v = (s->bsBuff >> (s->bsLive-5)) & ((1 << 5)-1); s->bsLive -= 5; curr = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1641          for (i = 0; i < alphaSize; i++) {
1642             while (((Bool)1)) {
1643                if (curr < 1 || curr > 20) { retVal = (-4); goto save_state_and_return; };;
1644                case 34: s->state = 34; while (((Bool)1)) { if (s->bsLive >= 1) { UInt32 v; v = (s->bsBuff >> (s->bsLive-1)) & ((1 << 1)-1); s->bsLive -= 1; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1645                if (uc == 0) break;
1646                case 35: s->state = 35; while (((Bool)1)) { if (s->bsLive >= 1) { UInt32 v; v = (s->bsBuff >> (s->bsLive-1)) & ((1 << 1)-1); s->bsLive -= 1; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1647                if (uc == 0) curr++; else curr--;
1648             }
1649             s->len[t][i] = curr;
1650          }
1651       }
1652
1653
1654       for (t = 0; t < nGroups; t++) {
1655          minLen = 32;
1656          maxLen = 0;
1657          for (i = 0; i < alphaSize; i++) {
1658             if (s->len[t][i] > maxLen) maxLen = s->len[t][i];
1659             if (s->len[t][i] < minLen) minLen = s->len[t][i];
1660          }
1661          BZ2_hbCreateDecodeTables (
1662             &(s->limit[t][0]),
1663             &(s->base[t][0]),
1664             &(s->perm[t][0]),
1665             &(s->len[t][0]),
1666             minLen, maxLen, alphaSize
1667          );
1668          s->minLens[t] = minLen;
1669       }
1670
1671
1672
1673       EOB = s->nInUse+1;
1674       nblockMAX = 100000 * s->blockSize100k;
1675       groupNo = -1;
1676       groupPos = 0;
1677
1678       for (i = 0; i <= 255; i++) s->unzftab[i] = 0;
1679
1680
1681       {
1682          Int32 ii, jj, kk;
1683          kk = 4096 -1;
1684          for (ii = 256 / 16 - 1; ii >= 0; ii--) {
1685             for (jj = 16 -1; jj >= 0; jj--) {
1686                s->mtfa[kk] = (UChar)(ii * 16 + jj);
1687                kk--;
1688             }
1689             s->mtfbase[ii] = kk + 1;
1690          }
1691       }
1692
1693
1694       nblock = 0;
1695       { if (groupPos == 0) { groupNo++; if (groupNo >= nSelectors) { retVal = (-4); goto save_state_and_return; };; groupPos = 50; gSel = s->selector[groupNo]; gMinlen = s->minLens[gSel]; gLimit = &(s->limit[gSel][0]); gPerm = &(s->perm[gSel][0]); gBase = &(s->base[gSel][0]); } groupPos--; zn = gMinlen; case 36: s->state = 36; while (((Bool)1)) { if (s->bsLive >= zn) { UInt32 v; v = (s->bsBuff >> (s->bsLive-zn)) & ((1 << zn)-1); s->bsLive -= zn; zvec = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; }; while (1) { if (zn > 20 ) { retVal = (-4); goto save_state_and_return; };; if (zvec <= gLimit[zn]) break; zn++; case 37: s->state = 37; while (((Bool)1)) { if (s->bsLive >= 1) { UInt32 v; v = (s->bsBuff >> (s->bsLive-1)) & ((1 << 1)-1); s->bsLive -= 1; zj = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; }; zvec = (zvec << 1) | zj; }; if (zvec - gBase[zn] < 0 || zvec - gBase[zn] >= 258) { retVal = (-4); goto save_state_and_return; };; nextSym = gPerm[zvec - gBase[zn]]; };
1696
1697       while (((Bool)1)) {
1698
1699          if (nextSym == EOB) break;
1700
1701          if (nextSym == 0 || nextSym == 1) {
1702
1703             es = -1;
1704             N = 1;
1705             do {
1706                if (nextSym == 0) es = es + (0+1) * N; else
1707                if (nextSym == 1) es = es + (1+1) * N;
1708                N = N * 2;
1709                { if (groupPos == 0) { groupNo++; if (groupNo >= nSelectors) { retVal = (-4); goto save_state_and_return; };; groupPos = 50; gSel = s->selector[groupNo]; gMinlen = s->minLens[gSel]; gLimit = &(s->limit[gSel][0]); gPerm = &(s->perm[gSel][0]); gBase = &(s->base[gSel][0]); } groupPos--; zn = gMinlen; case 38: s->state = 38; while (((Bool)1)) { if (s->bsLive >= zn) { UInt32 v; v = (s->bsBuff >> (s->bsLive-zn)) & ((1 << zn)-1); s->bsLive -= zn; zvec = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; }; while (1) { if (zn > 20 ) { retVal = (-4); goto save_state_and_return; };; if (zvec <= gLimit[zn]) break; zn++; case 39: s->state = 39; while (((Bool)1)) { if (s->bsLive >= 1) { UInt32 v; v = (s->bsBuff >> (s->bsLive-1)) & ((1 << 1)-1); s->bsLive -= 1; zj = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; }; zvec = (zvec << 1) | zj; }; if (zvec - gBase[zn] < 0 || zvec - gBase[zn] >= 258) { retVal = (-4); goto save_state_and_return; };; nextSym = gPerm[zvec - gBase[zn]]; };
1710             }
1711                while (nextSym == 0 || nextSym == 1);
1712
1713             es++;
1714             uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ];
1715             s->unzftab[uc] += es;
1716
1717             if (s->smallDecompress)
1718                while (es > 0) {
1719                   if (nblock >= nblockMAX) { retVal = (-4); goto save_state_and_return; };;
1720                   s->ll16[nblock] = (UInt16)uc;
1721                   nblock++;
1722                   es--;
1723                }
1724             else
1725                while (es > 0) {
1726                   if (nblock >= nblockMAX) { retVal = (-4); goto save_state_and_return; };;
1727                   s->tt[nblock] = (UInt32)uc;
1728                   nblock++;
1729                   es--;
1730                };
1731
1732             continue;
1733
1734          } else {
1735
1736             if (nblock >= nblockMAX) { retVal = (-4); goto save_state_and_return; };;
1737
1738
1739             {
1740                Int32 ii, jj, kk, pp, lno, off;
1741                UInt32 nn;
1742                nn = (UInt32)(nextSym - 1);
1743
1744                if (nn < 16) {
1745
1746                   pp = s->mtfbase[0];
1747                   uc = s->mtfa[pp+nn];
1748                   while (nn > 3) {
1749                      Int32 z = pp+nn;
1750                      s->mtfa[(z) ] = s->mtfa[(z)-1];
1751                      s->mtfa[(z)-1] = s->mtfa[(z)-2];
1752                      s->mtfa[(z)-2] = s->mtfa[(z)-3];
1753                      s->mtfa[(z)-3] = s->mtfa[(z)-4];
1754                      nn -= 4;
1755                   }
1756                   while (nn > 0) {
1757                      s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--;
1758                   };
1759                   s->mtfa[pp] = uc;
1760                } else {
1761
1762                   lno = nn / 16;
1763                   off = nn % 16;
1764                   pp = s->mtfbase[lno] + off;
1765                   uc = s->mtfa[pp];
1766                   while (pp > s->mtfbase[lno]) {
1767                      s->mtfa[pp] = s->mtfa[pp-1]; pp--;
1768                   };
1769                   s->mtfbase[lno]++;
1770                   while (lno > 0) {
1771                      s->mtfbase[lno]--;
1772                      s->mtfa[s->mtfbase[lno]]
1773                         = s->mtfa[s->mtfbase[lno-1] + 16 - 1];
1774                      lno--;
1775                   }
1776                   s->mtfbase[0]--;
1777                   s->mtfa[s->mtfbase[0]] = uc;
1778                   if (s->mtfbase[0] == 0) {
1779                      kk = 4096 -1;
1780                      for (ii = 256 / 16 -1; ii >= 0; ii--) {
1781                         for (jj = 16 -1; jj >= 0; jj--) {
1782                            s->mtfa[kk] = s->mtfa[s->mtfbase[ii] + jj];
1783                            kk--;
1784                         }
1785                         s->mtfbase[ii] = kk + 1;
1786                      }
1787                   }
1788                }
1789             }
1790
1791
1792             s->unzftab[s->seqToUnseq[uc]]++;
1793             if (s->smallDecompress)
1794                s->ll16[nblock] = (UInt16)(s->seqToUnseq[uc]); else
1795                s->tt[nblock] = (UInt32)(s->seqToUnseq[uc]);
1796             nblock++;
1797
1798             { if (groupPos == 0) { groupNo++; if (groupNo >= nSelectors) { retVal = (-4); goto save_state_and_return; };; groupPos = 50; gSel = s->selector[groupNo]; gMinlen = s->minLens[gSel]; gLimit = &(s->limit[gSel][0]); gPerm = &(s->perm[gSel][0]); gBase = &(s->base[gSel][0]); } groupPos--; zn = gMinlen; case 40: s->state = 40; while (((Bool)1)) { if (s->bsLive >= zn) { UInt32 v; v = (s->bsBuff >> (s->bsLive-zn)) & ((1 << zn)-1); s->bsLive -= zn; zvec = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; }; while (1) { if (zn > 20 ) { retVal = (-4); goto save_state_and_return; };; if (zvec <= gLimit[zn]) break; zn++; case 41: s->state = 41; while (((Bool)1)) { if (s->bsLive >= 1) { UInt32 v; v = (s->bsBuff >> (s->bsLive-1)) & ((1 << 1)-1); s->bsLive -= 1; zj = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; }; zvec = (zvec << 1) | zj; }; if (zvec - gBase[zn] < 0 || zvec - gBase[zn] >= 258) { retVal = (-4); goto save_state_and_return; };; nextSym = gPerm[zvec - gBase[zn]]; };
1799             continue;
1800          }
1801       }
1802
1803
1804
1805
1806       if (s->origPtr < 0 || s->origPtr >= nblock)
1807          { retVal = (-4); goto save_state_and_return; };;
1808
1809
1810       s->cftab[0] = 0;
1811       for (i = 1; i <= 256; i++) s->cftab[i] = s->unzftab[i-1];
1812       for (i = 1; i <= 256; i++) s->cftab[i] += s->cftab[i-1];
1813       for (i = 0; i <= 256; i++) {
1814          if (s->cftab[i] < 0 || s->cftab[i] > nblock) {
1815
1816             { retVal = (-4); goto save_state_and_return; };;
1817          }
1818       }
1819
1820       s->state_out_len = 0;
1821       s->state_out_ch = 0;
1822       { s->calculatedBlockCRC = 0xffffffffL; };
1823       s->state = 2;
1824       if (s->verbosity >= 2) vex_printf("rt+rld");
1825
1826       if (s->smallDecompress) {
1827
1828
1829          for (i = 0; i <= 256; i++) s->cftabCopy[i] = s->cftab[i];
1830
1831
1832          for (i = 0; i < nblock; i++) {
1833             uc = (UChar)(s->ll16[i]);
1834             { s->ll16[i] = (UInt16)(s->cftabCopy[uc] & 0x0000ffff); { if (((i) & 0x1) == 0) s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0xf0) | (s->cftabCopy[uc] >> 16); else s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0x0f) | ((s->cftabCopy[uc] >> 16) << 4); }; };
1835             s->cftabCopy[uc]++;
1836          }
1837
1838
1839          i = s->origPtr;
1840          j = (((UInt32)s->ll16[i]) | (((((UInt32)(s->ll4[(i) >> 1])) >> (((i) << 2) & 0x4)) & 0xF) << 16));
1841          do {
1842             Int32 tmp = (((UInt32)s->ll16[j]) | (((((UInt32)(s->ll4[(j) >> 1])) >> (((j) << 2) & 0x4)) & 0xF) << 16));
1843             { s->ll16[j] = (UInt16)(i & 0x0000ffff); { if (((j) & 0x1) == 0) s->ll4[(j) >> 1] = (s->ll4[(j) >> 1] & 0xf0) | (i >> 16); else s->ll4[(j) >> 1] = (s->ll4[(j) >> 1] & 0x0f) | ((i >> 16) << 4); }; };
1844             i = j;
1845             j = tmp;
1846          }
1847             while (i != s->origPtr);
1848
1849          s->tPos = s->origPtr;
1850          s->nblock_used = 0;
1851          if (s->blockRandomised) {
1852             s->rNToGo = 0; s->rTPos = 0;
1853             s->k0 = BZ2_indexIntoF ( s->tPos, s->cftab ); s->tPos = (((UInt32)s->ll16[s->tPos]) | (((((UInt32)(s->ll4[(s->tPos) >> 1])) >> (((s->tPos) << 2) & 0x4)) & 0xF) << 16));; s->nblock_used++;
1854             if (s->rNToGo == 0) { s->rNToGo = BZ2_rNums[s->rTPos]; s->rTPos++; if (s->rTPos == 512) s->rTPos = 0; } s->rNToGo--;; s->k0 ^= ((s->rNToGo == 1) ? 1 : 0);
1855          } else {
1856             s->k0 = BZ2_indexIntoF ( s->tPos, s->cftab ); s->tPos = (((UInt32)s->ll16[s->tPos]) | (((((UInt32)(s->ll4[(s->tPos) >> 1])) >> (((s->tPos) << 2) & 0x4)) & 0xF) << 16));; s->nblock_used++;
1857          }
1858
1859       } else {
1860
1861
1862          for (i = 0; i < nblock; i++) {
1863             uc = (UChar)(s->tt[i] & 0xff);
1864             s->tt[s->cftab[uc]] |= (i << 8);
1865             s->cftab[uc]++;
1866          }
1867
1868          s->tPos = s->tt[s->origPtr] >> 8;
1869          s->nblock_used = 0;
1870          if (s->blockRandomised) {
1871             s->rNToGo = 0; s->rTPos = 0;
1872             s->tPos = s->tt[s->tPos]; s->k0 = (UChar)(s->tPos & 0xff); s->tPos >>= 8;; s->nblock_used++;
1873             if (s->rNToGo == 0) { s->rNToGo = BZ2_rNums[s->rTPos]; s->rTPos++; if (s->rTPos == 512) s->rTPos = 0; } s->rNToGo--;; s->k0 ^= ((s->rNToGo == 1) ? 1 : 0);
1874          } else {
1875             s->tPos = s->tt[s->tPos]; s->k0 = (UChar)(s->tPos & 0xff); s->tPos >>= 8;; s->nblock_used++;
1876          }
1877
1878       }
1879
1880       { retVal = 0; goto save_state_and_return; };;
1881
1882
1883
1884     endhdr_2:
1885
1886       case 42: s->state = 42; while (((Bool)1)) { if (s->bsLive >= 8) { UInt32 v; v = (s->bsBuff >> (s->bsLive-8)) & ((1 << 8)-1); s->bsLive -= 8; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1887       if (uc != 0x72) { retVal = (-4); goto save_state_and_return; };;
1888       case 43: s->state = 43; while (((Bool)1)) { if (s->bsLive >= 8) { UInt32 v; v = (s->bsBuff >> (s->bsLive-8)) & ((1 << 8)-1); s->bsLive -= 8; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1889       if (uc != 0x45) { retVal = (-4); goto save_state_and_return; };;
1890       case 44: s->state = 44; while (((Bool)1)) { if (s->bsLive >= 8) { UInt32 v; v = (s->bsBuff >> (s->bsLive-8)) & ((1 << 8)-1); s->bsLive -= 8; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1891       if (uc != 0x38) { retVal = (-4); goto save_state_and_return; };;
1892       case 45: s->state = 45; while (((Bool)1)) { if (s->bsLive >= 8) { UInt32 v; v = (s->bsBuff >> (s->bsLive-8)) & ((1 << 8)-1); s->bsLive -= 8; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1893       if (uc != 0x50) { retVal = (-4); goto save_state_and_return; };;
1894       case 46: s->state = 46; while (((Bool)1)) { if (s->bsLive >= 8) { UInt32 v; v = (s->bsBuff >> (s->bsLive-8)) & ((1 << 8)-1); s->bsLive -= 8; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1895       if (uc != 0x90) { retVal = (-4); goto save_state_and_return; };;
1896
1897       s->storedCombinedCRC = 0;
1898       case 47: s->state = 47; while (((Bool)1)) { if (s->bsLive >= 8) { UInt32 v; v = (s->bsBuff >> (s->bsLive-8)) & ((1 << 8)-1); s->bsLive -= 8; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1899       s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
1900       case 48: s->state = 48; while (((Bool)1)) { if (s->bsLive >= 8) { UInt32 v; v = (s->bsBuff >> (s->bsLive-8)) & ((1 << 8)-1); s->bsLive -= 8; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1901       s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
1902       case 49: s->state = 49; while (((Bool)1)) { if (s->bsLive >= 8) { UInt32 v; v = (s->bsBuff >> (s->bsLive-8)) & ((1 << 8)-1); s->bsLive -= 8; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1903       s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
1904       case 50: s->state = 50; while (((Bool)1)) { if (s->bsLive >= 8) { UInt32 v; v = (s->bsBuff >> (s->bsLive-8)) & ((1 << 8)-1); s->bsLive -= 8; uc = v; break; } if (s->strm->avail_in == 0) { retVal = 0; goto save_state_and_return; };; s->bsBuff = (s->bsBuff << 8) | ((UInt32) (*((UChar*)(s->strm->next_in)))); s->bsLive += 8; s->strm->next_in++; s->strm->avail_in--; s->strm->total_in_lo32++; if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; };
1905       s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
1906
1907       s->state = 1;
1908       { retVal = 4; goto save_state_and_return; };;
1909
1910       default: { if (!(((Bool)0))) bz_internal_error ( 4001 ); };
1911    }
1912
1913    { if (!(((Bool)0))) bz_internal_error ( 4002 ); };
1914
1915    save_state_and_return:
1916
1917    s->save_i = i;
1918    s->save_j = j;
1919    s->save_t = t;
1920    s->save_alphaSize = alphaSize;
1921    s->save_nGroups = nGroups;
1922    s->save_nSelectors = nSelectors;
1923    s->save_EOB = EOB;
1924    s->save_groupNo = groupNo;
1925    s->save_groupPos = groupPos;
1926    s->save_nextSym = nextSym;
1927    s->save_nblockMAX = nblockMAX;
1928    s->save_nblock = nblock;
1929    s->save_es = es;
1930    s->save_N = N;
1931    s->save_curr = curr;
1932    s->save_zt = zt;
1933    s->save_zn = zn;
1934    s->save_zvec = zvec;
1935    s->save_zj = zj;
1936    s->save_gSel = gSel;
1937    s->save_gMinlen = gMinlen;
1938    s->save_gLimit = gLimit;
1939    s->save_gBase = gBase;
1940    s->save_gPerm = gPerm;
1941
1942    return retVal;
1943 }
1944
1945 static
1946 __inline__
1947 void fallbackSimpleSort ( UInt32* fmap,
1948                           UInt32* eclass,
1949                           Int32 lo,
1950                           Int32 hi )
1951 {
1952    Int32 i, j, tmp;
1953    UInt32 ec_tmp;
1954
1955    if (lo == hi) return;
1956
1957    if (hi - lo > 3) {
1958       for ( i = hi-4; i >= lo; i-- ) {
1959          tmp = fmap[i];
1960          ec_tmp = eclass[tmp];
1961          for ( j = i+4; j <= hi && ec_tmp > eclass[fmap[j]]; j += 4 )
1962             fmap[j-4] = fmap[j];
1963          fmap[j-4] = tmp;
1964       }
1965    }
1966
1967    for ( i = hi-1; i >= lo; i-- ) {
1968       tmp = fmap[i];
1969       ec_tmp = eclass[tmp];
1970       for ( j = i+1; j <= hi && ec_tmp > eclass[fmap[j]]; j++ )
1971          fmap[j-1] = fmap[j];
1972       fmap[j-1] = tmp;
1973    }
1974 }
1975
1976 static
1977 void fallbackQSort3 ( UInt32* fmap,
1978                       UInt32* eclass,
1979                       Int32 loSt,
1980                       Int32 hiSt )
1981 {
1982    Int32 unLo, unHi, ltLo, gtHi, n, m;
1983    Int32 sp, lo, hi;
1984    UInt32 med, r, r3;
1985    Int32 stackLo[100];
1986    Int32 stackHi[100];
1987
1988    r = 0;
1989
1990    sp = 0;
1991    { stackLo[sp] = loSt; stackHi[sp] = hiSt; sp++; };
1992
1993    while (sp > 0) {
1994
1995       { if (!(sp < 100)) bz_internal_error ( 1004 ); };
1996
1997       { sp--; lo = stackLo[sp]; hi = stackHi[sp]; };
1998       if (hi - lo < 10) {
1999          fallbackSimpleSort ( fmap, eclass, lo, hi );
2000          continue;
2001       }
2002
2003       r = ((r * 7621) + 1) % 32768;
2004       r3 = r % 3;
2005       if (r3 == 0) med = eclass[fmap[lo]]; else
2006       if (r3 == 1) med = eclass[fmap[(lo+hi)>>1]]; else
2007                    med = eclass[fmap[hi]];
2008
2009       unLo = ltLo = lo;
2010       unHi = gtHi = hi;
2011
2012       while (1) {
2013          while (1) {
2014             if (unLo > unHi) break;
2015             n = (Int32)eclass[fmap[unLo]] - (Int32)med;
2016             if (n == 0) {
2017                { Int32 zztmp = fmap[unLo]; fmap[unLo] = fmap[ltLo]; fmap[ltLo] = zztmp; };
2018                ltLo++; unLo++;
2019                continue;
2020             };
2021             if (n > 0) break;
2022             unLo++;
2023          }
2024          while (1) {
2025             if (unLo > unHi) break;
2026             n = (Int32)eclass[fmap[unHi]] - (Int32)med;
2027             if (n == 0) {
2028                { Int32 zztmp = fmap[unHi]; fmap[unHi] = fmap[gtHi]; fmap[gtHi] = zztmp; };
2029                gtHi--; unHi--;
2030                continue;
2031             };
2032             if (n < 0) break;
2033             unHi--;
2034          }
2035          if (unLo > unHi) break;
2036          { Int32 zztmp = fmap[unLo]; fmap[unLo] = fmap[unHi]; fmap[unHi] = zztmp; }; unLo++; unHi--;
2037       }
2038
2039       ;
2040
2041       if (gtHi < ltLo) continue;
2042
2043       n = ((ltLo-lo) < (unLo-ltLo)) ? (ltLo-lo) : (unLo-ltLo); { Int32 yyp1 = (lo); Int32 yyp2 = (unLo-n); Int32 yyn = (n); while (yyn > 0) { { Int32 zztmp = fmap[yyp1]; fmap[yyp1] = fmap[yyp2]; fmap[yyp2] = zztmp; }; yyp1++; yyp2++; yyn--; } };
2044       m = ((hi-gtHi) < (gtHi-unHi)) ? (hi-gtHi) : (gtHi-unHi); { Int32 yyp1 = (unLo); Int32 yyp2 = (hi-m+1); Int32 yyn = (m); while (yyn > 0) { { Int32 zztmp = fmap[yyp1]; fmap[yyp1] = fmap[yyp2]; fmap[yyp2] = zztmp; }; yyp1++; yyp2++; yyn--; } };
2045
2046       n = lo + unLo - ltLo - 1;
2047       m = hi - (gtHi - unHi) + 1;
2048
2049       if (n - lo > hi - m) {
2050          { stackLo[sp] = lo; stackHi[sp] = n; sp++; };
2051          { stackLo[sp] = m; stackHi[sp] = hi; sp++; };
2052       } else {
2053          { stackLo[sp] = m; stackHi[sp] = hi; sp++; };
2054          { stackLo[sp] = lo; stackHi[sp] = n; sp++; };
2055       }
2056    }
2057 }
2058
2059 static
2060 void fallbackSort ( UInt32* fmap,
2061                     UInt32* eclass,
2062                     UInt32* bhtab,
2063                     Int32 nblock,
2064                     Int32 verb )
2065 {
2066    Int32 ftab[257];
2067    Int32 ftabCopy[256];
2068    Int32 H, i, j, k, l, r, cc, cc1;
2069    Int32 nNotDone;
2070    Int32 nBhtab;
2071    UChar* eclass8 = (UChar*)eclass;
2072
2073
2074
2075
2076
2077    if (verb >= 4)
2078       vex_printf("        bucket sorting ...\n");
2079    for (i = 0; i < 257; i++) ftab[i] = 0;
2080    for (i = 0; i < nblock; i++) ftab[eclass8[i]]++;
2081    for (i = 0; i < 256; i++) ftabCopy[i] = ftab[i];
2082    for (i = 1; i < 257; i++) ftab[i] += ftab[i-1];
2083
2084    for (i = 0; i < nblock; i++) {
2085       j = eclass8[i];
2086       k = ftab[j] - 1;
2087       ftab[j] = k;
2088       fmap[k] = i;
2089    }
2090
2091    nBhtab = 2 + (nblock / 32);
2092    for (i = 0; i < nBhtab; i++) bhtab[i] = 0;
2093    for (i = 0; i < 256; i++) bhtab[(ftab[i]) >> 5] |= (1 << ((ftab[i]) & 31));
2094
2095    for (i = 0; i < 32; i++) {
2096       bhtab[(nblock + 2*i) >> 5] |= (1 << ((nblock + 2*i) & 31));
2097       bhtab[(nblock + 2*i + 1) >> 5] &= ~(1 << ((nblock + 2*i + 1) & 31));
2098    }
2099
2100
2101    H = 1;
2102    while (1) {
2103
2104       if (verb >= 4)
2105          vex_printf("        depth %6d has ",H);
2106
2107       j = 0;
2108       for (i = 0; i < nblock; i++) {
2109          if ((bhtab[(i) >> 5] & (1 << ((i) & 31)))) j = i;
2110          k = fmap[i] - H; if (k < 0) k += nblock;
2111          eclass[k] = j;
2112       }
2113
2114       nNotDone = 0;
2115       r = -1;
2116       while (1) {
2117
2118
2119          k = r + 1;
2120          while ((bhtab[(k) >> 5] & (1 << ((k) & 31))) && ((k) & 0x01f)) k++;
2121          if ((bhtab[(k) >> 5] & (1 << ((k) & 31)))) {
2122             while (bhtab[(k) >> 5] == 0xffffffff) k += 32;
2123             while ((bhtab[(k) >> 5] & (1 << ((k) & 31)))) k++;
2124          }
2125          l = k - 1;
2126          if (l >= nblock) break;
2127          while (!(bhtab[(k) >> 5] & (1 << ((k) & 31))) && ((k) & 0x01f)) k++;
2128          if (!(bhtab[(k) >> 5] & (1 << ((k) & 31)))) {
2129             while (bhtab[(k) >> 5] == 0x00000000) k += 32;
2130             while (!(bhtab[(k) >> 5] & (1 << ((k) & 31)))) k++;
2131          }
2132          r = k - 1;
2133          if (r >= nblock) break;
2134
2135
2136          if (r > l) {
2137             nNotDone += (r - l + 1);
2138             fallbackQSort3 ( fmap, eclass, l, r );
2139
2140
2141             cc = -1;
2142             for (i = l; i <= r; i++) {
2143                cc1 = eclass[fmap[i]];
2144                if (cc != cc1) { bhtab[(i) >> 5] |= (1 << ((i) & 31)); cc = cc1; };
2145             }
2146          }
2147       }
2148
2149       if (verb >= 4)
2150          vex_printf("%6d unresolved strings\n",nNotDone);
2151
2152       H *= 2;
2153       if (H > nblock || nNotDone == 0) break;
2154    }
2155
2156
2157
2158
2159
2160
2161    if (verb >= 4)
2162       vex_printf("        reconstructing block ...\n");
2163    j = 0;
2164    for (i = 0; i < nblock; i++) {
2165       while (ftabCopy[j] == 0) j++;
2166       ftabCopy[j]--;
2167       eclass8[fmap[i]] = (UChar)j;
2168    }
2169    { if (!(j < 256)) bz_internal_error ( 1005 ); };
2170 }
2171
2172 static
2173 __inline__
2174 Bool mainGtU ( UInt32 i1,
2175                UInt32 i2,
2176                UChar* block,
2177                UInt16* quadrant,
2178                UInt32 nblock,
2179                Int32* budget )
2180 {
2181    Int32 k;
2182    UChar c1, c2;
2183    UInt16 s1, s2;
2184
2185    ;
2186
2187    c1 = block[i1]; c2 = block[i2];
2188    if (c1 != c2) return (c1 > c2);
2189    i1++; i2++;
2190
2191    c1 = block[i1]; c2 = block[i2];
2192    if (c1 != c2) return (c1 > c2);
2193    i1++; i2++;
2194
2195    c1 = block[i1]; c2 = block[i2];
2196    if (c1 != c2) return (c1 > c2);
2197    i1++; i2++;
2198
2199    c1 = block[i1]; c2 = block[i2];
2200    if (c1 != c2) return (c1 > c2);
2201    i1++; i2++;
2202
2203    c1 = block[i1]; c2 = block[i2];
2204    if (c1 != c2) return (c1 > c2);
2205    i1++; i2++;
2206
2207    c1 = block[i1]; c2 = block[i2];
2208    if (c1 != c2) return (c1 > c2);
2209    i1++; i2++;
2210
2211    c1 = block[i1]; c2 = block[i2];
2212    if (c1 != c2) return (c1 > c2);
2213    i1++; i2++;
2214
2215    c1 = block[i1]; c2 = block[i2];
2216    if (c1 != c2) return (c1 > c2);
2217    i1++; i2++;
2218
2219    c1 = block[i1]; c2 = block[i2];
2220    if (c1 != c2) return (c1 > c2);
2221    i1++; i2++;
2222
2223    c1 = block[i1]; c2 = block[i2];
2224    if (c1 != c2) return (c1 > c2);
2225    i1++; i2++;
2226
2227    c1 = block[i1]; c2 = block[i2];
2228    if (c1 != c2) return (c1 > c2);
2229    i1++; i2++;
2230
2231    c1 = block[i1]; c2 = block[i2];
2232    if (c1 != c2) return (c1 > c2);
2233    i1++; i2++;
2234
2235    k = nblock + 8;
2236
2237    do {
2238
2239       c1 = block[i1]; c2 = block[i2];
2240       if (c1 != c2) return (c1 > c2);
2241       s1 = quadrant[i1]; s2 = quadrant[i2];
2242       if (s1 != s2) return (s1 > s2);
2243       i1++; i2++;
2244
2245       c1 = block[i1]; c2 = block[i2];
2246       if (c1 != c2) return (c1 > c2);
2247       s1 = quadrant[i1]; s2 = quadrant[i2];
2248       if (s1 != s2) return (s1 > s2);
2249       i1++; i2++;
2250
2251       c1 = block[i1]; c2 = block[i2];
2252       if (c1 != c2) return (c1 > c2);
2253       s1 = quadrant[i1]; s2 = quadrant[i2];
2254       if (s1 != s2) return (s1 > s2);
2255       i1++; i2++;
2256
2257       c1 = block[i1]; c2 = block[i2];
2258       if (c1 != c2) return (c1 > c2);
2259       s1 = quadrant[i1]; s2 = quadrant[i2];
2260       if (s1 != s2) return (s1 > s2);
2261       i1++; i2++;
2262
2263       c1 = block[i1]; c2 = block[i2];
2264       if (c1 != c2) return (c1 > c2);
2265       s1 = quadrant[i1]; s2 = quadrant[i2];
2266       if (s1 != s2) return (s1 > s2);
2267       i1++; i2++;
2268
2269       c1 = block[i1]; c2 = block[i2];
2270       if (c1 != c2) return (c1 > c2);
2271       s1 = quadrant[i1]; s2 = quadrant[i2];
2272       if (s1 != s2) return (s1 > s2);
2273       i1++; i2++;
2274
2275       c1 = block[i1]; c2 = block[i2];
2276       if (c1 != c2) return (c1 > c2);
2277       s1 = quadrant[i1]; s2 = quadrant[i2];
2278       if (s1 != s2) return (s1 > s2);
2279       i1++; i2++;
2280
2281       c1 = block[i1]; c2 = block[i2];
2282       if (c1 != c2) return (c1 > c2);
2283       s1 = quadrant[i1]; s2 = quadrant[i2];
2284       if (s1 != s2) return (s1 > s2);
2285       i1++; i2++;
2286
2287       if (i1 >= nblock) i1 -= nblock;
2288       if (i2 >= nblock) i2 -= nblock;
2289
2290       k -= 8;
2291       (*budget)--;
2292    }
2293       while (k >= 0);
2294
2295    return ((Bool)0);
2296 }
2297
2298 static
2299 Int32 incs[14] = { 1, 4, 13, 40, 121, 364, 1093, 3280,
2300                    9841, 29524, 88573, 265720,
2301                    797161, 2391484 };
2302
2303 static
2304 void mainSimpleSort ( UInt32* ptr,
2305                       UChar* block,
2306                       UInt16* quadrant,
2307                       Int32 nblock,
2308                       Int32 lo,
2309                       Int32 hi,
2310                       Int32 d,
2311                       Int32* budget )
2312 {
2313    Int32 i, j, h, bigN, hp;
2314    UInt32 v;
2315
2316    bigN = hi - lo + 1;
2317    if (bigN < 2) return;
2318
2319    hp = 0;
2320    while (incs[hp] < bigN) hp++;
2321    hp--;
2322
2323    for (; hp >= 0; hp--) {
2324       h = incs[hp];
2325
2326       i = lo + h;
2327       while (((Bool)1)) {
2328
2329
2330          if (i > hi) break;
2331          v = ptr[i];
2332          j = i;
2333          while ( mainGtU (
2334                     ptr[j-h]+d, v+d, block, quadrant, nblock, budget
2335                  ) ) {
2336             ptr[j] = ptr[j-h];
2337             j = j - h;
2338             if (j <= (lo + h - 1)) break;
2339          }
2340          ptr[j] = v;
2341          i++;
2342
2343
2344          if (i > hi) break;
2345          v = ptr[i];
2346          j = i;
2347          while ( mainGtU (
2348                     ptr[j-h]+d, v+d, block, quadrant, nblock, budget
2349                  ) ) {
2350             ptr[j] = ptr[j-h];
2351             j = j - h;
2352             if (j <= (lo + h - 1)) break;
2353          }
2354          ptr[j] = v;
2355          i++;
2356
2357
2358          if (i > hi) break;
2359          v = ptr[i];
2360          j = i;
2361          while ( mainGtU (
2362                     ptr[j-h]+d, v+d, block, quadrant, nblock, budget
2363                  ) ) {
2364             ptr[j] = ptr[j-h];
2365             j = j - h;
2366             if (j <= (lo + h - 1)) break;
2367          }
2368          ptr[j] = v;
2369          i++;
2370
2371          if (*budget < 0) return;
2372       }
2373    }
2374 }
2375
2376 static
2377 __inline__
2378 UChar mmed3 ( UChar a, UChar b, UChar c )
2379 {
2380    UChar t;
2381    if (a > b) { t = a; a = b; b = t; };
2382    if (b > c) {
2383       b = c;
2384       if (a > b) b = a;
2385    }
2386    return b;
2387 }
2388
2389 static
2390 void mainQSort3 ( UInt32* ptr,
2391                   UChar* block,
2392                   UInt16* quadrant,
2393                   Int32 nblock,
2394                   Int32 loSt,
2395                   Int32 hiSt,
2396                   Int32 dSt,
2397                   Int32* budget )
2398 {
2399    Int32 unLo, unHi, ltLo, gtHi, n, m, med;
2400    Int32 sp, lo, hi, d;
2401
2402    Int32 stackLo[100];
2403    Int32 stackHi[100];
2404    Int32 stackD [100];
2405
2406    Int32 nextLo[3];
2407    Int32 nextHi[3];
2408    Int32 nextD [3];
2409
2410    sp = 0;
2411    { stackLo[sp] = loSt; stackHi[sp] = hiSt; stackD [sp] = dSt; sp++; };
2412
2413    while (sp > 0) {
2414
2415       { if (!(sp < 100)) bz_internal_error ( 1001 ); };
2416
2417       { sp--; lo = stackLo[sp]; hi = stackHi[sp]; d = stackD [sp]; };
2418       if (hi - lo < 20 ||
2419           d > (2 + 12)) {
2420          mainSimpleSort ( ptr, block, quadrant, nblock, lo, hi, d, budget );
2421          if (*budget < 0) return;
2422          continue;
2423       }
2424
2425       med = (Int32)
2426             mmed3 ( block[ptr[ lo ]+d],
2427                     block[ptr[ hi ]+d],
2428                     block[ptr[ (lo+hi)>>1 ]+d] );
2429
2430       unLo = ltLo = lo;
2431       unHi = gtHi = hi;
2432
2433       while (((Bool)1)) {
2434          while (((Bool)1)) {
2435             if (unLo > unHi) break;
2436             n = ((Int32)block[ptr[unLo]+d]) - med;
2437             if (n == 0) {
2438                { Int32 zztmp = ptr[unLo]; ptr[unLo] = ptr[ltLo]; ptr[ltLo] = zztmp; };
2439                ltLo++; unLo++; continue;
2440             };
2441             if (n > 0) break;
2442             unLo++;
2443          }
2444          while (((Bool)1)) {
2445             if (unLo > unHi) break;
2446             n = ((Int32)block[ptr[unHi]+d]) - med;
2447             if (n == 0) {
2448                { Int32 zztmp = ptr[unHi]; ptr[unHi] = ptr[gtHi]; ptr[gtHi] = zztmp; };
2449                gtHi--; unHi--; continue;
2450             };
2451             if (n < 0) break;
2452             unHi--;
2453          }
2454          if (unLo > unHi) break;
2455          { Int32 zztmp = ptr[unLo]; ptr[unLo] = ptr[unHi]; ptr[unHi] = zztmp; }; unLo++; unHi--;
2456       }
2457
2458       ;
2459
2460       if (gtHi < ltLo) {
2461          { stackLo[sp] = lo; stackHi[sp] = hi; stackD [sp] = d+1; sp++; };
2462          continue;
2463       }
2464
2465       n = ((ltLo-lo) < (unLo-ltLo)) ? (ltLo-lo) : (unLo-ltLo); { Int32 yyp1 = (lo); Int32 yyp2 = (unLo-n); Int32 yyn = (n); while (yyn > 0) { { Int32 zztmp = ptr[yyp1]; ptr[yyp1] = ptr[yyp2]; ptr[yyp2] = zztmp; }; yyp1++; yyp2++; yyn--; } };
2466       m = ((hi-gtHi) < (gtHi-unHi)) ? (hi-gtHi) : (gtHi-unHi); { Int32 yyp1 = (unLo); Int32 yyp2 = (hi-m+1); Int32 yyn = (m); while (yyn > 0) { { Int32 zztmp = ptr[yyp1]; ptr[yyp1] = ptr[yyp2]; ptr[yyp2] = zztmp; }; yyp1++; yyp2++; yyn--; } };
2467
2468       n = lo + unLo - ltLo - 1;
2469       m = hi - (gtHi - unHi) + 1;
2470
2471       nextLo[0] = lo; nextHi[0] = n; nextD[0] = d;
2472       nextLo[1] = m; nextHi[1] = hi; nextD[1] = d;
2473       nextLo[2] = n+1; nextHi[2] = m-1; nextD[2] = d+1;
2474
2475       if ((nextHi[0]-nextLo[0]) < (nextHi[1]-nextLo[1])) { Int32 tz; tz = nextLo[0]; nextLo[0] = nextLo[1]; nextLo[1] = tz; tz = nextHi[0]; nextHi[0] = nextHi[1]; nextHi[1] = tz; tz = nextD [0]; nextD [0] = nextD [1]; nextD [1] = tz; };
2476       if ((nextHi[1]-nextLo[1]) < (nextHi[2]-nextLo[2])) { Int32 tz; tz = nextLo[1]; nextLo[1] = nextLo[2]; nextLo[2] = tz; tz = nextHi[1]; nextHi[1] = nextHi[2]; nextHi[2] = tz; tz = nextD [1]; nextD [1] = nextD [2]; nextD [2] = tz; };
2477       if ((nextHi[0]-nextLo[0]) < (nextHi[1]-nextLo[1])) { Int32 tz; tz = nextLo[0]; nextLo[0] = nextLo[1]; nextLo[1] = tz; tz = nextHi[0]; nextHi[0] = nextHi[1]; nextHi[1] = tz; tz = nextD [0]; nextD [0] = nextD [1]; nextD [1] = tz; };
2478
2479       ;
2480       ;
2481
2482       { stackLo[sp] = nextLo[0]; stackHi[sp] = nextHi[0]; stackD [sp] = nextD[0]; sp++; };
2483       { stackLo[sp] = nextLo[1]; stackHi[sp] = nextHi[1]; stackD [sp] = nextD[1]; sp++; };
2484       { stackLo[sp] = nextLo[2]; stackHi[sp] = nextHi[2]; stackD [sp] = nextD[2]; sp++; };
2485    }
2486 }
2487
2488 static
2489 void mainSort ( UInt32* ptr,
2490                 UChar* block,
2491                 UInt16* quadrant,
2492                 UInt32* ftab,
2493                 Int32 nblock,
2494                 Int32 verb,
2495                 Int32* budget )
2496 {
2497    Int32 i, j, k, ss, sb;
2498    Int32 runningOrder[256];
2499    Bool bigDone[256];
2500    Int32 copyStart[256];
2501    Int32 copyEnd [256];
2502    UChar c1;
2503    Int32 numQSorted;
2504    UInt16 s;
2505    if (verb >= 4) vex_printf("        main sort initialise ...\n");
2506
2507
2508    for (i = 65536; i >= 0; i--) ftab[i] = 0;
2509
2510    j = block[0] << 8;
2511    i = nblock-1;
2512    for (; i >= 3; i -= 4) {
2513       quadrant[i] = 0;
2514       j = (j >> 8) | ( ((UInt16)block[i]) << 8);
2515       ftab[j]++;
2516       quadrant[i-1] = 0;
2517       j = (j >> 8) | ( ((UInt16)block[i-1]) << 8);
2518       ftab[j]++;
2519       quadrant[i-2] = 0;
2520       j = (j >> 8) | ( ((UInt16)block[i-2]) << 8);
2521       ftab[j]++;
2522       quadrant[i-3] = 0;
2523       j = (j >> 8) | ( ((UInt16)block[i-3]) << 8);
2524       ftab[j]++;
2525    }
2526    for (; i >= 0; i--) {
2527       quadrant[i] = 0;
2528       j = (j >> 8) | ( ((UInt16)block[i]) << 8);
2529       ftab[j]++;
2530    }
2531
2532
2533    for (i = 0; i < (2 + 12 + 18 + 2); i++) {
2534       block [nblock+i] = block[i];
2535       quadrant[nblock+i] = 0;
2536    }
2537
2538    if (verb >= 4) vex_printf("        bucket sorting ...\n");
2539
2540
2541    for (i = 1; i <= 65536; i++) ftab[i] += ftab[i-1];
2542
2543    s = block[0] << 8;
2544    i = nblock-1;
2545    for (; i >= 3; i -= 4) {
2546       s = (s >> 8) | (block[i] << 8);
2547       j = ftab[s] -1;
2548       ftab[s] = j;
2549       ptr[j] = i;
2550       s = (s >> 8) | (block[i-1] << 8);
2551       j = ftab[s] -1;
2552       ftab[s] = j;
2553       ptr[j] = i-1;
2554       s = (s >> 8) | (block[i-2] << 8);
2555       j = ftab[s] -1;
2556       ftab[s] = j;
2557       ptr[j] = i-2;
2558       s = (s >> 8) | (block[i-3] << 8);
2559       j = ftab[s] -1;
2560       ftab[s] = j;
2561       ptr[j] = i-3;
2562    }
2563    for (; i >= 0; i--) {
2564       s = (s >> 8) | (block[i] << 8);
2565       j = ftab[s] -1;
2566       ftab[s] = j;
2567       ptr[j] = i;
2568    }
2569
2570
2571
2572
2573
2574
2575    for (i = 0; i <= 255; i++) {
2576       bigDone [i] = ((Bool)0);
2577       runningOrder[i] = i;
2578    }
2579
2580    {
2581       Int32 vv;
2582       Int32 h = 1;
2583       do h = 3 * h + 1; while (h <= 256);
2584       do {
2585          h = h / 3;
2586          for (i = h; i <= 255; i++) {
2587             vv = runningOrder[i];
2588             j = i;
2589             while ( (ftab[((runningOrder[j-h])+1) << 8] - ftab[(runningOrder[j-h]) << 8]) > (ftab[((vv)+1) << 8] - ftab[(vv) << 8]) ) {
2590                runningOrder[j] = runningOrder[j-h];
2591                j = j - h;
2592                if (j <= (h - 1)) goto zero;
2593             }
2594             zero:
2595             runningOrder[j] = vv;
2596          }
2597       } while (h != 1);
2598    }
2599
2600
2601
2602
2603
2604    numQSorted = 0;
2605
2606    for (i = 0; i <= 255; i++) {
2607
2608
2609
2610
2611
2612
2613
2614       ss = runningOrder[i];
2615
2616       for (j = 0; j <= 255; j++) {
2617          if (j != ss) {
2618             sb = (ss << 8) + j;
2619             if ( ! (ftab[sb] & (1 << 21)) ) {
2620                Int32 lo = ftab[sb] & (~((1 << 21)));
2621                Int32 hi = (ftab[sb+1] & (~((1 << 21)))) - 1;
2622                if (hi > lo) {
2623                   if (verb >= 4)
2624                      vex_printf("        qsort [0x%x, 0x%x]   " "done %d   this %d\n",ss,j,numQSorted,hi - lo + 1);
2625
2626
2627                   mainQSort3 (
2628                      ptr, block, quadrant, nblock,
2629                      lo, hi, 2, budget
2630                   );
2631                   numQSorted += (hi - lo + 1);
2632                   if (*budget < 0) return;
2633                }
2634             }
2635             ftab[sb] |= (1 << 21);
2636          }
2637       }
2638
2639       { if (!(!bigDone[ss])) bz_internal_error ( 1006 ); };
2640
2641       {
2642          for (j = 0; j <= 255; j++) {
2643             copyStart[j] = ftab[(j << 8) + ss] & (~((1 << 21)));
2644             copyEnd [j] = (ftab[(j << 8) + ss + 1] & (~((1 << 21)))) - 1;
2645          }
2646          for (j = ftab[ss << 8] & (~((1 << 21))); j < copyStart[ss]; j++) {
2647             k = ptr[j]-1; if (k < 0) k += nblock;
2648             c1 = block[k];
2649             if (!bigDone[c1])
2650                ptr[ copyStart[c1]++ ] = k;
2651          }
2652          for (j = (ftab[(ss+1) << 8] & (~((1 << 21)))) - 1; j > copyEnd[ss]; j--) {
2653             k = ptr[j]-1; if (k < 0) k += nblock;
2654             c1 = block[k];
2655             if (!bigDone[c1])
2656                ptr[ copyEnd[c1]-- ] = k;
2657          }
2658       }
2659
2660       { if (!((copyStart[ss]-1 == copyEnd[ss]) || (copyStart[ss] == 0 && copyEnd[ss] == nblock-1))) bz_internal_error ( 1007 ); }
2661
2662       for (j = 0; j <= 255; j++) ftab[(j << 8) + ss] |= (1 << 21);
2663
2664       bigDone[ss] = ((Bool)1);
2665
2666       if (i < 255) {
2667          Int32 bbStart = ftab[ss << 8] & (~((1 << 21)));
2668          Int32 bbSize = (ftab[(ss+1) << 8] & (~((1 << 21)))) - bbStart;
2669          Int32 shifts = 0;
2670
2671          while ((bbSize >> shifts) > 65534) shifts++;
2672
2673          for (j = bbSize-1; j >= 0; j--) {
2674             Int32 a2update = ptr[bbStart + j];
2675             UInt16 qVal = (UInt16)(j >> shifts);
2676             quadrant[a2update] = qVal;
2677             if (a2update < (2 + 12 + 18 + 2))
2678                quadrant[a2update + nblock] = qVal;
2679          }
2680          { if (!(((bbSize-1) >> shifts) <= 65535)) bz_internal_error ( 1002 ); };
2681       }
2682
2683    }
2684
2685    if (verb >= 4)
2686       vex_printf("        %d pointers, %d sorted, %d scanned\n",nblock,numQSorted,nblock - numQSorted);
2687
2688 }
2689
2690 void BZ2_blockSort ( EState* s )
2691 {
2692    UInt32* ptr = s->ptr;
2693    UChar* block = s->block;
2694    UInt32* ftab = s->ftab;
2695    Int32 nblock = s->nblock;
2696    Int32 verb = s->verbosity;
2697    Int32 wfact = s->workFactor;
2698    UInt16* quadrant;
2699    Int32 budget;
2700    Int32 budgetInit;
2701    Int32 i;
2702
2703    if (nblock < 1000 ) {
2704       fallbackSort ( s->arr1, s->arr2, ftab, nblock, verb );
2705    } else {
2706
2707
2708
2709
2710
2711       i = nblock+(2 + 12 + 18 + 2);
2712       if (i & 1) i++;
2713       quadrant = (UInt16*)(&(block[i]));
2714
2715       if (wfact < 1 ) wfact = 1;
2716       if (wfact > 100) wfact = 100;
2717       budgetInit = nblock * ((wfact-1) / 3);
2718       budget = budgetInit;
2719
2720       mainSort ( ptr, block, quadrant, ftab, nblock, verb, &budget );
2721       if (0 && verb >= 3)
2722          vex_printf("      %d work, %d block, ratio %5.2f\n",budgetInit - budget,nblock,(float)(budgetInit - budget) / (float)(nblock==0 ? 1 : nblock));
2723
2724
2725
2726
2727       if (budget < 0) {
2728          if (verb >= 2)
2729             vex_printf("    too repetitive; using fallback" " sorting algorithm\n");
2730
2731          fallbackSort ( s->arr1, s->arr2, ftab, nblock, verb );
2732       }
2733    }
2734
2735    s->origPtr = -1;
2736    for (i = 0; i < s->nblock; i++)
2737       if (ptr[i] == 0)
2738          { s->origPtr = i; break; };
2739
2740    { if (!(s->origPtr != -1)) bz_internal_error ( 1003 ); };
2741 }
2742
2743 void BZ2_hbMakeCodeLengths ( UChar *len,
2744                              Int32 *freq,
2745                              Int32 alphaSize,
2746                              Int32 maxLen )
2747 {
2748
2749
2750
2751
2752    Int32 nNodes, nHeap, n1, n2, i, j, k;
2753    Bool tooLong;
2754
2755    Int32 heap [ 258 + 2 ];
2756    Int32 weight [ 258 * 2 ];
2757    Int32 parent [ 258 * 2 ];
2758
2759    for (i = 0; i < alphaSize; i++)
2760       weight[i+1] = (freq[i] == 0 ? 1 : freq[i]) << 8;
2761
2762    while (((Bool)1)) {
2763
2764       nNodes = alphaSize;
2765       nHeap = 0;
2766
2767       heap[0] = 0;
2768       weight[0] = 0;
2769       parent[0] = -2;
2770
2771       for (i = 1; i <= alphaSize; i++) {
2772          parent[i] = -1;
2773          nHeap++;
2774          heap[nHeap] = i;
2775          { Int32 zz, tmp; zz = nHeap; tmp = heap[zz]; while (weight[tmp] < weight[heap[zz >> 1]]) { heap[zz] = heap[zz >> 1]; zz >>= 1; } heap[zz] = tmp; };
2776       }
2777
2778       { if (!(nHeap < (258 +2))) bz_internal_error ( 2001 ); };
2779
2780       while (nHeap > 1) {
2781          n1 = heap[1]; heap[1] = heap[nHeap]; nHeap--; { Int32 zz, yy, tmp; zz = 1; tmp = heap[zz]; while (((Bool)1)) { yy = zz << 1; if (yy > nHeap) break; if (yy < nHeap && weight[heap[yy+1]] < weight[heap[yy]]) yy++; if (weight[tmp] < weight[heap[yy]]) break; heap[zz] = heap[yy]; zz = yy; } heap[zz] = tmp; };
2782          n2 = heap[1]; heap[1] = heap[nHeap]; nHeap--; { Int32 zz, yy, tmp; zz = 1; tmp = heap[zz]; while (((Bool)1)) { yy = zz << 1; if (yy > nHeap) break; if (yy < nHeap && weight[heap[yy+1]] < weight[heap[yy]]) yy++; if (weight[tmp] < weight[heap[yy]]) break; heap[zz] = heap[yy]; zz = yy; } heap[zz] = tmp; };
2783          nNodes++;
2784          parent[n1] = parent[n2] = nNodes;
2785          weight[nNodes] = (((weight[n1]) & 0xffffff00)+((weight[n2]) & 0xffffff00)) | (1 + ((((weight[n1]) & 0x000000ff)) > (((weight[n2]) & 0x000000ff)) ? (((weight[n1]) & 0x000000ff)) : (((weight[n2]) & 0x000000ff))));
2786          parent[nNodes] = -1;
2787          nHeap++;
2788          heap[nHeap] = nNodes;
2789          { Int32 zz, tmp; zz = nHeap; tmp = heap[zz]; while (weight[tmp] < weight[heap[zz >> 1]]) { heap[zz] = heap[zz >> 1]; zz >>= 1; } heap[zz] = tmp; };
2790       }
2791
2792       { if (!(nNodes < (258 * 2))) bz_internal_error ( 2002 ); };
2793
2794       tooLong = ((Bool)0);
2795       for (i = 1; i <= alphaSize; i++) {
2796          j = 0;
2797          k = i;
2798          while (parent[k] >= 0) { k = parent[k]; j++; }
2799          len[i-1] = j;
2800          if (j > maxLen) tooLong = ((Bool)1);
2801       }
2802
2803       if (! tooLong) break;
2804
2805       for (i = 1; i <= alphaSize; i++) {
2806          j = weight[i] >> 8;
2807          j = 1 + (j / 2);
2808          weight[i] = j << 8;
2809       }
2810    }
2811 }
2812
2813
2814
2815 void BZ2_hbAssignCodes ( Int32 *code,
2816                          UChar *length,
2817                          Int32 minLen,
2818                          Int32 maxLen,
2819                          Int32 alphaSize )
2820 {
2821    Int32 n, vec, i;
2822
2823    vec = 0;
2824    for (n = minLen; n <= maxLen; n++) {
2825       for (i = 0; i < alphaSize; i++)
2826          if (length[i] == n) { code[i] = vec; vec++; };
2827       vec <<= 1;
2828    }
2829 }
2830
2831
2832
2833 void BZ2_hbCreateDecodeTables ( Int32 *limit,
2834                                 Int32 *base,
2835                                 Int32 *perm,
2836                                 UChar *length,
2837                                 Int32 minLen,
2838                                 Int32 maxLen,
2839                                 Int32 alphaSize )
2840 {
2841    Int32 pp, i, j, vec;
2842
2843    pp = 0;
2844    for (i = minLen; i <= maxLen; i++)
2845       for (j = 0; j < alphaSize; j++)
2846          if (length[j] == i) { perm[pp] = j; pp++; };
2847
2848    for (i = 0; i < 23; i++) base[i] = 0;
2849    for (i = 0; i < alphaSize; i++) base[length[i]+1]++;
2850
2851    for (i = 1; i < 23; i++) base[i] += base[i-1];
2852
2853    for (i = 0; i < 23; i++) limit[i] = 0;
2854    vec = 0;
2855
2856    for (i = minLen; i <= maxLen; i++) {
2857       vec += (base[i+1] - base[i]);
2858       limit[i] = vec-1;
2859       vec <<= 1;
2860    }
2861    for (i = minLen + 1; i <= maxLen; i++)
2862       base[i] = ((limit[i-1] + 1) << 1) - base[i];
2863 }
2864
2865 void BZ2_bsInitWrite ( EState* s )
2866 {
2867    s->bsLive = 0;
2868    s->bsBuff = 0;
2869 }
2870
2871
2872
2873 static
2874 void bsFinishWrite ( EState* s )
2875 {
2876    while (s->bsLive > 0) {
2877       s->zbits[s->numZ] = (UChar)(s->bsBuff >> 24);
2878       s->numZ++;
2879       s->bsBuff <<= 8;
2880       s->bsLive -= 8;
2881    }
2882 }
2883
2884 static
2885 __inline__
2886 void bsW ( EState* s, Int32 n, UInt32 v )
2887 {
2888    { while (s->bsLive >= 8) { s->zbits[s->numZ] = (UChar)(s->bsBuff >> 24); s->numZ++; s->bsBuff <<= 8; s->bsLive -= 8; } };
2889    s->bsBuff |= (v << (32 - s->bsLive - n));
2890    s->bsLive += n;
2891 }
2892
2893
2894
2895 static
2896 void bsPutUInt32 ( EState* s, UInt32 u )
2897 {
2898    bsW ( s, 8, (u >> 24) & 0xffL );
2899    bsW ( s, 8, (u >> 16) & 0xffL );
2900    bsW ( s, 8, (u >> 8) & 0xffL );
2901    bsW ( s, 8, u & 0xffL );
2902 }
2903
2904
2905
2906 static
2907 void bsPutUChar ( EState* s, UChar c )
2908 {
2909    bsW( s, 8, (UInt32)c );
2910 }
2911
2912
2913
2914
2915
2916
2917
2918 static
2919 void makeMaps_e ( EState* s )
2920 {
2921    Int32 i;
2922    s->nInUse = 0;
2923    for (i = 0; i < 256; i++)
2924       if (s->inUse[i]) {
2925          s->unseqToSeq[i] = s->nInUse;
2926          s->nInUse++;
2927       }
2928 }
2929
2930
2931
2932 static
2933 void generateMTFValues ( EState* s )
2934 {
2935    UChar yy[256];
2936    Int32 i, j;
2937    Int32 zPend;
2938    Int32 wr;
2939    Int32 EOB;
2940
2941    UInt32* ptr = s->ptr;
2942    UChar* block = s->block;
2943    UInt16* mtfv = s->mtfv;
2944
2945    makeMaps_e ( s );
2946    EOB = s->nInUse+1;
2947
2948    for (i = 0; i <= EOB; i++) s->mtfFreq[i] = 0;
2949
2950    wr = 0;
2951    zPend = 0;
2952    for (i = 0; i < s->nInUse; i++) yy[i] = (UChar) i;
2953
2954    for (i = 0; i < s->nblock; i++) {
2955       UChar ll_i;
2956       ;
2957       j = ptr[i]-1; if (j < 0) j += s->nblock;
2958       ll_i = s->unseqToSeq[block[j]];
2959       ;
2960
2961       if (yy[0] == ll_i) {
2962          zPend++;
2963       } else {
2964
2965          if (zPend > 0) {
2966             zPend--;
2967             while (((Bool)1)) {
2968                if (zPend & 1) {
2969                   mtfv[wr] = 1; wr++;
2970                   s->mtfFreq[1]++;
2971                } else {
2972                   mtfv[wr] = 0; wr++;
2973                   s->mtfFreq[0]++;
2974                }
2975                if (zPend < 2) break;
2976                zPend = (zPend - 2) / 2;
2977             };
2978             zPend = 0;
2979          }
2980          {
2981             register UChar rtmp;
2982             register UChar* ryy_j;
2983             register UChar rll_i;
2984             rtmp = yy[1];
2985             yy[1] = yy[0];
2986             ryy_j = &(yy[1]);
2987             rll_i = ll_i;
2988             while ( rll_i != rtmp ) {
2989                register UChar rtmp2;
2990                ryy_j++;
2991                rtmp2 = rtmp;
2992                rtmp = *ryy_j;
2993                *ryy_j = rtmp2;
2994             };
2995             yy[0] = rtmp;
2996             j = ryy_j - &(yy[0]);
2997             mtfv[wr] = j+1; wr++; s->mtfFreq[j+1]++;
2998          }
2999
3000       }
3001    }
3002
3003    if (zPend > 0) {
3004       zPend--;
3005       while (((Bool)1)) {
3006          if (zPend & 1) {
3007             mtfv[wr] = 1; wr++;
3008             s->mtfFreq[1]++;
3009          } else {
3010             mtfv[wr] = 0; wr++;
3011             s->mtfFreq[0]++;
3012          }
3013          if (zPend < 2) break;
3014          zPend = (zPend - 2) / 2;
3015       };
3016       zPend = 0;
3017    }
3018
3019    mtfv[wr] = EOB; wr++; s->mtfFreq[EOB]++;
3020
3021    s->nMTF = wr;
3022 }
3023
3024
3025
3026
3027
3028
3029 static
3030 void sendMTFValues ( EState* s )
3031 {
3032    Int32 v, t, i, j, gs, ge, totc, bt, bc, iter;
3033    Int32 nSelectors, alphaSize, minLen, maxLen, selCtr;
3034    Int32 nGroups, nBytes;
3035
3036    UInt16 cost[6];
3037    Int32 fave[6];
3038
3039    UInt16* mtfv = s->mtfv;
3040
3041    if (s->verbosity >= 3)
3042       vex_printf("      %d in block, %d after MTF & 1-2 coding, " "%d+2 syms in use\n",s->nblock,s->nMTF,s->nInUse);
3043
3044
3045
3046    alphaSize = s->nInUse+2;
3047    for (t = 0; t < 6; t++)
3048       for (v = 0; v < alphaSize; v++)
3049          s->len[t][v] = 15;
3050
3051
3052    { if (!(s->nMTF > 0)) bz_internal_error ( 3001 ); };
3053    if (s->nMTF < 200) nGroups = 2; else
3054    if (s->nMTF < 600) nGroups = 3; else
3055    if (s->nMTF < 1200) nGroups = 4; else
3056    if (s->nMTF < 2400) nGroups = 5; else
3057                        nGroups = 6;
3058
3059
3060    {
3061       Int32 nPart, remF, tFreq, aFreq;
3062
3063       nPart = nGroups;
3064       remF = s->nMTF;
3065       gs = 0;
3066       while (nPart > 0) {
3067          tFreq = remF / nPart;
3068          ge = gs-1;
3069          aFreq = 0;
3070          while (aFreq < tFreq && ge < alphaSize-1) {
3071             ge++;
3072             aFreq += s->mtfFreq[ge];
3073          }
3074
3075          if (ge > gs
3076              && nPart != nGroups && nPart != 1
3077              && ((nGroups-nPart) % 2 == 1)) {
3078             aFreq -= s->mtfFreq[ge];
3079             ge--;
3080          }
3081
3082          if (0 && s->verbosity >= 3)
3083             vex_printf("      initial group %d, [%d .. %d], " "has %d syms (%4.1f%%)\n",nPart,gs,ge,aFreq,(100.0 * (float)aFreq) / (float)(s->nMTF));
3084
3085
3086
3087
3088          for (v = 0; v < alphaSize; v++)
3089             if (v >= gs && v <= ge)
3090                s->len[nPart-1][v] = 0; else
3091                s->len[nPart-1][v] = 15;
3092
3093          nPart--;
3094          gs = ge+1;
3095          remF -= aFreq;
3096       }
3097    }
3098
3099
3100
3101
3102    for (iter = 0; iter < 4; iter++) {
3103
3104       for (t = 0; t < nGroups; t++) fave[t] = 0;
3105
3106       for (t = 0; t < nGroups; t++)
3107          for (v = 0; v < alphaSize; v++)
3108             s->rfreq[t][v] = 0;
3109
3110
3111
3112
3113
3114       if (nGroups == 6) {
3115          for (v = 0; v < alphaSize; v++) {
3116             s->len_pack[v][0] = (s->len[1][v] << 16) | s->len[0][v];
3117             s->len_pack[v][1] = (s->len[3][v] << 16) | s->len[2][v];
3118             s->len_pack[v][2] = (s->len[5][v] << 16) | s->len[4][v];
3119   }
3120       }
3121
3122       nSelectors = 0;
3123       totc = 0;
3124       gs = 0;
3125       while (((Bool)1)) {
3126
3127
3128          if (gs >= s->nMTF) break;
3129          ge = gs + 50 - 1;
3130          if (ge >= s->nMTF) ge = s->nMTF-1;
3131
3132
3133
3134
3135
3136          for (t = 0; t < nGroups; t++) cost[t] = 0;
3137
3138          if (nGroups == 6 && 50 == ge-gs+1) {
3139
3140             register UInt32 cost01, cost23, cost45;
3141             register UInt16 icv;
3142             cost01 = cost23 = cost45 = 0;
3143
3144
3145
3146
3147
3148
3149
3150             icv = mtfv[gs+(0)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(1)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(2)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(3)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(4)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];;
3151             icv = mtfv[gs+(5)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(6)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(7)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(8)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(9)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];;
3152             icv = mtfv[gs+(10)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(11)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(12)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(13)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(14)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];;
3153             icv = mtfv[gs+(15)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(16)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(17)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(18)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(19)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];;
3154             icv = mtfv[gs+(20)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(21)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(22)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(23)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(24)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];;
3155             icv = mtfv[gs+(25)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(26)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(27)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(28)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(29)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];;
3156             icv = mtfv[gs+(30)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(31)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(32)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(33)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(34)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];;
3157             icv = mtfv[gs+(35)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(36)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(37)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(38)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(39)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];;
3158             icv = mtfv[gs+(40)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(41)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(42)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(43)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(44)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];;
3159             icv = mtfv[gs+(45)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(46)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(47)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(48)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];; icv = mtfv[gs+(49)]; cost01 += s->len_pack[icv][0]; cost23 += s->len_pack[icv][1]; cost45 += s->len_pack[icv][2];;
3160
3161
3162
3163             cost[0] = cost01 & 0xffff; cost[1] = cost01 >> 16;
3164             cost[2] = cost23 & 0xffff; cost[3] = cost23 >> 16;
3165             cost[4] = cost45 & 0xffff; cost[5] = cost45 >> 16;
3166
3167          } else {
3168
3169             for (i = gs; i <= ge; i++) {
3170                UInt16 icv = mtfv[i];
3171                for (t = 0; t < nGroups; t++) cost[t] += s->len[t][icv];
3172             }
3173          }
3174
3175
3176
3177
3178
3179          bc = 999999999; bt = -1;
3180          for (t = 0; t < nGroups; t++)
3181             if (cost[t] < bc) { bc = cost[t]; bt = t; };
3182          totc += bc;
3183          fave[bt]++;
3184          s->selector[nSelectors] = bt;
3185          nSelectors++;
3186
3187
3188
3189
3190          if (nGroups == 6 && 50 == ge-gs+1) {
3191
3192
3193
3194
3195             s->rfreq[bt][ mtfv[gs+(0)] ]++; s->rfreq[bt][ mtfv[gs+(1)] ]++; s->rfreq[bt][ mtfv[gs+(2)] ]++; s->rfreq[bt][ mtfv[gs+(3)] ]++; s->rfreq[bt][ mtfv[gs+(4)] ]++;
3196             s->rfreq[bt][ mtfv[gs+(5)] ]++; s->rfreq[bt][ mtfv[gs+(6)] ]++; s->rfreq[bt][ mtfv[gs+(7)] ]++; s->rfreq[bt][ mtfv[gs+(8)] ]++; s->rfreq[bt][ mtfv[gs+(9)] ]++;
3197             s->rfreq[bt][ mtfv[gs+(10)] ]++; s->rfreq[bt][ mtfv[gs+(11)] ]++; s->rfreq[bt][ mtfv[gs+(12)] ]++; s->rfreq[bt][ mtfv[gs+(13)] ]++; s->rfreq[bt][ mtfv[gs+(14)] ]++;
3198             s->rfreq[bt][ mtfv[gs+(15)] ]++; s->rfreq[bt][ mtfv[gs+(16)] ]++; s->rfreq[bt][ mtfv[gs+(17)] ]++; s->rfreq[bt][ mtfv[gs+(18)] ]++; s->rfreq[bt][ mtfv[gs+(19)] ]++;
3199             s->rfreq[bt][ mtfv[gs+(20)] ]++; s->rfreq[bt][ mtfv[gs+(21)] ]++; s->rfreq[bt][ mtfv[gs+(22)] ]++; s->rfreq[bt][ mtfv[gs+(23)] ]++; s->rfreq[bt][ mtfv[gs+(24)] ]++;
3200             s->rfreq[bt][ mtfv[gs+(25)] ]++; s->rfreq[bt][ mtfv[gs+(26)] ]++; s->rfreq[bt][ mtfv[gs+(27)] ]++; s->rfreq[bt][ mtfv[gs+(28)] ]++; s->rfreq[bt][ mtfv[gs+(29)] ]++;
3201             s->rfreq[bt][ mtfv[gs+(30)] ]++; s->rfreq[bt][ mtfv[gs+(31)] ]++; s->rfreq[bt][ mtfv[gs+(32)] ]++; s->rfreq[bt][ mtfv[gs+(33)] ]++; s->rfreq[bt][ mtfv[gs+(34)] ]++;
3202             s->rfreq[bt][ mtfv[gs+(35)] ]++; s->rfreq[bt][ mtfv[gs+(36)] ]++; s->rfreq[bt][ mtfv[gs+(37)] ]++; s->rfreq[bt][ mtfv[gs+(38)] ]++; s->rfreq[bt][ mtfv[gs+(39)] ]++;
3203             s->rfreq[bt][ mtfv[gs+(40)] ]++; s->rfreq[bt][ mtfv[gs+(41)] ]++; s->rfreq[bt][ mtfv[gs+(42)] ]++; s->rfreq[bt][ mtfv[gs+(43)] ]++; s->rfreq[bt][ mtfv[gs+(44)] ]++;
3204             s->rfreq[bt][ mtfv[gs+(45)] ]++; s->rfreq[bt][ mtfv[gs+(46)] ]++; s->rfreq[bt][ mtfv[gs+(47)] ]++; s->rfreq[bt][ mtfv[gs+(48)] ]++; s->rfreq[bt][ mtfv[gs+(49)] ]++;
3205
3206
3207
3208          } else {
3209
3210             for (i = gs; i <= ge; i++)
3211                s->rfreq[bt][ mtfv[i] ]++;
3212          }
3213
3214          gs = ge+1;
3215       }
3216       if (s->verbosity >= 3) {
3217          vex_printf("      pass %d: size is %d, grp uses are ",iter+1,totc/8);
3218
3219          for (t = 0; t < nGroups; t++)
3220             vex_printf("%d ",fave[t]);
3221          vex_printf("\n");
3222       }
3223
3224
3225
3226
3227
3228
3229       for (t = 0; t < nGroups; t++)
3230          BZ2_hbMakeCodeLengths ( &(s->len[t][0]), &(s->rfreq[t][0]),
3231                                  alphaSize, 17 );
3232    }
3233
3234
3235    { if (!(nGroups < 8)) bz_internal_error ( 3002 ); };
3236    { if (!(nSelectors < 32768 && nSelectors <= (2 + (900000 / 50)))) bz_internal_error ( 3003 ); };
3237
3238
3239
3240
3241
3242    {
3243       UChar pos[6], ll_i, tmp2, tmp;
3244       for (i = 0; i < nGroups; i++) pos[i] = i;
3245       for (i = 0; i < nSelectors; i++) {
3246          ll_i = s->selector[i];
3247          j = 0;
3248          tmp = pos[j];
3249          while ( ll_i != tmp ) {
3250             j++;
3251             tmp2 = tmp;
3252             tmp = pos[j];
3253             pos[j] = tmp2;
3254          };
3255          pos[0] = tmp;
3256          s->selectorMtf[i] = j;
3257       }
3258    };
3259
3260
3261    for (t = 0; t < nGroups; t++) {
3262       minLen = 32;
3263       maxLen = 0;
3264       for (i = 0; i < alphaSize; i++) {
3265          if (s->len[t][i] > maxLen) maxLen = s->len[t][i];
3266          if (s->len[t][i] < minLen) minLen = s->len[t][i];
3267       }
3268       { if (!(!(maxLen > 17 ))) bz_internal_error ( 3004 ); };
3269       { if (!(!(minLen < 1))) bz_internal_error ( 3005 ); };
3270       BZ2_hbAssignCodes ( &(s->code[t][0]), &(s->len[t][0]),
3271                           minLen, maxLen, alphaSize );
3272    }
3273
3274
3275    {
3276       Bool inUse16[16];
3277       for (i = 0; i < 16; i++) {
3278           inUse16[i] = ((Bool)0);
3279           for (j = 0; j < 16; j++)
3280              if (s->inUse[i * 16 + j]) inUse16[i] = ((Bool)1);
3281       }
3282
3283       nBytes = s->numZ;
3284       for (i = 0; i < 16; i++)
3285          if (inUse16[i]) bsW(s,1,1); else bsW(s,1,0);
3286
3287       for (i = 0; i < 16; i++)
3288          if (inUse16[i])
3289             for (j = 0; j < 16; j++) {
3290                if (s->inUse[i * 16 + j]) bsW(s,1,1); else bsW(s,1,0);
3291             }
3292
3293       if (s->verbosity >= 3)
3294          vex_printf("      bytes: mapping %d, ",s->numZ-nBytes);
3295    }
3296
3297
3298    nBytes = s->numZ;
3299    bsW ( s, 3, nGroups );
3300    bsW ( s, 15, nSelectors );
3301    for (i = 0; i < nSelectors; i++) {
3302       for (j = 0; j < s->selectorMtf[i]; j++) bsW(s,1,1);
3303       bsW(s,1,0);
3304    }
3305    if (s->verbosity >= 3)
3306       vex_printf("selectors %d, ",s->numZ-nBytes);
3307
3308
3309    nBytes = s->numZ;
3310
3311    for (t = 0; t < nGroups; t++) {
3312       Int32 curr = s->len[t][0];
3313       bsW ( s, 5, curr );
3314       for (i = 0; i < alphaSize; i++) {
3315          while (curr < s->len[t][i]) { bsW(s,2,2); curr++; };
3316          while (curr > s->len[t][i]) { bsW(s,2,3); curr--; };
3317          bsW ( s, 1, 0 );
3318       }
3319    }
3320
3321    if (s->verbosity >= 3)
3322       vex_printf("code lengths %d, ",s->numZ-nBytes);
3323
3324
3325    nBytes = s->numZ;
3326    selCtr = 0;
3327    gs = 0;
3328    while (((Bool)1)) {
3329       if (gs >= s->nMTF) break;
3330       ge = gs + 50 - 1;
3331       if (ge >= s->nMTF) ge = s->nMTF-1;
3332       { if (!(s->selector[selCtr] < nGroups)) bz_internal_error ( 3006 ); };
3333
3334       if (nGroups == 6 && 50 == ge-gs+1) {
3335
3336             UInt16 mtfv_i;
3337             UChar* s_len_sel_selCtr
3338                = &(s->len[s->selector[selCtr]][0]);
3339             Int32* s_code_sel_selCtr
3340                = &(s->code[s->selector[selCtr]][0]);
3341
3342
3343
3344
3345
3346
3347
3348             mtfv_i = mtfv[gs+(0)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(1)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(2)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(3)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(4)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] );
3349             mtfv_i = mtfv[gs+(5)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(6)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(7)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(8)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(9)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] );
3350             mtfv_i = mtfv[gs+(10)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(11)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(12)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(13)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(14)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] );
3351             mtfv_i = mtfv[gs+(15)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(16)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(17)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(18)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(19)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] );
3352             mtfv_i = mtfv[gs+(20)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(21)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(22)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(23)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(24)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] );
3353             mtfv_i = mtfv[gs+(25)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(26)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(27)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(28)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(29)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] );
3354             mtfv_i = mtfv[gs+(30)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(31)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(32)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(33)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(34)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] );
3355             mtfv_i = mtfv[gs+(35)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(36)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(37)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(38)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(39)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] );
3356             mtfv_i = mtfv[gs+(40)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(41)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(42)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(43)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(44)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] );
3357             mtfv_i = mtfv[gs+(45)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(46)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(47)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(48)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] ); mtfv_i = mtfv[gs+(49)]; bsW ( s, s_len_sel_selCtr[mtfv_i], s_code_sel_selCtr[mtfv_i] );
3358
3359
3360
3361       } else {
3362
3363          for (i = gs; i <= ge; i++) {
3364             bsW ( s,
3365                   s->len [s->selector[selCtr]] [mtfv[i]],
3366                   s->code [s->selector[selCtr]] [mtfv[i]] );
3367          }
3368       }
3369
3370
3371       gs = ge+1;
3372       selCtr++;
3373    }
3374    { if (!(selCtr == nSelectors)) bz_internal_error ( 3007 ); };
3375
3376    if (s->verbosity >= 3)
3377       vex_printf("codes %d\n",s->numZ-nBytes);
3378 }
3379
3380
3381
3382 void BZ2_compressBlock ( EState* s, Bool is_last_block )
3383 {
3384    if (s->nblock > 0) {
3385
3386       { s->blockCRC = ~(s->blockCRC); };
3387       s->combinedCRC = (s->combinedCRC << 1) | (s->combinedCRC >> 31);
3388       s->combinedCRC ^= s->blockCRC;
3389       if (s->blockNo > 1) s->numZ = 0;
3390
3391       if (s->verbosity >= 2)
3392          vex_printf("    block %d: crc = 0x%08x, " "combined CRC = 0x%08x, size = %d\n",s->blockNo,s->blockCRC,s->combinedCRC,s->nblock);
3393
3394
3395
3396       BZ2_blockSort ( s );
3397    }
3398
3399    s->zbits = (UChar*) (&((UChar*)s->arr2)[s->nblock]);
3400
3401
3402    if (s->blockNo == 1) {
3403       BZ2_bsInitWrite ( s );
3404       bsPutUChar ( s, 0x42 );
3405       bsPutUChar ( s, 0x5a );
3406       bsPutUChar ( s, 0x68 );
3407       bsPutUChar ( s, (UChar)(0x30 + s->blockSize100k) );
3408    }
3409
3410    if (s->nblock > 0) {
3411
3412       bsPutUChar ( s, 0x31 ); bsPutUChar ( s, 0x41 );
3413       bsPutUChar ( s, 0x59 ); bsPutUChar ( s, 0x26 );
3414       bsPutUChar ( s, 0x53 ); bsPutUChar ( s, 0x59 );
3415
3416
3417       bsPutUInt32 ( s, s->blockCRC );
3418
3419       bsW(s,1,0);
3420
3421       bsW ( s, 24, s->origPtr );
3422       generateMTFValues ( s );
3423       sendMTFValues ( s );
3424    }
3425
3426
3427
3428    if (is_last_block) {
3429
3430       bsPutUChar ( s, 0x17 ); bsPutUChar ( s, 0x72 );
3431       bsPutUChar ( s, 0x45 ); bsPutUChar ( s, 0x38 );
3432       bsPutUChar ( s, 0x50 ); bsPutUChar ( s, 0x90 );
3433       bsPutUInt32 ( s, s->combinedCRC );
3434       if (s->verbosity >= 2)
3435          vex_printf("    final combined CRC = 0x%08x\n   ",s->combinedCRC);
3436       bsFinishWrite ( s );
3437    }
3438 }
3439
3440 Int32 BZ2_rNums[512] = {
3441    619, 720, 127, 481, 931, 816, 813, 233, 566, 247,
3442    985, 724, 205, 454, 863, 491, 741, 242, 949, 214,
3443    733, 859, 335, 708, 621, 574, 73, 654, 730, 472,
3444    419, 436, 278, 496, 867, 210, 399, 680, 480, 51,
3445    878, 465, 811, 169, 869, 675, 611, 697, 867, 561,
3446    862, 687, 507, 283, 482, 129, 807, 591, 733, 623,
3447    150, 238, 59, 379, 684, 877, 625, 169, 643, 105,
3448    170, 607, 520, 932, 727, 476, 693, 425, 174, 647,
3449    73, 122, 335, 530, 442, 853, 695, 249, 445, 515,
3450    909, 545, 703, 919, 874, 474, 882, 500, 594, 612,
3451    641, 801, 220, 162, 819, 984, 589, 513, 495, 799,
3452    161, 604, 958, 533, 221, 400, 386, 867, 600, 782,
3453    382, 596, 414, 171, 516, 375, 682, 485, 911, 276,
3454    98, 553, 163, 354, 666, 933, 424, 341, 533, 870,
3455    227, 730, 475, 186, 263, 647, 537, 686, 600, 224,
3456    469, 68, 770, 919, 190, 373, 294, 822, 808, 206,
3457    184, 943, 795, 384, 383, 461, 404, 758, 839, 887,
3458    715, 67, 618, 276, 204, 918, 873, 777, 604, 560,
3459    951, 160, 578, 722, 79, 804, 96, 409, 713, 940,
3460    652, 934, 970, 447, 318, 353, 859, 672, 112, 785,
3461    645, 863, 803, 350, 139, 93, 354, 99, 820, 908,
3462    609, 772, 154, 274, 580, 184, 79, 626, 630, 742,
3463    653, 282, 762, 623, 680, 81, 927, 626, 789, 125,
3464    411, 521, 938, 300, 821, 78, 343, 175, 128, 250,
3465    170, 774, 972, 275, 999, 639, 495, 78, 352, 126,
3466    857, 956, 358, 619, 580, 124, 737, 594, 701, 612,
3467    669, 112, 134, 694, 363, 992, 809, 743, 168, 974,
3468    944, 375, 748, 52, 600, 747, 642, 182, 862, 81,
3469    344, 805, 988, 739, 511, 655, 814, 334, 249, 515,
3470    897, 955, 664, 981, 649, 113, 974, 459, 893, 228,
3471    433, 837, 553, 268, 926, 240, 102, 654, 459, 51,
3472    686, 754, 806, 760, 493, 403, 415, 394, 687, 700,
3473    946, 670, 656, 610, 738, 392, 760, 799, 887, 653,
3474    978, 321, 576, 617, 626, 502, 894, 679, 243, 440,
3475    680, 879, 194, 572, 640, 724, 926, 56, 204, 700,
3476    707, 151, 457, 449, 797, 195, 791, 558, 945, 679,
3477    297, 59, 87, 824, 713, 663, 412, 693, 342, 606,
3478    134, 108, 571, 364, 631, 212, 174, 643, 304, 329,
3479    343, 97, 430, 751, 497, 314, 983, 374, 822, 928,
3480    140, 206, 73, 263, 980, 736, 876, 478, 430, 305,
3481    170, 514, 364, 692, 829, 82, 855, 953, 676, 246,
3482    369, 970, 294, 750, 807, 827, 150, 790, 288, 923,
3483    804, 378, 215, 828, 592, 281, 565, 555, 710, 82,
3484    896, 831, 547, 261, 524, 462, 293, 465, 502, 56,
3485    661, 821, 976, 991, 658, 869, 905, 758, 745, 193,
3486    768, 550, 608, 933, 378, 286, 215, 979, 792, 961,
3487    61, 688, 793, 644, 986, 403, 106, 366, 905, 644,
3488    372, 567, 466, 434, 645, 210, 389, 550, 919, 135,
3489    780, 773, 635, 389, 707, 100, 626, 958, 165, 504,
3490    920, 176, 193, 713, 857, 265, 203, 50, 668, 108,
3491    645, 990, 626, 197, 510, 357, 358, 850, 858, 364,
3492    936, 638
3493 };
3494
3495 UInt32 BZ2_crc32Table[256] = {
3496
3497
3498
3499    0x00000000L, 0x04c11db7L, 0x09823b6eL, 0x0d4326d9L,
3500    0x130476dcL, 0x17c56b6bL, 0x1a864db2L, 0x1e475005L,
3501    0x2608edb8L, 0x22c9f00fL, 0x2f8ad6d6L, 0x2b4bcb61L,
3502    0x350c9b64L, 0x31cd86d3L, 0x3c8ea00aL, 0x384fbdbdL,
3503    0x4c11db70L, 0x48d0c6c7L, 0x4593e01eL, 0x4152fda9L,
3504    0x5f15adacL, 0x5bd4b01bL, 0x569796c2L, 0x52568b75L,
3505    0x6a1936c8L, 0x6ed82b7fL, 0x639b0da6L, 0x675a1011L,
3506    0x791d4014L, 0x7ddc5da3L, 0x709f7b7aL, 0x745e66cdL,
3507    0x9823b6e0L, 0x9ce2ab57L, 0x91a18d8eL, 0x95609039L,
3508    0x8b27c03cL, 0x8fe6dd8bL, 0x82a5fb52L, 0x8664e6e5L,
3509    0xbe2b5b58L, 0xbaea46efL, 0xb7a96036L, 0xb3687d81L,
3510    0xad2f2d84L, 0xa9ee3033L, 0xa4ad16eaL, 0xa06c0b5dL,
3511    0xd4326d90L, 0xd0f37027L, 0xddb056feL, 0xd9714b49L,
3512    0xc7361b4cL, 0xc3f706fbL, 0xceb42022L, 0xca753d95L,
3513    0xf23a8028L, 0xf6fb9d9fL, 0xfbb8bb46L, 0xff79a6f1L,
3514    0xe13ef6f4L, 0xe5ffeb43L, 0xe8bccd9aL, 0xec7dd02dL,
3515    0x34867077L, 0x30476dc0L, 0x3d044b19L, 0x39c556aeL,
3516    0x278206abL, 0x23431b1cL, 0x2e003dc5L, 0x2ac12072L,
3517    0x128e9dcfL, 0x164f8078L, 0x1b0ca6a1L, 0x1fcdbb16L,
3518    0x018aeb13L, 0x054bf6a4L, 0x0808d07dL, 0x0cc9cdcaL,
3519    0x7897ab07L, 0x7c56b6b0L, 0x71159069L, 0x75d48ddeL,
3520    0x6b93dddbL, 0x6f52c06cL, 0x6211e6b5L, 0x66d0fb02L,
3521    0x5e9f46bfL, 0x5a5e5b08L, 0x571d7dd1L, 0x53dc6066L,
3522    0x4d9b3063L, 0x495a2dd4L, 0x44190b0dL, 0x40d816baL,
3523    0xaca5c697L, 0xa864db20L, 0xa527fdf9L, 0xa1e6e04eL,
3524    0xbfa1b04bL, 0xbb60adfcL, 0xb6238b25L, 0xb2e29692L,
3525    0x8aad2b2fL, 0x8e6c3698L, 0x832f1041L, 0x87ee0df6L,
3526    0x99a95df3L, 0x9d684044L, 0x902b669dL, 0x94ea7b2aL,
3527    0xe0b41de7L, 0xe4750050L, 0xe9362689L, 0xedf73b3eL,
3528    0xf3b06b3bL, 0xf771768cL, 0xfa325055L, 0xfef34de2L,
3529    0xc6bcf05fL, 0xc27dede8L, 0xcf3ecb31L, 0xcbffd686L,
3530    0xd5b88683L, 0xd1799b34L, 0xdc3abdedL, 0xd8fba05aL,
3531    0x690ce0eeL, 0x6dcdfd59L, 0x608edb80L, 0x644fc637L,
3532    0x7a089632L, 0x7ec98b85L, 0x738aad5cL, 0x774bb0ebL,
3533    0x4f040d56L, 0x4bc510e1L, 0x46863638L, 0x42472b8fL,
3534    0x5c007b8aL, 0x58c1663dL, 0x558240e4L, 0x51435d53L,
3535    0x251d3b9eL, 0x21dc2629L, 0x2c9f00f0L, 0x285e1d47L,
3536    0x36194d42L, 0x32d850f5L, 0x3f9b762cL, 0x3b5a6b9bL,
3537    0x0315d626L, 0x07d4cb91L, 0x0a97ed48L, 0x0e56f0ffL,
3538    0x1011a0faL, 0x14d0bd4dL, 0x19939b94L, 0x1d528623L,
3539    0xf12f560eL, 0xf5ee4bb9L, 0xf8ad6d60L, 0xfc6c70d7L,
3540    0xe22b20d2L, 0xe6ea3d65L, 0xeba91bbcL, 0xef68060bL,
3541    0xd727bbb6L, 0xd3e6a601L, 0xdea580d8L, 0xda649d6fL,
3542    0xc423cd6aL, 0xc0e2d0ddL, 0xcda1f604L, 0xc960ebb3L,
3543    0xbd3e8d7eL, 0xb9ff90c9L, 0xb4bcb610L, 0xb07daba7L,
3544    0xae3afba2L, 0xaafbe615L, 0xa7b8c0ccL, 0xa379dd7bL,
3545    0x9b3660c6L, 0x9ff77d71L, 0x92b45ba8L, 0x9675461fL,
3546    0x8832161aL, 0x8cf30badL, 0x81b02d74L, 0x857130c3L,
3547    0x5d8a9099L, 0x594b8d2eL, 0x5408abf7L, 0x50c9b640L,
3548    0x4e8ee645L, 0x4a4ffbf2L, 0x470cdd2bL, 0x43cdc09cL,
3549    0x7b827d21L, 0x7f436096L, 0x7200464fL, 0x76c15bf8L,
3550    0x68860bfdL, 0x6c47164aL, 0x61043093L, 0x65c52d24L,
3551    0x119b4be9L, 0x155a565eL, 0x18197087L, 0x1cd86d30L,
3552    0x029f3d35L, 0x065e2082L, 0x0b1d065bL, 0x0fdc1becL,
3553    0x3793a651L, 0x3352bbe6L, 0x3e119d3fL, 0x3ad08088L,
3554    0x2497d08dL, 0x2056cd3aL, 0x2d15ebe3L, 0x29d4f654L,
3555    0xc5a92679L, 0xc1683bceL, 0xcc2b1d17L, 0xc8ea00a0L,
3556    0xd6ad50a5L, 0xd26c4d12L, 0xdf2f6bcbL, 0xdbee767cL,
3557    0xe3a1cbc1L, 0xe760d676L, 0xea23f0afL, 0xeee2ed18L,
3558    0xf0a5bd1dL, 0xf464a0aaL, 0xf9278673L, 0xfde69bc4L,
3559    0x89b8fd09L, 0x8d79e0beL, 0x803ac667L, 0x84fbdbd0L,
3560    0x9abc8bd5L, 0x9e7d9662L, 0x933eb0bbL, 0x97ffad0cL,
3561    0xafb010b1L, 0xab710d06L, 0xa6322bdfL, 0xa2f33668L,
3562    0xbcb4666dL, 0xb8757bdaL, 0xb5365d03L, 0xb1f740b4L
3563 };
3564
3565 void BZ2_bz__AssertH__fail ( int errcode )
3566 {
3567    vex_printf("BZ2_bz__AssertH__fail(%d) called, exiting\n", errcode);
3568    (*serviceFn)(0,0);
3569 }
3570
3571 void bz_internal_error ( int errcode )
3572 {
3573    vex_printf("bz_internal_error called, exiting\n", errcode);
3574    (*serviceFn)(0,0);
3575 }
3576
3577
3578 static
3579 int bz_config_ok ( void )
3580 {
3581    if (sizeof(int) != 4) return 0;
3582    if (sizeof(short) != 2) return 0;
3583    if (sizeof(char) != 1) return 0;
3584    return 1;
3585 }
3586
3587
3588
3589 static
3590 void* default_bzalloc ( void* opaque, Int32 items, Int32 size )
3591 {
3592    void* v = (void*) (*serviceFn)(2, items * size );
3593    return v;
3594 }
3595
3596 static
3597 void default_bzfree ( void* opaque, void* addr )
3598 {
3599    if (addr != ((void *)0)) (*serviceFn)( 3, (HWord)addr );
3600 }
3601
3602
3603
3604 static
3605 void prepare_new_block ( EState* s )
3606 {
3607    Int32 i;
3608    s->nblock = 0;
3609    s->numZ = 0;
3610    s->state_out_pos = 0;
3611    { s->blockCRC = 0xffffffffL; };
3612    for (i = 0; i < 256; i++) s->inUse[i] = ((Bool)0);
3613    s->blockNo++;
3614 }
3615
3616
3617
3618 static
3619 void init_RL ( EState* s )
3620 {
3621    s->state_in_ch = 256;
3622    s->state_in_len = 0;
3623 }
3624
3625
3626 static
3627 Bool isempty_RL ( EState* s )
3628 {
3629    if (s->state_in_ch < 256 && s->state_in_len > 0)
3630       return ((Bool)0); else
3631       return ((Bool)1);
3632 }
3633
3634
3635
3636 int BZ2_bzCompressInit
3637                     ( bz_stream* strm,
3638                      int blockSize100k,
3639                      int verbosity,
3640                      int workFactor )
3641 {
3642    Int32 n;
3643    EState* s;
3644
3645    if (!bz_config_ok()) return (-9);
3646
3647    if (strm == ((void *)0) ||
3648        blockSize100k < 1 || blockSize100k > 9 ||
3649        workFactor < 0 || workFactor > 250)
3650      return (-2);
3651
3652    if (workFactor == 0) workFactor = 30;
3653    if (strm->bzalloc == ((void *)0)) strm->bzalloc = default_bzalloc;
3654    if (strm->bzfree == ((void *)0)) strm->bzfree = default_bzfree;
3655
3656    s = (strm->bzalloc)(strm->opaque,(sizeof(EState)),1);
3657    if (s == ((void *)0)) return (-3);
3658    s->strm = strm;
3659
3660    s->arr1 = ((void *)0);
3661    s->arr2 = ((void *)0);
3662    s->ftab = ((void *)0);
3663
3664    n = 100000 * blockSize100k;
3665    s->arr1 = (strm->bzalloc)(strm->opaque,(n * sizeof(UInt32)),1);
3666    s->arr2 = (strm->bzalloc)(strm->opaque,((n+(2 + 12 + 18 + 2)) * sizeof(UInt32)),1);
3667    s->ftab = (strm->bzalloc)(strm->opaque,(65537 * sizeof(UInt32)),1);
3668
3669    if (s->arr1 == ((void *)0) || s->arr2 == ((void *)0) || s->ftab == ((void *)0)) {
3670       if (s->arr1 != ((void *)0)) (strm->bzfree)(strm->opaque,(s->arr1));
3671       if (s->arr2 != ((void *)0)) (strm->bzfree)(strm->opaque,(s->arr2));
3672       if (s->ftab != ((void *)0)) (strm->bzfree)(strm->opaque,(s->ftab));
3673       if (s != ((void *)0)) (strm->bzfree)(strm->opaque,(s));
3674       return (-3);
3675    }
3676
3677    s->blockNo = 0;
3678    s->state = 2;
3679    s->mode = 2;
3680    s->combinedCRC = 0;
3681    s->blockSize100k = blockSize100k;
3682    s->nblockMAX = 100000 * blockSize100k - 19;
3683    s->verbosity = verbosity;
3684    s->workFactor = workFactor;
3685
3686    s->block = (UChar*)s->arr2;
3687    s->mtfv = (UInt16*)s->arr1;
3688    s->zbits = ((void *)0);
3689    s->ptr = (UInt32*)s->arr1;
3690
3691    strm->state = s;
3692    strm->total_in_lo32 = 0;
3693    strm->total_in_hi32 = 0;
3694    strm->total_out_lo32 = 0;
3695    strm->total_out_hi32 = 0;
3696    init_RL ( s );
3697    prepare_new_block ( s );
3698    return 0;
3699 }
3700
3701
3702
3703 static
3704 void add_pair_to_block ( EState* s )
3705 {
3706    Int32 i;
3707    UChar ch = (UChar)(s->state_in_ch);
3708    for (i = 0; i < s->state_in_len; i++) {
3709       { s->blockCRC = (s->blockCRC << 8) ^ BZ2_crc32Table[(s->blockCRC >> 24) ^ ((UChar)ch)]; };
3710    }
3711    s->inUse[s->state_in_ch] = ((Bool)1);
3712    switch (s->state_in_len) {
3713       case 1:
3714          s->block[s->nblock] = (UChar)ch; s->nblock++;
3715          break;
3716       case 2:
3717          s->block[s->nblock] = (UChar)ch; s->nblock++;
3718          s->block[s->nblock] = (UChar)ch; s->nblock++;
3719          break;
3720       case 3:
3721          s->block[s->nblock] = (UChar)ch; s->nblock++;
3722          s->block[s->nblock] = (UChar)ch; s->nblock++;
3723          s->block[s->nblock] = (UChar)ch; s->nblock++;
3724          break;
3725       default:
3726          s->inUse[s->state_in_len-4] = ((Bool)1);
3727          s->block[s->nblock] = (UChar)ch; s->nblock++;
3728          s->block[s->nblock] = (UChar)ch; s->nblock++;
3729          s->block[s->nblock] = (UChar)ch; s->nblock++;
3730          s->block[s->nblock] = (UChar)ch; s->nblock++;
3731          s->block[s->nblock] = ((UChar)(s->state_in_len-4));
3732          s->nblock++;
3733          break;
3734    }
3735 }
3736
3737
3738
3739 static
3740 void flush_RL ( EState* s )
3741 {
3742    if (s->state_in_ch < 256) add_pair_to_block ( s );
3743    init_RL ( s );
3744 }
3745
3746 static
3747 Bool copy_input_until_stop ( EState* s )
3748 {
3749    Bool progress_in = ((Bool)0);
3750
3751    if (s->mode == 2) {
3752
3753
3754       while (((Bool)1)) {
3755
3756          if (s->nblock >= s->nblockMAX) break;
3757
3758          if (s->strm->avail_in == 0) break;
3759          progress_in = ((Bool)1);
3760          { UInt32 zchh = (UInt32)((UInt32)(*((UChar*)(s->strm->next_in)))); if (zchh != s->state_in_ch && s->state_in_len == 1) { UChar ch = (UChar)(s->state_in_ch); { s->blockCRC = (s->blockCRC << 8) ^ BZ2_crc32Table[(s->blockCRC >> 24) ^ ((UChar)ch)]; }; s->inUse[s->state_in_ch] = ((Bool)1); s->block[s->nblock] = (UChar)ch; s->nblock++; s->state_in_ch = zchh; } else if (zchh != s->state_in_ch || s->state_in_len == 255) { if (s->state_in_ch < 256) add_pair_to_block ( s ); s->state_in_ch = zchh; s->state_in_len = 1; } else { s->state_in_len++; } };
3761          s->strm->next_in++;
3762          s->strm->avail_in--;
3763          s->strm->total_in_lo32++;
3764          if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++;
3765       }
3766
3767    } else {
3768
3769
3770       while (((Bool)1)) {
3771
3772          if (s->nblock >= s->nblockMAX) break;
3773
3774          if (s->strm->avail_in == 0) break;
3775
3776          if (s->avail_in_expect == 0) break;
3777          progress_in = ((Bool)1);
3778          { UInt32 zchh = (UInt32)((UInt32)(*((UChar*)(s->strm->next_in)))); if (zchh != s->state_in_ch && s->state_in_len == 1) { UChar ch = (UChar)(s->state_in_ch); { s->blockCRC = (s->blockCRC << 8) ^ BZ2_crc32Table[(s->blockCRC >> 24) ^ ((UChar)ch)]; }; s->inUse[s->state_in_ch] = ((Bool)1); s->block[s->nblock] = (UChar)ch; s->nblock++; s->state_in_ch = zchh; } else if (zchh != s->state_in_ch || s->state_in_len == 255) { if (s->state_in_ch < 256) add_pair_to_block ( s ); s->state_in_ch = zchh; s->state_in_len = 1; } else { s->state_in_len++; } };
3779          s->strm->next_in++;
3780          s->strm->avail_in--;
3781          s->strm->total_in_lo32++;
3782          if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++;
3783          s->avail_in_expect--;
3784       }
3785    }
3786    return progress_in;
3787 }
3788
3789
3790
3791 static
3792 Bool copy_output_until_stop ( EState* s )
3793 {
3794    Bool progress_out = ((Bool)0);
3795
3796    while (((Bool)1)) {
3797
3798
3799       if (s->strm->avail_out == 0) break;
3800
3801
3802       if (s->state_out_pos >= s->numZ) break;
3803
3804       progress_out = ((Bool)1);
3805       *(s->strm->next_out) = s->zbits[s->state_out_pos];
3806       s->state_out_pos++;
3807       s->strm->avail_out--;
3808       s->strm->next_out++;
3809       s->strm->total_out_lo32++;
3810       if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
3811    }
3812
3813    return progress_out;
3814 }
3815
3816
3817
3818 static
3819 Bool handle_compress ( bz_stream* strm )
3820 {
3821    Bool progress_in = ((Bool)0);
3822    Bool progress_out = ((Bool)0);
3823    EState* s = strm->state;
3824
3825    while (((Bool)1)) {
3826
3827       if (s->state == 1) {
3828          progress_out |= copy_output_until_stop ( s );
3829          if (s->state_out_pos < s->numZ) break;
3830          if (s->mode == 4 &&
3831              s->avail_in_expect == 0 &&
3832              isempty_RL(s)) break;
3833          prepare_new_block ( s );
3834          s->state = 2;
3835          if (s->mode == 3 &&
3836              s->avail_in_expect == 0 &&
3837              isempty_RL(s)) break;
3838       }
3839
3840       if (s->state == 2) {
3841          progress_in |= copy_input_until_stop ( s );
3842          if (s->mode != 2 && s->avail_in_expect == 0) {
3843             flush_RL ( s );
3844             BZ2_compressBlock ( s, (Bool)(s->mode == 4) );
3845             s->state = 1;
3846          }
3847          else
3848          if (s->nblock >= s->nblockMAX) {
3849             BZ2_compressBlock ( s, ((Bool)0) );
3850             s->state = 1;
3851          }
3852          else
3853          if (s->strm->avail_in == 0) {
3854             break;
3855          }
3856       }
3857
3858    }
3859
3860    return progress_in || progress_out;
3861 }
3862
3863
3864
3865 int BZ2_bzCompress ( bz_stream *strm, int action )
3866 {
3867    Bool progress;
3868    EState* s;
3869    if (strm == ((void *)0)) return (-2);
3870    s = strm->state;
3871    if (s == ((void *)0)) return (-2);
3872    if (s->strm != strm) return (-2);
3873
3874    preswitch:
3875    switch (s->mode) {
3876
3877       case 1:
3878          return (-1);
3879
3880       case 2:
3881          if (action == 0) {
3882             progress = handle_compress ( strm );
3883             return progress ? 1 : (-2);
3884          }
3885          else
3886   if (action == 1) {
3887             s->avail_in_expect = strm->avail_in;
3888             s->mode = 3;
3889             goto preswitch;
3890          }
3891          else
3892          if (action == 2) {
3893             s->avail_in_expect = strm->avail_in;
3894             s->mode = 4;
3895             goto preswitch;
3896          }
3897          else
3898             return (-2);
3899
3900       case 3:
3901          if (action != 1) return (-1);
3902          if (s->avail_in_expect != s->strm->avail_in)
3903             return (-1);
3904          progress = handle_compress ( strm );
3905          if (s->avail_in_expect > 0 || !isempty_RL(s) ||
3906              s->state_out_pos < s->numZ) return 2;
3907          s->mode = 2;
3908          return 1;
3909
3910       case 4:
3911          if (action != 2) return (-1);
3912          if (s->avail_in_expect != s->strm->avail_in)
3913             return (-1);
3914          progress = handle_compress ( strm );
3915          if (!progress) return (-1);
3916          if (s->avail_in_expect > 0 || !isempty_RL(s) ||
3917              s->state_out_pos < s->numZ) return 3;
3918          s->mode = 1;
3919          return 4;
3920    }
3921    return 0;
3922 }
3923
3924
3925
3926 int BZ2_bzCompressEnd ( bz_stream *strm )
3927 {
3928    EState* s;
3929    if (strm == ((void *)0)) return (-2);
3930    s = strm->state;
3931    if (s == ((void *)0)) return (-2);
3932    if (s->strm != strm) return (-2);
3933
3934    if (s->arr1 != ((void *)0)) (strm->bzfree)(strm->opaque,(s->arr1));
3935    if (s->arr2 != ((void *)0)) (strm->bzfree)(strm->opaque,(s->arr2));
3936    if (s->ftab != ((void *)0)) (strm->bzfree)(strm->opaque,(s->ftab));
3937    (strm->bzfree)(strm->opaque,(strm->state));
3938
3939    strm->state = ((void *)0);
3940
3941    return 0;
3942 }
3943
3944
3945
3946
3947
3948
3949
3950 int BZ2_bzDecompressInit
3951                      ( bz_stream* strm,
3952                        int verbosity,
3953                        int small )
3954 {
3955    DState* s;
3956
3957    if (!bz_config_ok()) return (-9);
3958
3959    if (strm == ((void *)0)) return (-2);
3960    if (small != 0 && small != 1) return (-2);
3961    if (verbosity < 0 || verbosity > 4) return (-2);
3962
3963    if (strm->bzalloc == ((void *)0)) strm->bzalloc = default_bzalloc;
3964    if (strm->bzfree == ((void *)0)) strm->bzfree = default_bzfree;
3965
3966    s = (strm->bzalloc)(strm->opaque,(sizeof(DState)),1);
3967    if (s == ((void *)0)) return (-3);
3968    s->strm = strm;
3969    strm->state = s;
3970    s->state = 10;
3971    s->bsLive = 0;
3972    s->bsBuff = 0;
3973    s->calculatedCombinedCRC = 0;
3974    strm->total_in_lo32 = 0;
3975    strm->total_in_hi32 = 0;
3976    strm->total_out_lo32 = 0;
3977    strm->total_out_hi32 = 0;
3978    s->smallDecompress = (Bool)small;
3979    s->ll4 = ((void *)0);
3980    s->ll16 = ((void *)0);
3981    s->tt = ((void *)0);
3982    s->currBlockNo = 0;
3983    s->verbosity = verbosity;
3984
3985    return 0;
3986 }
3987
3988
3989
3990
3991
3992
3993 static
3994 Bool unRLE_obuf_to_output_FAST ( DState* s )
3995 {
3996    UChar k1;
3997
3998    if (s->blockRandomised) {
3999
4000       while (((Bool)1)) {
4001
4002          while (((Bool)1)) {
4003             if (s->strm->avail_out == 0) return ((Bool)0);
4004             if (s->state_out_len == 0) break;
4005             *( (UChar*)(s->strm->next_out) ) = s->state_out_ch;
4006             { s->calculatedBlockCRC = (s->calculatedBlockCRC << 8) ^ BZ2_crc32Table[(s->calculatedBlockCRC >> 24) ^ ((UChar)s->state_out_ch)]; };
4007             s->state_out_len--;
4008             s->strm->next_out++;
4009             s->strm->avail_out--;
4010             s->strm->total_out_lo32++;
4011             if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
4012          }
4013
4014
4015          if (s->nblock_used == s->save_nblock+1) return ((Bool)0);
4016
4017
4018          if (s->nblock_used > s->save_nblock+1)
4019             return ((Bool)1);
4020
4021          s->state_out_len = 1;
4022          s->state_out_ch = s->k0;
4023          s->tPos = s->tt[s->tPos]; k1 = (UChar)(s->tPos & 0xff); s->tPos >>= 8;; if (s->rNToGo == 0) { s->rNToGo = BZ2_rNums[s->rTPos]; s->rTPos++; if (s->rTPos == 512) s->rTPos = 0; } s->rNToGo--;;
4024          k1 ^= ((s->rNToGo == 1) ? 1 : 0); s->nblock_used++;
4025          if (s->nblock_used == s->save_nblock+1) continue;
4026          if (k1 != s->k0) { s->k0 = k1; continue; };
4027
4028          s->state_out_len = 2;
4029          s->tPos = s->tt[s->tPos]; k1 = (UChar)(s->tPos & 0xff); s->tPos >>= 8;; if (s->rNToGo == 0) { s->rNToGo = BZ2_rNums[s->rTPos]; s->rTPos++; if (s->rTPos == 512) s->rTPos = 0; } s->rNToGo--;;
4030          k1 ^= ((s->rNToGo == 1) ? 1 : 0); s->nblock_used++;
4031          if (s->nblock_used == s->save_nblock+1) continue;
4032          if (k1 != s->k0) { s->k0 = k1; continue; };
4033
4034          s->state_out_len = 3;
4035          s->tPos = s->tt[s->tPos]; k1 = (UChar)(s->tPos & 0xff); s->tPos >>= 8;; if (s->rNToGo == 0) { s->rNToGo = BZ2_rNums[s->rTPos]; s->rTPos++; if (s->rTPos == 512) s->rTPos = 0; } s->rNToGo--;;
4036          k1 ^= ((s->rNToGo == 1) ? 1 : 0); s->nblock_used++;
4037          if (s->nblock_used == s->save_nblock+1) continue;
4038          if (k1 != s->k0) { s->k0 = k1; continue; };
4039
4040          s->tPos = s->tt[s->tPos]; k1 = (UChar)(s->tPos & 0xff); s->tPos >>= 8;; if (s->rNToGo == 0) { s->rNToGo = BZ2_rNums[s->rTPos]; s->rTPos++; if (s->rTPos == 512) s->rTPos = 0; } s->rNToGo--;;
4041          k1 ^= ((s->rNToGo == 1) ? 1 : 0); s->nblock_used++;
4042          s->state_out_len = ((Int32)k1) + 4;
4043          s->tPos = s->tt[s->tPos]; s->k0 = (UChar)(s->tPos & 0xff); s->tPos >>= 8;; if (s->rNToGo == 0) { s->rNToGo = BZ2_rNums[s->rTPos]; s->rTPos++; if (s->rTPos == 512) s->rTPos = 0; } s->rNToGo--;;
4044          s->k0 ^= ((s->rNToGo == 1) ? 1 : 0); s->nblock_used++;
4045       }
4046
4047    } else {
4048
4049
4050       UInt32 c_calculatedBlockCRC = s->calculatedBlockCRC;
4051       UChar c_state_out_ch = s->state_out_ch;
4052       Int32 c_state_out_len = s->state_out_len;
4053       Int32 c_nblock_used = s->nblock_used;
4054       Int32 c_k0 = s->k0;
4055       UInt32* c_tt = s->tt;
4056       UInt32 c_tPos = s->tPos;
4057       char* cs_next_out = s->strm->next_out;
4058       unsigned int cs_avail_out = s->strm->avail_out;
4059
4060
4061       UInt32 avail_out_INIT = cs_avail_out;
4062       Int32 s_save_nblockPP = s->save_nblock+1;
4063       unsigned int total_out_lo32_old;
4064
4065       while (((Bool)1)) {
4066
4067
4068          if (c_state_out_len > 0) {
4069             while (((Bool)1)) {
4070                if (cs_avail_out == 0) goto return_notr;
4071                if (c_state_out_len == 1) break;
4072                *( (UChar*)(cs_next_out) ) = c_state_out_ch;
4073                { c_calculatedBlockCRC = (c_calculatedBlockCRC << 8) ^ BZ2_crc32Table[(c_calculatedBlockCRC >> 24) ^ ((UChar)c_state_out_ch)]; };
4074                c_state_out_len--;
4075                cs_next_out++;
4076                cs_avail_out--;
4077             }
4078             s_state_out_len_eq_one:
4079             {
4080                if (cs_avail_out == 0) {
4081                   c_state_out_len = 1; goto return_notr;
4082                };
4083                *( (UChar*)(cs_next_out) ) = c_state_out_ch;
4084                { c_calculatedBlockCRC = (c_calculatedBlockCRC << 8) ^ BZ2_crc32Table[(c_calculatedBlockCRC >> 24) ^ ((UChar)c_state_out_ch)]; };
4085                cs_next_out++;
4086                cs_avail_out--;
4087             }
4088          }
4089
4090          if (c_nblock_used > s_save_nblockPP)
4091             return ((Bool)1);
4092
4093
4094          if (c_nblock_used == s_save_nblockPP) {
4095             c_state_out_len = 0; goto return_notr;
4096          };
4097          c_state_out_ch = c_k0;
4098          c_tPos = c_tt[c_tPos]; k1 = (UChar)(c_tPos & 0xff); c_tPos >>= 8;; c_nblock_used++;
4099          if (k1 != c_k0) {
4100             c_k0 = k1; goto s_state_out_len_eq_one;
4101          };
4102          if (c_nblock_used == s_save_nblockPP)
4103             goto s_state_out_len_eq_one;
4104
4105          c_state_out_len = 2;
4106          c_tPos = c_tt[c_tPos]; k1 = (UChar)(c_tPos & 0xff); c_tPos >>= 8;; c_nblock_used++;
4107          if (c_nblock_used == s_save_nblockPP) continue;
4108          if (k1 != c_k0) { c_k0 = k1; continue; };
4109
4110          c_state_out_len = 3;
4111          c_tPos = c_tt[c_tPos]; k1 = (UChar)(c_tPos & 0xff); c_tPos >>= 8;; c_nblock_used++;
4112          if (c_nblock_used == s_save_nblockPP) continue;
4113          if (k1 != c_k0) { c_k0 = k1; continue; };
4114
4115          c_tPos = c_tt[c_tPos]; k1 = (UChar)(c_tPos & 0xff); c_tPos >>= 8;; c_nblock_used++;
4116          c_state_out_len = ((Int32)k1) + 4;
4117          c_tPos = c_tt[c_tPos]; c_k0 = (UChar)(c_tPos & 0xff); c_tPos >>= 8;; c_nblock_used++;
4118       }
4119
4120       return_notr:
4121       total_out_lo32_old = s->strm->total_out_lo32;
4122       s->strm->total_out_lo32 += (avail_out_INIT - cs_avail_out);
4123       if (s->strm->total_out_lo32 < total_out_lo32_old)
4124          s->strm->total_out_hi32++;
4125
4126
4127       s->calculatedBlockCRC = c_calculatedBlockCRC;
4128       s->state_out_ch = c_state_out_ch;
4129       s->state_out_len = c_state_out_len;
4130       s->nblock_used = c_nblock_used;
4131       s->k0 = c_k0;
4132       s->tt = c_tt;
4133       s->tPos = c_tPos;
4134       s->strm->next_out = cs_next_out;
4135       s->strm->avail_out = cs_avail_out;
4136
4137    }
4138    return ((Bool)0);
4139 }
4140
4141
4142
4143
4144
4145
4146
4147 static
4148 Bool unRLE_obuf_to_output_SMALL ( DState* s )
4149 {
4150    UChar k1;
4151
4152    if (s->blockRandomised) {
4153
4154       while (((Bool)1)) {
4155
4156          while (((Bool)1)) {
4157             if (s->strm->avail_out == 0) return ((Bool)0);
4158             if (s->state_out_len == 0) break;
4159             *( (UChar*)(s->strm->next_out) ) = s->state_out_ch;
4160             { s->calculatedBlockCRC = (s->calculatedBlockCRC << 8) ^ BZ2_crc32Table[(s->calculatedBlockCRC >> 24) ^ ((UChar)s->state_out_ch)]; };
4161             s->state_out_len--;
4162             s->strm->next_out++;
4163             s->strm->avail_out--;
4164             s->strm->total_out_lo32++;
4165             if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
4166          }
4167
4168
4169          if (s->nblock_used == s->save_nblock+1) return ((Bool)0);
4170
4171
4172          if (s->nblock_used > s->save_nblock+1)
4173             return ((Bool)1);
4174
4175          s->state_out_len = 1;
4176          s->state_out_ch = s->k0;
4177          k1 = BZ2_indexIntoF ( s->tPos, s->cftab ); s->tPos = (((UInt32)s->ll16[s->tPos]) | (((((UInt32)(s->ll4[(s->tPos) >> 1])) >> (((s->tPos) << 2) & 0x4)) & 0xF) << 16));; if (s->rNToGo == 0) { s->rNToGo = BZ2_rNums[s->rTPos]; s->rTPos++; if (s->rTPos == 512) s->rTPos = 0; } s->rNToGo--;;
4178          k1 ^= ((s->rNToGo == 1) ? 1 : 0); s->nblock_used++;
4179          if (s->nblock_used == s->save_nblock+1) continue;
4180          if (k1 != s->k0) { s->k0 = k1; continue; };
4181
4182          s->state_out_len = 2;
4183          k1 = BZ2_indexIntoF ( s->tPos, s->cftab ); s->tPos = (((UInt32)s->ll16[s->tPos]) | (((((UInt32)(s->ll4[(s->tPos) >> 1])) >> (((s->tPos) << 2) & 0x4)) & 0xF) << 16));; if (s->rNToGo == 0) { s->rNToGo = BZ2_rNums[s->rTPos]; s->rTPos++; if (s->rTPos == 512) s->rTPos = 0; } s->rNToGo--;;
4184          k1 ^= ((s->rNToGo == 1) ? 1 : 0); s->nblock_used++;
4185          if (s->nblock_used == s->save_nblock+1) continue;
4186          if (k1 != s->k0) { s->k0 = k1; continue; };
4187
4188          s->state_out_len = 3;
4189          k1 = BZ2_indexIntoF ( s->tPos, s->cftab ); s->tPos = (((UInt32)s->ll16[s->tPos]) | (((((UInt32)(s->ll4[(s->tPos) >> 1])) >> (((s->tPos) << 2) & 0x4)) & 0xF) << 16));; if (s->rNToGo == 0) { s->rNToGo = BZ2_rNums[s->rTPos]; s->rTPos++; if (s->rTPos == 512) s->rTPos = 0; } s->rNToGo--;;
4190          k1 ^= ((s->rNToGo == 1) ? 1 : 0); s->nblock_used++;
4191          if (s->nblock_used == s->save_nblock+1) continue;
4192          if (k1 != s->k0) { s->k0 = k1; continue; };
4193
4194          k1 = BZ2_indexIntoF ( s->tPos, s->cftab ); s->tPos = (((UInt32)s->ll16[s->tPos]) | (((((UInt32)(s->ll4[(s->tPos) >> 1])) >> (((s->tPos) << 2) & 0x4)) & 0xF) << 16));; if (s->rNToGo == 0) { s->rNToGo = BZ2_rNums[s->rTPos]; s->rTPos++; if (s->rTPos == 512) s->rTPos = 0; } s->rNToGo--;;
4195          k1 ^= ((s->rNToGo == 1) ? 1 : 0); s->nblock_used++;
4196          s->state_out_len = ((Int32)k1) + 4;
4197          s->k0 = BZ2_indexIntoF ( s->tPos, s->cftab ); s->tPos = (((UInt32)s->ll16[s->tPos]) | (((((UInt32)(s->ll4[(s->tPos) >> 1])) >> (((s->tPos) << 2) & 0x4)) & 0xF) << 16));; if (s->rNToGo == 0) { s->rNToGo = BZ2_rNums[s->rTPos]; s->rTPos++; if (s->rTPos == 512) s->rTPos = 0; } s->rNToGo--;;
4198          s->k0 ^= ((s->rNToGo == 1) ? 1 : 0); s->nblock_used++;
4199       }
4200
4201    } else {
4202
4203       while (((Bool)1)) {
4204
4205          while (((Bool)1)) {
4206             if (s->strm->avail_out == 0) return ((Bool)0);
4207             if (s->state_out_len == 0) break;
4208             *( (UChar*)(s->strm->next_out) ) = s->state_out_ch;
4209             { s->calculatedBlockCRC = (s->calculatedBlockCRC << 8) ^ BZ2_crc32Table[(s->calculatedBlockCRC >> 24) ^ ((UChar)s->state_out_ch)]; };
4210             s->state_out_len--;
4211             s->strm->next_out++;
4212             s->strm->avail_out--;
4213             s->strm->total_out_lo32++;
4214             if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
4215          }
4216
4217
4218          if (s->nblock_used == s->save_nblock+1) return ((Bool)0);
4219
4220
4221          if (s->nblock_used > s->save_nblock+1)
4222             return ((Bool)1);
4223
4224          s->state_out_len = 1;
4225          s->state_out_ch = s->k0;
4226          k1 = BZ2_indexIntoF ( s->tPos, s->cftab ); s->tPos = (((UInt32)s->ll16[s->tPos]) | (((((UInt32)(s->ll4[(s->tPos) >> 1])) >> (((s->tPos) << 2) & 0x4)) & 0xF) << 16));; s->nblock_used++;
4227          if (s->nblock_used == s->save_nblock+1) continue;
4228          if (k1 != s->k0) { s->k0 = k1; continue; };
4229
4230          s->state_out_len = 2;
4231          k1 = BZ2_indexIntoF ( s->tPos, s->cftab ); s->tPos = (((UInt32)s->ll16[s->tPos]) | (((((UInt32)(s->ll4[(s->tPos) >> 1])) >> (((s->tPos) << 2) & 0x4)) & 0xF) << 16));; s->nblock_used++;
4232          if (s->nblock_used == s->save_nblock+1) continue;
4233          if (k1 != s->k0) { s->k0 = k1; continue; };
4234
4235          s->state_out_len = 3;
4236          k1 = BZ2_indexIntoF ( s->tPos, s->cftab ); s->tPos = (((UInt32)s->ll16[s->tPos]) | (((((UInt32)(s->ll4[(s->tPos) >> 1])) >> (((s->tPos) << 2) & 0x4)) & 0xF) << 16));; s->nblock_used++;
4237          if (s->nblock_used == s->save_nblock+1) continue;
4238          if (k1 != s->k0) { s->k0 = k1; continue; };
4239
4240          k1 = BZ2_indexIntoF ( s->tPos, s->cftab ); s->tPos = (((UInt32)s->ll16[s->tPos]) | (((((UInt32)(s->ll4[(s->tPos) >> 1])) >> (((s->tPos) << 2) & 0x4)) & 0xF) << 16));; s->nblock_used++;
4241          s->state_out_len = ((Int32)k1) + 4;
4242          s->k0 = BZ2_indexIntoF ( s->tPos, s->cftab ); s->tPos = (((UInt32)s->ll16[s->tPos]) | (((((UInt32)(s->ll4[(s->tPos) >> 1])) >> (((s->tPos) << 2) & 0x4)) & 0xF) << 16));; s->nblock_used++;
4243       }
4244
4245    }
4246 }
4247
4248
4249
4250 int BZ2_bzDecompress ( bz_stream *strm )
4251 {
4252    Bool corrupt;
4253    DState* s;
4254    if (strm == ((void *)0)) return (-2);
4255    s = strm->state;
4256    if (s == ((void *)0)) return (-2);
4257    if (s->strm != strm) return (-2);
4258
4259    while (((Bool)1)) {
4260       if (s->state == 1) return (-1);
4261       if (s->state == 2) {
4262          if (s->smallDecompress)
4263             corrupt = unRLE_obuf_to_output_SMALL ( s ); else
4264             corrupt = unRLE_obuf_to_output_FAST ( s );
4265          if (corrupt) return (-4);
4266          if (s->nblock_used == s->save_nblock+1 && s->state_out_len == 0) {
4267             { s->calculatedBlockCRC = ~(s->calculatedBlockCRC); };
4268             if (s->verbosity >= 3)
4269                vex_printf(" {0x%08x, 0x%08x}",s->storedBlockCRC,s->calculatedBlockCRC);
4270
4271             if (s->verbosity >= 2) vex_printf("]");
4272             if (s->calculatedBlockCRC != s->storedBlockCRC)
4273                return (-4);
4274             s->calculatedCombinedCRC
4275                = (s->calculatedCombinedCRC << 1) |
4276                     (s->calculatedCombinedCRC >> 31);
4277             s->calculatedCombinedCRC ^= s->calculatedBlockCRC;
4278             s->state = 14;
4279          } else {
4280             return 0;
4281          }
4282       }
4283       if (s->state >= 10) {
4284          Int32 r = BZ2_decompress ( s );
4285          if (r == 4) {
4286             if (s->verbosity >= 3)
4287                vex_printf("\n    combined CRCs: stored = 0x%08x, computed = 0x%08x",s->storedCombinedCRC,s->calculatedCombinedCRC);
4288
4289             if (s->calculatedCombinedCRC != s->storedCombinedCRC)
4290                return (-4);
4291             return r;
4292          }
4293          if (s->state != 2) return r;
4294       }
4295    }
4296
4297    { if (!(0)) bz_internal_error ( 6001 ); };
4298
4299    return 0;
4300 }
4301
4302
4303
4304 int BZ2_bzDecompressEnd ( bz_stream *strm )
4305 {
4306    DState* s;
4307    if (strm == ((void *)0)) return (-2);
4308    s = strm->state;
4309    if (s == ((void *)0)) return (-2);
4310    if (s->strm != strm) return (-2);
4311
4312    if (s->tt != ((void *)0)) (strm->bzfree)(strm->opaque,(s->tt));
4313    if (s->ll16 != ((void *)0)) (strm->bzfree)(strm->opaque,(s->ll16));
4314    if (s->ll4 != ((void *)0)) (strm->bzfree)(strm->opaque,(s->ll4));
4315
4316    (strm->bzfree)(strm->opaque,(strm->state));
4317    strm->state = ((void *)0);
4318
4319    return 0;
4320 }
4321
4322 int BZ2_bzBuffToBuffCompress
4323                          ( char* dest,
4324                            unsigned int* destLen,
4325                            char* source,
4326                            unsigned int sourceLen,
4327                            int blockSize100k,
4328                            int verbosity,
4329                            int workFactor )
4330 {
4331    bz_stream strm;
4332    int ret;
4333
4334    if (dest == ((void *)0) || destLen == ((void *)0) ||
4335        source == ((void *)0) ||
4336        blockSize100k < 1 || blockSize100k > 9 ||
4337        verbosity < 0 || verbosity > 4 ||
4338        workFactor < 0 || workFactor > 250)
4339       return (-2);
4340
4341    if (workFactor == 0) workFactor = 30;
4342    strm.bzalloc = ((void *)0);
4343    strm.bzfree = ((void *)0);
4344    strm.opaque = ((void *)0);
4345    ret = BZ2_bzCompressInit ( &strm, blockSize100k,
4346                               verbosity, workFactor );
4347    if (ret != 0) return ret;
4348
4349    strm.next_in = source;
4350    strm.next_out = dest;
4351    strm.avail_in = sourceLen;
4352    strm.avail_out = *destLen;
4353
4354    ret = BZ2_bzCompress ( &strm, 2 );
4355    if (ret == 3) goto output_overflow;
4356    if (ret != 4) goto errhandler;
4357
4358
4359    *destLen -= strm.avail_out;
4360    BZ2_bzCompressEnd ( &strm );
4361    return 0;
4362
4363    output_overflow:
4364    BZ2_bzCompressEnd ( &strm );
4365    return (-8);
4366
4367    errhandler:
4368    BZ2_bzCompressEnd ( &strm );
4369    return ret;
4370 }
4371
4372
4373
4374 int BZ2_bzBuffToBuffDecompress
4375                            ( char* dest,
4376                              unsigned int* destLen,
4377                              char* source,
4378                              unsigned int sourceLen,
4379                              int small,
4380                              int verbosity )
4381 {
4382    bz_stream strm;
4383    int ret;
4384
4385    if (dest == ((void *)0) || destLen == ((void *)0) ||
4386        source == ((void *)0) ||
4387        (small != 0 && small != 1) ||
4388        verbosity < 0 || verbosity > 4)
4389           return (-2);
4390
4391    strm.bzalloc = ((void *)0);
4392    strm.bzfree = ((void *)0);
4393    strm.opaque = ((void *)0);
4394    ret = BZ2_bzDecompressInit ( &strm, verbosity, small );
4395    if (ret != 0) return ret;
4396
4397    strm.next_in = source;
4398    strm.next_out = dest;
4399    strm.avail_in = sourceLen;
4400    strm.avail_out = *destLen;
4401
4402    ret = BZ2_bzDecompress ( &strm );
4403    if (ret == 0) goto output_overflow_or_eof;
4404    if (ret != 4) goto errhandler;
4405
4406
4407    *destLen -= strm.avail_out;
4408    BZ2_bzDecompressEnd ( &strm );
4409    return 0;
4410
4411    output_overflow_or_eof:
4412    if (strm.avail_out > 0) {
4413       BZ2_bzDecompressEnd ( &strm );
4414       return (-7);
4415    } else {
4416       BZ2_bzDecompressEnd ( &strm );
4417       return (-8);
4418    };
4419
4420    errhandler:
4421    BZ2_bzDecompressEnd ( &strm );
4422    return ret;
4423 }
4424
4425 const char * BZ2_bzlibVersion(void)
4426 {
4427    return "1.0.3, 17-Oct-2004";
4428 }
4429
4430 typedef unsigned char uchar;
4431
4432
4433  char inbuf[1000000];
4434  char outbuf[(1000000 + 1000000)];
4435  char zbuf[1000000 + 600 + (1000000 / 100)];
4436
4437 int nIn;
4438 unsigned int nOut;
4439 unsigned int nZ;
4440
4441 void flip_bit ( int bit )
4442 {
4443    int byteno = bit / 8;
4444    int bitno = bit % 8;
4445    uchar mask = 1 << bitno;
4446
4447
4448    zbuf[byteno] ^= mask;
4449 }
4450
4451 void set_inbuf ( void )
4452 {
4453   inbuf[0] = 0;
4454   my_strcat(inbuf, "At her sixtieth birthday party, Margaret Thatcher ");
4455   my_strcat(inbuf, "blew on the cake to light the candles.\n");
4456   my_strcat(inbuf, "This program, bzip2, the associated library libbzip2, and all\n");
4457   my_strcat(inbuf, "documentation, are copyright (C) 1996-2004 Julian R Seward.  All\n");
4458   my_strcat(inbuf, "rights reserved.\n");
4459   my_strcat(inbuf, "\n");
4460   my_strcat(inbuf, "Redistribution and use in source and binary forms, with or without\n");
4461   my_strcat(inbuf, "modification, are permitted provided that the following conditions\n");
4462   my_strcat(inbuf, "are met:\n");
4463   my_strcat(inbuf, "\n");
4464   my_strcat(inbuf, "1. Redistributions of source code must retain the above copyright\n");
4465   my_strcat(inbuf, "   notice, this list of conditions and the following disclaimer.\n");
4466   my_strcat(inbuf, "\n");
4467   my_strcat(inbuf, "2. The origin of this software must not be misrepresented; you must\n");
4468   my_strcat(inbuf, "   not claim that you wrote the original software.  If you use this\n");
4469   my_strcat(inbuf, "   software in a product, an acknowledgment in the product\n");
4470   my_strcat(inbuf, "   documentation would be appreciated but is not required.\n");
4471   my_strcat(inbuf, "\n");
4472   my_strcat(inbuf, "3. Altered source versions must be plainly marked as such, and must\n");
4473   my_strcat(inbuf, "   not be misrepresented as being the original software.\n");
4474   my_strcat(inbuf, "\n");
4475   my_strcat(inbuf, "4. The name of the author may not be used to endorse or promote\n");
4476   my_strcat(inbuf, "   products derived from this software without specific prior written\n");
4477   my_strcat(inbuf, "   permission.\n");
4478   my_strcat(inbuf, "\n");
4479   my_strcat(inbuf, "THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS\n");
4480   my_strcat(inbuf, "OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n");
4481   my_strcat(inbuf, "WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n");
4482   my_strcat(inbuf, "ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY\n");
4483   my_strcat(inbuf, "DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n");
4484   my_strcat(inbuf, "DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE\n");
4485   my_strcat(inbuf, "GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n");
4486   my_strcat(inbuf, "INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,\n");
4487   my_strcat(inbuf, "WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\n");
4488   my_strcat(inbuf, "NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\n");
4489   my_strcat(inbuf, "SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n");
4490   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4491   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4492   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4493   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4494   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4495   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4496   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4497   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4498   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4499   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4500   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4501   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4502   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4503   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4504   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4505   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4506   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4507   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4508   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4509   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4510   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4511   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4512   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4513   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4514   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4515   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4516   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4517   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4518   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4519   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4520   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4521   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4522   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4523   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4524   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4525   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4526   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4527   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4528   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4529   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4530   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4531   my_strcat(inbuf, "ababababababababababababababababababababababababababababababab");
4532   my_strcat(inbuf, "                GNU GENERAL PUBLIC LICENSE\n");
4533   my_strcat(inbuf, "                   Version 2, June 1991\n");
4534   my_strcat(inbuf, "\n");
4535   my_strcat(inbuf, " Copyright (C) 1989, 1991 Free Software Foundation, Inc.\n");
4536   my_strcat(inbuf, "     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n");
4537   my_strcat(inbuf, " Everyone is permitted to copy and distribute verbatim copies\n");
4538   my_strcat(inbuf, " of this license document, but changing it is not allowed.\n");
4539   my_strcat(inbuf, "\n");
4540   my_strcat(inbuf, "                        Preamble\n");
4541   my_strcat(inbuf, "\n");
4542   my_strcat(inbuf, "  The licenses for most software are designed to take away your\n");
4543   my_strcat(inbuf, "freedom to share and change it.  By contrast, the GNU General Public\n");
4544   my_strcat(inbuf, "License is intended to guarantee your freedom to share and change free\n");
4545   my_strcat(inbuf, "software--to make sure the software is free for all its users.  This\n");
4546   my_strcat(inbuf, "General Public License applies to most of the Free Software\n");
4547   my_strcat(inbuf, "Foundation's software and to any other program whose authors commit to\n");
4548   my_strcat(inbuf, "using it.  (Some other Free Software Foundation software is covered by\n");
4549   my_strcat(inbuf, "the GNU Library General Public License instead.)  You can apply it to\n");
4550   my_strcat(inbuf, "your programs, too.\n");
4551   my_strcat(inbuf, "\n");
4552   my_strcat(inbuf, "  When we speak of free software, we are referring to freedom, not\n");
4553   my_strcat(inbuf, "price.  Our General Public Licenses are designed to make sure that you\n");
4554   my_strcat(inbuf, "have the freedom to distribute copies of free software (and charge for\n");
4555   my_strcat(inbuf, "this service if you wish), that you receive source code or can get it\n");
4556   my_strcat(inbuf, "if you want it, that you can change the software or use pieces of it\n");
4557   my_strcat(inbuf, "in new free programs; and that you know you can do these things.\n");
4558   my_strcat(inbuf, "\n");
4559   my_strcat(inbuf, "  To protect your rights, we need to make restrictions that forbid\n");
4560   my_strcat(inbuf, "anyone to deny you these rights or to ask you to surrender the rights.\n");
4561   my_strcat(inbuf, "These restrictions translate to certain responsibilities for you if you\n");
4562   my_strcat(inbuf, "distribute copies of the software, or if you modify it.\n");
4563   my_strcat(inbuf, "\n");
4564   my_strcat(inbuf, "  For example, if you distribute copies of such a program, whether\n");
4565   my_strcat(inbuf, "gratis or for a fee, you must give the recipients all the rights that\n");
4566   my_strcat(inbuf, "you have.  You must make sure that they, too, receive or can get the\n");
4567   my_strcat(inbuf, "source code.  And you must show them these terms so they know their\n");
4568   my_strcat(inbuf, "rights.\n");
4569   my_strcat(inbuf, "\n");
4570   my_strcat(inbuf, "  We protect your rights with two steps: (1) copyright the software, and\n");
4571   my_strcat(inbuf, "(2) offer you this license which gives you legal permission to copy,\n");
4572   my_strcat(inbuf, "distribute and/or modify the software.\n");
4573   my_strcat(inbuf, "\n");
4574   my_strcat(inbuf, "  Also, for each author's protection and ours, we want to make certain\n");
4575   my_strcat(inbuf, "that everyone understands that there is no warranty for this free\n");
4576   my_strcat(inbuf, "software.  If the software is modified by someone else and passed on, we\n");
4577   my_strcat(inbuf, "want its recipients to know that what they have is not the original, so\n");
4578   my_strcat(inbuf, "that any problems introduced by others will not reflect on the original\n");
4579   my_strcat(inbuf, "authors' reputations.\n");
4580   my_strcat(inbuf, "\n");
4581   my_strcat(inbuf, "  Finally, any free program is threatened constantly by software\n");
4582   my_strcat(inbuf, "patents.  We wish to avoid the danger that redistributors of a free\n");
4583   my_strcat(inbuf, "program will individually obtain patent licenses, in effect making the\n");
4584   my_strcat(inbuf, "program proprietary.  To prevent this, we have made it clear that any\n");
4585   my_strcat(inbuf, "patent must be licensed for everyone's free use or not licensed at all.\n");
4586   my_strcat(inbuf, "\n");
4587   my_strcat(inbuf, "  The precise terms and conditions for copying, distribution and\n");
4588   my_strcat(inbuf, "modification follow.\n");
4589   my_strcat(inbuf, "\n");
4590   my_strcat(inbuf, "                GNU GENERAL PUBLIC LICENSE\n");
4591   my_strcat(inbuf, "   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n");
4592   my_strcat(inbuf, "\n");
4593   my_strcat(inbuf, "  0. This License applies to any program or other work which contains\n");
4594   my_strcat(inbuf, "a notice placed by the copyright holder saying it may be distributed\n");
4595   my_strcat(inbuf, "under the terms of this General Public License.  The Program, below,\n");
4596   my_strcat(inbuf, "refers to any such program or work, and a work based on the Program\n");
4597   my_strcat(inbuf, "means either the Program or any derivative work under copyright law:\n");
4598   my_strcat(inbuf, "that is to say, a work containing the Program or a portion of it,\n");
4599   my_strcat(inbuf, "either verbatim or with modifications and/or translated into another\n");
4600   my_strcat(inbuf, "language.  (Hereinafter, translation is included without limitation in\n");
4601   my_strcat(inbuf, "the term modification.)  Each licensee is addressed as you.\n");
4602   my_strcat(inbuf, "\n");
4603   my_strcat(inbuf, "Activities other than copying, distribution and modification are not\n");
4604   my_strcat(inbuf, "covered by this License; they are outside its scope.  The act of\n");
4605   my_strcat(inbuf, "running the Program is not restricted, and the output from the Program\n");
4606   my_strcat(inbuf, "is covered only if its contents constitute a work based on the\n");
4607   my_strcat(inbuf, "Program (independent of having been made by running the Program).\n");
4608   my_strcat(inbuf, "Whether that is true depends on what the Program does.\n");
4609   my_strcat(inbuf, "\n");
4610   my_strcat(inbuf, "  1. You may copy and distribute verbatim copies of the Program's\n");
4611   my_strcat(inbuf, "source code as you receive it, in any medium, provided that you\n");
4612   my_strcat(inbuf, "conspicuously and appropriately publish on each copy an appropriate\n");
4613   my_strcat(inbuf, "copyright notice and disclaimer of warranty; keep intact all the\n");
4614   my_strcat(inbuf, "notices that refer to this License and to the absence of any warranty;\n");
4615   my_strcat(inbuf, "and give any other recipients of the Program a copy of this License\n");
4616   my_strcat(inbuf, "along with the Program.\n");
4617   my_strcat(inbuf, "\n");
4618   my_strcat(inbuf, "You may charge a fee for the physical act of transferring a copy, and\n");
4619   my_strcat(inbuf, "you may at your option offer warranty protection in exchange for a fee.\n");
4620   my_strcat(inbuf, "\n");
4621   my_strcat(inbuf, "  2. You may modify your copy or copies of the Program or any portion\n");
4622   my_strcat(inbuf, "of it, thus forming a work based on the Program, and copy and\n");
4623   my_strcat(inbuf, "distribute such modifications or work under the terms of Section 1\n");
4624   my_strcat(inbuf, "above, provided that you also meet all of these conditions:\n");
4625   my_strcat(inbuf, "\n");
4626   my_strcat(inbuf, "    a) You must cause the modified files to carry prominent notices\n");
4627   my_strcat(inbuf, "    stating that you changed the files and the date of any change.\n");
4628   my_strcat(inbuf, "\n");
4629   my_strcat(inbuf, "    b) You must cause any work that you distribute or publish, that in\n");
4630   my_strcat(inbuf, "    whole or in part contains or is derived from the Program or any\n");
4631   my_strcat(inbuf, "    part thereof, to be licensed as a whole at no charge to all third\n");
4632   my_strcat(inbuf, "    parties under the terms of this License.\n");
4633   my_strcat(inbuf, "\n");
4634   my_strcat(inbuf, "    c) If the modified program normally reads commands interactively\n");
4635   my_strcat(inbuf, "    when run, you must cause it, when started running for such\n");
4636   my_strcat(inbuf, "    interactive use in the most ordinary way, to print or display an\n");
4637   my_strcat(inbuf, "    announcement including an appropriate copyright notice and a\n");
4638   my_strcat(inbuf, "    notice that there is no warranty (or else, saying that you provide\n");
4639   my_strcat(inbuf, "    a warranty) and that users may redistribute the program under\n");
4640   my_strcat(inbuf, "    these conditions, and telling the user how to view a copy of this\n");
4641   my_strcat(inbuf, "    License.  (Exception: if the Program itself is interactive but\n");
4642   my_strcat(inbuf, "    does not normally print such an announcement, your work based on\n");
4643   my_strcat(inbuf, "    the Program is not required to print an announcement.)\n");
4644   my_strcat(inbuf, "\n");
4645   my_strcat(inbuf, "These requirements apply to the modified work as a whole.  If\n");
4646   my_strcat(inbuf, "identifiable sections of that work are not derived from the Program,\n");
4647   my_strcat(inbuf, "and can be reasonably considered independent and separate works in\n");
4648   my_strcat(inbuf, "themselves, then this License, and its terms, do not apply to those\n");
4649   my_strcat(inbuf, "sections when you distribute them as separate works.  But when you\n");
4650   my_strcat(inbuf, "distribute the same sections as part of a whole which is a work based\n");
4651   my_strcat(inbuf, "on the Program, the distribution of the whole must be on the terms of\n");
4652   my_strcat(inbuf, "this License, whose permissions for other licensees extend to the\n");
4653   my_strcat(inbuf, "entire whole, and thus to each and every part regardless of who wrote it.\n");
4654   my_strcat(inbuf, "\n");
4655   my_strcat(inbuf, "Thus, it is not the intent of this section to claim rights or contest\n");
4656   my_strcat(inbuf, "your rights to work written entirely by you; rather, the intent is to\n");
4657   my_strcat(inbuf, "exercise the right to control the distribution of derivative or\n");
4658   my_strcat(inbuf, "collective works based on the Program.\n");
4659   my_strcat(inbuf, "\n");
4660   my_strcat(inbuf, "In addition, mere aggregation of another work not based on the Program\n");
4661   my_strcat(inbuf, "with the Program (or with a work based on the Program) on a volume of\n");
4662   my_strcat(inbuf, "a storage or distribution medium does not bring the other work under\n");
4663   my_strcat(inbuf, "the scope of this License.\n");
4664   my_strcat(inbuf, "\n");
4665   my_strcat(inbuf, "  3. You may copy and distribute the Program (or a work based on it,\n");
4666   my_strcat(inbuf, "under Section 2) in object code or executable form under the terms of\n");
4667   my_strcat(inbuf, "Sections 1 and 2 above provided that you also do one of the following:\n");
4668   my_strcat(inbuf, "\n");
4669   my_strcat(inbuf, "    a) Accompany it with the complete corresponding machine-readable\n");
4670   my_strcat(inbuf, "    source code, which must be distributed under the terms of Sections\n");
4671   my_strcat(inbuf, "    1 and 2 above on a medium customarily used for software interchange; or,\n");
4672   my_strcat(inbuf, "\n");
4673   my_strcat(inbuf, "    b) Accompany it with a written offer, valid for at least three\n");
4674   my_strcat(inbuf, "    years, to give any third party, for a charge no more than your\n");
4675   my_strcat(inbuf, "    cost of physically performing source distribution, a complete\n");
4676   my_strcat(inbuf, "    machine-readable copy of the corresponding source code, to be\n");
4677   my_strcat(inbuf, "    distributed under the terms of Sections 1 and 2 above on a medium\n");
4678   my_strcat(inbuf, "    customarily used for software interchange; or,\n");
4679   my_strcat(inbuf, "\n");
4680   my_strcat(inbuf, "    c) Accompany it with the information you received as to the offer\n");
4681   my_strcat(inbuf, "    to distribute corresponding source code.  (This alternative is\n");
4682   my_strcat(inbuf, "    allowed only for noncommercial distribution and only if you\n");
4683   my_strcat(inbuf, "    received the program in object code or executable form with such\n");
4684   my_strcat(inbuf, "    an offer, in accord with Subsection b above.)\n");
4685   my_strcat(inbuf, "\n");
4686   my_strcat(inbuf, "The source code for a work means the preferred form of the work for\n");
4687   my_strcat(inbuf, "making modifications to it.  For an executable work, complete source\n");
4688   my_strcat(inbuf, "code means all the source code for all modules it contains, plus any\n");
4689   my_strcat(inbuf, "associated interface definition files, plus the scripts used to\n");
4690   my_strcat(inbuf, "control compilation and installation of the executable.  However, as a\n");
4691   my_strcat(inbuf, "special exception, the source code distributed need not include\n");
4692   my_strcat(inbuf, "anything that is normally distributed (in either source or binary\n");
4693   my_strcat(inbuf, "form) with the major components (compiler, kernel, and so on) of the\n");
4694   my_strcat(inbuf, "operating system on which the executable runs, unless that component\n");
4695   my_strcat(inbuf, "itself accompanies the executable.\n");
4696   my_strcat(inbuf, "\n");
4697   my_strcat(inbuf, "If distribution of executable or object code is made by offering\n");
4698   my_strcat(inbuf, "access to copy from a designated place, then offering equivalent\n");
4699   my_strcat(inbuf, "access to copy the source code from the same place counts as\n");
4700   my_strcat(inbuf, "distribution of the source code, even though third parties are not\n");
4701   my_strcat(inbuf, "compelled to copy the source along with the object code.\n");
4702   my_strcat(inbuf, "\n");
4703   my_strcat(inbuf, "  4. You may not copy, modify, sublicense, or distribute the Program\n");
4704   my_strcat(inbuf, "except as expressly provided under this License.  Any attempt\n");
4705   my_strcat(inbuf, "otherwise to copy, modify, sublicense or distribute the Program is\n");
4706   my_strcat(inbuf, "void, and will automatically terminate your rights under this License.\n");
4707   my_strcat(inbuf, "However, parties who have received copies, or rights, from you under\n");
4708   my_strcat(inbuf, "this License will not have their licenses terminated so long as such\n");
4709   my_strcat(inbuf, "parties remain in full compliance.\n");
4710   my_strcat(inbuf, "\n");
4711   my_strcat(inbuf, "  5. You are not required to accept this License, since you have not\n");
4712   my_strcat(inbuf, "signed it.  However, nothing else grants you permission to modify or\n");
4713   my_strcat(inbuf, "distribute the Program or its derivative works.  These actions are\n");
4714   my_strcat(inbuf, "prohibited by law if you do not accept this License.  Therefore, by\n");
4715   my_strcat(inbuf, "modifying or distributing the Program (or any work based on the\n");
4716   my_strcat(inbuf, "Program), you indicate your acceptance of this License to do so, and\n");
4717   my_strcat(inbuf, "all its terms and conditions for copying, distributing or modifying\n");
4718   my_strcat(inbuf, "the Program or works based on it.\n");
4719   my_strcat(inbuf, "\n");
4720   my_strcat(inbuf, "  6. Each time you redistribute the Program (or any work based on the\n");
4721   my_strcat(inbuf, "Program), the recipient automatically receives a license from the\n");
4722   my_strcat(inbuf, "original licensor to copy, distribute or modify the Program subject to\n");
4723   my_strcat(inbuf, "these terms and conditions.  You may not impose any further\n");
4724   my_strcat(inbuf, "restrictions on the recipients' exercise of the rights granted herein.\n");
4725   my_strcat(inbuf, "You are not responsible for enforcing compliance by third parties to\n");
4726   my_strcat(inbuf, "this License.\n");
4727   my_strcat(inbuf, "\n");
4728   my_strcat(inbuf, "  7. If, as a consequence of a court judgment or allegation of patent\n");
4729   my_strcat(inbuf, "infringement or for any other reason (not limited to patent issues),\n");
4730   my_strcat(inbuf, "conditions are imposed on you (whether by court order, agreement or\n");
4731   my_strcat(inbuf, "otherwise) that contradict the conditions of this License, they do not\n");
4732   my_strcat(inbuf, "excuse you from the conditions of this License.  If you cannot\n");
4733   my_strcat(inbuf, "distribute so as to satisfy simultaneously your obligations under this\n");
4734   my_strcat(inbuf, "License and any other pertinent obligations, then as a consequence you\n");
4735   my_strcat(inbuf, "may not distribute the Program at all.  For example, if a patent\n");
4736   my_strcat(inbuf, "license would not permit royalty-free redistribution of the Program by\n");
4737   my_strcat(inbuf, "all those who receive copies directly or indirectly through you, then\n");
4738   my_strcat(inbuf, "the only way you could satisfy both it and this License would be to\n");
4739   my_strcat(inbuf, "refrain entirely from distribution of the Program.\n");
4740   my_strcat(inbuf, "\n");
4741   my_strcat(inbuf, "If any portion of this section is held invalid or unenforceable under\n");
4742   my_strcat(inbuf, "any particular circumstance, the balance of the section is intended to\n");
4743   my_strcat(inbuf, "apply and the section as a whole is intended to apply in other\n");
4744   my_strcat(inbuf, "circumstances.\n");
4745   my_strcat(inbuf, "\n");
4746   my_strcat(inbuf, "It is not the purpose of this section to induce you to infringe any\n");
4747   my_strcat(inbuf, "patents or other property right claims or to contest validity of any\n");
4748   my_strcat(inbuf, "such claims; this section has the sole purpose of protecting the\n");
4749   my_strcat(inbuf, "integrity of the free software distribution system, which is\n");
4750   my_strcat(inbuf, "implemented by public license practices.  Many people have made\n");
4751   my_strcat(inbuf, "generous contributions to the wide range of software distributed\n");
4752   my_strcat(inbuf, "through that system in reliance on consistent application of that\n");
4753   my_strcat(inbuf, "system; it is up to the author/donor to decide if he or she is willing\n");
4754   my_strcat(inbuf, "to distribute software through any other system and a licensee cannot\n");
4755   my_strcat(inbuf, "impose that choice.\n");
4756   my_strcat(inbuf, "\n");
4757   my_strcat(inbuf, "This section is intended to make thoroughly clear what is believed to\n");
4758   my_strcat(inbuf, "be a consequence of the rest of this License.\n");
4759   my_strcat(inbuf, "\n");
4760   my_strcat(inbuf, "  8. If the distribution and/or use of the Program is restricted in\n");
4761   my_strcat(inbuf, "certain countries either by patents or by copyrighted interfaces, the\n");
4762   my_strcat(inbuf, "original copyright holder who places the Program under this License\n");
4763   my_strcat(inbuf, "may add an explicit geographical distribution limitation excluding\n");
4764   my_strcat(inbuf, "those countries, so that distribution is permitted only in or among\n");
4765   my_strcat(inbuf, "countries not thus excluded.  In such case, this License incorporates\n");
4766   my_strcat(inbuf, "the limitation as if written in the body of this License.\n");
4767   my_strcat(inbuf, "\n");
4768   my_strcat(inbuf, "  9. The Free Software Foundation may publish revised and/or new versions\n");
4769   my_strcat(inbuf, "of the General Public License from time to time.  Such new versions will\n");
4770   my_strcat(inbuf, "be similar in spirit to the present version, but may differ in detail to\n");
4771   my_strcat(inbuf, "address new problems or concerns.\n");
4772   my_strcat(inbuf, "\n");
4773   my_strcat(inbuf, "Each version is given a distinguishing version number.  If the Program\n");
4774   my_strcat(inbuf, "specifies a version number of this License which applies to it and any\n");
4775   my_strcat(inbuf, "later version, you have the option of following the terms and conditions\n");
4776   my_strcat(inbuf, "either of that version or of any later version published by the Free\n");
4777   my_strcat(inbuf, "Software Foundation.  If the Program does not specify a version number of\n");
4778   my_strcat(inbuf, "this License, you may choose any version ever published by the Free Software\n");
4779   my_strcat(inbuf, "Foundation.\n");
4780   my_strcat(inbuf, "\n");
4781   my_strcat(inbuf, "  10. If you wish to incorporate parts of the Program into other free\n");
4782   my_strcat(inbuf, "programs whose distribution conditions are different, write to the author\n");
4783   my_strcat(inbuf, "to ask for permission.  For software which is copyrighted by the Free\n");
4784   my_strcat(inbuf, "Software Foundation, write to the Free Software Foundation; we sometimes\n");
4785   my_strcat(inbuf, "make exceptions for this.  Our decision will be guided by the two goals\n");
4786   my_strcat(inbuf, "of preserving the free status of all derivatives of our free software and\n");
4787   my_strcat(inbuf, "of promoting the sharing and reuse of software generally.\n");
4788   my_strcat(inbuf, "\n");
4789   my_strcat(inbuf, "                        NO WARRANTY\n");
4790   my_strcat(inbuf, "\n");
4791   my_strcat(inbuf, "  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY\n");
4792   my_strcat(inbuf, "FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN\n");
4793   my_strcat(inbuf, "OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES\n");
4794   my_strcat(inbuf, "PROVIDE THE PROGRAM AS IS WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED\n");
4795   my_strcat(inbuf, "OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\n");
4796   my_strcat(inbuf, "MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS\n");
4797   my_strcat(inbuf, "TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE\n");
4798   my_strcat(inbuf, "PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,\n");
4799   my_strcat(inbuf, "REPAIR OR CORRECTION.\n");
4800   my_strcat(inbuf, "\n");
4801   my_strcat(inbuf, "  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING\n");
4802   my_strcat(inbuf, "WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR\n");
4803   my_strcat(inbuf, "REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,\n");
4804   my_strcat(inbuf, "INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING\n");
4805   my_strcat(inbuf, "OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED\n");
4806   my_strcat(inbuf, "TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY\n");
4807   my_strcat(inbuf, "YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER\n");
4808   my_strcat(inbuf, "PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE\n");
4809   my_strcat(inbuf, "POSSIBILITY OF SUCH DAMAGES.\n");
4810   my_strcat(inbuf, "\n");
4811   my_strcat(inbuf, "                 END OF TERMS AND CONDITIONS\n");
4812   my_strcat(inbuf, "\n");
4813   my_strcat(inbuf, "        How to Apply These Terms to Your New Programs\n");
4814   my_strcat(inbuf, "\n");
4815   my_strcat(inbuf, "  If you develop a new program, and you want it to be of the greatest\n");
4816   my_strcat(inbuf, "possible use to the public, the best way to achieve this is to make it\n");
4817   my_strcat(inbuf, "free software which everyone can redistribute and change under these terms.\n");
4818   my_strcat(inbuf, "\n");
4819   my_strcat(inbuf, "  To do so, attach the following notices to the program.  It is safest\n");
4820   my_strcat(inbuf, "to attach them to the start of each source file to most effectively\n");
4821   my_strcat(inbuf, "convey the exclusion of warranty; and each file should have at least\n");
4822   my_strcat(inbuf, "the copyright line and a pointer to where the full notice is found.\n");
4823   my_strcat(inbuf, "\n");
4824   my_strcat(inbuf, "    <one line to give the program's name and a brief idea of what it does.>\n");
4825   my_strcat(inbuf, "    Copyright (C) <year>  <name of author>\n");
4826   my_strcat(inbuf, "\n");
4827   my_strcat(inbuf, "    This program is free software; you can redistribute it and/or modify\n");
4828   my_strcat(inbuf, "    it under the terms of the GNU General Public License as published by\n");
4829   my_strcat(inbuf, "    the Free Software Foundation; either version 2 of the License, or\n");
4830   my_strcat(inbuf, "    (at your option) any later version.\n");
4831   my_strcat(inbuf, "\n");
4832   my_strcat(inbuf, "    This program is distributed in the hope that it will be useful,\n");
4833   my_strcat(inbuf, "    but WITHOUT ANY WARRANTY; without even the implied warranty of\n");
4834   my_strcat(inbuf, "    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n");
4835   my_strcat(inbuf, "    GNU General Public License for more details.\n");
4836   my_strcat(inbuf, "\n");
4837   my_strcat(inbuf, "    You should have received a copy of the GNU General Public License\n");
4838   my_strcat(inbuf, "    along with this program; if not, write to the Free Software\n");
4839   my_strcat(inbuf, "    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n");
4840   my_strcat(inbuf, "\n");
4841   my_strcat(inbuf, "\n");
4842   my_strcat(inbuf, "Also add information on how to contact you by electronic and paper mail.\n");
4843   my_strcat(inbuf, "\n");
4844   my_strcat(inbuf, "If the program is interactive, make it output a short notice like this\n");
4845   my_strcat(inbuf, "when it starts in an interactive mode:\n");
4846   my_strcat(inbuf, "\n");
4847   my_strcat(inbuf, "    Gnomovision version 69, Copyright (C) year  name of author\n");
4848   my_strcat(inbuf, "    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.\n");
4849   my_strcat(inbuf, "    This is free software, and you are welcome to redistribute it\n");
4850   my_strcat(inbuf, "    under certain conditions; type `show c' for details.\n");
4851   my_strcat(inbuf, "\n");
4852   my_strcat(inbuf, "The hypothetical commands `show w' and `show c' should show the appropriate\n");
4853   my_strcat(inbuf, "parts of the General Public License.  Of course, the commands you use may\n");
4854   my_strcat(inbuf, "be called something other than `show w' and `show c'; they could even be\n");
4855   my_strcat(inbuf, "mouse-clicks or menu items--whatever suits your program.\n");
4856   my_strcat(inbuf, "\n");
4857   my_strcat(inbuf, "You should also get your employer (if you work as a programmer) or your\n");
4858   my_strcat(inbuf, "school, if any, to sign a copyright disclaimer for the program, if\n");
4859   my_strcat(inbuf, "necessary.  Here is a sample; alter the names:\n");
4860   my_strcat(inbuf, "\n");
4861   my_strcat(inbuf, "  Yoyodyne, Inc., hereby disclaims all copyright interest in the program\n");
4862   my_strcat(inbuf, "  `Gnomovision' (which makes passes at compilers) written by James Hacker.\n");
4863   my_strcat(inbuf, "\n");
4864   my_strcat(inbuf, "  <signature of Ty Coon>, 1 April 1989\n");
4865   my_strcat(inbuf, "  Ty Coon, President of Vice\n");
4866   my_strcat(inbuf, "\n");
4867   my_strcat(inbuf, "This General Public License does not permit incorporating your program into\n");
4868   my_strcat(inbuf, "proprietary programs.  If your program is a subroutine library, you may\n");
4869   my_strcat(inbuf, "consider it more useful to permit linking proprietary applications with the\n");
4870   my_strcat(inbuf, "library.  If this is what you want to do, use the GNU Library General\n");
4871   my_strcat(inbuf, "Public License instead of this License.\n");
4872
4873   my_strcat(inbuf, "\n");
4874 }
4875
4876
4877 typedef struct _IO_FILE FILE;
4878
4879
4880
4881 typedef struct _IO_FILE __FILE;
4882 typedef unsigned int wint_t;
4883
4884 typedef struct
4885 {
4886   int __count;
4887   union
4888   {
4889     wint_t __wch;
4890     char __wchb[4];
4891   } __value;
4892 } __mbstate_t;
4893
4894
4895 typedef struct
4896 {
4897   __off_t __pos;
4898   __mbstate_t __state;
4899 } _G_fpos_t;
4900 typedef struct
4901 {
4902   __off64_t __pos;
4903   __mbstate_t __state;
4904 } _G_fpos64_t;
4905
4906
4907 enum
4908 {
4909   __GCONV_OK = 0,
4910   __GCONV_NOCONV,
4911   __GCONV_NODB,
4912   __GCONV_NOMEM,
4913
4914   __GCONV_EMPTY_INPUT,
4915   __GCONV_FULL_OUTPUT,
4916   __GCONV_ILLEGAL_INPUT,
4917   __GCONV_INCOMPLETE_INPUT,
4918
4919   __GCONV_ILLEGAL_DESCRIPTOR,
4920   __GCONV_INTERNAL_ERROR
4921 };
4922
4923
4924
4925 enum
4926 {
4927   __GCONV_IS_LAST = 0x0001,
4928   __GCONV_IGNORE_ERRORS = 0x0002
4929 };
4930
4931
4932
4933 struct __gconv_step;
4934 struct __gconv_step_data;
4935 struct __gconv_loaded_object;
4936 struct __gconv_trans_data;
4937
4938
4939
4940 typedef int (*__gconv_fct) (struct __gconv_step *, struct __gconv_step_data *,
4941        __const unsigned char **, __const unsigned char *,
4942        unsigned char **, size_t *, int, int);
4943
4944
4945 typedef wint_t (*__gconv_btowc_fct) (struct __gconv_step *, unsigned char);
4946
4947
4948 typedef int (*__gconv_init_fct) (struct __gconv_step *);
4949 typedef void (*__gconv_end_fct) (struct __gconv_step *);
4950
4951
4952
4953 typedef int (*__gconv_trans_fct) (struct __gconv_step *,
4954       struct __gconv_step_data *, void *,
4955       __const unsigned char *,
4956       __const unsigned char **,
4957       __const unsigned char *, unsigned char **,
4958       size_t *);
4959
4960
4961 typedef int (*__gconv_trans_context_fct) (void *, __const unsigned char *,
4962        __const unsigned char *,
4963        unsigned char *, unsigned char *);
4964
4965
4966 typedef int (*__gconv_trans_query_fct) (__const char *, __const char ***,
4967      size_t *);
4968
4969
4970 typedef int (*__gconv_trans_init_fct) (void **, const char *);
4971 typedef void (*__gconv_trans_end_fct) (void *);
4972
4973 struct __gconv_trans_data
4974 {
4975
4976   __gconv_trans_fct __trans_fct;
4977   __gconv_trans_context_fct __trans_context_fct;
4978   __gconv_trans_end_fct __trans_end_fct;
4979   void *__data;
4980   struct __gconv_trans_data *__next;
4981 };
4982
4983
4984
4985 struct __gconv_step
4986 {
4987   struct __gconv_loaded_object *__shlib_handle;
4988   __const char *__modname;
4989
4990   int __counter;
4991
4992   char *__from_name;
4993   char *__to_name;
4994
4995   __gconv_fct __fct;
4996   __gconv_btowc_fct __btowc_fct;
4997   __gconv_init_fct __init_fct;
4998   __gconv_end_fct __end_fct;
4999
5000
5001
5002   int __min_needed_from;
5003   int __max_needed_from;
5004   int __min_needed_to;
5005   int __max_needed_to;
5006
5007
5008   int __stateful;
5009
5010   void *__data;
5011 };
5012
5013
5014
5015 struct __gconv_step_data
5016 {
5017   unsigned char *__outbuf;
5018   unsigned char *__outbufend;
5019
5020
5021
5022   int __flags;
5023
5024
5025
5026   int __invocation_counter;
5027
5028
5029
5030   int __internal_use;
5031
5032   __mbstate_t *__statep;
5033   __mbstate_t __state;
5034
5035
5036
5037   struct __gconv_trans_data *__trans;
5038 };
5039
5040
5041
5042 typedef struct __gconv_info
5043 {
5044   size_t __nsteps;
5045   struct __gconv_step *__steps;
5046   __extension__ struct __gconv_step_data __data [];
5047 } *__gconv_t;
5048
5049 typedef union
5050 {
5051   struct __gconv_info __cd;
5052   struct
5053   {
5054     struct __gconv_info __cd;
5055     struct __gconv_step_data __data;
5056   } __combined;
5057 } _G_iconv_t;
5058
5059 typedef int _G_int16_t __attribute__ ((__mode__ (__HI__)));
5060 typedef int _G_int32_t __attribute__ ((__mode__ (__SI__)));
5061 typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
5062 typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__)));
5063
5064 struct _IO_jump_t; struct _IO_FILE;
5065
5066 typedef void _IO_lock_t;
5067
5068
5069
5070
5071
5072 struct _IO_marker {
5073   struct _IO_marker *_next;
5074   struct _IO_FILE *_sbuf;
5075
5076
5077
5078   int _pos;
5079
5080 };
5081
5082
5083 enum __codecvt_result
5084 {
5085   __codecvt_ok,
5086   __codecvt_partial,
5087   __codecvt_error,
5088   __codecvt_noconv
5089 };
5090
5091 struct _IO_FILE {
5092   int _flags;
5093
5094
5095
5096
5097   char* _IO_read_ptr;
5098   char* _IO_read_end;
5099   char* _IO_read_base;
5100   char* _IO_write_base;
5101   char* _IO_write_ptr;
5102   char* _IO_write_end;
5103   char* _IO_buf_base;
5104   char* _IO_buf_end;
5105
5106   char *_IO_save_base;
5107   char *_IO_backup_base;
5108   char *_IO_save_end;
5109
5110   struct _IO_marker *_markers;
5111
5112   struct _IO_FILE *_chain;
5113
5114   int _fileno;
5115
5116
5117
5118   int _flags2;
5119
5120   __off_t _old_offset;
5121
5122
5123
5124   unsigned short _cur_column;
5125   signed char _vtable_offset;
5126   char _shortbuf[1];
5127
5128
5129
5130   _IO_lock_t *_lock;
5131
5132   __off64_t _offset;
5133
5134
5135
5136
5137
5138   void *__pad1;
5139   void *__pad2;
5140
5141   int _mode;
5142
5143   char _unused2[15 * sizeof (int) - 2 * sizeof (void *)];
5144
5145 };
5146
5147
5148 typedef struct _IO_FILE _IO_FILE;
5149
5150
5151 struct _IO_FILE_plus;
5152
5153 extern struct _IO_FILE_plus _IO_2_1_stdin_;
5154 extern struct _IO_FILE_plus _IO_2_1_stdout_;
5155 extern struct _IO_FILE_plus _IO_2_1_stderr_;
5156
5157 typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);
5158
5159
5160
5161
5162
5163
5164
5165 typedef __ssize_t __io_write_fn (void *__cookie, __const char *__buf,
5166      size_t __n);
5167
5168
5169
5170
5171
5172
5173
5174 typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);
5175
5176
5177 typedef int __io_close_fn (void *__cookie);
5178
5179 extern int __underflow (_IO_FILE *) __attribute__ ((__nothrow__));
5180 extern int __uflow (_IO_FILE *) __attribute__ ((__nothrow__));
5181 extern int __overflow (_IO_FILE *, int) __attribute__ ((__nothrow__));
5182 extern wint_t __wunderflow (_IO_FILE *) __attribute__ ((__nothrow__));
5183 extern wint_t __wuflow (_IO_FILE *) __attribute__ ((__nothrow__));
5184 extern wint_t __woverflow (_IO_FILE *, wint_t) __attribute__ ((__nothrow__));
5185
5186 extern int _IO_getc (_IO_FILE *__fp) __attribute__ ((__nothrow__));
5187 extern int _IO_putc (int __c, _IO_FILE *__fp) __attribute__ ((__nothrow__));
5188 extern int _IO_feof (_IO_FILE *__fp) __attribute__ ((__nothrow__));
5189 extern int _IO_ferror (_IO_FILE *__fp) __attribute__ ((__nothrow__));
5190
5191 extern int _IO_peekc_locked (_IO_FILE *__fp) __attribute__ ((__nothrow__));
5192
5193
5194
5195
5196
5197 extern void _IO_flockfile (_IO_FILE *) __attribute__ ((__nothrow__));
5198 extern void _IO_funlockfile (_IO_FILE *) __attribute__ ((__nothrow__));
5199 extern int _IO_ftrylockfile (_IO_FILE *) __attribute__ ((__nothrow__));
5200
5201 extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t) __attribute__ ((__nothrow__));
5202 extern size_t _IO_sgetn (_IO_FILE *, void *, size_t) __attribute__ ((__nothrow__));
5203
5204 extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int) __attribute__ ((__nothrow__));
5205 extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int) __attribute__ ((__nothrow__));
5206
5207 extern void _IO_free_backup_area (_IO_FILE *) __attribute__ ((__nothrow__));
5208
5209
5210 typedef _G_fpos_t fpos_t;
5211
5212
5213
5214
5215
5216
5217
5218
5219 extern struct _IO_FILE *stdin;
5220 extern struct _IO_FILE *stdout;
5221 extern struct _IO_FILE *stderr;
5222
5223
5224
5225
5226
5227
5228
5229
5230
5231 extern int remove (__const char *__filename) __attribute__ ((__nothrow__));
5232
5233 extern int rename (__const char *__old, __const char *__new) __attribute__ ((__nothrow__));
5234
5235
5236
5237
5238
5239
5240
5241
5242
5243 extern FILE *tmpfile (void);
5244
5245 extern char *tmpnam (char *__s) __attribute__ ((__nothrow__));
5246
5247
5248
5249
5250
5251 extern char *tmpnam_r (char *__s) __attribute__ ((__nothrow__));
5252
5253 extern char *tempnam (__const char *__dir, __const char *__pfx)
5254      __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));
5255
5256
5257
5258
5259
5260
5261
5262
5263 extern int fclose (FILE *__stream);
5264
5265
5266
5267
5268 extern int fflush (FILE *__stream);
5269
5270
5271 extern int fflush_unlocked (FILE *__stream);
5272
5273
5274
5275
5276
5277
5278
5279 extern FILE *fopen (__const char *__restrict __filename,
5280       __const char *__restrict __modes);
5281
5282
5283
5284
5285 extern FILE *freopen (__const char *__restrict __filename,
5286         __const char *__restrict __modes,
5287         FILE *__restrict __stream);
5288
5289
5290
5291 extern FILE *fdopen (int __fd, __const char *__modes) __attribute__ ((__nothrow__));
5292
5293
5294
5295
5296 extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) __attribute__ ((__nothrow__));
5297
5298
5299
5300 extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
5301       int __modes, size_t __n) __attribute__ ((__nothrow__));
5302
5303
5304
5305
5306
5307 extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
5308          size_t __size) __attribute__ ((__nothrow__));
5309
5310
5311 extern void setlinebuf (FILE *__stream) __attribute__ ((__nothrow__));
5312
5313
5314
5315
5316
5317
5318
5319
5320 extern int fprintf (FILE *__restrict __stream,
5321       __const char *__restrict __format, ...);
5322
5323
5324
5325
5326 extern int printf (__const char *__restrict __format, ...);
5327
5328 extern int sprintf (char *__restrict __s,
5329       __const char *__restrict __format, ...) __attribute__ ((__nothrow__));
5330
5331
5332
5333
5334
5335
5336
5337
5338
5339
5340
5341
5342
5343
5344
5345
5346 extern int snprintf (char *__restrict __s, size_t __maxlen,
5347        __const char *__restrict __format, ...)
5348      __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 4)));
5349
5350
5351
5352
5353
5354
5355
5356
5357 extern int fscanf (FILE *__restrict __stream,
5358      __const char *__restrict __format, ...);
5359
5360
5361
5362
5363 extern int scanf (__const char *__restrict __format, ...);
5364
5365 extern int sscanf (__const char *__restrict __s,
5366      __const char *__restrict __format, ...) __attribute__ ((__nothrow__));
5367
5368
5369
5370
5371
5372
5373
5374 extern int fgetc (FILE *__stream);
5375 extern int getc (FILE *__stream);
5376
5377
5378
5379
5380
5381 extern int getchar (void);
5382
5383
5384 extern int getc_unlocked (FILE *__stream);
5385 extern int getchar_unlocked (void);
5386
5387 extern int fgetc_unlocked (FILE *__stream);
5388
5389
5390
5391
5392
5393
5394
5395
5396
5397
5398
5399 extern int fputc (int __c, FILE *__stream);
5400 extern int putc (int __c, FILE *__stream);
5401
5402
5403
5404
5405
5406 extern int putchar (int __c);
5407
5408
5409 extern int fputc_unlocked (int __c, FILE *__stream);
5410
5411
5412
5413
5414
5415
5416
5417 extern int putc_unlocked (int __c, FILE *__stream);
5418 extern int putchar_unlocked (int __c);
5419
5420
5421
5422
5423
5424
5425 extern int getw (FILE *__stream);
5426
5427
5428 extern int putw (int __w, FILE *__stream);
5429
5430
5431
5432
5433
5434
5435
5436
5437 extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream);
5438
5439
5440
5441
5442
5443
5444 extern char *gets (char *__s);
5445
5446
5447
5448
5449
5450
5451
5452 extern int fputs (__const char *__restrict __s, FILE *__restrict __stream);
5453
5454
5455
5456
5457
5458 extern int puts (__const char *__s);
5459
5460
5461
5462
5463
5464
5465 extern int ungetc (int __c, FILE *__stream);
5466
5467
5468
5469
5470
5471
5472 extern size_t fread (void *__restrict __ptr, size_t __size,
5473        size_t __n, FILE *__restrict __stream);
5474
5475
5476
5477
5478 extern size_t fwrite (__const void *__restrict __ptr, size_t __size,
5479         size_t __n, FILE *__restrict __s);
5480
5481
5482 extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
5483          size_t __n, FILE *__restrict __stream);
5484 extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size,
5485           size_t __n, FILE *__restrict __stream);
5486
5487
5488
5489
5490
5491
5492
5493
5494 extern int fseek (FILE *__stream, long int __off, int __whence);
5495
5496
5497
5498
5499 extern long int ftell (FILE *__stream);
5500
5501
5502
5503
5504 extern void rewind (FILE *__stream);
5505
5506
5507
5508
5509
5510
5511
5512
5513 extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
5514
5515
5516
5517
5518 extern int fsetpos (FILE *__stream, __const fpos_t *__pos);
5519
5520
5521
5522 extern void clearerr (FILE *__stream) __attribute__ ((__nothrow__));
5523
5524 extern int feof (FILE *__stream) __attribute__ ((__nothrow__));
5525
5526 extern int ferror (FILE *__stream) __attribute__ ((__nothrow__));
5527
5528
5529
5530
5531 extern void clearerr_unlocked (FILE *__stream) __attribute__ ((__nothrow__));
5532 extern int feof_unlocked (FILE *__stream) __attribute__ ((__nothrow__));
5533 extern int ferror_unlocked (FILE *__stream) __attribute__ ((__nothrow__));
5534
5535
5536
5537
5538
5539
5540
5541
5542 extern void perror (__const char *__s);
5543
5544
5545
5546
5547
5548
5549 extern int sys_nerr;
5550 extern __const char *__const sys_errlist[];
5551
5552
5553
5554
5555
5556 extern int fileno (FILE *__stream) __attribute__ ((__nothrow__));
5557
5558
5559
5560
5561 extern int fileno_unlocked (FILE *__stream) __attribute__ ((__nothrow__));
5562
5563 extern FILE *popen (__const char *__command, __const char *__modes);
5564
5565
5566
5567
5568
5569 extern int pclose (FILE *__stream);
5570
5571
5572
5573
5574
5575 extern char *ctermid (char *__s) __attribute__ ((__nothrow__));
5576
5577 extern void flockfile (FILE *__stream) __attribute__ ((__nothrow__));
5578
5579
5580
5581 extern int ftrylockfile (FILE *__stream) __attribute__ ((__nothrow__));
5582
5583
5584 extern void funlockfile (FILE *__stream) __attribute__ ((__nothrow__));
5585
5586 typedef int ptrdiff_t;
5587
5588 extern void * malloc (size_t __size) __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));
5589
5590
5591 extern void * calloc (size_t __nmemb, size_t __size) __attribute__ ((__nothrow__))
5592        __attribute__ ((__malloc__));
5593
5594
5595
5596 extern void * realloc (void * __ptr, size_t __size) __attribute__ ((__nothrow__))
5597
5598        __attribute__ ((__malloc__));
5599
5600
5601 extern void free (void * __ptr) __attribute__ ((__nothrow__));
5602
5603
5604 extern void cfree (void * __ptr) __attribute__ ((__nothrow__));
5605
5606
5607 extern void * memalign (size_t __alignment, size_t __size) __attribute__ ((__nothrow__));
5608
5609
5610 extern void * valloc (size_t __size) __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));
5611
5612
5613
5614 extern void * pvalloc (size_t __size) __attribute__ ((__nothrow__))
5615        __attribute__ ((__malloc__));
5616
5617
5618
5619 extern void * (*__morecore) (ptrdiff_t __size);
5620
5621
5622 extern void * __default_morecore (ptrdiff_t __size) __attribute__ ((__nothrow__))
5623        __attribute__ ((__malloc__));
5624
5625
5626
5627 struct mallinfo {
5628   int arena;
5629   int ordblks;
5630   int smblks;
5631   int hblks;
5632   int hblkhd;
5633   int usmblks;
5634   int fsmblks;
5635   int uordblks;
5636   int fordblks;
5637   int keepcost;
5638 };
5639
5640
5641 extern struct mallinfo mallinfo (void) __attribute__ ((__nothrow__));
5642
5643 extern int mallopt (int __param, int __val) __attribute__ ((__nothrow__));
5644
5645
5646
5647 extern int malloc_trim (size_t __pad) __attribute__ ((__nothrow__));
5648
5649
5650
5651 extern size_t malloc_usable_size (void * __ptr) __attribute__ ((__nothrow__));
5652
5653
5654 extern void malloc_stats (void) __attribute__ ((__nothrow__));
5655
5656
5657 extern void * malloc_get_state (void) __attribute__ ((__nothrow__));
5658
5659
5660
5661 extern int malloc_set_state (void * __ptr) __attribute__ ((__nothrow__));
5662
5663
5664
5665
5666 extern void (*__malloc_initialize_hook) (void);
5667
5668 extern void (*__free_hook) (void * __ptr, __const void *);
5669
5670 extern void * (*__malloc_hook) (size_t __size, __const void *);
5671
5672 extern void * (*__realloc_hook) (void * __ptr, size_t __size, __const void *);
5673
5674
5675 extern void * (*__memalign_hook) (size_t __alignment, size_t __size, __const void *);
5676
5677
5678 extern void (*__after_morecore_hook) (void);
5679
5680
5681 extern void __malloc_check_init (void) __attribute__ ((__nothrow__));
5682
5683
5684
5685 extern void __assert_fail (__const char *__assertion, __const char *__file,
5686       unsigned int __line, __const char *__function)
5687      __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));
5688
5689
5690 extern void __assert_perror_fail (int __errnum, __const char *__file,
5691       unsigned int __line,
5692       __const char *__function)
5693      __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));
5694
5695
5696
5697
5698 extern void __assert (const char *__assertion, const char *__file, int __line)
5699      __attribute__ ((__nothrow__)) __attribute__ ((__noreturn__));
5700
5701
5702
5703
5704
5705
5706 static HWord g_serviceFn ( HWord arg1, HWord arg2 )
5707 {
5708    switch (arg1) {
5709       case 0:
5710          exit(0);
5711       case 1:
5712          putchar(arg2);
5713          return 0;
5714       case 2:
5715          return (HWord)malloc(arg2);
5716       case 3:
5717          free((void*)arg2);
5718          return 0;
5719       default:
5720          ((void) ((0) ? 0 : (__assert_fail ("0", "./bz2.c", 6428, "__PRETTY_FUNCTION__"), 0)));
5721    }
5722 }
5723
5724
5725 int main ( void )
5726 {
5727    int r;
5728    int bit;
5729    int i;
5730
5731    serviceFn = g_serviceFn;
5732
5733    set_inbuf();
5734    nIn = vex_strlen(inbuf)+1;
5735    vex_printf( "%d bytes read\n", nIn );
5736
5737    nZ = 1000000;
5738    r = BZ2_bzBuffToBuffCompress (
5739           zbuf, &nZ, inbuf, nIn, 9, 3 , 30 );
5740
5741    if (r != 0) {
5742      vex_printf("initial compress failed!\n");
5743      (*serviceFn)(0,0);
5744    }
5745    vex_printf( "%d after compression\n", nZ );
5746
5747    for (bit = 0; bit < nZ*8; bit += (bit < 35 ? 1 : 137)) {
5748
5749       flip_bit ( bit );
5750       nOut = (1000000 + 1000000);
5751       r = BZ2_bzBuffToBuffDecompress (
5752              outbuf, &nOut, zbuf, nZ, 1 , 0 );
5753
5754
5755       if (r != 0) {
5756
5757       } else {
5758          if (nOut != nIn) {
5759            vex_printf( "nIn/nOut mismatch %d %d\n", nIn, nOut );
5760            (*serviceFn)(0,0);
5761          } else {
5762            for (i = 0; i < nOut; i++)
5763              if (inbuf[i] != outbuf[i]) {
5764                 vex_printf( "mismatch at %d\n", i );
5765                 (*serviceFn)(0,0);
5766            }
5767            if (i == nOut) vex_printf( "really ok!\n" );
5768          }
5769       }
5770
5771       flip_bit ( bit );
5772    }
5773
5774    vex_printf( "all ok\n" );
5775    (*serviceFn)(0,0);
5776
5777    return 0;
5778 }