#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 sprintf(char *, char *, ...);
int Printfloat10(char *s, long double ext) {
  int k;
  char *e = (char *)&ext;
  if (*(unsigned int *)e == 0 && *(unsigned short *)(e + 4) == 0 &&
      *(unsigned int *)(e + 6) == 0x7FFF8000L)
    k = sprintf(s, "+INF 7FFF 80000000 00000000");
  else if (*(unsigned int *)e == 0 && *(unsigned short *)(e + 4) == 0 &&
           *(unsigned int *)(e + 6) == 0xFFFF8000L)
    k = sprintf(s, "-INF FFFF 80000000 00000000");
  else if ((*(unsigned int *)(e + 6) & 0x7FFF8000L) == 0x7FFF8000L)
    k = sprintf(s,
                "%cNAN %04X "
                "0x%08x"
                " "
                "0x%08x",
                (e[9] & 0x80) == 0 ? '+' : '-',
                (int)(*(unsigned short *)(e + 8)), *(unsigned int *)(e + 4),
                *(unsigned int *)e);
  else if ((*(unsigned int *)(e + 6) & 0x7FFF0000L) == 0x7FFF0000L)
    k = sprintf(s,
                "%c??? %04X "
                "0x%08x"
                " "
                "0x%08x",
                (e[9] & 0x80) == 0 ? '+' : '-',
                (int)(*(unsigned short *)(e + 8)), *(unsigned int *)(e + 4),
                *(unsigned int *)e);
  else if ((*(unsigned int *)(e + 6) & 0x7FFF0000L) != 0 &&
           (*(unsigned int *)(e + 6) & 0x00008000) == 0)
    k = sprintf(s,
                "%cUNORM %04X "
                "0x%08x"
                " "
                "0x%08x",
                (e[9] & 0x80) == 0 ? '+' : '-',
                (int)(*(unsigned short *)(e + 8)), *(unsigned int *)(e + 4),
                *(unsigned int *)e);
  else if (*(unsigned int *)e == 0 && *(unsigned short *)(e + 4) == 0 &&
           *(unsigned int *)(e + 6) == 0x80000000L)
    k = sprintf(s, "-0.0");
  else if (ext == 0.0)
    k = sprintf(s, "0.0");
  else if ((ext >= -1.e10 && ext < -1.0) || (ext > 1.0 && ext <= 1.e10))
    k = sprintf(s, "%#.20Lg", ext);
  else if ((ext >= -1.0 && ext <= -1.e-5) || (ext >= 1.e-5 && ext <= 1.0))
    k = sprintf(s, "%#.19Lf", ext);
  else
    k = sprintf(s, "%#.19Le", ext);
  return k;
}


