// File: /workspace/github_c_makefile_star2_O3/thegenemyers[P]DASCRUBBER/DASrealign.c
// Function: EXTENDER
static void EXTENDER(int aread, Overlap *ovls, int novl)
{ Finger      _afinger, *afinger = &_afinger;
  Finger      _bfinger, *bfinger = &_bfinger;

  static Overlap     _ovla, *ovla = &_ovla;
  static Path        *ipath = &_ovla.path;

  static Path         rpath, fpath;
  static Alignment   _ralign, *ralign = &_ralign;
  static Alignment   _falign, *falign = &_falign;

  static Work_Data  *work = NULL;
  static Align_Spec *spec;

  int ap, alast;

  if (aread < ADB_ofirst || aread >= ADB_olast)
    return;

  if (work == NULL)
    { spec = New_Align_Spec(.70,100,ADB->freq,1);
      work = New_Work_Data();
      ralign->path = &rpath;
      falign->path = &fpath;
    }

  alast = IAMAP[aread+1];
  for (ap = IAMAP[aread]; ap < alast; ap++)
    { int mb, me;
      int aend, abeg, alen;

      mb = AMAP_IDX[ap]+2;
      me = AMAP_IDX[ap+1];

      abeg = AMAP[mb];
      aend = AMAP[me-1];
      if (aend - abeg < MIN_LEN)
        continue;

      ralign->aseq = falign->aseq = ((char *) ADB->bases) + ADB->reads[ap].boff;
      ralign->alen = falign->alen = alen = ADB->reads[ap].rlen;

#ifdef OUTLINE
      printf("AREAD %d -> %d [%d,%d]\n",aread,ap,abeg,aend);
      fflush(stdout);
#endif
#ifdef SHOW_MAP
      print_map(AMAP,mb,me,0);
#endif

      { int   o, ob, oe;
        Path *path;
        int   bread;
        int   bp, blast;

        for (ob = 0; ob < novl; ob = oe)
          { bread = ovls[ob].bread;
            for (oe = ob+1; oe < novl && ovls[oe].bread == bread; oe += 1)
              ;
            if (bread < BDB_ofirst || bread >= BDB_olast)
              continue;

            blast = IBMAP[bread+1];
            for (bp = IBMAP[bread]; bp < blast; bp++)
              { int hb, he;
                int bend, bbeg, blen;
                int alpos, clen;

                hb = BMAP_IDX[bp]+2;
                he = BMAP_IDX[bp+1];

                bbeg = BMAP[hb];
                bend = BMAP[he-1];
                if (bend - bbeg < MIN_LEN)
                  continue;

#ifdef OUTLINE
		printf("  BREAD %d->%d [%d,%d]\n",bread,bp,bbeg,bend);
                fflush(stdout);
#endif
#ifdef SHOW_MAP
		print_map(BMAP,hb,he,0);
#endif

                alpos = -1;
                for (o = ob; o < oe; o++)
                  { int bbreal, bereal;

                    path = &(ovls[o].path);
                    if (COMP(ovls[o].flags))
                      { clen = BMAP[hb-1];
                        bbreal = clen-path->bepos;
                        bereal = clen-path->bbpos;
                      }
                    else
                      { clen = 0;
                        bbreal = path->bbpos;
                        bereal = path->bepos;
                      }
  
#ifdef OUTLINE
                    printf("    OVL %d: [%d,%d] %c [%d,%d]\n",o,
                           path->abpos,path->aepos,(clen==0)?'n':'c',bbreal,bereal);
                    fflush(stdout);
#endif

                    if (path->abpos <= aend-MIN_LEN && path->aepos >= abeg+MIN_LEN &&
                             bbreal <= bend-MIN_LEN &&      bereal >= bbeg+MIN_LEN)

                      { ralign->bseq  = falign->bseq  = ((char *) BDB->bases) + BDB->reads[bp].boff;
                        ralign->blen  = falign->blen  = blen = BDB->reads[bp].rlen;
                        ralign->flags = falign->flags = ovls[o].flags;

                        if (COMP(ralign->flags))
                          Complement_Seq(ralign->bseq,blen);

#ifdef SHOW_MAP
                        print_map(BMAP,hb,he,clen);
#endif

                        init_finger(afinger,AMAP,mb,me,0);
                        init_finger(bfinger,BMAP,hb,he,clen);
                        if ( ! recon(ipath,path,afinger,bfinger))
                          { int apos, bpos, acc, len, diag;

                            init_finger(afinger,AMAP,mb,me,0);
                            init_finger(bfinger,BMAP,hb,he,clen);
                            if (estimate(path,afinger,bfinger,&apos,&bpos,&acc))
                              if (apos > alpos)
                                { diag = apos-bpos;

                                  acc /= 2;
                                  if (apos + acc > alen)
                                    acc = alen-apos;
                                  if (bpos + acc > blen)
                                    acc = blen-bpos;
                                  if (apos < acc)
                                    acc = apos;
                                  if (bpos < acc)
                                    acc = bpos;
                                  if (acc > 500)
                                    acc = 500;
                                  acc *= 2;

#ifdef OUTLINE
                                  printf("      Trying: %d,%d + %d\n",apos,bpos,acc);
                                  fflush(stdout);
#endif
                                  Local_Alignment(ralign,work,spec,
                                                  diag-acc,diag+acc,apos+bpos,-1,-1);
#ifdef OUTLINE
                                  printf("      Local: <%d,%d> -> <%d,%d>\n",
                                         ralign->path->abpos,ralign->path->bbpos,
                                         ralign->path->aepos,ralign->path->bepos);
                                  fflush(stdout);
#endif
                                  len = ralign->path->aepos - ralign->path->abpos;
                                  if (len >= MIN_LEN && ralign->path->diffs <= .35*len)
                                    { ovla->aread = ap;
                                      ovla->bread = bp;
                                      ovla->flags = ralign->flags;
                                      _ovla.path  = *(ralign->path);
                                      convert_trace(ralign->path);
#ifdef OUTLINE
                                      printf("      Final: %d[%d..%d] vs %d[%d..%d] %c d=%d\n",
                                             ovla->aread,ovla->path.abpos,ovla->path.aepos,
                                             ovla->bread,ovla->path.bbpos,ovla->path.bepos,
                                             (COMP(ovla->flags) ? 'c' : 'n'), ovla->path.diffs);
                                      fflush(stdout);
#endif
#ifdef SHOW_FINAL
                                      show_overlap(ovla);
#endif
#ifdef SHOW_ALIGNMENTS
                                      Compute_Trace_IRR(ralign,work,GREEDIEST);
                                      Print_Alignment(stdout,ralign,work,4,80,10,0,6);
#else
                                      Write_Overlap(OUTPUT,ovla,sizeof(uint16));
                                      WOVLS += 1;
#endif

                                      alpos  = ralign->path->aepos;
#ifdef OUTLINE
                                      printf("        ACCEPT\n");
#endif
                                    }
#ifdef OUTLINE
                                  else
                                    printf("        REJECT\n");
#endif
                                }
#ifdef OUTLINE
                              else
                                printf("        SKIP\n");
                            else
                              printf("        NO OVERLAP\n");
                            fflush(stdout);
#endif
                          }

                        else if (ipath->aepos > alpos)
                          { int ab, bb;
                            int ae, be;
                            int ar, br;
                            int af, bf;

                            ab = ipath->abpos;
                            bb = ipath->bbpos;
                            ae = ipath->aepos;
                            be = ipath->bepos;

                            ar = ab;
                            br = bb;
                            if (ab > 0 && bb > 0)
                              { Find_Extension(ralign,work,spec,ab-bb,ab+bb,-1,-1,1);
                                ar = ralign->path->abpos;
                                br = ralign->path->bbpos;
#ifdef OUTLINE
                                printf("      Rev: (%d,%d)",ab,bb);
                                printf(" -> (%d,%d)",ar,br);
                                printf(" %d",ralign->path->diffs);
                                fflush(stdout);
#endif
                                if (ar == 0 || br == 0 || ralign->path->diffs <= .35*(ab-ar))
                                  {
#ifdef OUTLINE
                                    printf(" OK\n");
                                    fflush(stdout);
#endif
                                    if (ab - 10 < ar)
                                      { uint16 *trace = (uint16 *) ipath->trace;
                                        int     tlen  = ipath->tlen;

                                        if (tlen > 0)
                                          { trace[0] += ab - ar;
                                            trace[1] += bb - br;
                                          }
                                        ipath->abpos = ar;
                                        ipath->bbpos = br;
                                      }
                                    else
                                      { convert_trace(ralign->path);
                                        fusion(ralign->path,ipath,2);
                                      }
                                  }
                                else
                                  { ar = ab;
                                    br = bb;
#ifdef OUTLINE
                                    printf(" NOTOK\n");
                                    fflush(stdout);
#endif
                                  }
                              }

                            af = ae;
                            bf = be;
                            if (ae < alen && be < blen)
                              { Find_Extension(falign,work,spec,ae-be,ae+be,-1,-1,0);
                                af = falign->path->aepos;
                                bf = falign->path->bepos;
#ifdef OUTLINE
                                printf("      Fow: (%d,%d)",ae,be);
                                printf(" -> (%d,%d)",af,bf);
                                printf(" %d",falign->path->diffs);
                                fflush(stdout);
#endif
                                if (af == alen || bf == blen || falign->path->diffs <= .35*(af-ae))
                                  {
#ifdef OUTLINE
                                    printf(" OK\n");
                                    fflush(stdout);
#endif
                                    if (ae + 10 > af)
                                      { uint16 *trace = (uint16 *) ipath->trace;
                                        int     tlen  = ipath->tlen;

                                        if (tlen > 0)
                                          { trace[tlen-2] += af-ae;
                                            trace[tlen-1] += bf-be;
                                          }
                                        ipath->aepos = af;
                                        ipath->bepos = bf;
                                      }
                                    else
                                      { convert_trace(falign->path);
                                        fusion(ipath,falign->path,1);
                                      }
                                  }
                                else
                                  { af = ae;
                                    bf = be;
#ifdef OUTLINE
                                    printf(" NOTOK\n");
                                    fflush(stdout);
#endif
                                  }
                              }

                            alpos = af;
                            if (af-ar >= MIN_LEN) 
                              { ovla->aread = AFIRST + ap;
                                ovla->bread = BFIRST + bp;
                                ovla->flags = ralign->flags;
#ifdef OUTLINE
                                printf("      Final: %d[%d..%d] vs %d[%d..%d] %c d=%d\n",
                                       ovla->aread,ovla->path.abpos,ovla->path.aepos,
                                       ovla->bread,ovla->path.bbpos,ovla->path.bepos,
                                       (COMP(ovla->flags) ? 'c' : 'n'), ovla->path.diffs);
                                fflush(stdout);
#endif
#ifdef SHOW_FINAL
                                show_overlap(ovla);
#endif
#ifdef SHOW_ALIGNMENTS
				fpath = *ipath;
                                Compute_Trace_IRR(falign,work,GREEDIEST);
                                Print_Alignment(stdout,falign,work,4,80,10,0,6);
#else
                                Write_Overlap(OUTPUT,ovla,sizeof(uint16));
                                WOVLS += 1;
#endif
                              }
#ifdef OUTLINE
                            else
                              printf("        NO OVERLAP\n");
#endif
                            fusion(NULL,NULL,0);
                          }

#ifdef OUTLINE
                        else
                          printf("     SKIP\n");
                        fflush(stdout);
#endif

                        if (COMP(ralign->flags))
                          Complement_Seq(ralign->bseq,blen);
                      }
                  }
              }
          }
      }
    }
}

