// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DAScover.c
// Function: main
int main(int argc, char *argv[])
{ char  *root, *dpwd;
  int64  novl, hgap64;
  int    c;

  DAZZ_EXTRA ex_covr, ex_hgap;

  //  Process arguments

  { int  i, j, k;
    int  flags[128];
    char *eptr;
    int   mmax;

    ARG_INIT("DAScover")

    HGAP_MIN = 0;
    NUM_MASK = 0;

    mmax  = 10;
    MASKS = (Mask *) Malloc(mmax*sizeof(Mask),"Allocating mask array");
    if (MASKS == NULL)
      exit (1);

    j = 1;
    for (i = 1; i < argc; i++)
      if (argv[i][0] == '-')
        switch (argv[i][1])
        { default:
            ARG_FLAGS("v")
            break;
          case 'm':
            if (NUM_MASK >= mmax)
              { mmax  = 1.2*NUM_MASK + 10;
                MASKS = (Mask *) Realloc(MASKS,mmax*sizeof(Mask),"Reallocating mask array");
                if (MASKS == NULL)
                  exit (1);
              }
            MASKS[NUM_MASK++].name = argv[i]+2;
            break;
          case 'H':
            ARG_POSITIVE(HGAP_MIN,"HGAP threshold (in bp.s)")
            break;
        }
      else
        argv[j++] = argv[i];
    argc = j;

    VERBOSE = flags['v'];

    if (argc < 3)
      { fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage);
        fprintf(stderr,"\n");
        fprintf(stderr,"      -v: Verbose mode, output statistics as proceed.\n");
        fprintf(stderr,"      -H: HGAP minimum length threshold.\n");
        fprintf(stderr,"      -m: repeat masks, stats not collected over these intervals\n");
        exit (1);
      }
  }

  //  Open trimmed DB and any mask tracks

  { DAZZ_TRACK *track;
    int64      *anno;
    int         status, kind;
    int         i, j, k;

    status = Open_DB(argv[1],DB);
    if (status < 0)
      exit (1);
    if (status == 1)
      { fprintf(stderr,"%s: Cannot be called on a .dam index: %s\n",Prog_Name,argv[1]);
        exit (1);
      }
    if (DB->part)
      { fprintf(stderr,"%s: Cannot be called on a block: %s\n",Prog_Name,argv[1]);
        exit (1);
      }
    Trim_DB(DB);
    Reads = DB->reads;

    k = 0;
    for (i = 0; i < NUM_MASK; i++)
      { status = Check_Track(DB,MASKS[i].name,&kind);
        switch (status)
        { case 0:
            fprintf(stderr,"%s: [WARNING] %s track is for the *un*trimmed DB?\n",
                           Prog_Name,MASKS[i].name);
            continue;
          case -1:
            fprintf(stderr,"%s: [WARNING] %s track size not correct for trimmed DB.\n",
                           Prog_Name,MASKS[i].name);
            continue;
          case -2:
            fprintf(stderr,"%s: [WARNING] -m%s option given but no track found.\n",
                           Prog_Name,MASKS[i].name);
            continue;
          default:
            if (kind != MASK_TRACK)
              { fprintf(stderr,"%s: [WARNING] %s track is not a mask track.\n",
                               Prog_Name,MASKS[i].name);
                continue;
              }
            break;
        }

        track = Open_Track(DB,MASKS[i].name);
        Load_All_Track_Data(track);

        anno = (int64 *) (track->anno);
        for (j = 0; j <= DB->nreads; j++)
          anno[j] /= sizeof(int);

        MASKS[k].name = MASKS[i].name;
        MASKS[k].idx  = anno;
        MASKS[k].data = (int *) (track->data);
        k += 1;
      }
    NUM_MASK = k;
  }

  //  Determine if overlap block is being processed and if so get first and last read
  //    from .db file

  ex_covr.vtype = DB_INT;
  ex_covr.nelem = MAX_COVER+1;
  ex_covr.accum = DB_SUM;
  ex_covr.name  = Cov_Name;
  ex_covr.value = Cov_Hist; 

  ex_hgap.vtype = DB_INT;
  ex_hgap.nelem = 1;
  ex_hgap.accum = DB_EXACT;
  ex_hgap.name  = Hgap_Name;
  hgap64 = HGAP_MIN;
  ex_hgap.value = &hgap64;

  dpwd = PathTo(argv[1]);
  root = Root(argv[1],".db");

  for (c = 2; c < argc; c++)
    { Block_Looper *parse;
      FILE         *input;

      parse = Parse_Block_LAS_Arg(argv[c]);

      while ((input = Next_Block_Arg(parse)) != NULL)
        { DB_PART  = 0;
          DB_FIRST = 0;
          DB_LAST  = DB->nreads;

          { FILE *dbfile;
            char  buffer[2*MAX_NAME+100];
            char *p, *eptr;
            int   i, part, nfiles, nblocks, cutoff, all, oindx;
            int64 size;

            p = rindex(Block_Arg_Root(parse),'.');
            if (p != NULL)
              { part = strtol(p+1,&eptr,10);
                if (*eptr == '\0' && eptr != p+1)
                  { dbfile = Fopen(Catenate(dpwd,"/",root,".db"),"r");
                    if (dbfile == NULL)
                      exit (1);
                    if (fscanf(dbfile,DB_NFILE,&nfiles) != 1)
                      SYSTEM_READ_ERROR
                    for (i = 0; i < nfiles; i++)
                      if (fgets(buffer,2*MAX_NAME+100,dbfile) == NULL)
                        SYSTEM_READ_ERROR
                    if (fscanf(dbfile,DB_NBLOCK,&nblocks) != 1)
                      SYSTEM_READ_ERROR
                    if (fscanf(dbfile,DB_PARAMS,&size,&cutoff,&all) != 3)
                      SYSTEM_READ_ERROR
                    for (i = 1; i <= part; i++)
                      if (fscanf(dbfile,DB_BDATA,&oindx,&DB_FIRST) != 2)
                        SYSTEM_READ_ERROR
                    if (fscanf(dbfile,DB_BDATA,&oindx,&DB_LAST) != 2)
                      SYSTEM_READ_ERROR
                    fclose(dbfile);
                    DB_PART = part;
                  }
              }
          }

          //  Set up cover extra's track

          if (DB_PART > 0)
           CV_ANAME = Strdup(Catenate(dpwd,PATHSEP,root,
                           Numbered_Suffix(".",DB_PART,".covr.anno")),"Allocating cover anno name");
          else
           CV_ANAME = Strdup(Catenate(dpwd,PATHSEP,root,".covr.anno"),"Allocating cover anno name");
          CV_AFILE = Fopen(CV_ANAME,"w");
          if (CV_ANAME == NULL || CV_AFILE == NULL)
            exit (1);

          { int size, length;

            length = 0;
            size   = 1;
            fwrite(&length,sizeof(int),1,CV_AFILE);
            fwrite(&size,sizeof(int),1,CV_AFILE);
          }

          //  Get trace point spacing information

          fread(&novl,sizeof(int64),1,input);
          fread(&TRACE_SPACING,sizeof(int),1,input);

          //  Initialize statistics gathering

          if (VERBOSE)
            { nreads = 0;
              totlen = 0;
              printf("\nDAScover %s %s\n",argv[1],Block_Arg_Root(parse));
            }

          { int i;

            for (i = 0; i <= MAX_COVER; i++)
              Cov_Hist[i] = 0;
          }

          //  Process each read pile

          make_a_pass(input,HISTOGRAM_COVER,0);

          //  If verbose output statistics summary to stdout

          if (VERBOSE)
            { int   i, cover;
              int64 ssum, stotal;

              printf("\nInput:  ");
              Print_Number(nreads,7,stdout);
              printf(" reads,  ");
              Print_Number(totlen,12,stdout);
              printf(" bases");
              if (HGAP_MIN > 0)
                { printf(" (another ");
                  Print_Number((DB_LAST-DB_FIRST) - nreads,0,stdout);
                  printf(" were < H-length)");
                }
              printf("\n");
 
              stotal = 0;
              for (i = 0; i <= MAX_COVER; i++)
                stotal += Cov_Hist[i];

              printf("\nCoverage Histogram\n\n");
              ssum = Cov_Hist[MAX_COVER];
              if (ssum > 0)
                printf("    %4d:  %9lld  %5.1f%%\n\n",
                       MAX_COVER,Cov_Hist[MAX_COVER],(100.*ssum)/stotal);
              stotal -= ssum;
              ssum    = 0;
              for (i = MAX_COVER-1; i >= 0; i--) 
                if (Cov_Hist[i] > 0)
                  { ssum += Cov_Hist[i];
                    printf("    %4d:  %9lld  %5.1f%%\n",
                           i,Cov_Hist[i],(100.*ssum)/stotal);
                  }

              i = 0;
              while (Cov_Hist[i+1] < Cov_Hist[i])
                i += 1;
              for (cover = i++; i < MAX_COVER; i++)
                if (Cov_Hist[cover] < Cov_Hist[i])
                  cover = i;

              printf("\n  Coverage is estimated at %d\n\n",cover);
            }

          //  Output coverage histogram

          Write_Extra(CV_AFILE,&ex_covr);
          Write_Extra(CV_AFILE,&ex_hgap);

          fclose(CV_AFILE);
          free(CV_ANAME);
          fclose(input);
        }

      Free_Block_Arg(parse);
    }

  free(dpwd);
  free(root);

  Close_DB(DB);
  free(Prog_Name);

  exit (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4f88, %rsp           # imm = 0x4F88
movq %rsi, 0x8(%rsp)
movl %edi, %ebp
leaq 0x17af5(%rip), %rdi     # 0x1a020
leaq 0x17e70(%rip), %rsi     # 0x1a3a2
callq 0x12392
leaq 0x1fc9a(%rip), %rcx     # 0x221d8
movq %rax, (%rcx)
leaq 0x100(%rsp), %rdi
xorl %ebx, %ebx
movl $0x200, %edx            # imm = 0x200
xorl %esi, %esi
callq 0x1140
movl %ebx, 0x1dc43(%rip)     # 0x201a0
movl %ebx, 0x1dc41(%rip)     # 0x201a4
leaq 0x17abf(%rip), %rsi     # 0x1a029
movl $0xf0, %edi
callq 0x122d5
movq %rax, 0x1dc2d(%rip)     # 0x201a8
testq %rax, %rax
je 0x3890
movl $0x1, %r15d
cmpl $0x2, %ebp
movq 0x8(%rsp), %r8
jl 0x270b
movl %ebp, %r14d
movl $0xa, %ebp
movl $0x1, %ebx
leaq 0x17a93(%rip), %r12     # 0x1a03f
movq (%r8,%rbx,8), %r13
cmpb $0x2d, (%r13)
jne 0x2656
movzbl 0x1(%r13), %eax
cmpl $0x48, %eax
je 0x2665
cmpl $0x6d, %eax
jne 0x26b1
movl 0x1dbcc(%rip), %eax     # 0x201a4
cmpl %ebp, %eax
jl 0x262a
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x17a1d(%rip), %xmm0    # 0x1a008
addsd 0x17a1d(%rip), %xmm0    # 0x1a010
cvttsd2si %xmm0, %ebp
movq 0x1dbaa(%rip), %rdi     # 0x201a8
movslq %ebp, %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
leaq 0x17a4f(%rip), %rdx     # 0x1a05f
callq 0x1232d
movq 0x8(%rsp), %r8
movq %rax, 0x1db87(%rip)     # 0x201a8
testq %rax, %rax
je 0x3890
movq (%r8,%rbx,8), %rax
addq $0x2, %rax
movq 0x1db6f(%rip), %rcx     # 0x201a8
movslq 0x1db64(%rip), %rdx     # 0x201a4
leal 0x1(%rdx), %esi
movl %esi, 0x1db5b(%rip)     # 0x201a4
leaq (%rdx,%rdx,2), %rdx
movq %rax, (%rcx,%rdx,8)
jmp 0x26ff
movslq %r15d, %rax
incl %r15d
movq %r13, (%r8,%rax,8)
jmp 0x26ff
addq $0x2, %r13
movq %r13, %rdi
leaq 0xb0(%rsp), %rsi
movl $0xa, %edx
callq 0x11d0
movq 0x8(%rsp), %r8
movl %eax, 0x1db17(%rip)     # 0x201a0
movq 0xb0(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x3833
movq (%r8,%rbx,8), %rcx
cmpb $0x0, 0x2(%rcx)
je 0x3833
testl %eax, %eax
jg 0x26ff
jmp 0x3864
movb 0x1(%r13), %al
testb %al, %al
je 0x26ff
movl %r15d, (%rsp)
movl %ebp, %r15d
addq $0x2, %r13
movsbl %al, %ebp
movq %r12, %rdi
movl %ebp, %esi
callq 0x1150
testq %rax, %rax
je 0x27a8
movslq %ebp, %rax
movl $0x1, 0x100(%rsp,%rax,4)
movb (%r13), %al
incq %r13
testb %al, %al
jne 0x26c4
movq 0x8(%rsp), %r8
movl %r15d, %ebp
movl (%rsp), %r15d
incq %rbx
cmpq %r14, %rbx
jne 0x25ac
movl 0x2d8(%rsp), %eax
movl %eax, 0x1da98(%rip)     # 0x201b0
cmpl $0x2, %r15d
jg 0x27d1
movq 0x1d8cf(%rip), %rbx     # 0x1fff8
movq (%rbx), %rdi
leaq 0x1faa5(%rip), %rax     # 0x221d8
movq (%rax), %rdx
leaq 0x1799a(%rip), %rsi     # 0x1a0d7
leaq 0x17c9a(%rip), %rcx     # 0x1a3de
xorl %eax, %eax
callq 0x11b0
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x1180
movq (%rbx), %rcx
leaq 0x17983(%rip), %rdi     # 0x1a0e5
movl $0x36, %esi
movl $0x1, %edx
callq 0x12a0
movq (%rbx), %rcx
leaq 0x179a1(%rip), %rdi     # 0x1a11c
movl $0x29, %esi
movl $0x1, %edx
callq 0x12a0
movq (%rbx), %rcx
leaq 0x179b2(%rip), %rdi     # 0x1a146
movl $0x41, %esi
movl $0x1, %edx
callq 0x12a0
jmp 0x3890
movq 0x1d849(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
leaq 0x1fa1f(%rip), %rax     # 0x221d8
movq (%rax), %rdx
leaq 0x1787e(%rip), %rsi     # 0x1a041
movl %ebp, %ecx
xorl %eax, %eax
callq 0x11b0
jmp 0x3890
movq 0x8(%r8), %rdi
leaq 0x1f964(%rip), %rsi     # 0x22140
callq 0x13290
testl %eax, %eax
js 0x3890
cmpl $0x1, %eax
jne 0x2817
movq 0x1d803(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
leaq 0x1f9d9(%rip), %rax     # 0x221d8
movq (%rax), %rdx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
leaq 0x17976(%rip), %rsi     # 0x1a188
jmp 0x382a
cmpl $0x0, 0x1f95a(%rip)     # 0x22178
jne 0x3806
leaq 0x1f915(%rip), %rdi     # 0x22140
callq 0x13a55
movq 0x1f969(%rip), %rax     # 0x221a0
movq %rax, 0x1d97a(%rip)     # 0x201b8
cmpl $0x0, 0x1d95f(%rip)     # 0x201a4
movl $0x0, %ebp
jle 0x29cc
leaq 0x1f8e9(%rip), %r14     # 0x22140
xorl %ebx, %ebx
xorl %ebp, %ebp
movq 0x1d946(%rip), %rax     # 0x201a8
leaq (%rbx,%rbx,2), %r13
movq (%rax,%r13,8), %rsi
movq %r14, %rdi
leaq 0x100(%rsp), %rdx
callq 0x14ef2
cmpl $-0x2, %eax
je 0x293c
cmpl $-0x1, %eax
je 0x2914
testl %eax, %eax
je 0x2964
cmpl $0x1, 0x100(%rsp)
jne 0x298c
movq 0x1d8ff(%rip), %rax     # 0x201a8
movq (%rax,%r13,8), %rsi
movq %r14, %rdi
callq 0x150fb
movq %rax, %r12
movq %rax, %rdi
callq 0x15a05
movq 0x18(%r12), %rax
movl 0x1f8a5(%rip), %ecx     # 0x22170
testl %ecx, %ecx
js 0x28e1
incq %rcx
xorl %edx, %edx
shrq $0x2, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x28d4
movq 0x1d8c0(%rip), %rcx     # 0x201a8
movq (%rcx,%r13,8), %rdx
movslq %ebp, %rbp
leaq (,%rbp,2), %rsi
addq %rbp, %rsi
movq %rdx, (%rcx,%rsi,8)
movq %rax, 0x8(%rcx,%rsi,8)
movq 0x28(%r12), %rax
movq %rax, 0x10(%rcx,%rsi,8)
incl %ebp
jmp 0x29b9
movq 0x1d6dd(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
leaq 0x1f8b3(%rip), %rax     # 0x221d8
movq (%rax), %rdx
movq 0x1d879(%rip), %rax     # 0x201a8
movq (%rax,%r13,8), %rcx
leaq 0x178d0(%rip), %rsi     # 0x1a20a
jmp 0x29b2
movq 0x1d6b5(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
leaq 0x1f88b(%rip), %rax     # 0x221d8
movq (%rax), %rdx
movq 0x1d851(%rip), %rax     # 0x201a8
movq (%rax,%r13,8), %rcx
leaq 0x178e1(%rip), %rsi     # 0x1a243
jmp 0x29b2
movq 0x1d68d(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
leaq 0x1f863(%rip), %rax     # 0x221d8
movq (%rax), %rdx
movq 0x1d829(%rip), %rax     # 0x201a8
movq (%rax,%r13,8), %rcx
leaq 0x1784d(%rip), %rsi     # 0x1a1d7
jmp 0x29b2
movq 0x1d665(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
leaq 0x1f83b(%rip), %rax     # 0x221d8
movq (%rax), %rdx
movq 0x1d801(%rip), %rax     # 0x201a8
movq (%rax,%r13,8), %rcx
leaq 0x178c6(%rip), %rsi     # 0x1a278
xorl %eax, %eax
callq 0x11b0
incq %rbx
movslq 0x1d7e1(%rip), %rax     # 0x201a4
cmpq %rax, %rbx
jl 0x285b
movl %ebp, 0x1d7d2(%rip)     # 0x201a4
movabsq $0x3e900000000, %rax    # imm = 0x3E900000000
leaq 0xb0(%rsp), %rcx
movq %rax, (%rcx)
movl $0x1, 0x8(%rcx)
leaq 0x17a24(%rip), %rax     # 0x1a419
movq %rax, 0x10(%rcx)
leaq 0x1d7c0(%rip), %r14     # 0x201c0
movq %r14, 0x18(%rcx)
movabsq $0x100000000, %rax      # imm = 0x100000000
leaq 0xe0(%rsp), %rdx
movq %rax, (%rdx)
movl $0x0, 0x8(%rdx)
leaq 0x17a05(%rip), %rax     # 0x1a42c
movq %rax, 0x10(%rdx)
movslq 0x1d76e(%rip), %rax     # 0x201a0
leaq 0xd0(%rsp), %rcx
movq %rax, (%rcx)
movq %rcx, 0x18(%rdx)
movq 0x8(%rsp), %rbx
movq 0x8(%rbx), %rdi
callq 0x1244e
movq %rax, 0x38(%rsp)
movq 0x8(%rbx), %rdi
leaq 0x17846(%rip), %rsi     # 0x1a2a5
callq 0x124a8
movq %rax, 0x30(%rsp)
cmpl $0x4, %r15d
movl $0x3, %eax
cmovgel %r15d, %eax
movq %rax, 0x70(%rsp)
movq %r14, %r15
movl $0x2, %ecx
xorl %r14d, %r14d
movq 0x8(%rsp), %rax
movq %rcx, 0x78(%rsp)
movq (%rax,%rcx,8), %rdi
callq 0x16cd7
movq %rax, %rbx
movq %rax, %rdi
callq 0x16b0a
testq %rax, %rax
je 0x37b5
movq %rbx, 0x60(%rsp)
movq %rax, 0x20(%rsp)
movl %r14d, 0x1f64a(%rip)    # 0x22108
movl %r14d, 0x1f647(%rip)    # 0x2210c
movl 0x1f6a5(%rip), %eax     # 0x22170
movl %eax, 0x1f63f(%rip)     # 0x22110
movq %rbx, %rdi
callq 0x16bbe
movq %rax, %rdi
movl $0x2e, %esi
callq 0x1270
testq %rax, %rax
je 0x2c62
movq %rax, %r13
incq %r13
movq %r13, %rdi
leaq 0x48(%rsp), %rsi
movl $0xa, %edx
callq 0x11d0
movq %rax, %r12
movq 0x48(%rsp), %rax
cmpq %r13, %rax
je 0x2c62
cmpb $0x0, (%rax)
jne 0x2c62
movq 0x38(%rsp), %rdi
leaq 0x1777c(%rip), %rsi     # 0x1a2a9
movq 0x30(%rsp), %rdx
leaq 0x1776c(%rip), %rcx     # 0x1a2a5
callq 0x1256d
movq %rax, %rdi
leaq 0x18854(%rip), %rsi     # 0x1b39c
callq 0x123f1
testq %rax, %rax
je 0x3890
movq %rax, %r13
movq %rax, %rdi
leaq 0x17748(%rip), %rsi     # 0x1a2ab
leaq 0x2c(%rsp), %rdx
xorl %eax, %eax
callq 0x1090
cmpl $0x1, %eax
jne 0x389a
cmpl $0x0, 0x2c(%rsp)
jle 0x2ba7
xorl %ebx, %ebx
leaq 0x100(%rsp), %rdi
movl $0x4e84, %esi           # imm = 0x4E84
movq %r13, %rdx
callq 0x1190
testq %rax, %rax
je 0x389a
incl %ebx
cmpl 0x2c(%rsp), %ebx
jl 0x2b81
movq %r13, %rdi
leaq 0x17727(%rip), %rsi     # 0x1a2d8
leaq 0xa4(%rsp), %rdx
xorl %eax, %eax
callq 0x1090
cmpl $0x1, %eax
jne 0x389a
movq %r13, %rdi
leaq 0x17713(%rip), %rsi     # 0x1a2e6
leaq 0xa8(%rsp), %rdx
leaq 0xa0(%rsp), %rcx
leaq 0x9c(%rsp), %r8
xorl %eax, %eax
callq 0x1090
cmpl $0x3, %eax
jne 0x389a
movl %r12d, %ebx
testl %r12d, %r12d
jle 0x2c2d
movq %r13, %rdi
leaq 0x176ff(%rip), %rsi     # 0x1a30c
leaq 0x5c(%rsp), %rdx
leaq 0x1f4f3(%rip), %rcx     # 0x2210c
xorl %eax, %eax
callq 0x1090
cmpl $0x2, %eax
jne 0x389a
decl %ebx
jne 0x2c03
movq %r13, %rdi
leaq 0x176d5(%rip), %rsi     # 0x1a30c
leaq 0x5c(%rsp), %rdx
leaq 0x1f4cd(%rip), %rcx     # 0x22110
xorl %eax, %eax
callq 0x1090
cmpl $0x2, %eax
jne 0x389a
movq %r13, %rdi
callq 0x10d0
movl %r12d, 0x1f4a6(%rip)    # 0x22108
movl 0x1f4a0(%rip), %esi     # 0x22108
testl %esi, %esi
jle 0x2c95
leaq 0x177a4(%rip), %rdi     # 0x1a417
leaq 0x1769f(%rip), %rdx     # 0x1a319
callq 0x1265d
movq 0x38(%rsp), %rdi
leaq 0x1768b(%rip), %rsi     # 0x1a316
movq 0x30(%rsp), %rdx
movq %rax, %rcx
jmp 0x2cad
movq 0x38(%rsp), %rdi
leaq 0x17675(%rip), %rsi     # 0x1a316
movq 0x30(%rsp), %rdx
leaq 0x1766c(%rip), %rcx     # 0x1a319
callq 0x1256d
movq %rax, %rdi
leaq 0x177dd(%rip), %r13     # 0x1a499
movq 0x20(%rsp), %r12
leaq 0x1765c(%rip), %rsi     # 0x1a324
callq 0x12392
movq %rax, 0x1f444(%rip)     # 0x22118
movq %rax, %rdi
leaq 0x180de(%rip), %rsi     # 0x1adbc
callq 0x123f1
movq %rax, 0x1f436(%rip)     # 0x22120
cmpq $0x0, 0x1f426(%rip)     # 0x22118
je 0x3890
testq %rax, %rax
je 0x3890
movl $0x0, 0x48(%rsp)
movl $0x1, 0x100(%rsp)
movl $0x4, %esi
movl $0x1, %edx
leaq 0x48(%rsp), %rdi
movq %rax, %rcx
callq 0x12a0
movq 0x1f3ee(%rip), %rcx     # 0x22120
movl $0x4, %esi
movl $0x1, %edx
leaq 0x100(%rsp), %rdi
callq 0x12a0
movl $0x8, %esi
movl $0x1, %edx
leaq 0xd8(%rsp), %rdi
movq %r12, %rcx
callq 0x10c0
movl $0x4, %esi
movl $0x1, %edx
leaq 0x1f3b4(%rip), %rdi     # 0x22128
movq %r12, %rcx
callq 0x10c0
cmpl $0x0, 0x1d42d(%rip)     # 0x201b0
je 0x2dbf
movq %r14, 0x1f3a4(%rip)     # 0x22130
movq %r14, 0x1f3a5(%rip)     # 0x22138
movq 0x8(%rsp), %rax
movq 0x8(%rax), %r12
movq 0x60(%rsp), %rdi
callq 0x16bbe
leaq 0x17592(%rip), %rdi     # 0x1a33f
movq %r12, %rsi
movq 0x20(%rsp), %r12
movq %rax, %rdx
xorl %eax, %eax
callq 0x1110
movl $0x1f48, %edx           # imm = 0x1F48
movq %r15, %rdi
xorl %esi, %esi
callq 0x1140
cmpq $0x0, 0x1f3da(%rip)     # 0x221b0
jne 0x2e03
movslq 0x1d399(%rip), %rax     # 0x20178
shlq $0x4, %rax
leaq (%rax,%rax,2), %rdi
leaq 0x1764d(%rip), %rsi     # 0x1a43b
callq 0x122d5
movq %rax, 0x1f3b6(%rip)     # 0x221b0
testq %rax, %rax
je 0x3890
movq %r12, %rdi
callq 0x1120
movl $0x8, %esi
movl $0x1, %edx
leaq 0x100(%rsp), %rdi
movq %r12, %rcx
callq 0x10c0
movl $0x4, %esi
movl $0x1, %edx
leaq 0x1f2f2(%rip), %rdi     # 0x22128
movq %r12, %rcx
callq 0x10c0
xorl %eax, %eax
cmpl $0x7e, 0x1f2e1(%rip)    # 0x22128
setge %al
incl %eax
movl %eax, 0x1f366(%rip)     # 0x221b8
movq 0x1f357(%rip), %rsi     # 0x221b0
movq %r12, %rdi
callq 0x9738
testl %eax, %eax
je 0x2e75
movq 0x1f344(%rip), %rax     # 0x221b0
movl $0x7fffffff, 0x24(%rax) # imm = 0x7FFFFFFF
jmp 0x2e98
movslq 0x1f33c(%rip), %rax     # 0x221b8
movq 0x1f32d(%rip), %rcx     # 0x221b0
movslq 0x8(%rcx), %rsi
imulq %rax, %rsi
movq %r12, %rdi
movl $0x1, %edx
callq 0x1220
movq 0x1f311(%rip), %rax     # 0x221b0
movslq 0x1f266(%rip), %rcx     # 0x2210c
cmpl %ecx, 0x24(%rax)
jl 0x38c6
cmpl 0x1f25b(%rip), %ecx     # 0x22110
jge 0x355b
leal 0x1(%rcx), %eax
movl %eax, 0x28(%rsp)
movl $0x0, (%rsp)
movq %rcx, %r15
movq 0x1f2dd(%rip), %rsi     # 0x221b0
movslq (%rsp), %rax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movupd (%rsi,%rax), %xmm0
movupd 0x10(%rsi,%rax), %xmm1
movups 0x20(%rsi,%rax), %xmm2
movups %xmm2, 0x20(%rsi)
movupd %xmm1, 0x10(%rsi)
movupd %xmm0, (%rsi)
movslq 0x24(%rsi), %r14
movl $0x0, (%rsp)
cmpq %r14, %r15
jne 0x3021
addq $0x30, %rsi
movq %r12, %rdi
callq 0x9738
testl %eax, %eax
je 0x2f31
movl $0x1, %ebx
movl $0x1, (%rsp)
jmp 0x2fe7
movq %r15, %rbp
movl $0x1, %ebx
movl $0x60, %r15d
movslq 0x1f272(%rip), %rax     # 0x221b8
movq 0x1f263(%rip), %rcx     # 0x221b0
movslq -0x28(%rcx,%r15), %rsi
imulq %rax, %rsi
movq %r12, %rdi
movl $0x1, %edx
callq 0x1220
movq 0x1f246(%rip), %rdi     # 0x221b0
cmpl %r14d, -0xc(%rdi,%r15)
jne 0x3550
incq %rbx
cmpl %ebx, 0x1d1fa(%rip)     # 0x20178
jg 0x2fc3
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
mulsd 0x17079(%rip), %xmm0    # 0x1a008
addsd 0x17081(%rip), %xmm0    # 0x1a018
cvttsd2si %xmm0, %eax
movl %eax, 0x1d1d7(%rip)     # 0x20178
cltq
shlq $0x4, %rax
leaq (%rax,%rax,2), %rsi
movq %r13, %rdx
callq 0x1232d
movq %rax, 0x1f1f6(%rip)     # 0x221b0
testq %rax, %rax
je 0x3890
movq 0x1f1e6(%rip), %rsi     # 0x221b0
addq %r15, %rsi
movq %r12, %rdi
callq 0x9738
addq $0x30, %r15
testl %eax, %eax
je 0x2f3f
movl %ebx, (%rsp)
movq %rbp, %r15
movq 0x1f1c2(%rip), %rax     # 0x221b0
leaq (%rbx,%rbx,2), %rcx
shlq $0x4, %rcx
movl $0x7fffffff, 0x24(%rax,%rcx) # imm = 0x7FFFFFFF
movq 0x1f1ab(%rip), %rax     # 0x221b0
addq $0x8, %rax
xorl %ecx, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx), %rdx
movq %rdx, -0x8(%rax)
addl (%rax), %ecx
addq $0x30, %rax
decq %rbx
jne 0x300b
movq 0x1f178(%rip), %rax     # 0x221a0
movslq %r15d, %rcx
movq %rcx, 0x68(%rsp)
leaq (%rcx,%rcx,4), %rcx
movslq 0x4(%rax,%rcx,8), %rsi
movl 0x1f0e9(%rip), %ecx     # 0x22128
leal (%rcx,%rsi), %eax
decl %eax
cltd
idivl %ecx
cmpl 0x1d153(%rip), %esi     # 0x201a0
jl 0x3537
movl %eax, 0x54(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x1f14a(%rip), %r12     # 0x221b0
cmpl $0x0, 0x1f14f(%rip)     # 0x221bc
movl $0x0, %ebx
jne 0x312c
leal -0x1(%rcx), %eax
addl 0x1f0df(%rip), %eax     # 0x22160
cltd
idivl %ecx
movl %eax, 0x1f132(%rip)     # 0x221bc
movslq %eax, %rdi
shlq $0x2, %rdi
leaq 0x1741a(%rip), %rsi     # 0x1a4b2
callq 0x122d5
movq %rax, 0x1f11c(%rip)     # 0x221c0
movslq 0x1f111(%rip), %rdi     # 0x221bc
shlq $0x2, %rdi
leaq 0x17413(%rip), %r14     # 0x1a4c9
movq %r14, %rsi
callq 0x122d5
movq %rax, 0x1f103(%rip)     # 0x221c8
movslq 0x1f0f0(%rip), %rdi     # 0x221bc
shlq $0x2, %rdi
movq %r14, %rsi
callq 0x122d5
movq %rax, 0x1f0f1(%rip)     # 0x221d0
movq 0x1f0da(%rip), %rcx     # 0x221c0
testq %rcx, %rcx
je 0x3890
movq 0x1f0d2(%rip), %rdx     # 0x221c8
testq %rdx, %rdx
je 0x3890
testq %rax, %rax
je 0x3890
movslq 0x1f0ad(%rip), %rsi     # 0x221bc
testq %rsi, %rsi
jle 0x312c
incq %rsi
movl %ebx, -0x8(%rax,%rsi,4)
movl %ebx, -0x8(%rdx,%rsi,4)
movl %ebx, -0x8(%rcx,%rsi,4)
decq %rsi
cmpq $0x1, %rsi
jg 0x3117
movl 0x1eff6(%rip), %eax     # 0x22128
movl 0x1f038(%rip), %ebp     # 0x22170
leal 0x1(%r15), %ecx
movl %ecx, %r8d
movl %ecx, 0x50(%rsp)
cmpl %ebp, %ecx
jge 0x317c
movl 0x28(%rsp), %esi
movslq %esi, %rcx
shlq $0x3, %rcx
leaq (%rcx,%rcx,4), %rcx
movq 0x1d05b(%rip), %rdx     # 0x201b8
addq %rdx, %rcx
addq $0x20, %rcx
movl %esi, %r8d
testb $0x4, 0x1(%rcx)
je 0x317c
incl %r8d
addq $0x28, %rcx
cmpl %r8d, %ebp
jne 0x3167
movl %ebp, %r8d
testq %r15, %r15
movq %r15, 0x80(%rsp)
js 0x31b5
movq 0x1d028(%rip), %rcx     # 0x201b8
movl %r15d, %esi
movl %esi, %edx
leaq (%rdx,%rdx,4), %rdx
testb $0x4, 0x21(%rcx,%rdx,8)
je 0x31bc
leal -0x1(%rsi), %edx
testl %esi, %esi
movl %edx, %esi
jg 0x3193
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rcx, 0x10(%rsp)
jmp 0x31c1
movq %r15, 0x10(%rsp)
jmp 0x31c1
movq %rsi, 0x10(%rsp)
cmpl $0x0, (%rsp)
jle 0x336b
movl %eax, %r10d
shrl $0x1f, %r10d
addl %eax, %r10d
sarl %r10d
leal -0x1(%r10), %r11d
movslq %ebp, %rsi
movq 0x1cfd2(%rip), %rax     # 0x201b8
movq 0x1efd3(%rip), %r14     # 0x221c0
movq 0x1efd4(%rip), %r13     # 0x221c8
movl (%rsp), %ecx
movq %rcx, 0x90(%rsp)
addq $0x48, %rax
movq %rax, 0x40(%rsp)
xorl %r15d, %r15d
movq 0x10(%rsp), %rax
movl %ebp, 0x58(%rsp)
movl %r8d, 0x1c(%rsp)
movslq %r15d, %rbx
leaq (%rbx,%rbx,2), %rcx
shlq $0x4, %rcx
movl 0x28(%r12,%rcx), %edi
cmpl %edi, 0x10(%rsp)
jg 0x323e
cmpl %r8d, %edi
jge 0x323e
incl %eax
movl %eax, %r15d
jmp 0x335e
movslq %edi, %rax
leal 0x1(%rdi), %ecx
cmpl %ecx, %ebp
cmovgl %ebp, %ecx
decl %ecx
decl %edi
leaq (%rax,%rax,4), %rdx
movq 0x40(%rsp), %r9
leaq (%r9,%rdx,8), %rdx
incq %rax
cmpq %rsi, %rax
jge 0x3273
incl %edi
incq %rax
testb $0x4, 0x1(%rdx)
leaq 0x28(%rdx), %rdx
jne 0x325d
jmp 0x3275
movl %ecx, %edi
cmpl (%rsp), %r15d
jge 0x335e
movq %rbx, %rbp
leaq (,%rbp,2), %r8
addq %rbp, %r8
shlq $0x4, %r8
cmpl %edi, 0x28(%r12,%r8)
jg 0x32db
addq %r12, %r8
movl 0x18(%r8), %eax
addl %r10d, %eax
movl 0x1ee7f(%rip), %r9d     # 0x22128
cltd
idivl %r9d
movl %eax, %ecx
movl 0x10(%r8), %eax
addl %r11d, %eax
cltd
idivl %r9d
cmpl %ecx, %eax
jge 0x32d3
cltq
movslq %ecx, %rcx
movl $0x1, (%r14,%rax,4)
incq %rax
cmpq %rax, %rcx
jne 0x32c3
incq %rbp
cmpl %ebp, (%rsp)
jne 0x3282
cmpl (%rsp), %r15d
movl 0x58(%rsp), %ebp
movl 0x1c(%rsp), %r8d
jge 0x335e
movq 0x90(%rsp), %r15
leaq (%rbx,%rbx,2), %r8
shlq $0x4, %r8
cmpl %edi, 0x28(%r12,%r8)
jg 0x3356
addq %r12, %r8
movl 0x18(%r8), %eax
addl %r10d, %eax
movl 0x1ee16(%rip), %r9d     # 0x22128
cltd
idivl %r9d
movl %eax, %ecx
movl 0x10(%r8), %eax
addl %r11d, %eax
cltd
idivl %r9d
cmpl %ecx, %eax
jge 0x3348
cltq
movslq %ecx, %rcx
cmpl $0x0, (%r14,%rax,4)
jle 0x3340
movl $0x0, (%r14,%rax,4)
incl (%r13,%rax,4)
incq %rax
cmpq %rax, %rcx
jne 0x332c
incq %rbx
cmpq %r15, %rbx
jne 0x32f2
movl (%rsp), %r15d
jmp 0x3359
movl %ebx, %r15d
movl 0x1c(%rsp), %r8d
movl %r15d, %eax
cmpl (%rsp), %r15d
jl 0x3219
movslq 0x1ce32(%rip), %rbp     # 0x201a4
movslq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
testq %rbp, %rbp
leaq 0x1ce3a(%rip), %r15     # 0x201c0
jle 0x3410
movq 0x1ce15(%rip), %rdi     # 0x201a8
movq 0x1ee36(%rip), %r8      # 0x221d0
xorl %r9d, %r9d
leaq (%r9,%r9,2), %rax
movq 0x8(%rdi,%rax,8), %rcx
movq 0x68(%rsp), %rdx
movslq (%rcx,%rdx,8), %r10
movq 0x10(%rsp), %rdx
movq (%rcx,%rdx,8), %r11
cmpq %r10, %r11
jle 0x3408
leaq (%rdi,%rax,8), %rax
movq 0x10(%rax), %rbx
movl (%rbx,%r10,4), %esi
movl 0x4(%rbx,%r10,4), %eax
movl 0x1ed53(%rip), %r14d    # 0x22128
addl %r14d, %eax
decl %eax
cltd
idivl %r14d
movl %eax, %ecx
movl %esi, %eax
cltd
idivl %r14d
cmpl %ecx, %eax
jge 0x33ff
cltq
movslq %ecx, %rcx
movl $0x1, (%r8,%rax,4)
incq %rax
cmpq %rax, %rcx
jne 0x33ef
addq $0x2, %r10
cmpq %r10, %r11
jg 0x33c5
incq %r9
cmpq %rbp, %r9
jne 0x339d
movl 0x54(%rsp), %edx
testl %edx, %edx
jle 0x3459
movq 0x1edb1(%rip), %rax     # 0x221d0
movq 0x1eda2(%rip), %rcx     # 0x221c8
movl %edx, %edx
xorl %esi, %esi
cmpl $0x0, (%rax,%rsi,4)
jne 0x344a
movslq (%rcx,%rsi,4), %rdi
cmpq $0x3e8, %rdi            # imm = 0x3E8
jl 0x3446
incq 0x1ecbc(%rip)           # 0x22100
jmp 0x344a
incq (%r15,%rdi,8)
movl $0x0, (%rcx,%rsi,4)
incq %rsi
cmpq %rsi, %rdx
jne 0x342a
testl %ebp, %ebp
jle 0x3504
movq 0x1cd40(%rip), %rax     # 0x201a8
movq %rax, 0x40(%rsp)
movq 0x1ed5c(%rip), %r12     # 0x221d0
xorl %r13d, %r13d
movq %rbp, %r15
leaq (,%r13,2), %rax
addq %r13, %rax
movq 0x40(%rsp), %rcx
movq 0x8(%rcx,%rax,8), %rcx
movq 0x68(%rsp), %rdx
movslq (%rcx,%rdx,8), %rbp
movq 0x10(%rsp), %rdx
movq (%rcx,%rdx,8), %r14
cmpq %rbp, %r14
jle 0x34f5
movq 0x40(%rsp), %rcx
leaq (%rcx,%rax,8), %rax
movq 0x10(%rax), %rbx
movl (%rbx,%rbp,4), %esi
movl 0x4(%rbx,%rbp,4), %eax
movl 0x1ec68(%rip), %edi     # 0x22128
addl %edi, %eax
decl %eax
cltd
idivl %edi
movl %eax, %ecx
movl %esi, %eax
cltd
idivl %edi
cmpl %ecx, %eax
jge 0x34ec
movslq %eax, %rdx
leaq (%r12,%rdx,4), %rdi
notl %eax
addl %eax, %ecx
leaq 0x4(,%rcx,4), %rdx
xorl %esi, %esi
callq 0x1140
addq $0x2, %rbp
cmpq %rbp, %r14
jg 0x34b3
incq %r13
movq %r15, %rbp
cmpq %r15, %r13
jne 0x3477
cmpl $0x0, 0x1cca5(%rip)     # 0x201b0
leaq 0x16f87(%rip), %r13     # 0x1a499
movq 0x20(%rsp), %r12
movq 0x80(%rsp), %r15
movq 0x88(%rsp), %rax
je 0x3537
incq 0x1ec00(%rip)           # 0x22130
addq %rax, 0x1ec01(%rip)     # 0x22138
incq %r15
movslq 0x1ebcf(%rip), %rax     # 0x22110
incl 0x28(%rsp)
cmpq %rax, %r15
jl 0x2ecc
jmp 0x355f
movl %ebx, (%rsp)
movq %rbp, %r15
jmp 0x2ffe
xorl %eax, %eax
jmp 0x356d
movslq (%rsp), %rax
xorl %r14d, %r14d
leaq 0x1cc53(%rip), %r15     # 0x201c0
movq 0x1ec3c(%rip), %rcx     # 0x221b0
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
cmpl $0x7fffffff, 0x24(%rcx,%rax) # imm = 0x7FFFFFFF
movq 0x1ca4d(%rip), %rbx     # 0x1ffd8
leaq 0x16e11(%rip), %r13     # 0x1a3a3
jne 0x38c6
cmpl $0x0, 0x1cc11(%rip)     # 0x201b0
je 0x3757
leaq 0x16da4(%rip), %rdi     # 0x1a350
xorl %eax, %eax
callq 0x1110
movq 0x1eb76(%rip), %rdi     # 0x22130
movq (%rbx), %rdx
movl $0x7, %esi
callq 0x12710
leaq 0x16d8c(%rip), %rdi     # 0x1a35a
xorl %eax, %eax
callq 0x1110
movq 0x1eb5c(%rip), %rdi     # 0x22138
movq (%rbx), %rdx
movl $0xc, %esi
callq 0x12710
leaq 0x16d74(%rip), %rdi     # 0x1a364
xorl %eax, %eax
callq 0x1110
cmpl $0x0, 0x1cba2(%rip)     # 0x201a0
jle 0x363e
leaq 0x16d64(%rip), %rdi     # 0x1a36b
xorl %eax, %eax
callq 0x1110
movslq 0x1eafb(%rip), %rdi     # 0x22110
movslq 0x1eaf0(%rip), %rax     # 0x2210c
subq %rax, %rdi
subq 0x1eb0a(%rip), %rdi     # 0x22130
movq (%rbx), %rdx
xorl %esi, %esi
callq 0x12710
leaq 0x16d3f(%rip), %rdi     # 0x1a376
xorl %eax, %eax
callq 0x1110
movl $0xa, %edi
callq 0x1040
xorl %eax, %eax
xorl %ebx, %ebx
addq (%rax,%r15), %rbx
addq $0x8, %rax
cmpq $0x1f48, %rax           # imm = 0x1F48
jne 0x364c
leaq 0x16e7d(%rip), %rdi     # 0x1a4e0
callq 0x10a0
movq 0x1ea91(%rip), %r12     # 0x22100
testq %r12, %r12
jle 0x36a0
cvtsi2sd %r12, %xmm0
mulsd 0x16997(%rip), %xmm0    # 0x1a018
cvtsi2sd %rbx, %xmm1
divsd %xmm1, %xmm0
leaq 0x16cf7(%rip), %rdi     # 0x1a388
movl $0x3e8, %esi            # imm = 0x3E8
movq %r12, %rdx
movb $0x1, %al
callq 0x1110
subq %r12, %rbx
xorps %xmm0, %xmm0
cvtsi2sd %rbx, %xmm0
movsd %xmm0, (%rsp)
movl $0x3e7, %r12d           # imm = 0x3E7
xorl %ebx, %ebx
movq (%r15,%r12,8), %rdx
testq %rdx, %rdx
jle 0x36e6
addq %rdx, %rbx
xorps %xmm0, %xmm0
cvtsi2sd %rbx, %xmm0
mulsd 0x16944(%rip), %xmm0    # 0x1a018
divsd (%rsp), %xmm0
movq %r13, %rdi
movl %r12d, %esi
movb $0x1, %al
callq 0x1110
addq $-0x1, %r12
jb 0x36b8
movq $-0x1, %rsi
leaq 0x1cace(%rip), %rcx     # 0x201c8
movq %rsi, %rdx
movq %rcx, %rax
movq 0x10(%r15,%rsi,8), %rdi
incq %rsi
addq $0x8, %rcx
cmpq 0x8(%r15,%rdx,8), %rdi
jl 0x36fa
cmpq $0x3e7, %rsi            # imm = 0x3E7
movq 0x20(%rsp), %r12
jae 0x3749
leaq 0x1(%rsi), %rcx
movl %esi, %edx
movslq %edx, %rsi
movq (%r15,%rsi,8), %rdi
movl %ecx, %esi
cmpq (%rax), %rdi
jl 0x3737
movl %edx, %esi
incq %rcx
addq $0x8, %rax
movl %esi, %edx
cmpq $0x3e8, %rcx            # imm = 0x3E8
jne 0x3727
leaq 0x16c6d(%rip), %rdi     # 0x1a3bd
xorl %eax, %eax
callq 0x1110
movq 0x1e9c2(%rip), %rdi     # 0x22120
leaq 0xb0(%rsp), %rsi
callq 0x15f76
movq 0x1e9ae(%rip), %rdi     # 0x22120
leaq 0xe0(%rsp), %rsi
callq 0x15f76
movq 0x1e99a(%rip), %rdi     # 0x22120
callq 0x10d0
movq 0x1e986(%rip), %rdi     # 0x22118
callq 0x1030
movq %r12, %rdi
callq 0x10d0
movq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0x16b0a
testq %rax, %rax
jne 0x2ab2
movq %rbx, %rdi
callq 0x16be9
movq 0x78(%rsp), %rcx
incq %rcx
cmpq 0x70(%rsp), %rcx
jne 0x2a86
movq 0x38(%rsp), %rdi
callq 0x1030
movq 0x30(%rsp), %rdi
callq 0x1030
leaq 0x1e955(%rip), %rdi     # 0x22140
callq 0x14268
leaq 0x1e9e1(%rip), %rax     # 0x221d8
movq (%rax), %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1290
movq 0x1c7eb(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
leaq 0x1e9c1(%rip), %rax     # 0x221d8
movq (%rax), %rdx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
leaq 0x16988(%rip), %rsi     # 0x1a1b2
xorl %eax, %eax
callq 0x11b0
jmp 0x3890
movq 0x1c7be(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
leaq 0x1e994(%rip), %rax     # 0x221d8
movq (%rax), %rdx
movq (%r8,%rbx,8), %r8
movsbl 0x1(%r8), %ecx
addq $0x2, %r8
leaq 0x1681c(%rip), %rsi     # 0x1a077
xorl %eax, %eax
callq 0x11b0
jmp 0x3890
movq 0x1c78d(%rip), %rcx     # 0x1fff8
movq (%rcx), %rdi
leaq 0x1e963(%rip), %rcx     # 0x221d8
movq (%rcx), %rdx
leaq 0x16821(%rip), %rsi     # 0x1a0a0
leaq 0x16838(%rip), %rcx     # 0x1a0be
movl %eax, %r8d
xorl %eax, %eax
callq 0x11b0
movl $0x1, %edi
callq 0x1290
movq 0x1c757(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
leaq 0x1e92d(%rip), %rax     # 0x221d8
movq (%rax), %rdx
leaq 0x16a03(%rip), %rsi     # 0x1a2b8
xorl %eax, %eax
callq 0x11b0
movl $0x2, %edi
callq 0x1290
movq 0x1c72b(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
leaq 0x1e901(%rip), %rax     # 0x221d8
movq (%rax), %rdx
movl 0x1e828(%rip), %ecx     # 0x22108
leaq 0x16b6e(%rip), %rsi     # 0x1a455
jmp 0x27c5