#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 */

/* Variables and functions */
int /*<<< orphan*/ exit(int /*<<< orphan*/);
int /*<<< orphan*/ flierr(long double, long double, int);
long double floorl(long double);
long double ldexpl(long double, int);
int /*<<< orphan*/ printf(char *, ...);
int main() {
  long double x, y, y0, z, f, x00, y00;
  int i, j, e, e0;
  int errfr, errld, errfl, underexp, err, errth, e00;
  long double frexpl(), ldexpl(), floorl();
  printf("Testing frexpl() and ldexpl().\n");
  errth = 0.0L;
  errfr = 0;
  errld = 0;
  underexp = 0;
  f = 1.0L;
  x00 = 2.0L;
  y00 = 0.5L;
  e00 = 2;
  for (j = 0; j < 20; j++) {
    if (j == 10) {
      f = 1.0L;
      x00 = 2.0L;
      e00 = 1;
      for (i = 0; i < 13; i++) {
        x00 *= x00;
        e00 += e00;
      }
      y00 = x00 / 2.0L;
      x00 = x00 * y00;
      e00 += e00;
      y00 = 0.5L;
    }
    x = x00 * f;
    y0 = y00 * f;
    e0 = e00;
    for (i = 0; i < 16448; i++) {
      x /= 2.0L;
      e0 -= 1;
      if (x == 0.0L) {
        if (f == 1.0L)
          underexp = e0;
        y0 = 0.0L;
        e0 = 0;
      }
      y = frexpl(x, &e);
      if ((e0 < -16383) && (e != e0)) {
        if (e == (e0 - 1)) {
          e += 1;
          y /= 2.0L;
        }
        if (e == (e0 + 1)) {
          e -= 1;
          y *= 2.0L;
        }
      }
      err = y - y0;
      if (y0 != 0.0L)
        err /= y0;
      if (err < 0.0L)
        err = -err;
      if (e0 > -1023)
        errth = 0.0L;
      else {
        if (e0 == -16383) {
          errth = 2.0L * 5.42101086242752217003726400434970855712890625E-20L;
        } else {
          errth *= 2.0L;
        }
      }
      if ((x != 0.0L) && ((err > errth) || (e != e0))) {
        printf("Test %d: ", j + 1);
        printf(" frexpl( %.20Le) =?= %.20Le * 2**%d;", x, y, e);
        printf(" should be %.20Le * 2**%d\n", y0, e0);
        errfr += 1;
      }
      y = ldexpl(x, 1 - e0);
      err = y - 1.0L;
      if (err < 0.0L)
        err = -err;
      if ((err > errth) && ((x == 0.0L) && (y != 0.0L))) {
        printf("Test %d: ", j + 1);
        printf("ldexpl( %.15Le, %d ) =?= %.15Le;", x, 1 - e0, y);
        if (x != 0.0L)
          printf(" should be %.15Le\n", f);
        else
          printf(" should be %.15Le\n", 0.0L);
        errld += 1;
      }
      if (x == 0.0L) {
        break;
      }
    }
    f = f * 1.08005973889L;
  }
  if ((errld == 0) && (errfr == 0)) {
    printf("No errors found.\n");
  }
  printf("Testing floorl().\n");
  errfl = 0;
  f = 1.0L / 5.42101086242752217003726400434970855712890625E-20L;
  x00 = 1.0L;
  for (j = 0; j < 57; j++) {
    x = x00 - 1.0L;
    for (i = 0; i < 128; i++) {
      y = floorl(x);
      if (y != x) {
        flierr(x, y, j);
        errfl += 1;
      }
      z = x - 0.49L;
      y = floorl(z);
      if (z == x)
        break;
      if (y != (x - 1.0L)) {
        flierr(z, y, j);
        errfl += 1;
      }
      z = x + 0.49L;
      y = floorl(z);
      if (z != x) {
        if (y != x) {
          flierr(z, y, j);
          errfl += 1;
        }
      }
      x = -x;
      y = floorl(x);
      if (z != x) {
        if (y != x) {
          flierr(x, y, j);
          errfl += 1;
        }
      }
      z = x + 0.49L;
      y = floorl(z);
      if (z != x) {
        if (y != x) {
          flierr(z, y, j);
          errfl += 1;
        }
      }
      z = x - 0.49L;
      y = floorl(z);
      if (z != x) {
        if (y != (x - 1.0L)) {
          flierr(z, y, j);
          errfl += 1;
        }
      }
      x = -x;
      x += 1.0L;
    }
    x00 = x00 + x00;
  }
  y = floorl(0.0L);
  if (y != 0.0L) {
    flierr(0.0L, y, 57);
    errfl += 1;
  }
  y = floorl(-0.0L);
  if (y != 0.0L) {
    flierr(-0.0L, y, 58);
    errfl += 1;
  }
  y = floorl(-1.0L);
  if (y != -1.0L) {
    flierr(-1.0L, y, 59);
    errfl += 1;
  }
  y = floorl(-0.1L);
  if (y != -1.0l) {
    flierr(-0.1L, y, 60);
    errfl += 1;
  }
  if (errfl == 0)
    printf("No errors found in floorl().\n");
  exit(0);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xed7(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
movl   $0x0,-0xa8(%rbp)
movl   $0x0,-0x94(%rbp)
movl   $0x0,-0x98(%rbp)
movl   $0x0,-0xa0(%rbp)
fld1
fstpt  -0x60(%rbp)
flds   0xe4d(%rip)
fstpt  -0x70(%rbp)
flds   0xe48(%rip)
fstpt  -0x80(%rbp)
movl   $0x2,-0xac(%rbp)
movl   $0x0,-0x88(%rbp)
cmpl   $0x14,-0x88(%rbp)
jge    17b5 <main+0x655>
cmpl   $0xa,-0x88(%rbp)
jne    127a <main+0x11a>
fld1
fstpt  -0x60(%rbp)
flds   0xe08(%rip)
fstpt  -0x70(%rbp)
movl   $0x1,-0xac(%rbp)
movl   $0x0,-0x84(%rbp)
cmpl   $0xd,-0x84(%rbp)
jge    124a <main+0xea>
fldt   -0x70(%rbp)
fmul   %st,%st(0)
fstpt  -0x70(%rbp)
mov    -0xac(%rbp),%eax
add    -0xac(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    120f <main+0xaf>
fldt   -0x70(%rbp)
flds   0xdad(%rip)
fdivrp %st,%st(1)
fstpt  -0x80(%rbp)
fldt   -0x70(%rbp)
fldt   -0x80(%rbp)
fmulp  %st,%st(1)
fstpt  -0x70(%rbp)
mov    -0xac(%rbp),%eax
add    %eax,%eax
mov    %eax,-0xac(%rbp)
flds   0xd8d(%rip)
fstpt  -0x80(%rbp)
fldt   -0x70(%rbp)
fldt   -0x60(%rbp)
fmulp  %st,%st(1)
fstpt  -0x20(%rbp)
fldt   -0x80(%rbp)
fldt   -0x60(%rbp)
fmulp  %st,%st(1)
fstpt  -0x40(%rbp)
mov    -0xac(%rbp),%eax
mov    %eax,-0x90(%rbp)
movl   $0x0,-0x84(%rbp)
cmpl   $0x4040,-0x84(%rbp)
jge    1793 <main+0x633>
fldt   -0x20(%rbp)
flds   0xd41(%rip)
fdivrp %st,%st(1)
fstpt  -0x20(%rbp)
mov    -0x90(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x90(%rbp)
fldt   -0x20(%rbp)
fldz
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    1326 <main+0x1c6>
jp     1326 <main+0x1c6>
jmp    12ef <main+0x18f>
fldt   -0x60(%rbp)
fld1
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    1317 <main+0x1b7>
jp     1317 <main+0x1b7>
jmp    130b <main+0x1ab>
mov    -0x90(%rbp),%eax
mov    %eax,-0xa0(%rbp)
fldz
fstpt  -0x40(%rbp)
movl   $0x0,-0x90(%rbp)
fldt   -0x20(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
lea    -0x8c(%rbp),%rdi
call   1040 <frexpl@plt>
fstpt  -0x30(%rbp)
cmpl   $0xffffc001,-0x90(%rbp)
c0 ff ff
jge    13c6 <main+0x266>
mov    -0x8c(%rbp),%eax
cmp    -0x90(%rbp),%eax
je     13c6 <main+0x266>
mov    -0x8c(%rbp),%eax
mov    -0x90(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1393 <main+0x233>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
fldt   -0x30(%rbp)
flds   0xc72(%rip)
fdivrp %st,%st(1)
fstpt  -0x30(%rbp)
mov    -0x8c(%rbp),%eax
mov    -0x90(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jne    13c1 <main+0x261>
mov    -0x8c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x8c(%rbp)
fldt   -0x30(%rbp)
fadd   %st,%st(0)
fstpt  -0x30(%rbp)
jmp    13c6 <main+0x266>
fldt   -0x30(%rbp)
fldt   -0x40(%rbp)
fsubrp %st,%st(1)
fnstcw -0xce(%rbp)
movzwl -0xce(%rbp),%eax
or     $0xc00,%eax
mov    %ax,-0xd0(%rbp)
fldcw  -0xd0(%rbp)
fistpl -0xb0(%rbp)
fldcw  -0xce(%rbp)
mov    -0xb0(%rbp),%eax
mov    %eax,-0xa4(%rbp)
fldt   -0x40(%rbp)
fldz
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    1421 <main+0x2c1>
jp     1421 <main+0x2c1>
jmp    146f <main+0x30f>
fldt   -0x40(%rbp)
mov    -0xa4(%rbp),%eax
mov    %eax,-0xb8(%rbp)
fildl  -0xb8(%rbp)
fdivp  %st,%st(1)
fnstcw -0xd2(%rbp)
movzwl -0xd2(%rbp),%eax
or     $0xc00,%eax
mov    %ax,-0xd4(%rbp)
fldcw  -0xd4(%rbp)
fistpl -0xb4(%rbp)
fldcw  -0xd2(%rbp)
mov    -0xb4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
mov    %eax,-0xbc(%rbp)
fildl  -0xbc(%rbp)
fldz
fucomip %st(1),%st
fstp   %st(0)
jbe    14a0 <main+0x340>
jmp    1492 <main+0x332>
xor    %eax,%eax
sub    -0xa4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
cmpl   $0xfffffc01,-0x90(%rbp)
fc ff ff
jle    14bf <main+0x35f>
movl   $0x0,-0xa8(%rbp)
jmp    152e <main+0x3ce>
cmpl   $0xffffc001,-0x90(%rbp)
c0 ff ff
jne    14de <main+0x37e>
movl   $0x0,-0xa8(%rbp)
jmp    1529 <main+0x3c9>
mov    -0xa8(%rbp),%eax
mov    %eax,-0xc4(%rbp)
fildl  -0xc4(%rbp)
fadd   %st,%st(0)
fnstcw -0xd6(%rbp)
movzwl -0xd6(%rbp),%eax
or     $0xc00,%eax
mov    %ax,-0xd8(%rbp)
fldcw  -0xd8(%rbp)
fistpl -0xc0(%rbp)
fldcw  -0xd6(%rbp)
mov    -0xc0(%rbp),%eax
mov    %eax,-0xa8(%rbp)
jmp    152e <main+0x3ce>
fldt   -0x20(%rbp)
fldz
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    154a <main+0x3ea>
jp     154a <main+0x3ea>
jmp    15dc <main+0x47c>
mov    -0xa4(%rbp),%eax
cmp    -0xa8(%rbp),%eax
jg     156e <main+0x40e>
mov    -0x8c(%rbp),%eax
cmp    -0x90(%rbp),%eax
je     15dc <main+0x47c>
mov    -0x88(%rbp),%esi
add    $0x1,%esi
lea    0xaf2(%rip),%rdi
xor    %eax,%eax
mov    %al,-0xdd(%rbp)
call   1030 <printf@plt>
mov    -0xdd(%rbp),%al
fldt   -0x20(%rbp)
fldt   -0x30(%rbp)
mov    -0x8c(%rbp),%esi
mov    %rsp,%rcx
fstpt  0x10(%rcx)
fstpt  (%rcx)
lea    0xace(%rip),%rdi
call   1030 <printf@plt>
fldt   -0x40(%rbp)
mov    -0x90(%rbp),%esi
mov    %rsp,%rax
fstpt  (%rax)
lea    0xad9(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
fldt   -0x20(%rbp)
mov    -0x90(%rbp),%eax
mov    $0x1,%edi
sub    %eax,%edi
mov    %rsp,%rax
fstpt  (%rax)
call   1050 <ldexpl@plt>
fstpt  -0x30(%rbp)
fldt   -0x30(%rbp)
fld1
fchs
faddp  %st,%st(1)
fnstcw -0xda(%rbp)
movzwl -0xda(%rbp),%eax
or     $0xc00,%eax
mov    %ax,-0xdc(%rbp)
fldcw  -0xdc(%rbp)
fistpl -0xcc(%rbp)
fldcw  -0xda(%rbp)
mov    -0xcc(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
mov    %eax,-0xc8(%rbp)
fildl  -0xc8(%rbp)
fldz
fucomip %st(1),%st
fstp   %st(0)
jbe    166a <main+0x50a>
jmp    165c <main+0x4fc>
xor    %eax,%eax
sub    -0xa4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0xa8(%rbp),%eax
jle    1759 <main+0x5f9>
fldt   -0x20(%rbp)
fldz
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    1759 <main+0x5f9>
jp     1759 <main+0x5f9>
jmp    1698 <main+0x538>
fldt   -0x30(%rbp)
fldz
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    16b4 <main+0x554>
jp     16b4 <main+0x554>
jmp    1759 <main+0x5f9>
mov    -0x88(%rbp),%esi
add    $0x1,%esi
lea    0x9ac(%rip),%rdi
xor    %eax,%eax
mov    %al,-0xde(%rbp)
call   1030 <printf@plt>
mov    -0xde(%rbp),%al
fldt   -0x20(%rbp)
mov    -0x90(%rbp),%ecx
mov    $0x1,%esi
sub    %ecx,%esi
fldt   -0x30(%rbp)
mov    %rsp,%rcx
fstpt  0x10(%rcx)
fstpt  (%rcx)
lea    0x9c1(%rip),%rdi
call   1030 <printf@plt>
fldt   -0x20(%rbp)
fldz
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    171a <main+0x5ba>
jp     171a <main+0x5ba>
jmp    1735 <main+0x5d5>
fldt   -0x60(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
lea    0x9b2(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
jmp    174a <main+0x5ea>
mov    %rsp,%rax
fldz
fstpt  (%rax)
lea    0x998(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
fldt   -0x20(%rbp)
fldz
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    177a <main+0x61a>
jp     177a <main+0x61a>
jmp    1775 <main+0x615>
jmp    1793 <main+0x633>
jmp    177f <main+0x61f>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    12a6 <main+0x146>
fldt   -0x60(%rbp)
fldt   0x8a4(%rip)
fmulp  %st,%st(1)
fstpt  -0x60(%rbp)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    11d3 <main+0x73>
cmpl   $0x0,-0x98(%rbp)
jne    17dd <main+0x67d>
cmpl   $0x0,-0x94(%rbp)
jne    17dd <main+0x67d>
lea    0x918(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x91c(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
movl   $0x0,-0x9c(%rbp)
flds   0x80d(%rip)
fstpt  -0x60(%rbp)
fld1
fstpt  -0x70(%rbp)
movl   $0x0,-0x88(%rbp)
cmpl   $0x39,-0x88(%rbp)
jge    1b76 <main+0xa16>
fldt   -0x70(%rbp)
fld1
fchs
faddp  %st,%st(1)
fstpt  -0x20(%rbp)
movl   $0x0,-0x84(%rbp)
cmpl   $0x80,-0x84(%rbp)
jge    1b5a <main+0x9fa>
fldt   -0x20(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   1070 <floorl@plt>
fstpt  -0x30(%rbp)
fldt   -0x30(%rbp)
fldt   -0x20(%rbp)
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    186d <main+0x70d>
jp     186d <main+0x70d>
jmp    1895 <main+0x735>
fldt   -0x20(%rbp)
fldt   -0x30(%rbp)
mov    -0x88(%rbp),%edi
mov    %rsp,%rax
fstpt  0x10(%rax)
fstpt  (%rax)
call   1080 <flierr@plt>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
fldt   -0x20(%rbp)
fldt   0x782(%rip)
faddp  %st,%st(1)
fstpt  -0x50(%rbp)
fldt   -0x50(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   1070 <floorl@plt>
fstpt  -0x30(%rbp)
fldt   -0x50(%rbp)
fldt   -0x20(%rbp)
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    18d5 <main+0x775>
jp     18d5 <main+0x775>
jmp    18d0 <main+0x770>
jmp    1b5a <main+0x9fa>
fldt   -0x30(%rbp)
fldt   -0x20(%rbp)
fld1
fchs
faddp  %st,%st(1)
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    18f8 <main+0x798>
jp     18f8 <main+0x798>
jmp    1920 <main+0x7c0>
fldt   -0x50(%rbp)
fldt   -0x30(%rbp)
mov    -0x88(%rbp),%edi
mov    %rsp,%rax
fstpt  0x10(%rax)
fstpt  (%rax)
call   1080 <flierr@plt>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
fldt   -0x20(%rbp)
fldt   0x707(%rip)
faddp  %st,%st(1)
fstpt  -0x50(%rbp)
fldt   -0x50(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   1070 <floorl@plt>
fstpt  -0x30(%rbp)
fldt   -0x50(%rbp)
fldt   -0x20(%rbp)
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    195b <main+0x7fb>
jp     195b <main+0x7fb>
jmp    19a5 <main+0x845>
fldt   -0x30(%rbp)
fldt   -0x20(%rbp)
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    1978 <main+0x818>
jp     1978 <main+0x818>
jmp    19a0 <main+0x840>
fldt   -0x50(%rbp)
fldt   -0x30(%rbp)
mov    -0x88(%rbp),%edi
mov    %rsp,%rax
fstpt  0x10(%rax)
fstpt  (%rax)
call   1080 <flierr@plt>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    19a5 <main+0x845>
fldt   -0x20(%rbp)
fchs
fstpt  -0x20(%rbp)
fldt   -0x20(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   1070 <floorl@plt>
fstpt  -0x30(%rbp)
fldt   -0x50(%rbp)
fldt   -0x20(%rbp)
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    19da <main+0x87a>
jp     19da <main+0x87a>
jmp    1a24 <main+0x8c4>
fldt   -0x30(%rbp)
fldt   -0x20(%rbp)
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    19f7 <main+0x897>
jp     19f7 <main+0x897>
jmp    1a1f <main+0x8bf>
fldt   -0x20(%rbp)
fldt   -0x30(%rbp)
mov    -0x88(%rbp),%edi
mov    %rsp,%rax
fstpt  0x10(%rax)
fstpt  (%rax)
call   1080 <flierr@plt>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1a24 <main+0x8c4>
fldt   -0x20(%rbp)
fldt   0x603(%rip)
faddp  %st,%st(1)
fstpt  -0x50(%rbp)
fldt   -0x50(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   1070 <floorl@plt>
fstpt  -0x30(%rbp)
fldt   -0x50(%rbp)
fldt   -0x20(%rbp)
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    1a5f <main+0x8ff>
jp     1a5f <main+0x8ff>
jmp    1aa9 <main+0x949>
fldt   -0x30(%rbp)
fldt   -0x20(%rbp)
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    1a7c <main+0x91c>
jp     1a7c <main+0x91c>
jmp    1aa4 <main+0x944>
fldt   -0x50(%rbp)
fldt   -0x30(%rbp)
mov    -0x88(%rbp),%edi
mov    %rsp,%rax
fstpt  0x10(%rax)
fstpt  (%rax)
call   1080 <flierr@plt>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1aa9 <main+0x949>
fldt   -0x20(%rbp)
fldt   0x56e(%rip)
faddp  %st,%st(1)
fstpt  -0x50(%rbp)
fldt   -0x50(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
call   1070 <floorl@plt>
fstpt  -0x30(%rbp)
fldt   -0x50(%rbp)
fldt   -0x20(%rbp)
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    1ae4 <main+0x984>
jp     1ae4 <main+0x984>
jmp    1b34 <main+0x9d4>
fldt   -0x30(%rbp)
fldt   -0x20(%rbp)
fld1
fchs
faddp  %st,%st(1)
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    1b07 <main+0x9a7>
jp     1b07 <main+0x9a7>
jmp    1b2f <main+0x9cf>
fldt   -0x50(%rbp)
fldt   -0x30(%rbp)
mov    -0x88(%rbp),%edi
mov    %rsp,%rax
fstpt  0x10(%rax)
fstpt  (%rax)
call   1080 <flierr@plt>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1b34 <main+0x9d4>
fldt   -0x20(%rbp)
fchs
fstpt  -0x20(%rbp)
fldt   -0x20(%rbp)
fld1
faddp  %st,%st(1)
fstpt  -0x20(%rbp)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1830 <main+0x6d0>
fldt   -0x70(%rbp)
fadd   %st,%st(0)
fstpt  -0x70(%rbp)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    180d <main+0x6ad>
fldz
fld    %st(0)
fstpt  -0x30(%rbp)
fldt   -0x30(%rbp)
fucomip %st(1),%st
fstp   %st(0)
jne    1b95 <main+0xa35>
jp     1b95 <main+0xa35>
jmp    1bbb <main+0xa5b>
fldt   -0x30(%rbp)
mov    %rsp,%rax
fstpt  0x10(%rax)
fldz
fstpt  (%rax)
mov    $0x39,%edi
call   1080 <flierr@plt>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
fldz
fld    %st(0)
fchs
fstpt  -0x30(%rbp)
fldt   -0x30(%rbp)
fucomip %st(1),%st
fstp   %st(0)
jne    1bdc <main+0xa7c>
jp     1bdc <main+0xa7c>
jmp    1c04 <main+0xaa4>
fldt   -0x30(%rbp)
mov    %rsp,%rax
fstpt  0x10(%rax)
fldz
fchs
fstpt  (%rax)
mov    $0x3a,%edi
call   1080 <flierr@plt>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
fld1
fchs
fld    %st(0)
fstpt  -0x30(%rbp)
fldt   -0x30(%rbp)
fucomip %st(1),%st
fstp   %st(0)
jne    1c25 <main+0xac5>
jp     1c25 <main+0xac5>
jmp    1c4d <main+0xaed>
fldt   -0x30(%rbp)
mov    %rsp,%rax
fstpt  0x10(%rax)
fld1
fchs
fstpt  (%rax)
mov    $0x3b,%edi
call   1080 <flierr@plt>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
fld1
fchs
fld    %st(0)
fstpt  -0x30(%rbp)
fldt   -0x30(%rbp)
fucomip %st(1),%st
fstp   %st(0)
jne    1c6e <main+0xb0e>
jp     1c6e <main+0xb0e>
jmp    1c98 <main+0xb38>
fldt   -0x30(%rbp)
mov    %rsp,%rax
fstpt  0x10(%rax)
fldt   0x393(%rip)
fstpt  (%rax)
mov    $0x3c,%edi
call   1080 <flierr@plt>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
cmpl   $0x0,-0x9c(%rbp)
jne    1cb3 <main+0xb53>
lea    0x467(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %edi,%edi
call   1060 <exit@plt>

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
lea    0xf56(%rip),%rdi
call   1030 <puts@plt>
fld1
flds   0xe6b(%rip)
fstpt  0x80(%rsp)
mov    $0x2,%eax
xor    %r14d,%r14d
movl   $0x0,0x60(%rsp)
xor    %r15d,%r15d
jmp    11df <main+0x6f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
fstp   %st(0)
fldt   0xe58(%rip)
fldt   0x8c(%rsp)
fmulp  %st,%st(1)
cmp    $0x14,%r15d
mov    0x5c(%rsp),%eax
je     14c3 <main+0x353>
cmp    $0xa,%r15d
fld1
fxch   %st(1)
fcmove %st(1),%st
fstp   %st(1)
fldt   0xe1f(%rip)
fldt   0x80(%rsp)
fcmove %st(1),%st
fstp   %st(1)
mov    $0x4000,%ecx
cmove  %ecx,%eax
fld    %st(0)
fstpt  0x80(%rsp)
fmul   %st(1),%st
fld    %st(1)
fstpt  0x8c(%rsp)
fxch   %st(1)
fmuls  0xde4(%rip)
fstpt  0x44(%rsp)
add    $0x1,%r15d
mov    %eax,0x5c(%rsp)
mov    %eax,%r12d
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
fmuls  0xdbe(%rip)
fld    %st(0)
fstpt  0x24(%rsp)
fstpt  (%rsp)
lea    0x50(%rsp),%rdi
call   1050 <frexpl@plt>
fldt   0x24(%rsp)
fldz
fxch   %st(1)
fucomi %st(1),%st
fstp   %st(1)
jne    12a0 <main+0x130>
jp     12a0 <main+0x130>
fnstcw 0x36(%rsp)
movzwl 0x36(%rsp),%eax
or     $0xc00,%eax
mov    %ax,0x5a(%rsp)
fldcw  0x5a(%rsp)
fxch   %st(1)
fistl  0x70(%rsp)
fldcw  0x36(%rsp)
xor    %r12d,%r12d
fldz
mov    0x70(%rsp),%ecx
jmp    1367 <main+0x1f7>
nopl   0x0(%rax,%rax,1)
lea    -0x1(%r12),%eax
cmp    $0xffffc001,%r12d
jg     12f8 <main+0x188>
mov    0x50(%rsp),%edx
cmp    %eax,%edx
fldt   0x44(%rsp)
je     12fc <main+0x18c>
lea    -0x2(%r12),%esi
xor    %ecx,%ecx
fld    %st(2)
fmuls  0xd3b(%rip)
cmp    %esi,%edx
fxch   %st(3)
fcmove %st(3),%st
fstp   %st(3)
sete   %cl
add    %edx,%ecx
cmp    %r12d,%ecx
fld    %st(2)
fadd   %st(3),%st
fxch   %st(3)
fcmove %st(3),%st
fstp   %st(3)
cmp    %esi,%edx
je     12ec <main+0x17c>
cmp    %r12d,%ecx
jne    12fc <main+0x18c>
cmp    %r12d,%ecx
cmove  %eax,%ecx
mov    %ecx,0x50(%rsp)
jmp    12fc <main+0x18c>
fldt   0x44(%rsp)
fld    %st(2)
fsub   %st(1),%st
fnstcw 0x34(%rsp)
movzwl 0x34(%rsp),%ecx
or     $0xc00,%ecx
mov    %cx,0x58(%rsp)
fldcw  0x58(%rsp)
fistpl 0x7c(%rsp)
fldcw  0x34(%rsp)
mov    0x7c(%rsp),%ecx
fldz
fxch   %st(1)
fucomi %st(1),%st
fstp   %st(1)
jne    1330 <main+0x1c0>
jnp    135e <main+0x1ee>
mov    %ecx,0x74(%rsp)
fld    %st(0)
fidivrl 0x74(%rsp)
fnstcw 0x32(%rsp)
movzwl 0x32(%rsp),%ecx
or     $0xc00,%ecx
mov    %cx,0x56(%rsp)
fldcw  0x56(%rsp)
fistpl 0x78(%rsp)
fldcw  0x32(%rsp)
mov    0x78(%rsp),%ecx
mov    %eax,%r12d
fxch   %st(1)
fxch   %st(2)
fxch   %st(1)
fldz
fxch   %st(3)
fucomi %st(3),%st
fstp   %st(3)
fstpt  0x44(%rsp)
jne    1377 <main+0x207>
jnp    1384 <main+0x214>
mov    0x50(%rsp),%ebp
test   %ecx,%ecx
jne    1390 <main+0x220>
cmp    %r12d,%ebp
jne    1390 <main+0x220>
fstp   %st(0)
jmp    13e7 <main+0x277>
nopl   0x0(%rax,%rax,1)
fstp   %st(1)
lea    0xcc7(%rip),%rdi
mov    %r15d,%esi
xor    %eax,%eax
fstpt  0x38(%rsp)
call   1040 <printf@plt>
fldt   0x38(%rsp)
fstpt  0x10(%rsp)
fldt   0x24(%rsp)
fstpt  (%rsp)
lea    0xcad(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1040 <printf@plt>
fldt   0x44(%rsp)
fstpt  (%rsp)
lea    0xcbb(%rip),%rdi
mov    %r12d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
fldt   0x24(%rsp)
addl   $0x1,0x60(%rsp)
mov    $0x1,%r13d
sub    %r12d,%r13d
fstpt  (%rsp)
mov    %r13d,%edi
call   1060 <ldexpl@plt>
fld1
fchs
fadd   %st(1),%st
fnstcw 0x30(%rsp)
movzwl 0x30(%rsp),%eax
or     $0xc00,%eax
mov    %ax,0x54(%rsp)
fldcw  0x54(%rsp)
fistpl 0x6c(%rsp)
fldcw  0x30(%rsp)
cmpl   $0x0,0x6c(%rsp)
je     1491 <main+0x321>
fldz
fldt   0x24(%rsp)
fucomi %st(1),%st
jne    1499 <main+0x329>
jp     1499 <main+0x329>
fxch   %st(2)
fucomi %st(1),%st
fstp   %st(1)
jne    143d <main+0x2cd>
jnp    149b <main+0x32b>
fstp   %st(1)
lea    0xc1a(%rip),%rdi
mov    %r15d,%esi
xor    %eax,%eax
fstpt  0x38(%rsp)
call   1040 <printf@plt>
fldt   0x38(%rsp)
fstpt  0x10(%rsp)
fldt   0x24(%rsp)
fstpt  (%rsp)
lea    0xc40(%rip),%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
fldz
fstpt  (%rsp)
lea    0xc4b(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
fldt   0x24(%rsp)
add    $0x1,%r14d
jmp    149d <main+0x32d>
fstp   %st(0)
fldt   0x24(%rsp)
jmp    149d <main+0x32d>
fstp   %st(2)
fstp   %st(0)
fldz
fxch   %st(1)
fucomi %st(1),%st
fstp   %st(1)
jne    14ad <main+0x33d>
jnp    11c0 <main+0x50>
lea    0x1(%rbx),%eax
cmp    $0x403f,%ebx
mov    %eax,%ebx
jb     1240 <main+0xd0>
jmp    11c0 <main+0x50>
fstp   %st(0)
or     0x60(%rsp),%r14d
jne    14d8 <main+0x368>
lea    0xc59(%rip),%rdi
call   1030 <puts@plt>
lea    0xc1e(%rip),%rdi
call   1030 <puts@plt>
fld1
xor    %ebp,%ebp
xor    %r14d,%r14d
jmp    150e <main+0x39e>
nopl   (%rax)
fstp   %st(2)
fstp   %st(0)
fstp   %st(0)
fldz
fstp   %st(0)
fldt   0x60(%rsp)
fadd   %st,%st(0)
add    $0x1,%r14d
cmp    $0x39,%r14d
je     174d <main+0x5dd>
fld1
fchs
fld    %st(1)
fstpt  0x60(%rsp)
faddp  %st,%st(1)
mov    $0x80,%ebx
jmp    153f <main+0x3cf>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
fstp   %st(3)
fstp   %st(2)
fstp   %st(0)
fld1
faddp  %st,%st(1)
add    $0xffffffff,%ebx
je     14f8 <main+0x388>
fld    %st(0)
fstpt  0x24(%rsp)
fstpt  (%rsp)
call   1080 <floorl@plt>
fldt   0x24(%rsp)
fxch   %st(1)
fucomi %st(1),%st
jne    1559 <main+0x3e9>
jnp    1580 <main+0x410>
fstpt  0x10(%rsp)
fstpt  (%rsp)
mov    %r14d,%edi
call   1090 <flierr@plt>
fldt   0x24(%rsp)
add    $0x1,%ebp
jmp    1582 <main+0x412>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
fstp   %st(0)
fldt   0xaa8(%rip)
faddp  %st,%st(1)
fld    %st(0)
fstpt  0x44(%rsp)
fstpt  (%rsp)
call   1080 <floorl@plt>
fldt   0x44(%rsp)
fldt   0x24(%rsp)
fxch   %st(1)
fucomi %st(1),%st
jne    15ac <main+0x43c>
jnp    14f0 <main+0x380>
fld1
fchs
fadd   %st(2),%st
fxch   %st(3)
fucomi %st(3),%st
fstp   %st(3)
jne    15bc <main+0x44c>
jnp    15e0 <main+0x470>
fstp   %st(1)
fxch   %st(1)
fstpt  0x10(%rsp)
fstpt  (%rsp)
mov    %r14d,%edi
call   1090 <flierr@plt>
fldt   0x24(%rsp)
add    $0x1,%ebp
jmp    15e4 <main+0x474>
nopl   0x0(%rax,%rax,1)
fstp   %st(2)
fstp   %st(1)
fldt   0xa56(%rip)
faddp  %st,%st(1)
fld    %st(0)
fstpt  0x38(%rsp)
fstpt  (%rsp)
call   1080 <floorl@plt>
fldt   0x38(%rsp)
fldt   0x24(%rsp)
fxch   %st(1)
fucomi %st(1),%st
jne    160a <main+0x49a>
jnp    1630 <main+0x4c0>
fxch   %st(2)
fucomi %st(1),%st
jne    1612 <main+0x4a2>
jnp    1640 <main+0x4d0>
fstp   %st(1)
fstpt  0x10(%rsp)
fstpt  (%rsp)
mov    %r14d,%edi
call   1090 <flierr@plt>
fldt   0x24(%rsp)
add    $0x1,%ebp
jmp    1644 <main+0x4d4>
nopl   0x0(%rax)
fstp   %st(2)
jmp    1642 <main+0x4d2>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
fstp   %st(0)
fstp   %st(1)
fchs
fld    %st(0)
fstpt  0x44(%rsp)
fstpt  (%rsp)
call   1080 <floorl@plt>
fldt   0x44(%rsp)
fldt   0x38(%rsp)
fucomip %st(1),%st
jne    1662 <main+0x4f2>
jnp    1680 <main+0x510>
fxch   %st(1)
fucomi %st(1),%st
jne    166a <main+0x4fa>
jnp    1690 <main+0x520>
fstpt  0x10(%rsp)
fstpt  (%rsp)
mov    %r14d,%edi
call   1090 <flierr@plt>
add    $0x1,%ebp
jmp    1694 <main+0x524>
xchg   %ax,%ax
fstp   %st(1)
jmp    1692 <main+0x522>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
fstp   %st(0)
fstp   %st(0)
fldt   0x24(%rsp)
fldt   0x9a2(%rip)
fsubp  %st,%st(1)
fld    %st(0)
fstpt  0x38(%rsp)
fstpt  (%rsp)
call   1080 <floorl@plt>
fldt   0x38(%rsp)
fldt   0x44(%rsp)
fxch   %st(1)
fucomi %st(1),%st
jne    16be <main+0x54e>
jnp    16e0 <main+0x570>
fxch   %st(2)
fucomi %st(1),%st
fstp   %st(1)
jne    16c8 <main+0x558>
jnp    16e2 <main+0x572>
fstpt  0x10(%rsp)
fstpt  (%rsp)
mov    %r14d,%edi
call   1090 <flierr@plt>
add    $0x1,%ebp
jmp    16e6 <main+0x576>
nopl   0x0(%rax)
fstp   %st(2)
fstp   %st(0)
fstp   %st(0)
fldt   0x24(%rsp)
fldt   0x940(%rip)
fsubp  %st,%st(1)
fld    %st(0)
fstpt  0x38(%rsp)
fstpt  (%rsp)
call   1080 <floorl@plt>
fldt   0x38(%rsp)
fldt   0x24(%rsp)
fldt   0x44(%rsp)
fxch   %st(2)
fucomi %st(2),%st
fstp   %st(2)
fld1
fchs
fsub   %st(1),%st
jne    1720 <main+0x5b0>
jnp    1530 <main+0x3c0>
fxch   %st(3)
fucomi %st(3),%st
fstp   %st(3)
jne    172e <main+0x5be>
jnp    1532 <main+0x3c2>
fstp   %st(0)
fxch   %st(1)
fstpt  0x10(%rsp)
fstpt  (%rsp)
mov    %r14d,%edi
call   1090 <flierr@plt>
fldt   0x24(%rsp)
add    $0x1,%ebp
jmp    1536 <main+0x3c6>
fstp   %st(0)
fldz
mov    $0x1,%bl
test   %bl,%bl
jne    176f <main+0x5ff>
fstpt  0x10(%rsp)
fldz
fstpt  (%rsp)
mov    $0x39,%edi
call   1090 <flierr@plt>
add    $0x1,%ebp
jmp    1771 <main+0x601>
fstp   %st(0)
fldz
fchs
test   %bl,%bl
jne    1793 <main+0x623>
fstpt  0x10(%rsp)
fldz
fchs
fstpt  (%rsp)
mov    $0x3a,%edi
call   1090 <flierr@plt>
add    $0x1,%ebp
jmp    1795 <main+0x625>
fstp   %st(0)
fld1
fchs
mov    $0x1,%bl
test   %bl,%bl
jne    17b9 <main+0x649>
fstpt  0x10(%rsp)
fld1
fchs
fstpt  (%rsp)
mov    $0x3b,%edi
call   1090 <flierr@plt>
add    $0x1,%ebp
jmp    17bb <main+0x64b>
fstp   %st(0)
fld1
fchs
test   %bl,%bl
jne    17e3 <main+0x673>
fstpt  0x10(%rsp)
fldt   0x883(%rip)
fstpt  (%rsp)
mov    $0x3c,%edi
call   1090 <flierr@plt>
add    $0x1,%ebp
test   %ebp,%ebp
je     17e9 <main+0x679>
jmp    17f5 <main+0x685>
fstp   %st(0)
test   %ebp,%ebp
jne    17f5 <main+0x685>
lea    0x91f(%rip),%rdi
call   1030 <puts@plt>
xor    %edi,%edi
call   1070 <exit@plt>

LLVM IR (-O0):
@.str = [32 x i8] c"Testing frexpl() and ldexpl().\0A\00"
@.str.1 = [10 x i8] c"Test %d: \00"
@.str.2 = [37 x i8] c" frexpl( %.20Le) =?= %.20Le * 2**%d;\00"
@.str.3 = [27 x i8] c" should be %.20Le * 2**%d\0A\00"
@.str.4 = [33 x i8] c"ldexpl( %.15Le, %d ) =?= %.15Le;\00"
@.str.5 = [19 x i8] c" should be %.15Le\0A\00"
@.str.6 = [18 x i8] c"No errors found.\0A\00"
@.str.7 = [19 x i8] c"Testing floorl().\0A\00"
@.str.8 = [30 x i8] c"No errors found in floorl().\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca x86_fp80
%3 = alloca x86_fp80
%4 = alloca x86_fp80
%5 = alloca x86_fp80
%6 = alloca x86_fp80
%7 = alloca x86_fp80
%8 = alloca x86_fp80
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
store i32 0, i32* %1
%20 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %18
store i32 0, i32* %13
store i32 0, i32* %14
store i32 0, i32* %16
store x86_fp80 0xK3FFF8000000000000000, x86_fp80* %6
store x86_fp80 0xK40008000000000000000, x86_fp80* %7
store x86_fp80 0xK3FFE8000000000000000, x86_fp80* %8
store i32 2, i32* %19
store i32 0, i32* %10
br label %21
21: ; preds = %216, %0
%22 = load i32, i32* %10
%23 = icmp slt i32 %22, 20
br i1 %23, label %24, label %219
24: ; preds = %21
%25 = load i32, i32* %10
%26 = icmp eq i32 %25, 10
br i1 %26, label %27, label %50
27: ; preds = %24
store x86_fp80 0xK3FFF8000000000000000, x86_fp80* %6
store x86_fp80 0xK40008000000000000000, x86_fp80* %7
store i32 1, i32* %19
store i32 0, i32* %9
br label %28
28: ; preds = %38, %27
%29 = load i32, i32* %9
%30 = icmp slt i32 %29, 13
br i1 %30, label %31, label %41
31: ; preds = %28
%32 = load x86_fp80, x86_fp80* %7
%33 = load x86_fp80, x86_fp80* %7
%34 = fmul x86_fp80 %33, %32
store x86_fp80 %34, x86_fp80* %7
%35 = load i32, i32* %19
%36 = load i32, i32* %19
%37 = add nsw i32 %36, %35
store i32 %37, i32* %19
br label %38
38: ; preds = %31
%39 = load i32, i32* %9
%40 = add nsw i32 %39, 1
store i32 %40, i32* %9
br label %28
41: ; preds = %28
%42 = load x86_fp80, x86_fp80* %7
%43 = fdiv x86_fp80 %42, 0xK40008000000000000000
store x86_fp80 %43, x86_fp80* %8
%44 = load x86_fp80, x86_fp80* %7
%45 = load x86_fp80, x86_fp80* %8
%46 = fmul x86_fp80 %44, %45
store x86_fp80 %46, x86_fp80* %7
%47 = load i32, i32* %19
%48 = load i32, i32* %19
%49 = add nsw i32 %48, %47
store i32 %49, i32* %19
store x86_fp80 0xK3FFE8000000000000000, x86_fp80* %8
br label %50
50: ; preds = %41, %24
%51 = load x86_fp80, x86_fp80* %7
%52 = load x86_fp80, x86_fp80* %6
%53 = fmul x86_fp80 %51, %52
store x86_fp80 %53, x86_fp80* %2
%54 = load x86_fp80, x86_fp80* %8
%55 = load x86_fp80, x86_fp80* %6
%56 = fmul x86_fp80 %54, %55
store x86_fp80 %56, x86_fp80* %4
%57 = load i32, i32* %19
store i32 %57, i32* %12
store i32 0, i32* %9
br label %58
58: ; preds = %210, %50
%59 = load i32, i32* %9
%60 = icmp slt i32 %59, 16448
br i1 %60, label %61, label %213
61: ; preds = %58
%62 = load x86_fp80, x86_fp80* %2
%63 = fdiv x86_fp80 %62, 0xK40008000000000000000
store x86_fp80 %63, x86_fp80* %2
%64 = load i32, i32* %12
%65 = sub nsw i32 %64, 1
store i32 %65, i32* %12
%66 = load x86_fp80, x86_fp80* %2
%67 = fcmp oeq x86_fp80 %66, 0xK00000000000000000000
br i1 %67, label %68, label %74
68: ; preds = %61
%69 = load x86_fp80, x86_fp80* %6
%70 = fcmp oeq x86_fp80 %69, 0xK3FFF8000000000000000
br i1 %70, label %71, label %73
71: ; preds = %68
%72 = load i32, i32* %12
store i32 %72, i32* %16
br label %73
73: ; preds = %71, %68
store x86_fp80 0xK00000000000000000000, x86_fp80* %4
store i32 0, i32* %12
br label %74
74: ; preds = %73, %61
%75 = load x86_fp80, x86_fp80* %2
%76 = call x86_fp80 @frexpl(x86_fp80 %75, i32* %11)
store x86_fp80 %76, x86_fp80* %3
%77 = load i32, i32* %12
%78 = icmp slt i32 %77, -16383
br i1 %78, label %79, label %104
79: ; preds = %74
%80 = load i32, i32* %11
%81 = load i32, i32* %12
%82 = icmp ne i32 %80, %81
br i1 %82, label %83, label %104
83: ; preds = %79
%84 = load i32, i32* %11
%85 = load i32, i32* %12
%86 = sub nsw i32 %85, 1
%87 = icmp eq i32 %84, %86
br i1 %87, label %88, label %93
88: ; preds = %83
%89 = load i32, i32* %11
%90 = add nsw i32 %89, 1
store i32 %90, i32* %11
%91 = load x86_fp80, x86_fp80* %3
%92 = fdiv x86_fp80 %91, 0xK40008000000000000000
store x86_fp80 %92, x86_fp80* %3
br label %93
93: ; preds = %88, %83
%94 = load i32, i32* %11
%95 = load i32, i32* %12
%96 = add nsw i32 %95, 1
%97 = icmp eq i32 %94, %96
br i1 %97, label %98, label %103
98: ; preds = %93
%99 = load i32, i32* %11
%100 = sub nsw i32 %99, 1
store i32 %100, i32* %11
%101 = load x86_fp80, x86_fp80* %3
%102 = fmul x86_fp80 %101, 0xK40008000000000000000
store x86_fp80 %102, x86_fp80* %3
br label %103
103: ; preds = %98, %93
br label %104
104: ; preds = %103, %79, %74
%105 = load x86_fp80, x86_fp80* %3
%106 = load x86_fp80, x86_fp80* %4
%107 = fsub x86_fp80 %105, %106
%108 = fptosi x86_fp80 %107 to i32
store i32 %108, i32* %17
%109 = load x86_fp80, x86_fp80* %4
%110 = fcmp une x86_fp80 %109, 0xK00000000000000000000
br i1 %110, label %111, label %117
111: ; preds = %104
%112 = load x86_fp80, x86_fp80* %4
%113 = load i32, i32* %17
%114 = sitofp i32 %113 to x86_fp80
%115 = fdiv x86_fp80 %114, %112
%116 = fptosi x86_fp80 %115 to i32
store i32 %116, i32* %17
br label %117
117: ; preds = %111, %104
%118 = load i32, i32* %17
%119 = sitofp i32 %118 to x86_fp80
%120 = fcmp olt x86_fp80 %119, 0xK00000000000000000000
br i1 %120, label %121, label %124
121: ; preds = %117
%122 = load i32, i32* %17
%123 = sub nsw i32 0, %122
store i32 %123, i32* %17
br label %124
124: ; preds = %121, %117
%125 = load i32, i32* %12
%126 = icmp sgt i32 %125, -1023
br i1 %126, label %127, label %128
127: ; preds = %124
store i32 0, i32* %18
br label %138
128: ; preds = %124
%129 = load i32, i32* %12
%130 = icmp eq i32 %129, -16383
br i1 %130, label %131, label %132
131: ; preds = %128
store i32 0, i32* %18
br label %137
132: ; preds = %128
%133 = load i32, i32* %18
%134 = sitofp i32 %133 to x86_fp80
%135 = fmul x86_fp80 %134, 0xK40008000000000000000
%136 = fptosi x86_fp80 %135 to i32
store i32 %136, i32* %18
br label %137
137: ; preds = %132, %131
br label %138
138: ; preds = %137, %127
%139 = load x86_fp80, x86_fp80* %2
%140 = fcmp une x86_fp80 %139, 0xK00000000000000000000
br i1 %140, label %141, label %162
141: ; preds = %138
%142 = load i32, i32* %17
%143 = load i32, i32* %18
%144 = icmp sgt i32 %142, %143
br i1 %144, label %149, label %145
145: ; preds = %141
%146 = load i32, i32* %11
%147 = load i32, i32* %12
%148 = icmp ne i32 %146, %147
br i1 %148, label %149, label %162
149: ; preds = %145, %141
%150 = load i32, i32* %10
%151 = add nsw i32 %150, 1
%152 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i32 %151)
%153 = load x86_fp80, x86_fp80* %2
%154 = load x86_fp80, x86_fp80* %3
%155 = load i32, i32* %11
%156 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.2, i64 0, i64 0), x86_fp80 %153, x86_fp80 %154, i32 %155)
%157 = load x86_fp80, x86_fp80* %4
%158 = load i32, i32* %12
%159 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.3, i64 0, i64 0), x86_fp80 %157, i32 %158)
%160 = load i32, i32* %13
%161 = add nsw i32 %160, 1
store i32 %161, i32* %13
br label %162
162: ; preds = %149, %145, %138
%163 = load x86_fp80, x86_fp80* %2
%164 = load i32, i32* %12
%165 = sub nsw i32 1, %164
%166 = call x86_fp80 @ldexpl(x86_fp80 %163, i32 %165)
store x86_fp80 %166, x86_fp80* %3
%167 = load x86_fp80, x86_fp80* %3
%168 = fsub x86_fp80 %167, 0xK3FFF8000000000000000
%169 = fptosi x86_fp80 %168 to i32
store i32 %169, i32* %17
%170 = load i32, i32* %17
%171 = sitofp i32 %170 to x86_fp80
%172 = fcmp olt x86_fp80 %171, 0xK00000000000000000000
br i1 %172, label %173, label %176
173: ; preds = %162
%174 = load i32, i32* %17
%175 = sub nsw i32 0, %174
store i32 %175, i32* %17
br label %176
176: ; preds = %173, %162
%177 = load i32, i32* %17
%178 = load i32, i32* %18
%179 = icmp sgt i32 %177, %178
br i1 %179, label %180, label %205
180: ; preds = %176
%181 = load x86_fp80, x86_fp80* %2
%182 = fcmp oeq x86_fp80 %181, 0xK00000000000000000000
br i1 %182, label %183, label %205
183: ; preds = %180
%184 = load x86_fp80, x86_fp80* %3
%185 = fcmp une x86_fp80 %184, 0xK00000000000000000000
br i1 %185, label %186, label %205
186: ; preds = %183
%187 = load i32, i32* %10
%188 = add nsw i32 %187, 1
%189 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i32 %188)
%190 = load x86_fp80, x86_fp80* %2
%191 = load i32, i32* %12
%192 = sub nsw i32 1, %191
%193 = load x86_fp80, x86_fp80* %3
%194 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.4, i64 0, i64 0), x86_fp80 %190, i32 %192, x86_fp80 %193)
%195 = load x86_fp80, x86_fp80* %2
%196 = fcmp une x86_fp80 %195, 0xK00000000000000000000
br i1 %196, label %197, label %200
197: ; preds = %186
%198 = load x86_fp80, x86_fp80* %6
%199 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.5, i64 0, i64 0), x86_fp80 %198)
br label %202
200: ; preds = %186
%201 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.5, i64 0, i64 0), x86_fp80 0xK00000000000000000000)
br label %202
202: ; preds = %200, %197
%203 = load i32, i32* %14
%204 = add nsw i32 %203, 1
store i32 %204, i32* %14
br label %205
205: ; preds = %202, %183, %180, %176
%206 = load x86_fp80, x86_fp80* %2
%207 = fcmp oeq x86_fp80 %206, 0xK00000000000000000000
br i1 %207, label %208, label %209
208: ; preds = %205
br label %213
209: ; preds = %205
br label %210
210: ; preds = %209
%211 = load i32, i32* %9
%212 = add nsw i32 %211, 1
store i32 %212, i32* %9
br label %58
213: ; preds = %208, %58
%214 = load x86_fp80, x86_fp80* %6
%215 = fmul x86_fp80 %214, 0xK3FFF8A3F65C42121F9A8
store x86_fp80 %215, x86_fp80* %6
br label %216
216: ; preds = %213
%217 = load i32, i32* %10
%218 = add nsw i32 %217, 1
store i32 %218, i32* %10
br label %21
219: ; preds = %21
%220 = load i32, i32* %14
%221 = icmp eq i32 %220, 0
br i1 %221, label %222, label %227
222: ; preds = %219
%223 = load i32, i32* %13
%224 = icmp eq i32 %223, 0
br i1 %224, label %225, label %227
225: ; preds = %222
%226 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.6, i64 0, i64 0))
br label %227
227: ; preds = %225, %222, %219
%228 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.7, i64 0, i64 0))
store i32 0, i32* %15
store x86_fp80 0xK403F8000000000000000, x86_fp80* %6
store x86_fp80 0xK3FFF8000000000000000, x86_fp80* %7
store i32 0, i32* %10
br label %229
229: ; preds = %365, %227
%230 = load i32, i32* %10
%231 = icmp slt i32 %230, 57
br i1 %231, label %232, label %368
232: ; preds = %229
%233 = load x86_fp80, x86_fp80* %7
%234 = fsub x86_fp80 %233, 0xK3FFF8000000000000000
store x86_fp80 %234, x86_fp80* %2
store i32 0, i32* %9
br label %235
235: ; preds = %358, %232
%236 = load i32, i32* %9
%237 = icmp slt i32 %236, 128
br i1 %237, label %238, label %361
238: ; preds = %235
%239 = load x86_fp80, x86_fp80* %2
%240 = call x86_fp80 @llvm.floor.f80(x86_fp80 %239)
store x86_fp80 %240, x86_fp80* %3
%241 = load x86_fp80, x86_fp80* %3
%242 = load x86_fp80, x86_fp80* %2
%243 = fcmp une x86_fp80 %241, %242
br i1 %243, label %244, label %251
244: ; preds = %238
%245 = load x86_fp80, x86_fp80* %2
%246 = load x86_fp80, x86_fp80* %3
%247 = load i32, i32* %10
%248 = call i32 @flierr(x86_fp80 %245, x86_fp80 %246, i32 %247)
%249 = load i32, i32* %15
%250 = add nsw i32 %249, 1
store i32 %250, i32* %15
br label %251
251: ; preds = %244, %238
%252 = load x86_fp80, x86_fp80* %2
%253 = fsub x86_fp80 %252, 0xK3FFDFAE147AE147AE148
store x86_fp80 %253, x86_fp80* %5
%254 = load x86_fp80, x86_fp80* %5
%255 = call x86_fp80 @llvm.floor.f80(x86_fp80 %254)
store x86_fp80 %255, x86_fp80* %3
%256 = load x86_fp80, x86_fp80* %5
%257 = load x86_fp80, x86_fp80* %2
%258 = fcmp oeq x86_fp80 %256, %257
br i1 %258, label %259, label %260
259: ; preds = %251
br label %361
260: ; preds = %251
%261 = load x86_fp80, x86_fp80* %3
%262 = load x86_fp80, x86_fp80* %2
%263 = fsub x86_fp80 %262, 0xK3FFF8000000000000000
%264 = fcmp une x86_fp80 %261, %263
br i1 %264, label %265, label %272
265: ; preds = %260
%266 = load x86_fp80, x86_fp80* %5
%267 = load x86_fp80, x86_fp80* %3
%268 = load i32, i32* %10
%269 = call i32 @flierr(x86_fp80 %266, x86_fp80 %267, i32 %268)
%270 = load i32, i32* %15
%271 = add nsw i32 %270, 1
store i32 %271, i32* %15
br label %272
272: ; preds = %265, %260
%273 = load x86_fp80, x86_fp80* %2
%274 = fadd x86_fp80 %273, 0xK3FFDFAE147AE147AE148
store x86_fp80 %274, x86_fp80* %5
%275 = load x86_fp80, x86_fp80* %5
%276 = call x86_fp80 @llvm.floor.f80(x86_fp80 %275)
store x86_fp80 %276, x86_fp80* %3
%277 = load x86_fp80, x86_fp80* %5
%278 = load x86_fp80, x86_fp80* %2
%279 = fcmp une x86_fp80 %277, %278
br i1 %279, label %280, label %292
280: ; preds = %272
%281 = load x86_fp80, x86_fp80* %3
%282 = load x86_fp80, x86_fp80* %2
%283 = fcmp une x86_fp80 %281, %282
br i1 %283, label %284, label %291
284: ; preds = %280
%285 = load x86_fp80, x86_fp80* %5
%286 = load x86_fp80, x86_fp80* %3
%287 = load i32, i32* %10
%288 = call i32 @flierr(x86_fp80 %285, x86_fp80 %286, i32 %287)
%289 = load i32, i32* %15
%290 = add nsw i32 %289, 1
store i32 %290, i32* %15
br label %291
291: ; preds = %284, %280
br label %292
292: ; preds = %291, %272
%293 = load x86_fp80, x86_fp80* %2
%294 = fneg x86_fp80 %293
store x86_fp80 %294, x86_fp80* %2
%295 = load x86_fp80, x86_fp80* %2
%296 = call x86_fp80 @llvm.floor.f80(x86_fp80 %295)
store x86_fp80 %296, x86_fp80* %3
%297 = load x86_fp80, x86_fp80* %5
%298 = load x86_fp80, x86_fp80* %2
%299 = fcmp une x86_fp80 %297, %298
br i1 %299, label %300, label %312
300: ; preds = %292
%301 = load x86_fp80, x86_fp80* %3
%302 = load x86_fp80, x86_fp80* %2
%303 = fcmp une x86_fp80 %301, %302
br i1 %303, label %304, label %311
304: ; preds = %300
%305 = load x86_fp80, x86_fp80* %2
%306 = load x86_fp80, x86_fp80* %3
%307 = load i32, i32* %10
%308 = call i32 @flierr(x86_fp80 %305, x86_fp80 %306, i32 %307)
%309 = load i32, i32* %15
%310 = add nsw i32 %309, 1
store i32 %310, i32* %15
br label %311
311: ; preds = %304, %300
br label %312
312: ; preds = %311, %292
%313 = load x86_fp80, x86_fp80* %2
%314 = fadd x86_fp80 %313, 0xK3FFDFAE147AE147AE148
store x86_fp80 %314, x86_fp80* %5
%315 = load x86_fp80, x86_fp80* %5
%316 = call x86_fp80 @llvm.floor.f80(x86_fp80 %315)
store x86_fp80 %316, x86_fp80* %3
%317 = load x86_fp80, x86_fp80* %5
%318 = load x86_fp80, x86_fp80* %2
%319 = fcmp une x86_fp80 %317, %318
br i1 %319, label %320, label %332
320: ; preds = %312
%321 = load x86_fp80, x86_fp80* %3
%322 = load x86_fp80, x86_fp80* %2
%323 = fcmp une x86_fp80 %321, %322
br i1 %323, label %324, label %331
324: ; preds = %320
%325 = load x86_fp80, x86_fp80* %5
%326 = load x86_fp80, x86_fp80* %3
%327 = load i32, i32* %10
%328 = call i32 @flierr(x86_fp80 %325, x86_fp80 %326, i32 %327)
%329 = load i32, i32* %15
%330 = add nsw i32 %329, 1
store i32 %330, i32* %15
br label %331
331: ; preds = %324, %320
br label %332
332: ; preds = %331, %312
%333 = load x86_fp80, x86_fp80* %2
%334 = fsub x86_fp80 %333, 0xK3FFDFAE147AE147AE148
store x86_fp80 %334, x86_fp80* %5
%335 = load x86_fp80, x86_fp80* %5
%336 = call x86_fp80 @llvm.floor.f80(x86_fp80 %335)
store x86_fp80 %336, x86_fp80* %3
%337 = load x86_fp80, x86_fp80* %5
%338 = load x86_fp80, x86_fp80* %2
%339 = fcmp une x86_fp80 %337, %338
br i1 %339, label %340, label %353
340: ; preds = %332
%341 = load x86_fp80, x86_fp80* %3
%342 = load x86_fp80, x86_fp80* %2
%343 = fsub x86_fp80 %342, 0xK3FFF8000000000000000
%344 = fcmp une x86_fp80 %341, %343
br i1 %344, label %345, label %352
345: ; preds = %340
%346 = load x86_fp80, x86_fp80* %5
%347 = load x86_fp80, x86_fp80* %3
%348 = load i32, i32* %10
%349 = call i32 @flierr(x86_fp80 %346, x86_fp80 %347, i32 %348)
%350 = load i32, i32* %15
%351 = add nsw i32 %350, 1
store i32 %351, i32* %15
br label %352
352: ; preds = %345, %340
br label %353
353: ; preds = %352, %332
%354 = load x86_fp80, x86_fp80* %2
%355 = fneg x86_fp80 %354
store x86_fp80 %355, x86_fp80* %2
%356 = load x86_fp80, x86_fp80* %2
%357 = fadd x86_fp80 %356, 0xK3FFF8000000000000000
store x86_fp80 %357, x86_fp80* %2
br label %358
358: ; preds = %353
%359 = load i32, i32* %9
%360 = add nsw i32 %359, 1
store i32 %360, i32* %9
br label %235
361: ; preds = %259, %235
%362 = load x86_fp80, x86_fp80* %7
%363 = load x86_fp80, x86_fp80* %7
%364 = fadd x86_fp80 %362, %363
store x86_fp80 %364, x86_fp80* %7
br label %365
365: ; preds = %361
%366 = load i32, i32* %10
%367 = add nsw i32 %366, 1
store i32 %367, i32* %10
br label %229
368: ; preds = %229
%369 = call x86_fp80 @llvm.floor.f80(x86_fp80 0xK00000000000000000000)
store x86_fp80 %369, x86_fp80* %3
%370 = load x86_fp80, x86_fp80* %3
%371 = fcmp une x86_fp80 %370, 0xK00000000000000000000
br i1 %371, label %372, label %377
372: ; preds = %368
%373 = load x86_fp80, x86_fp80* %3
%374 = call i32 @flierr(x86_fp80 0xK00000000000000000000, x86_fp80 %373, i32 57)
%375 = load i32, i32* %15
%376 = add nsw i32 %375, 1
store i32 %376, i32* %15
br label %377
377: ; preds = %372, %368
%378 = call x86_fp80 @llvm.floor.f80(x86_fp80 0xK80000000000000000000)
store x86_fp80 %378, x86_fp80* %3
%379 = load x86_fp80, x86_fp80* %3
%380 = fcmp une x86_fp80 %379, 0xK00000000000000000000
br i1 %380, label %381, label %386
381: ; preds = %377
%382 = load x86_fp80, x86_fp80* %3
%383 = call i32 @flierr(x86_fp80 0xK80000000000000000000, x86_fp80 %382, i32 58)
%384 = load i32, i32* %15
%385 = add nsw i32 %384, 1
store i32 %385, i32* %15
br label %386
386: ; preds = %381, %377
%387 = call x86_fp80 @llvm.floor.f80(x86_fp80 0xKBFFF8000000000000000)
store x86_fp80 %387, x86_fp80* %3
%388 = load x86_fp80, x86_fp80* %3
%389 = fcmp une x86_fp80 %388, 0xKBFFF8000000000000000
br i1 %389, label %390, label %395
390: ; preds = %386
%391 = load x86_fp80, x86_fp80* %3
%392 = call i32 @flierr(x86_fp80 0xKBFFF8000000000000000, x86_fp80 %391, i32 59)
%393 = load i32, i32* %15
%394 = add nsw i32 %393, 1
store i32 %394, i32* %15
br label %395
395: ; preds = %390, %386
%396 = call x86_fp80 @llvm.floor.f80(x86_fp80 0xKBFFBCCCCCCCCCCCCCCCD)
store x86_fp80 %396, x86_fp80* %3
%397 = load x86_fp80, x86_fp80* %3
%398 = fcmp une x86_fp80 %397, 0xKBFFF8000000000000000
br i1 %398, label %399, label %404
399: ; preds = %395
%400 = load x86_fp80, x86_fp80* %3
%401 = call i32 @flierr(x86_fp80 0xKBFFBCCCCCCCCCCCCCCCD, x86_fp80 %400, i32 60)
%402 = load i32, i32* %15
%403 = add nsw i32 %402, 1
store i32 %403, i32* %15
br label %404
404: ; preds = %399, %395
%405 = load i32, i32* %15
%406 = icmp eq i32 %405, 0
br i1 %406, label %407, label %409
407: ; preds = %404
%408 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.8, i64 0, i64 0))
br label %409
409: ; preds = %407, %404
%410 = call i32 @exit(i32 0)
unreachable
}

LLVM IR (-O2):
@.str.1 = [10 x i8] c"Test %d: \00"
@.str.2 = [37 x i8] c" frexpl( %.20Le) =?= %.20Le * 2**%d;\00"
@.str.3 = [27 x i8] c" should be %.20Le * 2**%d\0A\00"
@.str.4 = [33 x i8] c"ldexpl( %.15Le, %d ) =?= %.15Le;\00"
@.str.5 = [19 x i8] c" should be %.15Le\0A\00"
@str = [31 x i8] c"Testing frexpl() and ldexpl().\00"
@str.9 = [18 x i8] c"Testing floorl().\00"
@str.10 = [29 x i8] c"No errors found in floorl().\00"
@str.11 = [17 x i8] c"No errors found.\00"
define i32 @main() {
%1 = alloca i32
%2 = bitcast i32* %1 to i8*
%3 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @str, i64 0, i64 0))
br label %4
4: ; preds = %0, %95
%5 = phi i32 [ 2, %0 ], [ %14, %95 ]
%6 = phi i32 [ 0, %0 ], [ %90, %95 ]
%7 = phi i32 [ 0, %0 ], [ %75, %95 ]
%8 = phi i32 [ 0, %0 ], [ %17, %95 ]
%9 = phi x86_fp80 [ 0xK40008000000000000000, %0 ], [ %13, %95 ]
%10 = phi x86_fp80 [ 0xK3FFF8000000000000000, %0 ], [ %96, %95 ]
%11 = icmp eq i32 %8, 10
%12 = select i1 %11, x86_fp80 0xK3FFF8000000000000000, x86_fp80 %10
%13 = select i1 %11, x86_fp80 0xK7FFE8000000000000000, x86_fp80 %9
%14 = select i1 %11, i32 16384, i32 %5
%15 = fmul x86_fp80 %12, %13
%16 = fmul x86_fp80 %12, 0xK3FFE8000000000000000
%17 = add nuw nsw i32 %8, 1
br label %18
18: ; preds = %89, %4
%19 = phi i32 [ %6, %4 ], [ %90, %89 ]
%20 = phi i32 [ %7, %4 ], [ %75, %89 ]
%21 = phi i32 [ %14, %4 ], [ %61, %89 ]
%22 = phi i32 [ 0, %4 ], [ %91, %89 ]
%23 = phi x86_fp80 [ %15, %4 ], [ %25, %89 ]
%24 = phi x86_fp80 [ %16, %4 ], [ %60, %89 ]
%25 = fmul x86_fp80 %23, 0xK3FFE8000000000000000
%26 = add nsw i32 %21, -1
%27 = fcmp oeq x86_fp80 %25, 0xK00000000000000000000
%28 = call x86_fp80 @frexpl(x86_fp80 %25, i32* %1)
br i1 %27, label %29, label %31
29: ; preds = %18
%30 = fptosi x86_fp80 %28 to i32
br label %58
31: ; preds = %18
%32 = icmp slt i32 %21, -16382
br i1 %32, label %33, label %49
33: ; preds = %31
%34 = load i32, i32* %1
%35 = icmp eq i32 %34, %26
br i1 %35, label %49, label %36
36: ; preds = %33
%37 = add nsw i32 %21, -2
%38 = icmp eq i32 %34, %37
%39 = fmul x86_fp80 %28, 0xK3FFE8000000000000000
%40 = zext i1 %38 to i32
%41 = add nsw i32 %34, %40
%42 = select i1 %38, x86_fp80 %39, x86_fp80 %28
%43 = icmp eq i32 %41, %21
%44 = fmul x86_fp80 %42, 0xK40008000000000000000
%45 = select i1 %43, x86_fp80 %44, x86_fp80 %42
%46 = or i1 %38, %43
br i1 %46, label %47, label %49
47: ; preds = %36
%48 = select i1 %43, i32 %26, i32 %41
store i32 %48, i32* %1
br label %49
49: ; preds = %47, %36, %33, %31
%50 = phi x86_fp80 [ %28, %33 ], [ %28, %31 ], [ %45, %36 ], [ %45, %47 ]
%51 = fsub x86_fp80 %50, %24
%52 = fptosi x86_fp80 %51 to i32
%53 = fcmp une x86_fp80 %24, 0xK00000000000000000000
br i1 %53, label %54, label %58
54: ; preds = %49
%55 = sitofp i32 %52 to x86_fp80
%56 = fdiv x86_fp80 %55, %24
%57 = fptosi x86_fp80 %56 to i32
br label %58
58: ; preds = %29, %54, %49
%59 = phi x86_fp80 [ %50, %54 ], [ %50, %49 ], [ %28, %29 ]
%60 = phi x86_fp80 [ %24, %54 ], [ %24, %49 ], [ 0xK00000000000000000000, %29 ]
%61 = phi i32 [ %26, %54 ], [ %26, %49 ], [ 0, %29 ]
%62 = phi i32 [ %57, %54 ], [ %52, %49 ], [ %30, %29 ]
%63 = fcmp une x86_fp80 %25, 0xK00000000000000000000
br i1 %63, label %64, label %74
64: ; preds = %58
%65 = icmp eq i32 %62, 0
%66 = load i32, i32* %1
%67 = icmp eq i32 %66, %61
%68 = select i1 %65, i1 %67, i1 false
br i1 %68, label %74, label %69
69: ; preds = %64
%70 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i32 %17)
%71 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str.2, i64 0, i64 0), x86_fp80 %25, x86_fp80 %59, i32 %66)
%72 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @.str.3, i64 0, i64 0), x86_fp80 %60, i32 %61)
%73 = add nsw i32 %20, 1
br label %74
74: ; preds = %64, %69, %58
%75 = phi i32 [ %73, %69 ], [ %20, %58 ], [ %20, %64 ]
%76 = sub nsw i32 1, %61
%77 = tail call x86_fp80 @ldexpl(x86_fp80 %25, i32 %76)
%78 = fadd x86_fp80 %77, 0xKBFFF8000000000000000
%79 = fptosi x86_fp80 %78 to i32
%80 = icmp ne i32 %79, 0
%81 = and i1 %80, %27
%82 = fcmp une x86_fp80 %77, 0xK00000000000000000000
%83 = select i1 %81, i1 %82, i1 false
br i1 %83, label %84, label %89
84: ; preds = %74
%85 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i32 %17)
%86 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @.str.4, i64 0, i64 0), x86_fp80 %25, i32 %76, x86_fp80 %77)
%87 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.5, i64 0, i64 0), x86_fp80 0xK00000000000000000000)
%88 = add nsw i32 %19, 1
br label %89
89: ; preds = %84, %74
%90 = phi i32 [ %88, %84 ], [ %19, %74 ]
%91 = add nuw nsw i32 %22, 1
%92 = xor i1 %27, true
%93 = icmp ult i32 %22, 16447
%94 = select i1 %92, i1 %93, i1 false
br i1 %94, label %18, label %95
95: ; preds = %89
%96 = fmul x86_fp80 %12, 0xK3FFF8A3F65C42121F9A8
%97 = icmp eq i32 %17, 20
br i1 %97, label %98, label %4
98: ; preds = %95
%99 = icmp eq i32 %90, 0
%100 = icmp eq i32 %75, 0
%101 = select i1 %99, i1 %100, i1 false
br i1 %101, label %102, label %104
102: ; preds = %98
%103 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @str.11, i64 0, i64 0))
br label %104
104: ; preds = %102, %98
%105 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @str.9, i64 0, i64 0))
br label %106
106: ; preds = %104, %177
%107 = phi i32 [ 0, %104 ], [ %178, %177 ]
%108 = phi i32 [ 0, %104 ], [ %180, %177 ]
%109 = phi x86_fp80 [ 0xK3FFF8000000000000000, %104 ], [ %179, %177 ]
%110 = fadd x86_fp80 %109, 0xKBFFF8000000000000000
br label %111
111: ; preds = %106, %172
%112 = phi i32 [ %107, %106 ], [ %173, %172 ]
%113 = phi i32 [ 0, %106 ], [ %175, %172 ]
%114 = phi x86_fp80 [ %110, %106 ], [ %174, %172 ]
%115 = tail call x86_fp80 @llvm.floor.f80(x86_fp80 %114)
%116 = fcmp une x86_fp80 %115, %114
br i1 %116, label %117, label %120
117: ; preds = %111
%118 = tail call i32 @flierr(x86_fp80 %114, x86_fp80 %115, i32 %108)
%119 = add nsw i32 %112, 1
br label %120
120: ; preds = %117, %111
%121 = phi i32 [ %119, %117 ], [ %112, %111 ]
%122 = fadd x86_fp80 %114, 0xKBFFDFAE147AE147AE148
%123 = tail call x86_fp80 @llvm.floor.f80(x86_fp80 %122)
%124 = fcmp oeq x86_fp80 %122, %114
br i1 %124, label %177, label %125
125: ; preds = %120
%126 = fadd x86_fp80 %114, 0xKBFFF8000000000000000
%127 = fcmp une x86_fp80 %123, %126
br i1 %127, label %128, label %131
128: ; preds = %125
%129 = tail call i32 @flierr(x86_fp80 %122, x86_fp80 %123, i32 %108)
%130 = add nsw i32 %121, 1
br label %131
131: ; preds = %128, %125
%132 = phi i32 [ %130, %128 ], [ %121, %125 ]
%133 = fadd x86_fp80 %114, 0xK3FFDFAE147AE147AE148
%134 = tail call x86_fp80 @llvm.floor.f80(x86_fp80 %133)
%135 = fcmp une x86_fp80 %133, %114
%136 = fcmp une x86_fp80 %134, %114
%137 = select i1 %135, i1 %136, i1 false
br i1 %137, label %138, label %141
138: ; preds = %131
%139 = tail call i32 @flierr(x86_fp80 %133, x86_fp80 %134, i32 %108)
%140 = add nsw i32 %132, 1
br label %141
141: ; preds = %138, %131
%142 = phi i32 [ %140, %138 ], [ %132, %131 ]
%143 = fneg x86_fp80 %114
%144 = tail call x86_fp80 @llvm.floor.f80(x86_fp80 %143)
%145 = fcmp une x86_fp80 %133, %143
%146 = fcmp une x86_fp80 %144, %143
%147 = select i1 %145, i1 %146, i1 false
br i1 %147, label %148, label %151
148: ; preds = %141
%149 = tail call i32 @flierr(x86_fp80 %143, x86_fp80 %144, i32 %108)
%150 = add nsw i32 %142, 1
br label %151
151: ; preds = %148, %141
%152 = phi i32 [ %150, %148 ], [ %142, %141 ]
%153 = fsub x86_fp80 0xK3FFDFAE147AE147AE148, %114
%154 = tail call x86_fp80 @llvm.floor.f80(x86_fp80 %153)
%155 = fcmp une x86_fp80 %153, %143
%156 = fcmp une x86_fp80 %154, %143
%157 = select i1 %155, i1 %156, i1 false
br i1 %157, label %158, label %161
158: ; preds = %151
%159 = tail call i32 @flierr(x86_fp80 %153, x86_fp80 %154, i32 %108)
%160 = add nsw i32 %152, 1
br label %161
161: ; preds = %158, %151
%162 = phi i32 [ %160, %158 ], [ %152, %151 ]
%163 = fsub x86_fp80 0xKBFFDFAE147AE147AE148, %114
%164 = tail call x86_fp80 @llvm.floor.f80(x86_fp80 %163)
%165 = fcmp une x86_fp80 %163, %143
%166 = fsub x86_fp80 0xKBFFF8000000000000000, %114
%167 = fcmp une x86_fp80 %164, %166
%168 = select i1 %165, i1 %167, i1 false
br i1 %168, label %169, label %172
169: ; preds = %161
%170 = tail call i32 @flierr(x86_fp80 %163, x86_fp80 %164, i32 %108)
%171 = add nsw i32 %162, 1
br label %172
172: ; preds = %169, %161
%173 = phi i32 [ %171, %169 ], [ %162, %161 ]
%174 = fadd x86_fp80 %114, 0xK3FFF8000000000000000
%175 = add nuw nsw i32 %113, 1
%176 = icmp eq i32 %175, 128
br i1 %176, label %177, label %111
177: ; preds = %120, %172
%178 = phi i32 [ %121, %120 ], [ %173, %172 ]
%179 = fadd x86_fp80 %109, %109
%180 = add nuw nsw i32 %108, 1
%181 = icmp eq i32 %180, 57
br i1 %181, label %182, label %106
182: ; preds = %177
%183 = tail call x86_fp80 @llvm.floor.f80(x86_fp80 0xK00000000000000000000)
%184 = fcmp une x86_fp80 %183, 0xK00000000000000000000
br i1 %184, label %185, label %188
185: ; preds = %182
%186 = tail call i32 @flierr(x86_fp80 0xK00000000000000000000, x86_fp80 %183, i32 57)
%187 = add nsw i32 %178, 1
br label %188
188: ; preds = %185, %182
%189 = phi i32 [ %187, %185 ], [ %178, %182 ]
%190 = tail call x86_fp80 @llvm.floor.f80(x86_fp80 0xK80000000000000000000)
%191 = fcmp une x86_fp80 %190, 0xK00000000000000000000
br i1 %191, label %192, label %195
192: ; preds = %188
%193 = tail call i32 @flierr(x86_fp80 0xK80000000000000000000, x86_fp80 %190, i32 58)
%194 = add nsw i32 %189, 1
br label %195
195: ; preds = %192, %188
%196 = phi i32 [ %194, %192 ], [ %189, %188 ]
%197 = tail call x86_fp80 @llvm.floor.f80(x86_fp80 0xKBFFF8000000000000000)
%198 = fcmp une x86_fp80 %197, 0xKBFFF8000000000000000
br i1 %198, label %199, label %202
199: ; preds = %195
%200 = tail call i32 @flierr(x86_fp80 0xKBFFF8000000000000000, x86_fp80 %197, i32 59)
%201 = add nsw i32 %196, 1
br label %202
202: ; preds = %199, %195
%203 = phi i32 [ %201, %199 ], [ %196, %195 ]
%204 = tail call x86_fp80 @llvm.floor.f80(x86_fp80 0xKBFFBCCCCCCCCCCCCCCCD)
%205 = fcmp une x86_fp80 %204, 0xKBFFF8000000000000000
br i1 %205, label %206, label %209
206: ; preds = %202
%207 = tail call i32 @flierr(x86_fp80 0xKBFFBCCCCCCCCCCCCCCCD, x86_fp80 %204, i32 60)
%208 = add nsw i32 %203, 1
br label %209
209: ; preds = %206, %202
%210 = phi i32 [ %208, %206 ], [ %203, %202 ]
%211 = icmp eq i32 %210, 0
br i1 %211, label %212, label %214
212: ; preds = %209
%213 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @str.10, i64 0, i64 0))
br label %214
214: ; preds = %212, %209
%215 = tail call i32 @exit(i32 0)
unreachable
}