#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ alpha;

/* Variables and functions */
int Ndrgtb(double, int);
double floor(double);
double log(double);
scalar_t__ log10(double);
double pow(double, double);
char *Nfmtb(double n, int b, char *t, int wth, int d, char *s) {
  register int si, i;
  int sign, blnk, comma, left, paren, zfill, nd, dol, tw, dl, ez, ucase,
      cf = 3, w = wth, percent;
  double base;
  static char alpha[] = "0123456789abcdefghijklmnopqrstuvwxyz";
  if (b < 2 || b > (int)(sizeof(alpha) - 1))
    b = 10;
  base = b;
  if (sign = n < 0.0)
    n = -n;
  if (d >= 0) {
    double r = pow(base, (double)d);
    n = floor(.5 + n * r) / r;
  }
  switch (b) {
  case 10:
    cf = 3;
    dl = n < 1.0 ? 0 : 1 + (int)log10(n);
    break;
  case 2:
    cf = 4;
    dl = n < 1.0 ? 0 : 1 + (int)(log(n) / .6931471806);
    break;
  case 8:
    cf = 3;
    dl = n < 1.0 ? 0 : 1 + (int)(log(n) / 2.079441542);
    break;
  case 16:
    cf = 4;
    dl = n < 1.0 ? 0 : 1 + (int)(log(n) / 2.772588722);
    break;
  default:
    cf = 3;
    dl = n < 1.0 ? 0 : 1 + (int)(log(n) / log(base));
    break;
  }
  if (d < 0)
    d = Ndrgtb(n, b);
  blnk = comma = left = paren = zfill = dol = ucase = percent = 0;
  if (t)
    while (*t)
      switch (*t++) {
      case 'B':
        blnk = 1;
        break;
      case 'C':
        comma = (dl - 1) / cf;
        break;
      case 'L':
        left = 1;
        break;
      case 'P':
        paren = 1;
        break;
      case 'Z':
        zfill = 1;
        break;
      case 'D':
        dol = 1;
        break;
      case 'U':
        ucase = 1;
        break;
      case 'R':
        percent = 1;
        break;
      }
  ez = n < 1.0;
  tw = dol + paren + comma + sign + dl + d + !!d + ez + percent;
  if (w < 1)
    w = tw;
  else if (tw > w) {
    if (ez)
      tw -= ez--;
    if ((i = dol) && tw > w)
      tw -= dol--;
    if (tw > w && comma) {
      tw -= comma;
      comma = 0;
    }
    if (tw < w && i) {
      tw++;
      dol = 1;
    }
    if (tw > w && paren)
      tw -= paren--;
    if (tw > w && percent)
      tw -= percent--;
    if (tw > w) {
    nofit:
      for (i = 0; i < w;)
        s[i++] = '*';
      s[i] = '\0';
      return (s);
    }
  }
  n = floor(.5 + n * floor(.5 + pow(base, (double)d)));
  if (blnk && n == 0.0) {
    for (i = 0; i < wth;)
      s[i++] = ' ';
    s[wth] = '\0';
    return (s);
  }
  s[si = w] = '\0';
  if (left && w > tw) {
    i = w - tw;
    while (i--)
      s[--si] = ' ';
  }
  if (paren)
    s[--si] = sign ? ')' : ' ';
  if (percent)
    s[--si] = '%';
  for (nd = 0; nd < d && si; nd++) {
    n /= base;
    i = (int)floor(base * (n - floor(n)) + .5);
    n = floor(n);
    s[--si] = ucase && i > 9 ? alpha[i] + ('A' - 'a') : alpha[i];
  }
  if (d)
    if (si)
      s[--si] = '.';
    else
      n = 1.0;
  if (ez && si > sign + dol)
    s[--si] = '0';
  nd = 0;
  while (n > 0.0 && si)
    if (comma && nd == cf) {
      s[--si] = ',';
      nd = 0;
    } else {
      n /= base;
      i = (int)floor(base * (n - floor(n)) + .5);
      n = floor(n);
      s[--si] = ucase && i > 9 ? alpha[i] + ('A' - 'a') : alpha[i];
      nd++;
    }
  if (zfill) {
    i = sign + dol;
    while (si > i)
      s[--si] = '0';
  }
  if (dol && si)
    s[--si] = '$';
  if (sign)
    if (si)
      s[--si] = paren ? '(' : '-';
    else
      n = 1.0;
  while (si)
    s[--si] = ' ';
  if (n != 0.0)
    goto nofit;
  return (s);
}