x86 assembly (clang, -O0):
<Printfloat10>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
fldt   0x10(%rbp)
mov    %rdi,-0x8(%rbp)
fstpt  -0x20(%rbp)
lea    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmpl   $0x0,(%rax)
jne    1175 <Printfloat10+0x65>
mov    -0x30(%rbp),%rax
movzwl 0x4(%rax),%eax
cmp    $0x0,%eax
jne    1175 <Printfloat10+0x65>
mov    -0x30(%rbp),%rax
mov    0x6(%rax),%eax
cmp    $0x7fff8000,%rax
jne    1175 <Printfloat10+0x65>
mov    -0x8(%rbp),%rdi
lea    0xeb2(%rip),%rsi
mov    $0x0,%al
call   1030 <sprintf@plt>
mov    %eax,-0x24(%rbp)
jmp    14d5 <Printfloat10+0x3c5>
mov    -0x30(%rbp),%rax
cmpl   $0x0,(%rax)
jne    11c2 <Printfloat10+0xb2>
mov    -0x30(%rbp),%rax
movzwl 0x4(%rax),%eax
cmp    $0x0,%eax
jne    11c2 <Printfloat10+0xb2>
mov    -0x30(%rbp),%rax
mov    0x6(%rax),%eax
mov    $0xffff8000,%ecx
cmp    %rcx,%rax
jne    11c2 <Printfloat10+0xb2>
mov    -0x8(%rbp),%rdi
lea    0xe81(%rip),%rsi
mov    $0x0,%al
call   1030 <sprintf@plt>
mov    %eax,-0x24(%rbp)
jmp    14d0 <Printfloat10+0x3c0>
mov    -0x30(%rbp),%rax
mov    0x6(%rax),%eax
and    $0x7fff8000,%rax
cmp    $0x7fff8000,%rax
jne    122a <Printfloat10+0x11a>
mov    -0x8(%rbp),%rdi
mov    -0x30(%rbp),%rax
movsbl 0x9(%rax),%ecx
and    $0x80,%ecx
mov    $0x2d,%edx
mov    $0x2b,%eax
cmp    $0x0,%ecx
cmove  %eax,%edx
mov    -0x30(%rbp),%rax
movzwl 0x8(%rax),%ecx
mov    -0x30(%rbp),%rax
mov    0x4(%rax),%r8d
mov    -0x30(%rbp),%rax
mov    (%rax),%r9d
lea    0xe35(%rip),%rsi
mov    $0x0,%al
call   1030 <sprintf@plt>
mov    %eax,-0x24(%rbp)
jmp    14cb <Printfloat10+0x3bb>
mov    -0x30(%rbp),%rax
mov    0x6(%rax),%eax
and    $0x7fff0000,%rax
cmp    $0x7fff0000,%rax
jne    1292 <Printfloat10+0x182>
mov    -0x8(%rbp),%rdi
mov    -0x30(%rbp),%rax
movsbl 0x9(%rax),%ecx
and    $0x80,%ecx
mov    $0x2d,%edx
mov    $0x2b,%eax
cmp    $0x0,%ecx
cmove  %eax,%edx
mov    -0x30(%rbp),%rax
movzwl 0x8(%rax),%ecx
mov    -0x30(%rbp),%rax
mov    0x4(%rax),%r8d
mov    -0x30(%rbp),%rax
mov    (%rax),%r9d
lea    0xde6(%rip),%rsi
mov    $0x0,%al
call   1030 <sprintf@plt>
mov    %eax,-0x24(%rbp)
jmp    14c6 <Printfloat10+0x3b6>
mov    -0x30(%rbp),%rax
mov    0x6(%rax),%eax
and    $0x7fff0000,%rax
cmp    $0x0,%rax
je     130d <Printfloat10+0x1fd>
mov    -0x30(%rbp),%rax
mov    0x6(%rax),%eax
and    $0x8000,%eax
cmp    $0x0,%eax
jne    130d <Printfloat10+0x1fd>
mov    -0x8(%rbp),%rdi
mov    -0x30(%rbp),%rax
movsbl 0x9(%rax),%ecx
and    $0x80,%ecx
mov    $0x2d,%edx
mov    $0x2b,%eax
cmp    $0x0,%ecx
cmove  %eax,%edx
mov    -0x30(%rbp),%rax
movzwl 0x8(%rax),%ecx
mov    -0x30(%rbp),%rax
mov    0x4(%rax),%r8d
mov    -0x30(%rbp),%rax
mov    (%rax),%r9d
lea    0xd84(%rip),%rsi
mov    $0x0,%al
call   1030 <sprintf@plt>
mov    %eax,-0x24(%rbp)
jmp    14c1 <Printfloat10+0x3b1>
mov    -0x30(%rbp),%rax
cmpl   $0x0,(%rax)
jne    135a <Printfloat10+0x24a>
mov    -0x30(%rbp),%rax
movzwl 0x4(%rax),%eax
cmp    $0x0,%eax
jne    135a <Printfloat10+0x24a>
mov    -0x30(%rbp),%rax
mov    0x6(%rax),%eax
mov    $0x80000000,%ecx
cmp    %rcx,%rax
jne    135a <Printfloat10+0x24a>
mov    -0x8(%rbp),%rdi
lea    0xd52(%rip),%rsi
mov    $0x0,%al
call   1030 <sprintf@plt>
mov    %eax,-0x24(%rbp)
jmp    14bc <Printfloat10+0x3ac>
fldt   -0x20(%rbp)
fldz
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jne    1390 <Printfloat10+0x280>
jp     1390 <Printfloat10+0x280>
jmp    1376 <Printfloat10+0x266>
mov    -0x8(%rbp),%rdi
lea    0xd1d(%rip),%rsi
mov    $0x0,%al
call   1030 <sprintf@plt>
mov    %eax,-0x24(%rbp)
jmp    14b7 <Printfloat10+0x3a7>
fldt   -0x20(%rbp)
flds   0xc67(%rip)
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jb     13c0 <Printfloat10+0x2b0>
jmp    13aa <Printfloat10+0x29a>
fldt   -0x20(%rbp)
fld1
fchs
fucomip %st(1),%st
fstp   %st(0)
ja     13ee <Printfloat10+0x2de>
jmp    13c0 <Printfloat10+0x2b0>
fldt   -0x20(%rbp)
fld1
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jbe    1410 <Printfloat10+0x300>
jmp    13d6 <Printfloat10+0x2c6>
fldt   -0x20(%rbp)
flds   0xc25(%rip)
fucomip %st(1),%st
fstp   %st(0)
jb     1410 <Printfloat10+0x300>
jmp    13ee <Printfloat10+0x2de>
mov    -0x8(%rbp),%rdi
fldt   -0x20(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
lea    0xca1(%rip),%rsi
xor    %eax,%eax
call   1030 <sprintf@plt>
mov    %eax,-0x24(%rbp)
jmp    14b2 <Printfloat10+0x3a2>
fldt   -0x20(%rbp)
fld1
fchs
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jb     1440 <Printfloat10+0x330>
jmp    1428 <Printfloat10+0x318>
fldt   -0x20(%rbp)
fldl   0xbd7(%rip)
fucomip %st(1),%st
fstp   %st(0)
jae    146e <Printfloat10+0x35e>
jmp    1440 <Printfloat10+0x330>
fldt   -0x20(%rbp)
fldl   0xbc7(%rip)
fxch   %st(1)
fucomip %st(1),%st
fstp   %st(0)
jb     1490 <Printfloat10+0x380>
jmp    145a <Printfloat10+0x34a>
fldt   -0x20(%rbp)
fld1
fucomip %st(1),%st
fstp   %st(0)
jb     1490 <Printfloat10+0x380>
jmp    146e <Printfloat10+0x35e>
mov    -0x8(%rbp),%rdi
fldt   -0x20(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
lea    0xc29(%rip),%rsi
xor    %eax,%eax
call   1030 <sprintf@plt>
mov    %eax,-0x24(%rbp)
jmp    14ad <Printfloat10+0x39d>
mov    -0x8(%rbp),%rdi
fldt   -0x20(%rbp)
mov    %rsp,%rax
fstpt  (%rax)
lea    0xc0f(%rip),%rsi
xor    %eax,%eax
call   1030 <sprintf@plt>
mov    %eax,-0x24(%rbp)
jmp    14b2 <Printfloat10+0x3a2>
jmp    14b7 <Printfloat10+0x3a7>
jmp    14bc <Printfloat10+0x3ac>
jmp    14c1 <Printfloat10+0x3b1>
jmp    14c6 <Printfloat10+0x3b6>
jmp    14cb <Printfloat10+0x3bb>
jmp    14d0 <Printfloat10+0x3c0>
jmp    14d5 <Printfloat10+0x3c5>
mov    -0x24(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Printfloat10>:
sub    $0x28,%rsp
fldt   0x30(%rsp)
fld    %st(0)
fstpt  0x10(%rsp)
movswq 0x18(%rsp),%rax
mov    %eax,%edx
not    %edx
mov    0x10(%rsp),%r9
movabs $0x8000000000000000,%rcx
xor    %r9,%rcx
movzwl %dx,%edx
or     %rcx,%rdx
je     1167 <Printfloat10+0x57>
movzwl %ax,%edx
xor    $0x7fff,%rdx
or     %rdx,%rcx
jne    1188 <Printfloat10+0x78>
fstp   %st(0)
movups 0xeca(%rip),%xmm0
movups %xmm0,0xc(%rdi)
movups 0xeb3(%rip),%xmm0
jmp    117b <Printfloat10+0x6b>
fstp   %st(0)
movups 0xed0(%rip),%xmm0
movups %xmm0,0xc(%rdi)
movups 0xeb9(%rip),%xmm0
movups %xmm0,(%rdi)
mov    $0x1b,%eax
add    $0x28,%rsp
ret
movzwl %ax,%ecx
shld   $0x10,%r9,%rcx
mov    %ecx,%edx
not    %edx
test   $0x7fff8000,%edx
jne    11be <Printfloat10+0xae>
fstp   %st(0)
movzwl %ax,%ecx
mov    %rcx,%rax
shr    $0xf,%rax
lea    (%rax,%rax,1),%edx
add    $0x2b,%edx
mov    %r9,%r8
shr    $0x20,%r8
lea    0xe94(%rip),%rsi
jmp    121c <Printfloat10+0x10c>
mov    %rcx,%rdx
and    $0x7fff0000,%rdx
je     1227 <Printfloat10+0x117>
cmp    $0x7fff0000,%rdx
jne    11f5 <Printfloat10+0xe5>
fstp   %st(0)
movzwl %ax,%ecx
mov    %rcx,%rax
shr    $0xf,%rax
lea    (%rax,%rax,1),%edx
add    $0x2b,%edx
mov    %r9,%r8
shr    $0x20,%r8
lea    0xe76(%rip),%rsi
jmp    121c <Printfloat10+0x10c>
bt     $0x3f,%r9
jb     1227 <Printfloat10+0x117>
fstp   %st(0)
movzwl %ax,%ecx
mov    %rcx,%rax
shr    $0xf,%rax
lea    (%rax,%rax,1),%edx
add    $0x2b,%edx
mov    %r9,%r8
shr    $0x20,%r8
lea    0xe66(%rip),%rsi
xor    %eax,%eax
add    $0x28,%rsp
jmp    1030 <sprintf@plt>
shl    $0x10,%r9
jne    124b <Printfloat10+0x13b>
cmp    $0x80000000,%ecx
jne    124b <Printfloat10+0x13b>
fstp   %st(0)
movb   $0x0,0x4(%rdi)
movl   $0x302e302d,(%rdi)
mov    $0x4,%eax
add    $0x28,%rsp
ret
fldz
fxch   %st(1)
fucomi %st(1),%st
fstp   %st(1)
jne    1269 <Printfloat10+0x159>
jp     1269 <Printfloat10+0x159>
fstp   %st(0)
movl   $0x302e30,(%rdi)
mov    $0x3,%eax
add    $0x28,%rsp
ret
flds   0xd91(%rip)
fxch   %st(1)
fucomi %st(1),%st
fstp   %st(1)
fldz
jb     1285 <Printfloat10+0x175>
fstp   %st(0)
fld1
fchs
fucomip %st(1),%st
fldz
ja     129b <Printfloat10+0x18b>
fstp   %st(0)
fld1
fxch   %st(1)
fucomi %st(1),%st
fxch   %st(1)
jbe    12b3 <Printfloat10+0x1a3>
flds   0xd6d(%rip)
fucomip %st(2),%st
jb     12b3 <Printfloat10+0x1a3>
fstp   %st(0)
fstpt  (%rsp)
lea    0xdfb(%rip),%rsi
xor    %eax,%eax
call   1030 <sprintf@plt>
add    $0x28,%rsp
ret
fld    %st(0)
fchs
fxch   %st(2)
fucomi %st(2),%st
fstp   %st(2)
jb     12c9 <Printfloat10+0x1b9>
fldl   0xd43(%rip)
fucomip %st(2),%st
jae    12dd <Printfloat10+0x1cd>
fldl   0xd41(%rip)
fxch   %st(2)
fucomi %st(2),%st
fstp   %st(2)
jb     12eb <Printfloat10+0x1db>
fucomip %st(1),%st
fldz
jb     12eb <Printfloat10+0x1db>
fstp   %st(0)
fstpt  (%rsp)
lea    0xdc1(%rip),%rsi
jmp    12a7 <Printfloat10+0x197>
fstp   %st(0)
fstpt  (%rsp)
lea    0xdbb(%rip),%rsi
jmp    12a7 <Printfloat10+0x197>

LLVM IR (-O0):
@.str = [28 x i8] c"+INF 7FFF 80000000 00000000\00"
@.str.1 = [28 x i8] c"-INF FFFF 80000000 00000000\00"
@.str.2 = [25 x i8] c"%cNAN %04X 0x%08x 0x%08x\00"
@.str.3 = [25 x i8] c"%c??? %04X 0x%08x 0x%08x\00"
@.str.4 = [27 x i8] c"%cUNORM %04X 0x%08x 0x%08x\00"
@.str.5 = [5 x i8] c"-0.0\00"
@.str.6 = [4 x i8] c"0.0\00"
@.str.7 = [8 x i8] c"%#.20Lg\00"
@.str.8 = [8 x i8] c"%#.19Lf\00"
@.str.9 = [8 x i8] c"%#.19Le\00"
define i32 @Printfloat10(i8* %0, x86_fp80 %1) {
%3 = alloca i8*
%4 = alloca x86_fp80
%5 = alloca i32
%6 = alloca i8*
store i8* %0, i8** %3
store x86_fp80 %1, x86_fp80* %4
%7 = bitcast x86_fp80* %4 to i8*
store i8* %7, i8** %6
%8 = load i8*, i8** %6
%9 = bitcast i8* %8 to i32*
%10 = load i32, i32* %9
%11 = icmp eq i32 %10, 0
br i1 %11, label %12, label %29
12: ; preds = %2
%13 = load i8*, i8** %6
%14 = getelementptr inbounds i8, i8* %13, i64 4
%15 = bitcast i8* %14 to i16*
%16 = load i16, i16* %15
%17 = zext i16 %16 to i32
%18 = icmp eq i32 %17, 0
br i1 %18, label %19, label %29
19: ; preds = %12
%20 = load i8*, i8** %6
%21 = getelementptr inbounds i8, i8* %20, i64 6
%22 = bitcast i8* %21 to i32*
%23 = load i32, i32* %22
%24 = zext i32 %23 to i64
%25 = icmp eq i64 %24, 2147450880
br i1 %25, label %26, label %29
26: ; preds = %19
%27 = load i8*, i8** %3
%28 = call i32 (i8*, i8*, ...) @sprintf(i8* %27, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str, i64 0, i64 0))
store i32 %28, i32* %5
br label %223
29: ; preds = %19, %12, %2
%30 = load i8*, i8** %6
%31 = bitcast i8* %30 to i32*
%32 = load i32, i32* %31
%33 = icmp eq i32 %32, 0
br i1 %33, label %34, label %51
34: ; preds = %29
%35 = load i8*, i8** %6
%36 = getelementptr inbounds i8, i8* %35, i64 4
%37 = bitcast i8* %36 to i16*
%38 = load i16, i16* %37
%39 = zext i16 %38 to i32
%40 = icmp eq i32 %39, 0
br i1 %40, label %41, label %51
41: ; preds = %34
%42 = load i8*, i8** %6
%43 = getelementptr inbounds i8, i8* %42, i64 6
%44 = bitcast i8* %43 to i32*
%45 = load i32, i32* %44
%46 = zext i32 %45 to i64
%47 = icmp eq i64 %46, 4294934528
br i1 %47, label %48, label %51
48: ; preds = %41
%49 = load i8*, i8** %3
%50 = call i32 (i8*, i8*, ...) @sprintf(i8* %49, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.1, i64 0, i64 0))
store i32 %50, i32* %5
br label %222
51: ; preds = %41, %34, %29
%52 = load i8*, i8** %6
%53 = getelementptr inbounds i8, i8* %52, i64 6
%54 = bitcast i8* %53 to i32*
%55 = load i32, i32* %54
%56 = zext i32 %55 to i64
%57 = and i64 %56, 2147450880
%58 = icmp eq i64 %57, 2147450880
br i1 %58, label %59, label %82
59: ; preds = %51
%60 = load i8*, i8** %3
%61 = load i8*, i8** %6
%62 = getelementptr inbounds i8, i8* %61, i64 9
%63 = load i8, i8* %62
%64 = sext i8 %63 to i32
%65 = and i32 %64, 128
%66 = icmp eq i32 %65, 0
%67 = zext i1 %66 to i64
%68 = select i1 %66, i32 43, i32 45
%69 = load i8*, i8** %6
%70 = getelementptr inbounds i8, i8* %69, i64 8
%71 = bitcast i8* %70 to i16*
%72 = load i16, i16* %71
%73 = zext i16 %72 to i32
%74 = load i8*, i8** %6
%75 = getelementptr inbounds i8, i8* %74, i64 4
%76 = bitcast i8* %75 to i32*
%77 = load i32, i32* %76
%78 = load i8*, i8** %6
%79 = bitcast i8* %78 to i32*
%80 = load i32, i32* %79
%81 = call i32 (i8*, i8*, ...) @sprintf(i8* %60, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.2, i64 0, i64 0), i32 %68, i32 %73, i32 %77, i32 %80)
store i32 %81, i32* %5
br label %221
82: ; preds = %51
%83 = load i8*, i8** %6
%84 = getelementptr inbounds i8, i8* %83, i64 6
%85 = bitcast i8* %84 to i32*
%86 = load i32, i32* %85
%87 = zext i32 %86 to i64
%88 = and i64 %87, 2147418112
%89 = icmp eq i64 %88, 2147418112
br i1 %89, label %90, label %113
90: ; preds = %82
%91 = load i8*, i8** %3
%92 = load i8*, i8** %6
%93 = getelementptr inbounds i8, i8* %92, i64 9
%94 = load i8, i8* %93
%95 = sext i8 %94 to i32
%96 = and i32 %95, 128
%97 = icmp eq i32 %96, 0
%98 = zext i1 %97 to i64
%99 = select i1 %97, i32 43, i32 45
%100 = load i8*, i8** %6
%101 = getelementptr inbounds i8, i8* %100, i64 8
%102 = bitcast i8* %101 to i16*
%103 = load i16, i16* %102
%104 = zext i16 %103 to i32
%105 = load i8*, i8** %6
%106 = getelementptr inbounds i8, i8* %105, i64 4
%107 = bitcast i8* %106 to i32*
%108 = load i32, i32* %107
%109 = load i8*, i8** %6
%110 = bitcast i8* %109 to i32*
%111 = load i32, i32* %110
%112 = call i32 (i8*, i8*, ...) @sprintf(i8* %91, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.3, i64 0, i64 0), i32 %99, i32 %104, i32 %108, i32 %111)
store i32 %112, i32* %5
br label %220
113: ; preds = %82
%114 = load i8*, i8** %6
%115 = getelementptr inbounds i8, i8* %114, i64 6
%116 = bitcast i8* %115 to i32*
%117 = load i32, i32* %116
%118 = zext i32 %117 to i64
%119 = and i64 %118, 2147418112
%120 = icmp ne i64 %119, 0
br i1 %120, label %121, label %151
121: ; preds = %113
%122 = load i8*, i8** %6
%123 = getelementptr inbounds i8, i8* %122, i64 6
%124 = bitcast i8* %123 to i32*
%125 = load i32, i32* %124
%126 = and i32 %125, 32768
%127 = icmp eq i32 %126, 0
br i1 %127, label %128, label %151
128: ; preds = %121
%129 = load i8*, i8** %3
%130 = load i8*, i8** %6
%131 = getelementptr inbounds i8, i8* %130, i64 9
%132 = load i8, i8* %131
%133 = sext i8 %132 to i32
%134 = and i32 %133, 128
%135 = icmp eq i32 %134, 0
%136 = zext i1 %135 to i64
%137 = select i1 %135, i32 43, i32 45
%138 = load i8*, i8** %6
%139 = getelementptr inbounds i8, i8* %138, i64 8
%140 = bitcast i8* %139 to i16*
%141 = load i16, i16* %140
%142 = zext i16 %141 to i32
%143 = load i8*, i8** %6
%144 = getelementptr inbounds i8, i8* %143, i64 4
%145 = bitcast i8* %144 to i32*
%146 = load i32, i32* %145
%147 = load i8*, i8** %6
%148 = bitcast i8* %147 to i32*
%149 = load i32, i32* %148
%150 = call i32 (i8*, i8*, ...) @sprintf(i8* %129, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.4, i64 0, i64 0), i32 %137, i32 %142, i32 %146, i32 %149)
store i32 %150, i32* %5
br label %219
151: ; preds = %121, %113
%152 = load i8*, i8** %6
%153 = bitcast i8* %152 to i32*
%154 = load i32, i32* %153
%155 = icmp eq i32 %154, 0
br i1 %155, label %156, label %173
156: ; preds = %151
%157 = load i8*, i8** %6
%158 = getelementptr inbounds i8, i8* %157, i64 4
%159 = bitcast i8* %158 to i16*
%160 = load i16, i16* %159
%161 = zext i16 %160 to i32
%162 = icmp eq i32 %161, 0
br i1 %162, label %163, label %173
163: ; preds = %156
%164 = load i8*, i8** %6
%165 = getelementptr inbounds i8, i8* %164, i64 6
%166 = bitcast i8* %165 to i32*
%167 = load i32, i32* %166
%168 = zext i32 %167 to i64
%169 = icmp eq i64 %168, 2147483648
br i1 %169, label %170, label %173
170: ; preds = %163
%171 = load i8*, i8** %3
%172 = call i32 (i8*, i8*, ...) @sprintf(i8* %171, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
store i32 %172, i32* %5
br label %218
173: ; preds = %163, %156, %151
%174 = load x86_fp80, x86_fp80* %4
%175 = fcmp oeq x86_fp80 %174, 0xK00000000000000000000
br i1 %175, label %176, label %179
176: ; preds = %173
%177 = load i8*, i8** %3
%178 = call i32 (i8*, i8*, ...) @sprintf(i8* %177, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0))
store i32 %178, i32* %5
br label %217
179: ; preds = %173
%180 = load x86_fp80, x86_fp80* %4
%181 = fcmp oge x86_fp80 %180, 0xKC0209502F90000000000
br i1 %181, label %182, label %185
182: ; preds = %179
%183 = load x86_fp80, x86_fp80* %4
%184 = fcmp olt x86_fp80 %183, 0xKBFFF8000000000000000
br i1 %184, label %191, label %185
185: ; preds = %182, %179
%186 = load x86_fp80, x86_fp80* %4
%187 = fcmp ogt x86_fp80 %186, 0xK3FFF8000000000000000
br i1 %187, label %188, label %195
188: ; preds = %185
%189 = load x86_fp80, x86_fp80* %4
%190 = fcmp ole x86_fp80 %189, 0xK40209502F90000000000
br i1 %190, label %191, label %195
191: ; preds = %188, %182
%192 = load i8*, i8** %3
%193 = load x86_fp80, x86_fp80* %4
%194 = call i32 (i8*, i8*, ...) @sprintf(i8* %192, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.7, i64 0, i64 0), x86_fp80 %193)
store i32 %194, i32* %5
br label %216
195: ; preds = %188, %185
%196 = load x86_fp80, x86_fp80* %4
%197 = fcmp oge x86_fp80 %196, 0xKBFFF8000000000000000
br i1 %197, label %198, label %201
198: ; preds = %195
%199 = load x86_fp80, x86_fp80* %4
%200 = fcmp ole x86_fp80 %199, 0xKBFEEA7C5AC471B478800
br i1 %200, label %207, label %201
201: ; preds = %198, %195
%202 = load x86_fp80, x86_fp80* %4
%203 = fcmp oge x86_fp80 %202, 0xK3FEEA7C5AC471B478800
br i1 %203, label %204, label %211
204: ; preds = %201
%205 = load x86_fp80, x86_fp80* %4
%206 = fcmp ole x86_fp80 %205, 0xK3FFF8000000000000000
br i1 %206, label %207, label %211
207: ; preds = %204, %198
%208 = load i8*, i8** %3
%209 = load x86_fp80, x86_fp80* %4
%210 = call i32 (i8*, i8*, ...) @sprintf(i8* %208, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.8, i64 0, i64 0), x86_fp80 %209)
store i32 %210, i32* %5
br label %215
211: ; preds = %204, %201
%212 = load i8*, i8** %3
%213 = load x86_fp80, x86_fp80* %4
%214 = call i32 (i8*, i8*, ...) @sprintf(i8* %212, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.9, i64 0, i64 0), x86_fp80 %213)
store i32 %214, i32* %5
br label %215
215: ; preds = %211, %207
br label %216
216: ; preds = %215, %191
br label %217
217: ; preds = %216, %176
br label %218
218: ; preds = %217, %170
br label %219
219: ; preds = %218, %128
br label %220
220: ; preds = %219, %90
br label %221
221: ; preds = %220, %59
br label %222
222: ; preds = %221, %48
br label %223
223: ; preds = %222, %26
%224 = load i32, i32* %5
ret i32 %224
}

