#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 */
scalar_t__ isdigit(int);
float atof(char *s) {
  float a = 0.0;
  int e = 0;
  int c;
  while ((c = *s++) != '\0' && isdigit(c)) {
    a = a * 10.0 + (c - '0');
  }
  if (c == '.') {
    while ((c = *s++) != '\0' && isdigit(c)) {
      a = a * 10.0 + (c - '0');
      e = e - 1;
    }
  }
  if (c == 'e' || c == 'E') {
    int sign = 1;
    int i = 0;
    c = *s++;
    if (c == '+')
      c = *s++;
    else if (c == '-') {
      c = *s++;
      sign = -1;
    }
    while (isdigit(c)) {
      i = i * 10 + (c - '0');
      c = *s++;
    }
    e += i * sign;
  }
  while (e > 0) {
    a *= 10.0;
    e--;
  }
  while (e < 0) {
    a *= 0.1;
    e++;
  }
  return a;
}


x86 assembly (clang, -O0):
<atof>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movsbl (%rax),%ecx
mov    %ecx,-0x14(%rbp)
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x1d(%rbp)
je     1160 <atof+0x50>
mov    -0x14(%rbp),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x1d(%rbp)
mov    -0x1d(%rbp),%al
test   $0x1,%al
jne    1170 <atof+0x60>
jmp    11a1 <atof+0x91>
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x14(%rbp),%eax
sub    $0x30,%eax
cvtsi2sd %eax,%xmm1
movsd  0xe7d(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xc(%rbp)
jmp    112b <atof+0x1b>
cmpl   $0x2e,-0x14(%rbp)
jne    1234 <atof+0x124>
jmp    11b0 <atof+0xa0>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movsbl (%rax),%ecx
mov    %ecx,-0x14(%rbp)
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x1e(%rbp)
je     11e5 <atof+0xd5>
mov    -0x14(%rbp),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x1e(%rbp)
mov    -0x1e(%rbp),%al
test   $0x1,%al
jne    11f5 <atof+0xe5>
jmp    122f <atof+0x11f>
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x14(%rbp),%eax
sub    $0x30,%eax
cvtsi2sd %eax,%xmm1
movsd  0xdf8(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xc(%rbp)
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11b0 <atof+0xa0>
jmp    1234 <atof+0x124>
cmpl   $0x65,-0x14(%rbp)
je     1248 <atof+0x138>
cmpl   $0x45,-0x14(%rbp)
jne    1307 <atof+0x1f7>
movl   $0x1,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movsbl (%rax),%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x2b,-0x14(%rbp)
jne    128f <atof+0x17f>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movsbl (%rax),%eax
mov    %eax,-0x14(%rbp)
jmp    12ba <atof+0x1aa>
cmpl   $0x2d,-0x14(%rbp)
jne    12b5 <atof+0x1a5>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movsbl (%rax),%eax
mov    %eax,-0x14(%rbp)
movl   $0xffffffff,-0x18(%rbp)
jmp    12ba <atof+0x1aa>
jmp    12bf <atof+0x1af>
mov    -0x14(%rbp),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     12fa <atof+0x1ea>
imul   $0xa,-0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x30,%ecx
add    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movsbl (%rax),%eax
mov    %eax,-0x14(%rbp)
jmp    12bf <atof+0x1af>
mov    -0x1c(%rbp),%eax
imul   -0x18(%rbp),%eax
add    -0x10(%rbp),%eax
mov    %eax,-0x10(%rbp)
jmp    130c <atof+0x1fc>
cmpl   $0x0,-0x10(%rbp)
jle    1342 <atof+0x232>
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xce1(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xc(%rbp)
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    130c <atof+0x1fc>
jmp    1347 <atof+0x237>
cmpl   $0x0,-0x10(%rbp)
jge    137d <atof+0x26d>
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc9e(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xc(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1347 <atof+0x237>
movss  -0xc(%rbp),%xmm0
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<atof>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x10,%rsp
mov    (%rdi),%bl
test   %bl,%bl
je     1178 <atof+0x68>
mov    %rdi,%r12
add    $0x1,%r12
xorps  %xmm0,%xmm0
nopl   0x0(%rax)
movss  %xmm0,0xc(%rsp)
movsbl %bl,%ebp
mov    %ebp,%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     1188 <atof+0x78>
movss  0xc(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
add    $0xffffffd0,%ebp
xorps  %xmm1,%xmm1
cvtsi2sd %ebp,%xmm1
mulsd  0xe9f(%rip),%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movzbl (%r12),%ebx
add    $0x1,%r12
test   %bl,%bl
jne    1130 <atof+0x20>
jmp    117b <atof+0x6b>
xorps  %xmm0,%xmm0
add    $0x10,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %r15d,%r15d
cmp    $0x2e,%bl
jne    127f <atof+0x16f>
mov    (%r12),%bl
test   %bl,%bl
movss  0xc(%rsp),%xmm0
je     117b <atof+0x6b>
add    $0x1,%r12
xor    %r15d,%r15d
nopl   0x0(%rax)
movss  %xmm0,0xc(%rsp)
movsbl %bl,%ebp
mov    %ebp,%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     127f <atof+0x16f>
movss  0xc(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
add    $0xffffffd0,%ebp
xorps  %xmm1,%xmm1
cvtsi2sd %ebp,%xmm1
mulsd  0xe1b(%rip),%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
add    $0xffffffff,%r15d
movzbl (%r12),%ebx
add    $0x1,%r12
test   %bl,%bl
jne    11b0 <atof+0xa0>
test   %r15d,%r15d
jle    12f9 <atof+0x1e9>
lea    -0x1(%r15),%eax
mov    %r15d,%ecx
and    $0x7,%ecx
je     122e <atof+0x11e>
xor    %edx,%edx
movss  0xdf3(%rip),%xmm1
nopl   (%rax)
mulss  %xmm1,%xmm0
add    $0x1,%edx
cmp    %edx,%ecx
jne    1220 <atof+0x110>
sub    %edx,%r15d
cmp    $0x7,%eax
jb     117b <atof+0x6b>
add    $0xffffffff,%r15d
movss  0xdcd(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mulss  %xmm1,%xmm0
mulss  %xmm1,%xmm0
mulss  %xmm1,%xmm0
mulss  %xmm1,%xmm0
mulss  %xmm1,%xmm0
mulss  %xmm1,%xmm0
mulss  %xmm1,%xmm0
mulss  %xmm1,%xmm0
add    $0xfffffff8,%r15d
cmp    $0xfffffffe,%r15d
jb     1250 <atof+0x140>
jmp    117b <atof+0x6b>
and    $0xdf,%bl
cmp    $0x45,%bl
jne    12ea <atof+0x1da>
mov    (%r12),%al
mov    $0x1,%ebx
cmp    $0x2b,%al
je     129d <atof+0x18d>
cmp    $0x2d,%al
jne    12a8 <atof+0x198>
mov    $0xffffffff,%ebx
mov    0x1(%r12),%al
add    $0x2,%r12
jmp    12ac <atof+0x19c>
add    $0x1,%r12
movsbl %al,%r14d
mov    %r14d,%edi
call   1030 <isdigit@plt>
xor    %ebp,%ebp
test   %rax,%rax
je     12e1 <atof+0x1d1>
nop
lea    0x0(%rbp,%rbp,4),%eax
lea    (%r14,%rax,2),%ebp
add    $0xffffffd0,%ebp
movsbl (%r12),%r14d
add    $0x1,%r12
mov    %r14d,%edi
call   1030 <isdigit@plt>
test   %rax,%rax
jne    12c0 <atof+0x1b0>
imul   %ebx,%ebp
add    %r15d,%ebp
mov    %ebp,%r15d
movss  0xc(%rsp),%xmm0
test   %r15d,%r15d
jg     1207 <atof+0xf7>
jns    117b <atof+0x6b>
mov    %r15d,%eax
neg    %eax
and    $0x3,%eax
je     1340 <atof+0x230>
neg    %eax
xor    %ecx,%ecx
movsd  0xcf3(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nop
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
mulsd  %xmm2,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
add    $0xffffffff,%ecx
cmp    %ecx,%eax
jne    1320 <atof+0x210>
mov    %r15d,%eax
sub    %ecx,%eax
jmp    1343 <atof+0x233>
mov    %r15d,%eax
cmp    $0xfffffffc,%r15d
ja     117b <atof+0x6b>
movsd  0xcb3(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nop
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
mulsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
add    $0x4,%eax
jne    1360 <atof+0x250>
jmp    117b <atof+0x6b>

LLVM IR (-O0):
define float @atof(i8* %0) {
%2 = alloca i8*
%3 = alloca float
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
store i8* %0, i8** %2
store float 0.000000e+00, float* %3
store i32 0, i32* %4
br label %8
8: ; preds = %20, %1
%9 = load i8*, i8** %2
%10 = getelementptr inbounds i8, i8* %9, i32 1
store i8* %10, i8** %2
%11 = load i8, i8* %9
%12 = sext i8 %11 to i32
store i32 %12, i32* %5
%13 = icmp ne i32 %12, 0
br i1 %13, label %14, label %18
14: ; preds = %8
%15 = load i32, i32* %5
%16 = call i64 @isdigit(i32 %15)
%17 = icmp ne i64 %16, 0
br label %18
18: ; preds = %14, %8
%19 = phi i1 [ false, %8 ], [ %17, %14 ]
br i1 %19, label %20, label %28
20: ; preds = %18
%21 = load float, float* %3
%22 = fpext float %21 to double
%23 = load i32, i32* %5
%24 = sub nsw i32 %23, 48
%25 = sitofp i32 %24 to double
%26 = call double @llvm.fmuladd.f64(double %22, double 1.000000e+01, double %25)
%27 = fptrunc double %26 to float
store float %27, float* %3
br label %8
28: ; preds = %18
%29 = load i32, i32* %5
%30 = icmp eq i32 %29, 46
br i1 %30, label %31, label %55
31: ; preds = %28
br label %32
32: ; preds = %44, %31
%33 = load i8*, i8** %2
%34 = getelementptr inbounds i8, i8* %33, i32 1
store i8* %34, i8** %2
%35 = load i8, i8* %33
%36 = sext i8 %35 to i32
store i32 %36, i32* %5
%37 = icmp ne i32 %36, 0
br i1 %37, label %38, label %42
38: ; preds = %32
%39 = load i32, i32* %5
%40 = call i64 @isdigit(i32 %39)
%41 = icmp ne i64 %40, 0
br label %42
42: ; preds = %38, %32
%43 = phi i1 [ false, %32 ], [ %41, %38 ]
br i1 %43, label %44, label %54
44: ; preds = %42
%45 = load float, float* %3
%46 = fpext float %45 to double
%47 = load i32, i32* %5
%48 = sub nsw i32 %47, 48
%49 = sitofp i32 %48 to double
%50 = call double @llvm.fmuladd.f64(double %46, double 1.000000e+01, double %49)
%51 = fptrunc double %50 to float
store float %51, float* %3
%52 = load i32, i32* %4
%53 = sub nsw i32 %52, 1
store i32 %53, i32* %4
br label %32
54: ; preds = %42
br label %55
55: ; preds = %54, %28
%56 = load i32, i32* %5
%57 = icmp eq i32 %56, 101
br i1 %57, label %61, label %58
58: ; preds = %55
%59 = load i32, i32* %5
%60 = icmp eq i32 %59, 69
br i1 %60, label %61, label %103
61: ; preds = %58, %55
store i32 1, i32* %6
store i32 0, i32* %7
%62 = load i8*, i8** %2
%63 = getelementptr inbounds i8, i8* %62, i32 1
store i8* %63, i8** %2
%64 = load i8, i8* %62
%65 = sext i8 %64 to i32
store i32 %65, i32* %5
%66 = load i32, i32* %5
%67 = icmp eq i32 %66, 43
br i1 %67, label %68, label %73
68: ; preds = %61
%69 = load i8*, i8** %2
%70 = getelementptr inbounds i8, i8* %69, i32 1
store i8* %70, i8** %2
%71 = load i8, i8* %69
%72 = sext i8 %71 to i32
store i32 %72, i32* %5
br label %82
73: ; preds = %61
%74 = load i32, i32* %5
%75 = icmp eq i32 %74, 45
br i1 %75, label %76, label %81
76: ; preds = %73
%77 = load i8*, i8** %2
%78 = getelementptr inbounds i8, i8* %77, i32 1
store i8* %78, i8** %2
%79 = load i8, i8* %77
%80 = sext i8 %79 to i32
store i32 %80, i32* %5
store i32 -1, i32* %6
br label %81
81: ; preds = %76, %73
br label %82
82: ; preds = %81, %68
br label %83
83: ; preds = %87, %82
%84 = load i32, i32* %5
%85 = call i64 @isdigit(i32 %84)
%86 = icmp ne i64 %85, 0
br i1 %86, label %87, label %97
87: ; preds = %83
%88 = load i32, i32* %7
%89 = mul nsw i32 %88, 10
%90 = load i32, i32* %5
%91 = sub nsw i32 %90, 48
%92 = add nsw i32 %89, %91
store i32 %92, i32* %7
%93 = load i8*, i8** %2
%94 = getelementptr inbounds i8, i8* %93, i32 1
store i8* %94, i8** %2
%95 = load i8, i8* %93
%96 = sext i8 %95 to i32
store i32 %96, i32* %5
br label %83
97: ; preds = %83
%98 = load i32, i32* %7
%99 = load i32, i32* %6
%100 = mul nsw i32 %98, %99
%101 = load i32, i32* %4
%102 = add nsw i32 %101, %100
store i32 %102, i32* %4
br label %103
103: ; preds = %97, %58
br label %104
104: ; preds = %107, %103
%105 = load i32, i32* %4
%106 = icmp sgt i32 %105, 0
br i1 %106, label %107, label %114
107: ; preds = %104
%108 = load float, float* %3
%109 = fpext float %108 to double
%110 = fmul double %109, 1.000000e+01
%111 = fptrunc double %110 to float
store float %111, float* %3
%112 = load i32, i32* %4
%113 = add nsw i32 %112, -1
store i32 %113, i32* %4
br label %104
114: ; preds = %104
br label %115
115: ; preds = %118, %114
%116 = load i32, i32* %4
%117 = icmp slt i32 %116, 0
br i1 %117, label %118, label %125
118: ; preds = %115
%119 = load float, float* %3
%120 = fpext float %119 to double
%121 = fmul double %120, 1.000000e-01
%122 = fptrunc double %121 to float
store float %122, float* %3
%123 = load i32, i32* %4
%124 = add nsw i32 %123, 1
store i32 %124, i32* %4
br label %115
125: ; preds = %115
%126 = load float, float* %3
ret float %126
}

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