// File: marxn[P]pupp/3rdparty/gmp/mpn/mulmod_bnm1.c
// Function: _gmpn_mulmod_bnm1
void
mpn_mulmod_bnm1 (mp_ptr rp, mp_size_t rn, mp_srcptr ap, mp_size_t an, mp_srcptr bp, mp_size_t bn, mp_ptr tp)
{
  ASSERT (0 < bn);
  ASSERT (bn <= an);
  ASSERT (an <= rn);

  if ((rn & 1) != 0 || BELOW_THRESHOLD (rn, MULMOD_BNM1_THRESHOLD))
    {
      if (UNLIKELY (bn < rn))
	{
	  if (UNLIKELY (an + bn <= rn))
	    {
	      mpn_mul (rp, ap, an, bp, bn);
	    }
	  else
	    {
	      mp_limb_t cy;
	      mpn_mul (tp, ap, an, bp, bn);
	      cy = mpn_add (rp, tp, rn, tp + rn, an + bn - rn);
	      MPN_INCR_U (rp, rn, cy);
	    }
	}
      else
	mpn_bc_mulmod_bnm1 (rp, ap, bp, rn, tp);
    }
  else
    {
      mp_size_t n;
      mp_limb_t cy;
      mp_limb_t hi;

      n = rn >> 1;

      /* We need at least an + bn >= n, to be able to fit one of the
	 recursive products at rp. Requiring strict inequality makes
	 the code slightly simpler. If desired, we could avoid this
	 restriction by initially halving rn as long as rn is even and
	 an + bn <= rn/2. */

      ASSERT (an + bn > n);

      /* Compute xm = a*b mod (B^n - 1), xp = a*b mod (B^n + 1)
	 and crt together as

	 x = -xp * B^n + (B^n + 1) * [ (xp + xm)/2 mod (B^n-1)]
      */

#define a0 ap
#define a1 (ap + n)
#define b0 bp
#define b1 (bp + n)

#define xp  tp	/* 2n + 2 */
      /* am1  maybe in {xp, n} */
      /* bm1  maybe in {xp + n, n} */
#define sp1 (tp + 2*n + 2)
      /* ap1  maybe in {sp1, n + 1} */
      /* bp1  maybe in {sp1 + n + 1, n + 1} */

      {
	mp_srcptr am1, bm1;
	mp_size_t anm, bnm;
	mp_ptr so;

	bm1 = b0;
	bnm = bn;
	if (LIKELY (an > n))
	  {
	    am1 = xp;
	    cy = mpn_add (xp, a0, n, a1, an - n);
	    MPN_INCR_U (xp, n, cy);
	    anm = n;
	    so = xp + n;
	    if (LIKELY (bn > n))
	      {
		bm1 = so;
		cy = mpn_add (so, b0, n, b1, bn - n);
		MPN_INCR_U (so, n, cy);
		bnm = n;
		so += n;
	      }
	  }
	else
	  {
	    so = xp;
	    am1 = a0;
	    anm = an;
	  }

	mpn_mulmod_bnm1 (rp, n, am1, anm, bm1, bnm, so);
      }

      {
	int       k;
	mp_srcptr ap1, bp1;
	mp_size_t anp, bnp;

	bp1 = b0;
	bnp = bn;
	if (LIKELY (an > n)) {
	  ap1 = sp1;
	  cy = mpn_sub (sp1, a0, n, a1, an - n);
	  sp1[n] = 0;
	  MPN_INCR_U (sp1, n + 1, cy);
	  anp = n + ap1[n];
	  if (LIKELY (bn > n)) {
	    bp1 = sp1 + n + 1;
	    cy = mpn_sub (sp1 + n + 1, b0, n, b1, bn - n);
	    sp1[2*n+1] = 0;
	    MPN_INCR_U (sp1 + n + 1, n + 1, cy);
	    bnp = n + bp1[n];
	  }
	} else {
	  ap1 = a0;
	  anp = an;
	}

	if (BELOW_THRESHOLD (n, MUL_FFT_MODF_THRESHOLD))
	  k=0;
	else
	  {
	    int mask;
	    k = mpn_fft_best_k (n, 0);
	    mask = (1<<k) - 1;
	    while (n & mask) {k--; mask >>=1;};
	  }
	if (k >= FFT_FIRST_K)
	  xp[n] = mpn_mul_fft (xp, n, ap1, anp, bp1, bnp, k);
	else if (UNLIKELY (bp1 == b0))
	  {
	    ASSERT (anp + bnp <= 2*n+1);
	    ASSERT (anp + bnp > n);
	    ASSERT (anp >= bnp);
	    mpn_mul (xp, ap1, anp, bp1, bnp);
	    anp = anp + bnp - n;
	    ASSERT (anp <= n || xp[2*n]==0);
	    anp-= anp > n;
	    cy = mpn_sub (xp, xp, n, xp + n, anp);
	    xp[n] = 0;
	    MPN_INCR_U (xp, n+1, cy);
	  }
	else
	  mpn_bc_mulmod_bnp1 (xp, ap1, bp1, n, xp);
      }

      /* Here the CRT recomposition begins.

	 xm <- (xp + xm)/2 = (xp + xm)B^n/2 mod (B^n-1)
	 Division by 2 is a bitwise rotation.

	 Assumes xp normalised mod (B^n+1).

	 The residue class [0] is represented by [B^n-1]; except when
	 both input are ZERO.
      */

#if HAVE_NATIVE_mpn_rsh1add_n || HAVE_NATIVE_mpn_rsh1add_nc
#if HAVE_NATIVE_mpn_rsh1add_nc
      cy = mpn_rsh1add_nc(rp, rp, xp, n, xp[n]); /* B^n = 1 */
      hi = cy << (GMP_NUMB_BITS - 1);
      cy = 0;
      /* next update of rp[n-1] will set cy = 1 only if rp[n-1]+=hi
	 overflows, i.e. a further increment will not overflow again. */
#else /* ! _nc */
      cy = xp[n] + mpn_rsh1add_n(rp, rp, xp, n); /* B^n = 1 */
      hi = (cy<<(GMP_NUMB_BITS-1))&GMP_NUMB_MASK; /* (cy&1) << ... */
      cy >>= 1;
      /* cy = 1 only if xp[n] = 1 i.e. {xp,n} = ZERO, this implies that
	 the rsh1add was a simple rshift: the top bit is 0. cy=1 => hi=0. */
#endif
#if GMP_NAIL_BITS == 0
      add_ssaaaa(cy, rp[n-1], cy, rp[n-1], 0, hi);
#else
      cy += (hi & rp[n-1]) >> (GMP_NUMB_BITS-1);
      rp[n-1] ^= hi;
#endif
#else /* ! HAVE_NATIVE_mpn_rsh1add_n */
#if HAVE_NATIVE_mpn_add_nc
      cy = mpn_add_nc(rp, rp, xp, n, xp[n]);
#else /* ! _nc */
      cy = xp[n] + mpn_add_n(rp, rp, xp, n); /* xp[n] == 1 implies {xp,n} == ZERO */
#endif
      cy += (rp[0]&1);
      mpn_rshift(rp, rp, n, 1);
      ASSERT (cy <= 2);
      hi = (cy<<(GMP_NUMB_BITS-1))&GMP_NUMB_MASK; /* (cy&1) << ... */
      cy >>= 1;
      /* We can have cy != 0 only if hi = 0... */
      ASSERT ((rp[n-1] & GMP_NUMB_HIGHBIT) == 0);
      rp[n-1] |= hi;
      /* ... rp[n-1] + cy can not overflow, the following INCR is correct. */
#endif
      ASSERT (cy <= 1);
      /* Next increment can not overflow, read the previous comments about cy. */
      ASSERT ((cy == 0) || ((rp[n-1] & GMP_NUMB_HIGHBIT) == 0));
      MPN_INCR_U(rp, n, cy);

      /* Compute the highest half:
	 ([(xp + xm)/2 mod (B^n-1)] - xp ) * B^n
       */
      if (UNLIKELY (an + bn < rn))
	{
	  /* Note that in this case, the only way the result can equal
	     zero mod B^{rn} - 1 is if one of the inputs is zero, and
	     then the output of both the recursive calls and this CRT
	     reconstruction is zero, not B^{rn} - 1. Which is good,
	     since the latter representation doesn't fit in the output
	     area.*/
	  cy = mpn_sub_n (rp + n, rp, xp, an + bn - n);

	  /* FIXME: This subtraction of the high parts is not really
	     necessary, we do it to get the carry out, and for sanity
	     checking. */
	  cy = xp[n] + mpn_sub_nc (xp + an + bn - n, rp + an + bn - n,
				   xp + an + bn - n, rn - (an + bn), cy);
	  ASSERT (an + bn == rn - 1 ||
		  mpn_zero_p (xp + an + bn - n + 1, rn - 1 - (an + bn)));
	  cy = mpn_sub_1 (rp, rp, an + bn, cy);
	  ASSERT (cy == (xp + an + bn - n)[0]);
	}
      else
	{
	  cy = xp[n] + mpn_sub_n (rp + n, rp, xp, n);
	  /* cy = 1 only if {xp,n+1} is not ZERO, i.e. {rp,n} is not ZERO.
	     DECR will affect _at most_ the lowest n limbs. */
	  MPN_DECR_U (rp, 2*n, cy);
	}
#undef a0
#undef a1
#undef b0
#undef b1
#undef xp
#undef sp1
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
jmp 0x4e179
jmp 0x4e17b
jmp 0x4e17d
jmp 0x4e17f
jmp 0x4e181
movq -0x10(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x4e19a
cmpq $0x12, -0x10(%rbp)
jge 0x4e28e
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
setl %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x4e270
movq -0x20(%rbp), %rax
addq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
setle %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x4e203
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x37f00
jmp 0x4e26e
movq 0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x37f00
movq -0x8(%rbp), %rdi
movq 0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq 0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x20(%rbp), %r8
addq -0x30(%rbp), %r8
subq -0x10(%rbp), %r8
callq 0x36b60
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
addq %rcx, (%rax)
jae 0x4e264
addq $0x1, 0x8(%rax)
leaq 0x8(%rax), %rax
jb 0x4e259
movq %rax, -0x40(%rbp)
jmp 0x4e26a
jmp 0x4e26c
jmp 0x4e26e
jmp 0x4e289
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0x4e0d0
jmp 0x4ea6a
movq -0x10(%rbp), %rax
sarq %rax
movq %rax, -0x48(%rbp)
jmp 0x4e29b
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x48(%rbp), %rax
setg %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x4e3d8
movq 0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq 0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x48(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x20(%rbp), %r8
subq -0x48(%rbp), %r8
callq 0x36b60
movq %rax, -0x50(%rbp)
movq 0x10(%rbp), %rax
movq -0x50(%rbp), %rcx
addq %rcx, (%rax)
jae 0x4e31e
addq $0x1, 0x8(%rax)
leaq 0x8(%rax), %rax
jb 0x4e313
movq %rax, -0x88(%rbp)
jmp 0x4e327
jmp 0x4e329
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
movq 0x10(%rbp), %rax
movq -0x48(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x80(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x48(%rbp), %rax
setg %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x4e3d6
movq -0x80(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x80(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x48(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x30(%rbp), %r8
subq -0x48(%rbp), %r8
callq 0x36b60
movq %rax, -0x50(%rbp)
movq -0x80(%rbp), %rax
movq -0x50(%rbp), %rcx
addq %rcx, (%rax)
jae 0x4e3b3
addq $0x1, 0x8(%rax)
leaq 0x8(%rax), %rax
jb 0x4e3a8
movq %rax, -0x90(%rbp)
jmp 0x4e3bc
jmp 0x4e3be
movq -0x48(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x48(%rbp), %rax
shlq $0x3, %rax
addq -0x80(%rbp), %rax
movq %rax, -0x80(%rbp)
jmp 0x4e3f0
movq 0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq -0x70(%rbp), %rcx
movq -0x68(%rbp), %r8
movq -0x78(%rbp), %r9
movq -0x80(%rbp), %rax
movq %rax, (%rsp)
callq 0x4e150
movq -0x28(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x48(%rbp), %rax
setg %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x4e63d
movq 0x10(%rbp), %rax
movq -0x48(%rbp), %rcx
shlq %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $0x10, %rax
movq %rax, -0xa0(%rbp)
movq 0x10(%rbp), %rdi
movq -0x48(%rbp), %rax
shlq %rax
shlq $0x3, %rax
addq %rax, %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x48(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x20(%rbp), %r8
subq -0x48(%rbp), %r8
callq 0x36d60
movq %rax, -0x50(%rbp)
movq 0x10(%rbp), %rax
movq -0x48(%rbp), %rcx
shlq %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq -0x48(%rbp), %rcx
movq $0x0, 0x10(%rax,%rcx,8)
movq 0x10(%rbp), %rax
movq -0x48(%rbp), %rcx
shlq %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $0x10, %rax
movq -0x50(%rbp), %rcx
addq %rcx, (%rax)
jae 0x4e4f6
addq $0x1, 0x8(%rax)
leaq 0x8(%rax), %rax
jb 0x4e4eb
movq %rax, -0xc0(%rbp)
jmp 0x4e4ff
jmp 0x4e501
movq -0x48(%rbp), %rax
movq -0xa0(%rbp), %rcx
movq -0x48(%rbp), %rdx
addq (%rcx,%rdx,8), %rax
movq %rax, -0xb0(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x48(%rbp), %rax
setg %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x4e63b
movq 0x10(%rbp), %rax
movq -0x48(%rbp), %rcx
shlq %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $0x10, %rax
movq -0x48(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $0x8, %rax
movq %rax, -0xa8(%rbp)
movq 0x10(%rbp), %rdi
movq -0x48(%rbp), %rax
shlq %rax
shlq $0x3, %rax
addq %rax, %rdi
addq $0x10, %rdi
movq -0x48(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x48(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x30(%rbp), %r8
subq -0x48(%rbp), %r8
callq 0x36d60
movq %rax, -0x50(%rbp)
movq 0x10(%rbp), %rax
movq -0x48(%rbp), %rcx
shlq %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq -0x48(%rbp), %rcx
shlq %rcx
movq $0x0, 0x18(%rax,%rcx,8)
movq 0x10(%rbp), %rax
movq -0x48(%rbp), %rcx
shlq %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $0x10, %rax
movq -0x48(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $0x8, %rax
movq -0x50(%rbp), %rcx
addq %rcx, (%rax)
jae 0x4e616
addq $0x1, 0x8(%rax)
leaq 0x8(%rax), %rax
jb 0x4e60b
movq %rax, -0xc8(%rbp)
jmp 0x4e61f
jmp 0x4e621
movq -0x48(%rbp), %rax
movq -0xa8(%rbp), %rcx
movq -0x48(%rbp), %rdx
addq (%rcx,%rdx,8), %rax
movq %rax, -0xb8(%rbp)
jmp 0x4e653
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xb0(%rbp)
cmpq $0x28e, -0x48(%rbp)     # imm = 0x28E
jge 0x4e669
movl $0x0, -0x94(%rbp)
jmp 0x4e6c5
movq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x56ab0
movl %eax, -0x94(%rbp)
movl -0x94(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
movl %eax, -0xcc(%rbp)
movq -0x48(%rbp), %rax
movslq -0xcc(%rbp), %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x4e6c3
movl -0x94(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x94(%rbp)
movl -0xcc(%rbp), %eax
sarl %eax
movl %eax, -0xcc(%rbp)
jmp 0x4e690
jmp 0x4e6c5
cmpl $0x4, -0x94(%rbp)
jl 0x4e714
movq 0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movq -0xb0(%rbp), %rcx
movq -0xa8(%rbp), %r8
movq -0xb8(%rbp), %r9
movl -0x94(%rbp), %eax
movl %eax, (%rsp)
callq 0x56b70
movq %rax, %rdx
movq 0x10(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x4e832
movq -0xa8(%rbp), %rax
cmpq -0x28(%rbp), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x4e811
jmp 0x4e740
jmp 0x4e742
jmp 0x4e744
jmp 0x4e746
jmp 0x4e748
jmp 0x4e74a
movq 0x10(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq -0xb0(%rbp), %rdx
movq -0xa8(%rbp), %rcx
movq -0xb8(%rbp), %r8
callq 0x37f00
movq -0xb0(%rbp), %rax
addq -0xb8(%rbp), %rax
subq -0x48(%rbp), %rax
movq %rax, -0xb0(%rbp)
jmp 0x4e78a
movq -0xb0(%rbp), %rax
cmpq -0x48(%rbp), %rax
setg %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
movq -0xb0(%rbp), %rax
subq %rcx, %rax
movq %rax, -0xb0(%rbp)
movq 0x10(%rbp), %rdi
movq 0x10(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq 0x10(%rbp), %rcx
movq -0x48(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0xb0(%rbp), %r8
callq 0x36d60
movq %rax, -0x50(%rbp)
movq 0x10(%rbp), %rax
movq -0x48(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq 0x10(%rbp), %rax
movq -0x50(%rbp), %rcx
addq %rcx, (%rax)
jae 0x4e804
addq $0x1, 0x8(%rax)
leaq 0x8(%rax), %rax
jb 0x4e7f9
movq %rax, -0xd8(%rbp)
jmp 0x4e80d
jmp 0x4e80f
jmp 0x4e830
movq 0x10(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq -0x48(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0x4ea80
jmp 0x4e832
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq 0x10(%rbp), %rdx
movq -0x48(%rbp), %rcx
movq 0x10(%rbp), %rax
movq -0x48(%rbp), %r8
movq (%rax,%r8,8), %r8
callq 0x558e0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
shlq $0x3f, %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq -0x48(%rbp), %rcx
subq $0x1, %rcx
movq -0x50(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x48(%rbp), %rdi
subq $0x1, %rdi
movq (%rdx,%rdi,8), %rdx
movq -0x58(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
addq -0xf0(%rbp), %rdx
adcq $0x0, %rsi
movq %rsi, -0x50(%rbp)
movq %rdx, (%rax,%rcx,8)
jmp 0x4e8ab
jmp 0x4e8ad
jmp 0x4e8af
jmp 0x4e8b1
movq -0x8(%rbp), %rax
movq -0x50(%rbp), %rcx
addq %rcx, (%rax)
jae 0x4e8c9
addq $0x1, 0x8(%rax)
leaq 0x8(%rax), %rax
jb 0x4e8be
movq %rax, -0xe0(%rbp)
jmp 0x4e8d2
jmp 0x4e8d4
movq -0x20(%rbp), %rax
addq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
setl %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x4e9ff
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movq 0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
addq -0x30(%rbp), %rcx
subq -0x48(%rbp), %rcx
callq 0x36fe0
movq %rax, -0x50(%rbp)
movq 0x10(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0xf8(%rbp)
movq 0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
xorl %eax, %eax
subq -0x48(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
xorl %eax, %eax
subq -0x48(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq 0x10(%rbp), %rdx
movq -0x20(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
movq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
xorl %eax, %eax
subq -0x48(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
addq -0x30(%rbp), %rax
subq %rax, %rcx
movq -0x50(%rbp), %r8
callq 0x36fc0
movq %rax, %rcx
movq -0xf8(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x50(%rbp)
jmp 0x4e9de
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq -0x30(%rbp), %rdx
movq -0x50(%rbp), %rcx
callq 0x36e60
movq %rax, -0x50(%rbp)
jmp 0x4e9fd
jmp 0x4ea68
movq 0x10(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x100(%rbp)
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movq 0x10(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x36fe0
movq %rax, %rcx
movq -0x100(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq -0x50(%rbp), %rcx
subq %rcx, (%rax)
jae 0x4ea5b
subq $0x1, 0x8(%rax)
leaq 0x8(%rax), %rax
jb 0x4ea50
movq %rax, -0xe8(%rbp)
jmp 0x4ea64
jmp 0x4ea66
jmp 0x4ea68
jmp 0x4ea6a
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)