LLVM IR (-O2):
@.str = [28 x i8] c"+INF 7FFF 80000000 00000000\00"
@.str.1 = [28 x i8] c"-INF FFFF 80000000 00000000\00"
@.str.2 = [25 x i8] c"%cNAN %04X 0x%08x 0x%08x\00"
@.str.3 = [25 x i8] c"%c??? %04X 0x%08x 0x%08x\00"
@.str.4 = [27 x i8] c"%cUNORM %04X 0x%08x 0x%08x\00"
@.str.5 = [5 x i8] c"-0.0\00"
@.str.7 = [8 x i8] c"%#.20Lg\00"
@.str.8 = [8 x i8] c"%#.19Lf\00"
@.str.9 = [8 x i8] c"%#.19Le\00"
define i32 @Printfloat10(i8* nocapture writeonly %0, x86_fp80 %1) {
%3 = bitcast x86_fp80 %1 to i80
%4 = trunc i80 %3 to i32
%5 = and i80 %3, 281474976710655
%6 = icmp eq i80 %5, 0
switch i80 %3, label %9 [
i80 604453686435277732577280, label %7
i80 -9223372036854775808, label %8
]
7: ; preds = %2
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(28) %0, i8* align 1 dereferenceable(28) getelementptr inbounds ([28 x i8], [28 x i8]* @.str, i64 0, i64 0), i64 28, i1 false)
br label %73
8: ; preds = %2
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(28) %0, i8* align 1 dereferenceable(28) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.1, i64 0, i64 0), i64 28, i1 false)
br label %73
9: ; preds = %2
%10 = lshr i80 %3, 48
%11 = trunc i80 %10 to i64
%12 = and i64 %11, 2147450880
%13 = icmp eq i64 %12, 2147450880
br i1 %13, label %14, label %22
14: ; preds = %9
%15 = icmp sgt i80 %3, -1
%16 = select i1 %15, i32 43, i32 45
%17 = lshr i80 %3, 64
%18 = trunc i80 %17 to i32
%19 = lshr i80 %3, 32
%20 = trunc i80 %19 to i32
%21 = tail call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.2, i64 0, i64 0), i32 %16, i32 %18, i32 %20, i32 %4)
br label %73
22: ; preds = %9
%23 = and i64 %11, 2147418112
switch i64 %23, label %32 [
i64 2147418112, label %24
i64 0, label %43
]
24: ; preds = %22
%25 = icmp sgt i80 %3, -1
%26 = select i1 %25, i32 43, i32 45
%27 = lshr i80 %3, 64
%28 = trunc i80 %27 to i32
%29 = lshr i80 %3, 32
%30 = trunc i80 %29 to i32
%31 = tail call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.3, i64 0, i64 0), i32 %26, i32 %28, i32 %30, i32 %4)
br label %73
32: ; preds = %22
%33 = and i80 %3, 9223372036854775808
%34 = icmp eq i80 %33, 0
br i1 %34, label %35, label %43
35: ; preds = %32
%36 = icmp sgt i80 %3, -1
%37 = select i1 %36, i32 43, i32 45
%38 = lshr i80 %3, 64
%39 = trunc i80 %38 to i32
%40 = lshr i80 %3, 32
%41 = trunc i80 %40 to i32
%42 = tail call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @.str.4, i64 0, i64 0), i32 %37, i32 %39, i32 %41, i32 %4)
br label %73
43: ; preds = %22, %32
%44 = icmp eq i64 %11, 2147483648
%45 = and i1 %6, %44
br i1 %45, label %46, label %47
46: ; preds = %43
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %0, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0), i64 5, i1 false)
br label %73
47: ; preds = %43
%48 = fcmp oeq x86_fp80 %1, 0xK00000000000000000000
br i1 %48, label %49, label %51
49: ; preds = %47
%50 = bitcast i8* %0 to i32*
store i32 3157552, i32* %50
br label %73
51: ; preds = %47
%52 = fcmp oge x86_fp80 %1, 0xKC0209502F90000000000
%53 = fcmp olt x86_fp80 %1, 0xKBFFF8000000000000000
%54 = and i1 %52, %53
br i1 %54, label %59, label %55
55: ; preds = %51
%56 = fcmp ogt x86_fp80 %1, 0xK3FFF8000000000000000
%57 = fcmp ole x86_fp80 %1, 0xK40209502F90000000000
%58 = and i1 %56, %57
br i1 %58, label %59, label %61
59: ; preds = %55, %51
%60 = tail call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.7, i64 0, i64 0), x86_fp80 %1)
br label %73
61: ; preds = %55
%62 = fcmp oge x86_fp80 %1, 0xKBFFF8000000000000000
%63 = fcmp ole x86_fp80 %1, 0xKBFEEA7C5AC471B478800
%64 = and i1 %62, %63
br i1 %64, label %69, label %65
65: ; preds = %61
%66 = fcmp oge x86_fp80 %1, 0xK3FEEA7C5AC471B478800
%67 = fcmp ole x86_fp80 %1, 0xK3FFF8000000000000000
%68 = and i1 %66, %67
br i1 %68, label %69, label %71
69: ; preds = %65, %61
%70 = tail call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.8, i64 0, i64 0), x86_fp80 %1)
br label %73
71: ; preds = %65
%72 = tail call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.9, i64 0, i64 0), x86_fp80 %1)
br label %73
73: ; preds = %8, %24, %46, %59, %71, %69, %49, %35, %14, %7
%74 = phi i32 [ 27, %7 ], [ 27, %8 ], [ %21, %14 ], [ %31, %24 ], [ %42, %35 ], [ 4, %46 ], [ 3, %49 ], [ %60, %59 ], [ %70, %69 ], [ %72, %71 ]
ret i32 %74
}