// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/diagonalbandalign_affinegapcost.c
// Function: evaluateaffineDBcrosspoints
static GtAffineAlignRnode evaluateaffineDBcrosspoints(
                                             GtLinspaceManagement *spacemanager,
                                             GtAffineDiagAlignentry *Diagcolumn,
                                             const GtScoreHandler *scorehandler,
                                             GtAffineAlignEdge edge,
                                             GtAffineAlignEdge from_edge,
                                             GtAffineAlignEdge to_edge,
                                             GtUword rowoffset,
                                             GtUword coloffset,
                                             const GtUchar *useq,
                                             GtUword ustart,
                                             GtUword ulen,
                                             const GtUchar *vseq,
                                             GtUword vstart,
                                             GtUword vlen,
                                             GtWord left_dist,
                                             GtWord right_dist)
{
  GtUword i,new_ulen, new_vlen, col_start, col_end,
          row_start = 0, row_end;
  GtWord new_left, new_right, diag;
  GtDiagAlignentry cpoint = {0,0,0}, prevcpoint;
  GtAffineDiagAlignentry temp_entry;
  GtAffineAlignRnode rpoint, temprpoint, lastrpoint;
  GtAffineAlignEdge prevcp_type,cp_type;

  diag = GT_DIV2(left_dist+right_dist);
  gt_assert(vstart == coloffset);

  if (ulen == 0)
  {
    switch (edge) {
      case(Affine_R):
      {
        Diagcolumn[0].val_R.currentrowindex = rowoffset;
        Diagcolumn[0].val_R.last_type = from_edge;
        prevcp_type = Affine_R;
        break;
      }
      case(Affine_I):
      {
        Diagcolumn[0].val_I.currentrowindex = rowoffset;
        Diagcolumn[0].val_I.last_type = from_edge;
        prevcp_type = Affine_I;
        break;
      }
      case(Affine_D):
      {
        Diagcolumn[0].val_D.currentrowindex = rowoffset;
        Diagcolumn[0].val_D.last_type = from_edge;
        prevcp_type = Affine_D;
        break;
      }
      default:
      {
        Diagcolumn[0].val_I.currentrowindex = rowoffset;
        Diagcolumn[0].val_I.last_type = from_edge;
        prevcp_type = Affine_I;
      }
    }

    for (i = 1; i <=vlen; i++)
    {
      Diagcolumn[i].val_I.currentrowindex = rowoffset;
      Diagcolumn[i].val_I.last_type = prevcp_type;
      prevcp_type = Affine_I;
    }
    return (GtAffineAlignRnode) {vlen, prevcp_type};

  }

  if (vlen == 0)
  {
    switch (edge) {
      case(Affine_R):
      {
        Diagcolumn[0].val_R.currentrowindex = rowoffset;
        Diagcolumn[0].val_R.last_type = from_edge;
        break;
      }
      case(Affine_I):
      {
        Diagcolumn[0].val_I.currentrowindex = rowoffset;
        Diagcolumn[0].val_I.last_type = from_edge;
        break;
      }
      case(Affine_D):
      {
        Diagcolumn[0].val_D.currentrowindex = rowoffset;
        Diagcolumn[0].val_D.last_type = from_edge;
        break;
      }
      default:
      {
        Diagcolumn[0].val_D.currentrowindex = rowoffset;
        Diagcolumn[0].val_D.last_type = from_edge;
      }
    }
    return (GtAffineAlignRnode) {0, edge};
  }

  if (gt_linspace_management_checksquare(spacemanager, ulen, vlen,
                                         sizeof (GtAffinealignDPentry),
                                         sizeof (GtAffineAlignRtabentry)))
  { /* call square function */
    return affineDtab_in_square_space(spacemanager, Diagcolumn,
                                      useq, ustart, ulen, vseq, vstart, vlen,
                                      left_dist, right_dist, rowoffset,
                                      from_edge, edge, to_edge,scorehandler);
  }

  rpoint = evaluateallaffineDBcolumns(spacemanager, Diagcolumn, scorehandler,
                                      edge, from_edge, to_edge, rowoffset,
                                      useq, ustart, ulen,  vseq, vstart, vlen,
                                      left_dist, right_dist);

  lastrpoint = rpoint;
  col_start = rpoint.idx;
  cp_type = rpoint.edge;

  /* if no crosspoint is found */
  if (col_start == GT_UWORD_MAX)
  {
    gt_assert(diag != 0);
    if (diag < 0)
    {
      return evaluateaffineDBcrosspoints(spacemanager, Diagcolumn, scorehandler,
                                         edge, from_edge, to_edge, rowoffset,
                                         coloffset, useq, ustart, ulen, vseq,
                                         vstart, vlen, diag+1, right_dist);
    } else
    {
      if (diag > 0)
      {
        return evaluateaffineDBcrosspoints(spacemanager, Diagcolumn,
                                           scorehandler,
                                           edge, from_edge, to_edge, rowoffset,
                                           coloffset, useq, ustart, ulen, vseq,
                                           vstart, vlen, left_dist, diag-1);
      }
    }
  }
  else
  {
    switch (cp_type) {
    case Affine_R:
      cpoint = Diagcolumn[col_start].val_R;
      cp_type = Affine_R;
      row_start = Diagcolumn[col_start].val_R.currentrowindex;
      break;
    case Affine_D:
      cpoint = Diagcolumn[col_start].val_D;
      cp_type = Affine_D;
      row_start = Diagcolumn[col_start].val_D.currentrowindex;
      break;
    default:
      gt_assert(cp_type == Affine_I);
      cpoint = Diagcolumn[col_start].val_I;
      cp_type = Affine_I;
      row_start = Diagcolumn[col_start].val_I.currentrowindex;
      break;
    }
  }

  /* exception, if last cpoint != (m+1)entry */
  if (col_start != vlen)
  {
    if (diag + ((GtWord)ulen-(GtWord)vlen) > 0)
    {
      new_ulen = ulen - (row_start+1-rowoffset);
      new_vlen = vlen-col_start;
      new_left = GT_MAX((GtWord)left_dist-diag+1,
                    -(GtWord)new_ulen);
      new_right = 0;
      temp_entry = Diagcolumn[col_start];
      lastrpoint = evaluateaffineDBcrosspoints(spacemanager,
                      Diagcolumn+col_start, scorehandler, Affine_D,
                      cpoint.last_type, to_edge,
                      row_start+1, coloffset+col_start, useq,
                      row_start+1, new_ulen, vseq,
                      vstart+col_start, new_vlen, new_left, new_right);
      Diagcolumn[col_start] = temp_entry;
      Diagcolumn[col_start+1].val_R.last_type = cp_type;
      Diagcolumn[col_start+1].val_D.last_type = cp_type;
      Diagcolumn[col_start+1].val_I.last_type = cp_type;

      lastrpoint.idx += col_start;
    }
    else
    {
      new_ulen = ulen - (row_start - rowoffset);
      new_vlen = vlen-col_start-1;
      new_left = -1;
      new_right = GT_MIN((GtWord)right_dist-((GtWord)diag)-1,new_vlen);

      lastrpoint = evaluateaffineDBcrosspoints(spacemanager,
                            Diagcolumn+col_start+1,scorehandler, Affine_I,
                            cp_type, to_edge, row_start, coloffset+col_start+1,
                            useq, row_start, new_ulen, vseq, vstart+col_start+1,
                            new_vlen, new_left, new_right);
      lastrpoint.idx += (col_start+1);
    }
  }
  /* look at all 'normally' crosspoints */
  while (cpoint.lastcpoint != GT_UWORD_MAX)
  {
    prevcpoint = cpoint;
    prevcp_type = cp_type;
    col_end = col_start;
    row_end = row_start;
    col_start = prevcpoint.lastcpoint;
    switch (prevcpoint.last_type) {
    case Affine_R:
      cpoint = Diagcolumn[col_start].val_R;
      cp_type = Affine_R;
      row_start = Diagcolumn[col_start].val_R.currentrowindex;
      break;
    case Affine_D:
      cpoint = Diagcolumn[col_start].val_D;
      cp_type = Affine_D;
      row_start = Diagcolumn[col_start].val_D.currentrowindex;
      break;
    default:
      gt_assert(prevcpoint.last_type == Affine_I);
      cpoint = Diagcolumn[col_start].val_I;
      cp_type = Affine_I;
      row_start = Diagcolumn[col_start].val_I.currentrowindex;
      break;
    }

    if (prevcp_type == Affine_R ||
       ((prevcp_type == Affine_I) && (col_end-col_start == 1)))
    {
      continue;/* next crosspoint is also on the diagonal*/
    }
    else if (prevcp_type == Affine_D)
    {
      new_ulen = row_end - row_start - 1;
      new_vlen = col_end-col_start-1;
      new_left = -1;
      new_right = GT_MIN(right_dist-diag-1,new_vlen);

      temprpoint = evaluateaffineDBcrosspoints(spacemanager,
                           Diagcolumn+col_start+1, scorehandler,
                           Affine_I, cp_type, Affine_D, row_start,
                           coloffset + col_start + 1, useq, row_start,
                           new_ulen, vseq, vstart + col_start + 1,
                           new_vlen, new_left, new_right);
      if (temprpoint.idx + col_start + 1 < vlen)
      {
        GtUword update_idx = temprpoint.idx+1+col_start+1;
        Diagcolumn[update_idx].val_R.last_type = temprpoint.edge;
        Diagcolumn[update_idx].val_D.last_type = temprpoint.edge;
        Diagcolumn[update_idx].val_I.last_type = temprpoint.edge;
      }
      if (temprpoint.idx + col_start + 1 == lastrpoint.idx)
      {
        lastrpoint = temprpoint;
        lastrpoint.idx += col_start + 1;
      }
    }
    else if (prevcp_type == Affine_I)
    {
      new_ulen = row_end - row_start-1;
      new_left = GT_MAX(left_dist-diag+1,
                        -(GtWord)new_ulen);
      new_right = 0;
      temp_entry = Diagcolumn[col_start];
      temprpoint = evaluateaffineDBcrosspoints(spacemanager,
                            Diagcolumn + col_start, scorehandler,
                            Affine_D, cpoint.last_type, Affine_I, row_start + 1,
                            coloffset + col_start,
                            useq, row_start+1, new_ulen,
                            vseq, vstart+col_start, col_end-col_start-1,
                            new_left, new_right);
      Diagcolumn[col_start] = temp_entry;
      Diagcolumn[col_start+1].val_R.last_type = cp_type;
      Diagcolumn[col_start+1].val_D.last_type = cp_type;
      Diagcolumn[col_start+1].val_I.last_type = cp_type;
      Diagcolumn[col_end].val_I.last_type = temprpoint.edge;
    }
    else
    {
      /* if (Diagcolumn[cpoint].last_type == Linear_X), never reach this line */
      gt_assert(false);
    }
  }
  col_end = col_start;
  row_end = row_start;
  /* exception, if first crosspoint != 0-entry */
   if (vstart-coloffset != col_end)
   {
     switch (cp_type) {
     case Affine_D:
      if (row_end == ustart-1)
         gt_assert(false);
       new_ulen = row_end-ustart-1;
       new_left =  GT_MAX(-new_ulen, diag);
       new_right = GT_MIN(right_dist, (GtWord)col_end);

       rpoint = evaluateaffineDBcrosspoints(spacemanager, Diagcolumn,
                                        scorehandler, edge, from_edge,Affine_D,
                                        rowoffset,coloffset, useq, ustart,
                                        new_ulen, vseq, vstart, col_end,
                                        new_left, new_right);
       if (col_start + 1 <= vlen)
       {
         Diagcolumn[col_start+1].val_R.last_type = rpoint.edge;
         Diagcolumn[col_start+1].val_D.last_type = rpoint.edge;
         Diagcolumn[col_start+1].val_I.last_type = rpoint.edge;
       }
       if (rpoint.idx == lastrpoint.idx)
         lastrpoint = rpoint;
       break;
     case Affine_I:
       new_ulen = row_end-ustart;
       new_vlen = col_end-1;
       new_left = GT_MAX(left_dist,
                 -(GtWord)new_ulen);

       new_right = GT_MIN(diag,new_vlen);
       rpoint = evaluateaffineDBcrosspoints(spacemanager, Diagcolumn,
                               scorehandler,edge, from_edge, Affine_I,rowoffset,
                               coloffset, useq, ustart, new_ulen, vseq, vstart,
                               new_vlen, new_left, new_right);

       Diagcolumn[col_start].val_I.last_type = rpoint.edge;
       break;
     default:
       gt_assert(false);
     }
   }
   else if (cp_type == Affine_D)
   {
     Diagcolumn[1].val_I.last_type = Affine_R;
     Diagcolumn[1].val_D.last_type = Affine_R;
     Diagcolumn[1].val_R.last_type = Affine_R;
     Diagcolumn[0].val_R.currentrowindex = rowoffset;
     Diagcolumn[0].val_R.last_type = from_edge;
   }
  return lastrpoint;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movl %r9d, 0x54(%rsp)
movq %r8, (%rsp)
movq %rdx, 0x28(%rsp)
movq 0x230(%rsp), %rax
cmpq 0x208(%rsp), %rax
jne 0xcda15
movl %ecx, %r10d
movq %rsi, %r13
movq 0x238(%rsp), %rbx
movq 0x220(%rsp), %rsi
movq 0x200(%rsp), %r12
testq %rsi, %rsi
je 0xcc225
testq %rbx, %rbx
je 0xcc283
movq %r10, 0xb0(%rsp)
pushq $0x30
popq %rcx
movq %rbx, %rdx
movq %rdi, %rbp
movq %rcx, %r8
movq %rsi, %r15
callq 0xf9879
testb %al, %al
movq %r15, 0xb8(%rsp)
je 0xcc2aa
testq %rbp, %rbp
je 0xcda43
testq %r13, %r13
je 0xcda43
movq 0x220(%rsp), %rax
leaq 0x1(%rax), %r15
leaq 0x1(%rbx), %rax
imulq %r15, %rax
movq %rbx, %r14
imulq $0x30, %rax, %rbx
movq %rbp, %rdi
callq 0xf999b
cmpq %rax, %rbx
ja 0xcdaa5
movq %rbp, %rdi
callq 0xf9981
movq %rax, %rbx
movq %rbp, %rdi
callq 0xf9975
movq %rax, (%rbx)
pushq $0x1
popq %rax
imulq $0x30, %r14, %r14
movq 0xb0(%rsp), %r10
cmpq %r15, %rax
jae 0xcc431
movq -0x8(%rbx,%rax,8), %rcx
addq %r14, %rcx
addq $0x30, %rcx
movq %rcx, (%rbx,%rax,8)
incq %rax
jmp 0xcc207
leaq 0x20(%r13), %rax
leaq 0x40(%r13), %rcx
leaq 0x28(%r13), %rdx
cmpl $0x1, %r10d
cmovneq %rcx, %rdx
leaq 0x38(%r13), %rcx
xorl %esi, %esi
cmpl $0x1, %r10d
cmoveq %rax, %rcx
setne %sil
incl %esi
movq %r12, (%rcx)
movq (%rsp), %rax
movl %eax, (%rdx)
addq $0x88, %r13
pushq $0x1
popq %rax
pushq $0x2
popq %rcx
movl %esi, %r10d
cmpq %rbx, %rax
ja 0xcd969
movq %r12, -0x8(%r13)
movl %r10d, (%r13)
incq %rax
addq $0x48, %r13
movl %ecx, %r10d
jmp 0xcc266
cmpl $0x1, %r10d
je 0xcc4ca
cmpl $0x2, %r10d
jne 0xcc4dc
movq %r12, 0x38(%r13)
movq (%rsp), %rax
movl %eax, 0x40(%r13)
pushq $0x2
jmp 0xcc4d8
movq %rbp, 0x58(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
subq %r15, %rbx
movq %rbx, %rdx
sarq $0x3f, %rdx
andq %rbx, %rdx
xorl %eax, %eax
testq %rbx, %rbx
cmovgq %rbx, %rax
cmpq 0x240(%rsp), %rdx
jl 0xcda74
cmpq 0x248(%rsp), %rax
jg 0xcda74
movq 0x58(%rsp), %rbx
movq %rbx, %rdi
callq 0xf9975
movq %rax, %r15
movq %rbx, %rdi
callq 0xf9981
movq %rax, %rbp
movq 0x240(%rsp), %rax
negq %rax
movq %rax, %r14
cmpq 0x220(%rsp), %rax
sete %al
movl %eax, 0x30(%rsp)
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x114a29
movq %rax, 0xe0(%rsp)
movq %rbx, %rdi
callq 0x114a6a
movq %rax, 0x48(%rsp)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, (%r15)
movq %rax, 0x8(%r15)
movq %r15, 0x8(%rsp)
movq %rax, 0x10(%r15)
movq %r13, %rdi
callq 0xcdc5e
orq $-0x1, 0x20(%r13)
pushq $0x3
popq %rcx
movl %ecx, 0x28(%r13)
orq $-0x1, 0x18(%r13)
orq $-0x1, 0x38(%r13)
movl %ecx, 0x40(%r13)
orq $-0x1, 0x30(%r13)
testq %rbp, %rbp
je 0xcdad6
orq $-0x1, (%rbp)
movl %ecx, 0x8(%rbp)
orq $-0x1, 0x10(%rbp)
movl %ecx, 0x18(%rbp)
orq $-0x1, 0x20(%rbp)
movq 0x248(%rsp), %rax
movq 0x240(%rsp), %rdx
addq %rdx, %rax
movq %rax, 0xc8(%rsp)
movl %ecx, 0x28(%rbp)
movq 0xb0(%rsp), %rax
cmpl $0x2, %eax
je 0xcc4ef
cmpl $0x1, %eax
movabsq $0x7fffffffffffffff, %rdi # imm = 0x7FFFFFFFFFFFFFFF
movq 0x8(%rsp), %r8
movq %r14, %r15
jne 0xcc535
andq $0x0, 0x8(%r8)
movq (%rsp), %rax
movl %eax, 0x18(%rbp)
cmpq $0x1, 0xc8(%rsp)
ja 0xcc58e
movq %r12, 0x20(%r13)
movq (%rsp), %rax
movl %eax, 0x28(%r13)
andq $0x0, 0x10(%rbp)
movl $0x1, 0x18(%rbp)
jmp 0xcc58e
movq %rbx, %rdi
movq 0x210(%rsp), %rsi
movq 0x218(%rsp), %rdx
movq 0x220(%rsp), %rbp
movq %rbp, %rcx
movq 0x228(%rsp), %r8
movq 0x230(%rsp), %r9
movq 0x28(%rsp), %r15
pushq %r15
pushq %r10
pushq 0x10(%rsp)
pushq 0x260(%rsp)
pushq 0x260(%rsp)
pushq 0x260(%rsp)
callq 0xcb098
addq $0x30, %rsp
movq %r15, %rdi
callq 0x114a29
addq (%rbx,%rbp,8), %r14
movq %r14, %rdi
movl 0x54(%rsp), %esi
movq %rax, %rdx
callq 0xf7884
movq 0x238(%rsp), %rsi
imulq $0x48, %rsi, %rcx
cmpl $0x1, %eax
je 0xcc526
cmpl $0x2, %eax
jne 0xcd11e
addq %r13, %rcx
addq $0x30, %rcx
pushq $0x2
jmp 0xcc52f
movq %r12, 0x20(%r13)
movq (%rsp), %rax
movl %eax, 0x28(%r13)
pushq $0x1
popq %r10
jmp 0xcc4e8
movq %r12, 0x20(%r13)
movq (%rsp), %rax
movl %eax, 0x28(%r13)
xorl %ebx, %ebx
jmp 0xcd969
movq 0x8(%rsp), %r8
andq $0x0, 0x10(%r8)
movq (%rsp), %rax
movl %eax, 0x28(%rbp)
cmpq $0x1, 0xc8(%rsp)
movabsq $0x7fffffffffffffff, %rdi # imm = 0x7FFFFFFFFFFFFFFF
movq %r14, %r15
ja 0xcc58e
movq %r12, 0x38(%r13)
movq (%rsp), %rax
movl %eax, 0x40(%r13)
jmp 0xcc582
addq %r13, %rcx
addq $0x18, %rcx
pushq $0x1
popq %rdi
jmp 0xcd123
andq $0x0, (%r8)
movq 0xe0(%rsp), %rax
movq %rax, 0x8(%r8)
movq %rax, 0x10(%r8)
movq (%rsp), %rax
movl %eax, 0x28(%rbp)
movl %eax, 0x8(%rbp)
movl %eax, 0x18(%rbp)
cmpq $0x1, 0xc8(%rsp)
ja 0xcc58e
movq %r12, 0x8(%r13)
movq %r12, 0x20(%r13)
movq %r12, 0x38(%r13)
andq $0x0, (%rbp)
andl $0x0, 0x8(%rbp)
andq $0x0, 0x10(%rbp)
movl $0x1, 0x18(%rbp)
andq $0x0, 0x20(%rbp)
movl $0x2, 0x28(%rbp)
movq 0xc8(%rsp), %rax
sarq %rax
movq %rax, 0x38(%rsp)
pushq $0x1
popq %rbx
leaq 0x20(%rbp), %rax
movq %rax, 0x140(%rsp)
pushq $0x40
popq %r14
cmpq %r15, %rbx
ja 0xcc665
movq %rdi, -0x10(%r8,%r14)
movq -0x38(%r8,%r14), %rax
movq 0x48(%rsp), %rcx
addq %rax, %rcx
cmpq %rdi, %rax
cmoveq %rdi, %rcx
movq %rcx, -0x8(%r8,%r14)
movq %rdi, (%r8,%r14)
movq 0x38(%rsp), %rax
addq %rbx, %rax
je 0xcc60c
movups -0x40(%rbp,%r14), %xmm0
movups -0x30(%rbp,%r14), %xmm1
movups -0x20(%rbp,%r14), %xmm2
movups %xmm2, 0x10(%rbp,%r14)
movups %xmm1, (%rbp,%r14)
movups %xmm0, -0x10(%rbp,%r14)
jmp 0xcc659
movq (%rsp), %rax
movl %eax, 0x28(%r13)
orq $-0x1, 0x18(%r13)
leaq (%r12,%rbx), %rax
movq %rax, 0x20(%r13)
andq $0x0, (%rbp,%r14)
movl $0x1, 0x8(%rbp,%r14)
movq %r13, %rdi
callq 0xcdc5e
movq 0x8(%rsp), %r8
movabsq $0x7fffffffffffffff, %rdi # imm = 0x7FFFFFFFFFFFFFFF
orq $-0x1, 0x38(%r13)
movl $0x3, 0x40(%r13)
orq $-0x1, 0x30(%r13)
incq %rbx
addq $0x30, %r14
jmp 0xcc5b1
movq 0x210(%rsp), %rax
movq 0x218(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x118(%rsp)
movq 0x230(%rsp), %rax
movq 0x228(%rsp), %rcx
leaq -0x1(%rcx,%rax), %rax
movq %rax, 0x130(%rsp)
leaq 0x30(%rbp), %rax
movq %rax, 0x110(%rsp)
movq 0xe0(%rsp), %rax
movq 0x48(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0xd8(%rsp)
movq %r8, %rax
addq $0x40, %rax
movq %rax, 0x158(%rsp)
leaq 0x1(%r12), %rax
movq %rax, 0x150(%rsp)
pushq $0x1
popq %r11
movq %r11, %rcx
movq 0x220(%rsp), %rax
subq %rax, %rcx
movq %rcx, 0x148(%rsp)
movq $0x0, 0x98(%rsp)
movq 0x38(%rsp), %rcx
movq %rcx, 0x120(%rsp)
movq %rdi, 0x18(%rsp)
movq %rdi, 0xa8(%rsp)
movq %rdi, 0xa0(%rsp)
movq %r13, 0x40(%rsp)
movl 0x30(%rsp), %ecx
movq %rbp, 0x20(%rsp)
movq 0x238(%rsp), %r10
cmpq %r10, %r11
movl 0x54(%rsp), %r9d
ja 0xcd072
movq (%r8), %rdx
movq %rdx, 0x100(%rsp)
movq 0x8(%r8), %rdx
movq %rdx, 0x108(%rsp)
movq 0x10(%r8), %rdx
movq %rdx, 0xd0(%rsp)
movups (%rbp), %xmm0
movups 0x10(%rbp), %xmm1
movups 0x20(%rbp), %xmm2
movaps %xmm2, 0x1a0(%rsp)
movaps %xmm1, 0x190(%rsp)
movaps %xmm0, 0x180(%rsp)
cmpq 0x248(%rsp), %r11
jbe 0xcc7f2
movq 0x98(%rsp), %r10
cmpq %r10, %r15
movq 0xa8(%rsp), %r9
movq 0xa0(%rsp), %rbx
je 0xcc7ed
movq 0x30(%r8), %rbx
movq 0x38(%r8), %r9
movq 0x40(%r8), %rdx
movq %rdx, 0x18(%rsp)
movq 0x110(%rsp), %rdx
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups 0x20(%rdx), %xmm2
movaps %xmm2, 0x80(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
incq %r10
jmp 0xcc828
movq (%r8), %rbx
movq 0x8(%r8), %r9
movq 0x10(%r8), %rdx
movq %rdx, 0x18(%rsp)
movups (%rbp), %xmm0
movups 0x10(%rbp), %xmm1
movups 0x20(%rbp), %xmm2
movaps %xmm2, 0x80(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movq 0x98(%rsp), %r10
xorl %edx, %edx
cmpq %rax, %r15
setb %dl
movq %rdx, 0xc0(%rsp)
leaq (%r15,%rdx), %rsi
testb $0x1, %cl
jne 0xcc88d
cmpq %rsi, %r10
jne 0xcc88d
orq $-0x1, 0x60(%rsp)
pushq $0x3
popq %rax
movl %eax, 0x68(%rsp)
orq $-0x1, 0x70(%rsp)
movl %eax, 0x78(%rsp)
orq $-0x1, 0x80(%rsp)
movl %eax, 0x88(%rsp)
movq %rdi, %r13
movq %rdi, %rax
movq %rdi, 0x18(%rsp)
movq %rdi, 0xa8(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rdi, %rbp
jmp 0xcc8e4
movq 0xd8(%rsp), %rdx
leaq (%rbx,%rdx), %rax
movq %rbx, 0xa0(%rsp)
cmpq %rdi, %rbx
movq %rax, %rbx
cmoveq %rdi, %rax
leaq (%r9,%rdx), %rbp
movq %r9, 0xa8(%rsp)
cmpq %rdi, %r9
cmoveq %rdi, %rbp
movq 0x48(%rsp), %rdx
movq 0x18(%rsp), %r9
leaq (%r9,%rdx), %r13
cmpq %rdi, %r9
cmoveq %rdi, %r13
cmpq %rbp, %rax
jge 0xcc8e4
cmpq %r13, %rax
cmovgeq %r13, %rax
movq %rax, %r14
jmp 0xcc8f1
cmpq %r13, %rbp
movq %r13, %r14
cmovlq %rbp, %r14
movq %rax, %rbx
movq %r14, 0x10(%r8)
movq %rdi, (%r8)
movq %rdi, 0x8(%r8)
movq %r11, %r12
subq %r10, %r12
cmpq %r12, 0x38(%rsp)
movq %r11, 0xf8(%rsp)
movq %r10, 0x98(%rsp)
movq %rsi, 0x138(%rsp)
movl %ecx, 0x30(%rsp)
movq %r15, 0x10(%rsp)
jne 0xcc9fe
movq %rbp, 0xe8(%rsp)
movq %rbx, 0xf0(%rsp)
imulq $0x48, %r11, %rbx
movq 0x40(%rsp), %r15
leaq (%r15,%rbx), %rbp
movq %rbp, %rdi
callq 0xcdc5e
orq $-0x1, 0x20(%r15,%rbx)
movl $0x3, 0x28(%r15,%rbx)
orq $-0x1, 0x18(%r15,%rbx)
leaq 0x68(%rsp), %rax
leaq 0x60(%rsp), %rcx
cmpq 0xf0(%rsp), %r14
je 0xcc9a5
leaq 0x88(%rsp), %rax
leaq 0x80(%rsp), %rcx
cmpq %r13, %r14
je 0xcc9a5
leaq 0x78(%rsp), %rax
leaq 0x70(%rsp), %rcx
cmpq 0xe8(%rsp), %r14
jne 0xcc9b1
movl (%rax), %eax
movl %eax, 0x40(%rbp)
movq (%rcx), %rax
movq %rax, 0x30(%rbp)
movq 0x200(%rsp), %rax
movq 0x98(%rsp), %r10
addq %r10, %rax
movq %rax, 0x38(%rbp)
movq 0x20(%rsp), %rbp
orq $-0x1, (%rbp)
pushq $0x3
popq %rax
movl %eax, 0x8(%rbp)
orq $-0x1, 0x10(%rbp)
movl %eax, 0x18(%rbp)
movq 0xf8(%rsp), %r11
movq %r11, 0x20(%rbp)
movl $0x2, 0x28(%rbp)
movl 0x30(%rsp), %ecx
movq 0x10(%rsp), %r15
jmp 0xcca45
leaq 0x60(%rsp), %rax
cmpq %rbx, %r14
pushq $0x3
popq %rdx
je 0xcca22
leaq 0x80(%rsp), %rax
cmpq %r13, %r14
je 0xcca22
leaq 0x70(%rsp), %rax
cmpq %rbp, %r14
jne 0xcca30
movups (%rax), %xmm0
movq 0x140(%rsp), %rax
movups %xmm0, (%rax)
movq 0x20(%rsp), %rbp
orq $-0x1, 0x10(%rbp)
movl %edx, 0x18(%rbp)
orq $-0x1, (%rbp)
movl %edx, 0x8(%rbp)
testq %r10, %r10
movq 0x40(%rsp), %r14
je 0xccb61
movq 0x118(%rsp), %rax
movzbl -0x1(%rax,%r10), %esi
movq 0x130(%rsp), %rax
movzbl (%rax,%r11), %edx
movq 0x28(%rsp), %rdi
movq %r11, %r13
movq %r10, %r15
callq 0x114b2c
movq 0x100(%rsp), %rsi
leaq (%rax,%rsi), %rcx
movabsq $0x7fffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rdx, %rsi
cmoveq %rdx, %rcx
movq 0x108(%rsp), %rsi
leaq (%rax,%rsi), %r9
cmpq %rdx, %rsi
cmoveq %rdx, %r9
movq 0xd0(%rsp), %rsi
addq %rsi, %rax
cmpq %rdx, %rsi
cmoveq %rdx, %rax
cmpq %r9, %rcx
movq %r9, %rsi
cmovlq %rcx, %rsi
cmpq %rax, %rsi
movq %rax, %rdx
cmovlq %rsi, %rdx
movq 0x8(%rsp), %rdi
movq %rdx, (%rdi)
cmpq %r12, 0x38(%rsp)
jne 0xccb24
imulq $0x48, %r13, %rbx
leaq (%r14,%rbx), %rdi
leaq 0x180(%rsp), %rsi
movq %rax, %r8
callq 0xcdcad
movq 0x200(%rsp), %rax
addq %r15, %rax
movq %rax, 0x8(%r14,%rbx)
movq %r13, (%rbp)
andl $0x0, 0x8(%rbp)
movl 0x30(%rsp), %ecx
movq %r13, %r11
movq %r15, %r10
movq 0x10(%rsp), %r15
jmp 0xccb61
leaq 0x180(%rsp), %rdi
cmpq %rcx, %rdx
movl 0x30(%rsp), %ecx
movq %r13, %r11
movq %r15, %r10
movq 0x10(%rsp), %r15
je 0xccb5a
leaq 0x1a0(%rsp), %rdi
cmpq %rsi, %rax
jle 0xccb5a
leaq 0x190(%rsp), %rdi
cmpq %r9, %rdx
jne 0xccb61
movups (%rdi), %xmm0
movups %xmm0, (%rbp)
imulq $0x48, %r11, %rax
leaq (%r14,%rax), %rdx
addq $0x30, %rdx
movq %rdx, 0x128(%rsp)
leaq (%r14,%rax), %rdx
movq %rdx, 0x178(%rsp)
addq %r14, %rax
addq $0x18, %rax
movq %rax, 0x170(%rsp)
imulq $0x30, %r10, %rdx
movq 0x110(%rsp), %rax
addq %rdx, %rax
movq %rax, 0x160(%rsp)
addq 0x158(%rsp), %rdx
movq %rdx, 0x168(%rsp)
movq 0x120(%rsp), %rax
addq %r10, %rax
movq %rax, 0xf0(%rsp)
movq 0x148(%rsp), %rax
addq %r10, %rax
movq %rax, 0xe8(%rsp)
addq 0xc0(%rsp), %r15
negq %r15
addq %r10, %r15
incq %r15
xorl %r13d, %r13d
movq 0x150(%rsp), %r12
xorl %ebx, %ebx
movq 0x118(%rsp), %r9
movabsq $0x7fffffffffffffff, %rdi # imm = 0x7FFFFFFFFFFFFFFF
movq 0x8(%rsp), %r8
movq 0x138(%rsp), %rdx
leaq (%r10,%r13), %rax
incq %rax
cmpq %rdx, %rax
ja 0xcd04a
movaps 0x60(%rsp), %xmm0
movaps 0x70(%rsp), %xmm1
movaps 0x80(%rsp), %xmm2
movaps %xmm2, 0x1a0(%rsp)
movaps %xmm1, 0x190(%rsp)
movaps %xmm0, 0x180(%rsp)
testb $0x1, %cl
jne 0xccc93
movq %r15, %rax
addq %r13, %rax
jne 0xccc93
orq $-0x1, 0x60(%rsp)
pushq $0x3
popq %rax
movl %eax, 0x68(%rsp)
orq $-0x1, 0x70(%rsp)
movl %eax, 0x78(%rsp)
orq $-0x1, 0x80(%rsp)
movl %eax, 0x88(%rsp)
movq %rdi, %rbp
movq %rdi, %r14
movq %rdi, %rdx
jmp 0xcccfc
testq %r10, %r10
je 0xcccbe
movq 0x60(%r8,%rbx), %rdx
movq 0x68(%r8,%rbx), %r14
movq 0x70(%r8,%rbx), %rax
movups 0x60(%rbp,%rbx), %xmm0
movups 0x70(%rbp,%rbx), %xmm1
movups 0x80(%rbp,%rbx), %xmm2
movq %rax, %rbp
jmp 0xcccea
movq 0x168(%rsp), %rax
movq -0x10(%rax,%rbx), %rdx
movq -0x8(%rax,%rbx), %r14
movq (%rax,%rbx), %rbp
movq 0x160(%rsp), %rax
movups (%rax,%rbx), %xmm0
movups 0x10(%rax,%rbx), %xmm1
movups 0x20(%rax,%rbx), %xmm2
movaps %xmm2, 0x80(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movq 0xe8(%rsp), %rax
addq %r13, %rax
movzbl %cl, %ecx
pushq $0x1
popq %rax
cmovel %eax, %ecx
movl %ecx, 0x30(%rsp)
movq 0xd8(%rsp), %rax
leaq (%rdx,%rax), %rsi
movq %rdx, 0xd0(%rsp)
cmpq %rdi, %rdx
cmoveq %rdi, %rsi
addq %r14, %rax
movq %r14, 0x108(%rsp)
cmpq %rdi, %r14
cmoveq %rdi, %rax
movq 0x48(%rsp), %rcx
leaq (%rcx,%rbp), %rdx
movq %rbp, 0x100(%rsp)
cmpq %rdi, %rbp
cmoveq %rdi, %rdx
cmpq %rax, %rsi
movq %rax, %rdi
cmovlq %rsi, %rdi
cmpq %rdx, %rdi
movq %rdx, %rcx
cmovlq %rdi, %rcx
movq %rcx, 0x40(%r8,%rbx)
movq 0xf0(%rsp), %rbp
addq %r13, %rbp
movq %r12, 0x10(%rsp)
je 0xccdbe
leaq 0x60(%rsp), %r8
cmpq %rsi, %rcx
je 0xccda9
leaq 0x80(%rsp), %r8
cmpq %rdi, %rdx
jle 0xccda9
leaq 0x70(%rsp), %r8
cmpq %rax, %rcx
jne 0xcce2d
movq 0x20(%rsp), %rax
addq %rbx, %rax
addq $0x50, %rax
movups (%r8), %xmm0
movups %xmm0, (%rax)
jmp 0xcce2d
movq %r9, %r14
leaq 0x68(%rsp), %r8
leaq 0x60(%rsp), %r9
cmpq %rsi, %rcx
je 0xccdf4
leaq 0x88(%rsp), %r8
leaq 0x80(%rsp), %r9
cmpq %rdi, %rdx
jle 0xccdf4
leaq 0x78(%rsp), %r8
leaq 0x70(%rsp), %r9
cmpq %rax, %rcx
jne 0xcce08
movl (%r8), %eax
movq 0x128(%rsp), %rcx
movl %eax, 0x10(%rcx)
movq (%r9), %rax
movq %rax, (%rcx)
leaq (%r10,%r12), %rax
movq 0x128(%rsp), %rcx
movq %rax, 0x8(%rcx)
movq 0x20(%rsp), %rax
movq %r11, 0x50(%rax,%rbx)
movl $0x2, 0x58(%rax,%rbx)
movq %r14, %r9
movq %r9, 0xc0(%rsp)
movzbl (%r9,%r10), %esi
movq 0x130(%rsp), %rax
movzbl (%rax,%r11), %edx
movq 0x28(%rsp), %rdi
movq %r11, %r12
movq %r10, %r14
callq 0x114b2c
movq 0xa0(%rsp), %rsi
leaq (%rax,%rsi), %rcx
movabsq $0x7fffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rdx, %rsi
cmoveq %rdx, %rcx
movq 0xa8(%rsp), %rsi
leaq (%rax,%rsi), %r9
cmpq %rdx, %rsi
cmoveq %rdx, %r9
movq 0x18(%rsp), %rsi
addq %rsi, %rax
cmpq %rdx, %rsi
cmoveq %rdx, %rax
cmpq %r9, %rcx
movq %r9, %rdx
cmovlq %rcx, %rdx
cmpq %rax, %rdx
cmovgeq %rax, %rdx
movq 0x8(%rsp), %rsi
movq %rdx, 0x30(%rsi,%rbx)
testq %rbp, %rbp
je 0xcced5
movq 0x20(%rsp), %rsi
leaq (%rsi,%rbx), %rdi
addq $0x30, %rdi
leaq 0x180(%rsp), %rsi
movq %rax, %r8
callq 0xcdd23
jmp 0xccf1b
movq %r13, 0x18(%rsp)
movq %r15, %r13
movq 0x178(%rsp), %r15
movq %r15, %rdi
leaq 0x180(%rsp), %rsi
movq %rax, %r8
callq 0xcdcad
movq 0x10(%rsp), %rax
addq %r14, %rax
movq %rax, 0x8(%r15)
movq %r13, %r15
movq 0x18(%rsp), %r13
movq 0x20(%rsp), %rax
movq %r12, 0x30(%rax,%rbx)
andl $0x0, 0x38(%rax,%rbx)
movq 0x8(%rsp), %rdi
movq (%rdi,%rbx), %rax
movq 0x8(%rdi,%rbx), %rdx
movq 0xd8(%rsp), %r8
leaq (%rax,%r8), %rcx
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rsi, %rax
cmoveq %rsi, %rcx
movq 0x48(%rsp), %rax
leaq (%rdx,%rax), %r9
cmpq %rsi, %rdx
cmoveq %rsi, %r9
movq 0x10(%rdi,%rbx), %rax
addq %rax, %r8
cmpq %rsi, %rax
cmoveq %rsi, %r8
cmpq %r9, %rcx
movq %r9, %rdx
cmovlq %rcx, %rdx
cmpq %r8, %rdx
cmovgeq %r8, %rdx
movq %rdx, 0x38(%rdi,%rbx)
testq %rbp, %rbp
je 0xccfad
movq 0x20(%rsp), %rbp
leaq (%rbx,%rbp), %rsi
leaq (%rbx,%rbp), %rdi
addq $0x40, %rdi
callq 0xcdd23
movq 0xf8(%rsp), %r11
movq 0x98(%rsp), %r10
movq 0x10(%rsp), %r12
jmp 0xccff0
movq 0x20(%rsp), %rbp
leaq (%rbx,%rbp), %rsi
movq 0x170(%rsp), %r14
movq %r14, %rdi
callq 0xcdcad
movq 0x98(%rsp), %r10
movq 0x10(%rsp), %r12
leaq (%r10,%r12), %rax
movq %rax, 0x8(%r14)
movq 0xf8(%rsp), %r11
movq %r11, 0x40(%rbp,%rbx)
movl $0x1, 0x48(%rbp,%rbx)
movq 0xc0(%rsp), %r9
incq %r9
addq $0x30, %rbx
incq %r12
incq %r13
movq 0x100(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x108(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0xa0(%rsp)
movabsq $0x7fffffffffffffff, %rdi # imm = 0x7FFFFFFFFFFFFFFF
movq 0x8(%rsp), %r8
movl 0x30(%rsp), %ecx
jmp 0xccc12
incq %r11
decq 0x120(%rsp)
movq %rdx, %r15
movq 0x200(%rsp), %r12
movq 0x40(%rsp), %r13
movq 0x220(%rsp), %rax
jmp 0xcc733
subq 0x98(%rsp), %r15
imulq $0x30, %r15, %rax
movq (%r8,%rax), %rsi
movq 0x8(%r8,%rax), %rcx
movq 0x10(%r8,%rax), %rdx
cmpl $0x1, %r9d
je 0xcd0ba
cmpl $0x2, %r9d
jne 0xcd0da
cmpq %rdi, %rsi
movq 0xe0(%rsp), %r8
leaq (%rsi,%r8), %rsi
cmoveq %rdi, %rsi
addq %rcx, %r8
cmpq %rdi, %rcx
cmoveq %rdi, %r8
movq %r8, %rcx
jmp 0xcd0da
cmpq %rdi, %rsi
movq 0xe0(%rsp), %r8
leaq (%rsi,%r8), %rsi
cmoveq %rdi, %rsi
addq %rdx, %r8
cmpq %rdi, %rdx
cmoveq %rdi, %r8
movq %r8, %rdx
cmpq %rcx, %rsi
movq %rcx, %r8
cmovlq %rsi, %r8
cmpq %rdx, %r8
movq %rdx, %rdi
cmovlq %r8, %rdi
cmpq %rsi, %rdi
jne 0xcd0fb
addq %rax, %rbp
jmp 0xcd255
cmpq %r8, %rdx
jle 0xcd24e
cmpq %rcx, %rdi
movq 0x58(%rsp), %r8
jne 0xcd289
addq %rax, %rbp
addq $0x10, %rbp
jmp 0xcd25a
addq %r13, %rcx
xorl %edi, %edi
movabsq $0x7fffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFFF
movl %edi, %r10d
imulq $0x30, %rsi, %rdi
movq 0xb8(%rsp), %r8
movq %r8, 0xb8(%rsp)
orq %rsi, %r8
je 0xcd213
cmpq 0x238(%rsp), %rsi
cmovel %eax, %r10d
cmpl $0x1, %eax
jne 0xcd17c
movq 0xb8(%rsp), %r8
testq %r8, %r8
je 0xcd981
movq (%rbx,%r8,8), %rax
movl 0x24(%rax,%rdi), %eax
decq %r8
jmp 0xcd13c
cmpl $0x2, %eax
je 0xcd1d6
testl %eax, %eax
jne 0xcd9af
movq 0xb8(%rsp), %r11
movq (%rbx,%r11,8), %rax
cmpq %rdx, (%rax,%rdi)
je 0xcdb07
leaq (%r12,%r11), %r9
imulq $0x48, %rsi, %r8
movq %r9, 0x8(%r13,%r8)
movl 0x20(%rax,%rdi), %eax
andl $0x0, 0x10(%rcx)
testq %r11, %r11
je 0xcdb38
testq %rsi, %rsi
je 0xcdb38
addq %r13, %r8
decq 0xb8(%rsp)
movq %r8, %rcx
jmp 0xcd20b
movq 0xb8(%rsp), %r9
leaq (%r12,%r9), %rax
imulq $0x48, %rsi, %r8
movq %rax, 0x38(%r13,%r8)
movq (%rbx,%r9,8), %rax
movl 0x28(%rax,%rdi), %eax
movl $0x2, 0x10(%rcx)
testq %rsi, %rsi
je 0xcdb69
leaq (%r8,%r13), %rcx
addq $0x30, %rcx
decq %rsi
jmp 0xcd130
movl %eax, 0x10(%rcx)
orq $-0x1, (%r13)
movq %r12, 0x8(%r13)
movq (%rsp), %rax
movl %eax, 0x10(%r13)
orq $-0x1, 0x18(%r13)
movq %r12, 0x20(%r13)
movl %eax, 0x28(%r13)
orq $-0x1, 0x30(%r13)
movq %r12, 0x38(%r13)
movl %eax, 0x40(%r13)
movq 0x238(%rsp), %rbx
jmp 0xcd969
addq %rax, %rbp
addq $0x20, %rbp
movq 0x58(%rsp), %r8
movq %rbp, %rax
movq (%rbp), %rbp
cmpq $-0x1, %rbp
je 0xcd289
movl 0x8(%rax), %r12d
cmpl $0x2, %r12d
je 0xcd2da
cmpl $0x1, %r12d
je 0xcd2cd
testl %r12d, %r12d
jne 0xcdbcb
imulq $0x48, %rbp, %rax
addq %r13, %rax
jmp 0xcd2e5
cmpq $0x1, 0xc8(%rsp)
jbe 0xcdb9a
movq 0x38(%rsp), %rax
testq %rax, %rax
js 0xcd431
decq %rax
movq %r8, %rdi
movq %r13, %rsi
movq 0x28(%rsp), %rdx
movq 0xb0(%rsp), %rcx
movq (%rsp), %r8
pushq %rax
pushq 0x248(%rsp)
jmp 0xcd453
imulq $0x48, %rbp, %rax
addq %r13, %rax
addq $0x18, %rax
jmp 0xcd2e5
imulq $0x48, %rbp, %rax
addq %r13, %rax
addq $0x30, %rax
movq (%rax), %r15
movq 0x8(%rax), %rbx
movl 0x10(%rax), %r13d
movq 0x238(%rsp), %rcx
movq %rcx, %rax
movq 0x38(%rsp), %r9
movq %r9, %rsi
notq %rsi
movl %r12d, %edx
subq %rbp, %rax
je 0xcd529
movq 0x220(%rsp), %r14
movq %r14, %rcx
movq 0x238(%rsp), %rdx
subq %rdx, %rcx
addq %r9, %rcx
movq %rsi, 0x20(%rsp)
jle 0xcd491
leaq 0x1(%rbx), %rcx
movq %rcx, 0x10(%rsp)
movq 0x200(%rsp), %r11
subq %rcx, %r11
addq %r14, %r11
movq 0x240(%rsp), %rcx
subq %r9, %rcx
movq %r11, %rdx
negq %rdx
leaq 0x1(%rcx), %r10
cmpq %rdx, %rcx
cmovlq %rdx, %r10
imulq $0x48, %rbp, %rcx
movq %rcx, 0x8(%rsp)
movq 0x40(%rsp), %r14
leaq (%r14,%rcx), %rdx
movq %rdx, 0x30(%rsp)
pushq $0x9
popq %rcx
leaq 0x180(%rsp), %rdi
movq %rdx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x230(%rsp), %rcx
leaq (%rbp,%rcx), %rcx
movq %rcx, 0x18(%rsp)
pushq $0x1
popq %rcx
movq %r8, %rdi
movq %rdx, %rsi
movq 0x28(%rsp), %rdx
movl %r13d, %r8d
movl 0x54(%rsp), %r9d
pushq $0x0
pushq %r10
pushq %rax
movq 0x30(%rsp), %r10
pushq %r10
pushq 0x248(%rsp)
pushq %r11
movq 0x40(%rsp), %rax
pushq %rax
pushq 0x248(%rsp)
pushq %r10
pushq %rax
callq 0xcc113
movq 0x88(%rsp), %r9
movq 0xa8(%rsp), %r8
addq $0x50, %rsp
pushq $0x9
popq %rcx
movq 0x30(%rsp), %rdi
leaq 0x180(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x20(%rsp), %rsi
movq %rax, %rcx
movq 0x8(%rsp), %rax
movl %r12d, 0x58(%r14,%rax)
movl %r12d, 0x70(%r14,%rax)
movl %r12d, 0x88(%r14,%rax)
addq %rbp, %rcx
jmp 0xcd529
incq %rax
movq %r8, %rdi
movq %r13, %rsi
movq 0x28(%rsp), %rdx
movq 0xb0(%rsp), %rcx
movq (%rsp), %r8
pushq 0x248(%rsp)
pushq %rax
pushq %r10
movq 0x248(%rsp), %rax
pushq %rax
pushq 0x248(%rsp)
pushq 0x248(%rsp)
pushq 0x248(%rsp)
pushq 0x248(%rsp)
pushq %rax
pushq %r12
callq 0xcc113
addq $0x50, %rsp
movq %rax, %rbx
movl %edx, %r10d
jmp 0xcd969
addq 0x200(%rsp), %r14
subq %rbx, %r14
movq %rbp, %rax
notq %rax
addq %rdx, %rax
movq 0x248(%rsp), %rcx
leaq (%rsi,%rcx), %r10
cmpq %rax, %r10
cmovaeq %rax, %r10
imulq $0x48, %rbp, %rcx
movq 0x40(%rsp), %rdx
leaq (%rdx,%rcx), %rsi
addq $0x48, %rsi
movq 0x230(%rsp), %rcx
leaq 0x1(%rcx,%rbp), %r11
pushq $0x2
popq %rcx
movq %r8, %rdi
movq 0x28(%rsp), %rdx
movl %r12d, %r8d
movl 0x54(%rsp), %r9d
pushq %r10
pushq $-0x1
pushq %rax
pushq %r11
pushq 0x248(%rsp)
pushq %r14
pushq %rbx
pushq 0x248(%rsp)
pushq %r11
pushq %rbx
callq 0xcc113
movq 0x88(%rsp), %r9
movq 0x70(%rsp), %rsi
movq 0xa8(%rsp), %r8
addq $0x50, %rsp
leaq (%rax,%rbp), %rcx
incq %rcx
movl %edx, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rax
movq %rax, 0xc0(%rsp)
movq 0x240(%rsp), %rdi
subq %r9, %rdi
leaq 0x1(%rdi), %r9
addq 0x248(%rsp), %rsi
movq %rsi, 0x20(%rsp)
movq 0x230(%rsp), %rax
incq %rax
movq %rax, 0xd0(%rsp)
movl %r12d, %edx
movq %rbp, %r14
movq %rbx, %rax
movl %edx, %ecx
cmpq $-0x1, %r15
je 0xcd7c5
movq %r15, %rbp
movl %r13d, %r12d
cmpl $0x2, %r13d
movq 0x40(%rsp), %rsi
je 0xcd5bd
cmpl $0x1, %r12d
je 0xcd5b0
testl %r12d, %r12d
jne 0xcd9e7
imulq $0x48, %rbp, %rdx
addq %rsi, %rdx
jmp 0xcd5c8
imulq $0x48, %rbp, %rdx
addq %rsi, %rdx
addq $0x18, %rdx
jmp 0xcd5c8
imulq $0x48, %rbp, %rdx
addq %rsi, %rdx
addq $0x30, %rdx
movq (%rdx), %r15
movq 0x8(%rdx), %rbx
movl 0x10(%rdx), %r13d
movl %r12d, %edx
testl %ecx, %ecx
je 0xcd575
cmpl $0x2, %ecx
jne 0xcd5ee
movq %r14, %rsi
subq %rbp, %rsi
movl %r12d, %edx
cmpq $0x1, %rsi
je 0xcd575
movq %rbx, %rdx
notq %rdx
addq %rdx, %rax
movq %rbp, %r10
notq %r10
cmpl $0x1, %ecx
movq %rdi, 0x30(%rsp)
movq %r9, 0x18(%rsp)
je 0xcd707
movq %rax, %r11
negq %r11
cmpq %r11, %rdi
cmovgeq %r9, %r11
imulq $0x48, %rbp, %rcx
movq %rcx, 0x48(%rsp)
movq 0x40(%rsp), %rdx
leaq (%rdx,%rcx), %rsi
pushq $0x9
popq %rcx
leaq 0x180(%rsp), %rdi
movq %rsi, %rdx
movq %rsi, 0xa8(%rsp)
rep  movsq (%rsi), %es:(%rdi)
leaq 0x1(%rbx), %rcx
movq %rcx, 0xa0(%rsp)
movq 0x230(%rsp), %rcx
addq %rbp, %rcx
movq %rcx, 0xd8(%rsp)
addq %r14, %r10
movq %r8, %rdi
movq %rdx, %rsi
movq 0x28(%rsp), %rdx
pushq $0x1
popq %rcx
movl %r13d, %r8d
pushq $0x2
popq %r9
pushq $0x0
pushq %r11
pushq %r10
movq 0xf0(%rsp), %r10
pushq %r10
pushq 0x248(%rsp)
pushq %rax
movq 0xd0(%rsp), %rax
pushq %rax
pushq 0x248(%rsp)
pushq %r10
pushq %rax
callq 0xcc113
movq 0x68(%rsp), %r9
movq 0xa8(%rsp), %r8
addq $0x50, %rsp
pushq $0x9
popq %rcx
movq 0xa8(%rsp), %rdi
leaq 0x180(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x48(%rsp), %rcx
movl %r12d, 0x58(%rax,%rcx)
movl %r12d, 0x70(%rax,%rcx)
movl %r12d, 0x88(%rax,%rcx)
movq %rax, %rcx
imulq $0x48, %r14, %rax
movl %edx, 0x40(%rcx,%rax)
jmp 0xcd572
addq %r10, %r14
movq 0x20(%rsp), %rcx
cmpq %r14, %rcx
movq %r14, %r10
cmovbq %rcx, %r10
imulq $0x48, %rbp, %rdx
movq 0xc0(%rsp), %rcx
movq %rdx, 0x48(%rsp)
leaq (%rcx,%rdx), %rsi
movq 0xd0(%rsp), %rcx
leaq (%rcx,%rbp), %r11
movq %r8, %rdi
movq 0x28(%rsp), %rdx
pushq $0x2
popq %rcx
movl %r12d, %r8d
pushq $0x1
popq %r9
pushq %r10
pushq $-0x1
pushq %r14
pushq %r11
pushq 0x248(%rsp)
pushq %rax
pushq %rbx
pushq 0x248(%rsp)
pushq %r11
pushq %rbx
callq 0xcc113
addq $0x50, %rsp
leaq (%rax,%rbp), %rcx
incq %rcx
cmpq 0x238(%rsp), %rcx
jae 0xcd7a1
imulq $0x48, %rax, %rax
addq 0xc0(%rsp), %rax
movq 0x48(%rsp), %rsi
movl %edx, 0x58(%rsi,%rax)
movl %edx, 0x70(%rsi,%rax)
movl %edx, 0x88(%rsi,%rax)
cmpq 0x10(%rsp), %rcx
movl 0x8(%rsp), %eax
cmovel %edx, %eax
movl %eax, 0x8(%rsp)
movq 0x58(%rsp), %r8
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %r9
jmp 0xcd572
testq %r14, %r14
movq 0x40(%rsp), %r15
movq 0x240(%rsp), %rdx
je 0xcd8b3
cmpl $0x2, %ecx
movq 0x200(%rsp), %rbx
je 0xcd8e4
cmpl $0x1, %ecx
movq 0x218(%rsp), %r11
jne 0xcdbfc
leaq -0x1(%r11), %rcx
cmpq %rcx, %rax
movq 0x38(%rsp), %rdx
je 0xcdc2d
movq %r11, %rcx
notq %rcx
addq %rcx, %rax
movq %rax, %r10
negq %r10
cmpq %r10, %rdx
cmovaq %rdx, %r10
movq 0x248(%rsp), %r12
cmpq %r12, %r14
cmovlq %r14, %r12
pushq $0x1
popq %r9
movq %r8, %rdi
movq %r15, %rsi
movq 0x28(%rsp), %rdx
movq 0xb0(%rsp), %rcx
movq (%rsp), %r8
pushq %r12
pushq %r10
pushq %r14
movq 0x248(%rsp), %r10
pushq %r10
pushq 0x248(%rsp)
pushq %rax
pushq %r11
pushq 0x248(%rsp)
pushq %r10
pushq %rbx
callq 0xcc113
addq $0x50, %rsp
cmpq 0x238(%rsp), %r14
jae 0xcd89c
imulq $0x48, %r14, %rcx
movl %edx, 0x58(%r15,%rcx)
movl %edx, 0x70(%r15,%rcx)
movl %edx, 0x88(%r15,%rcx)
movq 0x10(%rsp), %rbx
cmpq %rbx, %rax
movl 0x8(%rsp), %eax
cmovel %edx, %eax
movl %eax, %r10d
jmp 0xcd969
cmpl $0x1, %ecx
movq 0x200(%rsp), %rax
jne 0xcd95d
andl $0x0, 0x88(%r15)
andl $0x0, 0x70(%r15)
andl $0x0, 0x58(%r15)
movq %rax, 0x8(%r15)
movq (%rsp), %rax
movl %eax, 0x10(%r15)
jmp 0xcd95d
movq 0x218(%rsp), %r12
subq %r12, %rax
movq %rax, %r10
negq %r10
cmpq %rdx, %r10
cmovleq %rdx, %r10
leaq -0x1(%r14), %r11
movq 0x38(%rsp), %r13
cmpq %r11, %r13
cmovaeq %r11, %r13
pushq $0x2
popq %r9
movq %r8, %rdi
movq %r15, %rsi
movq 0x28(%rsp), %rdx
movq 0xb0(%rsp), %rcx
movq (%rsp), %r8
pushq %r13
pushq %r10
pushq %r11
movq 0x248(%rsp), %r10
pushq %r10
pushq 0x248(%rsp)
pushq %rax
pushq %r12
pushq 0x248(%rsp)
pushq %r10
pushq %rbx
callq 0xcc113
addq $0x50, %rsp
imulq $0x48, %r14, %rax
movl %edx, 0x40(%r15,%rax)
movl 0x8(%rsp), %eax
movl %eax, %r10d
movq 0x10(%rsp), %rbx
movq %rbx, %rax
movl %r10d, %edx
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x36a5e0(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x217681(%rip), %rsi    # 0x2e5013
leaq 0x24120a(%rip), %rdx    # 0x30eba3
leaq 0x24dbb6(%rip), %rcx    # 0x31b556
leaq 0x24d8b3(%rip), %r8     # 0x31b25a
movl $0x16f, %r9d            # imm = 0x16F
jmp 0xcd9db
movq 0x36a5b2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x217653(%rip), %rsi    # 0x2e5013
leaq 0x259025(%rip), %rdx    # 0x3269ec
leaq 0x24db88(%rip), %rcx    # 0x31b556
leaq 0x24d885(%rip), %r8     # 0x31b25a
movl $0x17b, %r9d            # imm = 0x17B
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x36a57a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x21761b(%rip), %rsi    # 0x2e5013
leaq 0x24dafd(%rip), %rdx    # 0x31b4fc
leaq 0x24dabc(%rip), %rcx    # 0x31b4c2
leaq 0x24d84d(%rip), %r8     # 0x31b25a
movl $0x4dd, %r9d            # imm = 0x4DD
jmp 0xcd9db
movq 0x36a54c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2175ed(%rip), %rsi    # 0x2e5013
leaq 0x24da81(%rip), %rdx    # 0x31b4ae
leaq 0x24da8e(%rip), %rcx    # 0x31b4c2
leaq 0x24d81f(%rip), %r8     # 0x31b25a
movl $0x419, %r9d            # imm = 0x419
jmp 0xcd9db
movq 0x36a51e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2175bf(%rip), %rsi    # 0x2e5013
leaq 0x24dac2(%rip), %rdx    # 0x31b51d
leaq 0x24dad9(%rip), %rcx    # 0x31b53b
leaq 0x24d7f1(%rip), %r8     # 0x31b25a
movl $0x1a2, %r9d            # imm = 0x1A2
jmp 0xcd9db
movq 0x36a4ed(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x21758e(%rip), %rsi    # 0x2e5013
leaq 0x258f60(%rip), %rdx    # 0x3269ec
leaq 0x24db23(%rip), %rcx    # 0x31b5b6
leaq 0x24d7c0(%rip), %r8     # 0x31b25a
movl $0x30e, %r9d            # imm = 0x30E
jmp 0xcd9db
movq 0x36a4bc(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x21755d(%rip), %rsi    # 0x2e5013
leaq 0x24d7cc(%rip), %rdx    # 0x31b289
leaq 0x24da77(%rip), %rcx    # 0x31b53b
leaq 0x24d78f(%rip), %r8     # 0x31b25a
movl $0x1a5, %r9d            # imm = 0x1A5
jmp 0xcd9db
movq 0x36a48b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x21752c(%rip), %rsi    # 0x2e5013
leaq 0x256f02(%rip), %rdx    # 0x3249f0
leaq 0x24db2c(%rip), %rcx    # 0x31b621
leaq 0x24d75e(%rip), %r8     # 0x31b25a
movl $0x26d, %r9d            # imm = 0x26D
jmp 0xcd9db
movq 0x36a45a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2174fb(%rip), %rsi    # 0x2e5013
leaq 0x24da61(%rip), %rdx    # 0x31b580
leaq 0x24da30(%rip), %rcx    # 0x31b556
leaq 0x24d72d(%rip), %r8     # 0x31b25a
movl $0x164, %r9d            # imm = 0x164
jmp 0xcd9db
movq 0x36a429(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2174ca(%rip), %rsi    # 0x2e5013
leaq 0x24da57(%rip), %rdx    # 0x31b5a7
leaq 0x24d9ff(%rip), %rcx    # 0x31b556
leaq 0x24d6fc(%rip), %r8     # 0x31b25a
movl $0x169, %r9d            # imm = 0x169
jmp 0xcd9db
movq 0x36a3f8(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x217499(%rip), %rsi    # 0x2e5013
leaq 0x2327ce(%rip), %rdx    # 0x30034f
leaq 0x24d9ce(%rip), %rcx    # 0x31b556
leaq 0x24d6cb(%rip), %r8     # 0x31b25a
movl $0x177, %r9d            # imm = 0x177
jmp 0xcd9db
movq 0x36a3c7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x217468(%rip), %rsi    # 0x2e5013
leaq 0x24d92c(%rip), %rdx    # 0x31b4de
leaq 0x24d909(%rip), %rcx    # 0x31b4c2
leaq 0x24d69a(%rip), %r8     # 0x31b25a
movl $0x479, %r9d            # imm = 0x479
jmp 0xcd9db
movq 0x36a396(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x217437(%rip), %rsi    # 0x2e5013
leaq 0x24d905(%rip), %rdx    # 0x31b4e8
leaq 0x24d8d8(%rip), %rcx    # 0x31b4c2
leaq 0x24d669(%rip), %r8     # 0x31b25a
movl $0x49a, %r9d            # imm = 0x49A
jmp 0xcd9db
movq 0x36a365(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x217406(%rip), %rsi    # 0x2e5013
leaq 0x258dd8(%rip), %rdx    # 0x3269ec
leaq 0x24d8a7(%rip), %rcx    # 0x31b4c2
leaq 0x24d638(%rip), %r8     # 0x31b25a
movl $0x547, %r9d            # imm = 0x547
jmp 0xcd9db
movq 0x36a334(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2173d5(%rip), %rsi    # 0x2e5013
leaq 0x258da7(%rip), %rdx    # 0x3269ec
leaq 0x24d876(%rip), %rcx    # 0x31b4c2
leaq 0x24d607(%rip), %r8     # 0x31b25a
movl $0x525, %r9d            # imm = 0x525
jmp 0xcd9db