#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(char);
char tolower(char);
double custom_atof(char s[]) {
  double val, power;
  int i, sign;
  int isScience = 0;
  int scienceSign = 0;
  int scienceVal = 0;
  for (i = 0; s[i] == ' '; ++i)
    ;
  sign = (s[i] == '-') ? -1 : 1;
  if (s[i] == '-' || s[i] == '+') {
    ++i;
  }
  for (val = 0.0; isdigit(s[i]); ++i) {
    val = val * 10 + (s[i] - '0');
  }
  if (s[i] == '.') {
    ++i;
  }
  for (power = 1.0; isdigit(s[i]); ++i) {
    val = val * 10 + (s[i] - '0');
    power *= 10;
  }
  if (tolower(s[i]) == 'e') {
    isScience = 1;
    ++i;
  }
  scienceSign = (s[i] == '-') ? -1 : 1;
  if (s[i] == '-' || s[i] == '+') {
    ++i;
  }
  for (scienceVal = 1; isdigit(s[i]); ++i) {
    scienceVal = 10 * scienceVal + (s[i] - '0');
  }
  if (isScience) {
    if (sign == 1) {
      for (int j = 0; j < scienceVal; ++j) {
        power /= 10;
      }
    } else {
      for (int j = 0; j < scienceVal; ++j) {
        power *= 10;
      }
    }
  }
  return sign * val / power;
}


