// File: /workspace/github_c_makefile_star2_O3/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 0x8d87(%rip), %rdi      # 0xb010
leaq 0x8f6f(%rip), %rsi      # 0xb1ff
callq 0x2f12
leaq 0xdeec(%rip), %rcx      # 0x10188
movq %rax, (%rcx)
cmpl $0x2, %ebx
jge 0x22cb
movq 0xdd4d(%rip), %rcx      # 0xfff8
movq (%rcx), %rdi
leaq 0x8d63(%rip), %rsi      # 0xb018
leaq 0x907f(%rip), %rcx      # 0xb33b
movq %rax, %rdx
xorl %eax, %eax
callq 0x11a0
jmp 0x2e16
movl %ebx, %eax
movq %rax, 0x70(%rsp)
movl $0x1, %r12d
leaq 0x168(%rsp), %rbx
movq %r15, 0x78(%rsp)
movq (%r15,%r12,8), %rdi
movq %rbx, %rsi
callq 0x3edb
testl %eax, %eax
js 0x2e16
cmpl $0x1, %eax
je 0x2d0b
movq %rbx, %rdi
callq 0x46e4
movl 0x1a0(%rsp), %esi
movq 0x1b0(%rsp), %rbx
testl %esi, %esi
je 0x2379
leaq 0x9025(%rip), %rdi      # 0xb349
movq %rdi, %rdx
callq 0x31fe
movq %rbx, %rdi
movq %rax, %rsi
leaq 0x8cda(%rip), %rdx      # 0xb013
leaq 0x8d10(%rip), %rcx      # 0xb050
callq 0x30f7
movq %rax, %rdi
leaq 0x8d07(%rip), %rsi      # 0xb056
callq 0x2f12
testq %rax, %rax
je 0x2e16
movq %rax, %rbx
movq %rax, %rdi
leaq 0x9b75(%rip), %rsi      # 0xbedf
callq 0x1240
testq %rax, %rax
jne 0x23c9
jmp 0x2dc9
movq %rbx, %rdi
leaq 0x8fc6(%rip), %rsi      # 0xb349
leaq 0x8c89(%rip), %rdx      # 0xb013
leaq 0x8cbf(%rip), %rcx      # 0xb050
callq 0x30f7
movq %rax, %rdi
leaq 0x8cb6(%rip), %rsi      # 0xb056
callq 0x2f12
testq %rax, %rax
je 0x2e16
movq %rax, %rbx
movq %rax, %rdi
leaq 0x9b24(%rip), %rsi      # 0xbedf
callq 0x1240
testq %rax, %rax
je 0x2df4
movq %rax, %r14
movl $0x4, %esi
movl $0x1, %edx
leaq 0x24(%rsp), %rdi
movq %rax, %rcx
callq 0x10b0
movl $0x4, %esi
movl $0x1, %edx
leaq 0x20(%rsp), %rdi
movq %r14, %rcx
callq 0x10b0
movq %r14, %rdi
xorl %esi, %esi
movl $0x2, %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 $0x2, %edx
callq 0x1230
movl $0x0, 0x14c(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
leaq 0x148(%rsp), %rdx
callq 0x67ef
testl %eax, %eax
jne 0x2d2f
movl $0x0, 0x12c(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
leaq 0x128(%rsp), %rdx
callq 0x67ef
testl %eax, %eax
jne 0x2d4f
movl $0x0, 0x10c(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
leaq 0x108(%rsp), %rdx
callq 0x67ef
testl %eax, %eax
jne 0x2d6f
movl $0x0, 0xec(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
leaq 0xe8(%rsp), %rdx
callq 0x67ef
testl %eax, %eax
jne 0x2d8f
movl $0x0, 0xcc(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
leaq 0xc8(%rsp), %rdx
callq 0x67ef
testl %eax, %eax
jne 0x2dac
movq %r14, %rdi
callq 0x10c0
movq %r12, 0xc0(%rsp)
movq (%r15,%r12,8), %rdi
leaq 0x8ccc(%rip), %rsi      # 0xb1d6
callq 0x302f
movq %rax, %r15
movq 0x160(%rsp), %rax
movl (%rax), %ebx
movq 0x140(%rsp), %rax
movl (%rax), %ebp
movq 0x120(%rsp), %rax
movl (%rax), %r13d
movq 0x100(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x8(%rsp)
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, 0x58(%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, 0x60(%rsp)
movq 0x50(%rax), %rcx
movq %rcx, 0xa8(%rsp)
movq 0x58(%rax), %rcx
movq %rcx, 0x98(%rsp)
movq 0x60(%rax), %rcx
movq %rcx, 0x90(%rsp)
movq 0x68(%rax), %rcx
movq %rcx, 0x68(%rsp)
movq 0x70(%rax), %rcx
movq %rcx, 0xb0(%rsp)
movq 0x78(%rax), %rax
movq %rax, 0xa0(%rsp)
movslq 0x198(%rsp), %r12
movq 0x190(%rsp), %r14
leaq 0x8bd8(%rip), %rdi      # 0xb1da
xorl %eax, %eax
callq 0x1100
testl %ebx, %ebx
jle 0x267d
leaq 0x8bcf(%rip), %rdi      # 0xb1e3
movl %ebx, %esi
xorl %eax, %eax
callq 0x1100
leaq 0x8bc7(%rip), %rdi      # 0xb1eb
movl %ebp, %esi
movl %r13d, %edx
movl 0x8(%rsp), %ecx
movq %r15, %r8
xorl %eax, %eax
callq 0x1100
movslq 0x198(%rsp), %rcx
testq %rcx, %rcx
jle 0x2697
movq 0x1c8(%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 0x2659
jmp 0x2697
leaq 0x8b67(%rip), %rdi      # 0xb1eb
movl %ebp, %esi
movl %r13d, %edx
movl 0x8(%rsp), %ecx
movq %r15, %r8
xorl %eax, %eax
callq 0x1100
movq 0x28(%rsp), %rcx
cmpq %rcx, %r12
cmovgq %r12, %rcx
movl $0x3, %ebp
movl $0x3, %r13d
testq %rcx, %rcx
jle 0x26ec
movl $0x1, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq %rdx, %rdx
leaq (%rdx,%rdx,4), %rdx
incl %eax
cmpq %rcx, %rdx
jle 0x26bd
movl $0x3, %r13d
cmpl $0x3, %eax
jb 0x26ec
movl %eax, %ecx
movl $0xaaaaaaab, %edx       # imm = 0xAAAAAAAB
imulq %rdx, %rcx
shrq $0x21, %rcx
leal (%rcx,%rax), %r13d
incl %r13d
testq %r14, %r14
movq %r15, 0xb8(%rsp)
jle 0x272a
movl $0x1, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq %rcx, %rcx
leaq (%rcx,%rcx,4), %rcx
incl %eax
cmpq %r14, %rcx
jle 0x2703
cmpl $0x3, %eax
jb 0x272a
movl %eax, %ecx
movl $0xaaaaaaab, %edx       # imm = 0xAAAAAAAB
imulq %rdx, %rcx
shrq $0x21, %rcx
leal (%rcx,%rax), %ebp
incl %ebp
leaq 0x8acf(%rip), %rdi      # 0xb200
xorl %eax, %eax
callq 0x1100
movq 0xd899(%rip), %r15      # 0xffd8
movq (%r15), %rdx
movq %r12, %rdi
movl %r13d, %esi
callq 0x32ad
leaq 0x8ab9(%rip), %rdi      # 0xb20d
xorl %eax, %eax
callq 0x1100
movq (%r15), %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x32ad
leaq 0x8ab4(%rip), %rdi      # 0xb223
xorl %eax, %eax
callq 0x1100
testl %ebx, %ebx
jle 0x27ab
leaq 0x8ab3(%rip), %rdi      # 0xb234
xorl %eax, %eax
callq 0x1100
movslq 0x198(%rsp), %rdi
subq %r12, %rdi
movq (%r15), %rdx
xorl %esi, %esi
callq 0x32ad
leaq 0x8a9b(%rip), %rdi      # 0xb23f
xorl %eax, %eax
callq 0x1100
movl $0xa, %edi
callq 0x1040
leaq 0x8a95(%rip), %rdi      # 0xb251
xorl %eax, %eax
callq 0x1100
movq (%r15), %rdx
movq 0x38(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x32ad
cvtsi2sd %rbx, %xmm0
movsd 0x8825(%rip), %xmm1     # 0xb008
mulsd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r12, %xmm1
movsd %xmm1, 0x10(%rsp)
divsd %xmm1, %xmm0
movq %r15, %rbx
leaq 0x8a5b(%rip), %r15      # 0xb25e
movq %r15, %rdi
movb $0x1, %al
callq 0x1100
movq (%rbx), %rdx
movq 0x50(%rsp), %r12
movq %r12, %rdi
movl %ebp, %esi
callq 0x32ad
xorps %xmm0, %xmm0
cvtsi2sd %r12, %xmm0
mulsd 0x87d9(%rip), %xmm0     # 0xb008
xorps %xmm1, %xmm1
cvtsi2sd %r14, %xmm1
movsd %xmm1, 0x8(%rsp)
divsd %xmm1, %xmm0
leaq 0x8a2c(%rip), %rdi      # 0xb274
movb $0x1, %al
callq 0x1100
leaq 0x8a30(%rip), %rdi      # 0xb286
xorl %eax, %eax
callq 0x1100
movq %rbx, %r12
movq (%rbx), %rdx
movq 0x40(%rsp), %r14
movq %r14, %rdi
movl %r13d, %esi
callq 0x32ad
xorps %xmm0, %xmm0
cvtsi2sd %r14, %xmm0
mulsd 0x8785(%rip), %xmm0     # 0xb008
divsd 0x10(%rsp), %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x1100
movq (%rbx), %rdx
movq 0x58(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x32ad
xorps %xmm0, %xmm0
cvtsi2sd %rbx, %xmm0
mulsd 0x8753(%rip), %xmm0     # 0xb008
divsd 0x8(%rsp), %xmm0
leaq 0x89b2(%rip), %rdi      # 0xb274
movq %rdi, %r14
movb $0x1, %al
callq 0x1100
leaq 0x89c0(%rip), %rdi      # 0xb293
xorl %eax, %eax
callq 0x1100
movq (%r12), %rdx
movq 0x30(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x32ad
xorps %xmm0, %xmm0
cvtsi2sd %rbx, %xmm0
mulsd 0x870a(%rip), %xmm0     # 0xb008
divsd 0x10(%rsp), %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x1100
movq (%r12), %rdx
movq 0x48(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x32ad
xorps %xmm0, %xmm0
cvtsi2sd %rbx, %xmm0
mulsd 0x86d7(%rip), %xmm0     # 0xb008
divsd 0x8(%rsp), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x1100
leaq 0x8958(%rip), %rdi      # 0xb2a0
xorl %eax, %eax
callq 0x1100
movq (%r12), %rdx
movq 0x80(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x32ad
xorps %xmm0, %xmm0
cvtsi2sd %rbx, %xmm0
mulsd 0x8692(%rip), %xmm0     # 0xb008
divsd 0x10(%rsp), %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x1100
movq (%r12), %rdx
movq 0x88(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x32ad
xorps %xmm0, %xmm0
cvtsi2sd %rbx, %xmm0
mulsd 0x865c(%rip), %xmm0     # 0xb008
divsd 0x8(%rsp), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x1100
movl $0xa, %edi
callq 0x1040
leaq 0x88e0(%rip), %rdi      # 0xb2ad
xorl %eax, %eax
callq 0x1100
movq (%r12), %rdx
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x32ad
xorps %xmm0, %xmm0
cvtsi2sd %rbx, %xmm0
mulsd 0x8610(%rip), %xmm0     # 0xb008
divsd 0x10(%rsp), %xmm0
leaq 0x88b5(%rip), %r14      # 0xb2ba
movq %r14, %rdi
movb $0x1, %al
callq 0x1100
movq %r12, %r15
movq (%r12), %rdx
movq 0x90(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x32ad
xorps %xmm0, %xmm0
cvtsi2sd %rbx, %xmm0
mulsd 0x85d0(%rip), %xmm0     # 0xb008
divsd 0x8(%rsp), %xmm0
leaq 0x882f(%rip), %r12      # 0xb274
movq %r12, %rdi
movb $0x1, %al
callq 0x1100
leaq 0x887a(%rip), %rdi      # 0xb2d0
xorl %eax, %eax
callq 0x1100
movq %r15, %rbx
movq (%r15), %rdx
movq 0x60(%rsp), %r15
movq %r15, %rdi
movl %r13d, %esi
callq 0x32ad
xorps %xmm0, %xmm0
cvtsi2sd %r15, %xmm0
mulsd 0x8585(%rip), %xmm0     # 0xb008
divsd 0x10(%rsp), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x1100
movq (%rbx), %rdx
movq 0x68(%rsp), %r15
movq %r15, %rdi
movl %ebp, %esi
callq 0x32ad
xorps %xmm0, %xmm0
cvtsi2sd %r15, %xmm0
mulsd 0x8553(%rip), %xmm0     # 0xb008
divsd 0x8(%rsp), %xmm0
movq %r12, %rdi
movb $0x1, %al
callq 0x1100
leaq 0x8811(%rip), %rdi      # 0xb2dd
xorl %eax, %eax
callq 0x1100
movq (%rbx), %rdx
movq 0xa8(%rsp), %r15
movq %r15, %rdi
movl %r13d, %esi
callq 0x32ad
xorps %xmm0, %xmm0
cvtsi2sd %r15, %xmm0
mulsd 0x850f(%rip), %xmm0     # 0xb008
divsd 0x10(%rsp), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x1100
movq (%rbx), %rdx
movq 0xb0(%rsp), %r12
movq %r12, %rdi
movl %ebp, %esi
callq 0x32ad
xorps %xmm0, %xmm0
cvtsi2sd %r12, %xmm0
mulsd 0x84da(%rip), %xmm0     # 0xb008
divsd 0x8(%rsp), %xmm0
leaq 0x8739(%rip), %rdi      # 0xb274
movb $0x1, %al
callq 0x1100
leaq 0x87a1(%rip), %rdi      # 0xb2ea
xorl %eax, %eax
callq 0x1100
movq (%rbx), %rdx
movl %r13d, %esi
movl %r13d, 0x1c(%rsp)
movq 0x98(%rsp), %r13
movq %r13, %rdi
callq 0x32ad
xorps %xmm0, %xmm0
cvtsi2sd %r13, %xmm0
mulsd 0x848d(%rip), %xmm0     # 0xb008
divsd 0x10(%rsp), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x1100
movq (%rbx), %rdx
movq %rbx, %r14
movl %ebp, %ebx
movq 0xa0(%rsp), %rbp
movq %rbp, %rdi
movl %ebx, %esi
callq 0x32ad
xorps %xmm0, %xmm0
cvtsi2sd %rbp, %xmm0
mulsd 0x8453(%rip), %xmm0     # 0xb008
divsd 0x8(%rsp), %xmm0
leaq 0x86b2(%rip), %rdi      # 0xb274
movb $0x1, %al
callq 0x1100
movl $0xa, %edi
callq 0x1040
leaq 0x871d(%rip), %rdi      # 0xb2f7
xorl %eax, %eax
callq 0x1100
movq 0x40(%rsp), %rdi
addq 0x38(%rsp), %rdi
addq 0x30(%rsp), %rdi
addq %r13, %rdi
movq (%r14), %rdx
movl 0x1c(%rsp), %r13d
movl %r13d, %esi
callq 0x32ad
leaq 0x86fa(%rip), %rdi      # 0xb304
xorl %eax, %eax
callq 0x1100
movq 0x58(%rsp), %rdi
addq 0x50(%rsp), %rdi
addq 0x48(%rsp), %rdi
addq %rbp, %rdi
movq (%r14), %rdx
movq %r14, %rbp
movq %rdi, %r14
movl %ebx, %esi
callq 0x32ad
xorps %xmm0, %xmm0
cvtsi2sd %r14, %xmm0
mulsd 0x83c5(%rip), %xmm0     # 0xb008
divsd 0x8(%rsp), %xmm0
leaq 0x8624(%rip), %r14      # 0xb274
movq %r14, %rdi
movb $0x1, %al
callq 0x1100
leaq 0x86b8(%rip), %rdi      # 0xb319
xorl %eax, %eax
callq 0x1100
addq 0x60(%rsp), %r15
movq (%rbp), %rdx
movq %r15, %rdi
movl %r13d, %esi
callq 0x32ad
leaq 0x86a3(%rip), %rdi      # 0xb326
xorl %eax, %eax
callq 0x1100
addq 0x68(%rsp), %r12
movq (%rbp), %rdx
movq %r12, %rdi
movl %ebx, %esi
callq 0x32ad
xorps %xmm0, %xmm0
cvtsi2sd %r12, %xmm0
mulsd 0x835b(%rip), %xmm0     # 0xb008
divsd 0x8(%rsp), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x1100
movq 0xb8(%rsp), %rdi
callq 0x1030
leaq 0x168(%rsp), %rbx
movq %rbx, %rdi
callq 0x4ec2
movq 0xc0(%rsp), %r12
incq %r12
cmpq 0x70(%rsp), %r12
movq 0x78(%rsp), %r15
jne 0x22e5
leaq 0xd48c(%rip), %rax      # 0x10188
movq (%rax), %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1270
movq 0xd2e6(%rip), %rax      # 0xfff8
movq (%rax), %rdi
leaq 0xd46c(%rip), %rax      # 0x10188
movq (%rax), %rdx
movq 0x8(%r15), %rcx
leaq 0x82fc(%rip), %rsi      # 0xb026
jmp 0x22bf
movq 0xd2c2(%rip), %rax      # 0xfff8
movq (%rax), %rdi
leaq 0xd448(%rip), %rax      # 0x10188
movq (%rax), %rdx
leaq 0x837a(%rip), %rsi      # 0xb0c4
jmp 0x2e0f
movq 0xd2a2(%rip), %rax      # 0xfff8
movq (%rax), %rdi
leaq 0xd428(%rip), %rax      # 0x10188
movq (%rax), %rdx
leaq 0x838e(%rip), %rsi      # 0xb0f8
jmp 0x2e0f
movq 0xd282(%rip), %rax      # 0xfff8
movq (%rax), %rdi
leaq 0xd408(%rip), %rax      # 0x10188
movq (%rax), %rdx
leaq 0x83a5(%rip), %rsi      # 0xb12f
jmp 0x2e0f
movq 0xd262(%rip), %rax      # 0xfff8
movq (%rax), %rdi
leaq 0xd3e8(%rip), %rax      # 0x10188
movq (%rax), %rdx
leaq 0x83bc(%rip), %rsi      # 0xb166
jmp 0x2e0f
movq 0xd245(%rip), %rax      # 0xfff8
movq (%rax), %rdi
leaq 0xd3cb(%rip), %rax      # 0x10188
movq (%rax), %rdx
leaq 0x83d6(%rip), %rsi      # 0xb19d
jmp 0x2e0f
movq 0xd228(%rip), %rax      # 0xfff8
movq (%rax), %rdi
leaq 0xd3ae(%rip), %rax      # 0x10188
movq (%rax), %rdx
movl 0x1a0(%rsp), %ecx
leaq 0x8280(%rip), %rsi      # 0xb06b
xorl %eax, %eax
callq 0x11a0
jmp 0x2e16
movq 0xd1fd(%rip), %rax      # 0xfff8
movq (%rax), %rdi
leaq 0xd383(%rip), %rax      # 0x10188
movq (%rax), %rdx
leaq 0x828a(%rip), %rsi      # 0xb099
xorl %eax, %eax
callq 0x11a0
movl $0x1, %edi
callq 0x1270