// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/mpf/set_str.c
// Function: _gmpf_set_str
int
mpf_set_str (mpf_ptr x, const char *str, int base)
{
  size_t str_size;
  char *s, *begs;
  size_t i, j;
  int c;
  int negative;
  char *dotpos = 0;
  const char *expptr;
  int exp_base;
  const char  *point = GMP_DECIMAL_POINT;
  size_t      pointlen = strlen (point);
  const unsigned char *digit_value;
  TMP_DECL;

  c = (unsigned char) *str;

  /* Skip whitespace.  */
  while (isspace (c))
    c = (unsigned char) *++str;

  negative = 0;
  if (c == '-')
    {
      negative = 1;
      c = (unsigned char) *++str;
    }

  /* Default base to decimal.  */
  if (base == 0)
    base = 10;

  exp_base = base;

  if (base < 0)
    {
      exp_base = 10;
      base = -base;
    }

  digit_value = digit_value_tab;
  if (base > 36)
    {
      /* For bases > 36, use the collating sequence
	 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz.  */
      digit_value += 208;
      if (base > 62)
	return -1;		/* too large base */
    }

  /* Require at least one digit, possibly after an initial decimal point.  */
  if (digit_value[c] >= base)
    {
      /* not a digit, must be a decimal point */
      for (i = 0; i < pointlen; i++)
	if (str[i] != point[i])
	  return -1;
      if (digit_value[(unsigned char) str[pointlen]] >= base)
	return -1;
    }

  /* Locate exponent part of the input.  Look from the right of the string,
     since the exponent is usually a lot shorter than the mantissa.  */
  expptr = NULL;
  str_size = strlen (str);
  for (i = str_size - 1; i > 0; i--)
    {
      c = (unsigned char) str[i];
      if (c == '@' || (base <= 10 && (c == 'e' || c == 'E')))
	{
	  expptr = str + i + 1;
	  str_size = i;
	  break;
	}
    }

  TMP_MARK;
  s = begs = (char *) TMP_ALLOC (str_size + 1);

  /* Loop through mantissa, converting it from ASCII to raw byte values.  */
  for (i = 0; i < str_size; i++)
    {
      c = (unsigned char) *str;
      if (!isspace (c))
	{
	  int dig;

	  for (j = 0; j < pointlen; j++)
	    if (str[j] != point[j])
	      goto not_point;
	  if (1)
	    {
	      if (dotpos != 0)
		{
		  /* already saw a decimal point, another is invalid */
		  TMP_FREE;
		  return -1;
		}
	      dotpos = s;
	      str += pointlen - 1;
	      i += pointlen - 1;
	    }
	  else
	    {
	    not_point:
	      dig = digit_value[c];
	      if (dig >= base)
		{
		  TMP_FREE;
		  return -1;
		}
	      *s++ = dig;
	    }
	}
      c = (unsigned char) *++str;
    }

  str_size = s - begs;

  {
    long exp_in_base;
    mp_size_t ra, ma, rn, mn;
    int cnt;
    mp_ptr mp, tp, rp;
    mp_exp_t exp_in_limbs;
    mp_size_t prec = PREC(x) + 1;
    int divflag;
    mp_size_t madj, radj;

#if 0
    size_t n_chars_needed;

    /* This breaks things like 0.000...0001.  To safely ignore superfluous
       digits, we need to skip over leading zeros.  */
    /* Just consider the relevant leading digits of the mantissa.  */
    LIMBS_PER_DIGIT_IN_BASE (n_chars_needed, prec, base);
    if (str_size > n_chars_needed)
      str_size = n_chars_needed;
#endif

    LIMBS_PER_DIGIT_IN_BASE (ma, str_size, base);
    mp = TMP_ALLOC_LIMBS (ma);
    mn = mpn_set_str (mp, (unsigned char *) begs, str_size, base);

    if (mn == 0)
      {
	SIZ(x) = 0;
	EXP(x) = 0;
	TMP_FREE;
	return 0;
      }

    madj = 0;
    /* Ignore excess limbs in MP,MSIZE.  */
    if (mn > prec)
      {
	madj = mn - prec;
	mp += mn - prec;
	mn = prec;
      }

    if (expptr != 0)
      {
	/* Scan and convert the exponent, in base exp_base.  */
	long dig, minus, plusminus;
	c = (unsigned char) *expptr;
	minus = -(long) (c == '-');
	plusminus = minus | -(long) (c == '+');
	expptr -= plusminus;			/* conditional increment */
	c = (unsigned char) *expptr++;
	dig = digit_value[c];
	if (dig >= exp_base)
	  {
	    TMP_FREE;
	    return -1;
	  }
	exp_in_base = dig;
	c = (unsigned char) *expptr++;
	dig = digit_value[c];
	while (dig < exp_base)
	  {
	    exp_in_base = exp_in_base * exp_base;
	    exp_in_base += dig;
	    c = (unsigned char) *expptr++;
	    dig = digit_value[c];
	  }
	exp_in_base = (exp_in_base ^ minus) - minus; /* conditional negation */
      }
    else
      exp_in_base = 0;
    if (dotpos != 0)
      exp_in_base -= s - dotpos;
    divflag = exp_in_base < 0;
    exp_in_base = ABS (exp_in_base);

    if (exp_in_base == 0)
      {
	MPN_COPY (PTR(x), mp, mn);
	SIZ(x) = negative ? -mn : mn;
	EXP(x) = mn + madj;
	TMP_FREE;
	return 0;
      }

    ra = 2 * (prec + 1);
    rp = TMP_ALLOC_LIMBS (ra);
    tp = TMP_ALLOC_LIMBS (ra);
    rn = mpn_pow_1_highpart (rp, &radj, (mp_limb_t) base, exp_in_base, prec, tp);

    if (divflag)
      {
#if 0
	/* FIXME: Should use mpn_div_q here.  */
	...
	mpn_div_q (tp, mp, mn, rp, rn, scratch);
	...
#else
	mp_ptr qp;
	mp_limb_t qlimb;
	if (mn < rn)
	  {
	    /* Pad out MP,MSIZE for current divrem semantics.  */
	    mp_ptr tmp = TMP_ALLOC_LIMBS (rn + 1);
	    MPN_ZERO (tmp, rn - mn);
	    MPN_COPY (tmp + rn - mn, mp, mn);
	    mp = tmp;
	    madj -= rn - mn;
	    mn = rn;
	  }
	if ((rp[rn - 1] & GMP_NUMB_HIGHBIT) == 0)
	  {
	    mp_limb_t cy;
	    count_leading_zeros (cnt, rp[rn - 1]);
	    cnt -= GMP_NAIL_BITS;
	    mpn_lshift (rp, rp, rn, cnt);
	    cy = mpn_lshift (mp, mp, mn, cnt);
	    if (cy)
	      mp[mn++] = cy;
	  }

	qp = TMP_ALLOC_LIMBS (prec + 1);
	qlimb = mpn_divrem (qp, prec - (mn - rn), mp, mn, rp, rn);
	tp = qp;
	exp_in_limbs = qlimb + (mn - rn) + (madj - radj);
	rn = prec;
	if (qlimb != 0)
	  {
	    tp[prec] = qlimb;
	    /* Skip the least significant limb not to overrun the destination
	       variable.  */
	    tp++;
	  }
#endif
      }
    else
      {
	tp = TMP_ALLOC_LIMBS (rn + mn);
	if (rn > mn)
	  mpn_mul (tp, rp, rn, mp, mn);
	else
	  mpn_mul (tp, mp, mn, rp, rn);
	rn += mn;
	rn -= tp[rn - 1] == 0;
	exp_in_limbs = rn + madj + radj;

	if (rn > prec)
	  {
	    tp += rn - prec;
	    rn = prec;
	    exp_in_limbs += 0;
	  }
      }

    MPN_COPY (PTR(x), tp, rn);
    SIZ(x) = negative ? -rn : rn;
    EXP(x) = exp_in_limbs;
    TMP_FREE;
    return 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, -0x88(%rbp)
movl $0x10000, %edi          # imm = 0x10000
callq 0x6230
movq %rax, -0x30(%rbp)
movq %rax, %rdi
callq 0x6120
movq %rax, %r13
callq 0x62b0
movq %rax, %r9
movq (%rax), %rax
movzbl (%r15), %r14d
incq %r15
testb $0x20, 0x1(%rax,%r14,2)
jne 0x19e94
cmpb $0x2d, %r14b
jne 0x19eae
movb (%r15), %cl
jmp 0x19eb4
decq %r15
movl %r14d, %ecx
movq -0x30(%rbp), %rdi
testl %ebx, %ebx
movl $0xa, %esi
cmovel %esi, %ebx
testl %ebx, %ebx
cmovnsl %ebx, %esi
movl %ebx, %r8d
negl %r8d
cmovsl %ebx, %r8d
cmpl $0x25, %r8d
jb 0x19ef4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x3e, %r8d
ja 0x1a5cc
movl $0xd0, %edx
addq 0x2e0c6(%rip), %rdx     # 0x47fb8
jmp 0x19efb
leaq 0x20bd5(%rip), %rdx     # 0x3aad0
movzbl %cl, %eax
movzbl (%rdx,%rax), %eax
cmpl %eax, %r8d
ja 0x19f3a
testq %r13, %r13
je 0x19f23
xorl %eax, %eax
movb (%r15,%rax), %cl
cmpb (%rdi,%rax), %cl
jne 0x1a088
incq %rax
cmpq %rax, %r13
jne 0x19f0e
movzbl (%r15,%r13), %eax
movzbl (%rdx,%rax), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %r8d
jbe 0x1a5cc
movq %r9, -0x48(%rbp)
movl %esi, -0x70(%rbp)
movq %rdx, -0x38(%rbp)
movq %r15, %rdi
movl %r8d, -0x50(%rbp)
callq 0x6120
movl -0x50(%rbp), %ecx
leaq (%r15,%rax), %rdx
movl $0x1, %edi
movq %rax, %rbx
subq %rdi, %rbx
je 0x19f8a
movq %rdx, %r9
movb -0x1(%rdx), %sil
cmpb $0x40, %sil
je 0x19f90
leaq -0x1(%r9), %rdx
incq %rdi
cmpl $0xa, %ecx
ja 0x19f5d
andb $-0x21, %sil
cmpb $0x45, %sil
jne 0x19f5d
jmp 0x19f90
xorl %r9d, %r9d
movq %rax, %rbx
movq $0x0, -0x40(%rbp)
leaq 0x1(%rbx), %rsi
cmpq $0x7f00, %rsi           # imm = 0x7F00
movq -0x38(%rbp), %r8
movq -0x30(%rbp), %r10
movq -0x48(%rbp), %r11
ja 0x1a5db
movq %rsp, %rax
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %rax
movq %rax, %rsp
testq %rbx, %rbx
movq %rax, -0x78(%rbp)
je 0x1a092
leaq -0x1(%r13), %rdx
movq %rdx, -0x90(%rbp)
xorl %r12d, %r12d
movq %rax, -0x60(%rbp)
movq $0x0, -0x58(%rbp)
movzbl (%r15), %eax
movq (%r11), %rdx
testb $0x20, 0x1(%rdx,%rax,2)
jne 0x1a05d
testq %r13, %r13
je 0x1a014
xorl %esi, %esi
movb (%r15,%rsi), %dl
cmpb (%r10,%rsi), %dl
jne 0x1a034
incq %rsi
cmpq %rsi, %r13
jne 0x1a002
cmpq $0x0, -0x58(%rbp)
jne 0x1a04e
movq -0x90(%rbp), %rax
addq %rax, %r15
addq %rax, %r12
movb $0x1, %al
movq -0x60(%rbp), %rdx
movq %rdx, -0x58(%rbp)
jmp 0x1a059
movzbl (%r8,%rax), %eax
cmpl %eax, %ecx
jbe 0x1a04e
movq -0x60(%rbp), %rdx
movb %al, (%rdx)
incq %rdx
movq %rdx, -0x60(%rbp)
movb $0x1, %al
jmp 0x1a059
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
jne 0x1a06a
xorl %eax, %eax
testb %al, %al
je 0x1a088
incq %r15
incq %r12
cmpq %rbx, %r12
jb 0x19fed
jmp 0x1a09e
movq %r9, -0x68(%rbp)
callq 0x301a3
movq -0x48(%rbp), %r11
movq -0x30(%rbp), %r10
movl -0x50(%rbp), %ecx
movq -0x68(%rbp), %r9
movq -0x38(%rbp), %r8
jmp 0x1a057
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1a5cc
movq $0x0, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movq %r9, -0x68(%rbp)
movq -0x60(%rbp), %r12
subq -0x78(%rbp), %r12
movq -0x88(%rbp), %rax
movl (%rax), %ebx
movl %ecx, %eax
movq %rax, -0x90(%rbp)
leaq (%rax,%rax,4), %rax
leaq 0x1e069(%rip), %rdx     # 0x38130
movq 0x10(%rdx,%rax,8), %rax
movq %r12, -0xb0(%rbp)
mulq -0xb0(%rbp)
movabsq $0x1ffffffffffffff8, %rax # imm = 0x1FFFFFFFFFFFFFF8
andq %rdx, %rax
leaq 0x10(%rax), %rsi
cmpq $0x7ef0, %rax           # imm = 0x7EF0
ja 0x1a5fe
movq %rsp, %r15
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %r15
movq %r15, %rsp
movq %r15, %rdi
movq -0x78(%rbp), %rsi
movq %r12, %rdx
callq 0x1e9c4
testq %rax, %rax
je 0x1a1ac
movq %rax, %r10
incl %ebx
movslq %ebx, %r8
xorl %ecx, %ecx
movq %rax, %r13
subq %r8, %r13
movq %r8, %rdx
cmovlq %rax, %rdx
cmovleq %rcx, %r13
movq -0x68(%rbp), %r9
testq %r9, %r9
movq -0x38(%rbp), %rdi
movl -0x70(%rbp), %esi
je 0x1a1e2
movb (%r9), %al
leal -0x2b(%rax), %ecx
andb $-0x3, %cl
cmpb $0x1, %cl
adcq $0x0, %r9
movzbl (%r9), %ecx
movzbl (%rdi,%rcx), %ebx
movl %esi, %r12d
cmpq %r12, %rbx
jae 0x1a1c7
movzbl 0x1(%r9), %ecx
movzbl (%rdi,%rcx), %ecx
movq %rbx, %rsi
cmpq %r12, %rcx
jae 0x1a19e
addq $0x2, %r9
movq %rbx, %rsi
imulq %r12, %rsi
addq %rcx, %rsi
movzbl (%r9), %ecx
incq %r9
movzbl (%rdi,%rcx), %ecx
cmpq %r12, %rcx
jb 0x1a187
movq %rsi, %rcx
negq %rcx
cmpb $0x2d, %al
cmovneq %rsi, %rcx
jmp 0x1a1d4
movq -0x88(%rbp), %rax
movl $0x0, 0x4(%rax)
movq $0x0, 0x8(%rax)
jmp 0x1a5c1
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
jne 0x1a659
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %r12d, %ebx
jae 0x1a5cc
leaq (%r15,%r13,8), %rsi
movq -0x58(%rbp), %rax
movq %rax, %rdi
subq -0x60(%rbp), %rdi
testq %rax, %rax
cmoveq %rax, %rdi
addq %rcx, %rdi
movq %rdi, %rax
negq %rax
cmovsq %rdi, %rax
movq %rax, -0x78(%rbp)
jae 0x1a345
movq %rdi, -0x68(%rbp)
leaq 0x1(%r8), %rbx
movq %rbx, -0x98(%rbp)
shlq $0x4, %rbx
cmpq $0x7f00, %rbx           # imm = 0x7F00
movq %rsi, -0x70(%rbp)
movq %r10, -0x80(%rbp)
ja 0x1a619
movq %rsp, %rcx
leaq 0xf(%rbx), %rax
andq $-0x10, %rax
subq %rax, %rcx
movq %rcx, %rsp
cmpq $0x7f00, %rbx           # imm = 0x7F00
movq %r8, -0x30(%rbp)
ja 0x1a639
movq %rsp, %rsi
addq $0xf, %rbx
andq $-0x10, %rbx
subq %rbx, %rsi
movq %rsi, %rsp
movq %r13, -0x50(%rbp)
movq -0x90(%rbp), %rax
movq %rax, (%rcx)
movq -0x78(%rbp), %rax
movq %rax, -0xa8(%rbp)
bsrq -0xa8(%rbp), %rax
xorl $-0x40, %eax
addl $0x3f, %eax
movq %rdx, -0x48(%rbp)
movq %rcx, -0x38(%rbp)
js 0x1a374
movl %eax, %r13d
movl $0x1, %ebx
xorl %edi, %edi
xorl %eax, %eax
movq %rdi, -0x58(%rbp)
movq %rsi, %r12
movq %rcx, -0x60(%rbp)
leaq (%rcx,%rax,8), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x1da3c
leaq (%rbx,%rbx), %r15
shlq $0x4, %rbx
cmpq $0x1, -0x8(%rbx,%r12)
sbbq $0x0, %r15
movq %r15, %rbx
movq -0x30(%rbp), %rax
subq %rax, %rbx
cmovgeq %rax, %r15
movl $0x0, %eax
cmovleq %rax, %rbx
movq -0x78(%rbp), %rax
btq %r13, %rax
jae 0x1a31e
leaq (%r12,%rbx,8), %rsi
movq %r12, %rdi
movq %r15, %rdx
movq -0x90(%rbp), %rcx
callq 0x1c386
movq %rax, (%r12,%r15,8)
cmpq $0x1, %rax
sbbq $-0x1, %r15
xorl %eax, %eax
jmp 0x1a321
movq %rbx, %rax
movq -0x58(%rbp), %rdi
leaq (%rbx,%rdi,2), %rdi
leaq -0x1(%r13), %rdx
movq %r12, %rcx
movq %r15, %rbx
testq %r13, %r13
movq %rdx, %r13
movq -0x60(%rbp), %rsi
jg 0x1a2ab
jmp 0x1a381
movq -0x88(%rbp), %rbx
movq 0x10(%rbx), %rdi
movq %rdx, %r15
callq 0x2f4c6
movl %r15d, %eax
negl %eax
cmpb $0x2d, %r14b
cmovnel %r15d, %eax
movl %eax, 0x4(%rbx)
addq %r15, %r13
movq %r13, 0x8(%rbx)
jmp 0x1a5c1
xorl %eax, %eax
movl $0x1, %r15d
xorl %edi, %edi
movq %rcx, %r12
xorl %ecx, %ecx
movq %r15, %rdx
movq -0x30(%rbp), %rsi
subq %rsi, %rdx
cmovgeq %rsi, %r15
cmovgq %rdx, %rcx
addq %rcx, %rdi
movq %rdi, -0x58(%rbp)
leaq (%r12,%rcx,8), %rcx
leaq (%rcx,%rax,8), %rsi
movq -0x38(%rbp), %rdi
movq %r15, %rdx
callq 0x2f4c6
cmpq $0x0, -0x68(%rbp)
js 0x1a40c
movq -0x48(%rbp), %r8
leaq (%r15,%r8), %r12
leaq (,%r12,8), %rsi
cmpq $0x7f00, %rsi           # imm = 0x7F00
movq -0x50(%rbp), %r13
movq -0x80(%rbp), %rdx
ja 0x1a67b
movq %rsp, %rbx
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %rbx
movq %rbx, %rsp
movq -0x38(%rbp), %rcx
movq %rbx, %rdi
cmpq %r15, %rdx
jge 0x1a48d
movq %rcx, %rsi
movq %r15, %rdx
movq -0x70(%rbp), %rcx
jmp 0x1a497
cmpq %r15, -0x80(%rbp)
movq -0x48(%rbp), %r9
jge 0x1a4ca
leaq 0x8(,%r15,8), %rsi
cmpq $0x7f00, %rsi           # imm = 0x7F00
ja 0x1a6b7
movq %rsp, %r13
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %r13
movq %r13, %rsp
movq %r9, %rbx
subq %r15, %rbx
je 0x1a462
movq %r15, %rdx
subq %r9, %rdx
shlq $0x3, %rdx
movq %r13, %rdi
xorl %esi, %esi
movq %r9, %r12
callq 0x6170
movq %r12, %r9
leaq (,%r15,8), %rdi
addq %r13, %rdi
leaq (,%r9,8), %rax
subq %rax, %rdi
movq -0x70(%rbp), %rsi
movq %r9, %rdx
callq 0x2f4c6
addq %rbx, -0x50(%rbp)
movq %r15, %r9
jmp 0x1a4ce
movq -0x70(%rbp), %rsi
movq %r8, %rdx
movq %r15, %r8
callq 0x1cd58
cmpq $0x1, -0x8(%rbx,%r12,8)
sbbq $0x0, %r12
addq -0x58(%rbp), %r13
addq %r12, %r13
movq %r12, %rax
movq -0x30(%rbp), %rdx
subq %rdx, %rax
jle 0x1a4c2
leaq (%rbx,%rax,8), %rbx
jmp 0x1a598
movq %r12, %rdx
jmp 0x1a598
movq -0x70(%rbp), %r13
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x8(%r8,%r15,8), %rax
testq %rax, %rax
js 0x1a52d
movq %rax, -0xa0(%rbp)
bsrq -0xa0(%rbp), %rbx
xorl $0x3f, %ebx
movq %r8, %rdi
movq %r8, %rsi
movq %r15, %rdx
movl %ebx, %ecx
movq %r9, %r12
callq 0x1c4a0
movq %r13, %rdi
movq %r13, %rsi
movq %r12, %rdx
movl %ebx, %ecx
callq 0x1c4a0
testq %rax, %rax
je 0x1a522
movq %rax, (%r13,%r12,8)
incq %r12
movq -0x30(%rbp), %rcx
movq %r12, %r9
movq -0x38(%rbp), %r8
movq -0x98(%rbp), %rsi
shlq $0x3, %rsi
cmpq $0x7f00, %rsi           # imm = 0x7F00
ja 0x1a696
movq %rsp, %rbx
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %rbx
movq %rbx, %rsp
movq %r9, %r12
subq %r15, %r12
movq %rcx, %rsi
subq %r12, %rsi
movq %rbx, %rdi
movq %r13, %rdx
movq %r9, %rcx
movq %r15, %r9
callq 0x1c6b0
movq -0x50(%rbp), %r13
subq -0x58(%rbp), %r13
addq %r12, %r13
addq %rax, %r13
testq %rax, %rax
je 0x1a594
movq -0x30(%rbp), %rdx
movq %rax, (%rbx,%rdx,8)
addq $0x8, %rbx
jmp 0x1a598
movq -0x30(%rbp), %rdx
movq -0x88(%rbp), %r15
movq 0x10(%r15), %rdi
movq %rbx, %rsi
movq %rdx, %rbx
callq 0x2f4c6
movl %ebx, %eax
negl %eax
cmpb $0x2d, %r14b
cmovnel %ebx, %eax
movl %eax, 0x4(%r15)
movq %r13, 0x8(%r15)
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
jne 0x1a612
xorl %eax, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x40(%rbp), %rdi
movq %r9, %r12
callq 0x30170
movq -0x48(%rbp), %r11
movq -0x30(%rbp), %r10
movl -0x50(%rbp), %ecx
movq %r12, %r9
movq -0x38(%rbp), %r8
jmp 0x19fc6
leaq -0x40(%rbp), %rdi
callq 0x30170
movl -0x50(%rbp), %ecx
movq %rax, %r15
jmp 0x1a108
callq 0x301a3
jmp 0x1a5ca
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
movq %r8, %r15
movq %rdx, %r12
callq 0x30170
movq %r12, %rdx
movq %r15, %r8
movq %rax, %rcx
jmp 0x1a248
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
movq %rdx, %r15
movq %rcx, %r12
callq 0x30170
movq %r12, %rcx
movq %r15, %rdx
movq %rax, %rsi
jmp 0x1a26a
movq %r8, -0x30(%rbp)
movq %rdx, -0x48(%rbp)
movq %r10, -0x80(%rbp)
callq 0x301a3
movq -0x80(%rbp), %r10
movq -0x48(%rbp), %rdx
movq -0x30(%rbp), %r8
jmp 0x1a1d4
leaq -0x40(%rbp), %rdi
movq %rdx, %rbx
callq 0x30170
movq %rbx, %rdx
movq -0x48(%rbp), %r8
movq %rax, %rbx
jmp 0x1a3ed
leaq -0x40(%rbp), %rdi
movq %r9, %rbx
movq %r8, %r12
callq 0x30170
movq %r12, %r8
movq %rbx, %r9
movq -0x30(%rbp), %rcx
movq %rax, %rbx
jmp 0x1a556
leaq -0x40(%rbp), %rdi
movq %r9, %rbx
callq 0x30170
movq %rbx, %r9
movq %rax, %r13
jmp 0x1a440
nop