x86 assembly (clang, -O0):
<custom_atof>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jne    1170 <custom_atof+0x50>
jmp    1162 <custom_atof+0x42>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1148 <custom_atof+0x28>
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,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
je     11b9 <custom_atof+0x99>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2b,%eax
jne    11c2 <custom_atof+0xa2>
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     1220 <custom_atof+0x100>
movsd  -0x10(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
cvtsi2sd %eax,%xmm1
movsd  0xe03(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x10(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11ca <custom_atof+0xaa>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2e,%eax
jne    123e <custom_atof+0x11e>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
movsd  0xdba(%rip),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     12b3 <custom_atof+0x193>
movsd  -0x10(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
cvtsi2sd %eax,%xmm1
movsd  0xd82(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x10(%rbp)
movsd  0xd6d(%rip),%xmm0
mulsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    124b <custom_atof+0x12b>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <tolower@plt>
movsbl %al,%eax
cmp    $0x65,%eax
jne    12e0 <custom_atof+0x1c0>
movl   $0x1,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
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,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
je     1329 <custom_atof+0x209>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2b,%eax
jne    1332 <custom_atof+0x212>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     137a <custom_atof+0x25a>
imul   $0xa,-0x2c(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
sub    $0x30,%ecx
add    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1339 <custom_atof+0x219>
cmpl   $0x0,-0x24(%rbp)
je     1407 <custom_atof+0x2e7>
cmpl   $0x1,-0x20(%rbp)
jne    13ca <custom_atof+0x2aa>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    13c5 <custom_atof+0x2a5>
movsd  -0x18(%rbp),%xmm0
movsd  0xc5a(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1395 <custom_atof+0x275>
jmp    1402 <custom_atof+0x2e2>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    13fd <custom_atof+0x2dd>
movsd  0xc23(%rip),%xmm0
mulsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13d1 <custom_atof+0x2b1>
jmp    1402 <custom_atof+0x2e2>
jmp    1407 <custom_atof+0x2e7>
cvtsi2sdl -0x20(%rbp),%xmm0
mulsd  -0x10(%rbp),%xmm0
divsd  -0x18(%rbp),%xmm0
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<custom_atof>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rdi,%r15
mov    $0xffffffff,%ebx
mov    %rdi,%rax
nopl   0x0(%rax)
movzbl (%rax),%r12d
add    $0x1,%ebx
add    $0x1,%rax
cmp    $0x20,%r12b
je     1140 <custom_atof+0x20>
lea    -0x2b(%r12),%eax
xor    %r13d,%r13d
test   $0xfd,%al
sete   %r13b
lea    (%rbx,%r13,1),%r14d
movsbl (%r15,%r14,1),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     11ce <custom_atof+0xae>
mov    %r13d,%eax
add    %ebx,%r13d
add    %r15,%rax
mov    %ebx,%ebp
add    %rax,%rbp
xorpd  %xmm1,%xmm1
mov    %r13d,%r14d
nopw   0x0(%rax,%rax,1)
movsbl 0x0(%rbp),%eax
add    $0xffffffd0,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0xe5a(%rip),%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,0x10(%rsp)
movsbl 0x1(%rbp),%edi
add    $0x1,%rbp
call   1030 <isdigit@plt>
movapd 0x10(%rsp),%xmm1
add    $0x1,%r14d
test   %rax,%rax
jne    1190 <custom_atof+0x70>
jmp    11d6 <custom_atof+0xb6>
lea    (%r15,%r14,1),%rbp
xorpd  %xmm1,%xmm1
movapd %xmm1,0x10(%rsp)
xor    %ebx,%ebx
cmpb   $0x2e,0x0(%rbp)
sete   %bl
mov    %r14d,%eax
add    %rax,%rbx
movsbl (%r15,%rbx,1),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     1267 <custom_atof+0x147>
movsd  0xe06(%rip),%xmm1
movapd 0x10(%rsp),%xmm3
nopl   0x0(%rax,%rax,1)
movsbl (%r15,%rbx,1),%eax
add    $0xffffffd0,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0xdd9(%rip),%xmm2
mulsd  %xmm2,%xmm3
addsd  %xmm0,%xmm3
movapd %xmm3,0x10(%rsp)
mulsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%rsp)
movsbl 0x1(%r15,%rbx,1),%edi
add    $0x1,%rbx
call   1030 <isdigit@plt>
movapd 0x10(%rsp),%xmm3
movsd  0x8(%rsp),%xmm1
test   %rax,%rax
jne    1210 <custom_atof+0xf0>
mov    %rbx,%rax
add    %r15,%rax
jmp    127b <custom_atof+0x15b>
mov    %rbx,%rax
add    %r15,%rax
movsd  0xd93(%rip),%xmm0
movsd  %xmm0,0x8(%rsp)
movsbl (%rax),%edi
call   1040 <tolower@plt>
mov    %eax,%r14d
xor    %eax,%eax
cmp    $0x65,%r14b
sete   %al
mov    %ebx,%ecx
add    %rcx,%rax
mov    (%r15,%rax,1),%cl
cmp    $0x2d,%cl
je     12a2 <custom_atof+0x182>
cmp    $0x2b,%cl
jne    12a5 <custom_atof+0x185>
add    $0x1,%eax
movslq %eax,%rbx
movsbl (%r15,%rbx,1),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     137b <custom_atof+0x25b>
lea    (%rbx,%r15,1),%rbp
add    $0x1,%rbp
mov    $0x1,%ebx
nopl   0x0(%rax,%rax,1)
lea    (%rbx,%rbx,4),%eax
movsbl -0x1(%rbp),%ecx
lea    (%rcx,%rax,2),%ebx
add    $0xffffffd0,%ebx
movsbl 0x0(%rbp),%edi
call   1030 <isdigit@plt>
add    $0x1,%rbp
test   %rax,%rax
jne    12d0 <custom_atof+0x1b0>
cmp    $0x65,%r14b
jne    138a <custom_atof+0x26a>
cmp    $0x2d,%r12b
movsd  0x8(%rsp),%xmm1
jne    13bf <custom_atof+0x29f>
test   %ebx,%ebx
jle    1390 <custom_atof+0x270>
lea    -0x1(%rbx),%ecx
mov    %ebx,%eax
and    $0x7,%eax
cmp    $0x7,%ecx
jb     1355 <custom_atof+0x235>
and    $0xfffffff8,%ebx
movsd  0xcd7(%rip),%xmm0
nopl   0x0(%rax)
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
add    $0xfffffff8,%ebx
jne    1330 <custom_atof+0x210>
test   %eax,%eax
je     1390 <custom_atof+0x270>
movsd  0xc9f(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mulsd  %xmm0,%xmm1
add    $0xffffffff,%eax
jne    1370 <custom_atof+0x250>
jmp    1390 <custom_atof+0x270>
mov    $0x1,%ebx
cmp    $0x65,%r14b
je     12f9 <custom_atof+0x1d9>
movsd  0x8(%rsp),%xmm1
cmp    $0x2d,%r12b
je     139e <custom_atof+0x27e>
movapd 0x10(%rsp),%xmm0
jmp    13ac <custom_atof+0x28c>
movapd 0x10(%rsp),%xmm0
xorpd  0xc64(%rip),%xmm0
divsd  %xmm1,%xmm0
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
test   %ebx,%ebx
jle    1390 <custom_atof+0x270>
lea    -0x1(%rbx),%ecx
mov    %ebx,%eax
and    $0x3,%eax
cmp    $0x3,%ecx
jb     13f5 <custom_atof+0x2d5>
and    $0xfffffffc,%ebx
movsd  0xc25(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
divsd  %xmm0,%xmm1
divsd  %xmm0,%xmm1
divsd  %xmm0,%xmm1
divsd  %xmm0,%xmm1
add    $0xfffffffc,%ebx
jne    13e0 <custom_atof+0x2c0>
test   %eax,%eax
je     1390 <custom_atof+0x270>
movsd  0xbff(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
divsd  %xmm0,%xmm1
add    $0xffffffff,%eax
jne    1410 <custom_atof+0x2f0>
jmp    1390 <custom_atof+0x270>

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

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