// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/REPtrim.c
// Function: main
int main(int argc, char *argv[])
{ int c;

  //  Process arguments

  Prog_Name = Strdup("REPtrim","");

  if (argc < 2)
    { fprintf(stderr,"Usage: %s %s\n",Prog_Name,Usage);
      exit (1);
    }

  //  Open trimmed DB and .qual and .trim tracks

  for (c = 1; c < argc; c++)

    { DAZZ_DB    _DB, *DB  = &_DB;
      DAZZ_EXTRA ex_hgap, ex_cest, ex_good, ex_bad, ex_trim;

      //  Load DB

      { int status;

        status = Open_DB(argv[c],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);
          }
        Trim_DB(DB);
      }

      //  Get .trim track extras

      { FILE *afile;
        char *aname;
        int   extra, tracklen, size;

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

        fread(&tracklen,sizeof(int),1,afile);
        fread(&size,sizeof(int),1,afile);
        fseeko(afile,0,SEEK_END);
        extra = ftell(afile) - (size*(tracklen+1) + 2*sizeof(int));
        fseeko(afile,-extra,SEEK_END);
        ex_hgap.nelem = 0;
        if (Read_Extra(afile,aname,&ex_hgap) != 0)
          { fprintf(stderr,"%s: Hgap threshold extra missing from .trim track?\n",Prog_Name);
            exit (1);
          }
        ex_cest.nelem = 0;
        if (Read_Extra(afile,aname,&ex_cest) != 0)
          { fprintf(stderr,"%s: Coverage estimate extra missing from .trim track?\n",Prog_Name);
            exit (1);
          }
        ex_good.nelem = 0;
        if (Read_Extra(afile,aname,&ex_good) != 0)
          { fprintf(stderr,"%s: Good QV threshold extra missing from .trim track?\n",Prog_Name);
            exit (1);
          }
        ex_bad.nelem = 0;
        if (Read_Extra(afile,aname,&ex_bad) != 0)
          { fprintf(stderr,"%s: Bad QV threshdold extra missing from .trim track?\n",Prog_Name);
            exit (1);
          }
        ex_trim.nelem = 0;
        if (Read_Extra(afile,aname,&ex_trim) != 0)
          { fprintf(stderr,"%s: Trimming statistics extra missing from .trim track?\n",Prog_Name);
            exit (1);
          }
        fclose(afile);
      }

      //  Generate Display

      { char       *root;
        int64       nreads, totlen;
        int64       nelim, nelimbp;
        int64       n5trm, n5trmbp;
        int64       n3trm, n3trmbp;
        int64       natrm, natrmbp;
        int64       ngaps, ngapsbp;
        int64       nlowq, nlowqbp;
        int64       nspan, nspanbp;
        int64       nchim, nchimbp;
        int         rlog, blog;
        int         cover, hgap_min;
        int         bad_qv, good_qv;
        int64      *tstats;

        //  Get relevant variables

        root   = Root(argv[c],".db");
        nreads = DB->nreads;
        totlen = DB->totlen;

        hgap_min = (int) ((int64 *) (ex_hgap.value))[0];
        cover    = (int) ((int64 *) (ex_cest.value))[0];
        good_qv  = (int) ((int64 *) (ex_good.value))[0];
        bad_qv   = (int) ((int64 *) (ex_bad.value))[0];
        tstats   = (int64 *) (ex_trim.value);

        nelim   = tstats[0];
        n5trm   = tstats[1];
        n3trm   = tstats[2];
        natrm   = tstats[3];
        nelimbp = tstats[4];
        n5trmbp = tstats[5];
        n3trmbp = tstats[6];
        natrmbp = tstats[7];

        ngaps   = tstats[8];
        nlowq   = tstats[9];
        nspan   = tstats[10];
        nchim   = tstats[11];
        ngapsbp = tstats[12];
        nlowqbp = tstats[13];
        nspanbp = tstats[14];
        nchimbp = tstats[15];

        printf("\nDAStrim");
        if (hgap_min > 0)
          printf(" [-H%d]",hgap_min);
        printf(" -c%d -g%d -b%d %s\n\n",cover,good_qv,bad_qv,root);

        //  Compensate for HGAP

        if (hgap_min > 0)
          { int i;

            for (i = 0; i < DB->nreads; i++)
              if (DB->reads[i].rlen < hgap_min)
                { nreads -= 1;
                  totlen -= DB->reads[i].rlen;
                }
          }

        //  Compute maximum field widths of statistics

        { int64 mult;

          rlog = 0;
          mult = 1;
          while (mult <= nreads || mult <= ngaps)
            { mult *= 10;
              rlog += 1;
            }
          if (rlog <= 3)
            rlog = 3;
          else
            rlog += (rlog-1)/3;
  
          blog = 0;
          mult = 1;
          while (mult <= totlen)
            { mult *= 10;
              blog += 1;
            }
          if (blog <= 3)
            blog = 3;
          else
            blog += (blog-1)/3;
        }

        //  Display the statistices

        printf("  Input:    ");
        Print_Number((int64) nreads,rlog,stdout);
        printf(" (100.0%%) reads     ");
        Print_Number(totlen,blog,stdout);
        printf(" (100.0%%) bases");
        if (hgap_min > 0)
          { printf(" (another ");
            Print_Number((int64) (DB->nreads-nreads),0,stdout);
            printf(" were < H-length)");
          }
        printf("\n");

        printf("  Trimmed:  ");
        Print_Number(nelim,rlog,stdout);
        printf(" (%5.1f%%) reads     ",(100.*nelim)/nreads);
        Print_Number(nelimbp,blog,stdout);
        printf(" (%5.1f%%) bases\n",(100.*nelimbp)/totlen);

        printf("  5' trim:  ");
        Print_Number(n5trm,rlog,stdout);
        printf(" (%5.1f%%) reads     ",(100.*n5trm)/nreads);
        Print_Number(n5trmbp,blog,stdout);
        printf(" (%5.1f%%) bases\n",(100.*n5trmbp)/totlen);

        printf("  3' trim:  ");
        Print_Number(n3trm,rlog,stdout);
        printf(" (%5.1f%%) reads     ",(100.*n3trm)/nreads);
        Print_Number(n3trmbp,blog,stdout);
        printf(" (%5.1f%%) bases\n",(100.*n3trmbp)/totlen);

        printf("  Adapter:  ");
        Print_Number(natrm,rlog,stdout);
        printf(" (%5.1f%%) reads     ",(100.*natrm)/nreads);
        Print_Number(natrmbp,blog,stdout);
        printf(" (%5.1f%%) bases\n",(100.*natrmbp)/totlen);

        printf("\n");

        printf("  Gaps:     ");
        Print_Number(ngaps,rlog,stdout);
        printf(" (%5.1f%%) gaps      ",(100.*(ngaps))/nreads);
        Print_Number(ngapsbp,blog,stdout);
        printf(" (%5.1f%%) bases\n",(100.*(ngapsbp))/totlen);

        printf("    Low QV: ");
        Print_Number(nlowq,rlog,stdout);
        printf(" (%5.1f%%) gaps      ",(100.*(nlowq))/nreads);
        Print_Number(nlowqbp,blog,stdout);
        printf(" (%5.1f%%) bases\n",(100.*(nlowqbp))/totlen);

        printf("    Span'd: ");
        Print_Number(nspan,rlog,stdout);
        printf(" (%5.1f%%) gaps      ",(100.*(nspan))/nreads);
        Print_Number(nspanbp,blog,stdout);
        printf(" (%5.1f%%) bases\n",(100.*(nspanbp))/totlen);

        printf("    Break:  ");
        Print_Number(nchim,rlog,stdout);
        printf(" (%5.1f%%) gaps      ",(100.*(nchim))/nreads);
        Print_Number(nchimbp,blog,stdout);
        printf(" (%5.1f%%) bases\n",(100.*(nchimbp))/totlen);

        printf("\n");

        printf("  Clipped:  ");
        Print_Number(n5trm+n3trm+nelim+nchim,rlog,stdout);
        printf(" clips              ");
        Print_Number(n5trmbp+n3trmbp+nelimbp+nchimbp,blog,stdout);
        printf(" (%5.1f%%) bases\n",(100.*(n5trmbp+n3trmbp+nelimbp+nchimbp))/totlen);

        printf("  Patched:  ");
        Print_Number(nlowq+nspan,rlog,stdout);
        printf(" patches            ");
        Print_Number(nlowqbp+nspanbp,blog,stdout);
        printf(" (%5.1f%%) bases\n",(100.*(nlowqbp+nspanbp))/totlen);

        free(root);
        Close_DB(DB);
      }
    }

  free(Prog_Name);
  exit (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rsi, %r15
movl %edi, %ebx
leaq 0x8c47(%rip), %rdi      # 0xa010
leaq 0x8e2f(%rip), %rsi      # 0xa1ff
callq 0x201c
leaq 0xddac(%rip), %rcx      # 0xf188
movq %rax, (%rcx)
cmpl $0x2, %ebx
jge 0x140b
movq 0xdc0d(%rip), %rcx      # 0xeff8
movq (%rcx), %rdi
leaq 0x8c23(%rip), %rsi      # 0xa018
leaq 0x8f3f(%rip), %rcx      # 0xa33b
movq %rax, %rdx
xorl %eax, %eax
callq 0x11a0
jmp 0x1f25
movl %ebx, %eax
movq %rax, 0x78(%rsp)
pushq $0x1
popq %r12
leaq 0x168(%rsp), %rbx
movq %r15, 0x70(%rsp)
cmpq 0x78(%rsp), %r12
je 0x1e04
movq (%r15,%r12,8), %rdi
movq %rbx, %rsi
callq 0x2e04
testl %eax, %eax
js 0x1f25
cmpl $0x1, %eax
je 0x1e1a
movq %rbx, %rdi
callq 0x36aa
movl 0x1a0(%rsp), %esi
movq 0x1b0(%rsp), %rbx
testl %esi, %esi
movq %r12, 0x68(%rsp)
je 0x14c7
leaq 0x8ed7(%rip), %rdi      # 0xa349
movq %rdi, %rdx
callq 0x2322
movq %rbx, %rdi
movq %rax, %rsi
leaq 0x8b8c(%rip), %rdx      # 0xa013
leaq 0x8bc2(%rip), %rcx      # 0xa050
callq 0x21fb
movq %rax, %rdi
leaq 0x8bb9(%rip), %rsi      # 0xa056
callq 0x201c
testq %rax, %rax
je 0x1f25
movq %rax, %rbx
movq %rax, %rdi
leaq 0x99bf(%rip), %rsi      # 0xae77
callq 0x1240
testq %rax, %rax
jne 0x1517
jmp 0x1ed8
movq %rbx, %rdi
leaq 0x8e78(%rip), %rsi      # 0xa349
leaq 0x8b3b(%rip), %rdx      # 0xa013
leaq 0x8b71(%rip), %rcx      # 0xa050
callq 0x21fb
movq %rax, %rdi
leaq 0x8b68(%rip), %rsi      # 0xa056
callq 0x201c
testq %rax, %rax
je 0x1f25
movq %rax, %rbx
movq %rax, %rdi
leaq 0x996e(%rip), %rsi      # 0xae77
callq 0x1240
testq %rax, %rax
je 0x1f03
movq %rax, %r14
leaq 0x24(%rsp), %rdi
pushq $0x4
popq %r13
movq %r13, %rsi
pushq $0x1
popq %r12
movq %r12, %rdx
movq %rax, %rcx
callq 0x10b0
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x10b0
movq %r14, %rdi
xorl %esi, %esi
pushq $0x2
popq %rbp
movl %ebp, %edx
callq 0x1230
movq %r14, %rdi
callq 0x11b0
movl 0x24(%rsp), %ecx
incl %ecx
imull 0x20(%rsp), %ecx
subl %eax, %ecx
addl $0x8, %ecx
movslq %ecx, %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x1230
andl $0x0, 0x14c(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
leaq 0x148(%rsp), %rdx
callq 0x56fd
testl %eax, %eax
jne 0x1e3e
andl $0x0, 0x12c(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
leaq 0x128(%rsp), %rdx
callq 0x56fd
testl %eax, %eax
jne 0x1e5e
andl $0x0, 0x10c(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
leaq 0x108(%rsp), %rdx
callq 0x56fd
testl %eax, %eax
jne 0x1e7e
andl $0x0, 0xec(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
leaq 0xe8(%rsp), %rdx
callq 0x56fd
testl %eax, %eax
jne 0x1e9e
andl $0x0, 0xcc(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
leaq 0xc8(%rsp), %rdx
callq 0x56fd
testl %eax, %eax
jne 0x1ebb
movq %r14, %rdi
callq 0x10c0
movq 0x68(%rsp), %rax
movq (%r15,%rax,8), %rdi
leaq 0x8b93(%rip), %rsi      # 0xa1d6
callq 0x2137
movq %rax, %r15
movq 0x160(%rsp), %rax
movl (%rax), %r14d
movq 0x140(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x8(%rsp)
movq 0x120(%rsp), %rax
movl (%rax), %r13d
movq 0x100(%rsp), %rax
movl (%rax), %r12d
movq 0xe0(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x38(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x40(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x18(%rax), %rcx
movq %rcx, 0x80(%rsp)
movq 0x20(%rax), %rcx
movq %rcx, 0x50(%rsp)
movq 0x28(%rax), %rcx
movq %rcx, 0xa8(%rsp)
movq 0x30(%rax), %rcx
movq %rcx, 0x48(%rsp)
movq 0x38(%rax), %rcx
movq %rcx, 0x88(%rsp)
movq 0x40(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x48(%rax), %rcx
movq %rcx, 0x58(%rsp)
movq 0x50(%rax), %rcx
movq %rcx, 0xb0(%rsp)
movq 0x58(%rax), %rcx
movq %rcx, 0x98(%rsp)
movq 0x60(%rax), %rcx
movq %rcx, 0x90(%rsp)
movq 0x68(%rax), %rcx
movq %rcx, 0x60(%rsp)
movq 0x70(%rax), %rcx
movq %rcx, 0xb8(%rsp)
movq 0x78(%rax), %rax
movq %rax, 0xa0(%rsp)
movslq 0x198(%rsp), %rbp
movq 0x190(%rsp), %rbx
leaq 0x8a9a(%rip), %rdi      # 0xa1da
xorl %eax, %eax
callq 0x1100
testl %r14d, %r14d
jle 0x17be
leaq 0x8a90(%rip), %rdi      # 0xa1e3
movl %r14d, %esi
xorl %eax, %eax
callq 0x1100
leaq 0x8a87(%rip), %rdi      # 0xa1eb
movl 0x8(%rsp), %esi
movl %r13d, %edx
movl %r12d, %ecx
movq %r15, %r8
xorl %eax, %eax
callq 0x1100
movl 0x198(%rsp), %ecx
movq 0x1c8(%rsp), %rax
testl %ecx, %ecx
movl $0x0, %r8d
cmovlel %r8d, %ecx
imulq $0x28, %rcx, %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x17d9
movl 0x4(%rax,%rdx), %esi
xorl %edi, %edi
cmpl %r14d, %esi
setl %dil
cmovgel %r8d, %esi
movslq %esi, %rsi
subq %rsi, %rbx
subq %rdi, %rbp
addq $0x28, %rdx
jmp 0x1799
leaq 0x8a26(%rip), %rdi      # 0xa1eb
movl 0x8(%rsp), %esi
movl %r13d, %edx
movl %r12d, %ecx
movq %r15, %r8
xorl %eax, %eax
callq 0x1100
movq 0x28(%rsp), %rdx
cmpq %rdx, %rbp
cmovgq %rbp, %rdx
xorl %ecx, %ecx
pushq $-0x1
popq %rax
pushq $0x1
popq %rsi
cmpq %rdx, %rsi
jg 0x17fc
imulq $0xa, %rsi, %rsi
incl %ecx
incl %eax
jmp 0x17ed
pushq $0x3
popq %r13
cmpl $0x4, %ecx
jb 0x1812
xorl %edx, %edx
pushq $0x3
popq %rsi
divl %esi
movl %eax, %r13d
addl %ecx, %r13d
xorl %ecx, %ecx
pushq $-0x1
popq %rax
pushq $0x1
popq %rdx
cmpq %rbx, %rdx
jg 0x1829
imulq $0xa, %rdx, %rdx
incl %ecx
incl %eax
jmp 0x181a
movq %r15, 0xc0(%rsp)
pushq $0x3
popq %r15
cmpl $0x4, %ecx
jb 0x1847
xorl %edx, %edx
pushq $0x3
popq %rsi
divl %esi
movl %eax, %r15d
addl %ecx, %r15d
leaq 0x89b2(%rip), %rdi      # 0xa200
xorl %eax, %eax
callq 0x1100
movq 0xd77c(%rip), %r12      # 0xefd8
movq (%r12), %rdx
movq %rbp, %rdi
movl %r13d, %esi
callq 0x23f1
leaq 0x899b(%rip), %rdi      # 0xa20d
xorl %eax, %eax
callq 0x1100
movq (%r12), %rdx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x23f1
leaq 0x8994(%rip), %rdi      # 0xa223
xorl %eax, %eax
callq 0x1100
testl %r14d, %r14d
movq %r12, %r14
jle 0x18cf
leaq 0x898f(%rip), %rdi      # 0xa234
xorl %eax, %eax
callq 0x1100
movslq 0x198(%rsp), %rdi
subq %rbp, %rdi
movq (%r14), %rdx
xorl %esi, %esi
callq 0x23f1
leaq 0x8977(%rip), %rdi      # 0xa23f
xorl %eax, %eax
callq 0x1100
pushq $0xa
popq %rdi
callq 0x1040
leaq 0x8973(%rip), %rdi      # 0xa251
xorl %eax, %eax
callq 0x1100
movq (%r14), %rdx
movq 0x38(%rsp), %r12
movq %r12, %rdi
movl %r13d, %esi
callq 0x23f1
cvtsi2sd %r12, %xmm0
movsd 0x8703(%rip), %xmm1     # 0xa008
mulsd %xmm1, %xmm0
cvtsi2sd %rbp, %xmm1
movsd %xmm1, 0x10(%rsp)
divsd %xmm1, %xmm0
leaq 0x893f(%rip), %rdi      # 0xa25e
movb $0x1, %al
callq 0x1100
movq (%r14), %rdx
movq 0x50(%rsp), %r12
movq %r12, %rdi
movl %r15d, %esi
callq 0x23f1
cvtsi2sd %r12, %xmm0
mulsd 0x86c2(%rip), %xmm0     # 0xa008
cvtsi2sd %rbx, %xmm1
movsd %xmm1, 0x8(%rsp)
divsd %xmm1, %xmm0
leaq 0x8918(%rip), %rbp      # 0xa274
movq %rbp, %rdi
movb $0x1, %al
callq 0x1100
leaq 0x8919(%rip), %rdi      # 0xa286
xorl %eax, %eax
callq 0x1100
movq (%r14), %rdx
movl %r13d, %r12d
movq 0x40(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x23f1
cvtsi2sd %rbx, %xmm0
mulsd 0x8671(%rip), %xmm0     # 0xa008
divsd 0x10(%rsp), %xmm0
leaq 0x88ba(%rip), %rdi      # 0xa25e
movb $0x1, %al
callq 0x1100
movq (%r14), %rdx
movq %r14, %r13
movq 0xa8(%rsp), %rbx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x23f1
cvtsi2sd %rbx, %xmm0
mulsd 0x8637(%rip), %xmm0     # 0xa008
divsd 0x8(%rsp), %xmm0
movq %rbp, %rdi
movb $0x1, %al
callq 0x1100
leaq 0x88ab(%rip), %rdi      # 0xa293
xorl %eax, %eax
callq 0x1100
movq (%r14), %rdx
movq 0x30(%rsp), %r14
movq %r14, %rdi
movl %r12d, %esi
movl %r12d, %ebp
callq 0x23f1
cvtsi2sd %r14, %xmm0
mulsd 0x85f6(%rip), %xmm0     # 0xa008
divsd 0x10(%rsp), %xmm0
leaq 0x883f(%rip), %rdi      # 0xa25e
movb $0x1, %al
callq 0x1100
movq (%r13), %rdx
movq 0x48(%rsp), %r14
movq %r14, %rdi
movl %r15d, %esi
callq 0x23f1
cvtsi2sd %r14, %xmm0
mulsd 0x85c1(%rip), %xmm0     # 0xa008
divsd 0x8(%rsp), %xmm0
leaq 0x8820(%rip), %rdi      # 0xa274
movb $0x1, %al
callq 0x1100
leaq 0x883e(%rip), %rdi      # 0xa2a0
xorl %eax, %eax
callq 0x1100
movq (%r13), %rdx
movq 0x80(%rsp), %r12
movq %r12, %rdi
movl %ebp, %esi
callq 0x23f1
cvtsi2sd %r12, %xmm0
mulsd 0x857c(%rip), %xmm0     # 0xa008
divsd 0x10(%rsp), %xmm0
leaq 0x87c5(%rip), %rdi      # 0xa25e
movb $0x1, %al
callq 0x1100
movq (%r13), %rdx
movq 0x88(%rsp), %r12
movq %r12, %rdi
movl %r15d, %esi
callq 0x23f1
cvtsi2sd %r12, %xmm0
mulsd 0x8544(%rip), %xmm0     # 0xa008
divsd 0x8(%rsp), %xmm0
leaq 0x87a3(%rip), %rdi      # 0xa274
movb $0x1, %al
callq 0x1100
pushq $0xa
popq %rdi
callq 0x1040
leaq 0x87c6(%rip), %rdi      # 0xa2ad
xorl %eax, %eax
callq 0x1100
movq (%r13), %rdx
movq 0x28(%rsp), %r12
movq %r12, %rdi
movl %ebp, %esi
movl %ebp, %r14d
callq 0x23f1
cvtsi2sd %r12, %xmm0
mulsd 0x84f7(%rip), %xmm0     # 0xa008
divsd 0x10(%rsp), %xmm0
leaq 0x879c(%rip), %rdi      # 0xa2ba
movb $0x1, %al
callq 0x1100
movq (%r13), %rdx
movq 0x90(%rsp), %r12
movq %r12, %rdi
movl %r15d, %esi
callq 0x23f1
cvtsi2sd %r12, %xmm0
mulsd 0x84bf(%rip), %xmm0     # 0xa008
divsd 0x8(%rsp), %xmm0
leaq 0x871e(%rip), %r12      # 0xa274
movq %r12, %rdi
movb $0x1, %al
callq 0x1100
leaq 0x8769(%rip), %rdi      # 0xa2d0
xorl %eax, %eax
callq 0x1100
movq (%r13), %rdx
movq 0x58(%rsp), %rbp
movq %rbp, %rdi
movl %r14d, %esi
callq 0x23f1
cvtsi2sd %rbp, %xmm0
mulsd 0x8479(%rip), %xmm0     # 0xa008
divsd 0x10(%rsp), %xmm0
leaq 0x871e(%rip), %rdi      # 0xa2ba
movb $0x1, %al
callq 0x1100
movq (%r13), %rdx
movq 0x60(%rsp), %rbp
movq %rbp, %rdi
movl %r15d, %esi
callq 0x23f1
cvtsi2sd %rbp, %xmm0
mulsd 0x8444(%rip), %xmm0     # 0xa008
divsd 0x8(%rsp), %xmm0
movq %r12, %rdi
movb $0x1, %al
callq 0x1100
leaq 0x8702(%rip), %rdi      # 0xa2dd
xorl %eax, %eax
callq 0x1100
movq (%r13), %rdx
movq 0xb0(%rsp), %rbp
movq %rbp, %rdi
movl %r14d, %esi
movl %r14d, 0x1c(%rsp)
callq 0x23f1
cvtsi2sd %rbp, %xmm0
mulsd 0x83fd(%rip), %xmm0     # 0xa008
divsd 0x10(%rsp), %xmm0
leaq 0x86a2(%rip), %rdi      # 0xa2ba
movb $0x1, %al
callq 0x1100
movq (%r13), %rdx
movq 0xb8(%rsp), %r12
movq %r12, %rdi
movl %r15d, %esi
callq 0x23f1
cvtsi2sd %r12, %xmm0
mulsd 0x83c5(%rip), %xmm0     # 0xa008
divsd 0x8(%rsp), %xmm0
leaq 0x8624(%rip), %rdi      # 0xa274
movb $0x1, %al
callq 0x1100
leaq 0x868c(%rip), %rdi      # 0xa2ea
xorl %eax, %eax
callq 0x1100
movq (%r13), %rdx
movl %r15d, 0x18(%rsp)
movq 0x98(%rsp), %r13
movq %r13, %rdi
movl %r14d, %esi
callq 0x23f1
cvtsi2sd %r13, %xmm0
mulsd 0x837a(%rip), %xmm0     # 0xa008
divsd 0x10(%rsp), %xmm0
leaq 0x861f(%rip), %rdi      # 0xa2ba
movb $0x1, %al
callq 0x1100
movq 0xd32f(%rip), %rax      # 0xefd8
movq (%rax), %rdx
movq 0xa0(%rsp), %r14
movq %r14, %rdi
movl %r15d, %esi
callq 0x23f1
cvtsi2sd %r14, %xmm0
mulsd 0x833c(%rip), %xmm0     # 0xa008
divsd 0x8(%rsp), %xmm0
leaq 0x859b(%rip), %rdi      # 0xa274
movb $0x1, %al
callq 0x1100
pushq $0xa
popq %rdi
callq 0x1040
leaq 0x8608(%rip), %rdi      # 0xa2f7
xorl %eax, %eax
callq 0x1100
movq 0x40(%rsp), %rdi
addq 0x38(%rsp), %rdi
addq 0x30(%rsp), %rdi
addq %r13, %rdi
movq 0xd2c9(%rip), %r13      # 0xefd8
movq (%r13), %rdx
movl 0x1c(%rsp), %r15d
movl %r15d, %esi
callq 0x23f1
leaq 0x85dd(%rip), %rdi      # 0xa304
xorl %eax, %eax
callq 0x1100
addq 0x50(%rsp), %rbx
addq 0x48(%rsp), %rbx
addq %r14, %rbx
movq (%r13), %rdx
movq %r13, %r14
movq %rbx, %rdi
movl 0x18(%rsp), %r13d
movl %r13d, %esi
callq 0x23f1
cvtsi2sd %rbx, %xmm0
mulsd 0x82a9(%rip), %xmm0     # 0xa008
divsd 0x8(%rsp), %xmm0
leaq 0x8508(%rip), %rbx      # 0xa274
movq %rbx, %rdi
movb $0x1, %al
callq 0x1100
leaq 0x859c(%rip), %rdi      # 0xa319
xorl %eax, %eax
callq 0x1100
addq 0x58(%rsp), %rbp
movq (%r14), %rdx
movq %rbp, %rdi
movl %r15d, %esi
callq 0x23f1
leaq 0x8588(%rip), %rdi      # 0xa326
xorl %eax, %eax
callq 0x1100
addq 0x60(%rsp), %r12
movq (%r14), %rdx
movq %r12, %rdi
movl %r13d, %esi
callq 0x23f1
cvtsi2sd %r12, %xmm0
mulsd 0x8243(%rip), %xmm0     # 0xa008
divsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
movb $0x1, %al
callq 0x1100
movq 0xc0(%rsp), %rdi
callq 0x1030
leaq 0x168(%rsp), %rbx
movq %rbx, %rdi
callq 0x3e63
movq 0x68(%rsp), %r12
incq %r12
movq 0x70(%rsp), %r15
jmp 0x1423
leaq 0xd37d(%rip), %rax      # 0xf188
movq (%rax), %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1270
movq 0xd1d7(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0xd35d(%rip), %rax      # 0xf188
movq (%rax), %rdx
movq 0x8(%r15), %rcx
leaq 0x81ed(%rip), %rsi      # 0xa026
jmp 0x13ff
movq 0xd1b3(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0xd339(%rip), %rax      # 0xf188
movq (%rax), %rdx
leaq 0x826b(%rip), %rsi      # 0xa0c4
jmp 0x1f1e
movq 0xd193(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0xd319(%rip), %rax      # 0xf188
movq (%rax), %rdx
leaq 0x827f(%rip), %rsi      # 0xa0f8
jmp 0x1f1e
movq 0xd173(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0xd2f9(%rip), %rax      # 0xf188
movq (%rax), %rdx
leaq 0x8296(%rip), %rsi      # 0xa12f
jmp 0x1f1e
movq 0xd153(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0xd2d9(%rip), %rax      # 0xf188
movq (%rax), %rdx
leaq 0x82ad(%rip), %rsi      # 0xa166
jmp 0x1f1e
movq 0xd136(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0xd2bc(%rip), %rax      # 0xf188
movq (%rax), %rdx
leaq 0x82c7(%rip), %rsi      # 0xa19d
jmp 0x1f1e
movq 0xd119(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0xd29f(%rip), %rax      # 0xf188
movq (%rax), %rdx
movl 0x1a0(%rsp), %ecx
leaq 0x8171(%rip), %rsi      # 0xa06b
xorl %eax, %eax
callq 0x11a0
jmp 0x1f25
movq 0xd0ee(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0xd274(%rip), %rax      # 0xf188
movq (%rax), %rdx
leaq 0x817b(%rip), %rsi      # 0xa099
xorl %eax, %eax
callq 0x11a0
pushq $0x1
popq %rdi
callq 0x1270
nopl (%rax)