x86 assembly (clang, -O0):
<Nfmtb>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
movsd  %xmm0,-0x10(%rbp)
mov    %edi,-0x14(%rbp)
mov    %rsi,-0x20(%rbp)
mov    %edx,-0x24(%rbp)
mov    %ecx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
movl   $0x3,-0x6c(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x70(%rbp)
cmpl   $0x2,-0x14(%rbp)
jl     1192 <Nfmtb+0x42>
cmpl   $0x24,-0x14(%rbp)
jle    1199 <Nfmtb+0x49>
movl   $0xa,-0x14(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x10(%rbp),%xmm0
seta   %al
mov    %al,%cl
and    $0x1,%cl
movzbl %cl,%ecx
mov    %ecx,-0x3c(%rbp)
test   $0x1,%al
jne    11c6 <Nfmtb+0x76>
jmp    11e7 <Nfmtb+0x97>
movsd  -0x10(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x10(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1237 <Nfmtb+0xe7>
movsd  -0x80(%rbp),%xmm0
cvtsi2sdl -0x28(%rbp),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  0xddf(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1070 <floor@plt>
divsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x10(%rbp)
mov    -0x14(%rbp),%eax
add    $0xfffffffe,%eax
mov    %eax,%ecx
mov    %rcx,-0x90(%rbp)
sub    $0xe,%eax
ja     13b6 <Nfmtb+0x266>
mov    -0x90(%rbp),%rax
lea    0xdcb(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x3,-0x6c(%rbp)
movsd  0xd93(%rip),%xmm0
ucomisd -0x10(%rbp),%xmm0
jbe    128d <Nfmtb+0x13d>
xor    %eax,%eax
mov    %eax,-0x94(%rbp)
jmp    12a0 <Nfmtb+0x150>
movsd  -0x10(%rbp),%xmm0
call   1060 <log10@plt>
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    %eax,-0x60(%rbp)
jmp    141e <Nfmtb+0x2ce>
movl   $0x4,-0x6c(%rbp)
movsd  0xd4b(%rip),%xmm0
ucomisd -0x10(%rbp),%xmm0
jbe    12d5 <Nfmtb+0x185>
xor    %eax,%eax
mov    %eax,-0x98(%rbp)
jmp    12f8 <Nfmtb+0x1a8>
movsd  -0x10(%rbp),%xmm0
call   1040 <log@plt>
movsd  0xd39(%rip),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    %eax,-0x60(%rbp)
jmp    141e <Nfmtb+0x2ce>
movl   $0x3,-0x6c(%rbp)
movsd  0xcf3(%rip),%xmm0
ucomisd -0x10(%rbp),%xmm0
jbe    132d <Nfmtb+0x1dd>
xor    %eax,%eax
mov    %eax,-0x9c(%rbp)
jmp    1350 <Nfmtb+0x200>
movsd  -0x10(%rbp),%xmm0
call   1040 <log@plt>
movsd  0xcd9(%rip),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
mov    %eax,-0x60(%rbp)
jmp    141e <Nfmtb+0x2ce>
movl   $0x4,-0x6c(%rbp)
movsd  0xc9b(%rip),%xmm0
ucomisd -0x10(%rbp),%xmm0
jbe    1385 <Nfmtb+0x235>
xor    %eax,%eax
mov    %eax,-0xa0(%rbp)
jmp    13a8 <Nfmtb+0x258>
movsd  -0x10(%rbp),%xmm0
call   1040 <log@plt>
movsd  0xc79(%rip),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
mov    %eax,-0x60(%rbp)
jmp    141e <Nfmtb+0x2ce>
movl   $0x3,-0x6c(%rbp)
movsd  0xc43(%rip),%xmm0
ucomisd -0x10(%rbp),%xmm0
jbe    13dd <Nfmtb+0x28d>
xor    %eax,%eax
mov    %eax,-0xa4(%rbp)
jmp    1415 <Nfmtb+0x2c5>
movsd  -0x10(%rbp),%xmm0
call   1040 <log@plt>
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
call   1040 <log@plt>
movaps %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
mov    %eax,-0x60(%rbp)
cmpl   $0x0,-0x28(%rbp)
jge    1438 <Nfmtb+0x2e8>
movsd  -0x10(%rbp),%xmm0
mov    -0x14(%rbp),%edi
call   1030 <Ndrgtb@plt>
mov    %eax,-0x28(%rbp)
movl   $0x0,-0x74(%rbp)
movl   $0x0,-0x68(%rbp)
movl   $0x0,-0x58(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0x40(%rbp)
cmpq   $0x0,-0x20(%rbp)
je     1536 <Nfmtb+0x3e6>
jmp    1480 <Nfmtb+0x330>
mov    -0x20(%rbp),%rax
cmpb   $0x0,(%rax)
je     1531 <Nfmtb+0x3e1>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movsbl (%rax),%eax
add    $0xffffffbe,%eax
mov    %eax,%ecx
mov    %rcx,-0xb8(%rbp)
sub    $0x18,%eax
ja     152c <Nfmtb+0x3dc>
mov    -0xb8(%rbp),%rax
lea    0xba2(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x1,-0x40(%rbp)
jmp    152c <Nfmtb+0x3dc>
mov    -0x60(%rbp),%eax
sub    $0x1,%eax
cltd
idivl  -0x6c(%rbp)
mov    %eax,-0x44(%rbp)
jmp    152c <Nfmtb+0x3dc>
movl   $0x1,-0x48(%rbp)
jmp    152c <Nfmtb+0x3dc>
movl   $0x1,-0x4c(%rbp)
jmp    152c <Nfmtb+0x3dc>
movl   $0x1,-0x50(%rbp)
jmp    152c <Nfmtb+0x3dc>
movl   $0x1,-0x58(%rbp)
jmp    152c <Nfmtb+0x3dc>
movl   $0x1,-0x68(%rbp)
jmp    152c <Nfmtb+0x3dc>
movl   $0x1,-0x74(%rbp)
jmp    1480 <Nfmtb+0x330>
jmp    1536 <Nfmtb+0x3e6>
movsd  0xaca(%rip),%xmm0
ucomisd -0x10(%rbp),%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x64(%rbp)
mov    -0x58(%rbp),%eax
add    -0x4c(%rbp),%eax
add    -0x44(%rbp),%eax
add    -0x3c(%rbp),%eax
add    -0x60(%rbp),%eax
add    -0x28(%rbp),%eax
cmpl   $0x0,-0x28(%rbp)
setne  %cl
xor    $0xff,%cl
xor    $0xff,%cl
and    $0x1,%cl
movzbl %cl,%ecx
add    %ecx,%eax
add    -0x64(%rbp),%eax
add    -0x74(%rbp),%eax
mov    %eax,-0x5c(%rbp)
cmpl   $0x1,-0x70(%rbp)
jge    1593 <Nfmtb+0x443>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x70(%rbp)
jmp    16ec <Nfmtb+0x59c>
mov    -0x5c(%rbp),%eax
cmp    -0x70(%rbp),%eax
jle    16e7 <Nfmtb+0x597>
cmpl   $0x0,-0x64(%rbp)
je     15bc <Nfmtb+0x46c>
mov    -0x64(%rbp),%ecx
mov    %ecx,%eax
add    $0xffffffff,%eax
mov    %eax,-0x64(%rbp)
mov    -0x5c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x38(%rbp)
cmp    $0x0,%eax
je     15ea <Nfmtb+0x49a>
mov    -0x5c(%rbp),%eax
cmp    -0x70(%rbp),%eax
jle    15ea <Nfmtb+0x49a>
mov    -0x58(%rbp),%ecx
mov    %ecx,%eax
add    $0xffffffff,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x70(%rbp),%eax
jle    1612 <Nfmtb+0x4c2>
cmpl   $0x0,-0x44(%rbp)
je     1612 <Nfmtb+0x4c2>
mov    -0x44(%rbp),%ecx
mov    -0x5c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x5c(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    1638 <Nfmtb+0x4e8>
cmpl   $0x0,-0x38(%rbp)
je     1638 <Nfmtb+0x4e8>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
movl   $0x1,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x70(%rbp),%eax
jle    1661 <Nfmtb+0x511>
cmpl   $0x0,-0x4c(%rbp)
je     1661 <Nfmtb+0x511>
mov    -0x4c(%rbp),%ecx
mov    %ecx,%eax
add    $0xffffffff,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x5c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x70(%rbp),%eax
jle    168a <Nfmtb+0x53a>
cmpl   $0x0,-0x74(%rbp)
je     168a <Nfmtb+0x53a>
mov    -0x74(%rbp),%ecx
mov    %ecx,%eax
add    $0xffffffff,%eax
mov    %eax,-0x74(%rbp)
mov    -0x5c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x70(%rbp),%eax
jle    16e2 <Nfmtb+0x592>
jmp    169b <Nfmtb+0x54b>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    16c9 <Nfmtb+0x579>
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x38(%rbp)
movslq %ecx,%rcx
movb   $0x2a,(%rax,%rcx,1)
jmp    16a2 <Nfmtb+0x552>
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    1c56 <Nfmtb+0xb06>
jmp    16e7 <Nfmtb+0x597>
jmp    16ec <Nfmtb+0x59c>
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
cvtsi2sdl -0x28(%rbp),%xmm1
call   1050 <pow@plt>
movaps %xmm0,%xmm1
movsd  0x8ed(%rip),%xmm0
addsd  %xmm1,%xmm0
call   1070 <floor@plt>
movaps %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  0x8cd(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1070 <floor@plt>
movsd  %xmm0,-0x10(%rbp)
cmpl   $0x0,-0x40(%rbp)
je     17aa <Nfmtb+0x65a>
movsd  -0x10(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    17aa <Nfmtb+0x65a>
jp     17aa <Nfmtb+0x65a>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1791 <Nfmtb+0x641>
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x38(%rbp)
movslq %ecx,%rcx
movb   $0x20,(%rax,%rcx,1)
jmp    176a <Nfmtb+0x61a>
mov    -0x30(%rbp),%rax
movslq -0x24(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    1c56 <Nfmtb+0xb06>
mov    -0x30(%rbp),%rax
mov    -0x70(%rbp),%ecx
mov    %ecx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
cmpl   $0x0,-0x48(%rbp)
je     180c <Nfmtb+0x6bc>
mov    -0x70(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jle    180c <Nfmtb+0x6bc>
mov    -0x70(%rbp),%eax
sub    -0x5c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x38(%rbp)
cmp    $0x0,%eax
je     1807 <Nfmtb+0x6b7>
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0x20,(%rax,%rcx,1)
jmp    17da <Nfmtb+0x68a>
jmp    180c <Nfmtb+0x6bc>
cmpl   $0x0,-0x4c(%rbp)
je     183e <Nfmtb+0x6ee>
mov    -0x3c(%rbp),%edx
mov    $0x20,%eax
mov    $0x29,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x34(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
cmpl   $0x0,-0x74(%rbp)
je     185c <Nfmtb+0x70c>
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0x25,(%rax,%rcx,1)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0xc1(%rbp)
jge    1884 <Nfmtb+0x734>
cmpl   $0x0,-0x34(%rbp)
setne  %al
mov    %al,-0xc1(%rbp)
mov    -0xc1(%rbp),%al
test   $0x1,%al
jne    1897 <Nfmtb+0x747>
jmp    197f <Nfmtb+0x82f>
movsd  -0x80(%rbp),%xmm1
movsd  -0x10(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x10(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
call   1070 <floor@plt>
movsd  -0xd8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0xd0(%rbp),%xmm0
ff
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  0x70f(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1070 <floor@plt>
cvttsd2si %xmm0,%eax
mov    %eax,-0x38(%rbp)
movsd  -0x10(%rbp),%xmm0
call   1070 <floor@plt>
movsd  %xmm0,-0x10(%rbp)
cmpl   $0x0,-0x68(%rbp)
je     1941 <Nfmtb+0x7f1>
cmpl   $0x9,-0x38(%rbp)
jle    1941 <Nfmtb+0x7f1>
movslq -0x38(%rbp),%rcx
lea    0x2721(%rip),%rax
movsbl (%rax,%rcx,1),%eax
add    $0xffffffe0,%eax
mov    %eax,-0xdc(%rbp)
jmp    1956 <Nfmtb+0x806>
movslq -0x38(%rbp),%rcx
lea    0x2704(%rip),%rax
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0xdc(%rbp)
mov    -0xdc(%rbp),%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x34(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1863 <Nfmtb+0x713>
cmpl   $0x0,-0x28(%rbp)
je     19be <Nfmtb+0x86e>
cmpl   $0x0,-0x34(%rbp)
je     19ac <Nfmtb+0x85c>
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0x2e,(%rax,%rcx,1)
jmp    19b9 <Nfmtb+0x869>
movsd  0x654(%rip),%xmm0
movsd  %xmm0,-0x10(%rbp)
jmp    19be <Nfmtb+0x86e>
cmpl   $0x0,-0x64(%rbp)
je     19ed <Nfmtb+0x89d>
mov    -0x34(%rbp),%eax
mov    -0x3c(%rbp),%ecx
add    -0x58(%rbp),%ecx
cmp    %ecx,%eax
jle    19ed <Nfmtb+0x89d>
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0x30,(%rax,%rcx,1)
movl   $0x0,-0x54(%rbp)
movsd  -0x10(%rbp),%xmm0
xor    %eax,%eax
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
mov    %al,-0xdd(%rbp)
jbe    1a1b <Nfmtb+0x8cb>
cmpl   $0x0,-0x34(%rbp)
setne  %al
mov    %al,-0xdd(%rbp)
mov    -0xdd(%rbp),%al
test   $0x1,%al
jne    1a2e <Nfmtb+0x8de>
jmp    1b4c <Nfmtb+0x9fc>
cmpl   $0x0,-0x44(%rbp)
je     1a64 <Nfmtb+0x914>
mov    -0x54(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jne    1a64 <Nfmtb+0x914>
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0x2c,(%rax,%rcx,1)
movl   $0x0,-0x54(%rbp)
jmp    1b47 <Nfmtb+0x9f7>
movsd  -0x80(%rbp),%xmm1
movsd  -0x10(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x10(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
call   1070 <floor@plt>
movsd  -0xf0(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0xe8(%rbp),%xmm0
ff
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  0x542(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1070 <floor@plt>
cvttsd2si %xmm0,%eax
mov    %eax,-0x38(%rbp)
movsd  -0x10(%rbp),%xmm0
call   1070 <floor@plt>
movsd  %xmm0,-0x10(%rbp)
cmpl   $0x0,-0x68(%rbp)
je     1b0e <Nfmtb+0x9be>
cmpl   $0x9,-0x38(%rbp)
jle    1b0e <Nfmtb+0x9be>
movslq -0x38(%rbp),%rcx
lea    0x2554(%rip),%rax
movsbl (%rax,%rcx,1),%eax
add    $0xffffffe0,%eax
mov    %eax,-0xf4(%rbp)
jmp    1b23 <Nfmtb+0x9d3>
movslq -0x38(%rbp),%rcx
lea    0x2537(%rip),%rax
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0xf4(%rbp)
mov    -0xf4(%rbp),%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x34(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    19f4 <Nfmtb+0x8a4>
cmpl   $0x0,-0x50(%rbp)
je     1b89 <Nfmtb+0xa39>
mov    -0x3c(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jle    1b84 <Nfmtb+0xa34>
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0x30,(%rax,%rcx,1)
jmp    1b5f <Nfmtb+0xa0f>
jmp    1b89 <Nfmtb+0xa39>
cmpl   $0x0,-0x58(%rbp)
je     1bb1 <Nfmtb+0xa61>
cmpl   $0x0,-0x34(%rbp)
je     1bb1 <Nfmtb+0xa61>
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0x24,(%rax,%rcx,1)
cmpl   $0x0,-0x3c(%rbp)
je     1c04 <Nfmtb+0xab4>
cmpl   $0x0,-0x34(%rbp)
je     1bf2 <Nfmtb+0xaa2>
mov    -0x4c(%rbp),%edx
mov    $0x2d,%eax
mov    $0x28,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x34(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1bff <Nfmtb+0xaaf>
movsd  0x40e(%rip),%xmm0
movsd  %xmm0,-0x10(%rbp)
jmp    1c04 <Nfmtb+0xab4>
jmp    1c09 <Nfmtb+0xab9>
cmpl   $0x0,-0x34(%rbp)
je     1c2c <Nfmtb+0xadc>
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x34(%rbp)
movslq %ecx,%rcx
movb   $0x20,(%rax,%rcx,1)
jmp    1c09 <Nfmtb+0xab9>
movsd  -0x10(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1c49 <Nfmtb+0xaf9>
jp     1c49 <Nfmtb+0xaf9>
jmp    1c4e <Nfmtb+0xafe>
jmp    169b <Nfmtb+0x54b>
mov    -0x30(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Nfmtb>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r8,%r12
mov    %edx,0x8(%rsp)
mov    %rsi,%rbx
lea    -0x25(%rdi),%eax
cmp    $0xffffffdd,%eax
mov    $0xa,%r13d
cmovae %edi,%r13d
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
movapd %xmm0,%xmm1
seta   %r15b
ja     11a0 <Nfmtb+0x40>
movapd %xmm1,%xmm3
jmp    11ac <Nfmtb+0x4c>
movapd 0xe58(%rip),%xmm3
xorpd  %xmm1,%xmm3
xorps  %xmm0,%xmm0
cvtsi2sd %r13d,%xmm0
test   %ecx,%ecx
movapd %xmm1,0x60(%rsp)
movsd  %xmm0,0x10(%rsp)
js     1206 <Nfmtb+0xa6>
mov    %ecx,%r14d
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
movapd %xmm3,0x40(%rsp)
call   1060 <pow@plt>
movsd  %xmm0,0x28(%rsp)
movapd 0x40(%rsp),%xmm1
mulsd  %xmm0,%xmm1
addsd  0xe3f(%rip),%xmm1
movapd %xmm1,%xmm0
call   1080 <floor@plt>
movapd %xmm0,%xmm3
divsd  0x28(%rsp),%xmm3
jmp    1209 <Nfmtb+0xa9>
mov    %ecx,%r14d
lea    -0x2(%r13),%eax
ror    %eax
cmp    $0x7,%eax
movapd %xmm3,0x40(%rsp)
ja     1262 <Nfmtb+0x102>
lea    0xe37(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x4,0x18(%rsp)
xor    %ebp,%ebp
movsd  0xdfc(%rip),%xmm0
ucomisd %xmm3,%xmm0
ja     134d <Nfmtb+0x1ed>
movapd %xmm3,%xmm0
call   1050 <log@plt>
movapd 0x40(%rsp),%xmm3
divsd  0xdf3(%rip),%xmm0
jmp    1346 <Nfmtb+0x1e6>
movl   $0x3,0x18(%rsp)
xor    %ebp,%ebp
movsd  0xdc4(%rip),%xmm0
ucomisd %xmm3,%xmm0
ja     134d <Nfmtb+0x1ed>
movapd %xmm3,%xmm0
call   1050 <log@plt>
movsd  %xmm0,0x28(%rsp)
movsd  0x10(%rsp),%xmm0
call   1050 <log@plt>
movapd 0x40(%rsp),%xmm3
movsd  0x10(%rsp),%xmm2
movsd  0x28(%rsp),%xmm1
divsd  %xmm0,%xmm1
cvttsd2si %xmm1,%ebp
add    $0x1,%ebp
jmp    1353 <Nfmtb+0x1f3>
movl   $0x3,0x18(%rsp)
xor    %ebp,%ebp
movsd  0xd6c(%rip),%xmm0
ucomisd %xmm3,%xmm0
ja     134d <Nfmtb+0x1ed>
movapd %xmm3,%xmm0
call   1050 <log@plt>
movapd 0x40(%rsp),%xmm3
divsd  0xd5f(%rip),%xmm0
jmp    1346 <Nfmtb+0x1e6>
movl   $0x3,0x18(%rsp)
xor    %ebp,%ebp
movsd  0xd3b(%rip),%xmm0
ucomisd %xmm3,%xmm0
ja     134d <Nfmtb+0x1ed>
movapd %xmm3,%xmm0
call   1070 <log10@plt>
movapd 0x40(%rsp),%xmm3
mov    %rax,%rbp
jmp    134a <Nfmtb+0x1ea>
movl   $0x4,0x18(%rsp)
xor    %ebp,%ebp
movsd  0xd0f(%rip),%xmm0
ucomisd %xmm3,%xmm0
ja     134d <Nfmtb+0x1ed>
movapd %xmm3,%xmm0
call   1050 <log@plt>
movapd 0x40(%rsp),%xmm3
divsd  0xcfa(%rip),%xmm0
cvttsd2si %xmm0,%ebp
add    $0x1,%ebp
movsd  0x10(%rsp),%xmm2
mov    %r14d,%r10d
test   %r14d,%r14d
jns    1376 <Nfmtb+0x216>
movapd %xmm3,%xmm0
mov    %r13d,%edi
call   1040 <Ndrgtb@plt>
movapd 0x40(%rsp),%xmm3
movsd  0x10(%rsp),%xmm2
mov    %eax,%r10d
xor    %eax,%eax
mov    %r15b,%al
mov    %rax,%r15
xor    %r11d,%r11d
test   %rbx,%rbx
je     145c <Nfmtb+0x2fc>
mov    (%rbx),%dl
mov    $0x0,%eax
mov    $0x0,%r8d
mov    $0x0,%r13d
movl   $0x0,0x34(%rsp)
mov    $0x0,%r14d
movl   $0x0,0x28(%rsp)
mov    $0x0,%r9d
test   %dl,%dl
je     147a <Nfmtb+0x31a>
lea    -0x1(%rbp),%ecx
add    $0x1,%rbx
xor    %r9d,%r9d
lea    0xca6(%rip),%rsi
movl   $0x0,0x28(%rsp)
xor    %r14d,%r14d
movl   $0x0,0x34(%rsp)
xor    %r13d,%r13d
xor    %r8d,%r8d
xor    %eax,%eax
xor    %r11d,%r11d
jmp    140b <Nfmtb+0x2ab>
mov    $0x1,%r9d
nopl   0x0(%rax,%rax,1)
movzbl (%rbx),%edx
add    $0x1,%rbx
test   %dl,%dl
je     147a <Nfmtb+0x31a>
movsbl %dl,%edx
add    $0xffffffbe,%edx
cmp    $0x18,%edx
ja     1400 <Nfmtb+0x2a0>
movslq (%rsi,%rdx,4),%rdx
add    %rsi,%rdx
jmp    *%rdx
mov    $0x1,%r11d
jmp    1400 <Nfmtb+0x2a0>
mov    %ecx,%eax
cltd
idivl  0x18(%rsp)
jmp    1400 <Nfmtb+0x2a0>
mov    $0x1,%r14d
jmp    1400 <Nfmtb+0x2a0>
mov    $0x1,%r8d
jmp    1400 <Nfmtb+0x2a0>
mov    $0x1,%r13d
jmp    1400 <Nfmtb+0x2a0>
movl   $0x1,0x28(%rsp)
jmp    1400 <Nfmtb+0x2a0>
movl   $0x1,0x34(%rsp)
jmp    1400 <Nfmtb+0x2a0>
xor    %eax,%eax
xor    %r8d,%r8d
xor    %r13d,%r13d
movl   $0x0,0x34(%rsp)
xor    %r14d,%r14d
movl   $0x0,0x28(%rsp)
xor    %r9d,%r9d
movsd  0xbb6(%rip),%xmm0
xor    %edx,%edx
ucomisd %xmm3,%xmm0
seta   %dl
add    %edx,%ebp
add    %r15d,%ebp
add    %r10d,%ebp
cmp    $0x1,%r10d
sbb    $0xffffffff,%ebp
add    %eax,%ebp
add    %r13d,%ebp
add    %r14d,%ebp
add    %r9d,%ebp
mov    0x8(%rsp),%ebx
test   %ebx,%ebx
mov    %r15,0x58(%rsp)
mov    %r8d,0x20(%rsp)
mov    %r11d,%r15d
jle    1573 <Nfmtb+0x413>
cmp    %ebx,%ebp
jle    1585 <Nfmtb+0x425>
xor    %ecx,%ecx
ucomisd %xmm3,%xmm0
seta   %cl
sub    %ecx,%ebp
test   %r14d,%r14d
setne  %r8b
cmp    %ebx,%ebp
setg   %bl
setle  %dil
and    %r8b,%bl
movzbl %bl,%esi
sub    %esi,%ebp
cmp    0x8(%rsp),%ebp
setg   %bl
test   %eax,%eax
setne  %dl
xor    %r11d,%r11d
test   %dl,%bl
mov    %eax,%esi
cmovne %r11d,%esi
cmove  %r11d,%eax
sub    %eax,%ebp
cmp    0x8(%rsp),%ebp
setl   %al
and    %r8b,%al
movzbl %al,%edx
add    %ebp,%edx
cmp    0x8(%rsp),%edx
setg   %bl
test   %r13d,%r13d
setne  %cl
and    %bl,%cl
cmovne %r11d,%r13d
movzbl %cl,%ecx
sub    %ecx,%edx
cmp    0x8(%rsp),%edx
setg   %cl
test   %r9d,%r9d
setne  %bl
and    %cl,%bl
movzbl %bl,%ecx
mov    0x8(%rsp),%ebx
mov    %edx,%ebp
xor    %edx,%edx
sub    %ecx,%ebp
test   %cl,%cl
cmovne %edx,%r9d
cmp    %ebx,%ebp
jg     1b05 <Nfmtb+0x9a5>
xor    %ecx,%ecx
mov    %rcx,0x50(%rsp)
mov    %r9d,0x1c(%rsp)
mov    %esi,0x24(%rsp)
and    %dil,%r8b
or     %r8b,%al
movzbl %al,%r14d
jmp    1593 <Nfmtb+0x433>
mov    %rdx,0x50(%rsp)
mov    %r9d,0x1c(%rsp)
mov    %eax,0x24(%rsp)
mov    %ebp,%ebx
jmp    1593 <Nfmtb+0x433>
mov    %rdx,0x50(%rsp)
mov    %r9d,0x1c(%rsp)
mov    %eax,0x24(%rsp)
mov    %r10d,0x3c(%rsp)
xorps  %xmm1,%xmm1
cvtsi2sd %r10d,%xmm1
movapd %xmm2,%xmm0
call   1060 <pow@plt>
addsd  0xa7f(%rip),%xmm0
call   1080 <floor@plt>
mulsd  0x40(%rsp),%xmm0
addsd  0xa6c(%rip),%xmm0
call   1080 <floor@plt>
movapd %xmm0,%xmm3
test   %r15d,%r15d
je     15fd <Nfmtb+0x49d>
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm3
jne    15fd <Nfmtb+0x49d>
jp     15fd <Nfmtb+0x49d>
mov    0x8(%rsp),%ebx
test   %ebx,%ebx
jle    15f5 <Nfmtb+0x495>
mov    %ebx,%edx
mov    %r12,%rdi
mov    $0x20,%esi
call   1030 <memset@plt>
movslq %ebx,%rbx
jmp    1b1b <Nfmtb+0x9bb>
mov    %r14d,0x38(%rsp)
mov    %ebx,%eax
movslq %ebx,%rbx
movb   $0x0,(%r12,%rbx,1)
mov    %eax,%r14d
cmpl   $0x0,0x20(%rsp)
mov    %eax,0x20(%rsp)
mov    0x58(%rsp),%r15
je     171e <Nfmtb+0x5be>
mov    %eax,%r14d
cmp    %ebp,%eax
jle    171e <Nfmtb+0x5be>
mov    %eax,%ecx
mov    %eax,%r14d
sub    %ebp,%ecx
je     171e <Nfmtb+0x5be>
movsd  %xmm3,0x8(%rsp)
not    %ebp
add    %eax,%ebp
mov    %ecx,%r14d
mov    %rbp,%rdi
not    %rdi
add    %rbx,%rdi
add    %r12,%rdi
add    $0x1,%rbp
mov    $0x20,%esi
mov    %rbp,%rdx
call   1030 <memset@plt>
mov    %r14d,%edi
cmp    $0x4,%r14d
jae    1679 <Nfmtb+0x519>
movsd  0x8(%rsp),%xmm3
jmp    1706 <Nfmtb+0x5a6>
mov    %edi,%eax
and    $0xfffffffc,%eax
movq   %rbx,%xmm0
lea    -0x4(%rax),%esi
mov    %esi,%edx
shr    $0x2,%edx
add    $0x1,%edx
mov    %edx,%ecx
and    $0x7,%ecx
cmp    $0x1c,%esi
jae    16a4 <Nfmtb+0x544>
xorpd  %xmm1,%xmm1
movsd  0x8(%rsp),%xmm3
jmp    16cd <Nfmtb+0x56d>
and    $0xfffffff8,%edx
xorpd  %xmm1,%xmm1
movdqa 0x95d(%rip),%xmm2
movsd  0x8(%rsp),%xmm3
nopl   0x0(%rax)
paddq  %xmm2,%xmm0
paddq  %xmm2,%xmm1
add    $0xfffffff8,%edx
jne    16c0 <Nfmtb+0x560>
test   %ecx,%ecx
je     16ed <Nfmtb+0x58d>
pcmpeqd %xmm2,%xmm2
cs nopw 0x0(%rax,%rax,1)
nop
paddq  %xmm2,%xmm0
paddq  %xmm2,%xmm1
add    $0xffffffff,%ecx
jne    16e0 <Nfmtb+0x580>
paddq  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddq  %xmm0,%xmm1
movq   %xmm1,%rbx
cmp    %eax,%edi
je     171b <Nfmtb+0x5bb>
and    $0x3,%edi
mov    %edi,%ecx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %eax,%ecx
jne    1710 <Nfmtb+0x5b0>
sub    %rax,%rbx
mov    %ebx,%r14d
test   %r13d,%r13d
movsd  0x10(%rsp),%xmm1
mov    0x3c(%rsp),%edx
movsd  0x905(%rip),%xmm0
mov    0x1c(%rsp),%ecx
je     175a <Nfmtb+0x5fa>
xorpd  %xmm2,%xmm2
xor    %eax,%eax
ucomisd 0x60(%rsp),%xmm2
seta   %al
lea    (%rax,%rax,8),%eax
add    $0x20,%eax
movslq %r14d,%r14
mov    %al,-0x1(%r12,%r14,1)
add    $0xffffffffffffffff,%r14
test   %ecx,%ecx
je     176b <Nfmtb+0x60b>
movslq %r14d,%r14
movb   $0x25,-0x1(%r12,%r14,1)
add    $0xffffffffffffffff,%r14
test   %r14d,%r14d
setne  %al
test   %edx,%edx
jle    184d <Nfmtb+0x6ed>
test   %r14d,%r14d
je     184d <Nfmtb+0x6ed>
mov    %r13d,0x1c(%rsp)
movslq %r14d,%rax
lea    -0x1(%r14),%ebx
lea    (%rax,%r12,1),%rbp
add    $0xffffffffffffffff,%rbp
xor    %r15d,%r15d
lea    0x940(%rip),%r13
divsd  %xmm1,%xmm3
movsd  %xmm3,0x40(%rsp)
movapd %xmm3,%xmm0
call   1080 <floor@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x40(%rsp),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x10(%rsp),%xmm1
addsd  0x85f(%rip),%xmm1
movapd %xmm1,%xmm0
call   1080 <floor@plt>
cvttsd2si %xmm0,%eax
cmpl   $0x0,0x28(%rsp)
je     1800 <Nfmtb+0x6a0>
cmp    $0xa,%eax
jl     1800 <Nfmtb+0x6a0>
mov    %eax,%eax
movzbl (%rax,%r13,1),%eax
add    $0xe0,%al
jmp    1807 <Nfmtb+0x6a7>
cs nopw 0x0(%rax,%rax,1)
nop
cltq
movzbl (%rax,%r13,1),%eax
mov    0x3c(%rsp),%edx
mov    %al,0x0(%rbp)
lea    0x1(%r15),%ecx
cmp    %r15d,%ebx
setne  %al
cmp    %edx,%ecx
movsd  0x10(%rsp),%xmm1
movsd  0x8(%rsp),%xmm3
jge    1838 <Nfmtb+0x6d8>
add    $0xffffffffffffffff,%rbp
cmp    %r15d,%ebx
mov    %ecx,%r15d
jne    17a0 <Nfmtb+0x640>
sub    %ecx,%r14d
mov    0x58(%rsp),%r15
mov    0x1c(%rsp),%r13d
movsd  0x7eb(%rip),%xmm0
xor    %ebp,%ebp
test   %edx,%edx
cmove  %r14d,%ebp
jne    185b <Nfmtb+0x6fb>
movapd %xmm3,%xmm0
mov    0x50(%rsp),%rcx
je     187d <Nfmtb+0x71d>
test   %al,%al
mov    0x24(%rsp),%eax
je     1881 <Nfmtb+0x721>
movslq %r14d,%rbp
movb   $0x2e,-0x1(%r12,%rbp,1)
add    $0xffffffffffffffff,%rbp
movapd %xmm3,%xmm0
jmp    1881 <Nfmtb+0x721>
mov    0x24(%rsp),%eax
add    0x38(%rsp),%r15d
test   %ecx,%ecx
je     1897 <Nfmtb+0x737>
cmp    %r15d,%ebp
jle    1897 <Nfmtb+0x737>
add    $0xffffffff,%ebp
movb   $0x30,(%r12,%rbp,1)
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm0
jbe    1971 <Nfmtb+0x811>
test   %ebp,%ebp
je     1971 <Nfmtb+0x811>
xor    %ebx,%ebx
xorpd  %xmm2,%xmm2
lea    0x826(%rip),%r14
jmp    18de <Nfmtb+0x77e>
nopl   0x0(%rax)
movb   $0x2c,-0x1(%r12,%rbp,1)
add    $0xffffffffffffffff,%rbp
xor    %ebx,%ebx
ucomisd %xmm2,%xmm0
jbe    1971 <Nfmtb+0x811>
test   %ebp,%ebp
je     1971 <Nfmtb+0x811>
movslq %ebp,%rbp
test   %eax,%eax
je     18eb <Nfmtb+0x78b>
cmp    0x18(%rsp),%ebx
je     18c0 <Nfmtb+0x760>
divsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rsp)
call   1080 <floor@plt>
movsd  %xmm0,0x40(%rsp)
movsd  0x8(%rsp),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x10(%rsp),%xmm1
addsd  0x718(%rip),%xmm1
movapd %xmm1,%xmm0
call   1080 <floor@plt>
cvttsd2si %xmm0,%eax
cmpl   $0x0,0x28(%rsp)
je     1940 <Nfmtb+0x7e0>
cmp    $0xa,%eax
jl     1940 <Nfmtb+0x7e0>
mov    %eax,%eax
movzbl (%rax,%r14,1),%eax
add    $0xe0,%al
jmp    1947 <Nfmtb+0x7e7>
nopl   0x0(%rax)
cltq
movzbl (%rax,%r14,1),%eax
xorpd  %xmm2,%xmm2
mov    %al,-0x1(%r12,%rbp,1)
add    $0xffffffffffffffff,%rbp
add    $0x1,%ebx
movsd  0x40(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
mov    0x24(%rsp),%eax
ucomisd %xmm2,%xmm0
ja     18d6 <Nfmtb+0x776>
cmpl   $0x0,0x34(%rsp)
je     1a84 <Nfmtb+0x924>
mov    %ebp,%eax
sub    %r15d,%eax
mov    0x38(%rsp),%r9d
mov    0x20(%rsp),%ebx
jle    1a7d <Nfmtb+0x91d>
cmp    $0x20,%eax
jb     1a70 <Nfmtb+0x910>
lea    -0x1(%rbp),%ecx
cmp    %ecx,%r15d
ja     1a70 <Nfmtb+0x910>
mov    %eax,%r8d
and    $0xffffffe0,%r8d
lea    -0x20(%r8),%ebx
mov    %ebx,%edi
shr    $0x5,%edi
add    $0x1,%edi
mov    %edi,%edx
and    $0x3,%edx
xor    %esi,%esi
cmp    $0x60,%ebx
jb     1a2e <Nfmtb+0x8ce>
and    $0xfffffffc,%edi
lea    -0x61(%rbp),%ebx
xor    %esi,%esi
movapd 0x64c(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x60(%rbx),%ecx
movupd %xmm1,-0xf(%r12,%rcx,1)
movupd %xmm1,-0x1f(%r12,%rcx,1)
lea    0x40(%rbx),%ecx
movupd %xmm1,-0xf(%r12,%rcx,1)
movupd %xmm1,-0x1f(%r12,%rcx,1)
lea    0x20(%rbx),%ecx
movupd %xmm1,-0xf(%r12,%rcx,1)
movupd %xmm1,-0x1f(%r12,%rcx,1)
mov    %ebx,%ecx
movupd %xmm1,-0xf(%r12,%rcx,1)
movupd %xmm1,-0x1f(%r12,%rcx,1)
sub    $0xffffff80,%esi
add    $0xffffff80,%ebx
add    $0xfffffffc,%edi
jne    19e0 <Nfmtb+0x880>
test   %edx,%edx
mov    0x20(%rsp),%ebx
je     1a68 <Nfmtb+0x908>
not    %esi
add    %ebp,%esi
movapd 0x5de(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %esi,%ecx
movupd %xmm1,-0xf(%r12,%rcx,1)
movupd %xmm1,-0x1f(%r12,%rcx,1)
add    $0xffffffe0,%esi
add    $0xffffffff,%edx
jne    1a50 <Nfmtb+0x8f0>
sub    %r8d,%ebp
cmp    %r8d,%eax
je     1a7d <Nfmtb+0x91d>
add    $0xffffffff,%ebp
movb   $0x30,(%r12,%rbp,1)
cmp    %r15d,%ebp
jg     1a70 <Nfmtb+0x910>
test   %r9d,%r9d
jne    1a92 <Nfmtb+0x932>
jmp    1aa3 <Nfmtb+0x943>
mov    0x38(%rsp),%r9d
mov    0x20(%rsp),%ebx
test   %r9d,%r9d
je     1aa3 <Nfmtb+0x943>
test   %ebp,%ebp
je     1aa3 <Nfmtb+0x943>
movslq %ebp,%rbp
movb   $0x24,-0x1(%r12,%rbp,1)
add    $0xffffffffffffffff,%rbp
xorpd  %xmm1,%xmm1
ucomisd 0x60(%rsp),%xmm1
jbe    1acd <Nfmtb+0x96d>
test   %ebp,%ebp
je     1b01 <Nfmtb+0x9a1>
xor    %eax,%eax
test   %r13d,%r13d
sete   %al
lea    (%rax,%rax,4),%eax
add    $0x28,%eax
movslq %ebp,%rbp
mov    %al,-0x1(%r12,%rbp,1)
add    $0xffffffffffffffff,%rbp
test   %ebp,%ebp
je     1af5 <Nfmtb+0x995>
lea    -0x1(%rbp),%eax
movslq %eax,%rdi
sub    %rax,%rdi
add    %r12,%rdi
mov    %ebp,%edx
mov    $0x20,%esi
movsd  %xmm0,0x8(%rsp)
call   1030 <memset@plt>
movsd  0x8(%rsp),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1b01 <Nfmtb+0x9a1>
jnp    1b20 <Nfmtb+0x9c0>
test   %ebx,%ebx
jle    1b19 <Nfmtb+0x9b9>
mov    %ebx,%ebx
mov    %r12,%rdi
mov    $0x2a,%esi
mov    %rbx,%rdx
call   1030 <memset@plt>
jmp    1b1b <Nfmtb+0x9bb>
xor    %ebx,%ebx
movb   $0x0,(%r12,%rbx,1)
mov    %r12,%rax
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@Nfmtb.alpha = internal global [37 x i8] c"0123456789abcdefghijklmnopqrstuvwxyz\00"
define i8* @Nfmtb(double %0, i32 %1, i8* %2, i32 %3, i32 %4, i8* %5) {
%7 = alloca i8*
%8 = alloca double
%9 = alloca i32
%10 = alloca i8*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i8*
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca double
%32 = alloca double
store double %0, double* %8
store i32 %1, i32* %9
store i8* %2, i8** %10
store i32 %3, i32* %11
store i32 %4, i32* %12
store i8* %5, i8** %13
store i32 3, i32* %28
%33 = load i32, i32* %11
store i32 %33, i32* %29
%34 = load i32, i32* %9
%35 = icmp slt i32 %34, 2
br i1 %35, label %39, label %36
36: ; preds = %6
%37 = load i32, i32* %9
%38 = icmp sgt i32 %37, 36
br i1 %38, label %39, label %40
39: ; preds = %36, %6
store i32 10, i32* %9
br label %40
40: ; preds = %39, %36
%41 = load i32, i32* %9
%42 = sitofp i32 %41 to double
store double %42, double* %31
%43 = load double, double* %8
%44 = fcmp olt double %43, 0.000000e+00
%45 = zext i1 %44 to i32
store i32 %45, i32* %16
br i1 %44, label %46, label %49
46: ; preds = %40
%47 = load double, double* %8
%48 = fneg double %47
store double %48, double* %8
br label %49
49: ; preds = %46, %40
%50 = load i32, i32* %12
%51 = icmp sge i32 %50, 0
br i1 %51, label %52, label %63
52: ; preds = %49
%53 = load double, double* %31
%54 = load i32, i32* %12
%55 = sitofp i32 %54 to double
%56 = call double @pow(double %53, double %55)
store double %56, double* %32
%57 = load double, double* %8
%58 = load double, double* %32
%59 = call double @llvm.fmuladd.f64(double %57, double %58, double 5.000000e-01)
%60 = call double @llvm.floor.f64(double %59)
%61 = load double, double* %32
%62 = fdiv double %60, %61
store double %62, double* %8
br label %63
63: ; preds = %52, %49
%64 = load i32, i32* %9
switch i32 %64, label %112 [
i32 10, label %65
i32 2, label %76
i32 8, label %88
i32 16, label %100
]
65: ; preds = %63
store i32 3, i32* %28
%66 = load double, double* %8
%67 = fcmp olt double %66, 1.000000e+00
br i1 %67, label %68, label %69
68: ; preds = %65
br label %74
69: ; preds = %65
%70 = load double, double* %8
%71 = call i64 @log10(double %70)
%72 = trunc i64 %71 to i32
%73 = add nsw i32 1, %72
br label %74
74: ; preds = %69, %68
%75 = phi i32 [ 0, %68 ], [ %73, %69 ]
store i32 %75, i32* %25
br label %126
76: ; preds = %63
store i32 4, i32* %28
%77 = load double, double* %8
%78 = fcmp olt double %77, 1.000000e+00
br i1 %78, label %79, label %80
79: ; preds = %76
br label %86
80: ; preds = %76
%81 = load double, double* %8
%82 = call double @log(double %81)
%83 = fdiv double %82, 0x3FE62E42FEFFBB3C
%84 = fptosi double %83 to i32
%85 = add nsw i32 1, %84
br label %86
86: ; preds = %80, %79
%87 = phi i32 [ 0, %79 ], [ %85, %80 ]
store i32 %87, i32* %25
br label %126
88: ; preds = %63
store i32 3, i32* %28
%89 = load double, double* %8
%90 = fcmp olt double %89, 1.000000e+00
br i1 %90, label %91, label %92
91: ; preds = %88
br label %98
92: ; preds = %88
%93 = load double, double* %8
%94 = call double @log(double %93)
%95 = fdiv double %94, 0x4000A2B23F46ABA5
%96 = fptosi double %95 to i32
%97 = add nsw i32 1, %96
br label %98
98: ; preds = %92, %91
%99 = phi i32 [ 0, %91 ], [ %97, %92 ]
store i32 %99, i32* %25
br label %126
100: ; preds = %63
store i32 4, i32* %28
%101 = load double, double* %8
%102 = fcmp olt double %101, 1.000000e+00
br i1 %102, label %103, label %104
103: ; preds = %100
br label %110
104: ; preds = %100
%105 = load double, double* %8
%106 = call double @log(double %105)
%107 = fdiv double %106, 0x40062E42FEF1FCCC
%108 = fptosi double %107 to i32
%109 = add nsw i32 1, %108
br label %110
110: ; preds = %104, %103
%111 = phi i32 [ 0, %103 ], [ %109, %104 ]
store i32 %111, i32* %25
br label %126
112: ; preds = %63
store i32 3, i32* %28
%113 = load double, double* %8
%114 = fcmp olt double %113, 1.000000e+00
br i1 %114, label %115, label %116
115: ; preds = %112
br label %124
116: ; preds = %112
%117 = load double, double* %8
%118 = call double @log(double %117)
%119 = load double, double* %31
%120 = call double @log(double %119)
%121 = fdiv double %118, %120
%122 = fptosi double %121 to i32
%123 = add nsw i32 1, %122
br label %124
124: ; preds = %116, %115
%125 = phi i32 [ 0, %115 ], [ %123, %116 ]
store i32 %125, i32* %25
br label %126
126: ; preds = %124, %110, %98, %86, %74
%127 = load i32, i32* %12
%128 = icmp slt i32 %127, 0
br i1 %128, label %129, label %133
129: ; preds = %126
%130 = load double, double* %8
%131 = load i32, i32* %9
%132 = call i32 @Ndrgtb(double %130, i32 %131)
store i32 %132, i32* %12
br label %133
133: ; preds = %129, %126
store i32 0, i32* %30
store i32 0, i32* %27
store i32 0, i32* %23
store i32 0, i32* %21
store i32 0, i32* %20
store i32 0, i32* %19
store i32 0, i32* %18
store i32 0, i32* %17
%134 = load i8*, i8** %10
%135 = icmp ne i8* %134, null
br i1 %135, label %136, label %160
136: ; preds = %133
br label %137
137: ; preds = %158, %136
%138 = load i8*, i8** %10
%139 = load i8, i8* %138
%140 = icmp ne i8 %139, 0
br i1 %140, label %141, label %159
141: ; preds = %137
%142 = load i8*, i8** %10
%143 = getelementptr inbounds i8, i8* %142, i32 1
store i8* %143, i8** %10
%144 = load i8, i8* %142
%145 = sext i8 %144 to i32
switch i32 %145, label %158 [
i32 66, label %146
i32 67, label %147
i32 76, label %152
i32 80, label %153
i32 90, label %154
i32 68, label %155
i32 85, label %156
i32 82, label %157
]
146: ; preds = %141
store i32 1, i32* %17
br label %158
147: ; preds = %141
%148 = load i32, i32* %25
%149 = sub nsw i32 %148, 1
%150 = load i32, i32* %28
%151 = sdiv i32 %149, %150
store i32 %151, i32* %18
br label %158
152: ; preds = %141
store i32 1, i32* %19
br label %158
153: ; preds = %141
store i32 1, i32* %20
br label %158
154: ; preds = %141
store i32 1, i32* %21
br label %158
155: ; preds = %141
store i32 1, i32* %23
br label %158
156: ; preds = %141
store i32 1, i32* %27
br label %158
157: ; preds = %141
store i32 1, i32* %30
br label %158
158: ; preds = %141, %157, %156, %155, %154, %153, %152, %147, %146
br label %137
159: ; preds = %137
br label %160
160: ; preds = %159, %133
%161 = load double, double* %8
%162 = fcmp olt double %161, 1.000000e+00
%163 = zext i1 %162 to i32
store i32 %163, i32* %26
%164 = load i32, i32* %23
%165 = load i32, i32* %20
%166 = add nsw i32 %164, %165
%167 = load i32, i32* %18
%168 = add nsw i32 %166, %167
%169 = load i32, i32* %16
%170 = add nsw i32 %168, %169
%171 = load i32, i32* %25
%172 = add nsw i32 %170, %171
%173 = load i32, i32* %12
%174 = add nsw i32 %172, %173
%175 = load i32, i32* %12
%176 = icmp ne i32 %175, 0
%177 = xor i1 %176, true
%178 = xor i1 %177, true
%179 = zext i1 %178 to i32
%180 = add nsw i32 %174, %179
%181 = load i32, i32* %26
%182 = add nsw i32 %180, %181
%183 = load i32, i32* %30
%184 = add nsw i32 %182, %183
store i32 %184, i32* %24
%185 = load i32, i32* %29
%186 = icmp slt i32 %185, 1
br i1 %186, label %187, label %189
187: ; preds = %160
%188 = load i32, i32* %24
store i32 %188, i32* %29
br label %282
189: ; preds = %160
%190 = load i32, i32* %24
%191 = load i32, i32* %29
%192 = icmp sgt i32 %190, %191
br i1 %192, label %193, label %281
193: ; preds = %189
%194 = load i32, i32* %26
%195 = icmp ne i32 %194, 0
br i1 %195, label %196, label %201
196: ; preds = %193
%197 = load i32, i32* %26
%198 = add nsw i32 %197, -1
store i32 %198, i32* %26
%199 = load i32, i32* %24
%200 = sub nsw i32 %199, %197
store i32 %200, i32* %24
br label %201
201: ; preds = %196, %193
%202 = load i32, i32* %23
store i32 %202, i32* %15
%203 = icmp ne i32 %202, 0
br i1 %203, label %204, label %213
204: ; preds = %201
%205 = load i32, i32* %24
%206 = load i32, i32* %29
%207 = icmp sgt i32 %205, %206
br i1 %207, label %208, label %213
208: ; preds = %204
%209 = load i32, i32* %23
%210 = add nsw i32 %209, -1
store i32 %210, i32* %23
%211 = load i32, i32* %24
%212 = sub nsw i32 %211, %209
store i32 %212, i32* %24
br label %213
213: ; preds = %208, %204, %201
%214 = load i32, i32* %24
%215 = load i32, i32* %29
%216 = icmp sgt i32 %214, %215
br i1 %216, label %217, label %224
217: ; preds = %213
%218 = load i32, i32* %18
%219 = icmp ne i32 %218, 0
br i1 %219, label %220, label %224
220: ; preds = %217
%221 = load i32, i32* %18
%222 = load i32, i32* %24
%223 = sub nsw i32 %222, %221
store i32 %223, i32* %24
store i32 0, i32* %18
br label %224
224: ; preds = %220, %217, %213
%225 = load i32, i32* %24
%226 = load i32, i32* %29
%227 = icmp slt i32 %225, %226
br i1 %227, label %228, label %234
228: ; preds = %224
%229 = load i32, i32* %15
%230 = icmp ne i32 %229, 0
br i1 %230, label %231, label %234
231: ; preds = %228
%232 = load i32, i32* %24
%233 = add nsw i32 %232, 1
store i32 %233, i32* %24
store i32 1, i32* %23
br label %234
234: ; preds = %231, %228, %224
%235 = load i32, i32* %24
%236 = load i32, i32* %29
%237 = icmp sgt i32 %235, %236
br i1 %237, label %238, label %246
238: ; preds = %234
%239 = load i32, i32* %20
%240 = icmp ne i32 %239, 0
br i1 %240, label %241, label %246
241: ; preds = %238
%242 = load i32, i32* %20
%243 = add nsw i32 %242, -1
store i32 %243, i32* %20
%244 = load i32, i32* %24
%245 = sub nsw i32 %244, %242
store i32 %245, i32* %24
br label %246
246: ; preds = %241, %238, %234
%247 = load i32, i32* %24
%248 = load i32, i32* %29
%249 = icmp sgt i32 %247, %248
br i1 %249, label %250, label %258
250: ; preds = %246
%251 = load i32, i32* %30
%252 = icmp ne i32 %251, 0
br i1 %252, label %253, label %258
253: ; preds = %250
%254 = load i32, i32* %30
%255 = add nsw i32 %254, -1
store i32 %255, i32* %30
%256 = load i32, i32* %24
%257 = sub nsw i32 %256, %254
store i32 %257, i32* %24
br label %258
258: ; preds = %253, %250, %246
%259 = load i32, i32* %24
%260 = load i32, i32* %29
%261 = icmp sgt i32 %259, %260
br i1 %261, label %262, label %280
262: ; preds = %258
br label %263
263: ; preds = %572, %262
store i32 0, i32* %15
br label %264
264: ; preds = %268, %263
%265 = load i32, i32* %15
%266 = load i32, i32* %29
%267 = icmp slt i32 %265, %266
br i1 %267, label %268, label %274
268: ; preds = %264
%269 = load i8*, i8** %13
%270 = load i32, i32* %15
%271 = add nsw i32 %270, 1
store i32 %271, i32* %15
%272 = sext i32 %270 to i64
%273 = getelementptr inbounds i8, i8* %269, i64 %272
store i8 42, i8* %273
br label %264
274: ; preds = %264
%275 = load i8*, i8** %13
%276 = load i32, i32* %15
%277 = sext i32 %276 to i64
%278 = getelementptr inbounds i8, i8* %275, i64 %277
store i8 0, i8* %278
%279 = load i8*, i8** %13
store i8* %279, i8** %7
br label %575
280: ; preds = %258
br label %281
281: ; preds = %280, %189
br label %282
282: ; preds = %281, %187
%283 = load double, double* %8
%284 = load double, double* %31
%285 = load i32, i32* %12
%286 = sitofp i32 %285 to double
%287 = call double @pow(double %284, double %286)
%288 = fadd double 5.000000e-01, %287
%289 = call double @llvm.floor.f64(double %288)
%290 = call double @llvm.fmuladd.f64(double %283, double %289, double 5.000000e-01)
%291 = call double @llvm.floor.f64(double %290)
store double %291, double* %8
%292 = load i32, i32* %17
%293 = icmp ne i32 %292, 0
br i1 %293, label %294, label %314
294: ; preds = %282
%295 = load double, double* %8
%296 = fcmp oeq double %295, 0.000000e+00
br i1 %296, label %297, label %314
297: ; preds = %294
store i32 0, i32* %15
br label %298
298: ; preds = %302, %297
%299 = load i32, i32* %15
%300 = load i32, i32* %11
%301 = icmp slt i32 %299, %300
br i1 %301, label %302, label %308
302: ; preds = %298
%303 = load i8*, i8** %13
%304 = load i32, i32* %15
%305 = add nsw i32 %304, 1
store i32 %305, i32* %15
%306 = sext i32 %304 to i64
%307 = getelementptr inbounds i8, i8* %303, i64 %306
store i8 32, i8* %307
br label %298
308: ; preds = %298
%309 = load i8*, i8** %13
%310 = load i32, i32* %11
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds i8, i8* %309, i64 %311
store i8 0, i8* %312
%313 = load i8*, i8** %13
store i8* %313, i8** %7
br label %575
314: ; preds = %294, %282
%315 = load i8*, i8** %13
%316 = load i32, i32* %29
store i32 %316, i32* %14
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds i8, i8* %315, i64 %317
store i8 0, i8* %318
%319 = load i32, i32* %19
%320 = icmp ne i32 %319, 0
br i1 %320, label %321, label %340
321: ; preds = %314
%322 = load i32, i32* %29
%323 = load i32, i32* %24
%324 = icmp sgt i32 %322, %323
br i1 %324, label %325, label %340
325: ; preds = %321
%326 = load i32, i32* %29
%327 = load i32, i32* %24
%328 = sub nsw i32 %326, %327
store i32 %328, i32* %15
br label %329
329: ; preds = %333, %325
%330 = load i32, i32* %15
%331 = add nsw i32 %330, -1
store i32 %331, i32* %15
%332 = icmp ne i32 %330, 0
br i1 %332, label %333, label %339
333: ; preds = %329
%334 = load i8*, i8** %13
%335 = load i32, i32* %14
%336 = add nsw i32 %335, -1
store i32 %336, i32* %14
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds i8, i8* %334, i64 %337
store i8 32, i8* %338
br label %329
339: ; preds = %329
br label %340
340: ; preds = %339, %321, %314
%341 = load i32, i32* %20
%342 = icmp ne i32 %341, 0
br i1 %342, label %343, label %354
343: ; preds = %340
%344 = load i32, i32* %16
%345 = icmp ne i32 %344, 0
%346 = zext i1 %345 to i64
%347 = select i1 %345, i32 41, i32 32
%348 = trunc i32 %347 to i8
%349 = load i8*, i8** %13
%350 = load i32, i32* %14
%351 = add nsw i32 %350, -1
store i32 %351, i32* %14
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds i8, i8* %349, i64 %352
store i8 %348, i8* %353
br label %354
354: ; preds = %343, %340
%355 = load i32, i32* %30
%356 = icmp ne i32 %355, 0
br i1 %356, label %357, label %363
357: ; preds = %354
%358 = load i8*, i8** %13
%359 = load i32, i32* %14
%360 = add nsw i32 %359, -1
store i32 %360, i32* %14
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds i8, i8* %358, i64 %361
store i8 37, i8* %362
br label %363
363: ; preds = %357, %354
store i32 0, i32* %22
br label %364
364: ; preds = %413, %363
%365 = load i32, i32* %22
%366 = load i32, i32* %12
%367 = icmp slt i32 %365, %366
br i1 %367, label %368, label %371
368: ; preds = %364
%369 = load i32, i32* %14
%370 = icmp ne i32 %369, 0
br label %371
371: ; preds = %368, %364
%372 = phi i1 [ false, %364 ], [ %370, %368 ]
br i1 %372, label %373, label %416
373: ; preds = %371
%374 = load double, double* %31
%375 = load double, double* %8
%376 = fdiv double %375, %374
store double %376, double* %8
%377 = load double, double* %31
%378 = load double, double* %8
%379 = load double, double* %8
%380 = call double @llvm.floor.f64(double %379)
%381 = fsub double %378, %380
%382 = call double @llvm.fmuladd.f64(double %377, double %381, double 5.000000e-01)
%383 = call double @llvm.floor.f64(double %382)
%384 = fptosi double %383 to i32
store i32 %384, i32* %15
%385 = load double, double* %8
%386 = call double @llvm.floor.f64(double %385)
store double %386, double* %8
%387 = load i32, i32* %27
%388 = icmp ne i32 %387, 0
br i1 %388, label %389, label %399
389: ; preds = %373
%390 = load i32, i32* %15
%391 = icmp sgt i32 %390, 9
br i1 %391, label %392, label %399
392: ; preds = %389
%393 = load i32, i32* %15
%394 = sext i32 %393 to i64
%395 = getelementptr inbounds [37 x i8], [37 x i8]* @Nfmtb.alpha, i64 0, i64 %394
%396 = load i8, i8* %395
%397 = sext i8 %396 to i32
%398 = add nsw i32 %397, -32
br label %405
399: ; preds = %389, %373
%400 = load i32, i32* %15
%401 = sext i32 %400 to i64
%402 = getelementptr inbounds [37 x i8], [37 x i8]* @Nfmtb.alpha, i64 0, i64 %401
%403 = load i8, i8* %402
%404 = sext i8 %403 to i32
br label %405
405: ; preds = %399, %392
%406 = phi i32 [ %398, %392 ], [ %404, %399 ]
%407 = trunc i32 %406 to i8
%408 = load i8*, i8** %13
%409 = load i32, i32* %14
%410 = add nsw i32 %409, -1
store i32 %410, i32* %14
%411 = sext i32 %410 to i64
%412 = getelementptr inbounds i8, i8* %408, i64 %411
store i8 %407, i8* %412
br label %413
413: ; preds = %405
%414 = load i32, i32* %22
%415 = add nsw i32 %414, 1
store i32 %415, i32* %22
br label %364
416: ; preds = %371
%417 = load i32, i32* %12
%418 = icmp ne i32 %417, 0
br i1 %418, label %419, label %430
419: ; preds = %416
%420 = load i32, i32* %14
%421 = icmp ne i32 %420, 0
br i1 %421, label %422, label %428
422: ; preds = %419
%423 = load i8*, i8** %13
%424 = load i32, i32* %14
%425 = add nsw i32 %424, -1
store i32 %425, i32* %14
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds i8, i8* %423, i64 %426
store i8 46, i8* %427
br label %429
428: ; preds = %419
store double 1.000000e+00, double* %8
br label %429
429: ; preds = %428, %422
br label %430
430: ; preds = %429, %416
%431 = load i32, i32* %26
%432 = icmp ne i32 %431, 0
br i1 %432, label %433, label %445
433: ; preds = %430
%434 = load i32, i32* %14
%435 = load i32, i32* %16
%436 = load i32, i32* %23
%437 = add nsw i32 %435, %436
%438 = icmp sgt i32 %434, %437
br i1 %438, label %439, label %445
439: ; preds = %433
%440 = load i8*, i8** %13
%441 = load i32, i32* %14
%442 = add nsw i32 %441, -1
store i32 %442, i32* %14
%443 = sext i32 %442 to i64
%444 = getelementptr inbounds i8, i8* %440, i64 %443
store i8 48, i8* %444
br label %445
445: ; preds = %439, %433, %430
store i32 0, i32* %22
br label %446
446: ; preds = %509, %445
%447 = load double, double* %8
%448 = fcmp ogt double %447, 0.000000e+00
br i1 %448, label %449, label %452
449: ; preds = %446
%450 = load i32, i32* %14
%451 = icmp ne i32 %450, 0
br label %452
452: ; preds = %449, %446
%453 = phi i1 [ false, %446 ], [ %451, %449 ]
br i1 %453, label %454, label %510
454: ; preds = %452
%455 = load i32, i32* %18
%456 = icmp ne i32 %455, 0
br i1 %456, label %457, label %467
457: ; preds = %454
%458 = load i32, i32* %22
%459 = load i32, i32* %28
%460 = icmp eq i32 %458, %459
br i1 %460, label %461, label %467
461: ; preds = %457
%462 = load i8*, i8** %13
%463 = load i32, i32* %14
%464 = add nsw i32 %463, -1
store i32 %464, i32* %14
%465 = sext i32 %464 to i64
%466 = getelementptr inbounds i8, i8* %462, i64 %465
store i8 44, i8* %466
store i32 0, i32* %22
br label %509
467: ; preds = %457, %454
%468 = load double, double* %31
%469 = load double, double* %8
%470 = fdiv double %469, %468
store double %470, double* %8
%471 = load double, double* %31
%472 = load double, double* %8
%473 = load double, double* %8
%474 = call double @llvm.floor.f64(double %473)
%475 = fsub double %472, %474
%476 = call double @llvm.fmuladd.f64(double %471, double %475, double 5.000000e-01)
%477 = call double @llvm.floor.f64(double %476)
%478 = fptosi double %477 to i32
store i32 %478, i32* %15
%479 = load double, double* %8
%480 = call double @llvm.floor.f64(double %479)
store double %480, double* %8
%481 = load i32, i32* %27
%482 = icmp ne i32 %481, 0
br i1 %482, label %483, label %493
483: ; preds = %467
%484 = load i32, i32* %15
%485 = icmp sgt i32 %484, 9
br i1 %485, label %486, label %493
486: ; preds = %483
%487 = load i32, i32* %15
%488 = sext i32 %487 to i64
%489 = getelementptr inbounds [37 x i8], [37 x i8]* @Nfmtb.alpha, i64 0, i64 %488
%490 = load i8, i8* %489
%491 = sext i8 %490 to i32
%492 = add nsw i32 %491, -32
br label %499
493: ; preds = %483, %467
%494 = load i32, i32* %15
%495 = sext i32 %494 to i64
%496 = getelementptr inbounds [37 x i8], [37 x i8]* @Nfmtb.alpha, i64 0, i64 %495
%497 = load i8, i8* %496
%498 = sext i8 %497 to i32
br label %499
499: ; preds = %493, %486
%500 = phi i32 [ %492, %486 ], [ %498, %493 ]
%501 = trunc i32 %500 to i8
%502 = load i8*, i8** %13
%503 = load i32, i32* %14
%504 = add nsw i32 %503, -1
store i32 %504, i32* %14
%505 = sext i32 %504 to i64
%506 = getelementptr inbounds i8, i8* %502, i64 %505
store i8 %501, i8* %506
%507 = load i32, i32* %22
%508 = add nsw i32 %507, 1
store i32 %508, i32* %22
br label %509
509: ; preds = %499, %461
br label %446
510: ; preds = %452
%511 = load i32, i32* %21
%512 = icmp ne i32 %511, 0
br i1 %512, label %513, label %528
513: ; preds = %510
%514 = load i32, i32* %16
%515 = load i32, i32* %23
%516 = add nsw i32 %514, %515
store i32 %516, i32* %15
br label %517
517: ; preds = %521, %513
%518 = load i32, i32* %14
%519 = load i32, i32* %15
%520 = icmp sgt i32 %518, %519
br i1 %520, label %521, label %527
521: ; preds = %517
%522 = load i8*, i8** %13
%523 = load i32, i32* %14
%524 = add nsw i32 %523, -1
store i32 %524, i32* %14
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds i8, i8* %522, i64 %525
store i8 48, i8* %526
br label %517
527: ; preds = %517
br label %528
528: ; preds = %527, %510
%529 = load i32, i32* %23
%530 = icmp ne i32 %529, 0
br i1 %530, label %531, label %540
531: ; preds = %528
%532 = load i32, i32* %14
%533 = icmp ne i32 %532, 0
br i1 %533, label %534, label %540
534: ; preds = %531
%535 = load i8*, i8** %13
%536 = load i32, i32* %14
%537 = add nsw i32 %536, -1
store i32 %537, i32* %14
%538 = sext i32 %537 to i64
%539 = getelementptr inbounds i8, i8* %535, i64 %538
store i8 36, i8* %539
br label %540
540: ; preds = %534, %531, %528
%541 = load i32, i32* %16
%542 = icmp ne i32 %541, 0
br i1 %542, label %543, label %559
543: ; preds = %540
%544 = load i32, i32* %14
%545 = icmp ne i32 %544, 0
br i1 %545, label %546, label %557
546: ; preds = %543
%547 = load i32, i32* %20
%548 = icmp ne i32 %547, 0
%549 = zext i1 %548 to i64
%550 = select i1 %548, i32 40, i32 45
%551 = trunc i32 %550 to i8
%552 = load i8*, i8** %13
%553 = load i32, i32* %14
%554 = add nsw i32 %553, -1
store i32 %554, i32* %14
%555 = sext i32 %554 to i64
%556 = getelementptr inbounds i8, i8* %552, i64 %555
store i8 %551, i8* %556
br label %558
557: ; preds = %543
store double 1.000000e+00, double* %8
br label %558
558: ; preds = %557, %546
br label %559
559: ; preds = %558, %540
br label %560
560: ; preds = %563, %559
%561 = load i32, i32* %14
%562 = icmp ne i32 %561, 0
br i1 %562, label %563, label %569
563: ; preds = %560
%564 = load i8*, i8** %13
%565 = load i32, i32* %14
%566 = add nsw i32 %565, -1
store i32 %566, i32* %14
%567 = sext i32 %566 to i64
%568 = getelementptr inbounds i8, i8* %564, i64 %567
store i8 32, i8* %568
br label %560
569: ; preds = %560
%570 = load double, double* %8
%571 = fcmp une double %570, 0.000000e+00
br i1 %571, label %572, label %573
572: ; preds = %569
br label %263
573: ; preds = %569
%574 = load i8*, i8** %13
store i8* %574, i8** %7
br label %575
575: ; preds = %573, %308, %274
%576 = load i8*, i8** %7
ret i8* %576
}

LLVM IR (-O2):
@Nfmtb.alpha = internal unnamed_addr constant [37 x i8] c"0123456789abcdefghijklmnopqrstuvwxyz\00"
define i8* @Nfmtb(double %0, i32 %1, i8* %2, i32 %3, i32 %4, i8* returned writeonly %5) {
%7 = add i32 %1, -37
%8 = icmp ult i32 %7, -35
%9 = select i1 %8, i32 10, i32 %1
%10 = sitofp i32 %9 to double
%11 = fcmp olt double %0, 0.000000e+00
%12 = zext i1 %11 to i32
%13 = fneg double %0
%14 = select i1 %11, double %13, double %0
%15 = icmp sgt i32 %4, -1
br i1 %15, label %16, label %22
16: ; preds = %6
%17 = sitofp i32 %4 to double
%18 = tail call double @pow(double %10, double %17)
%19 = tail call double @llvm.fmuladd.f64(double %14, double %18, double 5.000000e-01)
%20 = tail call double @llvm.floor.f64(double %19)
%21 = fdiv double %20, %18
br label %22
22: ; preds = %16, %6
%23 = phi double [ %21, %16 ], [ %14, %6 ]
%24 = add nsw i32 %9, -2
%25 = tail call i32 @llvm.fshl.i32(i32 %24, i32 %24, i32 31)
switch i32 %25, label %53 [
i32 4, label %26
i32 0, label %32
i32 3, label %39
i32 7, label %46
]
26: ; preds = %22
%27 = fcmp olt double %23, 1.000000e+00
br i1 %27, label %61, label %28
28: ; preds = %26
%29 = tail call i64 @log10(double %23)
%30 = trunc i64 %29 to i32
%31 = add nsw i32 %30, 1
br label %61
32: ; preds = %22
%33 = fcmp olt double %23, 1.000000e+00
br i1 %33, label %61, label %34
34: ; preds = %32
%35 = tail call double @log(double %23)
%36 = fdiv double %35, 0x3FE62E42FEFFBB3C
%37 = fptosi double %36 to i32
%38 = add nsw i32 %37, 1
br label %61
39: ; preds = %22
%40 = fcmp olt double %23, 1.000000e+00
br i1 %40, label %61, label %41
41: ; preds = %39
%42 = tail call double @log(double %23)
%43 = fdiv double %42, 0x4000A2B23F46ABA5
%44 = fptosi double %43 to i32
%45 = add nsw i32 %44, 1
br label %61
46: ; preds = %22
%47 = fcmp olt double %23, 1.000000e+00
br i1 %47, label %61, label %48
48: ; preds = %46
%49 = tail call double @log(double %23)
%50 = fdiv double %49, 0x40062E42FEF1FCCC
%51 = fptosi double %50 to i32
%52 = add nsw i32 %51, 1
br label %61
53: ; preds = %22
%54 = fcmp olt double %23, 1.000000e+00
br i1 %54, label %61, label %55
55: ; preds = %53
%56 = tail call double @log(double %23)
%57 = tail call double @log(double %10)
%58 = fdiv double %56, %57
%59 = fptosi double %58 to i32
%60 = add nsw i32 %59, 1
br label %61
61: ; preds = %55, %53, %48, %46, %41, %39, %34, %32, %28, %26
%62 = phi i32 [ %31, %28 ], [ 0, %26 ], [ %38, %34 ], [ 0, %32 ], [ %45, %41 ], [ 0, %39 ], [ %52, %48 ], [ 0, %46 ], [ %60, %55 ], [ 0, %53 ]
%63 = phi i32 [ 3, %28 ], [ 3, %26 ], [ 4, %34 ], [ 4, %32 ], [ 3, %41 ], [ 3, %39 ], [ 4, %48 ], [ 4, %46 ], [ 3, %55 ], [ 3, %53 ]
%64 = icmp slt i32 %4, 0
br i1 %64, label %65, label %67
65: ; preds = %61
%66 = tail call i32 @Ndrgtb(double %23, i32 %9)
br label %67
67: ; preds = %65, %61
%68 = phi i32 [ %66, %65 ], [ %4, %61 ]
%69 = icmp eq i8* %2, null
br i1 %69, label %108, label %70
70: ; preds = %67
%71 = load i8, i8* %2
%72 = icmp eq i8 %71, 0
br i1 %72, label %108, label %73
73: ; preds = %70
%74 = add nsw i32 %62, -1
br label %75
75: ; preds = %73, %97
%76 = phi i8 [ %71, %73 ], [ %106, %97 ]
%77 = phi i32 [ 0, %73 ], [ %105, %97 ]
%78 = phi i32 [ 0, %73 ], [ %104, %97 ]
%79 = phi i32 [ 0, %73 ], [ %103, %97 ]
%80 = phi i32 [ 0, %73 ], [ %102, %97 ]
%81 = phi i32 [ 0, %73 ], [ %101, %97 ]
%82 = phi i32 [ 0, %73 ], [ %100, %97 ]
%83 = phi i32 [ 0, %73 ], [ %99, %97 ]
%84 = phi i32 [ 0, %73 ], [ %98, %97 ]
%85 = phi i8* [ %2, %73 ], [ %86, %97 ]
%86 = getelementptr inbounds i8, i8* %85, i64 1
%87 = sext i8 %76 to i32
switch i32 %87, label %97 [
i32 66, label %88
i32 67, label %89
i32 76, label %91
i32 80, label %92
i32 90, label %93
i32 68, label %94
i32 85, label %95
i32 82, label %96
]
88: ; preds = %75
br label %97
89: ; preds = %75
%90 = sdiv i32 %74, %63
br label %97
91: ; preds = %75
br label %97
92: ; preds = %75
br label %97
93: ; preds = %75
br label %97
94: ; preds = %75
br label %97
95: ; preds = %75
br label %97
96: ; preds = %75
br label %97
97: ; preds = %75, %96, %95, %94, %93, %92, %91, %89, %88
%98 = phi i32 [ %84, %75 ], [ %84, %96 ], [ %84, %95 ], [ %84, %94 ], [ %84, %93 ], [ %84, %92 ], [ %84, %91 ], [ %84, %89 ], [ 1, %88 ]
%99 = phi i32 [ %83, %75 ], [ %83, %96 ], [ %83, %95 ], [ %83, %94 ], [ %83, %93 ], [ %83, %92 ], [ %83, %91 ], [ %90, %89 ], [ %83, %88 ]
%100 = phi i32 [ %82, %75 ], [ %82, %96 ], [ %82, %95 ], [ %82, %94 ], [ %82, %93 ], [ %82, %92 ], [ 1, %91 ], [ %82, %89 ], [ %82, %88 ]
%101 = phi i32 [ %81, %75 ], [ %81, %96 ], [ %81, %95 ], [ %81, %94 ], [ %81, %93 ], [ 1, %92 ], [ %81, %91 ], [ %81, %89 ], [ %81, %88 ]
%102 = phi i32 [ %80, %75 ], [ %80, %96 ], [ %80, %95 ], [ %80, %94 ], [ 1, %93 ], [ %80, %92 ], [ %80, %91 ], [ %80, %89 ], [ %80, %88 ]
%103 = phi i32 [ %79, %75 ], [ %79, %96 ], [ %79, %95 ], [ 1, %94 ], [ %79, %93 ], [ %79, %92 ], [ %79, %91 ], [ %79, %89 ], [ %79, %88 ]
%104 = phi i32 [ %78, %75 ], [ %78, %96 ], [ 1, %95 ], [ %78, %94 ], [ %78, %93 ], [ %78, %92 ], [ %78, %91 ], [ %78, %89 ], [ %78, %88 ]
%105 = phi i32 [ %77, %75 ], [ 1, %96 ], [ %77, %95 ], [ %77, %94 ], [ %77, %93 ], [ %77, %92 ], [ %77, %91 ], [ %77, %89 ], [ %77, %88 ]
%106 = load i8, i8* %86
%107 = icmp eq i8 %106, 0
br i1 %107, label %108, label %75
108: ; preds = %97, %70, %67
%109 = phi i32 [ 0, %67 ], [ 0, %70 ], [ %98, %97 ]
%110 = phi i32 [ 0, %67 ], [ 0, %70 ], [ %99, %97 ]
%111 = phi i32 [ 0, %67 ], [ 0, %70 ], [ %100, %97 ]
%112 = phi i32 [ 0, %67 ], [ 0, %70 ], [ %101, %97 ]
%113 = phi i32 [ 0, %67 ], [ 0, %70 ], [ %102, %97 ]
%114 = phi i32 [ 0, %67 ], [ 0, %70 ], [ %103, %97 ]
%115 = phi i32 [ 0, %67 ], [ 0, %70 ], [ %104, %97 ]
%116 = phi i32 [ 0, %67 ], [ 0, %70 ], [ %105, %97 ]
%117 = fcmp olt double %23, 1.000000e+00
%118 = zext i1 %117 to i32
%119 = icmp ne i32 %68, 0
%120 = zext i1 %119 to i32
%121 = add nuw nsw i32 %118, %12
%122 = add i32 %121, %62
%123 = add i32 %122, %68
%124 = add i32 %123, %120
%125 = add i32 %124, %110
%126 = add i32 %125, %112
%127 = add i32 %126, %114
%128 = add i32 %127, %116
%129 = icmp slt i32 %3, 1
br i1 %129, label %173, label %130
130: ; preds = %108
%131 = icmp sgt i32 %128, %3
br i1 %131, label %132, label %173
132: ; preds = %130
%133 = sext i1 %117 to i32
%134 = add nsw i32 %128, %133
%135 = icmp ne i32 %114, 0
%136 = icmp sgt i32 %134, %3
%137 = xor i1 %136, true
%138 = select i1 %135, i1 %137, i1 false
%139 = select i1 %135, i1 %136, i1 false
%140 = sext i1 %139 to i32
%141 = add nsw i32 %134, %140
%142 = icmp sgt i32 %141, %3
%143 = icmp ne i32 %110, 0
%144 = select i1 %142, i1 %143, i1 false
%145 = select i1 %144, i32 0, i32 %110
%146 = select i1 %144, i32 %110, i32 0
%147 = sub nsw i32 %141, %146
%148 = icmp slt i32 %147, %3
%149 = select i1 %148, i1 %135, i1 false
%150 = select i1 %149, i1 true, i1 %138
%151 = zext i1 %150 to i32
%152 = zext i1 %149 to i32
%153 = add nsw i32 %147, %152
%154 = icmp sgt i32 %153, %3
%155 = icmp ne i32 %112, 0
%156 = select i1 %154, i1 %155, i1 false
%157 = select i1 %156, i32 0, i32 %112
%158 = sext i1 %156 to i32
%159 = add nsw i32 %153, %158
%160 = icmp sgt i32 %159, %3
%161 = icmp ne i32 %116, 0
%162 = select i1 %160, i1 %161, i1 false
%163 = sext i1 %162 to i32
%164 = add nsw i32 %159, %163
%165 = select i1 %162, i32 0, i32 %116
%166 = icmp sgt i32 %164, %3
br i1 %166, label %169, label %173
167: ; preds = %494, %511
%168 = icmp sgt i32 %179, 0
br i1 %168, label %169, label %513
169: ; preds = %132, %167
%170 = phi i32 [ %179, %167 ], [ %3, %132 ]
%171 = zext i32 %170 to i64
%172 = zext i32 %170 to i64
br label %513
173: ; preds = %108, %130, %132
%174 = phi i32 [ %145, %132 ], [ %110, %130 ], [ %110, %108 ]
%175 = phi i32 [ %157, %132 ], [ %112, %130 ], [ %112, %108 ]
%176 = phi i32 [ %151, %132 ], [ %114, %130 ], [ %114, %108 ]
%177 = phi i32 [ %164, %132 ], [ %128, %130 ], [ %128, %108 ]
%178 = phi i32 [ 0, %132 ], [ %118, %130 ], [ %118, %108 ]
%179 = phi i32 [ %3, %132 ], [ %3, %130 ], [ %128, %108 ]
%180 = phi i32 [ %165, %132 ], [ %116, %130 ], [ %116, %108 ]
%181 = sitofp i32 %68 to double
%182 = tail call double @pow(double %10, double %181)
%183 = fadd double %182, 5.000000e-01
%184 = tail call double @llvm.floor.f64(double %183)
%185 = tail call double @llvm.fmuladd.f64(double %23, double %184, double 5.000000e-01)
%186 = tail call double @llvm.floor.f64(double %185)
%187 = icmp ne i32 %109, 0
%188 = fcmp oeq double %186, 0.000000e+00
%189 = select i1 %187, i1 %188, i1 false
br i1 %189, label %190, label %196
190: ; preds = %173
%191 = icmp sgt i32 %3, 0
br i1 %191, label %192, label %194
192: ; preds = %190
%193 = zext i32 %3 to i64
br label %194
194: ; preds = %192, %190
%195 = sext i32 %3 to i64
br label %513
196: ; preds = %173
%197 = sext i32 %179 to i64
%198 = getelementptr inbounds i8, i8* %5, i64 %197
store i8 0, i8* %198
%199 = icmp eq i32 %111, 0
%200 = icmp sle i32 %179, %177
%201 = select i1 %199, i1 true, i1 %200
%202 = sub i32 %179, %177
%203 = icmp eq i32 %202, 0
%204 = select i1 %201, i1 true, i1 %203
br i1 %204, label %265, label %205
205: ; preds = %196
%206 = xor i32 %177, -1
%207 = add i32 %179, %206
%208 = zext i32 %207 to i64
%209 = xor i64 %208, -1
%210 = add nsw i64 %209, %197
%211 = getelementptr i8, i8* %5, i64 %210
%212 = add nuw nsw i64 %208, 1
%213 = icmp ult i32 %202, 4
br i1 %213, label %253, label %214
214: ; preds = %205
%215 = and i32 %202, -4
%216 = and i32 %202, 3
%217 = insertelement <2 x i64> <i64 poison, i64 0>, i64 %197, i64 0
%218 = add i32 %215, -4
%219 = lshr exact i32 %218, 2
%220 = add nuw nsw i32 %219, 1
%221 = and i32 %220, 7
%222 = icmp ult i32 %218, 28
br i1 %222, label %233, label %223
223: ; preds = %214
%224 = and i32 %220, 2147483640
br label %225
225: ; preds = %225, %223
%226 = phi <2 x i64> [ %217, %223 ], [ %229, %225 ]
%227 = phi <2 x i64> [ zeroinitializer, %223 ], [ %230, %225 ]
%228 = phi i32 [ 0, %223 ], [ %231, %225 ]
%229 = add <2 x i64> %226, <i64 -8, i64 -8>
%230 = add <2 x i64> %227, <i64 -8, i64 -8>
%231 = add i32 %228, 8
%232 = icmp eq i32 %231, %224
br i1 %232, label %233, label %225
233: ; preds = %225, %214
%234 = phi <2 x i64> [ undef, %214 ], [ %229, %225 ]
%235 = phi <2 x i64> [ undef, %214 ], [ %230, %225 ]
%236 = phi <2 x i64> [ %217, %214 ], [ %229, %225 ]
%237 = phi <2 x i64> [ zeroinitializer, %214 ], [ %230, %225 ]
%238 = icmp eq i32 %221, 0
br i1 %238, label %247, label %239
239: ; preds = %233, %239
%240 = phi <2 x i64> [ %243, %239 ], [ %236, %233 ]
%241 = phi <2 x i64> [ %244, %239 ], [ %237, %233 ]
%242 = phi i32 [ %245, %239 ], [ 0, %233 ]
%243 = add <2 x i64> %240, <i64 -1, i64 -1>
%244 = add <2 x i64> %241, <i64 -1, i64 -1>
%245 = add i32 %242, 1
%246 = icmp eq i32 %245, %221
br i1 %246, label %247, label %239
247: ; preds = %239, %233
%248 = phi <2 x i64> [ %234, %233 ], [ %243, %239 ]
%249 = phi <2 x i64> [ %235, %233 ], [ %244, %239 ]
%250 = add <2 x i64> %249, %248
%251 = call i64 @llvm.vector.reduce.add.v2i64(<2 x i64> %250)
%252 = icmp eq i32 %202, %215
br i1 %252, label %262, label %253
253: ; preds = %205, %247
%254 = phi i64 [ %197, %205 ], [ %251, %247 ]
%255 = phi i32 [ %202, %205 ], [ %216, %247 ]
br label %256
256: ; preds = %253, %256
%257 = phi i64 [ %260, %256 ], [ %254, %253 ]
%258 = phi i32 [ %259, %256 ], [ %255, %253 ]
%259 = add nsw i32 %258, -1
%260 = add nsw i64 %257, -1
%261 = icmp eq i32 %259, 0
br i1 %261, label %262, label %256
262: ; preds = %256, %247
%263 = phi i64 [ %251, %247 ], [ %260, %256 ]
%264 = trunc i64 %263 to i32
br label %265
265: ; preds = %262, %196
%266 = phi i32 [ %179, %196 ], [ %264, %262 ]
%267 = icmp eq i32 %175, 0
br i1 %267, label %273, label %268
268: ; preds = %265
%269 = select i1 %11, i8 41, i8 32
%270 = add nsw i32 %266, -1
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds i8, i8* %5, i64 %271
store i8 %269, i8* %272
br label %273
273: ; preds = %268, %265
%274 = phi i32 [ %270, %268 ], [ %266, %265 ]
%275 = icmp eq i32 %180, 0
br i1 %275, label %280, label %276
276: ; preds = %273
%277 = add nsw i32 %274, -1
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds i8, i8* %5, i64 %278
store i8 37, i8* %279
br label %280
280: ; preds = %276, %273
%281 = phi i32 [ %277, %276 ], [ %274, %273 ]
%282 = icmp sgt i32 %68, 0
%283 = icmp ne i32 %281, 0
%284 = select i1 %282, i1 %283, i1 false
br i1 %284, label %285, label %320
285: ; preds = %280
%286 = icmp ne i32 %115, 0
%287 = sext i32 %281 to i64
br label %288
288: ; preds = %285, %309
%289 = phi i64 [ %287, %285 ], [ %311, %309 ]
%290 = phi double [ %186, %285 ], [ %293, %309 ]
%291 = phi i32 [ 0, %285 ], [ %313, %309 ]
%292 = fdiv double %290, %10
%293 = tail call double @llvm.floor.f64(double %292)
%294 = fsub double %292, %293
%295 = tail call double @llvm.fmuladd.f64(double %10, double %294, double 5.000000e-01)
%296 = tail call double @llvm.floor.f64(double %295)
%297 = fptosi double %296 to i32
%298 = icmp sgt i32 %297, 9
%299 = select i1 %286, i1 %298, i1 false
br i1 %299, label %300, label %305
300: ; preds = %288
%301 = zext i32 %297 to i64
%302 = getelementptr inbounds [37 x i8], [37 x i8]* @Nfmtb.alpha, i64 0, i64 %301
%303 = load i8, i8* %302
%304 = add i8 %303, -32
br label %309
305: ; preds = %288
%306 = sext i32 %297 to i64
%307 = getelementptr inbounds [37 x i8], [37 x i8]* @Nfmtb.alpha, i64 0, i64 %306
%308 = load i8, i8* %307
br label %309
309: ; preds = %305, %300
%310 = phi i8 [ %304, %300 ], [ %308, %305 ]
%311 = add nsw i64 %289, -1
%312 = getelementptr inbounds i8, i8* %5, i64 %311
store i8 %310, i8* %312
%313 = add nuw nsw i32 %291, 1
%314 = icmp slt i32 %313, %68
%315 = trunc i64 %311 to i32
%316 = icmp ne i32 %315, 0
%317 = select i1 %314, i1 %316, i1 false
br i1 %317, label %288, label %318
318: ; preds = %309
%319 = trunc i64 %311 to i32
br label %320
320: ; preds = %318, %280
%321 = phi i32 [ %281, %280 ], [ %319, %318 ]
%322 = phi double [ %186, %280 ], [ %293, %318 ]
%323 = phi i1 [ %283, %280 ], [ %316, %318 ]
%324 = select i1 %119, i1 %323, i1 false
%325 = select i1 %119, i32 0, i32 %321
%326 = select i1 %119, double 1.000000e+00, double %322
br i1 %324, label %327, label %331
327: ; preds = %320
%328 = add nsw i32 %321, -1
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds i8, i8* %5, i64 %329
store i8 46, i8* %330
br label %331
331: ; preds = %320, %327
%332 = phi i32 [ %328, %327 ], [ %325, %320 ]
%333 = phi double [ %322, %327 ], [ %326, %320 ]
%334 = icmp ne i32 %178, 0
%335 = add i32 %176, %12
%336 = icmp sgt i32 %332, %335
%337 = select i1 %334, i1 %336, i1 false
br i1 %337, label %338, label %342
338: ; preds = %331
%339 = add nsw i32 %332, -1
%340 = zext i32 %339 to i64
%341 = getelementptr inbounds i8, i8* %5, i64 %340
store i8 48, i8* %341
br label %342
342: ; preds = %338, %331
%343 = phi i32 [ %339, %338 ], [ %332, %331 ]
%344 = fcmp ogt double %333, 0.000000e+00
%345 = icmp ne i32 %343, 0
%346 = select i1 %344, i1 %345, i1 false
br i1 %346, label %347, label %391
347: ; preds = %342
%348 = icmp ne i32 %174, 0
%349 = icmp ne i32 %115, 0
br label %350
350: ; preds = %347, %384
%351 = phi double [ %333, %347 ], [ %387, %384 ]
%352 = phi i32 [ 0, %347 ], [ %386, %384 ]
%353 = phi i32 [ %343, %347 ], [ %385, %384 ]
%354 = icmp eq i32 %352, %63
%355 = select i1 %348, i1 %354, i1 false
br i1 %355, label %356, label %360
356: ; preds = %350
%357 = add nsw i32 %353, -1
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds i8, i8* %5, i64 %358
store i8 44, i8* %359
br label %384
360: ; preds = %350
%361 = fdiv double %351, %10
%362 = tail call double @llvm.floor.f64(double %361)
%363 = fsub double %361, %362
%364 = tail call double @llvm.fmuladd.f64(double %10, double %363, double 5.000000e-01)
%365 = tail call double @llvm.floor.f64(double %364)
%366 = fptosi double %365 to i32
%367 = icmp sgt i32 %366, 9
%368 = select i1 %349, i1 %367, i1 false
br i1 %368, label %369, label %374
369: ; preds = %360
%370 = zext i32 %366 to i64
%371 = getelementptr inbounds [37 x i8], [37 x i8]* @Nfmtb.alpha, i64 0, i64 %370
%372 = load i8, i8* %371
%373 = add i8 %372, -32
br label %378
374: ; preds = %360
%375 = sext i32 %366 to i64
%376 = getelementptr inbounds [37 x i8], [37 x i8]* @Nfmtb.alpha, i64 0, i64 %375
%377 = load i8, i8* %376
br label %378
378: ; preds = %374, %369
%379 = phi i8 [ %373, %369 ], [ %377, %374 ]
%380 = add nsw i32 %353, -1
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds i8, i8* %5, i64 %381
store i8 %379, i8* %382
%383 = add nsw i32 %352, 1
br label %384
384: ; preds = %378, %356
%385 = phi i32 [ %357, %356 ], [ %380, %378 ]
%386 = phi i32 [ 0, %356 ], [ %383, %378 ]
%387 = phi double [ %351, %356 ], [ %362, %378 ]
%388 = fcmp ogt double %387, 0.000000e+00
%389 = icmp ne i32 %385, 0
%390 = select i1 %388, i1 %389, i1 false
br i1 %390, label %350, label %391
391: ; preds = %384, %342
%392 = phi i32 [ %343, %342 ], [ %385, %384 ]
%393 = phi double [ %333, %342 ], [ %387, %384 ]
%394 = icmp ne i32 %113, 0
%395 = icmp sgt i32 %392, %335
%396 = select i1 %394, i1 %395, i1 false
br i1 %396, label %397, label %483
397: ; preds = %391
%398 = sub i32 %392, %335
%399 = icmp ult i32 %398, 32
%400 = add i32 %392, -1
%401 = icmp ugt i32 %335, %400
%402 = or i1 %399, %401
br i1 %402, label %475, label %403
403: ; preds = %397
%404 = and i32 %398, -32
%405 = sub i32 %392, %404
%406 = add i32 %404, -32
%407 = lshr exact i32 %406, 5
%408 = add nuw nsw i32 %407, 1
%409 = and i32 %408, 3
%410 = icmp ult i32 %406, 96
br i1 %410, label %455, label %411
411: ; preds = %403
%412 = and i32 %408, 268435452
br label %413
413: ; preds = %413, %411
%414 = phi i32 [ 0, %411 ], [ %452, %413 ]
%415 = phi i32 [ 0, %411 ], [ %453, %413 ]
%416 = xor i32 %414, -1
%417 = add i32 %392, %416
%418 = zext i32 %417 to i64
%419 = getelementptr inbounds i8, i8* %5, i64 %418
%420 = getelementptr inbounds i8, i8* %419, i64 -15
%421 = bitcast i8* %420 to <16 x i8>*
store <16 x i8> <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>, <16 x i8>* %421
%422 = getelementptr inbounds i8, i8* %419, i64 -16
%423 = getelementptr inbounds i8, i8* %422, i64 -15
%424 = bitcast i8* %423 to <16 x i8>*
store <16 x i8> <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>, <16 x i8>* %424
%425 = sub nuw nsw i32 -33, %414
%426 = add i32 %392, %425
%427 = zext i32 %426 to i64
%428 = getelementptr inbounds i8, i8* %5, i64 %427
%429 = getelementptr inbounds i8, i8* %428, i64 -15
%430 = bitcast i8* %429 to <16 x i8>*
store <16 x i8> <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>, <16 x i8>* %430
%431 = getelementptr inbounds i8, i8* %428, i64 -16
%432 = getelementptr inbounds i8, i8* %431, i64 -15
%433 = bitcast i8* %432 to <16 x i8>*
store <16 x i8> <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>, <16 x i8>* %433
%434 = sub nuw nsw i32 -65, %414
%435 = add i32 %392, %434
%436 = zext i32 %435 to i64
%437 = getelementptr inbounds i8, i8* %5, i64 %436
%438 = getelementptr inbounds i8, i8* %437, i64 -15
%439 = bitcast i8* %438 to <16 x i8>*
store <16 x i8> <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>, <16 x i8>* %439
%440 = getelementptr inbounds i8, i8* %437, i64 -16
%441 = getelementptr inbounds i8, i8* %440, i64 -15
%442 = bitcast i8* %441 to <16 x i8>*
store <16 x i8> <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>, <16 x i8>* %442
%443 = sub nuw nsw i32 -97, %414
%444 = add i32 %392, %443
%445 = zext i32 %444 to i64
%446 = getelementptr inbounds i8, i8* %5, i64 %445
%447 = getelementptr inbounds i8, i8* %446, i64 -15
%448 = bitcast i8* %447 to <16 x i8>*
store <16 x i8> <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>, <16 x i8>* %448
%449 = getelementptr inbounds i8, i8* %446, i64 -16
%450 = getelementptr inbounds i8, i8* %449, i64 -15
%451 = bitcast i8* %450 to <16 x i8>*
store <16 x i8> <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>, <16 x i8>* %451
%452 = add nuw i32 %414, 128
%453 = add i32 %415, 4
%454 = icmp eq i32 %453, %412
br i1 %454, label %455, label %413
455: ; preds = %413, %403
%456 = phi i32 [ 0, %403 ], [ %452, %413 ]
%457 = icmp eq i32 %409, 0
br i1 %457, label %473, label %458
458: ; preds = %455, %458
%459 = phi i32 [ %470, %458 ], [ %456, %455 ]
%460 = phi i32 [ %471, %458 ], [ 0, %455 ]
%461 = xor i32 %459, -1
%462 = add i32 %392, %461
%463 = zext i32 %462 to i64
%464 = getelementptr inbounds i8, i8* %5, i64 %463
%465 = getelementptr inbounds i8, i8* %464, i64 -15
%466 = bitcast i8* %465 to <16 x i8>*
store <16 x i8> <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>, <16 x i8>* %466
%467 = getelementptr inbounds i8, i8* %464, i64 -16
%468 = getelementptr inbounds i8, i8* %467, i64 -15
%469 = bitcast i8* %468 to <16 x i8>*
store <16 x i8> <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>, <16 x i8>* %469
%470 = add nuw i32 %459, 32
%471 = add i32 %460, 1
%472 = icmp eq i32 %471, %409
br i1 %472, label %473, label %458
473: ; preds = %458, %455
%474 = icmp eq i32 %398, %404
br i1 %474, label %483, label %475
475: ; preds = %397, %473
%476 = phi i32 [ %392, %397 ], [ %405, %473 ]
br label %477
477: ; preds = %475, %477
%478 = phi i32 [ %479, %477 ], [ %476, %475 ]
%479 = add nsw i32 %478, -1
%480 = zext i32 %479 to i64
%481 = getelementptr inbounds i8, i8* %5, i64 %480
store i8 48, i8* %481
%482 = icmp sgt i32 %479, %335
br i1 %482, label %477, label %483
483: ; preds = %477, %473, %391
%484 = phi i32 [ %392, %391 ], [ %405, %473 ], [ %479, %477 ]
%485 = icmp ne i32 %176, 0
%486 = icmp ne i32 %484, 0
%487 = select i1 %485, i1 %486, i1 false
br i1 %487, label %488, label %492
488: ; preds = %483
%489 = add nsw i32 %484, -1
%490 = sext i32 %489 to i64
%491 = getelementptr inbounds i8, i8* %5, i64 %490
store i8 36, i8* %491
br label %492
492: ; preds = %488, %483
%493 = phi i32 [ %489, %488 ], [ %484, %483 ]
br i1 %11, label %494, label %501
494: ; preds = %492
%495 = icmp eq i32 %493, 0
br i1 %495, label %167, label %496
496: ; preds = %494
%497 = select i1 %267, i8 45, i8 40
%498 = add nsw i32 %493, -1
%499 = sext i32 %498 to i64
%500 = getelementptr inbounds i8, i8* %5, i64 %499
store i8 %497, i8* %500
br label %501
501: ; preds = %496, %492
%502 = phi i32 [ %498, %496 ], [ %493, %492 ]
%503 = icmp eq i32 %502, 0
br i1 %503, label %511, label %504
504: ; preds = %501
%505 = add i32 %502, -1
%506 = sext i32 %505 to i64
%507 = zext i32 %505 to i64
%508 = sub nsw i64 %506, %507
%509 = getelementptr i8, i8* %5, i64 %508
%510 = zext i32 %502 to i64
br label %511
511: ; preds = %504, %501
%512 = fcmp une double %393, 0.000000e+00
br i1 %512, label %167, label %516
513: ; preds = %167, %169, %194
%514 = phi i64 [ %195, %194 ], [ 0, %167 ], [ %172, %169 ]
%515 = getelementptr inbounds i8, i8* %5, i64 %514
store i8 0, i8* %515
br label %516
516: ; preds = %513, %511
ret i8* %5
}