// File: /workspace/github_c_makefile_star2_O1/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 0x8d17(%rip), %rdi      # 0xb010
leaq 0x8eff(%rip), %rsi      # 0xb1ff
callq 0x2f82
leaq 0xde7c(%rip), %rcx      # 0x10188
movq %rax, (%rcx)
cmpl $0x2, %ebx
jge 0x233b
movq 0xdcdd(%rip), %rcx      # 0xfff8
movq (%rcx), %rdi
leaq 0x8cf3(%rip), %rsi      # 0xb018
leaq 0x900f(%rip), %rcx      # 0xb33b
movq %rax, %rdx
xorl %eax, %eax
callq 0x11a0
jmp 0x2e85
movl %ebx, %eax
movq %rax, 0x58(%rsp)
movl $0x1, %r12d
leaq 0xc8(%rsp), %rbx
movq %r15, 0x60(%rsp)
movq (%r15,%r12,8), %rdi
movq %rbx, %rsi
callq 0x3e80
testl %eax, %eax
js 0x2e85
cmpl $0x1, %eax
je 0x2d7a
movq %rbx, %rdi
callq 0x4645
movl 0x100(%rsp), %esi
testl %esi, %esi
je 0x23e9
movq 0x110(%rsp), %rbx
leaq 0x8fb5(%rip), %rdi      # 0xb349
movq %rdi, %rdx
callq 0x324d
movq %rbx, %rdi
movq %rax, %rsi
leaq 0x8c6a(%rip), %rdx      # 0xb013
leaq 0x8ca0(%rip), %rcx      # 0xb050
callq 0x315d
movq %rax, %rdi
leaq 0x8c97(%rip), %rsi      # 0xb056
callq 0x2f82
testq %rax, %rax
je 0x2e85
movq %rax, %rbx
movq %rax, %rdi
leaq 0x9a9d(%rip), %rsi      # 0xbe77
callq 0x1240
testq %rax, %rax
jne 0x243e
jmp 0x2e38
movq 0x110(%rsp), %rdi
leaq 0x8f51(%rip), %rsi      # 0xb349
leaq 0x8c14(%rip), %rdx      # 0xb013
leaq 0x8c4a(%rip), %rcx      # 0xb050
callq 0x315d
movq %rax, %rdi
leaq 0x8c41(%rip), %rsi      # 0xb056
callq 0x2f82
testq %rax, %rax
je 0x2e85
movq %rax, %rbx
movq %rax, %rdi
leaq 0x9a47(%rip), %rsi      # 0xbe77
callq 0x1240
testq %rax, %rax
je 0x2e63
movq %rax, %r14
movl $0x4, %esi
movl $0x1, %edx
leaq 0x14(%rsp), %rdi
movq %rax, %rcx
callq 0x10b0
movl $0x4, %esi
movl $0x1, %edx
leaq 0x10(%rsp), %rdi
movq %r14, %rcx
callq 0x10b0
movq %r14, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x1230
movq %r14, %rdi
callq 0x11b0
movl 0x14(%rsp), %ecx
incl %ecx
imull 0x10(%rsp), %ecx
subl %eax, %ecx
addl $0x8, %ecx
movslq %ecx, %rsi
movq %r14, %rdi
movl $0x2, %edx
callq 0x1230
movl $0x0, 0x1bc(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
leaq 0x1b8(%rsp), %rdx
callq 0x67c1
testl %eax, %eax
jne 0x2d9e
movl $0x0, 0x19c(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
leaq 0x198(%rsp), %rdx
callq 0x67c1
testl %eax, %eax
jne 0x2dbe
movl $0x0, 0x17c(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
leaq 0x178(%rsp), %rdx
callq 0x67c1
testl %eax, %eax
jne 0x2dde
movl $0x0, 0x15c(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
leaq 0x158(%rsp), %rdx
callq 0x67c1
testl %eax, %eax
jne 0x2dfe
movl $0x0, 0x13c(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
leaq 0x138(%rsp), %rdx
callq 0x67c1
testl %eax, %eax
jne 0x2e1b
movq %r14, %rdi
callq 0x10c0
movq %r12, 0xc0(%rsp)
movq (%r15,%r12,8), %rdi
leaq 0x8c57(%rip), %rsi      # 0xb1d6
callq 0x3098
movq %rax, %r15
movq 0x1d0(%rsp), %rax
movl (%rax), %ebx
movq 0x1b0(%rsp), %rax
movl (%rax), %ebp
movq 0x190(%rsp), %rax
movl (%rax), %r13d
movq 0x170(%rsp), %rax
movl (%rax), %eax
movl %eax, (%rsp)
movq 0x150(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x18(%rax), %rcx
movq %rcx, 0x78(%rsp)
movq 0x20(%rax), %rcx
movq %rcx, 0x40(%rsp)
movq 0x28(%rax), %rcx
movq %rcx, 0xa0(%rsp)
movq 0x30(%rax), %rcx
movq %rcx, 0x38(%rsp)
movq 0x38(%rax), %rcx
movq %rcx, 0x80(%rsp)
movq 0x40(%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x48(%rax), %rcx
movq %rcx, 0x48(%rsp)
movq 0x50(%rax), %rcx
movq %rcx, 0xa8(%rsp)
movq 0x58(%rax), %rcx
movq %rcx, 0x90(%rsp)
movq 0x60(%rax), %rcx
movq %rcx, 0x88(%rsp)
movq 0x68(%rax), %rcx
movq %rcx, 0x50(%rsp)
movq 0x70(%rax), %rcx
movq %rcx, 0xb0(%rsp)
movq 0x78(%rax), %rax
movq %rax, 0x98(%rsp)
movslq 0xf8(%rsp), %r12
movq 0xf0(%rsp), %r14
leaq 0x8b64(%rip), %rdi      # 0xb1da
xorl %eax, %eax
callq 0x1100
testl %ebx, %ebx
jle 0x26f0
leaq 0x8b5b(%rip), %rdi      # 0xb1e3
movl %ebx, %esi
xorl %eax, %eax
callq 0x1100
leaq 0x8b53(%rip), %rdi      # 0xb1eb
movl %ebp, %esi
movl %r13d, %edx
movl (%rsp), %ecx
movq %r15, %r8
xorl %eax, %eax
callq 0x1100
movslq 0xf8(%rsp), %rcx
testq %rcx, %rcx
jle 0x2709
movq 0x128(%rsp), %rax
shlq $0x3, %rcx
leaq (%rcx,%rcx,4), %rcx
xorl %edx, %edx
xorl %r8d, %r8d
movl 0x4(%rax,%rdx), %esi
xorl %edi, %edi
cmpl %ebx, %esi
setl %dil
cmovgel %r8d, %esi
movslq %esi, %rsi
subq %rsi, %r14
subq %rdi, %r12
addq $0x28, %rdx
cmpq %rdx, %rcx
jne 0x26cc
jmp 0x2709
leaq 0x8af4(%rip), %rdi      # 0xb1eb
movl %ebp, %esi
movl %r13d, %edx
movl (%rsp), %ecx
movq %r15, %r8
xorl %eax, %eax
callq 0x1100
movq 0x18(%rsp), %rcx
cmpq %rcx, %r12
cmovgq %r12, %rcx
xorl %eax, %eax
testq %rcx, %rcx
jle 0x272f
movl $0x1, %edx
addq %rdx, %rdx
leaq (%rdx,%rdx,4), %rdx
incl %eax
cmpq %rcx, %rdx
jle 0x2721
movl $0x3, %r13d
cmpl $0x4, %eax
jb 0x274e
leal -0x1(%rax), %r13d
movl $0xaaaaaaab, %ecx       # imm = 0xAAAAAAAB
imulq %rcx, %r13
shrq $0x21, %r13
addl %eax, %r13d
xorl %eax, %eax
testq %r14, %r14
jle 0x2768
movl $0x1, %ecx
addq %rcx, %rcx
leaq (%rcx,%rcx,4), %rcx
incl %eax
cmpq %r14, %rcx
jle 0x275a
movq %r15, 0xb8(%rsp)
movl $0x3, %ebp
cmpl $0x4, %eax
jb 0x278c
leal -0x1(%rax), %ebp
movl $0xaaaaaaab, %ecx       # imm = 0xAAAAAAAB
imulq %rcx, %rbp
shrq $0x21, %rbp
addl %eax, %ebp
leaq 0x8a6d(%rip), %rdi      # 0xb200
xorl %eax, %eax
callq 0x1100
movq 0xd837(%rip), %r15      # 0xffd8
movq (%r15), %rdx
movq %r12, %rdi
movl %r13d, %esi
callq 0x3300
leaq 0x8a57(%rip), %rdi      # 0xb20d
xorl %eax, %eax
callq 0x1100
movq (%r15), %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x3300
leaq 0x8a52(%rip), %rdi      # 0xb223
xorl %eax, %eax
callq 0x1100
testl %ebx, %ebx
jle 0x280d
leaq 0x8a51(%rip), %rdi      # 0xb234
xorl %eax, %eax
callq 0x1100
movslq 0xf8(%rsp), %rdi
subq %r12, %rdi
movq (%r15), %rdx
xorl %esi, %esi
callq 0x3300
leaq 0x8a39(%rip), %rdi      # 0xb23f
xorl %eax, %eax
callq 0x1100
movl $0xa, %edi
callq 0x1040
leaq 0x8a33(%rip), %rdi      # 0xb251
xorl %eax, %eax
callq 0x1100
movq (%r15), %rdx
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x3300
cvtsi2sd %rbx, %xmm0
movsd 0x87c3(%rip), %xmm1     # 0xb008
mulsd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r12, %xmm1
movsd %xmm1, 0x8(%rsp)
divsd %xmm1, %xmm0
movq %r15, %rbx
leaq 0x89f9(%rip), %r15      # 0xb25e
movq %r15, %rdi
movb $0x1, %al
callq 0x1100
movq (%rbx), %rdx
movq 0x40(%rsp), %r12
movq %r12, %rdi
movl %ebp, %esi
callq 0x3300
xorps %xmm0, %xmm0
cvtsi2sd %r12, %xmm0
mulsd 0x8777(%rip), %xmm0     # 0xb008
xorps %xmm1, %xmm1
cvtsi2sd %r14, %xmm1
movsd %xmm1, (%rsp)
divsd %xmm1, %xmm0
leaq 0x89cb(%rip), %rdi      # 0xb274
movb $0x1, %al
callq 0x1100
leaq 0x89cf(%rip), %rdi      # 0xb286
xorl %eax, %eax
callq 0x1100
movq %rbx, %r12
movq (%rbx), %rdx
movq 0x30(%rsp), %r14
movq %r14, %rdi
movl %r13d, %esi
callq 0x3300
xorps %xmm0, %xmm0
cvtsi2sd %r14, %xmm0
mulsd 0x8724(%rip), %xmm0     # 0xb008
divsd 0x8(%rsp), %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x1100
movq (%rbx), %rdx
movq 0xa0(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
callq 0x3300
xorps %xmm0, %xmm0
cvtsi2sd %r14, %xmm0
mulsd 0x86ef(%rip), %xmm0     # 0xb008
divsd (%rsp), %xmm0
leaq 0x894f(%rip), %rdi      # 0xb274
movb $0x1, %al
callq 0x1100
leaq 0x8960(%rip), %rdi      # 0xb293
xorl %eax, %eax
callq 0x1100
movq (%rbx), %rdx
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x3300
xorps %xmm0, %xmm0
cvtsi2sd %rbx, %xmm0
mulsd 0x86ab(%rip), %xmm0     # 0xb008
divsd 0x8(%rsp), %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x1100
movq (%r12), %rdx
movq 0x38(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3300
xorps %xmm0, %xmm0
cvtsi2sd %rbx, %xmm0
mulsd 0x8678(%rip), %xmm0     # 0xb008
divsd (%rsp), %xmm0
leaq 0x88d8(%rip), %rdi      # 0xb274
movq %rdi, %r15
movb $0x1, %al
callq 0x1100
leaq 0x88f3(%rip), %rdi      # 0xb2a0
xorl %eax, %eax
callq 0x1100
movq (%r12), %rdx
movq 0x78(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x3300
xorps %xmm0, %xmm0
cvtsi2sd %rbx, %xmm0
mulsd 0x8630(%rip), %xmm0     # 0xb008
divsd 0x8(%rsp), %xmm0
leaq 0x8879(%rip), %rdi      # 0xb25e
movb $0x1, %al
callq 0x1100
movq (%r12), %rdx
movq 0x80(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3300
xorps %xmm0, %xmm0
cvtsi2sd %rbx, %xmm0
mulsd 0x85f6(%rip), %xmm0     # 0xb008
divsd (%rsp), %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x1100
movl $0xa, %edi
callq 0x1040
leaq 0x887b(%rip), %rdi      # 0xb2ad
xorl %eax, %eax
callq 0x1100
movq (%r12), %rdx
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x3300
xorps %xmm0, %xmm0
cvtsi2sd %rbx, %xmm0
mulsd 0x85ab(%rip), %xmm0     # 0xb008
divsd 0x8(%rsp), %xmm0
leaq 0x8850(%rip), %rdi      # 0xb2ba
movb $0x1, %al
callq 0x1100
movq %r12, %r15
movq (%r12), %rdx
movq 0x88(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3300
xorps %xmm0, %xmm0
cvtsi2sd %rbx, %xmm0
mulsd 0x856e(%rip), %xmm0     # 0xb008
divsd (%rsp), %xmm0
leaq 0x87ce(%rip), %r12      # 0xb274
movq %r12, %rdi
movb $0x1, %al
callq 0x1100
leaq 0x8819(%rip), %rdi      # 0xb2d0
xorl %eax, %eax
callq 0x1100
movq %r15, %rbx
movq (%r15), %rdx
movq 0x48(%rsp), %r15
movq %r15, %rdi
movl %r13d, %esi
callq 0x3300
xorps %xmm0, %xmm0
cvtsi2sd %r15, %xmm0
mulsd 0x8524(%rip), %xmm0     # 0xb008
divsd 0x8(%rsp), %xmm0
leaq 0x87c9(%rip), %rdi      # 0xb2ba
movb $0x1, %al
callq 0x1100
movq (%rbx), %rdx
movq 0x50(%rsp), %r15
movq %r15, %rdi
movl %ebp, %esi
callq 0x3300
xorps %xmm0, %xmm0
cvtsi2sd %r15, %xmm0
mulsd 0x84ee(%rip), %xmm0     # 0xb008
divsd (%rsp), %xmm0
movq %r12, %rdi
movb $0x1, %al
callq 0x1100
leaq 0x87ad(%rip), %rdi      # 0xb2dd
xorl %eax, %eax
callq 0x1100
movq (%rbx), %rdx
movq 0xa8(%rsp), %r15
movq %r15, %rdi
movl %r13d, %esi
callq 0x3300
xorps %xmm0, %xmm0
cvtsi2sd %r15, %xmm0
mulsd 0x84ab(%rip), %xmm0     # 0xb008
divsd 0x8(%rsp), %xmm0
leaq 0x8750(%rip), %rdi      # 0xb2ba
movb $0x1, %al
callq 0x1100
movq (%rbx), %rdx
movq 0xb0(%rsp), %r12
movq %r12, %rdi
movl %ebp, %esi
callq 0x3300
xorps %xmm0, %xmm0
cvtsi2sd %r12, %xmm0
mulsd 0x8472(%rip), %xmm0     # 0xb008
divsd (%rsp), %xmm0
leaq 0x86d2(%rip), %rdi      # 0xb274
movb $0x1, %al
callq 0x1100
leaq 0x873a(%rip), %rdi      # 0xb2ea
xorl %eax, %eax
callq 0x1100
movq (%rbx), %rdx
movq %rbp, 0x70(%rsp)
movq %r13, %rsi
movq %r13, 0x68(%rsp)
movq 0x90(%rsp), %r13
movq %r13, %rdi
callq 0x3300
xorps %xmm0, %xmm0
cvtsi2sd %r13, %xmm0
mulsd 0x8421(%rip), %xmm0     # 0xb008
divsd 0x8(%rsp), %xmm0
leaq 0x86c6(%rip), %rdi      # 0xb2ba
movb $0x1, %al
callq 0x1100
movq (%rbx), %rdx
movq 0x98(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3300
xorps %xmm0, %xmm0
cvtsi2sd %rbx, %xmm0
mulsd 0x83e8(%rip), %xmm0     # 0xb008
divsd (%rsp), %xmm0
leaq 0x8648(%rip), %rdi      # 0xb274
movb $0x1, %al
callq 0x1100
movl $0xa, %edi
callq 0x1040
leaq 0x86b3(%rip), %rdi      # 0xb2f7
xorl %eax, %eax
callq 0x1100
movq 0x30(%rsp), %rdi
addq 0x28(%rsp), %rdi
addq 0x20(%rsp), %rdi
addq %r13, %rdi
movq 0xd374(%rip), %r13      # 0xffd8
movq (%r13), %rdx
movq 0x68(%rsp), %rbp
movl %ebp, %esi
callq 0x3300
leaq 0x8689(%rip), %rdi      # 0xb304
xorl %eax, %eax
callq 0x1100
addq 0x40(%rsp), %r14
addq 0x38(%rsp), %r14
addq %rbx, %r14
movq (%r13), %rdx
movq %r13, %rbx
movq %r14, %rdi
movq 0x70(%rsp), %r13
movl %r13d, %esi
callq 0x3300
xorps %xmm0, %xmm0
cvtsi2sd %r14, %xmm0
mulsd 0x8352(%rip), %xmm0     # 0xb008
divsd (%rsp), %xmm0
leaq 0x85b2(%rip), %r14      # 0xb274
movq %r14, %rdi
movb $0x1, %al
callq 0x1100
leaq 0x8646(%rip), %rdi      # 0xb319
xorl %eax, %eax
callq 0x1100
addq 0x48(%rsp), %r15
movq (%rbx), %rdx
movq %r15, %rdi
movl %ebp, %esi
callq 0x3300
leaq 0x8633(%rip), %rdi      # 0xb326
xorl %eax, %eax
callq 0x1100
addq 0x50(%rsp), %r12
movq (%rbx), %rdx
movq %r12, %rdi
movl %r13d, %esi
callq 0x3300
xorps %xmm0, %xmm0
cvtsi2sd %r12, %xmm0
mulsd 0x82eb(%rip), %xmm0     # 0xb008
divsd (%rsp), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x1100
movq 0xb8(%rsp), %rdi
callq 0x1030
leaq 0xc8(%rsp), %rbx
movq %rbx, %rdi
callq 0x4e58
movq 0xc0(%rsp), %r12
incq %r12
cmpq 0x58(%rsp), %r12
movq 0x60(%rsp), %r15
jne 0x2355
leaq 0xd41d(%rip), %rax      # 0x10188
movq (%rax), %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1270
movq 0xd277(%rip), %rax      # 0xfff8
movq (%rax), %rdi
leaq 0xd3fd(%rip), %rax      # 0x10188
movq (%rax), %rdx
movq 0x8(%r15), %rcx
leaq 0x828d(%rip), %rsi      # 0xb026
jmp 0x232f
movq 0xd253(%rip), %rax      # 0xfff8
movq (%rax), %rdi
leaq 0xd3d9(%rip), %rax      # 0x10188
movq (%rax), %rdx
leaq 0x830b(%rip), %rsi      # 0xb0c4
jmp 0x2e7e
movq 0xd233(%rip), %rax      # 0xfff8
movq (%rax), %rdi
leaq 0xd3b9(%rip), %rax      # 0x10188
movq (%rax), %rdx
leaq 0x831f(%rip), %rsi      # 0xb0f8
jmp 0x2e7e
movq 0xd213(%rip), %rax      # 0xfff8
movq (%rax), %rdi
leaq 0xd399(%rip), %rax      # 0x10188
movq (%rax), %rdx
leaq 0x8336(%rip), %rsi      # 0xb12f
jmp 0x2e7e
movq 0xd1f3(%rip), %rax      # 0xfff8
movq (%rax), %rdi
leaq 0xd379(%rip), %rax      # 0x10188
movq (%rax), %rdx
leaq 0x834d(%rip), %rsi      # 0xb166
jmp 0x2e7e
movq 0xd1d6(%rip), %rax      # 0xfff8
movq (%rax), %rdi
leaq 0xd35c(%rip), %rax      # 0x10188
movq (%rax), %rdx
leaq 0x8367(%rip), %rsi      # 0xb19d
jmp 0x2e7e
movq 0xd1b9(%rip), %rax      # 0xfff8
movq (%rax), %rdi
leaq 0xd33f(%rip), %rax      # 0x10188
movq (%rax), %rdx
movl 0x100(%rsp), %ecx
leaq 0x8211(%rip), %rsi      # 0xb06b
xorl %eax, %eax
callq 0x11a0
jmp 0x2e85
movq 0xd18e(%rip), %rax      # 0xfff8
movq (%rax), %rdi
leaq 0xd314(%rip), %rax      # 0x10188
movq (%rax), %rdx
leaq 0x821b(%rip), %rsi      # 0xb099
xorl %eax, %eax
callq 0x11a0
movl $0x1, %edi
callq 0x1270
nop