#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 abs(int);
scalar_t__ isdigit(char);
scalar_t__ isspace(char);
char tolower(char);
double atof_(char s[]) {
  double val, power;
  int i, j, sign, e;
  char e_s[1000];
  for (i = 0; isspace(s[i]); i++)
    ;
  sign = (s[i] == '-') ? -1 : 1;
  if (s[i] == '+' || s[i] == '-')
    i++;
  for (val = 0.0; isdigit(s[i]); i++)
    val = 10.0 * val + s[i] - '0';
  if (s[i] == '.')
    i++;
  for (e = 0; isdigit(s[i]); i++) {
    val = 10.0 * val + s[i] - '0';
    e -= 1;
  }
  if (tolower(s[i]) == 'e')
    i++;
  for (j = 0; isdigit(s[i]) || s[i] == '+' || s[i] == '-'; e_s[j++] = s[i++])
    ;
  e_s[j] = '\0';
  if (j > 0)
    e += (int)atof_(e_s);
  for (j = 0, power = 1.0; j < abs(e); j++) {
    if (e > 0) {
      power *= 10.0;
    } else if (e < 0) {
      power /= 10.0;
    } else {
      power = 1.0;
    }
  }
  return sign * val * power;
}


x86 assembly (clang, -O0):
<atof_>:
push   %rbp
mov    %rsp,%rbp
sub    $0x420,%rsp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1050 <isspace@plt>
cmp    $0x0,%rax
je     1194 <atof_+0x44>
jmp    1186 <atof_+0x36>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1166 <atof_+0x16>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
mov    $0x1,%eax
mov    $0xffffffff,%ecx
cmp    $0x2d,%edx
cmove  %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2b,%eax
je     11dd <atof_+0x8d>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
jne    11e6 <atof_+0x96>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     124d <atof_+0xfd>
movsd  -0x10(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cvtsi2sd %eax,%xmm1
movsd  0xde2(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xdda(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x10(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11ee <atof_+0x9e>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2e,%eax
jne    126b <atof_+0x11b>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     12da <atof_+0x18a>
movsd  -0x10(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cvtsi2sd %eax,%xmm1
movsd  0xd5e(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xd56(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x10(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1272 <atof_+0x122>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1070 <tolower@plt>
movsbl %al,%eax
cmp    $0x65,%eax
jne    1300 <atof_+0x1b0>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
mov    %rax,%rcx
mov    $0x1,%al
cmp    $0x0,%rcx
mov    %al,-0x411(%rbp)
jne    1362 <atof_+0x212>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x1,%al
cmp    $0x2b,%ecx
mov    %al,-0x411(%rbp)
je     1362 <atof_+0x212>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
sete   %al
mov    %al,-0x411(%rbp)
mov    -0x411(%rbp),%al
test   $0x1,%al
jne    1375 <atof_+0x225>
jmp    13a8 <atof_+0x258>
jmp    137a <atof_+0x22a>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x1c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x20(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x20(%rbp)
cltq
mov    %cl,-0x410(%rbp,%rax,1)
jmp    1307 <atof_+0x1b7>
movslq -0x20(%rbp),%rax
movb   $0x0,-0x410(%rbp,%rax,1)
cmpl   $0x0,-0x20(%rbp)
jle    13d4 <atof_+0x284>
lea    -0x410(%rbp),%rdi
call   1060 <atof_@plt>
cvttsd2si %xmm0,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
movl   $0x0,-0x20(%rbp)
movsd  0xc1d(%rip),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x418(%rbp)
mov    -0x28(%rbp),%edi
call   1040 <abs@plt>
mov    %eax,%ecx
mov    -0x418(%rbp),%eax
cmp    %ecx,%eax
jge    1474 <atof_+0x324>
cmpl   $0x0,-0x28(%rbp)
jle    142a <atof_+0x2da>
movsd  0xbed(%rip),%xmm0
mulsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x18(%rbp)
jmp    1461 <atof_+0x311>
cmpl   $0x0,-0x28(%rbp)
jge    144f <atof_+0x2ff>
movsd  -0x18(%rbp),%xmm0
movsd  0xbc7(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x18(%rbp)
jmp    145c <atof_+0x30c>
movsd  0xba9(%rip),%xmm0
movsd  %xmm0,-0x18(%rbp)
jmp    1461 <atof_+0x311>
jmp    1466 <atof_+0x316>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    13e8 <atof_+0x298>
cvtsi2sdl -0x24(%rbp),%xmm0
mulsd  -0x10(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
add    $0x420,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<atof_>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x3f8,%rsp
mov    %rdi,%r13
mov    $0xffffffffffffffff,%rbx
nopl   0x0(%rax,%rax,1)
movsbl 0x1(%r13,%rbx,1),%edi
call   1040 <isspace@plt>
add    $0x1,%rbx
test   %rax,%rax
jne    1160 <atof_+0x20>
mov    %ebx,%eax
mov    0x0(%r13,%rax,1),%r14b
lea    -0x2b(%r14),%eax
xor    %r15d,%r15d
test   $0xfd,%al
sete   %r15b
lea    (%r15,%rbx,1),%r12
mov    %r12d,%ebp
movsbl 0x0(%r13,%rbp,1),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     1201 <atof_+0xc1>
mov    %r15d,%r12d
add    %ebx,%r12d
mov    %ebx,%ebp
add    %r13,%rbp
add    %r15,%rbp
xorpd  %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsbl 0x0(%rbp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0xe2d(%rip),%xmm1
addsd  %xmm0,%xmm1
addsd  0xe29(%rip),%xmm1
movapd %xmm1,(%rsp)
movsbl 0x1(%rbp),%edi
add    $0x1,%rbp
call   1030 <isdigit@plt>
movapd (%rsp),%xmm1
add    $0x1,%r12d
test   %rax,%rax
jne    11c0 <atof_+0x80>
jmp    1208 <atof_+0xc8>
add    %r13,%rbp
xorpd  %xmm1,%xmm1
movapd %xmm1,(%rsp)
xor    %r15d,%r15d
cmpb   $0x2e,0x0(%rbp)
sete   %r15b
mov    %r12d,%eax
add    %rax,%r15
lea    (%r15,%r13,1),%rbp
movsbl 0x0(%r13,%r15,1),%edi
call   1030 <isdigit@plt>
xor    %r12d,%r12d
test   %rax,%rax
je     1282 <atof_+0x142>
movapd (%rsp),%xmm1
nopw   0x0(%rax,%rax,1)
movsbl 0x0(%rbp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0xdad(%rip),%xmm1
addsd  %xmm0,%xmm1
addsd  0xda9(%rip),%xmm1
movapd %xmm1,(%rsp)
add    $0xffffffff,%r12d
movsbl 0x1(%rbp),%edi
add    $0x1,%rbp
call   1030 <isdigit@plt>
movapd (%rsp),%xmm1
test   %rax,%rax
jne    1240 <atof_+0x100>
sub    %r12d,%r15d
movsbl 0x0(%rbp),%edi
call   1060 <tolower@plt>
xor    %ecx,%ecx
cmp    $0x65,%al
sete   %cl
add    %r15d,%ecx
movslq %ecx,%rax
add    %rax,%r13
xor    %ebx,%ebx
jmp    12a8 <atof_+0x168>
nop
mov    %cl,0x10(%rsp,%rbx,1)
add    $0x1,%rbx
movsbl 0x0(%r13,%rbx,1),%edi
call   1030 <isdigit@plt>
movzbl 0x0(%r13,%rbx,1),%ecx
test   %rax,%rax
jne    12a0 <atof_+0x160>
cmp    $0x2d,%cl
je     12a0 <atof_+0x160>
cmp    $0x2b,%cl
je     12a0 <atof_+0x160>
mov    %ebx,%eax
movb   $0x0,0x10(%rsp,%rax,1)
test   %ebx,%ebx
je     12e4 <atof_+0x1a4>
lea    0x10(%rsp),%rdi
call   1050 <atof_@plt>
cvttsd2si %xmm0,%eax
add    %eax,%r12d
movapd (%rsp),%xmm0
test   %r12d,%r12d
je     137f <atof_+0x23f>
mov    %r12d,%eax
neg    %eax
cmovs  %r12d,%eax
cmp    $0x1,%eax
jne    1321 <atof_+0x1e1>
movsd  0xd08(%rip),%xmm4
test   $0x1,%al
je     1387 <atof_+0x247>
test   %r12d,%r12d
jle    137d <atof_+0x23d>
mulsd  0xce7(%rip),%xmm4
cmp    $0x2d,%r14b
jne    1395 <atof_+0x255>
jmp    138d <atof_+0x24d>
mov    %eax,%ecx
and    $0x7ffffffe,%ecx
movsd  0xcdf(%rip),%xmm1
movsd  0xcc7(%rip),%xmm2
movapd %xmm1,%xmm4
jmp    134d <atof_+0x20d>
nop
mulsd  %xmm2,%xmm3
movapd %xmm3,%xmm4
add    $0xfffffffe,%ecx
je     1308 <atof_+0x1c8>
test   %r12d,%r12d
jle    1360 <atof_+0x220>
mulsd  %xmm2,%xmm4
movapd %xmm4,%xmm3
jmp    1366 <atof_+0x226>
nopl   0x0(%rax)
movapd %xmm1,%xmm3
js     1377 <atof_+0x237>
test   %r12d,%r12d
jg     1340 <atof_+0x200>
movapd %xmm1,%xmm4
jns    1348 <atof_+0x208>
divsd  %xmm2,%xmm3
jmp    1344 <atof_+0x204>
divsd  %xmm2,%xmm4
jmp    1356 <atof_+0x216>
js     13ab <atof_+0x26b>
movsd  0xc89(%rip),%xmm4
cmp    $0x2d,%r14b
jne    1395 <atof_+0x255>
xorpd  0xc8b(%rip),%xmm0
mulsd  %xmm4,%xmm0
add    $0x3f8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
divsd  0xc4d(%rip),%xmm4
cmp    $0x2d,%r14b
jne    1395 <atof_+0x255>
jmp    138d <atof_+0x24d>

LLVM IR (-O0):
define double @atof_(i8* %0) {
%2 = alloca i8*
%3 = alloca double
%4 = alloca double
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca [1000 x i8]
store i8* %0, i8** %2
store i32 0, i32* %5
br label %10
10: ; preds = %19, %1
%11 = load i8*, i8** %2
%12 = load i32, i32* %5
%13 = sext i32 %12 to i64
%14 = getelementptr inbounds i8, i8* %11, i64 %13
%15 = load i8, i8* %14
%16 = call i64 @isspace(i8 signext %15)
%17 = icmp ne i64 %16, 0
br i1 %17, label %18, label %22
18: ; preds = %10
br label %19
19: ; preds = %18
%20 = load i32, i32* %5
%21 = add nsw i32 %20, 1
store i32 %21, i32* %5
br label %10
22: ; preds = %10
%23 = load i8*, i8** %2
%24 = load i32, i32* %5
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds i8, i8* %23, i64 %25
%27 = load i8, i8* %26
%28 = sext i8 %27 to i32
%29 = icmp eq i32 %28, 45
%30 = zext i1 %29 to i64
%31 = select i1 %29, i32 -1, i32 1
store i32 %31, i32* %7
%32 = load i8*, i8** %2
%33 = load i32, i32* %5
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds i8, i8* %32, i64 %34
%36 = load i8, i8* %35
%37 = sext i8 %36 to i32
%38 = icmp eq i32 %37, 43
br i1 %38, label %47, label %39
39: ; preds = %22
%40 = load i8*, i8** %2
%41 = load i32, i32* %5
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds i8, i8* %40, i64 %42
%44 = load i8, i8* %43
%45 = sext i8 %44 to i32
%46 = icmp eq i32 %45, 45
br i1 %46, label %47, label %50
47: ; preds = %39, %22
%48 = load i32, i32* %5
%49 = add nsw i32 %48, 1
store i32 %49, i32* %5
br label %50
50: ; preds = %47, %39
store double 0.000000e+00, double* %3
br label %51
51: ; preds = %70, %50
%52 = load i8*, i8** %2
%53 = load i32, i32* %5
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds i8, i8* %52, i64 %54
%56 = load i8, i8* %55
%57 = call i64 @isdigit(i8 signext %56)
%58 = icmp ne i64 %57, 0
br i1 %58, label %59, label %73
59: ; preds = %51
%60 = load double, double* %3
%61 = load i8*, i8** %2
%62 = load i32, i32* %5
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i8, i8* %61, i64 %63
%65 = load i8, i8* %64
%66 = sext i8 %65 to i32
%67 = sitofp i32 %66 to double
%68 = call double @llvm.fmuladd.f64(double 1.000000e+01, double %60, double %67)
%69 = fsub double %68, 4.800000e+01
store double %69, double* %3
br label %70
70: ; preds = %59
%71 = load i32, i32* %5
%72 = add nsw i32 %71, 1
store i32 %72, i32* %5
br label %51
73: ; preds = %51
%74 = load i8*, i8** %2
%75 = load i32, i32* %5
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds i8, i8* %74, i64 %76
%78 = load i8, i8* %77
%79 = sext i8 %78 to i32
%80 = icmp eq i32 %79, 46
br i1 %80, label %81, label %84
81: ; preds = %73
%82 = load i32, i32* %5
%83 = add nsw i32 %82, 1
store i32 %83, i32* %5
br label %84
84: ; preds = %81, %73
store i32 0, i32* %8
br label %85
85: ; preds = %106, %84
%86 = load i8*, i8** %2
%87 = load i32, i32* %5
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds i8, i8* %86, i64 %88
%90 = load i8, i8* %89
%91 = call i64 @isdigit(i8 signext %90)
%92 = icmp ne i64 %91, 0
br i1 %92, label %93, label %109
93: ; preds = %85
%94 = load double, double* %3
%95 = load i8*, i8** %2
%96 = load i32, i32* %5
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds i8, i8* %95, i64 %97
%99 = load i8, i8* %98
%100 = sext i8 %99 to i32
%101 = sitofp i32 %100 to double
%102 = call double @llvm.fmuladd.f64(double 1.000000e+01, double %94, double %101)
%103 = fsub double %102, 4.800000e+01
store double %103, double* %3
%104 = load i32, i32* %8
%105 = sub nsw i32 %104, 1
store i32 %105, i32* %8
br label %106
106: ; preds = %93
%107 = load i32, i32* %5
%108 = add nsw i32 %107, 1
store i32 %108, i32* %5
br label %85
109: ; preds = %85
%110 = load i8*, i8** %2
%111 = load i32, i32* %5
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds i8, i8* %110, i64 %112
%114 = load i8, i8* %113
%115 = call signext i8 @tolower(i8 signext %114)
%116 = sext i8 %115 to i32
%117 = icmp eq i32 %116, 101
br i1 %117, label %118, label %121
118: ; preds = %109
%119 = load i32, i32* %5
%120 = add nsw i32 %119, 1
store i32 %120, i32* %5
br label %121
121: ; preds = %118, %109
store i32 0, i32* %6
br label %122
122: ; preds = %149, %121
%123 = load i8*, i8** %2
%124 = load i32, i32* %5
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds i8, i8* %123, i64 %125
%127 = load i8, i8* %126
%128 = call i64 @isdigit(i8 signext %127)
%129 = icmp ne i64 %128, 0
br i1 %129, label %146, label %130
130: ; preds = %122
%131 = load i8*, i8** %2
%132 = load i32, i32* %5
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds i8, i8* %131, i64 %133
%135 = load i8, i8* %134
%136 = sext i8 %135 to i32
%137 = icmp eq i32 %136, 43
br i1 %137, label %146, label %138
138: ; preds = %130
%139 = load i8*, i8** %2
%140 = load i32, i32* %5
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds i8, i8* %139, i64 %141
%143 = load i8, i8* %142
%144 = sext i8 %143 to i32
%145 = icmp eq i32 %144, 45
br label %146
146: ; preds = %138, %130, %122
%147 = phi i1 [ true, %130 ], [ true, %122 ], [ %145, %138 ]
br i1 %147, label %148, label %160
148: ; preds = %146
br label %149
149: ; preds = %148
%150 = load i8*, i8** %2
%151 = load i32, i32* %5
%152 = add nsw i32 %151, 1
store i32 %152, i32* %5
%153 = sext i32 %151 to i64
%154 = getelementptr inbounds i8, i8* %150, i64 %153
%155 = load i8, i8* %154
%156 = load i32, i32* %6
%157 = add nsw i32 %156, 1
store i32 %157, i32* %6
%158 = sext i32 %156 to i64
%159 = getelementptr inbounds [1000 x i8], [1000 x i8]* %9, i64 0, i64 %158
store i8 %155, i8* %159
br label %122
160: ; preds = %146
%161 = load i32, i32* %6
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds [1000 x i8], [1000 x i8]* %9, i64 0, i64 %162
store i8 0, i8* %163
%164 = load i32, i32* %6
%165 = icmp sgt i32 %164, 0
br i1 %165, label %166, label %172
166: ; preds = %160
%167 = getelementptr inbounds [1000 x i8], [1000 x i8]* %9, i64 0, i64 0
%168 = call double @atof_(i8* %167)
%169 = fptosi double %168 to i32
%170 = load i32, i32* %8
%171 = add nsw i32 %170, %169
store i32 %171, i32* %8
br label %172
172: ; preds = %166, %160
store i32 0, i32* %6
store double 1.000000e+00, double* %4
br label %173
173: ; preds = %193, %172
%174 = load i32, i32* %6
%175 = load i32, i32* %8
%176 = call i32 @abs(i32 %175)
%177 = icmp slt i32 %174, %176
br i1 %177, label %178, label %196
178: ; preds = %173
%179 = load i32, i32* %8
%180 = icmp sgt i32 %179, 0
br i1 %180, label %181, label %184
181: ; preds = %178
%182 = load double, double* %4
%183 = fmul double %182, 1.000000e+01
store double %183, double* %4
br label %192
184: ; preds = %178
%185 = load i32, i32* %8
%186 = icmp slt i32 %185, 0
br i1 %186, label %187, label %190
187: ; preds = %184
%188 = load double, double* %4
%189 = fdiv double %188, 1.000000e+01
store double %189, double* %4
br label %191
190: ; preds = %184
store double 1.000000e+00, double* %4
br label %191
191: ; preds = %190, %187
br label %192
192: ; preds = %191, %181
br label %193
193: ; preds = %192
%194 = load i32, i32* %6
%195 = add nsw i32 %194, 1
store i32 %195, i32* %6
br label %173
196: ; preds = %173
%197 = load i32, i32* %7
%198 = sitofp i32 %197 to double
%199 = load double, double* %3
%200 = fmul double %198, %199
%201 = load double, double* %4
%202 = fmul double %200, %201
ret double %202
}

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