// File: /workspace/github_c_makefile_star2_O0/coapp-packages[P]bzip2/bzip2recover.c
// Function: main
Int32 main ( Int32 argc, Char** argv )
{
   FILE*       inFile;
   FILE*       outFile;
   BitStream*  bsIn, *bsWr;
   Int32       b, wrBlock, currBlock, rbCtr;
   MaybeUInt64 bitsRead;

   UInt32      buffHi, buffLo, blockCRC;
   Char*       p;

   strcpy ( progName, argv[0] );
   inFileName[0] = outFileName[0] = 0;

   fprintf ( stderr, 
             "bzip2recover 1.0.6: extracts blocks from damaged .bz2 files.\n" );

   if (argc != 2) {
      fprintf ( stderr, "%s: usage is `%s damaged_file_name'.\n",
                        progName, progName );
      switch (sizeof(MaybeUInt64)) {
         case 8:
            fprintf(stderr, 
                    "\trestrictions on size of recovered file: None\n");
            break;
         case 4:
            fprintf(stderr, 
                    "\trestrictions on size of recovered file: 512 MB\n");
            fprintf(stderr, 
                    "\tto circumvent, recompile with MaybeUInt64 as an\n"
                    "\tunsigned 64-bit int.\n");
            break;
         default:
            fprintf(stderr, 
                    "\tsizeof(MaybeUInt64) is not 4 or 8 -- "
                    "configuration error.\n");
            break;
      }
      exit(1);
   }

   if (strlen(argv[1]) >= BZ_MAX_FILENAME-20) {
      fprintf ( stderr, 
                "%s: supplied filename is suspiciously (>= %d chars) long.  Bye!\n",
                progName, (int)strlen(argv[1]) );
      exit(1);
   }

   strcpy ( inFileName, argv[1] );

   inFile = fopen ( inFileName, "rb" );
   if (inFile == NULL) {
      fprintf ( stderr, "%s: can't read `%s'\n", progName, inFileName );
      exit(1);
   }

   bsIn = bsOpenReadStream ( inFile );
   fprintf ( stderr, "%s: searching for block boundaries ...\n", progName );

   bitsRead = 0;
   buffHi = buffLo = 0;
   currBlock = 0;
   bStart[currBlock] = 0;

   rbCtr = 0;

   while (True) {
      b = bsGetBit ( bsIn );
      bitsRead++;
      if (b == 2) {
         if (bitsRead >= bStart[currBlock] &&
            (bitsRead - bStart[currBlock]) >= 40) {
            bEnd[currBlock] = bitsRead-1;
            if (currBlock > 0)
               fprintf ( stderr, "   block %d runs from " MaybeUInt64_FMT 
                                 " to " MaybeUInt64_FMT " (incomplete)\n",
                         currBlock,  bStart[currBlock], bEnd[currBlock] );
         } else
            currBlock--;
         break;
      }
      buffHi = (buffHi << 1) | (buffLo >> 31);
      buffLo = (buffLo << 1) | (b & 1);
      if ( ( (buffHi & 0x0000ffff) == BLOCK_HEADER_HI 
             && buffLo == BLOCK_HEADER_LO)
           || 
           ( (buffHi & 0x0000ffff) == BLOCK_ENDMARK_HI 
             && buffLo == BLOCK_ENDMARK_LO)
         ) {
         if (bitsRead > 49) {
            bEnd[currBlock] = bitsRead-49;
         } else {
            bEnd[currBlock] = 0;
         }
         if (currBlock > 0 &&
	     (bEnd[currBlock] - bStart[currBlock]) >= 130) {
            fprintf ( stderr, "   block %d runs from " MaybeUInt64_FMT 
                              " to " MaybeUInt64_FMT "\n",
                      rbCtr+1,  bStart[currBlock], bEnd[currBlock] );
            rbStart[rbCtr] = bStart[currBlock];
            rbEnd[rbCtr] = bEnd[currBlock];
            rbCtr++;
         }
         if (currBlock >= BZ_MAX_HANDLED_BLOCKS)
            tooManyBlocks(BZ_MAX_HANDLED_BLOCKS);
         currBlock++;

         bStart[currBlock] = bitsRead;
      }
   }

   bsClose ( bsIn );

   /*-- identified blocks run from 1 to rbCtr inclusive. --*/

   if (rbCtr < 1) {
      fprintf ( stderr,
                "%s: sorry, I couldn't find any block boundaries.\n",
                progName );
      exit(1);
   };

   fprintf ( stderr, "%s: splitting into blocks\n", progName );

   inFile = fopen ( inFileName, "rb" );
   if (inFile == NULL) {
      fprintf ( stderr, "%s: can't open `%s'\n", progName, inFileName );
      exit(1);
   }
   bsIn = bsOpenReadStream ( inFile );

   /*-- placate gcc's dataflow analyser --*/
   blockCRC = 0; bsWr = 0;

   bitsRead = 0;
   outFile = NULL;
   wrBlock = 0;
   while (True) {
      b = bsGetBit(bsIn);
      if (b == 2) break;
      buffHi = (buffHi << 1) | (buffLo >> 31);
      buffLo = (buffLo << 1) | (b & 1);
      if (bitsRead == 47+rbStart[wrBlock]) 
         blockCRC = (buffHi << 16) | (buffLo >> 16);

      if (outFile != NULL && bitsRead >= rbStart[wrBlock]
                          && bitsRead <= rbEnd[wrBlock]) {
         bsPutBit ( bsWr, b );
      }

      bitsRead++;

      if (bitsRead == rbEnd[wrBlock]+1) {
         if (outFile != NULL) {
            bsPutUChar ( bsWr, 0x17 ); bsPutUChar ( bsWr, 0x72 );
            bsPutUChar ( bsWr, 0x45 ); bsPutUChar ( bsWr, 0x38 );
            bsPutUChar ( bsWr, 0x50 ); bsPutUChar ( bsWr, 0x90 );
            bsPutUInt32 ( bsWr, blockCRC );
            bsClose ( bsWr );
         }
         if (wrBlock >= rbCtr) break;
         wrBlock++;
      } else
      if (bitsRead == rbStart[wrBlock]) {
         /* Create the output file name, correctly handling leading paths. 
            (31.10.2001 by Sergey E. Kusikov) */
         Char* split;
         Int32 ofs, k;
         for (k = 0; k < BZ_MAX_FILENAME; k++) 
            outFileName[k] = 0;
         strcpy (outFileName, inFileName);
         split = strrchr (outFileName, BZ_SPLIT_SYM);
         if (split == NULL) {
            split = outFileName;
         } else {
            ++split;
	 }
	 /* Now split points to the start of the basename. */
         ofs  = split - outFileName;
         sprintf (split, "rec%5d", wrBlock+1);
         for (p = split; *p != 0; p++) if (*p == ' ') *p = '0';
         strcat (outFileName, inFileName + ofs);

         if ( !endsInBz2(outFileName)) strcat ( outFileName, ".bz2" );

         fprintf ( stderr, "   writing block %d to `%s' ...\n",
                           wrBlock+1, outFileName );

         outFile = fopen ( outFileName, "wb" );
         if (outFile == NULL) {
            fprintf ( stderr, "%s: can't write `%s'\n",
                      progName, outFileName );
            exit(1);
         }
         bsWr = bsOpenWriteStream ( outFile );
         bsPutUChar ( bsWr, BZ_HDR_B );    
         bsPutUChar ( bsWr, BZ_HDR_Z );    
         bsPutUChar ( bsWr, BZ_HDR_h );    
         bsPutUChar ( bsWr, BZ_HDR_0 + 9 );
         bsPutUChar ( bsWr, 0x31 ); bsPutUChar ( bsWr, 0x41 );
         bsPutUChar ( bsWr, 0x59 ); bsPutUChar ( bsWr, 0x26 );
         bsPutUChar ( bsWr, 0x53 ); bsPutUChar ( bsWr, 0x59 );
      }
   }

   fprintf ( stderr, "%s: finished\n", progName );
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x3e79(%rip), %rdi      # 0x50d0
callq 0x1050
movb $0x0, 0x463d(%rip)      # 0x58a0
movb $0x0, 0x4e06(%rip)      # 0x6070
movq 0x3d87(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1d89(%rip), %rsi      # 0x3004
movb $0x0, %al
callq 0x10a0
cmpl $0x2, -0x8(%rbp)
je 0x12cc
movq 0x3d69(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1da9(%rip), %rsi      # 0x3042
leaq 0x3e30(%rip), %rcx      # 0x50d0
movq %rcx, %rdx
movb $0x0, %al
callq 0x10a0
movq 0x3d47(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1dad(%rip), %rsi      # 0x3068
movb $0x0, %al
callq 0x10a0
movl $0x1, %edi
callq 0x1110
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1070
cmpq $0x7bc, %rax            # imm = 0x7BC
jb 0x1321
movq 0x3d10(%rip), %rax      # 0x4ff8
movq (%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1070
movq -0x78(%rbp), %rdi
movl %eax, %ecx
leaq 0x1d8e(%rip), %rsi      # 0x3097
leaq 0x3dc0(%rip), %rdx      # 0x50d0
movb $0x0, %al
callq 0x10a0
movl $0x1, %edi
callq 0x1110
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x4d40(%rip), %rdi      # 0x6070
callq 0x1050
leaq 0x4d34(%rip), %rdi      # 0x6070
leaq 0x1d95(%rip), %rsi      # 0x30d8
callq 0x10d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1383
movq 0x3c9e(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1d77(%rip), %rsi      # 0x30db
leaq 0x3d65(%rip), %rdx      # 0x50d0
leaq 0x4cfe(%rip), %rcx      # 0x6070
movb $0x0, %al
callq 0x10a0
movl $0x1, %edi
callq 0x1110
movq -0x18(%rbp), %rdi
callq 0x1ab0
movq %rax, -0x28(%rbp)
movq 0x3c61(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1d4f(%rip), %rsi      # 0x30f0
leaq 0x3d28(%rip), %rdx      # 0x50d0
movb $0x0, %al
callq 0x10a0
movq $0x0, -0x48(%rbp)
movl $0x0, -0x50(%rbp)
movl $0x0, -0x4c(%rbp)
movl $0x0, -0x3c(%rbp)
movslq -0x3c(%rbp), %rcx
leaq 0x5469(%rip), %rax      # 0x6840
movq $0x0, (%rax,%rcx,8)
movl $0x0, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1b10
movl %eax, -0x34(%rbp)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
cmpl $0x2, -0x34(%rbp)
jne 0x149c
movq -0x48(%rbp), %rax
movslq -0x3c(%rbp), %rdx
leaq 0x5429(%rip), %rcx      # 0x6840
cmpq (%rcx,%rdx,8), %rax
jb 0x148e
movq -0x48(%rbp), %rax
movslq -0x3c(%rbp), %rdx
leaq 0x5414(%rip), %rcx      # 0x6840
subq (%rcx,%rdx,8), %rax
cmpq $0x28, %rax
jb 0x148e
movq -0x48(%rbp), %rdx
subq $0x1, %rdx
movslq -0x3c(%rbp), %rcx
leaq 0x66e77(%rip), %rax     # 0x682c0
movq %rdx, (%rax,%rcx,8)
cmpl $0x0, -0x3c(%rbp)
jle 0x148c
movq 0x3b9e(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movl -0x3c(%rbp), %edx
movslq -0x3c(%rbp), %rcx
leaq 0x53d5(%rip), %rax      # 0x6840
movq (%rax,%rcx,8), %rcx
movslq -0x3c(%rbp), %rsi
leaq 0x66e46(%rip), %rax     # 0x682c0
movq (%rax,%rsi,8), %r8
leaq 0x1c93(%rip), %rsi      # 0x3118
movb $0x0, %al
callq 0x10a0
jmp 0x1497
movl -0x3c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x161a
movl -0x4c(%rbp), %eax
shll %eax
movl -0x50(%rbp), %ecx
shrl $0x1f, %ecx
orl %ecx, %eax
movl %eax, -0x4c(%rbp)
movl -0x50(%rbp), %eax
shll %eax
movl -0x34(%rbp), %ecx
andl $0x1, %ecx
orl %ecx, %eax
movl %eax, -0x50(%rbp)
movl -0x4c(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, %eax
cmpq $0x3141, %rax           # imm = 0x3141
jne 0x14d9
movl -0x50(%rbp), %eax
cmpq $0x59265359, %rax       # imm = 0x59265359
je 0x14fe
movl -0x4c(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, %eax
cmpq $0x1772, %rax           # imm = 0x1772
jne 0x1615
movl -0x50(%rbp), %eax
cmpq $0x45385090, %rax       # imm = 0x45385090
jne 0x1615
cmpq $0x31, -0x48(%rbp)
jbe 0x151e
movq -0x48(%rbp), %rdx
subq $0x31, %rdx
movslq -0x3c(%rbp), %rcx
leaq 0x66da8(%rip), %rax     # 0x682c0
movq %rdx, (%rax,%rcx,8)
jmp 0x1531
movslq -0x3c(%rbp), %rcx
leaq 0x66d97(%rip), %rax     # 0x682c0
movq $0x0, (%rax,%rcx,8)
cmpl $0x0, -0x3c(%rbp)
jle 0x15e6
movslq -0x3c(%rbp), %rcx
leaq 0x66d7a(%rip), %rax     # 0x682c0
movq (%rax,%rcx,8), %rax
movslq -0x3c(%rbp), %rdx
leaq 0x52eb(%rip), %rcx      # 0x6840
subq (%rcx,%rdx,8), %rax
cmpq $0x82, %rax
jb 0x15e6
movq 0x3a8c(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movl -0x40(%rbp), %edx
addl $0x1, %edx
movslq -0x3c(%rbp), %rcx
leaq 0x52c0(%rip), %rax      # 0x6840
movq (%rax,%rcx,8), %rcx
movslq -0x3c(%rbp), %rsi
leaq 0x66d31(%rip), %rax     # 0x682c0
movq (%rax,%rsi,8), %r8
leaq 0x1bad(%rip), %rsi      # 0x3147
movb $0x0, %al
callq 0x10a0
movslq -0x3c(%rbp), %rcx
leaq 0x5294(%rip), %rax      # 0x6840
movq (%rax,%rcx,8), %rdx
movslq -0x40(%rbp), %rcx
leaq 0xc8785(%rip), %rax     # 0xc9d40
movq %rdx, (%rax,%rcx,8)
movslq -0x3c(%rbp), %rcx
leaq 0x66cf6(%rip), %rax     # 0x682c0
movq (%rax,%rcx,8), %rdx
movslq -0x40(%rbp), %rcx
leaq 0x12a1e7(%rip), %rax    # 0x12b7c0
movq %rdx, (%rax,%rcx,8)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
cmpl $0xc350, -0x3c(%rbp)    # imm = 0xC350
jl 0x15f9
movl $0xc350, %edi           # imm = 0xC350
callq 0x1bb0
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
movq -0x48(%rbp), %rdx
movslq -0x3c(%rbp), %rcx
leaq 0x522f(%rip), %rax      # 0x6840
movq %rdx, (%rax,%rcx,8)
jmp 0x13e6
movq -0x28(%rbp), %rdi
callq 0x1c30
cmpl $0x1, -0x40(%rbp)
jge 0x1652
movq 0x39c8(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1b2f(%rip), %rsi      # 0x3169
leaq 0x3a8f(%rip), %rdx      # 0x50d0
movb $0x0, %al
callq 0x10a0
movl $0x1, %edi
callq 0x1110
movq 0x399f(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1b38(%rip), %rsi      # 0x319b
leaq 0x3a66(%rip), %rdx      # 0x50d0
movb $0x0, %al
callq 0x10a0
leaq 0x49f8(%rip), %rdi      # 0x6070
leaq 0x1a59(%rip), %rsi      # 0x30d8
callq 0x10d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x16bf
movq 0x3962(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1b16(%rip), %rsi      # 0x31b6
leaq 0x3a29(%rip), %rdx      # 0x50d0
leaq 0x49c2(%rip), %rcx      # 0x6070
movb $0x0, %al
callq 0x10a0
movl $0x1, %edi
callq 0x1110
movq -0x18(%rbp), %rdi
callq 0x1ab0
movq %rax, -0x28(%rbp)
movl $0x0, -0x54(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1b10
movl %eax, -0x34(%rbp)
cmpl $0x2, -0x34(%rbp)
jne 0x1709
jmp 0x1a85
movl -0x4c(%rbp), %eax
shll %eax
movl -0x50(%rbp), %ecx
shrl $0x1f, %ecx
orl %ecx, %eax
movl %eax, -0x4c(%rbp)
movl -0x50(%rbp), %eax
shll %eax
movl -0x34(%rbp), %ecx
andl $0x1, %ecx
orl %ecx, %eax
movl %eax, -0x50(%rbp)
movq -0x48(%rbp), %rax
movslq -0x38(%rbp), %rdx
leaq 0xc8608(%rip), %rcx     # 0xc9d40
movq (%rcx,%rdx,8), %rcx
addq $0x2f, %rcx
cmpq %rcx, %rax
jne 0x1756
movl -0x4c(%rbp), %eax
shll $0x10, %eax
movl -0x50(%rbp), %ecx
shrl $0x10, %ecx
orl %ecx, %eax
movl %eax, -0x54(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1793
movq -0x48(%rbp), %rax
movslq -0x38(%rbp), %rdx
leaq 0xc85d4(%rip), %rcx     # 0xc9d40
cmpq (%rcx,%rdx,8), %rax
jb 0x1793
movq -0x48(%rbp), %rax
movslq -0x38(%rbp), %rdx
leaq 0x12a03f(%rip), %rcx    # 0x12b7c0
cmpq (%rcx,%rdx,8), %rax
ja 0x1793
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x1d10
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movslq -0x38(%rbp), %rdx
leaq 0x12a012(%rip), %rcx    # 0x12b7c0
movq (%rcx,%rdx,8), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jne 0x184a
cmpq $0x0, -0x20(%rbp)
je 0x182f
movq -0x30(%rbp), %rdi
movl $0x17, %esi
callq 0x1db0
movq -0x30(%rbp), %rdi
movl $0x72, %esi
callq 0x1db0
movq -0x30(%rbp), %rdi
movl $0x45, %esi
callq 0x1db0
movq -0x30(%rbp), %rdi
movl $0x38, %esi
callq 0x1db0
movq -0x30(%rbp), %rdi
movl $0x50, %esi
callq 0x1db0
movq -0x30(%rbp), %rdi
movl $0x90, %esi
callq 0x1db0
movq -0x30(%rbp), %rdi
movl -0x54(%rbp), %esi
callq 0x1e00
movq -0x30(%rbp), %rdi
callq 0x1c30
movl -0x38(%rbp), %eax
cmpl -0x40(%rbp), %eax
jl 0x183c
jmp 0x1a85
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x1a80
movq -0x48(%rbp), %rax
movslq -0x38(%rbp), %rdx
leaq 0xc84e7(%rip), %rcx     # 0xc9d40
cmpq (%rcx,%rdx,8), %rax
jne 0x1a7e
movl $0x0, -0x70(%rbp)
cmpl $0x7d0, -0x70(%rbp)     # imm = 0x7D0
jge 0x188d
movslq -0x70(%rbp), %rcx
leaq 0x4022(%rip), %rax      # 0x58a0
movb $0x0, (%rax,%rcx)
movl -0x70(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x70(%rbp)
jmp 0x186a
leaq 0x400c(%rip), %rdi      # 0x58a0
leaq 0x47d5(%rip), %rsi      # 0x6070
callq 0x1050
leaq 0x3ff9(%rip), %rdi      # 0x58a0
movl $0x2f, %esi
callq 0x1080
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
jne 0x18c9
leaq 0x3fdd(%rip), %rax      # 0x58a0
movq %rax, -0x68(%rbp)
jmp 0x18d5
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
leaq 0x3fc0(%rip), %rcx      # 0x58a0
subq %rcx, %rax
movl %eax, -0x6c(%rbp)
movq -0x68(%rbp), %rdi
movl -0x38(%rbp), %edx
addl $0x1, %edx
leaq 0x18d4(%rip), %rsi      # 0x31cb
movb $0x0, %al
callq 0x1100
movq -0x68(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1935
movq -0x60(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x1925
movq -0x60(%rbp), %rax
movb $0x30, (%rax)
jmp 0x1927
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x1906
movslq -0x6c(%rbp), %rax
leaq 0x4730(%rip), %rsi      # 0x6070
addq %rax, %rsi
leaq 0x3f56(%rip), %rdi      # 0x58a0
callq 0x10f0
leaq 0x3f4a(%rip), %rdi      # 0x58a0
callq 0x1e50
cmpb $0x0, %al
jne 0x1972
leaq 0x3f3a(%rip), %rdi      # 0x58a0
leaq 0x1865(%rip), %rsi      # 0x31d2
callq 0x10f0
movq 0x367f(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movl -0x38(%rbp), %edx
addl $0x1, %edx
leaq 0x184e(%rip), %rsi      # 0x31d7
leaq 0x3f10(%rip), %rcx      # 0x58a0
movb $0x0, %al
callq 0x10a0
leaq 0x3f02(%rip), %rdi      # 0x58a0
leaq 0x1853(%rip), %rsi      # 0x31f8
callq 0x10d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x19e5
movq 0x363c(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1835(%rip), %rsi      # 0x31fb
leaq 0x3703(%rip), %rdx      # 0x50d0
leaq 0x3ecc(%rip), %rcx      # 0x58a0
movb $0x0, %al
callq 0x10a0
movl $0x1, %edi
callq 0x1110
movq -0x20(%rbp), %rdi
callq 0x1f00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl $0x42, %esi
callq 0x1db0
movq -0x30(%rbp), %rdi
movl $0x5a, %esi
callq 0x1db0
movq -0x30(%rbp), %rdi
movl $0x68, %esi
callq 0x1db0
movq -0x30(%rbp), %rdi
movl $0x39, %esi
callq 0x1db0
movq -0x30(%rbp), %rdi
movl $0x31, %esi
callq 0x1db0
movq -0x30(%rbp), %rdi
movl $0x41, %esi
callq 0x1db0
movq -0x30(%rbp), %rdi
movl $0x59, %esi
callq 0x1db0
movq -0x30(%rbp), %rdi
movl $0x26, %esi
callq 0x1db0
movq -0x30(%rbp), %rdi
movl $0x53, %esi
callq 0x1db0
movq -0x30(%rbp), %rdi
movl $0x59, %esi
callq 0x1db0
jmp 0x1a80
jmp 0x16f2
movq 0x356c(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x177b(%rip), %rsi      # 0x3211
leaq 0x3633(%rip), %rdx      # 0x50d0
movb $0x0, %al
callq 0x10a0
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
nop