#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*/ cfltcvt(double, char *, char, int);
int /*<<< orphan*/ cropzeros(char *);
int /*<<< orphan*/ forcdecpt(char *);
int strlen(char *);
char *flt(char *str, double num, int size, int precision, char fmt, int flags) {
  char tmp[80];
  char c, sign;
  int n, i;
  if (flags & 16)
    flags &= ~1;
  c = (flags & 1) ? '0' : ' ';
  sign = 0;
  if (flags & 2) {
    if (num < 0.0) {
      sign = '-';
      num = -num;
      size--;
    } else if (flags & 4) {
      sign = '+';
      size--;
    } else if (flags & 8) {
      sign = ' ';
      size--;
    }
  }
  if (precision < 0)
    precision = 6;
  cfltcvt(num, tmp, fmt, precision);
  if ((flags & 32) && precision == 0)
    forcdecpt(tmp);
  if (fmt == 'g' && !(flags & 32))
    cropzeros(tmp);
  n = strlen(tmp);
  size -= n;
  if (!(flags & (1 | 16)))
    while (size-- > 0)
      *str++ = ' ';
  if (sign)
    *str++ = sign;
  if (!(flags & 16))
    while (size-- > 0)
      *str++ = c;
  for (i = 0; i < n; i++)
    *str++ = tmp[i];
  while (size-- > 0)
    *str++ = ' ';
  return str;
}


