#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 */
double pow(int, int);
double my_str2double(const char *str, const char **endp) {
  double ret = 1.0f;
  int n = 0, m = 0, e = 0;
  unsigned long long o = 0;
  while (*str && *str < 33)
    str++;
  if (*str == '-') {
    ret = -1.0f;
    str++;
  }
  while (*str >= '0' && *str <= '9')
    n = n * 10 + *str++ - '0';
  if (*str != '.') {
    ret *= n;
  } else {
    str++;
    while (*str >= '0' && *str <= '9') {
      if (m > -16) {
        o = o * 10 + *str - '0';
        m--;
      }
      str++;
    }
    ret *= (n + pow(10, m) * o);
  }
  if (*str == 'e' || *str == 'E') {
    int esign = 1;
    str++;
    if (*str == '+')
      str++;
    else if (*str == '-') {
      str++;
      esign = -1;
    }
    while (*str >= '0' && *str <= '9')
      e = e * 10 + *str++ - '0';
    ret *= pow(10, e * esign);
  }
  if (endp != NULL)
    *endp = str;
  return ret;
}


x86 assembly (clang, -O0):
<my_str2double>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movsd  0xed8(%rip),%xmm0
movsd  %xmm0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x35(%rbp)
je     116f <my_str2double+0x5f>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x21,%eax
setl   %al
mov    %al,-0x35(%rbp)
mov    -0x35(%rbp),%al
test   $0x1,%al
jne    117f <my_str2double+0x6f>
jmp    1190 <my_str2double+0x80>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    114a <my_str2double+0x3a>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
jne    11b9 <my_str2double+0xa9>
movsd  0xe60(%rip),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    11be <my_str2double+0xae>
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x30,%ecx
mov    %al,-0x36(%rbp)
jl     11e3 <my_str2double+0xd3>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x39,%eax
setle  %al
mov    %al,-0x36(%rbp)
mov    -0x36(%rbp),%al
test   $0x1,%al
jne    11f3 <my_str2double+0xe3>
jmp    1216 <my_str2double+0x106>
imul   $0xa,-0x1c(%rbp),%eax
mov    -0x8(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
movsbl (%rcx),%ecx
add    %ecx,%eax
sub    $0x30,%eax
mov    %eax,-0x1c(%rbp)
jmp    11be <my_str2double+0xae>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
je     123a <my_str2double+0x12a>
cvtsi2sdl -0x1c(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x18(%rbp)
jmp    130c <my_str2double+0x1fc>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x30,%ecx
mov    %al,-0x37(%rbp)
jl     126b <my_str2double+0x15b>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x39,%eax
setle  %al
mov    %al,-0x37(%rbp)
mov    -0x37(%rbp),%al
test   $0x1,%al
jne    127b <my_str2double+0x16b>
jmp    12b7 <my_str2double+0x1a7>
cmpl   $0xfffffff0,-0x20(%rbp)
jle    12a6 <my_str2double+0x196>
imul   $0xa,-0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
movsbq (%rcx),%rcx
add    %rcx,%rax
sub    $0x30,%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    1246 <my_str2double+0x136>
cvtsi2sdl -0x1c(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%esi
mov    $0xa,%edi
call   1030 <pow@plt>
movsd  -0x40(%rbp),%xmm1
movaps 0xd36(%rip),%xmm3
movq   -0x30(%rbp),%xmm2
punpckldq %xmm3,%xmm2
movapd 0xd35(%rip),%xmm3
subpd  %xmm3,%xmm2
movaps %xmm2,%xmm3
unpckhpd %xmm2,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x65,%eax
je     132c <my_str2double+0x21c>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x45,%eax
jne    1400 <my_str2double+0x2f0>
movl   $0x1,-0x34(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2b,%eax
jne    1360 <my_str2double+0x250>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    1388 <my_str2double+0x278>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
jne    1383 <my_str2double+0x273>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
movl   $0xffffffff,-0x34(%rbp)
jmp    1388 <my_str2double+0x278>
jmp    138d <my_str2double+0x27d>
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x30,%ecx
mov    %al,-0x41(%rbp)
jl     13b2 <my_str2double+0x2a2>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x39,%eax
setle  %al
mov    %al,-0x41(%rbp)
mov    -0x41(%rbp),%al
test   $0x1,%al
jne    13c2 <my_str2double+0x2b2>
jmp    13e5 <my_str2double+0x2d5>
imul   $0xa,-0x24(%rbp),%eax
mov    -0x8(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
movsbl (%rcx),%ecx
add    %ecx,%eax
sub    $0x30,%eax
mov    %eax,-0x24(%rbp)
jmp    138d <my_str2double+0x27d>
mov    -0x24(%rbp),%esi
imul   -0x34(%rbp),%esi
mov    $0xa,%edi
call   1030 <pow@plt>
mulsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x18(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     1416 <my_str2double+0x306>
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
movsd  -0x18(%rbp),%xmm0
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<my_str2double>:
push   %rbp
push   %r14
push   %rbx
sub    $0x20,%rsp
mov    %rsi,%r14
mov    %rdi,%rbx
add    $0xffffffffffffffff,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl 0x1(%rbx),%ebp
add    $0x1,%rbx
test   %bpl,%bpl
je     1143 <my_str2double+0x33>
cmp    $0x21,%bpl
jl     1130 <my_str2double+0x20>
xor    %ecx,%ecx
cmp    $0x2d,%bpl
sete   %cl
mov    (%rbx,%rcx,1),%al
lea    -0x30(%rax),%edx
cmp    $0x9,%dl
ja     118e <my_str2double+0x7e>
xor    %edx,%edx
nopl   0x0(%rax)
movzbl %al,%eax
lea    (%rdx,%rdx,4),%edx
lea    (%rax,%rdx,2),%edx
add    $0xffffffd0,%edx
movzbl 0x1(%rbx,%rcx,1),%eax
lea    -0x30(%rax),%esi
add    $0x1,%rbx
cmp    $0xa,%sil
jb     1160 <my_str2double+0x50>
cvtsi2sd %edx,%xmm0
add    %rcx,%rbx
cmp    $0x2e,%al
je     119d <my_str2double+0x8d>
jmp    1242 <my_str2double+0x132>
add    %rcx,%rbx
xorpd  %xmm0,%xmm0
cmp    $0x2e,%al
jne    1242 <my_str2double+0x132>
mov    0x1(%rbx),%al
add    $0x1,%rbx
lea    -0x30(%rax),%ecx
cmp    $0x9,%cl
movapd %xmm0,(%rsp)
ja     1217 <my_str2double+0x107>
xor    %ecx,%ecx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rcx,%rdx
xor    %edi,%edi
cmp    $0xfffffff1,%esi
setge  %dil
lea    (%rcx,%rcx,4),%rcx
movzbl %al,%eax
lea    -0x30(%rax,%rcx,2),%rcx
cmovl  %rdx,%rcx
sub    %edi,%esi
movzbl 0x1(%rbx),%eax
add    $0x1,%rbx
lea    -0x30(%rax),%edx
cmp    $0xa,%dl
jb     11c0 <my_str2double+0xb0>
movq   %rcx,%xmm0
punpckldq 0xe05(%rip),%xmm0
subpd  0xe0d(%rip),%xmm0
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,0x10(%rsp)
jmp    1223 <my_str2double+0x113>
xorpd  %xmm0,%xmm0
movapd %xmm0,0x10(%rsp)
xor    %esi,%esi
mov    $0xa,%edi
call   1030 <pow@plt>
mulsd  0x10(%rsp),%xmm0
movapd (%rsp),%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
mov    (%rbx),%al
cmp    $0x2d,%bpl
jne    1250 <my_str2double+0x140>
xorpd  0xdd0(%rip),%xmm0
or     $0x20,%al
cmp    $0x65,%al
jne    12c6 <my_str2double+0x1b6>
mov    0x1(%rbx),%cl
cmp    $0x2d,%cl
je     126e <my_str2double+0x15e>
mov    $0x1,%eax
cmp    $0x2b,%cl
jne    1279 <my_str2double+0x169>
add    $0x2,%rbx
jmp    127d <my_str2double+0x16d>
add    $0x2,%rbx
mov    $0xffffffff,%eax
jmp    127d <my_str2double+0x16d>
add    $0x1,%rbx
mov    (%rbx),%cl
lea    -0x30(%rcx),%edx
xor    %esi,%esi
cmp    $0x9,%dl
movapd %xmm0,(%rsp)
ja     12ac <my_str2double+0x19c>
xor    %esi,%esi
movzbl %cl,%ecx
lea    (%rsi,%rsi,4),%edx
lea    (%rcx,%rdx,2),%esi
add    $0xffffffd0,%esi
movzbl 0x1(%rbx),%ecx
add    $0x1,%rbx
lea    -0x30(%rcx),%edx
cmp    $0xa,%dl
jb     1290 <my_str2double+0x180>
imul   %eax,%esi
mov    $0xa,%edi
call   1030 <pow@plt>
movapd (%rsp),%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
test   %r14,%r14
je     12ce <my_str2double+0x1be>
mov    %rbx,(%r14)
add    $0x20,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

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

LLVM IR (-O2):
define double @my_str2double(i8* %0, i8** writeonly %1) {
br label %3
3: ; preds = %3, %2
%4 = phi i8* [ %0, %2 ], [ %9, %3 ]
%5 = load i8, i8* %4
%6 = icmp ne i8 %5, 0
%7 = icmp slt i8 %5, 33
%8 = and i1 %6, %7
%9 = getelementptr inbounds i8, i8* %4, i64 1
br i1 %8, label %3, label %10
10: ; preds = %3
%11 = icmp eq i8 %5, 45
%12 = zext i1 %11 to i64
%13 = getelementptr i8, i8* %4, i64 %12
%14 = load i8, i8* %13
%15 = add i8 %14, -48
%16 = icmp ult i8 %15, 10
br i1 %16, label %17, label %31
17: ; preds = %10, %17
%18 = phi i8 [ %26, %17 ], [ %14, %10 ]
%19 = phi i32 [ %25, %17 ], [ 0, %10 ]
%20 = phi i8* [ %23, %17 ], [ %13, %10 ]
%21 = zext i8 %18 to i32
%22 = mul nsw i32 %19, 10
%23 = getelementptr inbounds i8, i8* %20, i64 1
%24 = add i32 %22, -48
%25 = add i32 %24, %21
%26 = load i8, i8* %23
%27 = add i8 %26, -48
%28 = icmp ult i8 %27, 10
br i1 %28, label %17, label %29
29: ; preds = %17
%30 = sitofp i32 %25 to double
br label %31
31: ; preds = %29, %10
%32 = phi i8* [ %13, %10 ], [ %23, %29 ]
%33 = phi double [ 0.000000e+00, %10 ], [ %30, %29 ]
%34 = phi i8 [ %14, %10 ], [ %26, %29 ]
%35 = icmp eq i8 %34, 46
br i1 %35, label %36, label %67
36: ; preds = %31
%37 = getelementptr inbounds i8, i8* %32, i64 1
%38 = load i8, i8* %37
%39 = add i8 %38, -48
%40 = icmp ult i8 %39, 10
br i1 %40, label %41, label %60
41: ; preds = %36, %41
%42 = phi i8 [ %55, %41 ], [ %38, %36 ]
%43 = phi i8* [ %54, %41 ], [ %37, %36 ]
%44 = phi i64 [ %53, %41 ], [ 0, %36 ]
%45 = phi i32 [ %52, %41 ], [ 0, %36 ]
%46 = icmp sgt i32 %45, -16
%47 = mul i64 %44, 10
%48 = zext i8 %42 to i64
%49 = add i64 %47, -48
%50 = add i64 %49, %48
%51 = sext i1 %46 to i32
%52 = add nsw i32 %45, %51
%53 = select i1 %46, i64 %50, i64 %44
%54 = getelementptr inbounds i8, i8* %43, i64 1
%55 = load i8, i8* %54
%56 = add i8 %55, -48
%57 = icmp ult i8 %56, 10
br i1 %57, label %41, label %58
58: ; preds = %41
%59 = uitofp i64 %53 to double
br label %60
60: ; preds = %58, %36
%61 = phi i32 [ 0, %36 ], [ %52, %58 ]
%62 = phi double [ 0.000000e+00, %36 ], [ %59, %58 ]
%63 = phi i8* [ %37, %36 ], [ %54, %58 ]
%64 = tail call double @pow(i32 10, i32 %61)
%65 = tail call double @llvm.fmuladd.f64(double %64, double %62, double %33)
%66 = load i8, i8* %63
br label %67
67: ; preds = %31, %60
%68 = phi i8 [ %66, %60 ], [ %34, %31 ]
%69 = phi i8* [ %63, %60 ], [ %32, %31 ]
%70 = phi double [ %65, %60 ], [ %33, %31 ]
%71 = fneg double %70
%72 = select i1 %11, double %71, double %70
switch i8 %68, label %104 [
i8 101, label %73
i8 69, label %73
]
73: ; preds = %67, %67
%74 = getelementptr inbounds i8, i8* %69, i64 1
%75 = load i8, i8* %74
switch i8 %75, label %80 [
i8 43, label %76
i8 45, label %78
]
76: ; preds = %73
%77 = getelementptr inbounds i8, i8* %69, i64 2
br label %80
78: ; preds = %73
%79 = getelementptr inbounds i8, i8* %69, i64 2
br label %80
80: ; preds = %73, %78, %76
%81 = phi i8* [ %77, %76 ], [ %79, %78 ], [ %74, %73 ]
%82 = phi i32 [ 1, %76 ], [ -1, %78 ], [ 1, %73 ]
%83 = load i8, i8* %81
%84 = add i8 %83, -48
%85 = icmp ult i8 %84, 10
br i1 %85, label %86, label %98
86: ; preds = %80, %86
%87 = phi i8 [ %95, %86 ], [ %83, %80 ]
%88 = phi i32 [ %94, %86 ], [ 0, %80 ]
%89 = phi i8* [ %92, %86 ], [ %81, %80 ]
%90 = zext i8 %87 to i32
%91 = mul nsw i32 %88, 10
%92 = getelementptr inbounds i8, i8* %89, i64 1
%93 = add i32 %91, -48
%94 = add i32 %93, %90
%95 = load i8, i8* %92
%96 = add i8 %95, -48
%97 = icmp ult i8 %96, 10
br i1 %97, label %86, label %98
98: ; preds = %86, %80
%99 = phi i8* [ %81, %80 ], [ %92, %86 ]
%100 = phi i32 [ 0, %80 ], [ %94, %86 ]
%101 = mul nsw i32 %100, %82
%102 = tail call double @pow(i32 10, i32 %101)
%103 = fmul double %72, %102
br label %104
104: ; preds = %67, %98
%105 = phi i8* [ %99, %98 ], [ %69, %67 ]
%106 = phi double [ %103, %98 ], [ %72, %67 ]
%107 = icmp eq i8** %1, null
br i1 %107, label %109, label %108
108: ; preds = %104
store i8* %105, i8** %1
br label %109
109: ; preds = %108, %104
ret double %106
}