// File: /workspace/github_c_makefile_star2_O1/coapp-packages[P]bzip2/bzip2.c
// Function: main
IntNative main ( IntNative argc, Char *argv[] )
{
   Int32  i, j;
   Char   *tmp;
   Cell   *argList;
   Cell   *aa;
   Bool   decode;

   /*-- Be really really really paranoid :-) --*/
   if (sizeof(Int32) != 4 || sizeof(UInt32) != 4  ||
       sizeof(Int16) != 2 || sizeof(UInt16) != 2  ||
       sizeof(Char)  != 1 || sizeof(UChar)  != 1)
      configError();

   /*-- Initialise --*/
   outputHandleJustInCase  = NULL;
   smallMode               = False;
   keepInputFiles          = False;
   forceOverwrite          = False;
   noisy                   = True;
   verbosity               = 0;
   blockSize100k           = 9;
   testFailsExist          = False;
   unzFailsExist           = False;
   numFileNames            = 0;
   numFilesProcessed       = 0;
   workFactor              = 30;
   deleteOutputOnInterrupt = False;
   exitValue               = 0;
   i = j = 0; /* avoid bogus warning from egcs-1.1.X */

   /*-- Set up signal handlers for mem access errors --*/
   signal (SIGSEGV, mySIGSEGVorSIGBUScatcher);
#  if BZ_UNIX
#  ifndef __DJGPP__
   signal (SIGBUS,  mySIGSEGVorSIGBUScatcher);
#  endif
#  endif

   copyFileName ( inName,  (Char*)"(none)" );
   copyFileName ( outName, (Char*)"(none)" );

   copyFileName ( progNameReally, argv[0] );
   progName = &progNameReally[0];
   for (tmp = &progNameReally[0]; *tmp != '\0'; tmp++)
      if (*tmp == PATH_SEP) progName = tmp + 1;


   /*-- Copy flags from env var BZIP2, and 
        expand filename wildcards in arg list.
   --*/
   argList = NULL;
   addFlagsFromEnvVar ( &argList,  (Char*)"BZIP2" );
   addFlagsFromEnvVar ( &argList,  (Char*)"BZIP" );
   for (i = 1; i <= argc-1; i++)
      APPEND_FILESPEC(argList, argv[i]);


   /*-- Find the length of the longest filename --*/
   longestFileName = 7;
   numFileNames    = 0;
   decode          = True;
   for (aa = argList; aa != NULL; aa = aa->link) {
      if (ISFLAG("--")) { decode = False; continue; }
      if (aa->name[0] == '-' && decode) continue;
      numFileNames++;
      if (longestFileName < (Int32)strlen(aa->name) )
         longestFileName = (Int32)strlen(aa->name);
   }


   /*-- Determine source modes; flag handling may change this too. --*/
   if (numFileNames == 0)
      srcMode = SM_I2O; else srcMode = SM_F2F;


   /*-- Determine what to do (compress/uncompress/test/cat). --*/
   /*-- Note that subsequent flag handling may change this. --*/
   opMode = OM_Z;

   if ( (strstr ( progName, "unzip" ) != 0) ||
        (strstr ( progName, "UNZIP" ) != 0) )
      opMode = OM_UNZ;

   if ( (strstr ( progName, "z2cat" ) != 0) ||
        (strstr ( progName, "Z2CAT" ) != 0) ||
        (strstr ( progName, "zcat" ) != 0)  ||
        (strstr ( progName, "ZCAT" ) != 0) )  {
      opMode = OM_UNZ;
      srcMode = (numFileNames == 0) ? SM_I2O : SM_F2O;
   }


   /*-- Look at the flags. --*/
   for (aa = argList; aa != NULL; aa = aa->link) {
      if (ISFLAG("--")) break;
      if (aa->name[0] == '-' && aa->name[1] != '-') {
         for (j = 1; aa->name[j] != '\0'; j++) {
            switch (aa->name[j]) {
               case 'c': srcMode          = SM_F2O; break;
               case 'd': opMode           = OM_UNZ; break;
               case 'z': opMode           = OM_Z; break;
               case 'f': forceOverwrite   = True; break;
               case 't': opMode           = OM_TEST; break;
               case 'k': keepInputFiles   = True; break;
               case 's': smallMode        = True; break;
               case 'q': noisy            = False; break;
               case '1': blockSize100k    = 1; break;
               case '2': blockSize100k    = 2; break;
               case '3': blockSize100k    = 3; break;
               case '4': blockSize100k    = 4; break;
               case '5': blockSize100k    = 5; break;
               case '6': blockSize100k    = 6; break;
               case '7': blockSize100k    = 7; break;
               case '8': blockSize100k    = 8; break;
               case '9': blockSize100k    = 9; break;
               case 'V':
               case 'L': license();            break;
               case 'v': verbosity++; break;
               case 'h': usage ( progName );
                         exit ( 0 );
                         break;
               default:  fprintf ( stderr, "%s: Bad flag `%s'\n",
                                   progName, aa->name );
                         usage ( progName );
                         exit ( 1 );
                         break;
            }
         }
      }
   }
   
   /*-- And again ... --*/
   for (aa = argList; aa != NULL; aa = aa->link) {
      if (ISFLAG("--")) break;
      if (ISFLAG("--stdout"))            srcMode          = SM_F2O;  else
      if (ISFLAG("--decompress"))        opMode           = OM_UNZ;  else
      if (ISFLAG("--compress"))          opMode           = OM_Z;    else
      if (ISFLAG("--force"))             forceOverwrite   = True;    else
      if (ISFLAG("--test"))              opMode           = OM_TEST; else
      if (ISFLAG("--keep"))              keepInputFiles   = True;    else
      if (ISFLAG("--small"))             smallMode        = True;    else
      if (ISFLAG("--quiet"))             noisy            = False;   else
      if (ISFLAG("--version"))           license();                  else
      if (ISFLAG("--license"))           license();                  else
      if (ISFLAG("--exponential"))       workFactor = 1;             else 
      if (ISFLAG("--repetitive-best"))   redundant(aa->name);        else
      if (ISFLAG("--repetitive-fast"))   redundant(aa->name);        else
      if (ISFLAG("--fast"))              blockSize100k = 1;          else
      if (ISFLAG("--best"))              blockSize100k = 9;          else
      if (ISFLAG("--verbose"))           verbosity++;                else
      if (ISFLAG("--help"))              { usage ( progName ); exit ( 0 ); }
         else
         if (strncmp ( aa->name, "--", 2) == 0) {
            fprintf ( stderr, "%s: Bad flag `%s'\n", progName, aa->name );
            usage ( progName );
            exit ( 1 );
         }
   }

   if (verbosity > 4) verbosity = 4;
   if (opMode == OM_Z && smallMode && blockSize100k > 2) 
      blockSize100k = 2;

   if (opMode == OM_TEST && srcMode == SM_F2O) {
      fprintf ( stderr, "%s: -c and -t cannot be used together.\n",
                progName );
      exit ( 1 );
   }

   if (srcMode == SM_F2O && numFileNames == 0)
      srcMode = SM_I2O;

   if (opMode != OM_Z) blockSize100k = 0;

   if (srcMode == SM_F2F) {
      signal (SIGINT,  mySignalCatcher);
      signal (SIGTERM, mySignalCatcher);
#     if BZ_UNIX
      signal (SIGHUP,  mySignalCatcher);
#     endif
   }

   if (opMode == OM_Z) {
     if (srcMode == SM_I2O) {
        compress ( NULL );
     } else {
        decode = True;
        for (aa = argList; aa != NULL; aa = aa->link) {
           if (ISFLAG("--")) { decode = False; continue; }
           if (aa->name[0] == '-' && decode) continue;
           numFilesProcessed++;
           compress ( aa->name );
        }
     }
   } 
   else

   if (opMode == OM_UNZ) {
      unzFailsExist = False;
      if (srcMode == SM_I2O) {
         uncompress ( NULL );
      } else {
         decode = True;
         for (aa = argList; aa != NULL; aa = aa->link) {
            if (ISFLAG("--")) { decode = False; continue; }
            if (aa->name[0] == '-' && decode) continue;
            numFilesProcessed++;
            uncompress ( aa->name );
         }      
      }
      if (unzFailsExist) { 
         setExit(2); 
         exit(exitValue);
      }
   } 

   else {
      testFailsExist = False;
      if (srcMode == SM_I2O) {
         testf ( NULL );
      } else {
         decode = True;
         for (aa = argList; aa != NULL; aa = aa->link) {
	    if (ISFLAG("--")) { decode = False; continue; }
            if (aa->name[0] == '-' && decode) continue;
            numFilesProcessed++;
            testf ( aa->name );
	 }
      }
      if (testFailsExist && noisy) {
         fprintf ( stderr,
           "\n"
           "You can use the `bzip2recover' program to attempt to recover\n"
           "data from undamaged sections of corrupted files.\n\n"
         );
         setExit(2);
         exit(exitValue);
      }
   }

   /* Free the argument list memory to mollify leak detectors 
      (eg) Purify, Checker.  Serves no other useful purpose.
   */
   aa = argList;
   while (aa != NULL) {
      Cell* aa2 = aa->link;
      if (aa->name != NULL) free(aa->name);
      free(aa);
      aa = aa2;
   }

   return exitValue;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movq $0x0, 0x11c69(%rip) # 0x14dc0
xorl %eax, %eax
movb %al, 0x11c69(%rip)      # 0x14dc8
movb %al, 0x11c64(%rip)      # 0x14dc9
movb %al, 0x11c5f(%rip)      # 0x14dca
movb $0x1, 0x11c59(%rip)     # 0x14dcb
movl %eax, 0x11c54(%rip)     # 0x14dcc
movl $0x9, 0x11c4e(%rip)     # 0x14dd0
movb %al, 0x11c4c(%rip)      # 0x14dd4
movb %al, 0x11c47(%rip)      # 0x14dd5
movl %eax, 0x11c44(%rip)     # 0x14dd8
movl %eax, 0x11c42(%rip)     # 0x14ddc
movl $0x1e, 0x11c3c(%rip)    # 0x14de0
movb %al, 0x11c3a(%rip)      # 0x14de4
movl %eax, 0x11c38(%rip)     # 0x14de8
leaq 0x8e2(%rip), %r14       # 0x3a99
movl $0xb, %edi
movq %r14, %rsi
callq 0x2170
movl $0x7, %edi
movq %r14, %rsi
callq 0x2170
leaq 0x11c18(%rip), %rdi     # 0x14df0
leaq 0xbf1a(%rip), %r14      # 0xf0f9
movq %r14, %rsi
callq 0x3b15
leaq 0x12012(%rip), %rdi     # 0x15200
movq %r14, %rsi
callq 0x3b15
movq (%rbx), %rsi
leaq 0x12410(%rip), %r14     # 0x15610
movq %r14, %rdi
callq 0x3b15
movq %r14, 0x12811(%rip)     # 0x15a20
leaq 0x123fb(%rip), %rax     # 0x15611
movzbl -0x1(%rax), %ecx
cmpl $0x2f, %ecx
je 0x3225
testl %ecx, %ecx
jne 0x322c
jmp 0x3231
movq %rax, 0x127f4(%rip)     # 0x15a20
incq %rax
jmp 0x3216
movq %rsp, %r14
movq $0x0, (%r14)
leaq 0xbebe(%rip), %rsi      # 0xf100
movq %r14, %rdi
callq 0x3b57
leaq 0xbeb5(%rip), %rsi      # 0xf106
movq %r14, %rdi
callq 0x3b57
movq (%r14), %r14
cmpl $0x2, %ebp
jl 0x3281
movl %ebp, %r15d
movl $0x1, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
callq 0x3c2f
movq %rax, %r14
incq %r12
cmpq %r12, %r15
jne 0x326a
movq %r14, (%rsp)
movl $0x7, 0x12799(%rip)     # 0x15a28
movl $0x0, 0x11b3f(%rip)     # 0x14dd8
testq %r14, %r14
je 0x32ff
movl $0x7, %r12d
xorl %ebp, %ebp
movb $0x1, %r13b
leaq 0xbe5b(%rip), %rbx      # 0xf10b
movq (%r14), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2160
testl %eax, %eax
je 0x32f3
cmpb $0x2d, (%r15)
sete %al
testb %r13b, %r13b
setne %cl
testb %cl, %al
jne 0x32f6
incl %ebp
movl %ebp, 0x11afd(%rip)     # 0x14dd8
movq %r15, %rdi
callq 0x20f0
cmpl %eax, %r12d
jge 0x32f6
movl %eax, 0x1273a(%rip)     # 0x15a28
movl %eax, %r12d
jmp 0x32f6
xorl %r13d, %r13d
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x32b0
movl 0x11ad3(%rip), %ebp     # 0x14dd8
xorl %eax, %eax
testl %ebp, %ebp
setne %al
leal 0x1(%rax,%rax), %eax
movl %eax, 0x12716(%rip)     # 0x15a2c
movl $0x1, 0x12710(%rip)     # 0x15a30
movq 0x126f9(%rip), %rbx     # 0x15a20
leaq 0xbde0(%rip), %rsi      # 0xf10e
movq %rbx, %rdi
callq 0x2290
testq %rax, %rax
jne 0x334f
leaq 0xbdd2(%rip), %rsi      # 0xf114
movq %rbx, %rdi
callq 0x2290
testq %rax, %rax
je 0x3359
movl $0x2, 0x126d7(%rip)     # 0x15a30
leaq 0xbdba(%rip), %rsi      # 0xf11a
movq %rbx, %rdi
callq 0x2290
testq %rax, %rax
jne 0x33a9
leaq 0xbdac(%rip), %rsi      # 0xf120
movq %rbx, %rdi
callq 0x2290
testq %rax, %rax
jne 0x33a9
leaq 0xbd9e(%rip), %rsi      # 0xf126
movq %rbx, %rdi
callq 0x2290
testq %rax, %rax
jne 0x33a9
leaq 0xbd8f(%rip), %rsi      # 0xf12b
movq %rbx, %rdi
callq 0x2290
testq %rax, %rax
je 0x33c0
movl $0x2, %eax
movl %eax, 0x1267c(%rip)     # 0x15a30
cmpl $0x1, %ebp
sbbl $0x0, %eax
movl %eax, 0x1266c(%rip)     # 0x15a2c
movq (%rsp), %r15
testq %r15, %r15
je 0x3557
leaq 0xbd37(%rip), %rbx      # 0xf10b
leaq 0xbc29(%rip), %r12      # 0xf004
leaq 0xbc46(%rip), %r13      # 0xf028
movq (%r15), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2160
testl %eax, %eax
je 0x3557
cmpb $0x2d, (%r14)
jne 0x354a
cmpb $0x2d, 0x1(%r14)
je 0x354a
movl $0x1, %r14d
movq (%r15), %rdi
movzbl (%rdi,%r14), %eax
cmpl $0x55, %eax
jg 0x3444
leal -0x31(%rax), %ecx
cmpl $0x8, %ecx
ja 0x352b
movslq (%r12,%rcx,4), %rax
addq %r12, %rax
jmpq *%rax
movl $0x1, 0x11991(%rip)     # 0x14dd0
jmp 0x3523
leal -0x63(%rax), %ecx
cmpl $0x17, %ecx
ja 0x3532
movslq (%r13,%rcx,4), %rax
addq %r13, %rax
jmpq *%rax
movl $0x2, 0x125c8(%rip)     # 0x15a2c
jmp 0x3523
movb $0x1, 0x1195a(%rip)     # 0x14dca
jmp 0x3523
movl $0x1, 0x125b1(%rip)     # 0x15a30
jmp 0x3523
movb $0x1, 0x1193e(%rip)     # 0x14dc9
jmp 0x3523
movl $0x2, 0x12596(%rip)     # 0x15a30
jmp 0x3523
incl 0x11927(%rip)           # 0x14dcc
jmp 0x3523
movb $0x0, 0x1191d(%rip)     # 0x14dcb
jmp 0x3523
movb $0x1, 0x11911(%rip)     # 0x14dc8
jmp 0x3523
movl $0x3, 0x1256d(%rip)     # 0x15a30
jmp 0x3523
movl $0x5, 0x11901(%rip)     # 0x14dd0
jmp 0x3523
movl $0x3, 0x118f5(%rip)     # 0x14dd0
jmp 0x3523
movl $0x4, 0x118e9(%rip)     # 0x14dd0
jmp 0x3523
movl $0x8, 0x118dd(%rip)     # 0x14dd0
jmp 0x3523
movl $0x2, 0x118d1(%rip)     # 0x14dd0
jmp 0x3523
movl $0x6, 0x118c5(%rip)     # 0x14dd0
jmp 0x3523
movl $0x7, 0x118b9(%rip)     # 0x14dd0
jmp 0x3523
movl $0x9, 0x118ad(%rip)     # 0x14dd0
incq %r14
jmp 0x3413
cmpl $0x4c, %eax
je 0x353b
jmp 0x3542
cmpl $0x56, %eax
jne 0x3a6f
callq 0x22f4
jmp 0x3523
testl %eax, %eax
jne 0x3a6f
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x33e2
movq (%rsp), %r13
testq %r13, %r13
je 0x37e2
leaq 0xbba0(%rip), %rbx      # 0xf10b
leaq 0xbbd1(%rip), %r14      # 0xf143
leaq 0xbbd3(%rip), %r15      # 0xf14c
leaq 0xbbd9(%rip), %r12      # 0xf159
movq (%r13), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x2160
testl %eax, %eax
je 0x37e2
movq %rbp, %rdi
movq %r14, %rsi
callq 0x2160
testl %eax, %eax
je 0x372f
movq %rbp, %rdi
movq %r15, %rsi
callq 0x2160
testl %eax, %eax
je 0x373e
movq %rbp, %rdi
movq %r12, %rsi
callq 0x2160
testl %eax, %eax
je 0x374d
movq %rbp, %rdi
leaq 0xbb8a(%rip), %rsi      # 0xf164
callq 0x2160
testl %eax, %eax
je 0x3759
movq %rbp, %rdi
leaq 0xbb7b(%rip), %rsi      # 0xf16c
callq 0x2160
testl %eax, %eax
je 0x3762
movq %rbp, %rdi
leaq 0xbb6b(%rip), %rsi      # 0xf173
callq 0x2160
testl %eax, %eax
je 0x376e
movq %rbp, %rdi
leaq 0xbb5b(%rip), %rsi      # 0xf17a
callq 0x2160
testl %eax, %eax
je 0x3777
movq %rbp, %rdi
leaq 0xbb4c(%rip), %rsi      # 0xf182
callq 0x2160
testl %eax, %eax
je 0x3780
movq %rbp, %rdi
leaq 0xbb3d(%rip), %rsi      # 0xf18a
callq 0x2160
testl %eax, %eax
je 0x37b5
movq %rbp, %rdi
leaq 0xbb30(%rip), %rsi      # 0xf194
callq 0x2160
testl %eax, %eax
je 0x37bc
movq %rbp, %rdi
leaq 0xbb23(%rip), %rsi      # 0xf19e
callq 0x2160
testl %eax, %eax
je 0x3789
movq %rbp, %rdi
leaq 0xbb1a(%rip), %rsi      # 0xf1ac
callq 0x2160
testl %eax, %eax
je 0x37c3
movq %rbp, %rdi
leaq 0xbb15(%rip), %rsi      # 0xf1be
callq 0x2160
testl %eax, %eax
je 0x37cd
movq %rbp, %rdi
leaq 0xbb10(%rip), %rsi      # 0xf1d0
callq 0x2160
testl %eax, %eax
je 0x3795
movq %rbp, %rdi
leaq 0xbb00(%rip), %rsi      # 0xf1d7
callq 0x2160
testl %eax, %eax
je 0x37a1
movq %rbp, %rdi
leaq 0xbaf0(%rip), %rsi      # 0xf1de
callq 0x2160
testl %eax, %eax
je 0x37ad
movq %rbp, %rdi
leaq 0xbae3(%rip), %rsi      # 0xf1e8
callq 0x2160
testl %eax, %eax
je 0x3a74
movl $0x2, %edx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x2090
testl %eax, %eax
jne 0x37d5
jmp 0x3a91
movl $0x2, 0x122f3(%rip)     # 0x15a2c
jmp 0x37d5
movl $0x2, 0x122e8(%rip)     # 0x15a30
jmp 0x37d5
movl $0x1, 0x122d9(%rip)     # 0x15a30
jmp 0x37d5
movb $0x1, 0x1166a(%rip)     # 0x14dca
jmp 0x37d5
movl $0x3, 0x122c4(%rip)     # 0x15a30
jmp 0x37d5
movb $0x1, 0x11654(%rip)     # 0x14dc9
jmp 0x37d5
movb $0x1, 0x1164a(%rip)     # 0x14dc8
jmp 0x37d5
movb $0x0, 0x11644(%rip)     # 0x14dcb
jmp 0x37d5
movl $0x1, 0x1164d(%rip)     # 0x14de0
jmp 0x37d5
movl $0x1, 0x11631(%rip)     # 0x14dd0
jmp 0x37d5
movl $0x9, 0x11625(%rip)     # 0x14dd0
jmp 0x37d5
incl 0x11619(%rip)           # 0x14dcc
jmp 0x37d5
callq 0x23f0
jmp 0x37d5
callq 0x23cb
jmp 0x37d5
movq %rbp, %rdi
callq 0x23a9
jmp 0x37d5
movq %rbp, %rdi
callq 0x2387
movq 0x8(%r13), %r13
testq %r13, %r13
jne 0x3580
cmpl $0x5, 0x115e3(%rip)     # 0x14dcc
jl 0x37f5
movl $0x4, 0x115d7(%rip)     # 0x14dcc
movl 0x12235(%rip), %eax     # 0x15a30
cmpl $0x1, %eax
jne 0x381c
cmpb $0x0, 0x115c1(%rip)     # 0x14dc8
je 0x381c
cmpl $0x3, 0x115c0(%rip)     # 0x14dd0
jl 0x381c
movl $0x2, 0x115b4(%rip)     # 0x14dd0
movl %eax, %edx
xorl $0x3, %edx
movl 0x12205(%rip), %ecx     # 0x15a2c
movl %ecx, %esi
xorl $0x2, %esi
orl %edx, %esi
je 0x3a87
cmpl $0x2, %ecx
jne 0x384c
cmpl $0x0, 0x11598(%rip)     # 0x14dd8
jne 0x384c
movl $0x1, 0x121e0(%rip)     # 0x15a2c
cmpl $0x1, %eax
je 0x385b
movl $0x0, 0x11575(%rip)     # 0x14dd0
cmpl $0x3, 0x121ca(%rip)     # 0x15a2c
jne 0x3892
leaq 0x43f(%rip), %rbx       # 0x3caa
movl $0x2, %edi
movq %rbx, %rsi
callq 0x2170
movl $0xf, %edi
movq %rbx, %rsi
callq 0x2170
movl $0x1, %edi
movq %rbx, %rsi
callq 0x2170
movl 0x12198(%rip), %eax     # 0x15a30
cmpl $0x2, %eax
je 0x38b7
cmpl $0x1, %eax
jne 0x38d7
cmpl $0x1, 0x12183(%rip)     # 0x15a2c
jne 0x38f7
xorl %edi, %edi
callq 0x3cd4
jmp 0x3a30
movb $0x0, 0x11517(%rip)     # 0x14dd5
cmpl $0x1, 0x12167(%rip)     # 0x15a2c
jne 0x3951
xorl %edi, %edi
callq 0x4411
jmp 0x39a2
movb $0x0, 0x114f6(%rip)     # 0x14dd4
cmpl $0x1, 0x12147(%rip)     # 0x15a2c
jne 0x39cd
xorl %edi, %edi
callq 0x4bff
jmp 0x3a1e
movq (%rsp), %r15
testq %r15, %r15
je 0x3a30
movb $0x1, %bpl
leaq 0xb7fd(%rip), %rbx      # 0xf10b
movq (%r15), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2160
testl %eax, %eax
je 0x3941
cmpb $0x2d, (%r14)
sete %al
testb %bpl, %bpl
setne %cl
testb %cl, %al
jne 0x3943
incl 0x114a5(%rip)           # 0x14ddc
movq %r14, %rdi
callq 0x3cd4
jmp 0x3943
xorl %ebp, %ebp
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x390e
jmp 0x3a30
movq (%rsp), %r15
testq %r15, %r15
je 0x39a2
movb $0x1, %bpl
leaq 0xb7a7(%rip), %rbx      # 0xf10b
movq (%r15), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2160
testl %eax, %eax
je 0x3997
cmpb $0x2d, (%r14)
sete %al
testb %bpl, %bpl
setne %cl
testb %cl, %al
jne 0x3999
incl 0x1144f(%rip)           # 0x14ddc
movq %r14, %rdi
callq 0x4411
jmp 0x3999
xorl %ebp, %ebp
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x3964
cmpb $0x0, 0x1142c(%rip)     # 0x14dd5
je 0x3a30
cmpl $0x1, 0x11432(%rip)     # 0x14de8
jg 0x39c2
movl $0x2, 0x11426(%rip)     # 0x14de8
movl 0x11420(%rip), %edi     # 0x14de8
callq 0x2260
movq (%rsp), %r15
testq %r15, %r15
je 0x3a1e
movb $0x1, %bpl
leaq 0xb72b(%rip), %rbx      # 0xf10b
movq (%r15), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2160
testl %eax, %eax
je 0x3a13
cmpb $0x2d, (%r14)
sete %al
testb %bpl, %bpl
setne %cl
testb %cl, %al
jne 0x3a15
incl 0x113d3(%rip)           # 0x14ddc
movq %r14, %rdi
callq 0x4bff
jmp 0x3a15
xorl %ebp, %ebp
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x39e0
cmpb $0x0, 0x113af(%rip)     # 0x14dd4
je 0x3a30
cmpb $0x0, 0x1139d(%rip)     # 0x14dcb
jne 0x3a8c
movq (%rsp), %rbx
testq %rbx, %rbx
je 0x3a5a
movq (%rbx), %rdi
movq 0x8(%rbx), %r14
testq %rdi, %rdi
je 0x3a4a
callq 0x2050
movq %rbx, %rdi
callq 0x2050
movq %r14, %rbx
testq %r14, %r14
jne 0x3a39
movl 0x11388(%rip), %eax     # 0x14de8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2319
movq 0x11fa5(%rip), %rdi     # 0x15a20
callq 0x22c0
xorl %edi, %edi
callq 0x2260
callq 0x2450
callq 0x2415
movq %rbp, %rdi
callq 0x2350