x86 assembly (clang, -O0):
<flt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %cl,%al
mov    %rdi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %al,-0x19(%rbp)
mov    %r8d,-0x20(%rbp)
mov    -0x20(%rbp),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     117b <flt+0x3b>
mov    -0x20(%rbp),%eax
and    $0xfffffffe,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%edx
and    $0x1,%edx
mov    $0x20,%eax
mov    $0x30,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %al,-0x71(%rbp)
movb   $0x0,-0x72(%rbp)
mov    -0x20(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     1234 <flt+0xf4>
xorps  %xmm0,%xmm0
ucomisd -0x10(%rbp),%xmm0
jbe    11e8 <flt+0xa8>
movb   $0x2d,-0x72(%rbp)
movsd  -0x10(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x10(%rbp)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    122f <flt+0xef>
mov    -0x20(%rbp),%eax
and    $0x4,%eax
cmp    $0x0,%eax
je     1209 <flt+0xc9>
movb   $0x2b,-0x72(%rbp)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    122a <flt+0xea>
mov    -0x20(%rbp),%eax
and    $0x8,%eax
cmp    $0x0,%eax
je     1225 <flt+0xe5>
movb   $0x20,-0x72(%rbp)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    122a <flt+0xea>
jmp    122f <flt+0xef>
jmp    1234 <flt+0xf4>
cmpl   $0x0,-0x18(%rbp)
jge    1245 <flt+0x105>
movl   $0x6,-0x18(%rbp)
movsd  -0x10(%rbp),%xmm0
lea    -0x70(%rbp),%rdi
mov    -0x19(%rbp),%al
mov    -0x18(%rbp),%edx
movsbl %al,%esi
call   1060 <cfltcvt@plt>
mov    -0x20(%rbp),%eax
and    $0x20,%eax
cmp    $0x0,%eax
je     127e <flt+0x13e>
cmpl   $0x0,-0x18(%rbp)
jne    127e <flt+0x13e>
lea    -0x70(%rbp),%rdi
call   1050 <forcdecpt@plt>
movsbl -0x19(%rbp),%eax
cmp    $0x67,%eax
jne    12a3 <flt+0x163>
mov    -0x20(%rbp),%eax
and    $0x20,%eax
cmp    $0x0,%eax
jne    12a3 <flt+0x163>
lea    -0x70(%rbp),%rdi
call   1030 <cropzeros@plt>
lea    -0x70(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%ecx
mov    -0x14(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%eax
and    $0x11,%eax
cmp    $0x0,%eax
jne    12fe <flt+0x1be>
jmp    12ce <flt+0x18e>
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x14(%rbp)
cmp    $0x0,%eax
jle    12f9 <flt+0x1b9>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movb   $0x20,(%rax)
jmp    12ce <flt+0x18e>
jmp    12fe <flt+0x1be>
cmpb   $0x0,-0x72(%rbp)
je     131c <flt+0x1dc>
mov    -0x72(%rbp),%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%eax
and    $0x10,%eax
cmp    $0x0,%eax
jne    1362 <flt+0x222>
jmp    1330 <flt+0x1f0>
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x14(%rbp)
cmp    $0x0,%eax
jle    135d <flt+0x21d>
mov    -0x71(%rbp),%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
jmp    1330 <flt+0x1f0>
jmp    1362 <flt+0x222>
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    139c <flt+0x25c>
movslq -0x7c(%rbp),%rax
mov    -0x70(%rbp,%rax,1),%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1369 <flt+0x229>
jmp    13a1 <flt+0x261>
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x14(%rbp)
cmp    $0x0,%eax
jle    13cc <flt+0x28c>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movb   $0x20,(%rax)
jmp    13a1 <flt+0x261>
mov    -0x8(%rbp),%rax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<flt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %ecx,%r13d
mov    %esi,%r14d
mov    %rdi,%rbx
mov    %r8d,%r15d
and    $0xfffffffe,%r15d
test   $0x10,%r8b
cmove  %r8d,%r15d
test   $0x2,%r15b
jne    118c <flt+0x3c>
mov    $0x1,%al
mov    %eax,0x8(%rsp)
movl   $0x0,0xc(%rsp)
jmp    11cc <flt+0x7c>
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
jbe    11a6 <flt+0x56>
xorpd  0xe62(%rip),%xmm0
add    $0xffffffff,%r14d
mov    $0x2d,%al
jmp    11c0 <flt+0x70>
test   $0x4,%r15b
jne    11ba <flt+0x6a>
test   $0x8,%r15b
je     117c <flt+0x2c>
add    $0xffffffff,%r14d
mov    $0x20,%al
jmp    11c0 <flt+0x70>
add    $0xffffffff,%r14d
mov    $0x2b,%al
mov    %eax,0xc(%rsp)
movl   $0x0,0x8(%rsp)
test   %edx,%edx
mov    $0x6,%ebp
cmovns %edx,%ebp
movsbl %r13b,%esi
lea    0x10(%rsp),%rdi
mov    %ebp,%edx
call   1070 <cfltcvt@plt>
mov    %r15d,%r12d
and    $0x20,%r12d
test   %ebp,%ebp
jne    1200 <flt+0xb0>
test   %r12d,%r12d
je     1200 <flt+0xb0>
lea    0x10(%rsp),%rdi
call   1060 <forcdecpt@plt>
cmp    $0x67,%r13b
jne    1215 <flt+0xc5>
test   %r12d,%r12d
jne    1215 <flt+0xc5>
lea    0x10(%rsp),%rdi
call   1030 <cropzeros@plt>
lea    0x10(%rsp),%r12
mov    %r12,%rdi
call   1040 <strlen@plt>
mov    %eax,%ebp
sub    %eax,%r14d
test   $0x11,%r15b
jne    125c <flt+0x10c>
lea    -0x1(%r14),%eax
test   %r14d,%r14d
jle    1259 <flt+0x109>
mov    %eax,%r14d
lea    0x1(%r14),%rdx
mov    %rbx,%rdi
mov    $0x20,%esi
call   1050 <memset@plt>
add    %r14,%rbx
add    $0x1,%rbx
mov    $0xffffffff,%r14d
jmp    125c <flt+0x10c>
mov    %eax,%r14d
mov    0x8(%rsp),%eax
test   %al,%al
je     12ab <flt+0x15b>
test   $0x10,%r15b
jne    12bb <flt+0x16b>
lea    -0x1(%r14),%r13d
test   %r14d,%r14d
jle    1387 <flt+0x237>
and    $0x1,%r15b
shl    $0x4,%r15b
or     $0x20,%r15b
mov    %r14d,%edx
movzbl %r15b,%esi
mov    %rbx,%rdi
call   1050 <memset@plt>
mov    %r13d,%eax
add    %rax,%rbx
add    $0x1,%rbx
mov    $0xffffffff,%r14d
test   %ebp,%ebp
jg     12c3 <flt+0x173>
jmp    147b <flt+0x32b>
mov    0xc(%rsp),%eax
mov    %al,(%rbx)
add    $0x1,%rbx
test   $0x10,%r15b
je     126a <flt+0x11a>
test   %ebp,%ebp
jle    147b <flt+0x32b>
mov    %ebp,%r8d
cmp    $0x20,%ebp
jb     12e9 <flt+0x199>
lea    (%rsp,%r8,1),%rcx
add    $0x10,%rcx
cmp    %rcx,%rbx
jae    1397 <flt+0x247>
lea    (%rbx,%r8,1),%rcx
cmp    %rcx,%r12
jae    1397 <flt+0x247>
xor    %ecx,%ecx
mov    %rcx,%rdi
not    %rdi
add    %r8,%rdi
mov    %r8,%rsi
and    $0x7,%rsi
je     1315 <flt+0x1c5>
nopl   (%rax)
movzbl 0x10(%rsp,%rcx,1),%edx
mov    %dl,(%rbx)
add    $0x1,%rbx
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1300 <flt+0x1b0>
cmp    $0x7,%rdi
jb     147b <flt+0x32b>
sub    %rcx,%r8
lea    (%rcx,%r12,1),%rdx
add    $0x7,%rdx
xor    %ecx,%ecx
nopl   0x0(%rax)
movzbl -0x7(%rdx,%rcx,1),%eax
mov    %al,(%rbx,%rcx,1)
movzbl -0x6(%rdx,%rcx,1),%eax
mov    %al,0x1(%rbx,%rcx,1)
movzbl -0x5(%rdx,%rcx,1),%eax
mov    %al,0x2(%rbx,%rcx,1)
movzbl -0x4(%rdx,%rcx,1),%eax
mov    %al,0x3(%rbx,%rcx,1)
movzbl -0x3(%rdx,%rcx,1),%eax
mov    %al,0x4(%rbx,%rcx,1)
movzbl -0x2(%rdx,%rcx,1),%eax
mov    %al,0x5(%rbx,%rcx,1)
movzbl -0x1(%rdx,%rcx,1),%eax
mov    %al,0x6(%rbx,%rcx,1)
movzbl (%rdx,%rcx,1),%eax
mov    %al,0x7(%rbx,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%r8
jne    1330 <flt+0x1e0>
add    %rcx,%rbx
jmp    147b <flt+0x32b>
mov    %r13d,%r14d
test   %ebp,%ebp
jg     12c3 <flt+0x173>
jmp    147b <flt+0x32b>
mov    %r8d,%ecx
and    $0xffffffe0,%ecx
lea    -0x20(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x60,%rdi
jae    13bb <flt+0x26b>
xor    %edi,%edi
jmp    1430 <flt+0x2e0>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movaps 0x10(%rsp,%rdi,1),%xmm0
movaps 0x20(%rsp,%rdi,1),%xmm1
movups %xmm0,(%rbx,%rdi,1)
movups %xmm1,0x10(%rbx,%rdi,1)
movaps 0x30(%rsp,%rdi,1),%xmm0
movaps 0x40(%rsp,%rdi,1),%xmm1
movups %xmm0,0x20(%rbx,%rdi,1)
movups %xmm1,0x30(%rbx,%rdi,1)
movaps 0x50(%rsp,%rdi,1),%xmm0
movaps 0x60(%rsp,%rdi,1),%xmm1
movups %xmm0,0x40(%rbx,%rdi,1)
movups %xmm1,0x50(%rbx,%rdi,1)
movapd 0x70(%rsp,%rdi,1),%xmm0
movapd 0x80(%rsp,%rdi,1),%xmm1
movupd %xmm0,0x60(%rbx,%rdi,1)
movupd %xmm1,0x70(%rbx,%rdi,1)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffffc,%rsi
jne    13d0 <flt+0x280>
test   %rdx,%rdx
je     146f <flt+0x31f>
lea    (%rsp,%rdi,1),%rsi
add    $0x20,%rsi
add    %rbx,%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movapd -0x10(%rsi,%rbp,1),%xmm0
movapd (%rsi,%rbp,1),%xmm1
movupd %xmm0,-0x10(%rdi,%rbp,1)
movupd %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    1450 <flt+0x300>
add    %rcx,%rbx
cmp    %r8,%rcx
jne    12eb <flt+0x19b>
test   %r14d,%r14d
jle    149b <flt+0x34b>
mov    %r14d,%edx
mov    %rbx,%rdi
mov    $0x20,%esi
call   1050 <memset@plt>
add    $0xffffffff,%r14d
add    %r14,%rbx
add    $0x1,%rbx
mov    %rbx,%rax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i8* @flt(i8* %0, double %1, i32 %2, i32 %3, i8 signext %4, i32 %5) {
%7 = alloca i8*
%8 = alloca double
%9 = alloca i32
%10 = alloca i32
%11 = alloca i8
%12 = alloca i32
%13 = alloca [80 x i8]
%14 = alloca i8
%15 = alloca i8
%16 = alloca i32
%17 = alloca i32
store i8* %0, i8** %7
store double %1, double* %8
store i32 %2, i32* %9
store i32 %3, i32* %10
store i8 %4, i8* %11
store i32 %5, i32* %12
%18 = load i32, i32* %12
%19 = and i32 %18, 16
%20 = icmp ne i32 %19, 0
br i1 %20, label %21, label %24
21: ; preds = %6
%22 = load i32, i32* %12
%23 = and i32 %22, -2
store i32 %23, i32* %12
br label %24
24: ; preds = %21, %6
%25 = load i32, i32* %12
%26 = and i32 %25, 1
%27 = icmp ne i32 %26, 0
%28 = zext i1 %27 to i64
%29 = select i1 %27, i32 48, i32 32
%30 = trunc i32 %29 to i8
store i8 %30, i8* %14
store i8 0, i8* %15
%31 = load i32, i32* %12
%32 = and i32 %31, 2
%33 = icmp ne i32 %32, 0
br i1 %33, label %34, label %59
34: ; preds = %24
%35 = load double, double* %8
%36 = fcmp olt double %35, 0.000000e+00
br i1 %36, label %37, label %42
37: ; preds = %34
store i8 45, i8* %15
%38 = load double, double* %8
%39 = fneg double %38
store double %39, double* %8
%40 = load i32, i32* %9
%41 = add nsw i32 %40, -1
store i32 %41, i32* %9
br label %58
42: ; preds = %34
%43 = load i32, i32* %12
%44 = and i32 %43, 4
%45 = icmp ne i32 %44, 0
br i1 %45, label %46, label %49
46: ; preds = %42
store i8 43, i8* %15
%47 = load i32, i32* %9
%48 = add nsw i32 %47, -1
store i32 %48, i32* %9
br label %57
49: ; preds = %42
%50 = load i32, i32* %12
%51 = and i32 %50, 8
%52 = icmp ne i32 %51, 0
br i1 %52, label %53, label %56
53: ; preds = %49
store i8 32, i8* %15
%54 = load i32, i32* %9
%55 = add nsw i32 %54, -1
store i32 %55, i32* %9
br label %56
56: ; preds = %53, %49
br label %57
57: ; preds = %56, %46
br label %58
58: ; preds = %57, %37
br label %59
59: ; preds = %58, %24
%60 = load i32, i32* %10
%61 = icmp slt i32 %60, 0
br i1 %61, label %62, label %63
62: ; preds = %59
store i32 6, i32* %10
br label %63
63: ; preds = %62, %59
%64 = load double, double* %8
%65 = getelementptr inbounds [80 x i8], [80 x i8]* %13, i64 0, i64 0
%66 = load i8, i8* %11
%67 = load i32, i32* %10
%68 = call i32 @cfltcvt(double %64, i8* %65, i8 signext %66, i32 %67)
%69 = load i32, i32* %12
%70 = and i32 %69, 32
%71 = icmp ne i32 %70, 0
br i1 %71, label %72, label %78
72: ; preds = %63
%73 = load i32, i32* %10
%74 = icmp eq i32 %73, 0
br i1 %74, label %75, label %78
75: ; preds = %72
%76 = getelementptr inbounds [80 x i8], [80 x i8]* %13, i64 0, i64 0
%77 = call i32 @forcdecpt(i8* %76)
br label %78
78: ; preds = %75, %72, %63
%79 = load i8, i8* %11
%80 = sext i8 %79 to i32
%81 = icmp eq i32 %80, 103
br i1 %81, label %82, label %89
82: ; preds = %78
%83 = load i32, i32* %12
%84 = and i32 %83, 32
%85 = icmp ne i32 %84, 0
br i1 %85, label %89, label %86
86: ; preds = %82
%87 = getelementptr inbounds [80 x i8], [80 x i8]* %13, i64 0, i64 0
%88 = call i32 @cropzeros(i8* %87)
br label %89
89: ; preds = %86, %82, %78
%90 = getelementptr inbounds [80 x i8], [80 x i8]* %13, i64 0, i64 0
%91 = call i32 @strlen(i8* %90)
store i32 %91, i32* %16
%92 = load i32, i32* %16
%93 = load i32, i32* %9
%94 = sub nsw i32 %93, %92
store i32 %94, i32* %9
%95 = load i32, i32* %12
%96 = and i32 %95, 17
%97 = icmp ne i32 %96, 0
br i1 %97, label %107, label %98
98: ; preds = %89
br label %99
99: ; preds = %103, %98
%100 = load i32, i32* %9
%101 = add nsw i32 %100, -1
store i32 %101, i32* %9
%102 = icmp sgt i32 %100, 0
br i1 %102, label %103, label %106
103: ; preds = %99
%104 = load i8*, i8** %7
%105 = getelementptr inbounds i8, i8* %104, i32 1
store i8* %105, i8** %7
store i8 32, i8* %104
br label %99
106: ; preds = %99
br label %107
107: ; preds = %106, %89
%108 = load i8, i8* %15
%109 = icmp ne i8 %108, 0
br i1 %109, label %110, label %114
110: ; preds = %107
%111 = load i8, i8* %15
%112 = load i8*, i8** %7
%113 = getelementptr inbounds i8, i8* %112, i32 1
store i8* %113, i8** %7
store i8 %111, i8* %112
br label %114
114: ; preds = %110, %107
%115 = load i32, i32* %12
%116 = and i32 %115, 16
%117 = icmp ne i32 %116, 0
br i1 %117, label %128, label %118
118: ; preds = %114
br label %119
119: ; preds = %123, %118
%120 = load i32, i32* %9
%121 = add nsw i32 %120, -1
store i32 %121, i32* %9
%122 = icmp sgt i32 %120, 0
br i1 %122, label %123, label %127
123: ; preds = %119
%124 = load i8, i8* %14
%125 = load i8*, i8** %7
%126 = getelementptr inbounds i8, i8* %125, i32 1
store i8* %126, i8** %7
store i8 %124, i8* %125
br label %119
127: ; preds = %119
br label %128
128: ; preds = %127, %114
store i32 0, i32* %17
br label %129
129: ; preds = %140, %128
%130 = load i32, i32* %17
%131 = load i32, i32* %16
%132 = icmp slt i32 %130, %131
br i1 %132, label %133, label %143
133: ; preds = %129
%134 = load i32, i32* %17
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds [80 x i8], [80 x i8]* %13, i64 0, i64 %135
%137 = load i8, i8* %136
%138 = load i8*, i8** %7
%139 = getelementptr inbounds i8, i8* %138, i32 1
store i8* %139, i8** %7
store i8 %137, i8* %138
br label %140
140: ; preds = %133
%141 = load i32, i32* %17
%142 = add nsw i32 %141, 1
store i32 %142, i32* %17
br label %129
143: ; preds = %129
br label %144
144: ; preds = %148, %143
%145 = load i32, i32* %9
%146 = add nsw i32 %145, -1
store i32 %146, i32* %9
%147 = icmp sgt i32 %145, 0
br i1 %147, label %148, label %151
148: ; preds = %144
%149 = load i8*, i8** %7
%150 = getelementptr inbounds i8, i8* %149, i32 1
store i8* %150, i8** %7
store i8 32, i8* %149
br label %144
151: ; preds = %144
%152 = load i8*, i8** %7
ret i8* %152
}

LLVM IR (-O2):
define i8* @flt(i8* writeonly %0, double %1, i32 %2, i32 %3, i8 signext %4, i32 %5) {
%7 = alloca [80 x i8]
%8 = getelementptr inbounds [80 x i8], [80 x i8]* %7, i64 0, i64 0
%9 = getelementptr inbounds [80 x i8], [80 x i8]* %7, i64 0, i64 0
%10 = and i32 %5, 16
%11 = icmp eq i32 %10, 0
%12 = and i32 %5, -2
%13 = select i1 %11, i32 %5, i32 %12
%14 = and i32 %13, 1
%15 = icmp eq i32 %14, 0
%16 = select i1 %15, i8 32, i8 48
%17 = and i32 %13, 2
%18 = icmp eq i32 %17, 0
br i1 %18, label %34, label %19
19: ; preds = %6
%20 = fcmp olt double %1, 0.000000e+00
br i1 %20, label %21, label %24
21: ; preds = %19
%22 = fneg double %1
%23 = add nsw i32 %2, -1
br label %34
24: ; preds = %19
%25 = and i32 %13, 4
%26 = icmp eq i32 %25, 0
br i1 %26, label %29, label %27
27: ; preds = %24
%28 = add nsw i32 %2, -1
br label %34
29: ; preds = %24
%30 = and i32 %13, 8
%31 = icmp eq i32 %30, 0
br i1 %31, label %34, label %32
32: ; preds = %29
%33 = add nsw i32 %2, -1
br label %34
34: ; preds = %21, %29, %32, %27, %6
%35 = phi i32 [ %23, %21 ], [ %28, %27 ], [ %33, %32 ], [ %2, %29 ], [ %2, %6 ]
%36 = phi double [ %22, %21 ], [ %1, %27 ], [ %1, %32 ], [ %1, %29 ], [ %1, %6 ]
%37 = phi i1 [ false, %21 ], [ false, %27 ], [ false, %32 ], [ true, %29 ], [ true, %6 ]
%38 = phi i8 [ 45, %21 ], [ 43, %27 ], [ 32, %32 ], [ 0, %29 ], [ 0, %6 ]
%39 = icmp slt i32 %3, 0
%40 = select i1 %39, i32 6, i32 %3
%41 = call i32 @cfltcvt(double %36, i8* %9, i8 signext %4, i32 %40)
%42 = and i32 %13, 32
%43 = icmp ne i32 %42, 0
%44 = icmp eq i32 %40, 0
%45 = and i1 %44, %43
br i1 %45, label %46, label %48
46: ; preds = %34
%47 = call i32 @forcdecpt(i8* %9)
br label %48
48: ; preds = %46, %34
%49 = icmp ne i8 %4, 103
%50 = or i1 %49, %43
br i1 %50, label %53, label %51
51: ; preds = %48
%52 = call i32 @cropzeros(i8* %9)
br label %53
53: ; preds = %48, %51
%54 = call i32 @strlen(i8* %9)
%55 = sub nsw i32 %35, %54
%56 = and i32 %13, 17
%57 = icmp eq i32 %56, 0
br i1 %57, label %58, label %65
58: ; preds = %53
%59 = add i32 %55, -1
%60 = icmp sgt i32 %55, 0
br i1 %60, label %61, label %65
61: ; preds = %58
%62 = zext i32 %59 to i64
%63 = add nuw nsw i64 %62, 1
%64 = getelementptr i8, i8* %0, i64 %63
br label %65
65: ; preds = %61, %58, %53
%66 = phi i32 [ %55, %53 ], [ %59, %58 ], [ -1, %61 ]
%67 = phi i8* [ %0, %53 ], [ %0, %58 ], [ %64, %61 ]
br i1 %37, label %70, label %68
68: ; preds = %65
%69 = getelementptr inbounds i8, i8* %67, i64 1
store i8 %38, i8* %67
br label %70
70: ; preds = %68, %65
%71 = phi i8* [ %69, %68 ], [ %67, %65 ]
%72 = and i32 %13, 16
%73 = icmp eq i32 %72, 0
br i1 %73, label %74, label %82
74: ; preds = %70
%75 = add i32 %66, -1
%76 = icmp sgt i32 %66, 0
br i1 %76, label %77, label %82
77: ; preds = %74
%78 = zext i32 %66 to i64
%79 = zext i32 %75 to i64
%80 = add nuw nsw i64 %79, 1
%81 = getelementptr i8, i8* %71, i64 %80
br label %82
82: ; preds = %77, %74, %70
%83 = phi i32 [ %66, %70 ], [ %75, %74 ], [ -1, %77 ]
%84 = phi i8* [ %71, %70 ], [ %71, %74 ], [ %81, %77 ]
%85 = icmp sgt i32 %54, 0
br i1 %85, label %86, label %197
86: ; preds = %82
%87 = zext i32 %54 to i64
%88 = icmp ult i32 %54, 32
br i1 %88, label %175, label %89
89: ; preds = %86
%90 = getelementptr i8, i8* %84, i64 %87
%91 = getelementptr [80 x i8], [80 x i8]* %7, i64 0, i64 %87
%92 = icmp ult i8* %84, %91
%93 = icmp ult i8* %8, %90
%94 = and i1 %92, %93
br i1 %94, label %175, label %95
95: ; preds = %89
%96 = and i64 %87, 4294967264
%97 = getelementptr i8, i8* %84, i64 %96
%98 = add nsw i64 %96, -32
%99 = lshr exact i64 %98, 5
%100 = add nuw nsw i64 %99, 1
%101 = and i64 %100, 3
%102 = icmp ult i64 %98, 96
br i1 %102, label %154, label %103
103: ; preds = %95
%104 = and i64 %100, 1152921504606846972
br label %105
105: ; preds = %105, %103
%106 = phi i64 [ 0, %103 ], [ %151, %105 ]
%107 = phi i64 [ 0, %103 ], [ %152, %105 ]
%108 = getelementptr i8, i8* %84, i64 %106
%109 = getelementptr inbounds [80 x i8], [80 x i8]* %7, i64 0, i64 %106
%110 = bitcast i8* %109 to <16 x i8>*
%111 = load <16 x i8>, <16 x i8>* %110
%112 = getelementptr inbounds i8, i8* %109, i64 16
%113 = bitcast i8* %112 to <16 x i8>*
%114 = load <16 x i8>, <16 x i8>* %113
%115 = bitcast i8* %108 to <16 x i8>*
store <16 x i8> %111, <16 x i8>* %115
%116 = getelementptr i8, i8* %108, i64 16
%117 = bitcast i8* %116 to <16 x i8>*
store <16 x i8> %114, <16 x i8>* %117
%118 = or i64 %106, 32
%119 = getelementptr i8, i8* %84, i64 %118
%120 = getelementptr inbounds [80 x i8], [80 x i8]* %7, i64 0, i64 %118
%121 = bitcast i8* %120 to <16 x i8>*
%122 = load <16 x i8>, <16 x i8>* %121
%123 = getelementptr inbounds i8, i8* %120, i64 16
%124 = bitcast i8* %123 to <16 x i8>*
%125 = load <16 x i8>, <16 x i8>* %124
%126 = bitcast i8* %119 to <16 x i8>*
store <16 x i8> %122, <16 x i8>* %126
%127 = getelementptr i8, i8* %119, i64 16
%128 = bitcast i8* %127 to <16 x i8>*
store <16 x i8> %125, <16 x i8>* %128
%129 = or i64 %106, 64
%130 = getelementptr i8, i8* %84, i64 %129
%131 = getelementptr inbounds [80 x i8], [80 x i8]* %7, i64 0, i64 %129
%132 = bitcast i8* %131 to <16 x i8>*
%133 = load <16 x i8>, <16 x i8>* %132
%134 = getelementptr inbounds i8, i8* %131, i64 16
%135 = bitcast i8* %134 to <16 x i8>*
%136 = load <16 x i8>, <16 x i8>* %135
%137 = bitcast i8* %130 to <16 x i8>*
store <16 x i8> %133, <16 x i8>* %137
%138 = getelementptr i8, i8* %130, i64 16
%139 = bitcast i8* %138 to <16 x i8>*
store <16 x i8> %136, <16 x i8>* %139
%140 = or i64 %106, 96
%141 = getelementptr i8, i8* %84, i64 %140
%142 = getelementptr inbounds [80 x i8], [80 x i8]* %7, i64 0, i64 %140
%143 = bitcast i8* %142 to <16 x i8>*
%144 = load <16 x i8>, <16 x i8>* %143
%145 = getelementptr inbounds i8, i8* %142, i64 16
%146 = bitcast i8* %145 to <16 x i8>*
%147 = load <16 x i8>, <16 x i8>* %146
%148 = bitcast i8* %141 to <16 x i8>*
store <16 x i8> %144, <16 x i8>* %148
%149 = getelementptr i8, i8* %141, i64 16
%150 = bitcast i8* %149 to <16 x i8>*
store <16 x i8> %147, <16 x i8>* %150
%151 = add nuw i64 %106, 128
%152 = add i64 %107, 4
%153 = icmp eq i64 %152, %104
br i1 %153, label %154, label %105
154: ; preds = %105, %95
%155 = phi i64 [ 0, %95 ], [ %151, %105 ]
%156 = icmp eq i64 %101, 0
br i1 %156, label %173, label %157
157: ; preds = %154, %157
%158 = phi i64 [ %170, %157 ], [ %155, %154 ]
%159 = phi i64 [ %171, %157 ], [ 0, %154 ]
%160 = getelementptr i8, i8* %84, i64 %158
%161 = getelementptr inbounds [80 x i8], [80 x i8]* %7, i64 0, i64 %158
%162 = bitcast i8* %161 to <16 x i8>*
%163 = load <16 x i8>, <16 x i8>* %162
%164 = getelementptr inbounds i8, i8* %161, i64 16
%165 = bitcast i8* %164 to <16 x i8>*
%166 = load <16 x i8>, <16 x i8>* %165
%167 = bitcast i8* %160 to <16 x i8>*
store <16 x i8> %163, <16 x i8>* %167
%168 = getelementptr i8, i8* %160, i64 16
%169 = bitcast i8* %168 to <16 x i8>*
store <16 x i8> %166, <16 x i8>* %169
%170 = add nuw i64 %158, 32
%171 = add i64 %159, 1
%172 = icmp eq i64 %171, %101
br i1 %172, label %173, label %157
173: ; preds = %157, %154
%174 = icmp eq i64 %96, %87
br i1 %174, label %197, label %175
175: ; preds = %89, %86, %173
%176 = phi i64 [ 0, %89 ], [ 0, %86 ], [ %96, %173 ]
%177 = phi i8* [ %84, %89 ], [ %84, %86 ], [ %97, %173 ]
%178 = xor i64 %176, -1
%179 = add nsw i64 %178, %87
%180 = and i64 %87, 7
%181 = icmp eq i64 %180, 0
br i1 %181, label %192, label %182
182: ; preds = %175, %182
%183 = phi i64 [ %189, %182 ], [ %176, %175 ]
%184 = phi i8* [ %188, %182 ], [ %177, %175 ]
%185 = phi i64 [ %190, %182 ], [ 0, %175 ]
%186 = getelementptr inbounds [80 x i8], [80 x i8]* %7, i64 0, i64 %183
%187 = load i8, i8* %186
%188 = getelementptr inbounds i8, i8* %184, i64 1
store i8 %187, i8* %184
%189 = add nuw nsw i64 %183, 1
%190 = add i64 %185, 1
%191 = icmp eq i64 %190, %180
br i1 %191, label %192, label %182
192: ; preds = %182, %175
%193 = phi i8* [ undef, %175 ], [ %188, %182 ]
%194 = phi i64 [ %176, %175 ], [ %189, %182 ]
%195 = phi i8* [ %177, %175 ], [ %188, %182 ]
%196 = icmp ult i64 %179, 7
br i1 %196, label %197, label %206
197: ; preds = %192, %206, %173, %82
%198 = phi i8* [ %84, %82 ], [ %97, %173 ], [ %193, %192 ], [ %239, %206 ]
%199 = icmp sgt i32 %83, 0
br i1 %199, label %200, label %242
200: ; preds = %197
%201 = zext i32 %83 to i64
%202 = add nsw i32 %83, -1
%203 = zext i32 %202 to i64
%204 = add nuw nsw i64 %203, 1
%205 = getelementptr i8, i8* %198, i64 %204
br label %242
206: ; preds = %192, %206
%207 = phi i64 [ %240, %206 ], [ %194, %192 ]
%208 = phi i8* [ %239, %206 ], [ %195, %192 ]
%209 = getelementptr inbounds [80 x i8], [80 x i8]* %7, i64 0, i64 %207
%210 = load i8, i8* %209
%211 = getelementptr inbounds i8, i8* %208, i64 1
store i8 %210, i8* %208
%212 = add nuw nsw i64 %207, 1
%213 = getelementptr inbounds [80 x i8], [80 x i8]* %7, i64 0, i64 %212
%214 = load i8, i8* %213
%215 = getelementptr inbounds i8, i8* %208, i64 2
store i8 %214, i8* %211
%216 = add nuw nsw i64 %207, 2
%217 = getelementptr inbounds [80 x i8], [80 x i8]* %7, i64 0, i64 %216
%218 = load i8, i8* %217
%219 = getelementptr inbounds i8, i8* %208, i64 3
store i8 %218, i8* %215
%220 = add nuw nsw i64 %207, 3
%221 = getelementptr inbounds [80 x i8], [80 x i8]* %7, i64 0, i64 %220
%222 = load i8, i8* %221
%223 = getelementptr inbounds i8, i8* %208, i64 4
store i8 %222, i8* %219
%224 = add nuw nsw i64 %207, 4
%225 = getelementptr inbounds [80 x i8], [80 x i8]* %7, i64 0, i64 %224
%226 = load i8, i8* %225
%227 = getelementptr inbounds i8, i8* %208, i64 5
store i8 %226, i8* %223
%228 = add nuw nsw i64 %207, 5
%229 = getelementptr inbounds [80 x i8], [80 x i8]* %7, i64 0, i64 %228
%230 = load i8, i8* %229
%231 = getelementptr inbounds i8, i8* %208, i64 6
store i8 %230, i8* %227
%232 = add nuw nsw i64 %207, 6
%233 = getelementptr inbounds [80 x i8], [80 x i8]* %7, i64 0, i64 %232
%234 = load i8, i8* %233
%235 = getelementptr inbounds i8, i8* %208, i64 7
store i8 %234, i8* %231
%236 = add nuw nsw i64 %207, 7
%237 = getelementptr inbounds [80 x i8], [80 x i8]* %7, i64 0, i64 %236
%238 = load i8, i8* %237
%239 = getelementptr inbounds i8, i8* %208, i64 8
store i8 %238, i8* %235
%240 = add nuw nsw i64 %207, 8
%241 = icmp eq i64 %240, %87
br i1 %241, label %197, label %206
242: ; preds = %200, %197
%243 = phi i8* [ %198, %197 ], [ %205, %200 ]
ret i8* %243
}