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

  DAZZ_EXTRA ex_hgap, ex_covr;
  DAZZ_EXTRA ex_cest, ex_qvs, ex_dif;

  char *cest_name = "Coverage Estimate";
  char *qvs_name  = "Histogram of QVs";
  char *dif_name  = "Histogram of Tile Differences";
  int64 cover64;

  //  Process arguments

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

    ARG_INIT("DASqv")

    COVERAGE = -1;

    j = 1;
    for (i = 1; i < argc; i++)
      if (argv[i][0] == '-')
        switch (argv[i][1])
        { default:
            ARG_FLAGS("v")
            break;
          case 'c':
            ARG_POSITIVE(COVERAGE,"Voting depth")
            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,"      -c: Use this as the average coverage (not DAScover estimate).\n");
        exit (1);
      }
  }

  //  Open trimmed DB

  { int status;

    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);
  }

  //  Get .covr track information

  { FILE      *afile;
    char      *aname;
    int        extra, cmax;
    int64     *cgram;

    aname = Strdup(Catenate(DB->path,".","covr",".anno"),"Allocating anno file");
    if (aname == NULL)
      exit (1);
    afile  = fopen(aname,"r");
    if (afile == NULL)
      { fprintf(stderr,"%s: Must have a 'covr' track, run DAScover\n",Prog_Name);
        exit (1);
      }

    fseeko(afile,0,SEEK_END);
    extra = ftell(afile) - sizeof(int)*2;
    fseeko(afile,-extra,SEEK_END);
    ex_covr.nelem = 0;
    if (Read_Extra(afile,aname,&ex_covr) != 0)
      { fprintf(stderr,"%s: Histogram extra missing from .covr track?\n",Prog_Name);
        exit (1);
      }
    ex_hgap.nelem = 0;
    if (Read_Extra(afile,aname,&ex_hgap) != 0)
      { fprintf(stderr,"%s: Hgap threshold extra missing from .covr track?\n",Prog_Name);
        exit (1);
      }
    fclose(afile);

    HGAP_MIN = (int) ((int64 *) (ex_hgap.value))[0];
    cgram    = (int64 *) (ex_covr.value);
    cmax     = ex_covr.nelem - 1;

    if (COVERAGE < 0)
      { int i;

        i = 0;
        while (cgram[i+1] < cgram[i])
          i += 1;
        for (COVERAGE = i++; i < cmax; i++)
          if (cgram[COVERAGE] < cgram[i])
            COVERAGE = i;
      }

    if (COVERAGE >= 40)
      QV_DEEP = COVERAGE/8;
     else if (COVERAGE >= 20)
       QV_DEEP = 5;
     else if (COVERAGE >= 4)
       QV_DEEP = COVERAGE/4;
     else
       { fprintf(stderr,"%s: Average coverage is too low (< 4X), cannot infer qv's\n",Prog_Name);
         exit (1);
       }
  }

  //  Setup extras

  ex_cest.vtype = DB_INT;      // Estimated coverage (same for every .las)
  ex_cest.nelem = 1;
  ex_cest.accum = DB_EXACT;
  ex_cest.name  = cest_name;
  cover64 = COVERAGE;
  ex_cest.value = &cover64;

  ex_qvs.vtype = DB_INT;      //  Histogram of MAXQV1 trace-point diff counts
  ex_qvs.nelem = MAXQV1;
  ex_qvs.accum = DB_SUM;
  ex_qvs.name  = qvs_name;
  ex_qvs.value = &qgram;

  ex_dif.vtype = DB_INT;     //  Histogram of MAXQV1 intrinisic qv counts
  ex_dif.nelem = MAXQV1;
  ex_dif.accum = DB_SUM;
  ex_dif.name  = dif_name;
  ex_dif.value = &sgram;

  //  For each .las file do

  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;

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

          { 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 preliminary trimming track

          if (DB_PART > 0)
            { QV_AFILE = Fopen(Catenate(dpwd,PATHSEP,root,
                                        Numbered_Suffix(".",DB_PART,".qual.anno")),"w");
              QV_DFILE = Fopen(Catenate(dpwd,PATHSEP,root,
                                        Numbered_Suffix(".",DB_PART,".qual.data")),"w");
            }
          else
            { QV_AFILE = Fopen(Catenate(dpwd,PATHSEP,root,".qual.anno"),"w");
              QV_DFILE = Fopen(Catenate(dpwd,PATHSEP,root,".qual.data"),"w");
            }
          if (QV_AFILE == NULL || QV_DFILE == NULL)
            exit (1);

          { int size, length;

            length = DB_LAST - DB_FIRST;
            size   = sizeof(int64);
            fwrite(&length,sizeof(int),1,QV_AFILE);
            fwrite(&size,sizeof(int),1,QV_AFILE);
            QV_INDEX = 0;
            fwrite(&QV_INDEX,sizeof(int64),1,QV_AFILE);
          }

          //  Get trace point spacing information

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

          //  Initialize statistics gathering

          { int i;

            nreads = 0;
            totlen = 0;
            for (i = 0; i <= MAXQV; i++)
              qgram[i] = sgram[i] = 0;
          }

          if (VERBOSE)
            { printf("\n\nDASqv");
              if (HGAP_MIN > 0)
                printf(" -H%d",HGAP_MIN);
              printf(" -c%d %s %s\n\n",COVERAGE,argv[1],Block_Arg_Root(parse));
              fflush(stdout);
            }

          //  Process each read pile

          make_a_pass(input,CALCULATE_QVS,1);

          //  Write out extras and close .qual track

          Write_Extra(QV_AFILE,&ex_hgap);
          Write_Extra(QV_AFILE,&ex_cest);
          Write_Extra(QV_AFILE,&ex_qvs);
          Write_Extra(QV_AFILE,&ex_dif);

          fclose(QV_AFILE);
          fclose(QV_DFILE);
          fclose(input);

          //  If verbose output statistics summary to stdout

          if (VERBOSE)
            { int   i;
              int64 ssum, qsum;
              int64 stotal, qtotal;
              int   gval, bval;

              printf("\n  Input:  ");
              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 = qtotal = 0;
	      for (i = 0; i <= MAXQV; i++)
	        { stotal += sgram[i];
                  qtotal += qgram[i];
                }

              printf("\n  Histogram of q-values (average %d best)\n",2*QV_DEEP);
              printf("\n                   Input                 QV\n");
              qsum = qgram[MAXQV];
              ssum = sgram[MAXQV];
              printf("\n      %2d:  %9lld  %5.1f%%    %9lld  %5.1f%%\n\n",
                     MAXQV,sgram[MAXQV],(100.*ssum)/stotal,qgram[MAXQV],(100.*qsum)/qtotal);

              bval    = gval = -1;
              qtotal -= qsum;
              stotal -= ssum;
              ssum = qsum = 0;
              for (i = MAXQV-1; i >= 0; i--) 
                if (qgram[i] > 0)
                  { ssum += sgram[i];
                    qsum += qgram[i];
                    printf("      %2d:  %9lld  %5.1f%%    %9lld  %5.1f%%\n",
                           i,sgram[i],(100.*ssum)/stotal,
                             qgram[i],(100.*qsum)/qtotal);
                    if ((100.*qsum)/qtotal > 7. && bval < 0)
                      bval = i;
                    if ((100.*qsum)/qtotal > 20. && gval < 0)
                      gval = i;
                  }

              printf("\n    Recommend \'DAStrim -g%d -b%d'\n\n",gval,bval);
            }
        }

      Free_Block_Arg(parse);
    }

  //  Clean up

  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 $0x4fe8, %rsp           # imm = 0x4FE8
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x17e13(%rip), %rdi     # 0x1a33c
leaq 0x17eba(%rip), %rsi     # 0x1a3ea
callq 0x125ca
leaq 0x1e0a4(%rip), %rcx     # 0x205e0
movq %rax, (%rcx)
leaq 0x160(%rsp), %rdi
movl $0x200, %edx            # imm = 0x200
xorl %esi, %esi
callq 0x1140
movq %rbx, %rsi
movl $0xffffffff, 0x1dc50(%rip) # imm = 0xFFFFFFFF
movl $0x1, %r13d
cmpl $0x2, %ebp
movq %rbx, 0x8(%rsp)
jl 0x263b
movl %ebp, %r14d
movl $0x1, %ebx
leaq 0x17dbd(%rip), %r15     # 0x1a340
movq (%rsi,%rbx,8), %r12
cmpb $0x2d, (%r12)
jne 0x25e2
cmpb $0x63, 0x1(%r12)
jne 0x25ee
addq $0x2, %r12
movq %r12, %rdi
leaq 0xa8(%rsp), %rsi
movl $0xa, %edx
callq 0x11e0
movq 0x8(%rsp), %rsi
movl %eax, 0x1dbf6(%rip)     # 0x201b0
movq 0xa8(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x27bb
movq (%rsi,%rbx,8), %rcx
cmpb $0x0, 0x2(%rcx)
je 0x27bb
testl %eax, %eax
jg 0x262f
jmp 0x2821
movslq %r13d, %rax
incl %r13d
movq %r12, (%rsi,%rax,8)
jmp 0x262f
movb 0x1(%r12), %al
testb %al, %al
je 0x262f
addq $0x2, %r12
movsbl %al, %ebp
movq %r15, %rdi
movl %ebp, %esi
callq 0x1150
testq %rax, %rax
je 0x26bf
movslq %ebp, %rax
movl $0x1, 0x160(%rsp,%rax,4)
movb (%r12), %al
incq %r12
testb %al, %al
jne 0x25fb
movq 0x8(%rsp), %rsi
incq %rbx
cmpq %r14, %rbx
jne 0x2583
movl 0x338(%rsp), %eax
movl %eax, 0x1db6c(%rip)     # 0x201b4
cmpl $0x2, %r13d
jg 0x26e8
movq 0x1d99f(%rip), %rbx     # 0x1fff8
movq (%rbx), %rdi
leaq 0x1df7d(%rip), %rax     # 0x205e0
movq (%rax), %rdx
leaq 0x17a86(%rip), %rsi     # 0x1a0f3
leaq 0x17dca(%rip), %rcx     # 0x1a43e
xorl %eax, %eax
callq 0x11b0
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x1180
movq (%rbx), %rcx
leaq 0x17a6f(%rip), %rdi     # 0x1a101
movl $0x36, %esi
movl $0x1, %edx
callq 0x12a0
movq (%rbx), %rcx
leaq 0x17a8d(%rip), %rdi     # 0x1a138
movl $0x44, %esi
movl $0x1, %edx
callq 0x12a0
jmp 0x2817
movq 0x1d932(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
leaq 0x1df10(%rip), %rax     # 0x205e0
movq (%rax), %rdx
leaq 0x179a7(%rip), %rsi     # 0x1a081
movl %ebp, %ecx
xorl %eax, %eax
callq 0x11b0
jmp 0x2817
movq 0x8(%rsi), %rdi
leaq 0x1de45(%rip), %rsi     # 0x20538
callq 0x134c8
testl %eax, %eax
js 0x2817
cmpl $0x1, %eax
jne 0x272e
movq 0x1d8ec(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
leaq 0x1deca(%rip), %rax     # 0x205e0
movq (%rax), %rdx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
leaq 0x17a54(%rip), %rsi     # 0x1a17d
jmp 0x2810
cmpl $0x0, 0x1de3b(%rip)     # 0x20570
jne 0x27ec
leaq 0x1ddf6(%rip), %rdi     # 0x20538
callq 0x13c8d
movq 0x1de32(%rip), %rdi     # 0x20580
leaq 0x17d15(%rip), %rsi     # 0x1a46a
leaq 0x17a70(%rip), %rdx     # 0x1a1cc
leaq 0x17bc6(%rip), %rcx     # 0x1a329
callq 0x127a5
leaq 0x17a62(%rip), %rsi     # 0x1a1d1
movq %rax, %rdi
callq 0x125ca
testq %rax, %rax
je 0x2817
movq %rax, %r14
leaq 0x18c5c(%rip), %rsi     # 0x1b3e6
movq %rax, %rdi
callq 0x1260
testq %rax, %rax
jne 0x284f
movq 0x1d856(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
leaq 0x1de34(%rip), %rax     # 0x205e0
movq (%rax), %rdx
leaq 0x17a30(%rip), %rsi     # 0x1a1e6
jmp 0x2987
movq 0x1d836(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
leaq 0x1de14(%rip), %rax     # 0x205e0
movq (%rax), %rdx
movq (%rsi,%rbx,8), %r8
movsbl 0x1(%r8), %ecx
addq $0x2, %r8
leaq 0x178bc(%rip), %rsi     # 0x1a09f
xorl %eax, %eax
callq 0x11b0
jmp 0x2817
movq 0x1d805(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
leaq 0x1dde3(%rip), %rax     # 0x205e0
movq (%rax), %rdx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
leaq 0x17997(%rip), %rsi     # 0x1a1a7
xorl %eax, %eax
callq 0x11b0
movl $0x1, %edi
callq 0x1290
movq 0x1d7d0(%rip), %rcx     # 0x1fff8
movq (%rcx), %rdi
leaq 0x1ddae(%rip), %rcx     # 0x205e0
movq (%rcx), %rdx
leaq 0x1788c(%rip), %rsi     # 0x1a0c8
leaq 0x178a3(%rip), %rcx     # 0x1a0e6
movl %eax, %r8d
xorl %eax, %eax
callq 0x11b0
jmp 0x2817
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x1250
movq %r15, %rdi
callq 0x11c0
movl $0x8, %ecx
subl %eax, %ecx
movslq %ecx, %rsi
movq %r15, %rdi
movl $0x2, %edx
callq 0x1250
leaq 0xe0(%rsp), %rdx
movl $0x0, 0x4(%rdx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x15e09
testl %eax, %eax
jne 0x294f
leaq 0xa8(%rsp), %rdx
movl $0x0, 0x4(%rdx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x15e09
testl %eax, %eax
jne 0x296c
movq %r15, %rdi
callq 0x10d0
movq 0xc0(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x1d8dc(%rip)     # 0x201b8
cmpl $0x0, 0x1d8cd(%rip)     # 0x201b0
jns 0x2936
movq 0xf8(%rsp), %rax
movl 0xe4(%rsp), %esi
decl %esi
xorl %ecx, %ecx
movq %rcx, %rdx
movq 0x8(%rax,%rcx,8), %rdi
incq %rcx
cmpq (%rax,%rdx,8), %rdi
jl 0x28f8
leaq -0x1(%rcx), %rdx
movl %edx, 0x1d89d(%rip)     # 0x201b0
cmpl %ecx, %esi
jle 0x2936
movl %esi, %esi
movslq %edx, %rdi
movq (%rax,%rdi,8), %rdi
cmpq (%rax,%rcx,8), %rdi
jge 0x292e
movl %ecx, 0x1d884(%rip)     # 0x201b0
movl %ecx, %edx
incq %rcx
cmpq %rcx, %rsi
jne 0x2919
movslq 0x1d873(%rip), %rax     # 0x201b0
cmpq $0x28, %rax
jl 0x2993
movl %eax, %ecx
shrl $0x3, %ecx
movq 0x8(%rsp), %rsi
jmp 0x29b0
movq 0x1d6a2(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
leaq 0x1dc80(%rip), %rax     # 0x205e0
movq (%rax), %rdx
leaq 0x178a8(%rip), %rsi     # 0x1a212
jmp 0x2987
movq 0x1d685(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
leaq 0x1dc63(%rip), %rax     # 0x205e0
movq (%rax), %rdx
leaq 0x178ba(%rip), %rsi     # 0x1a241
xorl %eax, %eax
callq 0x11b0
jmp 0x2817
movl $0x5, %ecx
cmpl $0x13, %eax
movq 0x8(%rsp), %rsi
jg 0x29b0
cmpl $0x4, %eax
jl 0x3add
movl %eax, %ecx
shrl $0x2, %ecx
movl %ecx, 0x1d806(%rip)     # 0x201bc
movabsq $0x100000000, %rcx      # imm = 0x100000000
leaq 0x140(%rsp), %rdx
movq %rcx, (%rdx)
movl $0x0, 0x8(%rdx)
leaq 0x17667(%rip), %rcx     # 0x1a040
movq %rcx, 0x10(%rdx)
leaq 0xd0(%rsp), %rcx
movq %rax, (%rcx)
movq %rcx, 0x18(%rdx)
movabsq $0x3300000000, %rax     # imm = 0x3300000000
leaq 0x120(%rsp), %rdi
movq %rax, (%rdi)
movl $0x1, %ecx
movl %ecx, 0x8(%rdi)
leaq 0x17642(%rip), %rdx     # 0x1a052
movq %rdx, 0x10(%rdi)
leaq 0x1d7a5(%rip), %rdx     # 0x201c0
movq %rdx, 0x18(%rdi)
leaq 0x100(%rsp), %rdx
movq %rax, (%rdx)
movl %ecx, 0x8(%rdx)
leaq 0x1762f(%rip), %rax     # 0x1a063
movq %rax, 0x10(%rdx)
leaq 0x1d921(%rip), %rax     # 0x20360
movq %rax, 0x18(%rdx)
movq 0x8(%rsi), %rdi
movq %rsi, %rbx
callq 0x12686
movq %rax, 0x28(%rsp)
movq 0x8(%rbx), %rdi
leaq 0x17851(%rip), %rsi     # 0x1a2b0
callq 0x126e0
movq %rax, 0x20(%rsp)
cmpl $0x4, %r13d
movl $0x3, %eax
cmovgel %r13d, %eax
movq %rax, 0x60(%rsp)
movl $0x2, %ecx
movq 0x8(%rsp), %rax
movq %rcx, 0x68(%rsp)
movq (%rax,%rcx,8), %rdi
callq 0x16f0f
movq %rax, %r14
movq %rax, %rdi
callq 0x16d42
movq %rax, (%rsp)
testq %rax, %rax
je 0x3a60
movq %r14, 0x40(%rsp)
xorl %eax, %eax
movl %eax, 0x1da40(%rip)     # 0x204f8
movl %eax, 0x1da3e(%rip)     # 0x204fc
movl 0x1daa4(%rip), %eax     # 0x20568
movl %eax, 0x1da36(%rip)     # 0x20500
movq %r14, %rdi
callq 0x16df6
movq %rax, %rdi
movl $0x2e, %esi
callq 0x1270
testq %rax, %rax
je 0x2c5b
movq %rax, %r15
incq %r15
movq %r15, %rdi
leaq 0x50(%rsp), %rsi
movl $0xa, %edx
callq 0x11e0
movq %rax, %r13
movq 0x50(%rsp), %rax
cmpq %r15, %rax
je 0x2c5b
cmpb $0x0, (%rax)
jne 0x2c5b
movq 0x28(%rsp), %rdi
leaq 0x1778e(%rip), %rsi     # 0x1a2b4
movq 0x20(%rsp), %rdx
leaq 0x1777e(%rip), %rcx     # 0x1a2b0
callq 0x127a5
movq %rax, %rdi
leaq 0x188a5(%rip), %rsi     # 0x1b3e6
callq 0x12629
testq %rax, %rax
je 0x2817
movq %rax, %r15
movq %rax, %rdi
leaq 0x1775a(%rip), %rsi     # 0x1a2b6
leaq 0x1c(%rsp), %rdx
xorl %eax, %eax
callq 0x1090
cmpl $0x1, %eax
jne 0x3ab1
cmpl $0x0, 0x1c(%rsp)
jle 0x2ba0
xorl %ebx, %ebx
leaq 0x160(%rsp), %rdi
movl $0x4e84, %esi           # imm = 0x4E84
movq %r15, %rdx
callq 0x1190
testq %rax, %rax
je 0x3ab1
incl %ebx
cmpl 0x1c(%rsp), %ebx
jl 0x2b7a
movq %r15, %rdi
leaq 0x17739(%rip), %rsi     # 0x1a2e3
leaq 0xa4(%rsp), %rdx
xorl %eax, %eax
callq 0x1090
cmpl $0x1, %eax
jne 0x3ab1
movq %r15, %rdi
leaq 0x17725(%rip), %rsi     # 0x1a2f1
leaq 0xc8(%rsp), %rdx
leaq 0xa0(%rsp), %rcx
leaq 0x9c(%rsp), %r8
xorl %eax, %eax
callq 0x1090
cmpl $0x3, %eax
jne 0x3ab1
movl %r13d, %ebx
testl %r13d, %r13d
jle 0x2c26
movq %r15, %rdi
leaq 0x17711(%rip), %rsi     # 0x1a317
leaq 0x5c(%rsp), %rdx
leaq 0x1d8ea(%rip), %rcx     # 0x204fc
xorl %eax, %eax
callq 0x1090
cmpl $0x2, %eax
jne 0x3ab1
decl %ebx
jne 0x2bfc
movq %r15, %rdi
leaq 0x176e7(%rip), %rsi     # 0x1a317
leaq 0x5c(%rsp), %rdx
leaq 0x1d8c4(%rip), %rcx     # 0x20500
xorl %eax, %eax
callq 0x1090
cmpl $0x2, %eax
jne 0x3ab1
movq %r15, %rdi
callq 0x10d0
movl %r13d, 0x1d89d(%rip)    # 0x204f8
movl 0x1d897(%rip), %esi     # 0x204f8
testl %esi, %esi
jle 0x2cd9
leaq 0x177fe(%rip), %r15     # 0x1a46a
movq %r15, %rdi
leaq 0x176ae(%rip), %rdx     # 0x1a324
callq 0x12895
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
leaq 0x17697(%rip), %r12     # 0x1a321
movq %r12, %rsi
movq 0x20(%rsp), %r14
movq %r14, %rdx
movq %rax, %rcx
callq 0x127a5
movq %rax, %rdi
leaq 0x18165(%rip), %r13     # 0x1ae0c
movq %r13, %rsi
callq 0x12629
movq %rax, 0x1d852(%rip)     # 0x20508
movl 0x1d83c(%rip), %esi     # 0x204f8
movq %r15, %rdi
leaq 0x17669(%rip), %rdx     # 0x1a32f
callq 0x12895
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rax, %rcx
jmp 0x2d28
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
leaq 0x17639(%rip), %r15     # 0x1a321
movq %r15, %rsi
movq 0x20(%rsp), %r14
movq %r14, %rdx
leaq 0x1762a(%rip), %rcx     # 0x1a324
callq 0x127a5
movq %rax, %rdi
leaq 0x18103(%rip), %r13     # 0x1ae0c
movq %r13, %rsi
callq 0x12629
movq %rax, 0x1d7f0(%rip)     # 0x20508
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
leaq 0x17607(%rip), %rcx     # 0x1a32f
callq 0x127a5
movq %rax, %rdi
movq %r13, %rsi
callq 0x12629
movq %rax, 0x1d7d1(%rip)     # 0x20510
movq 0x1d7c2(%rip), %rcx     # 0x20508
testq %rcx, %rcx
je 0x2817
testq %rax, %rax
je 0x2817
movl 0x1d7a2(%rip), %eax     # 0x20500
subl 0x1d798(%rip), %eax     # 0x204fc
movl %eax, 0x50(%rsp)
movl $0x8, 0x160(%rsp)
movl $0x4, %esi
movl $0x1, %edx
leaq 0x50(%rsp), %rdi
callq 0x12a0
movq 0x1d77a(%rip), %rcx     # 0x20508
movl $0x4, %esi
movl $0x1, %edx
leaq 0x160(%rsp), %rdi
callq 0x12a0
xorl %ebx, %ebx
movq %rbx, 0x1d76a(%rip)     # 0x20518
movq 0x1d753(%rip), %rcx     # 0x20508
movl $0x8, %esi
movl $0x1, %edx
leaq 0x1d752(%rip), %rdi     # 0x20518
callq 0x12a0
movl $0x8, %esi
movl $0x1, %edx
leaq 0xd8(%rsp), %rdi
movq (%rsp), %r14
movq %r14, %rcx
callq 0x10c0
movl $0x4, %esi
movl $0x1, %edx
leaq 0x1d726(%rip), %rdi     # 0x20520
movq %r14, %rcx
callq 0x10c0
movq %rbx, 0x1d71f(%rip)     # 0x20528
movq %rbx, 0x1d720(%rip)     # 0x20530
movl $0x198, %edx            # imm = 0x198
leaq 0x1d544(%rip), %rdi     # 0x20360
xorl %esi, %esi
callq 0x1140
movl $0x198, %edx            # imm = 0x198
leaq 0x1d391(%rip), %rdi     # 0x201c0
xorl %esi, %esi
callq 0x1140
cmpl $0x0, 0x1d377(%rip)     # 0x201b4
je 0x2ea5
leaq 0x174f4(%rip), %rdi     # 0x1a33a
xorl %eax, %eax
callq 0x1110
movl 0x1d365(%rip), %esi     # 0x201b8
testl %esi, %esi
jle 0x2e65
leaq 0x174e4(%rip), %rdi     # 0x1a342
xorl %eax, %eax
callq 0x1110
movl 0x1d344(%rip), %r15d    # 0x201b0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %r12
movq 0x40(%rsp), %rdi
callq 0x16df6
leaq 0x174c2(%rip), %rdi     # 0x1a348
movl %r15d, %esi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1110
movq 0x1d13b(%rip), %rax     # 0x1ffd8
movq (%rax), %rdi
callq 0x1210
cmpq $0x0, 0x1d6fb(%rip)     # 0x205a8
jne 0x2eda
movslq 0x1d2c2(%rip), %rax     # 0x20178
shlq $0x4, %rax
leaq (%rax,%rax,2), %rdi
leaq 0x175a7(%rip), %rsi     # 0x1a46c
callq 0x1250d
movq %rax, 0x1d6d7(%rip)     # 0x205a8
testq %rax, %rax
je 0x2817
cmpq $0x0, 0x1d6ce(%rip)     # 0x205b0
jne 0x2f0a
movslq 0x1d291(%rip), %rdi     # 0x2017c
addq %rdi, %rdi
leaq 0x17591(%rip), %rsi     # 0x1a486
callq 0x1250d
movq %rax, 0x1d6af(%rip)     # 0x205b0
testq %rax, %rax
je 0x2817
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x1120
movl $0x8, %esi
movl $0x1, %edx
leaq 0x160(%rsp), %rdi
movq %rbx, %rcx
callq 0x10c0
movl $0x4, %esi
movl $0x1, %edx
leaq 0x1d5df(%rip), %rdi     # 0x20520
movq %rbx, %rcx
callq 0x10c0
xorl %eax, %eax
cmpl $0x7e, 0x1d5ce(%rip)    # 0x20520
setge %al
incl %eax
movl %eax, 0x1d65b(%rip)     # 0x205b8
movq 0x1d644(%rip), %rsi     # 0x205a8
movq %rbx, %rdi
callq 0x9970
movq 0x1d635(%rip), %rcx     # 0x205a8
testl %eax, %eax
je 0x2f83
movl $0x7fffffff, 0x24(%rcx) # imm = 0x7FFFFFFF
jmp 0x3015
movl 0x8(%rcx), %eax
cmpl 0x1d1f0(%rip), %eax     # 0x2017c
jle 0x2fd5
cvtsi2sd %eax, %xmm0
mulsd 0x1706e(%rip), %xmm0    # 0x1a008
addsd 0x1706e(%rip), %xmm0    # 0x1a010
cvttsd2si %xmm0, %eax
movl %eax, 0x1d1d0(%rip)     # 0x2017c
movq 0x1d5fd(%rip), %rdi     # 0x205b0
movslq %eax, %rsi
addq %rsi, %rsi
leaq 0x174dd(%rip), %rdx     # 0x1a49d
callq 0x12565
movq %rax, 0x1d5e4(%rip)     # 0x205b0
testq %rax, %rax
je 0x2817
movq 0x1d5d4(%rip), %rdi     # 0x205b0
movl 0x1d5d6(%rip), %esi     # 0x205b8
movq 0x1d5bf(%rip), %rax     # 0x205a8
movslq 0x8(%rax), %rdx
movq (%rsp), %rcx
callq 0x10c0
cmpl $0x1, 0x1d5bb(%rip)     # 0x205b8
jne 0x3015
movq 0x1d5aa(%rip), %rax     # 0x205b0
movq 0x1d59b(%rip), %rdi     # 0x205a8
movq %rax, (%rdi)
callq 0x9a7b
movq 0x1d58c(%rip), %rax     # 0x205a8
movslq 0x1d4d9(%rip), %r13     # 0x204fc
cmpl %r13d, 0x24(%rax)
jl 0x3afd
cmpl 0x1d4cc(%rip), %r13d    # 0x20500
jge 0x3753
xorl %esi, %esi
xorl %ebp, %ebp
movq 0x1d563(%rip), %r15     # 0x205a8
movslq %ebp, %rax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movupd (%r15,%rax), %xmm0
movupd 0x10(%r15,%rax), %xmm1
movupd 0x20(%r15,%rax), %xmm2
movupd %xmm2, 0x20(%r15)
movupd %xmm1, 0x10(%r15)
movupd %xmm0, (%r15)
movslq 0x24(%r15), %r14
cmpq %r14, %r13
jne 0x30bf
movq 0x1d52b(%rip), %rdi     # 0x205b0
movslq %esi, %rax
leaq (%rdi,%rax,2), %rsi
movslq 0x8(%r15), %rdx
addq %rdx, %rdx
callq 0x1240
movl 0x8(%r15), %ebp
addq $0x30, %r15
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x9970
movl $0x1, %ebx
testl %eax, %eax
je 0x30c6
movl $0x1, %ebp
jmp 0x3204
xorl %ebp, %ebp
jmp 0x3245
movl $0x30, %r15d
movq 0x1d4d5(%rip), %rax     # 0x205a8
movl 0x8(%rax,%r15), %eax
addl %ebp, %eax
cmpl 0x1d09c(%rip), %eax     # 0x2017c
jle 0x312c
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x16f17(%rip), %xmm0    # 0x1a008
addsd 0x16f17(%rip), %xmm0    # 0x1a010
cvttsd2si %xmm0, %eax
movl %eax, 0x1d079(%rip)     # 0x2017c
movq 0x1d4a6(%rip), %rdi     # 0x205b0
movslq %eax, %rsi
addq %rsi, %rsi
leaq 0x17386(%rip), %rdx     # 0x1a49d
callq 0x12565
movq %rax, 0x1d48d(%rip)     # 0x205b0
testq %rax, %rax
je 0x2817
movslq %ebp, %r12
addq %r12, %r12
movq 0x1d477(%rip), %rdi     # 0x205b0
addq %r12, %rdi
movl 0x1d476(%rip), %esi     # 0x205b8
movq 0x1d45f(%rip), %rax     # 0x205a8
movslq 0x8(%rax,%r15), %rdx
movq (%rsp), %rcx
callq 0x10c0
cmpl $0x1, 0x1d45a(%rip)     # 0x205b8
jne 0x317a
addq 0x1d449(%rip), %r12     # 0x205b0
movq 0x1d43a(%rip), %rdi     # 0x205a8
movq %r12, (%rdi,%r15)
addq %r15, %rdi
callq 0x9a7b
movq 0x1d427(%rip), %rdi     # 0x205a8
cmpl %r14d, 0x24(%rdi,%r15)
jne 0x374c
addl 0x8(%rdi,%r15), %ebp
incq %rbx
cmpl %ebx, 0x1cfde(%rip)     # 0x20178
jg 0x31e3
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
mulsd 0x16e5d(%rip), %xmm0    # 0x1a008
addsd 0x16e65(%rip), %xmm0    # 0x1a018
cvttsd2si %xmm0, %eax
movl %eax, 0x1cfbb(%rip)     # 0x20178
cltq
shlq $0x4, %rax
leaq (%rax,%rax,2), %rsi
leaq 0x17329(%rip), %rdx     # 0x1a4f7
callq 0x12565
movq %rax, 0x1d3ce(%rip)     # 0x205a8
testq %rax, %rax
je 0x2817
addq $0x30, %r15
movq 0x1d3ba(%rip), %rsi     # 0x205a8
addq %r15, %rsi
movq (%rsp), %rdi
callq 0x9970
testl %eax, %eax
je 0x30cc
movl %ebx, %ebp
movq 0x1d39d(%rip), %rax     # 0x205a8
leaq (%rbx,%rbx,2), %rcx
shlq $0x4, %rcx
movl $0x7fffffff, 0x24(%rax,%rcx) # imm = 0x7FFFFFFF
movq 0x1d38e(%rip), %rax     # 0x205b0
movq 0x1d37f(%rip), %rcx     # 0x205a8
addq $0x8, %rcx
xorl %esi, %esi
movslq %esi, %rsi
leaq (%rax,%rsi,2), %rdx
movq %rdx, -0x8(%rcx)
addl (%rcx), %esi
addq $0x30, %rcx
decq %rbx
jne 0x322f
movq %rsi, 0x70(%rsp)
movq 0x1d347(%rip), %rax     # 0x20598
movq %r13, 0x78(%rsp)
movslq %r13d, %rcx
leaq (%rcx,%rcx,4), %rcx
movslq 0x4(%rax,%rcx,8), %rsi
movl 0x1d2b8(%rip), %ecx     # 0x20520
leal (%rsi,%rcx), %eax
decl %eax
cltd
idivl %ecx
movq %rsi, 0x38(%rsp)
cmpl 0x1cf3d(%rip), %esi     # 0x201b8
jl 0x3710
movl %eax, %r14d
movq 0x1d31d(%rip), %r15     # 0x205a8
cmpl 0x1d32b(%rip), %eax     # 0x205bc
movsd 0x16d8f(%rip), %xmm2    # 0x1a028
jle 0x33a2
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
mulsd 0x16d59(%rip), %xmm0    # 0x1a008
addsd 0x16d61(%rip), %xmm0    # 0x1a018
cvttsd2si %xmm0, %eax
movl %eax, 0x1d2fb(%rip)     # 0x205bc
movq 0x1d2f8(%rip), %rdi     # 0x205c0
imull $0x33, %eax, %eax
movslq %eax, %rsi
shlq $0x2, %rsi
leaq 0x17237(%rip), %rbx     # 0x1a510
movq %rbx, %rdx
callq 0x12565
movq %rax, 0x1d2d8(%rip)     # 0x205c0
movq 0x1d2d9(%rip), %rdi     # 0x205c8
movslq 0x1d2c6(%rip), %rax     # 0x205bc
imulq $0xcc, %rax, %rsi
movq %rbx, %rdx
callq 0x12565
movq %rax, 0x1d2bc(%rip)     # 0x205c8
movq 0x1d2bd(%rip), %rdi     # 0x205d0
movslq 0x1d2a2(%rip), %rsi     # 0x205bc
leaq 0x17205(%rip), %rdx     # 0x1a526
callq 0x12565
movq %rax, 0x1d2a3(%rip)     # 0x205d0
movq 0x1d28c(%rip), %rcx     # 0x205c0
testq %rcx, %rcx
je 0x2817
movq 0x1d284(%rip), %rdx     # 0x205c8
testq %rdx, %rdx
je 0x2817
testq %rax, %rax
je 0x2817
movl 0x1d260(%rip), %eax     # 0x205bc
testl %eax, %eax
movl $0x0, %edi
jle 0x337d
imull $0x33, %eax, %eax
leal 0x1(%rax), %esi
decl %eax
movl %edi, (%rdx,%rax,4)
movl %edi, (%rcx,%rax,4)
decl %esi
decq %rax
cmpl $0x1, %esi
jg 0x336d
xorps %xmm0, %xmm0
cvtsi2sdl 0x1d198(%rip), %xmm0 # 0x20520
mulsd 0x16c90(%rip), %xmm0    # 0x1a020
cvttsd2si %xmm0, %eax
movl %eax, 0x1d23e(%rip)     # 0x205d8
movsd 0x16c86(%rip), %xmm2    # 0x1a028
movl %r14d, 0x10(%rsp)
movl %ebp, 0x14(%rsp)
testl %ebp, %ebp
jle 0x34d7
movl 0x1d21f(%rip), %ecx     # 0x205d8
movl 0x14(%rsp), %esi
movq 0x1d1fc(%rip), %rdi     # 0x205c0
movq 0x1d1fd(%rip), %r8      # 0x205c8
xorl %r9d, %r9d
leaq (%r9,%r9,2), %r14
shlq $0x4, %r14
movq (%r15,%r14), %r11
movl 0x8(%r15,%r14), %r12d
testb $0x1, 0x20(%r15,%r14)
movq %r8, %r10
cmoveq %rdi, %r10
movl 0x10(%r15,%r14), %eax
movl 0x1d128(%rip), %r13d    # 0x20520
cltd
idivl %r13d
imull $0x33, %eax, %eax
leal 0x33(%rax), %ebx
xorl %ebp, %ebp
testl %edx, %edx
cmovel %eax, %ebx
setne %bpl
addl %ebp, %ebp
movl 0x18(%r15,%r14), %eax
cltd
idivl %r13d
leal -0x2(%r12), %eax
testl %edx, %edx
cmovel %r12d, %eax
cmpl %eax, %ebp
jge 0x347d
movl %ebp, %r12d
movslq %eax, %r13
movslq %ebx, %rbx
movzwl (%r11,%r12,2), %ebp
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movzwl 0x2(%r11,%r12,2), %ebp
addl 0x1d0d8(%rip), %ebp     # 0x20520
mulsd %xmm2, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %ebp, %xmm1
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %ebp
movslq %ebp, %rbp
cmpq $0x32, %rbp
jl 0x3469
movl $0x32, %ebp
addq %rbx, %rbp
incl (%r10,%rbp,4)
addq $0x33, %rbx
addq $0x2, %r12
cmpq %r13, %r12
jl 0x3430
addq %r15, %r14
movq 0x38(%rsp), %r12
cmpl %r12d, 0x18(%r14)
jne 0x34cb
cmpl %ecx, %edx
jl 0x34cb
cltq
movzwl (%r11,%rax,2), %ebp
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movzwl 0x2(%r11,%rax,2), %eax
addl %eax, %edx
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
mulsd %xmm2, %xmm0
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
cmpl $0x32, %eax
movl $0x32, %edx
cmovgel %edx, %eax
addl %ebx, %eax
cltq
incl (%r10,%rax,4)
incq %r9
cmpq %rsi, %r9
jne 0x33ce
movl 0x10(%rsp), %r8d
testl %r8d, %r8d
jle 0x36d4
movq 0x1d0dc(%rip), %r13     # 0x205c8
movq 0x1d0cd(%rip), %r14     # 0x205c0
movl 0x1ccc2(%rip), %r10d    # 0x201bc
movq 0x1d0cf(%rip), %rax     # 0x205d0
movq %rax, 0x90(%rsp)
movl %r8d, %r9d
leaq 0x4(%r13), %rax
movq %rax, 0x88(%rsp)
leaq 0x4(%r14), %rax
movq %rax, 0x80(%rsp)
xorl %ecx, %ecx
movq %r9, 0x30(%rsp)
movl %r10d, 0x18(%rsp)
movq %rcx, 0x48(%rsp)
imulq $0xcc, %rcx, %rax
movq 0x88(%rsp), %rcx
leaq (%rcx,%rax), %r8
leaq 0x1ce11(%rip), %rcx     # 0x20360
xorl %edx, %edx
movslq (%r14,%rdx,4), %rsi
movslq (%r13,%rdx,4), %rdi
addq %rsi, %rdi
addq %rdi, (%rcx)
incq %rdx
addq $0x8, %rcx
cmpq $0x33, %rdx
jne 0x3551
addq 0x80(%rsp), %rax
xorl %ecx, %ecx
xorl %r15d, %r15d
xorl %ebx, %ebx
movl %r15d, %edx
movl (%r14,%rcx,4), %esi
movl $0x0, (%r14,%rcx,4)
addl %esi, %ebx
movl %ecx, %r15d
imull %esi, %r15d
addl %edx, %r15d
movl %r10d, %edx
subl %ebx, %edx
jle 0x35ae
incq %rcx
cmpq $0x33, %rcx
jne 0x357c
movl $0x33, %ecx
jmp 0x35b7
imull %ecx, %edx
addl %edx, %r15d
movl %r10d, %ebx
cmpl $0x31, %ecx
ja 0x35e8
movl %ecx, %edx
leaq (%rax,%rdx,4), %rdi
movl $0x31, %eax
subl %ecx, %eax
leaq 0x4(,%rax,4), %rdx
xorl %esi, %esi
movq %r8, %r12
callq 0x1140
movq %r12, %r8
movl 0x18(%rsp), %r10d
movq 0x30(%rsp), %r9
xorl %eax, %eax
xorl %r12d, %r12d
xorl %ebp, %ebp
movl %r12d, %ecx
movl (%r13,%rax,4), %edx
movl $0x0, (%r13,%rax,4)
addl %edx, %ebp
movl %eax, %r12d
imull %edx, %r12d
addl %ecx, %r12d
movl %r10d, %ecx
subl %ebp, %ecx
jle 0x3623
incq %rax
cmpq $0x33, %rax
jne 0x35ef
movl $0x33, %eax
jmp 0x362c
imull %eax, %ecx
addl %ecx, %r12d
movl %r10d, %ebp
cmpl $0x31, %eax
ja 0x3657
movl %eax, %ecx
leaq (%r8,%rcx,4), %rdi
movl $0x31, %ecx
subl %eax, %ecx
leaq 0x4(,%rcx,4), %rdx
xorl %esi, %esi
callq 0x1140
movl 0x18(%rsp), %r10d
movq 0x30(%rsp), %r9
movl $0x32, %ecx
movl $0x32, %esi
cmpl $0x2, %ebx
jl 0x366e
movl %r15d, %eax
cltd
idivl %ebx
movl %eax, %esi
cmpl $0x2, %ebp
jl 0x367b
movl %r12d, %eax
cltd
idivl %ebp
movl %eax, %ecx
cmpl %ecx, %esi
cmovgl %esi, %ecx
movq 0x90(%rsp), %rax
movq 0x48(%rsp), %rdx
movb %cl, (%rax,%rdx)
movq %rdx, %rcx
movl $0xcc, %eax
addq %rax, %r14
addq %rax, %r13
incq %rcx
cmpq %r9, %rcx
jne 0x3530
movl 0x10(%rsp), %r8d
testl %r8d, %r8d
leaq 0x1cb07(%rip), %rsi     # 0x201c0
jle 0x36d4
movq 0x1cf0e(%rip), %rax     # 0x205d0
xorl %ecx, %ecx
movzbl (%rax,%rcx), %edx
incq (%rsi,%rdx,8)
incq %rcx
cmpq %rcx, %r9
jne 0x36c4
incq 0x1ce4d(%rip)           # 0x20528
movq 0x38(%rsp), %rax
addq %rax, 0x1ce49(%rip)     # 0x20530
movq 0x1cee2(%rip), %rdi     # 0x205d0
movslq %r8d, %r15
movq 0x1ce18(%rip), %rcx     # 0x20510
movl $0x1, %esi
movq %r15, %rdx
callq 0x12a0
addq %r15, 0x1ce0c(%rip)     # 0x20518
movl 0x14(%rsp), %ebp
movq 0x1cdf1(%rip), %rcx     # 0x20508
movl $0x8, %esi
movl $0x1, %edx
leaq 0x1cdf0(%rip), %rdi     # 0x20518
callq 0x12a0
movq 0x78(%rsp), %r13
incq %r13
movslq 0x1cdc4(%rip), %rax     # 0x20500
cmpq %rax, %r13
movq 0x70(%rsp), %rsi
jl 0x303e
jmp 0x3757
movl %ebx, %ebp
jmp 0x321b
xorl %eax, %eax
jmp 0x375a
movslq %ebp, %rax
movq 0x1ce47(%rip), %rcx     # 0x205a8
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
cmpl $0x7fffffff, 0x24(%rcx,%rax) # imm = 0x7FFFFFFF
movq 0x1c860(%rip), %rbx     # 0x1ffd8
movq 0x40(%rsp), %r14
jne 0x3afd
movq 0x1cd7e(%rip), %rdi     # 0x20508
leaq 0xa8(%rsp), %rsi
callq 0x161ae
movq 0x1cd6a(%rip), %rdi     # 0x20508
leaq 0x140(%rsp), %rsi
callq 0x161ae
movq 0x1cd56(%rip), %rdi     # 0x20508
leaq 0x120(%rsp), %rsi
callq 0x161ae
movq 0x1cd42(%rip), %rdi     # 0x20508
leaq 0x100(%rsp), %rsi
callq 0x161ae
movq 0x1cd2e(%rip), %rdi     # 0x20508
callq 0x10d0
movq 0x1cd2a(%rip), %rdi     # 0x20510
callq 0x10d0
movq (%rsp), %rdi
callq 0x10d0
cmpl $0x0, 0x1c9b9(%rip)     # 0x201b4
je 0x3a4b
leaq 0x16b4e(%rip), %rdi     # 0x1a356
xorl %eax, %eax
callq 0x1110
movq 0x1cd12(%rip), %rdi     # 0x20528
movq (%rbx), %rdx
movl $0x7, %esi
callq 0x12948
leaq 0x16b38(%rip), %rdi     # 0x1a362
xorl %eax, %eax
callq 0x1110
movq 0x1ccf8(%rip), %rdi     # 0x20530
movq (%rbx), %rdx
movl $0xc, %esi
callq 0x12948
leaq 0x16b1f(%rip), %rdi     # 0x1a36b
xorl %eax, %eax
callq 0x1110
cmpl $0x0, 0x1c95e(%rip)     # 0x201b8
jle 0x389a
leaq 0x16b0f(%rip), %rdi     # 0x1a372
xorl %eax, %eax
callq 0x1110
movslq 0x1cc8f(%rip), %rdi     # 0x20500
movslq 0x1cc84(%rip), %rax     # 0x204fc
subq %rax, %rdi
subq 0x1cca6(%rip), %rdi     # 0x20528
movq (%rbx), %rdx
xorl %esi, %esi
callq 0x12948
leaq 0x16aea(%rip), %rdi     # 0x1a37d
xorl %eax, %eax
callq 0x1110
movl $0xa, %edi
callq 0x1040
xorl %eax, %eax
xorl %ebx, %ebx
xorl %r12d, %r12d
leaq 0x1c90e(%rip), %rcx     # 0x201c0
leaq 0x1caa7(%rip), %rdx     # 0x20360
addq (%rax,%rdx), %r12
addq (%rax,%rcx), %rbx
addq $0x8, %rax
cmpq $0x198, %rax            # imm = 0x198
jne 0x38b9
movl 0x1c8e9(%rip), %esi     # 0x201bc
addl %esi, %esi
leaq 0x16ab3(%rip), %rdi     # 0x1a38f
xorl %eax, %eax
callq 0x1110
leaq 0x16c51(%rip), %rdi     # 0x1a53b
callq 0x10a0
movq 0x1ca5a(%rip), %r14     # 0x20350
movq 0x1cbf3(%rip), %r15     # 0x204f0
cvtsi2sd %r15, %xmm0
cvtsi2sd %r12, %xmm1
movsd 0x16709(%rip), %xmm2    # 0x1a018
mulsd %xmm2, %xmm0
divsd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r14, %xmm1
mulsd %xmm2, %xmm1
xorps %xmm2, %xmm2
cvtsi2sd %rbx, %xmm2
divsd %xmm2, %xmm1
leaq 0x16a85(%rip), %rdi     # 0x1a3bb
movl $0x32, %esi
movq %r15, %rdx
movq %r14, %rcx
movb $0x2, %al
callq 0x1110
leaq 0x1ca11(%rip), %rdx     # 0x20360
leaq 0x1c86a(%rip), %rax     # 0x201c0
subq %r15, %r12
xorps %xmm0, %xmm0
cvtsi2sd %r12, %xmm0
movsd %xmm0, 0x38(%rsp)
subq %r14, %rbx
xorps %xmm0, %xmm0
cvtsi2sd %rbx, %xmm0
movsd %xmm0, 0x30(%rsp)
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl $0x31, %ebx
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
xorl %r13d, %r13d
xorl %ebp, %ebp
movq (%rax,%rbx,8), %rcx
testq %rcx, %rcx
jle 0x3a28
movq (%rdx,%rbx,8), %rdx
addq %rdx, %rbp
xorps %xmm0, %xmm0
cvtsi2sd %rbp, %xmm0
addq %rcx, %r13
movsd 0x16663(%rip), %xmm2    # 0x1a018
mulsd %xmm2, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r13, %xmm1
divsd 0x38(%rsp), %xmm0
mulsd %xmm2, %xmm1
divsd 0x30(%rsp), %xmm1
movl %ebx, %r12d
leaq 0x16a10(%rip), %rdi     # 0x1a3eb
movl %ebx, %esi
movsd %xmm1, 0x48(%rsp)
movb $0x2, %al
callq 0x1110
movl %ebx, %eax
testl %r14d, %r14d
js 0x39f4
movl %r14d, %eax
movsd 0x48(%rsp), %xmm0
ucomisd 0x1662e(%rip), %xmm0    # 0x1a030
cmoval %eax, %r14d
testl %r15d, %r15d
js 0x3a0e
movl %r15d, %r12d
ucomisd 0x16622(%rip), %xmm0    # 0x1a038
cmoval %r12d, %r15d
leaq 0x1c79f(%rip), %rax     # 0x201c0
leaq 0x1c938(%rip), %rdx     # 0x20360
addq $-0x1, %rbx
jb 0x398e
leaq 0x169e0(%rip), %rdi     # 0x1a419
movl %r15d, %esi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1110
movq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x16d42
movq %rax, (%rsp)
testq %rax, %rax
jne 0x2ab0
movq %r14, %rdi
callq 0x16e21
movq 0x68(%rsp), %rcx
incq %rcx
cmpq 0x60(%rsp), %rcx
jne 0x2a80
movq 0x28(%rsp), %rdi
callq 0x1030
movq 0x20(%rsp), %rdi
callq 0x1030
leaq 0x1caa2(%rip), %rdi     # 0x20538
callq 0x144a0
leaq 0x1cb3e(%rip), %rax     # 0x205e0
movq (%rax), %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1290
movq 0x1c540(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
leaq 0x1cb1e(%rip), %rax     # 0x205e0
movq (%rax), %rdx
leaq 0x167f7(%rip), %rsi     # 0x1a2c3
xorl %eax, %eax
callq 0x11b0
movl $0x2, %edi
callq 0x1290
movq 0x1c514(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
leaq 0x1caf2(%rip), %rax     # 0x205e0
movq (%rax), %rdx
leaq 0x1677d(%rip), %rsi     # 0x1a275
jmp 0x2987
movq 0x1c4f4(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
leaq 0x1cad2(%rip), %rax     # 0x205e0
movq (%rax), %rdx
movl 0x1c9e1(%rip), %ecx     # 0x204f8
leaq 0x16995(%rip), %rsi     # 0x1a4b3
jmp 0x26dc
nop