// Assembly:
cmpl %edi, 0x1e13d(%rip)     # 0x211b8
jg 0x43c7
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movl %edi, %ebx
cmpl %edi, 0x1e122(%rip)     # 0x211bc
jle 0x43b6
movl %edx, %ebp
movq %rsi, %r15
cmpq $0x0, 0x1e303(%rip)     # 0x213b0
jne 0x30fe
leaq 0x1e152(%rip), %rsi     # 0x21208
movsd 0x17f62(%rip), %xmm0    # 0x1b020
movl $0x64, %edi
movl $0x1, %edx
callq 0x478e
movq %rax, 0x1e2e4(%rip)     # 0x213b8
xorl %eax, %eax
callq 0x46f4
movq %rax, 0x1e2ce(%rip)     # 0x213b0
leaq 0x1e237(%rip), %rax     # 0x21320
movq %rax, 0x1e270(%rip)     # 0x21360
leaq 0x1e249(%rip), %rax     # 0x21340
movq %rax, 0x1e28a(%rip)     # 0x21388
movq 0x1e0bb(%rip), %rax     # 0x211c0
movslq %ebx, %rcx
movslq 0x4(%rax,%rcx,4), %rdx
movslq (%rax,%rcx,4), %rax
movq %rdx, 0x140(%rsp)
cmpl %edx, %eax
jge 0x43b6
movslq %ebp, %rcx
movq %rcx, 0x170(%rsp)
leaq 0x58(%r15), %rcx
movq %rcx, 0x148(%rsp)
movl %ebp, 0x28(%rsp)
movq %r15, 0x50(%rsp)
movq %rax, %rcx
movq 0x1e05d(%rip), %rax     # 0x211a8
movq (%rax,%rcx,8), %rsi
movq %rcx, 0xb0(%rsp)
movq 0x8(%rax,%rcx,8), %rdx
movq 0x1e04d(%rip), %rax     # 0x211b0
movq %rsi, %rdi
shlq $0x20, %rsi
movabsq $0x200000000, %rcx      # imm = 0x200000000
addq %rcx, %rsi
movq %rsi, %rcx
movq %rsi, 0x118(%rsp)
sarq $0x1e, %rcx
movl (%rax,%rcx), %esi
movq %rdx, 0xc0(%rsp)
movq %rdx, %r9
shlq $0x20, %r9
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
addq %r9, %rcx
sarq $0x1e, %rcx
movl (%rax,%rcx), %r12d
movl %r12d, %eax
movq %rsi, 0x178(%rsp)
subl %esi, %eax
cmpl 0x1dfdc(%rip), %eax     # 0x2119c
jl 0x439d
movq 0x1e083(%rip), %rax     # 0x21250
movq 0x1e084(%rip), %rcx     # 0x21258
movq 0xb0(%rsp), %rdx
leaq (%rdx,%rdx,4), %rdx
addq 0x10(%rcx,%rdx,8), %rax
movq %rax, 0x1e1ac(%rip)     # 0x21398
movq %rax, 0x1e17d(%rip)     # 0x21370
movl 0x4(%rcx,%rdx,8), %eax
movl %eax, 0x1e1ab(%rip)     # 0x213a8
movl %eax, 0x58(%rsp)
movl %eax, 0x1e179(%rip)     # 0x21380
testl %ebp, %ebp
jle 0x439d
sarq $0x20, 0x118(%rsp)
addl $0x5, %edi
movq %rdi, 0x110(%rsp)
movslq %edi, %rcx
sarq $0x20, %r9
movq %rcx, 0x168(%rsp)
leaq 0x3(%rcx), %rax
movq %rax, 0x158(%rsp)
xorl %eax, %eax
movq %r9, 0x10(%rsp)
movl %r12d, 0x2c(%rsp)
movl %eax, %edi
movslq %eax, %rsi
movq %rsi, %rax
shlq $0x4, %rax
leaq (%rax,%rax,2), %rcx
movslq 0x28(%r15,%rcx), %rax
leal 0x1(%rsi), %edx
cmpl %edx, %ebp
cmovgl %ebp, %edx
leal -0x1(%rdx), %r8d
movq %r8, 0xf0(%rsp)
movq %rsi, 0x150(%rsp)
incq %rsi
addq 0x148(%rsp), %rcx
movl %edi, 0x124(%rsp)
movq %rdi, 0x90(%rsp)
cmpq 0x170(%rsp), %rsi
jge 0x32d3
movq 0x90(%rsp), %rdi
incl %edi
movq %rdi, 0x90(%rsp)
incq %rsi
leaq 0x30(%rcx), %rdi
cmpl %eax, (%rcx)
movq %rdi, %rcx
je 0x3295
movq 0x90(%rsp), %rcx
decl %ecx
movq %rcx, 0xf0(%rsp)
jmp 0x32db
movq %rdx, 0x90(%rsp)
cmpl 0x1def7(%rip), %eax     # 0x211d8
jl 0x438d
cmpl 0x1deef(%rip), %eax     # 0x211dc
jge 0x438d
movq 0x1dee6(%rip), %rcx     # 0x211e0
movslq 0x4(%rcx,%rax,4), %rdx
movslq (%rcx,%rax,4), %rcx
movq %rdx, 0x160(%rsp)
cmpl %edx, %ecx
jge 0x438d
movq 0xf0(%rsp), %rax
leal 0x1(%rax), %r8d
movl %r8d, 0xa0(%rsp)
movq 0x1de9a(%rip), %rax     # 0x211c8
movq (%rax,%rcx,8), %rsi
movq %rcx, 0xb8(%rsp)
movq 0x8(%rax,%rcx,8), %rdi
movq 0x1de8a(%rip), %rax     # 0x211d0
movq %rsi, %rdx
shlq $0x20, %rsi
movabsq $0x200000000, %rcx      # imm = 0x200000000
movq %rsi, %r10
addq %rsi, %rcx
movq %rcx, 0xf8(%rsp)
sarq $0x1e, %rcx
movl (%rax,%rcx), %esi
movq %rdi, 0x100(%rsp)
shlq $0x20, %rdi
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
movq %rdi, 0x108(%rsp)
addq %rdi, %rcx
sarq $0x1e, %rcx
movl (%rax,%rcx), %eax
movl %eax, 0x12c(%rsp)
movl %esi, 0x128(%rsp)
subl %esi, %eax
cmpl 0x1ddf2(%rip), %eax     # 0x2119c
jl 0x4374
movq 0xf0(%rsp), %rax
cmpl %eax, 0x124(%rsp)
jg 0x4374
sarq $0x20, 0xf8(%rsp)
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %r10
sarq $0x1e, %r10
movq %r10, 0x188(%rsp)
movq 0x100(%rsp), %rax
addl $-0x4, %eax
movl %eax, 0xa8(%rsp)
leal 0x1(%rdx), %eax
movl %eax, 0xa4(%rsp)
sarq $0x1e, 0x108(%rsp)
addl $0x5, %edx
movq %rdx, 0x130(%rsp)
movl $0xffffffff, 0x40(%rsp) # imm = 0xFFFFFFFF
movq 0x150(%rsp), %r10
leaq (%r10,%r10,2), %rax
shlq $0x4, %rax
leaq (%r15,%rax), %r11
movl 0x20(%r15,%rax), %eax
testb $0x1, %al
jne 0x344e
movl 0x14(%r11), %edx
movl 0x1c(%r11), %ecx
movl $0x0, 0xc(%rsp)
jmp 0x346e
movq 0x1dd7b(%rip), %rcx     # 0x211d0
movq 0x188(%rsp), %rdx
movl (%rcx,%rdx), %ecx
movl %ecx, %edx
subl 0x1c(%r11), %edx
movl %ecx, 0xc(%rsp)
subl 0x14(%r11), %ecx
movl 0x1dd28(%rip), %esi     # 0x2119c
movl %r12d, %edi
subl %esi, %edi
cmpl %edi, 0x10(%r11)
jg 0x42a7
movq 0x178(%rsp), %rdi
addl %esi, %edi
cmpl %edi, 0x18(%r11)
jl 0x42a7
movl 0x12c(%rsp), %edi
subl %esi, %edi
cmpl %edi, %edx
jg 0x42a7
addl 0x128(%rsp), %esi
cmpl %esi, %ecx
jl 0x42a7
movq 0x1dcaa(%rip), %rcx     # 0x21168
movq 0x58(%rcx), %rdi
movq 0x60(%rcx), %rcx
movq 0xb8(%rsp), %rdx
leaq (%rdx,%rdx,4), %rdx
addq 0x10(%rcx,%rdx,8), %rdi
movq %rdi, 0x1dec2(%rip)     # 0x213a0
movq %rdi, 0x1de93(%rip)     # 0x21378
movl 0x4(%rcx,%rdx,8), %ecx
movl %ecx, 0x1debd(%rip)     # 0x213ac
movl %ecx, 0x3c(%rsp)
movl %ecx, 0x1de8b(%rip)     # 0x21384
movl %eax, 0x1de91(%rip)     # 0x21390
movl %eax, 0x1de63(%rip)     # 0x21368
testb $0x1, %al
movq %r10, 0x138(%rsp)
movq %r11, 0x48(%rsp)
je 0x3529
movl 0x3c(%rsp), %esi
callq 0xaa81
movq 0x48(%rsp), %r11
movq 0x10(%rsp), %r9
movq 0x1dc80(%rip), %r15     # 0x211b0
movq 0xc0(%rsp), %rax
movl %eax, 0xd4(%rsp)
movq 0x118(%rsp), %rax
movl (%r15,%rax,4), %r13d
movl $0x0, 0xe0(%rsp)
movq %r15, 0xe8(%rsp)
movq 0x1dc6b(%rip), %r14     # 0x211d0
movl 0xc(%rsp), %edi
testl %edi, %edi
movq %r14, 0x88(%rsp)
je 0x35b1
movl 0xa8(%rsp), %ebp
movl %ebp, 0x68(%rsp)
movl 0xa4(%rsp), %ecx
movl %ecx, 0x6c(%rsp)
movl %edi, %r12d
movq 0x108(%rsp), %rax
movq 0x88(%rsp), %rdx
subl -0x4(%rdx,%rax), %r12d
movl %ebp, 0x18(%rsp)
movq 0x88(%rsp), %r14
jmp 0x35d9
movq 0x130(%rsp), %rax
movl %eax, 0x68(%rsp)
movq 0x100(%rsp), %rcx
movl %ecx, 0x6c(%rsp)
movq 0xf8(%rsp), %rdx
movl (%r14,%rdx,4), %r12d
movl %eax, 0x18(%rsp)
movl %ecx, 0x24(%rsp)
movq 0x110(%rsp), %rbp
movl %edi, 0x78(%rsp)
movq %r14, 0x80(%rsp)
movq (%r11), %rax
movq %rax, 0x98(%rsp)
movl 0x8(%r11), %ecx
movq 0x1ddb9(%rip), %rax     # 0x213c0
cmpl 0x1db6b(%rip), %ecx     # 0x21178
jle 0x3657
cvtsi2sd %ecx, %xmm0
mulsd 0x179ed(%rip), %xmm0    # 0x1b008
addsd 0x179f5(%rip), %xmm0    # 0x1b018
cvttsd2si %xmm0, %ecx
movl %ecx, 0x1db4b(%rip)     # 0x21178
movslq %ecx, %rsi
addq %rsi, %rsi
movq %rax, %rdi
leaq 0x17c9b(%rip), %rdx     # 0x1b2d8
callq 0x13171
movl 0xc(%rsp), %edi
movq 0x48(%rsp), %r11
movq 0x10(%rsp), %r9
movq %rax, 0x1dd69(%rip)     # 0x213c0
movq %rax, 0x180(%rsp)
movq %rax, 0x1dc8a(%rip)     # 0x212f0
movl 0x1db2c(%rip), %esi     # 0x21198
movl 0x10(%r11), %ecx
movl 0x14(%r11), %ebx
movl %ecx, %eax
cltd
movl %esi, 0x5c(%rsp)
idivl %esi
movl %edx, 0xc8(%rsp)
cmpl 0xc0(%rsp), %ebp
jge 0x36a4
movq 0x168(%rsp), %rax
movl (%r15,%rax,4), %edx
xorl %eax, %eax
cmpl %ecx, %edx
jle 0x36ab
movl %ebp, %r8d
jmp 0x36de
xorl %eax, %eax
movl %ebp, %r8d
jmp 0x3711
xorl %eax, %eax
movq 0x158(%rsp), %r8
movl %eax, %esi
movl -0x14(%r15,%r8,4), %eax
subl %r13d, %eax
movl %edx, %r13d
addl -0x10(%r15,%r8,4), %eax
addl %esi, %eax
cmpq %r9, %r8
jge 0x36fa
movl (%r15,%r8,4), %edx
addq $0x3, %r8
cmpl %ecx, %edx
jle 0x36b5
addl $-0x3, %r8d
movq %r14, %rsi
movl %r13d, 0xdc(%rsp)
movl %eax, 0xd8(%rsp)
movl %r8d, 0xd0(%rsp)
jmp 0x3714
movl %r13d, 0xdc(%rsp)
movl %eax, 0xd8(%rsp)
movl %r8d, 0xd0(%rsp)
movq %r14, %rsi
movslq %r8d, %rdx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpl %ecx, -0x8(%r15,%rdx,4)
jl 0x3772
movl %ecx, %edx
subl %r13d, %edx
jl 0x3772
addl %eax, %edx
js 0x3772
movl %edx, 0x8(%rsp)
testl %edi, %edi
movl %ebx, %r14d
je 0x3f18
movl 0x18(%rsp), %edx
cmpl 0x24(%rsp), %edx
jle 0x3f95
movslq %edx, %rdx
movl %edi, %r11d
subl (%rsi,%rdx,4), %r11d
xorl %r10d, %r10d
cmpl %ebx, %r11d
jle 0x40cd
movl 0xc(%rsp), %edi
movq 0x88(%rsp), %rbp
jmp 0x4120
xorl %r10d, %r10d
movl $0x0, 0x8(%rsp)
xorl %edx, %edx
movslq 0x8(%r11), %r14
movq %r14, 0x190(%rsp)
cmpq $0x1, %r14
jle 0x3a66
movl %edx, 0x30(%rsp)
subl 0xc8(%rsp), %ecx
movslq 0x24(%rsp), %rdx
movq %rdx, 0xc8(%rsp)
movl $0x0, 0xac(%rsp)
movl $0x1, %edx
addl 0x5c(%rsp), %ecx
movl 0x18(%r11), %edi
cmpl %edi, %ecx
cmovgel %edi, %ecx
movl %ebx, %r14d
testl %ebp, %ebp
js 0x37e5
movq 0x98(%rsp), %rdi
movzwl -0x2(%rdi,%rdx,2), %edi
addl %edi, 0xac(%rsp)
cmpl 0xc0(%rsp), %r8d
jge 0x3828
movslq %r8d, %rdi
movl (%r15,%rdi,4), %r11d
cmpl %ecx, %r11d
jg 0x3828
addq $0x3, %rdi
movl %eax, %ebx
movl -0x14(%r15,%rdi,4), %eax
subl %r13d, %eax
movl %r11d, %r13d
movl %edi, %r8d
addl -0x10(%r15,%rdi,4), %eax
addl %ebx, %eax
cmpq %r9, %rdi
jge 0x3828
movl (%r15,%rdi,4), %r11d
addq $0x3, %rdi
cmpl %ecx, %r11d
jle 0x37ff
movq 0x98(%rsp), %rdi
movzwl (%rdi,%rdx,2), %edi
movl %r14d, %ebx
addl %edi, %ebx
movslq %r8d, %rdi
cmpl %ecx, -0x8(%r15,%rdi,4)
jl 0x398d
movl %ecx, %edi
subl %r13d, %edi
jl 0x398d
addl %eax, %edi
js 0x398d
cmpl $0x0, 0xc(%rsp)
movl %ebx, %r14d
je 0x389c
movl %ebp, 0x44(%rsp)
movq %rsi, %rbp
movl 0x18(%rsp), %esi
cmpl 0x24(%rsp), %esi
jle 0x390c
movslq %esi, %r11
movl 0xc(%rsp), %ebx
subl (%rbp,%r11,4), %ebx
cmpl %r14d, %ebx
jle 0x39bb
movl 0xc(%rsp), %esi
movq 0x88(%rsp), %rbp
jmp 0x3910
movl 0x18(%rsp), %r9d
cmpl 0x24(%rsp), %r9d
jge 0x38ea
movslq %r9d, %r11
movl (%rsi,%r11,4), %ebx
cmpl %r14d, %ebx
jg 0x38ea
addq $0x3, %r11
movl %r10d, %r9d
movl -0x14(%rsi,%r11,4), %r10d
subl %r12d, %r10d
movl %ebx, %r12d
movl %r11d, 0x18(%rsp)
addl -0x10(%rsi,%r11,4), %r10d
addl %r9d, %r10d
cmpq 0xc8(%rsp), %r11
jge 0x38ea
movl (%rsi,%r11,4), %ebx
addq $0x3, %r11
cmpl %r14d, %ebx
jle 0x38b8
movslq 0x18(%rsp), %r9
movl %r14d, %ebx
cmpl %r14d, -0x8(%rsi,%r9,4)
jl 0x3a53
cmpl %ebx, %r12d
movq 0x10(%rsp), %r9
jle 0x3937
jmp 0x398d
movl 0xc(%rsp), %esi
movslq 0x18(%rsp), %r9
subl 0x8(%rbp,%r9,4), %esi
movl %r14d, %ebx
cmpl %r14d, %esi
movq %rbp, %rsi
jl 0x3a0c
cmpl %ebx, %r12d
movq 0x10(%rsp), %r9
movl 0x44(%rsp), %ebp
jg 0x398d
movl %ebx, %r11d
subl %r12d, %r11d
addl %r10d, %r11d
js 0x398d
testl %ebp, %ebp
js 0x3a23
movl %edi, %r9d
subl 0x8(%rsp), %r9d
movl %ebp, %ebx
movl %ebp, 0x44(%rsp)
movq %rsi, %rbp
movq 0x180(%rsp), %rsi
movw %r9w, (%rsi,%rbx,2)
movl %r11d, %r9d
subl 0x30(%rsp), %r9d
movw %r9w, 0x2(%rsi,%rbx,2)
movq %rbp, %rsi
movl 0x44(%rsp), %ebp
movl %r14d, %ebx
movq 0x10(%rsp), %r9
addl $0x2, %ebp
jmp 0x3a32
movl 0x8(%rsp), %edi
movl 0x30(%rsp), %r11d
addq $0x2, %rdx
movl %r11d, 0x30(%rsp)
movl %edi, 0x8(%rsp)
cmpq 0x190(%rsp), %rdx
movq 0x48(%rsp), %r11
jb 0x37bd
jmp 0x3a71
addq $-0x3, %r11
movl 0xc(%rsp), %esi
movq 0x88(%rsp), %rbp
movl %r10d, %r9d
addl 0x14(%rbp,%r11,4), %r12d
movl %esi, %r10d
subl %r12d, %r10d
movl %ebx, %r12d
movl %r11d, 0x18(%rsp)
addl 0x10(%rbp,%r11,4), %r10d
addl %r9d, %r10d
cmpq 0xc8(%rsp), %r11
jle 0x3910
movl %esi, %ebx
subl (%rbp,%r11,4), %ebx
addq $-0x3, %r11
cmpl %r14d, %ebx
jle 0x39cb
jmp 0x3910
movl 0x8(%rsp), %edi
movl 0x30(%rsp), %r11d
movq 0x10(%rsp), %r9
movl 0x44(%rsp), %ebp
jmp 0x3996
movl %edi, 0x1d8d7(%rip)     # 0x21300
movl %r11d, 0x1d8d4(%rip)    # 0x21304
xorl %ebp, %ebp
movl %edi, 0x1d8d0(%rip)     # 0x21308
movl %r11d, 0x1d8cd(%rip)    # 0x2130c
movl 0xac(%rsp), %r14d
movl %r14d, 0x1d8ae(%rip)    # 0x212fc
jmp 0x3996
movl 0x8(%rsp), %edi
movl 0x30(%rsp), %r11d
movq 0x10(%rsp), %r9
jmp 0x3996
movl %ebp, 0x1d88c(%rip)     # 0x212f8
jmp 0x3b72
movl %r8d, 0xd0(%rsp)
movl %r13d, 0xdc(%rsp)
movl %eax, 0xd8(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x68(%rsp)
movl %r12d, 0x74(%rsp)
movl %r10d, 0x70(%rsp)
movl %ebp, 0x1d858(%rip)     # 0x212f8
testl %ebp, %ebp
movl 0xc(%rsp), %edi
jle 0x3b72
movl 0x1d856(%rip), %ebx     # 0x21308
cmpl 0x40(%rsp), %ebx
movl 0x28(%rsp), %ebp
movq 0x50(%rsp), %r15
movl 0x2c(%rsp), %r12d
jle 0x4279
movl 0x1d82f(%rip), %r12d    # 0x21300
movl 0x1d82c(%rip), %r15d    # 0x21304
movl 0x1d82d(%rip), %r14d    # 0x2130c
testl %r12d, %r12d
setg %al
testl %r15d, %r15d
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x3f9d
movq 0x1d8b3(%rip), %rsi     # 0x213b0
movq 0x1d8b4(%rip), %rdx     # 0x213b8
movl %r12d, %ecx
subl %r15d, %ecx
leal (%r15,%r12), %r8d
leaq 0x1d84b(%rip), %rdi     # 0x21360
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
pushq $0x1
pushq $-0x1
callq 0x8192
addq $0x10, %rsp
movq 0x1d831(%rip), %rdi     # 0x21360
movl 0x10(%rdi), %r13d
movl 0x14(%rdi), %eax
testl %r13d, %r13d
sete %cl
testl %eax, %eax
sete %dl
orb %cl, %dl
jne 0x3fab
cvtsi2sdl 0xc(%rdi), %xmm0
movl %r12d, %ecx
subl %r13d, %ecx
cvtsi2sd %ecx, %xmm1
mulsd 0x174c8(%rip), %xmm1    # 0x1b028
ucomisd %xmm0, %xmm1
jae 0x3fab
movl %r12d, %r13d
jmp 0x3fe5
movq 0x1d637(%rip), %rax     # 0x211b0
movq 0x110(%rsp), %rcx
movl %ecx, 0xd0(%rsp)
movq 0xc0(%rsp), %rcx
movl %ecx, 0xd4(%rsp)
movq 0x118(%rsp), %rcx
movl (%rax,%rcx,4), %ecx
movl %ecx, 0xdc(%rsp)
xorl %ecx, %ecx
movl %ecx, 0xd8(%rsp)
movl %ecx, 0xe0(%rsp)
movq %rax, 0xe8(%rsp)
movq 0x1d608(%rip), %rax     # 0x211d0
testl %edi, %edi
je 0x3bf2
movl 0xa8(%rsp), %ecx
movl %ecx, 0x68(%rsp)
movl 0xa4(%rsp), %ecx
movl %ecx, 0x6c(%rsp)
movl %edi, %ecx
movq 0x108(%rsp), %rdx
subl -0x4(%rax,%rdx), %ecx
jmp 0x3c15
movq 0x130(%rsp), %rcx
movl %ecx, 0x68(%rsp)
movq 0x100(%rsp), %rcx
movl %ecx, 0x6c(%rsp)
movq 0xf8(%rsp), %rcx
movl (%rax,%rcx,4), %ecx
movl %ecx, 0x74(%rsp)
movl $0x0, 0x70(%rsp)
movl %edi, 0x78(%rsp)
movq %rax, 0x80(%rsp)
movq (%r11), %rax
movq %rax, 0x18(%rsp)
movl 0x10(%r11), %r12d
movl %r12d, %eax
cltd
idivl 0x5c(%rsp)
movl %edx, %ebp
movl 0x14(%r11), %r15d
leaq 0xd0(%rsp), %rdi
movl %r12d, %esi
leaq 0x64(%rsp), %rdx
callq 0x452f
movl $0x7fffffff, 0x8(%rsp)  # imm = 0x7FFFFFFF
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x3c9e
movl %eax, %ebx
leaq 0x68(%rsp), %rdi
movl %r15d, %esi
leaq 0x60(%rsp), %rdx
callq 0x452f
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x3ca3
movl 0x60(%rsp), %ecx
addl 0x64(%rsp), %ecx
movl %ecx, 0x8(%rsp)
movl %ebx, %r14d
movl %eax, %ecx
jmp 0x3ca3
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %r14, 0x30(%rsp)
movq 0x48(%rsp), %rax
movl 0x8(%rax), %r14d
cmpl $0x2, %r14d
movq 0x10(%rsp), %r9
movq %rcx, 0x98(%rsp)
jl 0x3d5b
subl %ebp, %r12d
movl 0x18(%rax), %r13d
movl $0x1, %ebp
movl %r15d, %eax
addl 0x5c(%rsp), %r12d
movq 0x18(%rsp), %rcx
movzwl (%rcx,%rbp,2), %r15d
addl %eax, %r15d
cmpl %r13d, %r12d
cmovgel %r13d, %r12d
leaq 0xd0(%rsp), %rdi
movl %r12d, %esi
leaq 0x64(%rsp), %rdx
callq 0x452f
testl %eax, %eax
js 0x3d49
movl %eax, %ebx
leaq 0x68(%rsp), %rdi
movl %r15d, %esi
leaq 0x60(%rsp), %rdx
callq 0x452f
testl %eax, %eax
js 0x3d49
movl 0x60(%rsp), %ecx
addl 0x64(%rsp), %ecx
cmpl 0x8(%rsp), %ecx
movq 0x10(%rsp), %r9
jge 0x3d4e
movl %ebx, %edx
movq %rdx, 0x30(%rsp)
movq %rax, 0x98(%rsp)
movl %ecx, 0x8(%rsp)
jmp 0x3d4e
movq 0x10(%rsp), %r9
addq $0x2, %rbp
cmpl %ebp, %r14d
jg 0x3cd4
movq 0x30(%rsp), %r10
testl %r10d, %r10d
js 0x3f05
cmpl 0x40(%rsp), %r10d
movl 0x28(%rsp), %ebp
movq 0x50(%rsp), %r15
movl 0x2c(%rsp), %r12d
jle 0x4279
movl %r10d, %eax
movq 0x98(%rsp), %r9
subl %r9d, %eax
movl 0x8(%rsp), %edx
movl %edx, %ecx
shrl $0x1f, %ecx
addl %edx, %ecx
sarl %ecx
leal (%rcx,%r10), %edx
movl 0x58(%rsp), %edi
movl %edi, %esi
subl %r10d, %esi
cmpl %edi, %edx
cmovlel %ecx, %esi
leal (%rsi,%r9), %ecx
movl 0x3c(%rsp), %edx
movl %edx, %edi
subl %r9d, %edi
cmpl %edx, %ecx
cmovlel %esi, %edi
cmpl %edi, %r10d
cmovll %r10d, %edi
cmpl %edi, %r9d
cmovll %r9d, %edi
movl $0x1f4, %ecx            # imm = 0x1F4
cmpl %ecx, %edi
cmovgel %ecx, %edi
leal (%rdi,%rdi), %r11d
movq 0x1d5cc(%rip), %rsi     # 0x213b0
movq 0x1d5cd(%rip), %rdx     # 0x213b8
leal (%rax,%rdi,2), %r8d
movl %eax, %ecx
subl %r11d, %ecx
addl %r10d, %r9d
leaq 0x1d562(%rip), %rdi     # 0x21360
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
pushq %rax
pushq %rax
callq 0x49d5
addq $0x10, %rsp
movq 0x1d54b(%rip), %rax     # 0x21360
movl 0x18(%rax), %ecx
subl 0x10(%rax), %ecx
cmpl 0x1d37b(%rip), %ecx     # 0x2119c
jl 0x3efb
cvtsi2sdl 0xc(%rax), %xmm0
cvtsi2sd %ecx, %xmm1
mulsd 0x171f0(%rip), %xmm1    # 0x1b028
ucomisd %xmm0, %xmm1
movq 0x10(%rsp), %r9
jb 0x4279
movq 0xb0(%rsp), %rcx
movl %ecx, 0x1d4bf(%rip)     # 0x21314
movq 0xb8(%rsp), %rcx
movl %ecx, 0x1d4b5(%rip)     # 0x21318
movl 0x1d4ff(%rip), %ecx     # 0x21368
movl %ecx, 0x1d4a1(%rip)     # 0x21310
movupd (%rax), %xmm0
movupd 0x10(%rax), %xmm1
movupd %xmm1, 0x1d480(%rip)    # 0x21300
movupd %xmm0, 0x1d468(%rip)    # 0x212f0
movslq 0x8(%rax), %rsi
testq %rsi, %rsi
jle 0x3ece
movq (%rax), %rdi
movl 0x1d2fd(%rip), %r8d     # 0x21198
movl 0x10(%rax), %ecx
movl 0x18(%rax), %r9d
movl %ecx, %eax
cltd
idivl %r8d
movl %ecx, %eax
subl %edx, %eax
xorl %edx, %edx
addl %r8d, %eax
cmpl %r9d, %eax
cmovgel %r9d, %eax
movl %eax, %r10d
subl %ecx, %r10d
movw %r10w, (%rdi,%rdx,2)
addq $0x2, %rdx
movl %eax, %ecx
cmpq %rsi, %rdx
jb 0x3eae
movq 0x1d313(%rip), %rdi     # 0x211e8
leaq 0x1d414(%rip), %rsi     # 0x212f0
movl $0x2, %edx
callq 0xa547
incq 0x1d303(%rip)           # 0x211f0
movq 0x1d46c(%rip), %rax     # 0x21360
movl 0x18(%rax), %eax
movl %eax, 0x40(%rsp)
movq 0x10(%rsp), %r9
jmp 0x4279
movl 0x28(%rsp), %ebp
movq 0x50(%rsp), %r15
movl 0x2c(%rsp), %r12d
jmp 0x4279
movl 0x18(%rsp), %edx
cmpl 0x24(%rsp), %edx
jge 0x40c5
movslq %edx, %rdx
movl (%rsi,%rdx,4), %r11d
xorl %r10d, %r10d
cmpl %ebx, %r11d
jg 0x3f75
movslq 0x24(%rsp), %rdi
addq $0x3, %rdx
xorl %r10d, %r10d
movl %r10d, %ebx
movl -0x14(%rsi,%rdx,4), %r10d
subl %r12d, %r10d
movl %r11d, %r12d
addl -0x10(%rsi,%rdx,4), %r10d
addl %ebx, %r10d
cmpq %rdi, %rdx
jge 0x4306
movl (%rsi,%rdx,4), %r11d
addq $0x3, %rdx
addl $0x3, 0x18(%rsp)
movl %r14d, %ebx
cmpl %r14d, %r11d
jle 0x3f41
movl %r12d, 0x74(%rsp)
movl %r10d, 0x70(%rsp)
movl 0x18(%rsp), %edx
movl %edx, 0x68(%rsp)
movq 0x48(%rsp), %r11
movl 0xc(%rsp), %edi
jmp 0x4327
xorl %r10d, %r10d
jmp 0x42dd
movl %r12d, %r13d
movl 0x28(%rsp), %ebp
movq 0x50(%rsp), %r15
jmp 0x3ff3
leal -0xa(%r12), %ecx
cmpl %r13d, %ecx
jge 0x413f
cmpl $0x0, 0x1d338(%rip)     # 0x212f8
jle 0x3fd8
movq 0x1d327(%rip), %rcx     # 0x212f0
subl %r13d, %r12d
addw %r12w, (%rcx)
subl %eax, %r15d
addw %r15w, 0x2(%rcx)
movl %r13d, 0x1d321(%rip)    # 0x21300
movl %eax, 0x1d31f(%rip)     # 0x21304
movl 0x28(%rsp), %ebp
movq 0x50(%rsp), %r15
movq 0x10(%rsp), %r9
movl 0x2c(%rsp), %r12d
cmpl 0x58(%rsp), %ebx
jge 0x4078
cmpl 0x3c(%rsp), %r14d
jge 0x4078
movq 0x1d3a4(%rip), %rsi     # 0x213b0
movq 0x1d3a5(%rip), %rdx     # 0x213b8
movl %ebx, %ecx
subl %r14d, %ecx
leal (%r14,%rbx), %r8d
leaq 0x1d365(%rip), %rdi     # 0x21388
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
pushq $0x0
pushq $-0x1
callq 0x8192
addq $0x10, %rsp
movq 0x1d34b(%rip), %rsi     # 0x21388
movl 0x18(%rsi), %r8d
movl 0x1c(%rsi), %eax
cmpl 0x58(%rsp), %r8d
je 0x407d
cmpl 0x3c(%rsp), %eax
je 0x407d
xorps %xmm0, %xmm0
cvtsi2sdl 0xc(%rsi), %xmm0
movl %r8d, %ecx
subl %ebx, %ecx
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
mulsd 0x16fbb(%rip), %xmm1    # 0x1b028
ucomisd %xmm0, %xmm1
jae 0x407d
jmp 0x4203
jmp 0x4208
leal 0xa(%rbx), %ecx
cmpl %r8d, %ecx
jle 0x41af
movslq 0x1d268(%rip), %rcx     # 0x212f8
testq %rcx, %rcx
jle 0x40b0
movq 0x1d254(%rip), %rdx     # 0x212f0
movl %r8d, %esi
subl %ebx, %esi
addw %si, -0x4(%rdx,%rcx,2)
movl %eax, %esi
subl %r14d, %esi
addw %si, -0x2(%rdx,%rcx,2)
movl %r8d, 0x1d251(%rip)     # 0x21308
movl %eax, 0x1d24f(%rip)     # 0x2130c
movl %r8d, %ebx
jmp 0x4203
xorl %r10d, %r10d
jmp 0x4327
movslq 0x24(%rsp), %rsi
addq $-0x3, %rdx
xorl %r10d, %r10d
movl 0xc(%rsp), %edi
movq 0x88(%rsp), %rbp
addl 0x14(%rbp,%rdx,4), %r12d
movl %r10d, %ebx
movl %edi, %r10d
subl %r12d, %r10d
movl %r11d, %r12d
addl 0x10(%rbp,%rdx,4), %r10d
addl %ebx, %r10d
cmpq %rsi, %rdx
jle 0x42b8
movl %edi, %r11d
subl (%rbp,%rdx,4), %r11d
addq $-0x3, %rdx
addl $-0x3, 0x18(%rsp)
movl %r14d, %ebx
cmpl %r14d, %r11d
jle 0x40e5
movl %r12d, 0x74(%rsp)
movl %r10d, 0x70(%rsp)
movl 0x18(%rsp), %edx
movl %edx, 0x68(%rsp)
movq 0x48(%rsp), %r11
movq %rbp, %rsi
jmp 0x42d8
movslq 0x8(%rdi), %rcx
testq %rcx, %rcx
movl 0x28(%rsp), %ebp
movq 0x50(%rsp), %r15
movl 0x2c(%rsp), %r12d
jle 0x4194
movq (%rdi), %rsi
movl 0x1d038(%rip), %r8d     # 0x21198
movl %r13d, %eax
cltd
idivl %r8d
movl %r13d, %eax
subl %edx, %eax
movl 0x18(%rdi), %edx
xorl %r9d, %r9d
movl %r13d, %r10d
addl %r8d, %eax
cmpl %edx, %eax
cmovgel %edx, %eax
movl %eax, %r11d
subl %r10d, %r11d
movw %r11w, (%rsi,%r9,2)
addq $0x2, %r9
movl %eax, %r10d
cmpq %rcx, %r9
jb 0x4175
leaq 0x1d155(%rip), %rsi     # 0x212f0
movl $0x2, %edx
callq 0x43c8
movq 0x10(%rsp), %r9
jmp 0x3ff8
movslq 0x8(%rsi), %rdi
testq %rdi, %rdi
movl %r8d, %ebx
jle 0x41f2
movq (%rsi), %r8
movl 0x1cfd3(%rip), %r9d     # 0x21198
movl 0x10(%rsi), %ecx
movl %ecx, %eax
cltd
idivl %r9d
movl %ecx, %eax
subl %edx, %eax
xorl %edx, %edx
addl %r9d, %eax
cmpl %ebx, %eax
cmovgel %ebx, %eax
movl %eax, %r10d
subl %ecx, %r10d
movw %r10w, (%r8,%rdx,2)
addq $0x2, %rdx
movl %eax, %ecx
cmpq %rdi, %rdx
jb 0x41d4
leaq 0x1d0f7(%rip), %rdi     # 0x212f0
movl $0x1, %edx
callq 0x43c8
movq 0x10(%rsp), %r9
movl %ebx, 0x40(%rsp)
movl %ebx, %eax
subl %r13d, %eax
cmpl 0x1cf85(%rip), %eax     # 0x2119c
jl 0x426f
movl 0x1cf81(%rip), %eax     # 0x211a0
addl 0xb0(%rsp), %eax
movl %eax, 0x1d0e8(%rip)     # 0x21314
movl 0x1cf72(%rip), %eax     # 0x211a4
addl 0xb8(%rsp), %eax
movl %eax, 0x1d0d9(%rip)     # 0x21318
movl 0x1d123(%rip), %eax     # 0x21368
movl %eax, 0x1d0c5(%rip)     # 0x21310
movq 0x1cf96(%rip), %rdi     # 0x211e8
leaq 0x1d097(%rip), %rsi     # 0x212f0
movl $0x2, %edx
callq 0xa547
movq 0x10(%rsp), %r9
incq 0x1cf81(%rip)           # 0x211f0
movl $0x0, 0x1d15b(%rip)     # 0x213d4
testb $0x1, 0x1d0e8(%rip)     # 0x21368
je 0x4297
movq 0x1d0ef(%rip), %rdi     # 0x21378
movl 0x3c(%rsp), %esi
callq 0xaa81
movq 0x10(%rsp), %r9
movl 0xa0(%rsp), %r8d
movq 0x138(%rsp), %r10
incq %r10
cmpl %r10d, %r8d
jne 0x3427
jmp 0x4374
movl 0x18(%rsp), %edx
addl $-0x3, %edx
movl %r12d, 0x74(%rsp)
movl %r10d, 0x70(%rsp)
movl %edx, 0x68(%rsp)
movq 0x48(%rsp), %r11
movq %rbp, %rsi
movl %r14d, %ebx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %edx, 0x18(%rsp)
movslq %edx, %rdx
subl 0x8(%rsi,%rdx,4), %edi
cmpl %ebx, %edi
jl 0x42f5
cmpl %ebx, %r12d
movl 0xc(%rsp), %edi
jmp 0x433b
movl $0x0, 0x8(%rsp)
movl 0xc(%rsp), %edi
jmp 0x377d
movl 0x18(%rsp), %edx
addl $0x3, %edx
movl %r12d, 0x74(%rsp)
movl %r10d, 0x70(%rsp)
movl %edx, 0x68(%rsp)
movq 0x48(%rsp), %r11
movl 0xc(%rsp), %edi
movl %r14d, %ebx
movl %edx, 0x18(%rsp)
movslq %edx, %rdx
cmpl %ebx, -0x8(%rsi,%rdx,4)
jl 0x3775
cmpl %ebx, %r12d
movl $0x0, %edx
jg 0x4367
movl %ebx, %edx
subl %r12d, %edx
addl %r10d, %edx
js 0x3775
movl 0x8(%rsp), %ebp
movl %ebp, 0x1cfa6(%rip)     # 0x21300
movl %edx, 0x1cfa4(%rip)     # 0x21304
xorl %ebp, %ebp
jmp 0x377f
movl $0x0, 0x8(%rsp)
jmp 0x377f
movq 0xb8(%rsp), %rcx
incq %rcx
cmpq 0x160(%rsp), %rcx
jne 0x3327
movq 0x90(%rsp), %rax
cmpl %ebp, %eax
jl 0x324a
movq 0xb0(%rsp), %rax
incq %rax
cmpq 0x140(%rsp), %rax
jne 0x3141
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq