// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, 0x11a11(%rip)     # 0x12da0
movq %rsi, %r14
movl %edi, %r12d
xorl %eax, %eax
movb %al, 0x11a0b(%rip)      # 0x12da8
movb %al, 0x11a06(%rip)      # 0x12da9
andl $0x0, 0x11a02(%rip)     # 0x12dac
movb %al, 0x119fa(%rip)      # 0x12daa
movb $0x1, 0x119f4(%rip)     # 0x12dab
movl $0x9, 0x119ef(%rip)     # 0x12db0
movb %al, 0x119ed(%rip)      # 0x12db4
movb %al, 0x119e8(%rip)      # 0x12db5
andl $0x0, 0x119e4(%rip)     # 0x12db8
andl $0x0, 0x119e1(%rip)     # 0x12dbc
movl $0x1e, 0x119db(%rip)    # 0x12dc0
movb %al, 0x119d9(%rip)      # 0x12dc4
andl $0x0, 0x119d6(%rip)     # 0x12dc8
leaq 0x88a(%rip), %rbx       # 0x1c83
pushq $0xb
popq %rdi
movq %rbx, %rsi
callq 0x1150
pushq $0x7
popq %rbp
movl %ebp, %edi
movq %rbx, %rsi
callq 0x1150
leaq 0x119b8(%rip), %rdi     # 0x12dd0
leaq 0xbcda(%rip), %rbx      # 0xd0f9
movq %rbx, %rsi
callq 0x1cd8
leaq 0x11db2(%rip), %rdi     # 0x131e0
movq %rbx, %rsi
callq 0x1cd8
movq (%r14), %rsi
leaq 0x121b0(%rip), %rbx     # 0x135f0
movq %rbx, %rdi
callq 0x1cd8
movq %rbx, 0x125b1(%rip)     # 0x13a00
leaq 0x1219b(%rip), %rax     # 0x135f1
movzbl -0x1(%rax), %ecx
cmpl $0x2f, %ecx
je 0x1465
testl %ecx, %ecx
jne 0x146c
jmp 0x1471
movq %rax, 0x12594(%rip)     # 0x13a00
incq %rax
jmp 0x1456
movq %rsp, %rbx
andq $0x0, (%rbx)
leaq 0xbc81(%rip), %rsi      # 0xd100
movq %rbx, %rdi
callq 0x1d4e
leaq 0xbc78(%rip), %rsi      # 0xd106
movq %rbx, %rdi
callq 0x1d4e
movq (%rbx), %r15
movslq %r12d, %rbx
pushq $0x1
popq %r12
cmpq %rbx, %r12
jge 0x14b9
movq (%r14,%r12,8), %rsi
movq %r15, %rdi
callq 0x1e30
movq %rax, %r15
incq %r12
jmp 0x14a0
movq %r15, (%rsp)
andl $0x0, 0x118f4(%rip)     # 0x12db8
movl $0x7, 0x1253a(%rip)     # 0x13a08
movb $0x1, %r14b
xorl %ebx, %ebx
movq %r15, %r12
testq %r12, %r12
je 0x151a
movq (%r12), %rdi
cmpb $0x2d, (%rdi)
jne 0x14f5
cmpb $0x2d, 0x1(%rdi)
jne 0x14f0
cmpb $0x0, 0x2(%rdi)
je 0x1510
testb %r14b, %r14b
jne 0x1513
incl %ebx
movl %ebx, 0x118bb(%rip)     # 0x12db8
callq 0x10e0
cmpl %eax, %ebp
jge 0x1513
movl %eax, 0x124fc(%rip)     # 0x13a08
movl %eax, %ebp
jmp 0x1513
xorl %r14d, %r14d
movq 0x8(%r12), %r12
jmp 0x14d6
xorl %eax, %eax
testl %ebx, %ebx
setne %al
leal 0x1(%rax,%rax), %eax
movl %eax, 0x124e1(%rip)     # 0x13a0c
movl $0x1, 0x124db(%rip)     # 0x13a10
movq 0x124c4(%rip), %r14     # 0x13a00
leaq 0xbbc8(%rip), %rsi      # 0xd10b
movq %r14, %rdi
callq 0x1260
testq %rax, %rax
jne 0x1564
leaq 0xbbba(%rip), %rsi      # 0xd111
movq %r14, %rdi
callq 0x1260
testq %rax, %rax
je 0x156e
movl $0x2, 0x124a2(%rip)     # 0x13a10
leaq 0xbba2(%rip), %rsi      # 0xd117
movq %r14, %rdi
callq 0x1260
pushq $0x2
popq %rbp
testq %rax, %rax
jne 0x15c1
leaq 0xbb91(%rip), %rsi      # 0xd11d
movq %r14, %rdi
callq 0x1260
testq %rax, %rax
jne 0x15c1
leaq 0xbb83(%rip), %rsi      # 0xd123
movq %r14, %rdi
callq 0x1260
testq %rax, %rax
jne 0x15c1
leaq 0xbb74(%rip), %rsi      # 0xd128
movq %r14, %rdi
callq 0x1260
testq %rax, %rax
je 0x15d5
movl %ebp, 0x12449(%rip)     # 0x13a10
cmpl $0x1, %ebx
movl %ebp, %eax
sbbl $0x0, %eax
movl %eax, 0x12437(%rip)     # 0x13a0c
pushq $0x2
popq %r14
leaq 0xba24(%rip), %r12      # 0xd004
leaq 0xba41(%rip), %r13      # 0xd028
movq %r15, %rbx
pushq $0x1
popq %rbp
testq %rbx, %rbx
je 0x1758
movq (%rbx), %rcx
cmpb $0x2d, (%rcx)
jne 0x174f
cmpb $0x2d, 0x1(%rcx)
jne 0x1612
cmpb $0x0, 0x2(%rcx)
je 0x1758
movb 0x1(%rcx), %al
cmpb $0x2d, %al
je 0x174f
movq %r14, %rbp
movzbl %al, %eax
leal -0x63(%rax), %edx
cmpl $0x17, %edx
jbe 0x164b
leal -0x31(%rax), %edx
cmpl $0x8, %edx
ja 0x1664
movslq (%r12,%rdx,4), %rax
addq %r12, %rax
jmpq *%rax
movl $0x1, 0x1176a(%rip)     # 0x12db0
jmp 0x173c
movslq (%r13,%rdx,4), %rax
addq %r13, %rax
jmpq *%rax
movl $0x2, 0x123ad(%rip)     # 0x13a0c
jmp 0x173c
cmpl $0x4c, %eax
je 0x1672
cmpl $0x56, %eax
jne 0x1747
callq 0x1e96
movq (%rbx), %rcx
jmp 0x173c
movb $0x0, 0x11725(%rip)     # 0x12dab
jmp 0x173c
movb $0x1, 0x11716(%rip)     # 0x12da8
jmp 0x173c
movb $0x1, 0x1170b(%rip)     # 0x12da9
jmp 0x173c
incl 0x11703(%rip)           # 0x12dac
jmp 0x173c
movb $0x1, 0x116f5(%rip)     # 0x12daa
jmp 0x173c
movl $0x2, 0x1234c(%rip)     # 0x13a10
jmp 0x173c
movl $0x3, 0x12340(%rip)     # 0x13a10
jmp 0x173c
movl $0x1, 0x12334(%rip)     # 0x13a10
jmp 0x173c
movl $0x5, 0x116c8(%rip)     # 0x12db0
jmp 0x173c
movl $0x3, 0x116bc(%rip)     # 0x12db0
jmp 0x173c
movl $0x4, 0x116b0(%rip)     # 0x12db0
jmp 0x173c
movl $0x8, 0x116a4(%rip)     # 0x12db0
jmp 0x173c
movl $0x2, 0x11698(%rip)     # 0x12db0
jmp 0x173c
movl $0x6, 0x1168c(%rip)     # 0x12db0
jmp 0x173c
movl $0x7, 0x11680(%rip)     # 0x12db0
jmp 0x173c
movl $0x9, 0x11674(%rip)     # 0x12db0
movb (%rcx,%rbp), %al
incq %rbp
jmp 0x1620
testl %eax, %eax
jne 0x1bff
movq 0x8(%rbx), %rbx
jmp 0x15ea
movq %r15, %r12
testq %r12, %r12
je 0x19b5
movq (%r12), %r14
movb (%r14), %r13b
cmpb $0x2d, %r13b
jne 0x1783
cmpb $0x2d, 0x1(%r14)
jne 0x1783
cmpb $0x0, 0x2(%r14)
je 0x19b5
leaq 0xb9b6(%rip), %rsi      # 0xd140
movq %r14, %rdi
callq 0x1140
testl %eax, %eax
je 0x191c
leaq 0xb9a8(%rip), %rsi      # 0xd149
movq %r14, %rdi
callq 0x1140
testl %eax, %eax
je 0x1928
leaq 0xb99e(%rip), %rsi      # 0xd156
movq %r14, %rdi
callq 0x1140
testl %eax, %eax
je 0x1934
leaq 0xb992(%rip), %rsi      # 0xd161
movq %r14, %rdi
callq 0x1140
testl %eax, %eax
je 0x1940
leaq 0xb983(%rip), %rsi      # 0xd169
movq %r14, %rdi
callq 0x1140
testl %eax, %eax
je 0x1949
leaq 0xb973(%rip), %rsi      # 0xd170
movq %r14, %rdi
callq 0x1140
testl %eax, %eax
je 0x1955
leaq 0xb963(%rip), %rsi      # 0xd177
movq %r14, %rdi
callq 0x1140
testl %eax, %eax
je 0x195e
leaq 0xb954(%rip), %rsi      # 0xd17f
movq %r14, %rdi
callq 0x1140
testl %eax, %eax
je 0x196e
leaq 0xb945(%rip), %rsi      # 0xd187
movq %r14, %rdi
callq 0x1140
testl %eax, %eax
je 0x1967
leaq 0xb938(%rip), %rsi      # 0xd191
movq %r14, %rdi
callq 0x1140
testl %eax, %eax
je 0x1967
leaq 0xb92b(%rip), %rsi      # 0xd19b
movq %r14, %rdi
callq 0x1140
testl %eax, %eax
je 0x1989
leaq 0xb922(%rip), %rsi      # 0xd1a9
movq %r14, %rdi
callq 0x1140
testl %eax, %eax
je 0x197f
leaq 0xb91d(%rip), %rsi      # 0xd1bb
movq %r14, %rdi
callq 0x1140
testl %eax, %eax
je 0x197f
leaq 0xb918(%rip), %rsi      # 0xd1cd
movq %r14, %rdi
callq 0x1140
testl %eax, %eax
je 0x1995
leaq 0xb908(%rip), %rsi      # 0xd1d4
movq %r14, %rdi
callq 0x1140
testl %eax, %eax
je 0x19a1
leaq 0xb8f8(%rip), %rsi      # 0xd1db
movq %r14, %rdi
callq 0x1140
testl %eax, %eax
je 0x19ad
leaq 0xb8eb(%rip), %rsi      # 0xd1e5
movq %r14, %rdi
callq 0x1140
testl %eax, %eax
je 0x1c32
cmpb $0x2d, %r13b
jne 0x1975
cmpb $0x2d, 0x1(%r14)
jne 0x1975
jmp 0x1c66
movl $0x2, 0x120e6(%rip)     # 0x13a0c
jmp 0x1975
movl $0x2, 0x120de(%rip)     # 0x13a10
jmp 0x1975
movl $0x1, 0x120d2(%rip)     # 0x13a10
jmp 0x1975
movb $0x1, 0x11463(%rip)     # 0x12daa
jmp 0x1975
movl $0x3, 0x120bd(%rip)     # 0x13a10
jmp 0x1975
movb $0x1, 0x1144d(%rip)     # 0x12da9
jmp 0x1975
movb $0x1, 0x11443(%rip)     # 0x12da8
jmp 0x1975
callq 0x1e96
jmp 0x1975
movb $0x0, 0x11436(%rip)     # 0x12dab
movq 0x8(%r12), %r12
jmp 0x175b
movq %r14, %rdi
callq 0x1eef
jmp 0x1975
movl $0x1, 0x1142d(%rip)     # 0x12dc0
jmp 0x1975
movl $0x1, 0x11411(%rip)     # 0x12db0
jmp 0x1975
movl $0x9, 0x11405(%rip)     # 0x12db0
jmp 0x1975
incl 0x113f9(%rip)           # 0x12dac
jmp 0x1975
cmpl $0x5, 0x113f0(%rip)     # 0x12dac
jl 0x19c8
movl $0x4, 0x113e4(%rip)     # 0x12dac
movl 0x12042(%rip), %eax     # 0x13a10
cmpl $0x1, %eax
jne 0x19ef
cmpb $0x0, 0x113ce(%rip)     # 0x12da8
je 0x19ef
cmpl $0x3, 0x113cd(%rip)     # 0x12db0
jl 0x19ef
movl $0x2, 0x113c1(%rip)     # 0x12db0
movl %eax, %edx
xorl $0x3, %edx
movl 0x12012(%rip), %ecx     # 0x13a0c
movl %ecx, %esi
xorl $0x2, %esi
orl %edx, %esi
je 0x1c45
cmpl $0x2, %ecx
jne 0x1a21
cmpl $0x0, 0x113a5(%rip)     # 0x12db8
jne 0x1a21
movl $0x1, 0x11fed(%rip)     # 0x13a0c
movl %ebp, %ecx
cmpl $0x1, %eax
je 0x1a2d
andl $0x0, 0x11383(%rip)     # 0x12db0
cmpl $0x3, %ecx
jne 0x1a60
leaq 0x4d8(%rip), %r14       # 0x1f11
pushq $0x2
popq %rdi
movq %r14, %rsi
callq 0x1150
pushq $0xf
popq %rdi
movq %r14, %rsi
callq 0x1150
pushq $0x1
popq %rdi
movq %r14, %rsi
callq 0x1150
movl 0x11fb0(%rip), %eax     # 0x13a10
cmpl $0x2, %eax
je 0x1a83
cmpl $0x1, %eax
jne 0x1aad
cmpl $0x1, 0x11f9b(%rip)     # 0x13a0c
jne 0x1b1b
xorl %edi, %edi
callq 0x1f39
jmp 0x1b6b
movb $0x0, 0x1132b(%rip)     # 0x12db5
cmpl $0x1, 0x11f7b(%rip)     # 0x13a0c
jne 0x1b85
xorl %edi, %edi
callq 0x27c0
cmpb $0x0, 0x11310(%rip)     # 0x12db5
je 0x1b6b
jmp 0x1afe
movb $0x0, 0x11300(%rip)     # 0x12db4
cmpl $0x1, 0x11f51(%rip)     # 0x13a0c
jne 0x1bc2
xorl %edi, %edi
callq 0x3198
cmpb $0x0, 0x112e5(%rip)     # 0x12db4
je 0x1b6b
cmpb $0x0, 0x112cf(%rip)     # 0x12dab
je 0x1b6b
movq 0x1050f(%rip), %rax     # 0x11ff8
movq (%rax), %rcx
leaq 0xc0a9(%rip), %rdi      # 0xdb9c
pushq $0x70
popq %rsi
pushq $0x1
popq %rdx
callq 0x1240
movl 0x112c4(%rip), %edi     # 0x12dc8
cmpl $0x1, %edi
jg 0x1b16
movl $0x2, 0x112b5(%rip)     # 0x12dc8
pushq $0x2
popq %rdi
callq 0x1230
movb $0x1, %bpl
movq %r15, %rbx
testq %rbx, %rbx
je 0x1b6b
movq (%rbx), %rdi
cmpb $0x2d, (%rdi)
jne 0x1b3f
cmpb $0x2d, 0x1(%rdi)
jne 0x1b3a
cmpb $0x0, 0x2(%rdi)
je 0x1b50
testb %bpl, %bpl
jne 0x1b4a
incl 0x11277(%rip)           # 0x12dbc
callq 0x1f39
movq 0x8(%rbx), %rbx
jmp 0x1b21
xorl %ebp, %ebp
jmp 0x1b4a
movq (%r15), %rdi
movq 0x8(%r15), %rbx
callq 0x1050
movq %r15, %rdi
callq 0x1050
movq %rbx, %r15
testq %r15, %r15
jne 0x1b54
movl 0x11252(%rip), %eax     # 0x12dc8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %bpl
movq %r15, %rbx
testq %rbx, %rbx
je 0x1a9e
movq (%rbx), %rdi
cmpb $0x2d, (%rdi)
jne 0x1bad
cmpb $0x2d, 0x1(%rdi)
jne 0x1ba8
cmpb $0x0, 0x2(%rdi)
je 0x1bbe
testb %bpl, %bpl
jne 0x1bb8
incl 0x11209(%rip)           # 0x12dbc
callq 0x27c0
movq 0x8(%rbx), %rbx
jmp 0x1b8b
xorl %ebp, %ebp
jmp 0x1bb8
movb $0x1, %bpl
movq %r15, %rbx
testq %rbx, %rbx
je 0x1ac8
movq (%rbx), %rdi
cmpb $0x2d, (%rdi)
jne 0x1bea
cmpb $0x2d, 0x1(%rdi)
jne 0x1be5
cmpb $0x0, 0x2(%rdi)
je 0x1bfb
testb %bpl, %bpl
jne 0x1bf5
incl 0x111cc(%rip)           # 0x12dbc
callq 0x3198
movq 0x8(%rbx), %rbx
jmp 0x1bc8
xorl %ebp, %ebp
jmp 0x1bf5
movq 0x103f2(%rip), %rax     # 0x11ff8
movq (%rax), %rdi
movq 0x11df0(%rip), %rdx     # 0x13a00
leaq 0xb516(%rip), %rsi      # 0xd12d
xorl %eax, %eax
callq 0x1160
movq 0x11ddb(%rip), %rdi     # 0x13a00
callq 0x1ebb
pushq $0x1
popq %rdi
callq 0x1230
movq 0x11dc7(%rip), %rdi     # 0x13a00
callq 0x1ebb
xorl %edi, %edi
callq 0x1230
movq 0x103ac(%rip), %rax     # 0x11ff8
movq (%rax), %rdi
movq 0x11daa(%rip), %rdx     # 0x13a00
leaq 0xb58f(%rip), %rsi      # 0xd1ec
xorl %eax, %eax
callq 0x1160
jmp 0x1c2a
movq 0x1038b(%rip), %rax     # 0x11ff8
movq (%rax), %rdi
movq 0x11d89(%rip), %rdx     # 0x13a00
leaq 0xb4af(%rip), %rsi      # 0xd12d
movq %r14, %rcx
jmp 0x1c17