// File: marxn[P]pupp/3rdparty/gmp/mpf/get_str.c
// Function: _gmpf_get_str
char *
mpf_get_str (char *dbuf, mp_exp_t *exp, int base, size_t n_digits, mpf_srcptr u)
{
  mp_exp_t ue;
  mp_size_t n_limbs_needed;
  size_t max_digits;
  mp_ptr up, pp, tp;
  mp_size_t un, pn, tn;
  unsigned char *tstr;
  mp_exp_t exp_in_base;
  size_t n_digits_computed;
  mp_size_t i;
  const char *num_to_text;
  size_t alloc_size = 0;
  char *dp;
  TMP_DECL;

  up = PTR(u);
  un = ABSIZ(u);
  ue = EXP(u);

  if (base >= 0)
    {
      num_to_text = "0123456789abcdefghijklmnopqrstuvwxyz";
      if (base <= 1)
	base = 10;
      else if (base > 36)
	{
	  num_to_text = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
	  if (base > 62)
	    return NULL;
	}
    }
  else
    {
      base = -base;
      if (base <= 1)
	base = 10;
      else if (base > 36)
	return NULL;
      num_to_text = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    }

  MPF_SIGNIFICANT_DIGITS (max_digits, base, PREC(u));
  if (n_digits == 0 || n_digits > max_digits)
    n_digits = max_digits;

  if (dbuf == 0)
    {
      /* We didn't get a string from the user.  Allocate one (and return
	 a pointer to it) with space for `-' and terminating null.  */
      alloc_size = n_digits + 2;
      dbuf = (char *) (*__gmp_allocate_func) (n_digits + 2);
    }

  if (un == 0)
    {
      *exp = 0;
      *dbuf = 0;
      n_digits = 0;
      goto done;
    }

  TMP_MARK;

  /* Allocate temporary digit space.  We can't put digits directly in the user
     area, since we generate more digits than requested.  (We allocate
     2 * GMP_LIMB_BITS extra bytes because of the digit block nature of the
     conversion.)  */
  tstr = (unsigned char *) TMP_ALLOC (n_digits + 2 * GMP_LIMB_BITS + 3);

  LIMBS_PER_DIGIT_IN_BASE (n_limbs_needed, n_digits, base);

  if (un > n_limbs_needed)
    {
      up += un - n_limbs_needed;
      un = n_limbs_needed;
    }

  TMP_ALLOC_LIMBS_2 (pp, 2 * n_limbs_needed + 4,
		     tp, 2 * n_limbs_needed + 4);

  if (ue <= n_limbs_needed)
    {
      /* We need to multiply number by base^n to get an n_digits integer part.  */
      mp_size_t n_more_limbs_needed, ign, off;
      unsigned long e;

      n_more_limbs_needed = n_limbs_needed - ue;
      DIGITS_IN_BASE_PER_LIMB (e, n_more_limbs_needed, base);

      pn = mpn_pow_1_highpart (pp, &ign, (mp_limb_t) base, e, n_limbs_needed + 1, tp);
      if (un > pn)
	mpn_mul (tp, up, un, pp, pn);	/* FIXME: mpn_mul_highpart */
      else
	mpn_mul (tp, pp, pn, up, un);	/* FIXME: mpn_mul_highpart */
      tn = un + pn;
      tn -= tp[tn - 1] == 0;
      off = un - ue - ign;
      if (off < 0)
	{
	  MPN_COPY_DECR (tp - off, tp, tn);
	  MPN_ZERO (tp, -off);
	  tn -= off;
	  off = 0;
	}
      n_digits_computed = mpn_get_str (tstr, base, tp + off, tn - off);

      exp_in_base = n_digits_computed - e;
    }
  else
    {
      /* We need to divide number by base^n to get an n_digits integer part.  */
      mp_size_t n_less_limbs_needed, ign, off, xn;
      unsigned long e;
      mp_ptr dummyp, xp;

      n_less_limbs_needed = ue - n_limbs_needed;
      DIGITS_IN_BASE_PER_LIMB (e, n_less_limbs_needed, base);

      pn = mpn_pow_1_highpart (pp, &ign, (mp_limb_t) base, e, n_limbs_needed + 1, tp);

      xn = n_limbs_needed + (n_less_limbs_needed-ign);
      xp = TMP_ALLOC_LIMBS (xn);
      off = xn - un;
      MPN_ZERO (xp, off);
      MPN_COPY (xp + off, up, un);

      dummyp = TMP_ALLOC_LIMBS (pn);
      mpn_tdiv_qr (tp, dummyp, (mp_size_t) 0, xp, xn, pp, pn);
      tn = xn - pn + 1;
      tn -= tp[tn - 1] == 0;
      n_digits_computed = mpn_get_str (tstr, base, tp, tn);

      exp_in_base = n_digits_computed + e;
    }

  /* We should normally have computed too many digits.  Round the result
     at the point indicated by n_digits.  */
  if (n_digits_computed > n_digits)
    {
      size_t i;
      /* Round the result.  */
      if (tstr[n_digits] * 2 >= base)
	{
	  n_digits_computed = n_digits;
	  for (i = n_digits - 1;; i--)
	    {
	      unsigned int x;
	      x = ++(tstr[i]);
	      if (x != base)
		break;
	      n_digits_computed--;
	      if (i == 0)
		{
		  /* We had something like `bbbbbbb...bd', where 2*d >= base
		     and `b' denotes digit with significance base - 1.
		     This rounds up to `1', increasing the exponent.  */
		  tstr[0] = 1;
		  n_digits_computed = 1;
		  exp_in_base++;
		  break;
		}
	    }
	}
    }

  /* We might have fewer digits than requested as a result of rounding above,
     (i.e. 0.999999 => 1.0) or because we have a number that simply doesn't
     need many digits in this base (e.g., 0.125 in base 10).  */
  if (n_digits > n_digits_computed)
    n_digits = n_digits_computed;

  /* Remove trailing 0.  There can be many zeros.  */
  while (n_digits != 0 && tstr[n_digits - 1] == 0)
    n_digits--;

  dp = dbuf + (SIZ(u) < 0);

  /* Translate to ASCII and copy to result string.  */
  for (i = 0; i < n_digits; i++)
    dp[i] = num_to_text[tstr[i]];
  dp[n_digits] = 0;

  *exp = exp_in_base;

  if (SIZ(u) < 0)
    {
      dbuf[0] = '-';
      n_digits++;
    }

  TMP_FREE;

 done:
  /* If the string was alloced then resize it down to the actual space
     required.  */
  if (alloc_size != 0)
    {
      __GMP_REALLOCATE_FUNC_MAYBE_TYPE (dbuf, alloc_size, n_digits + 1, char);
    }

  return dbuf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq $0x0, -0xa8(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0x5c56e
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x1ac(%rbp)
jmp 0x5c57d
movq -0x30(%rbp), %rcx
xorl %eax, %eax
subl 0x4(%rcx), %eax
movl %eax, -0x1ac(%rbp)
movl -0x1ac(%rbp), %eax
cltq
movq %rax, -0x68(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x5c5e5
leaq 0x8602(%rip), %rax      # 0x64ba4
movq %rax, -0xa0(%rbp)
cmpl $0x1, -0x1c(%rbp)
jg 0x5c5b8
movl $0xa, -0x1c(%rbp)
jmp 0x5c5e3
cmpl $0x24, -0x1c(%rbp)
jle 0x5c5e1
leaq 0x862f(%rip), %rax      # 0x64bf4
movq %rax, -0xa0(%rbp)
cmpl $0x3e, -0x1c(%rbp)
jle 0x5c5df
movq $0x0, -0x8(%rbp)
jmp 0x5d019
jmp 0x5c5e1
jmp 0x5c5e3
jmp 0x5c61f
xorl %eax, %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jg 0x5c5fc
movl $0xa, -0x1c(%rbp)
jmp 0x5c611
cmpl $0x24, -0x1c(%rbp)
jle 0x5c60f
movq $0x0, -0x8(%rbp)
jmp 0x5d019
jmp 0x5c611
leaq 0x85b1(%rip), %rax      # 0x64bc9
movq %rax, -0xa0(%rbp)
jmp 0x5c621
jmp 0x5c623
jmp 0x5c625
jmp 0x5c627
movslq -0x1c(%rbp), %rcx
leaq 0x4c2e(%rip), %rax      # 0x61260
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x6, %rcx
movq %rcx, -0x190(%rbp)
mulq -0x190(%rbp)
movq %rax, -0xd0(%rbp)
movq %rdx, -0xc8(%rbp)
movq -0xc8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0xc0(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5c697
movq -0x28(%rbp), %rax
cmpq -0x48(%rbp), %rax
jbe 0x5c69f
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5c6cd
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0xa8(%rbp)
leaq 0x19c64(%rip), %rax     # 0x76320
movq (%rax), %rax
movq -0x28(%rbp), %rdi
addq $0x2, %rdi
callq *%rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x68(%rbp)
jne 0x5c6f3
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq $0x0, -0x28(%rbp)
jmp 0x5cfc2
movq $0x0, -0xb8(%rbp)
movq -0x28(%rbp), %rax
addq $0x80, %rax
addq $0x3, %rax
cmpq $0x7f00, %rax           # imm = 0x7F00
setbe %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x5c74e
movq -0x28(%rbp), %rcx
addq $0x92, %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x1b8(%rbp)
jmp 0x5c770
movq -0x28(%rbp), %rsi
addq $0x80, %rsi
addq $0x3, %rsi
leaq -0xb8(%rbp), %rdi
callq 0x56430
movq %rax, -0x1b8(%rbp)
movq -0x1b8(%rbp), %rax
movq %rax, -0x80(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0x4ada(%rip), %rax      # 0x61260
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq %rcx, -0x198(%rbp)
mulq -0x198(%rbp)
movq %rax, -0xe0(%rbp)
movq %rdx, -0xd8(%rbp)
movq -0xd8(%rbp), %rax
shlq $0x3, %rax
shrq $0x6, %rax
addq $0x2, %rax
movq %rax, -0x40(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x40(%rbp), %rax
jle 0x5c7ee
movq -0x68(%rbp), %rax
subq -0x40(%rbp), %rax
shlq $0x3, %rax
addq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x5c7f0
movq -0x40(%rbp), %rax
shlq %rax
addq $0x4, %rax
movq -0x40(%rbp), %rcx
shlq %rcx
addq $0x4, %rcx
addq %rcx, %rax
shlq $0x3, %rax
cmpq $0x7f00, %rax           # imm = 0x7F00
setbe %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x5c853
movq -0x40(%rbp), %rcx
movq %rcx, %rax
addq %rax, %rax
leaq 0x8(%rax,%rcx,2), %rcx
shlq $0x3, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x1c0(%rbp)
jmp 0x5c883
movq -0x40(%rbp), %rsi
shlq %rsi
addq $0x4, %rsi
movq -0x40(%rbp), %rax
shlq %rax
addq $0x4, %rax
addq %rax, %rsi
shlq $0x3, %rsi
leaq -0xb8(%rbp), %rdi
callq 0x56430
movq %rax, -0x1c0(%rbp)
movq -0x1c0(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq -0x40(%rbp), %rcx
shlq %rcx
addq $0x4, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jg 0x5cad2
movq -0x40(%rbp), %rax
subq -0x38(%rbp), %rax
movq %rax, -0xe8(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0x4990(%rip), %rax      # 0x61260
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq -0xe8(%rbp), %rcx
shlq $0x6, %rcx
movq %rcx, -0x1a8(%rbp)
mulq -0x1a8(%rbp)
movq %rax, -0x110(%rbp)
movq %rdx, -0x108(%rbp)
movq -0x108(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x58(%rbp), %rdi
movslq -0x1c(%rbp), %rdx
movq -0x100(%rbp), %rcx
movq -0x40(%rbp), %r8
addq $0x1, %r8
movq -0x60(%rbp), %r9
leaq -0xf0(%rbp), %rsi
callq 0x5d030
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x70(%rbp), %rax
jle 0x5c960
movq -0x60(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq -0x58(%rbp), %rcx
movq -0x70(%rbp), %r8
callq 0x37f00
jmp 0x5c979
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x68(%rbp), %r8
callq 0x37f00
movq -0x68(%rbp), %rax
addq -0x70(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x60(%rbp), %rax
movq -0x78(%rbp), %rcx
subq $0x1, %rcx
cmpq $0x0, (%rax,%rcx,8)
sete %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
movq -0x78(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x78(%rbp)
movq -0x68(%rbp), %rax
subq -0x38(%rbp), %rax
subq -0xf0(%rbp), %rax
movq %rax, -0xf8(%rbp)
cmpq $0x0, -0xf8(%rbp)
jge 0x5ca88
jmp 0x5c9d2
jmp 0x5c9d4
jmp 0x5c9d6
jmp 0x5c9d8
jmp 0x5c9da
movq -0x60(%rbp), %rdi
xorl %eax, %eax
subq -0xf8(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x60(%rbp), %rsi
movq -0x78(%rbp), %rdx
callq 0x5ed40
jmp 0x5c9fd
jmp 0x5c9ff
jmp 0x5ca01
xorl %eax, %eax
subq -0xf8(%rbp), %rax
cmpq $0x0, %rax
je 0x5ca69
jmp 0x5ca12
movq -0x60(%rbp), %rax
movq %rax, -0x118(%rbp)
xorl %eax, %eax
subq -0xf8(%rbp), %rax
movq %rax, -0x120(%rbp)
jmp 0x5ca2f
jmp 0x5ca31
movq -0x118(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x118(%rbp)
movq $0x0, (%rax)
movq -0x120(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x120(%rbp)
cmpq $0x0, %rax
jne 0x5ca31
jmp 0x5ca67
jmp 0x5ca69
jmp 0x5ca6b
movq -0xf8(%rbp), %rcx
movq -0x78(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x78(%rbp)
movq $0x0, -0xf8(%rbp)
movq -0x80(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x60(%rbp), %rdx
movq -0xf8(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
movq -0x78(%rbp), %rcx
subq -0xf8(%rbp), %rcx
callq 0x5dba0
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
subq -0x100(%rbp), %rax
movq %rax, -0x88(%rbp)
jmp 0x5cdb2
movq -0x38(%rbp), %rax
subq -0x40(%rbp), %rax
movq %rax, -0x128(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0x4774(%rip), %rax      # 0x61260
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq -0x128(%rbp), %rcx
shlq $0x6, %rcx
movq %rcx, -0x1a0(%rbp)
mulq -0x1a0(%rbp)
movq %rax, -0x168(%rbp)
movq %rdx, -0x160(%rbp)
movq -0x160(%rbp), %rax
movq %rax, -0x148(%rbp)
movq -0x58(%rbp), %rdi
movslq -0x1c(%rbp), %rdx
movq -0x148(%rbp), %rcx
movq -0x40(%rbp), %r8
addq $0x1, %r8
movq -0x60(%rbp), %r9
leaq -0x130(%rbp), %rsi
callq 0x5d030
movq %rax, -0x70(%rbp)
movq -0x40(%rbp), %rax
movq -0x128(%rbp), %rcx
subq -0x130(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x140(%rbp)
movq -0x140(%rbp), %rax
shlq $0x3, %rax
cmpq $0x7f00, %rax           # imm = 0x7F00
setbe %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x5cbc4
movq -0x140(%rbp), %rax
leaq 0xf(,%rax,8), %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x1c8(%rbp)
jmp 0x5cbe2
movq -0x140(%rbp), %rsi
shlq $0x3, %rsi
leaq -0xb8(%rbp), %rdi
callq 0x56430
movq %rax, -0x1c8(%rbp)
movq -0x1c8(%rbp), %rax
movq %rax, -0x158(%rbp)
movq -0x140(%rbp), %rax
subq -0x68(%rbp), %rax
movq %rax, -0x138(%rbp)
jmp 0x5cc04
jmp 0x5cc06
cmpq $0x0, -0x138(%rbp)
je 0x5cc6a
jmp 0x5cc12
movq -0x158(%rbp), %rax
movq %rax, -0x170(%rbp)
movq -0x138(%rbp), %rax
movq %rax, -0x178(%rbp)
jmp 0x5cc30
jmp 0x5cc32
movq -0x170(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x170(%rbp)
movq $0x0, (%rax)
movq -0x178(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x178(%rbp)
cmpq $0x0, %rax
jne 0x5cc32
jmp 0x5cc68
jmp 0x5cc6a
jmp 0x5cc6c
jmp 0x5cc6e
jmp 0x5cc70
jmp 0x5cc72
jmp 0x5cc74
jmp 0x5cc76
jmp 0x5cc78
jmp 0x5cc7a
jmp 0x5cc7c
movq -0x158(%rbp), %rdi
movq -0x138(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x50(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0x554c6
jmp 0x5cca0
movq -0x70(%rbp), %rax
shlq $0x3, %rax
cmpq $0x7f00, %rax           # imm = 0x7F00
setbe %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x5cceb
movq -0x70(%rbp), %rax
leaq 0xf(,%rax,8), %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x1d0(%rbp)
jmp 0x5cd06
movq -0x70(%rbp), %rsi
shlq $0x3, %rsi
leaq -0xb8(%rbp), %rdi
callq 0x56430
movq %rax, -0x1d0(%rbp)
movq -0x1d0(%rbp), %rax
movq %rax, -0x150(%rbp)
movq -0x60(%rbp), %rdi
movq -0x150(%rbp), %rsi
movq -0x158(%rbp), %rcx
movq -0x140(%rbp), %r8
movq -0x58(%rbp), %r9
movq -0x70(%rbp), %rax
xorl %edx, %edx
subq $0x10, %rsp
movq %rax, (%rsp)
callq 0x3cde0
addq $0x10, %rsp
movq -0x140(%rbp), %rax
subq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x78(%rbp)
movq -0x60(%rbp), %rax
movq -0x78(%rbp), %rcx
subq $0x1, %rcx
cmpq $0x0, (%rax,%rcx,8)
sete %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
movq -0x78(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x78(%rbp)
movq -0x80(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x60(%rbp), %rdx
movq -0x78(%rbp), %rcx
callq 0x5dba0
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
addq -0x148(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x90(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0x5ce7c
movq -0x80(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
shll %eax
cmpl -0x1c(%rbp), %eax
jl 0x5ce7a
movq -0x28(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x28(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x180(%rbp)
movq -0x80(%rbp), %rcx
movq -0x180(%rbp), %rdx
movb (%rcx,%rdx), %al
addb $0x1, %al
movb %al, (%rcx,%rdx)
movzbl %al, %eax
movl %eax, -0x184(%rbp)
movl -0x184(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0x5ce1d
jmp 0x5ce78
movq -0x90(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x90(%rbp)
cmpq $0x0, -0x180(%rbp)
jne 0x5ce5f
movq -0x80(%rbp), %rax
movb $0x1, (%rax)
movq $0x1, -0x90(%rbp)
movq -0x88(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x88(%rbp)
jmp 0x5ce78
jmp 0x5ce61
movq -0x180(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x180(%rbp)
jmp 0x5cdf4
jmp 0x5ce7a
jmp 0x5ce7c
movq -0x28(%rbp), %rax
cmpq -0x90(%rbp), %rax
jbe 0x5ce94
movq -0x90(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x5ce96
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x1d1(%rbp)
je 0x5cec1
movq -0x80(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x1d1(%rbp)
movb -0x1d1(%rbp), %al
testb $0x1, %al
jne 0x5cecd
jmp 0x5cedb
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x5ce96
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpl $0x0, 0x4(%rcx)
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0xb0(%rbp)
movq $0x0, -0x98(%rbp)
movq -0x98(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x5cf53
movq -0xa0(%rbp), %rax
movq -0x80(%rbp), %rcx
movq -0x98(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movb (%rax,%rcx), %dl
movq -0xb0(%rbp), %rax
movq -0x98(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x98(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x98(%rbp)
jmp 0x5cf08
movq -0xb0(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x88(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jge 0x5cf8d
movq -0x10(%rbp), %rax
movb $0x2d, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x5cf8f
cmpq $0x0, -0xb8(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x5cfbe
movq -0xb8(%rbp), %rdi
callq 0x564a0
jmp 0x5cfc0
jmp 0x5cfc2
cmpq $0x0, -0xa8(%rbp)
je 0x5d011
jmp 0x5cfce
movq -0xa8(%rbp), %rax
movq -0x28(%rbp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
je 0x5d00d
leaq 0x1933f(%rip), %rax     # 0x76328
movq (%rax), %rax
movq -0x10(%rbp), %rdi
movq -0xa8(%rbp), %rsi
shlq $0x0, %rsi
movq -0x28(%rbp), %rdx
addq $0x1, %rdx
shlq $0x0, %rdx
callq *%rax
movq %rax, -0x10(%rbp)
jmp 0x5d00f
jmp 0x5d011
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)