#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 */
long char2int(char const);
double str2dx(const char *s, char **endptr) {
  const char *sc;
  const char *sd;
  char sign;
  long x, y;
  double y1;
  for (sc = s; ((*sc) == ' '); ++sc)
    ;
  sign = (*sc == '-' || *sc == '+') ? *sc++ : '+';
  for (; *sc == '0'; ++sc)
    ;
  y = 0;
  for (; (((*sc) >= 48 && (*sc) <= 57 || (*sc) >= 97 && (*sc) <= 102 ||
           (*sc) >= 65 && (*sc) <= 70) ||
          (*sc) >= 97 && (*sc) <= 102 || (*sc) >= 65 && (*sc) <= 70);
       ++sc) {
    x = char2int(*sc);
    y = y * 10 + x;
  }
  if (*sc == '.') {
    y1 = 0.0;
    for (sd = sc + 1;
         ((*sd) >= 48 && (*sd) <= 57 || (*sd) >= 97 && (*sd) <= 102 ||
          (*sd) >= 65 && (*sd) <= 70);
         ++sd)
      ;
    *endptr = (char *)(sd);
    for (--sd; sd != sc; --sd) {
      x = char2int(*sd);
      y1 = (x + y1) * 0.1;
    }
    y1 += y;
  } else {
    *endptr = (char *)sc;
    y1 = y;
  }
  y1 *= ((sign == '-') ? -1 : 1);
  return y1;
}


x86 assembly (clang, -O0):
<str2dx>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
jne    114e <str2dx+0x3e>
jmp    113d <str2dx+0x2d>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1128 <str2dx+0x18>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
je     116e <str2dx+0x5e>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2b,%eax
jne    1188 <str2dx+0x78>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
movsbl (%rax),%eax
mov    %eax,-0x44(%rbp)
jmp    1195 <str2dx+0x85>
mov    $0x2b,%eax
mov    %eax,-0x44(%rbp)
jmp    1195 <str2dx+0x85>
mov    -0x44(%rbp),%eax
mov    %al,-0x21(%rbp)
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
jne    11c1 <str2dx+0xb1>
jmp    11b0 <str2dx+0xa0>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    119b <str2dx+0x8b>
movq   $0x0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
jl     11ee <str2dx+0xde>
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x39,%ecx
mov    %al,-0x45(%rbp)
jle    1288 <str2dx+0x178>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x61,%eax
jl     1213 <str2dx+0x103>
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x66,%ecx
mov    %al,-0x45(%rbp)
jle    1288 <str2dx+0x178>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x41,%eax
jl     1238 <str2dx+0x128>
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x46,%ecx
mov    %al,-0x45(%rbp)
jle    1288 <str2dx+0x178>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x61,%eax
jl     125d <str2dx+0x14d>
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x66,%ecx
mov    %al,-0x45(%rbp)
jle    1288 <str2dx+0x178>
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x41,%ecx
mov    %al,-0x46(%rbp)
jl     1282 <str2dx+0x172>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x46,%eax
setle  %al
mov    %al,-0x46(%rbp)
mov    -0x46(%rbp),%al
mov    %al,-0x45(%rbp)
mov    -0x45(%rbp),%al
test   $0x1,%al
jne    1298 <str2dx+0x188>
jmp    12c6 <str2dx+0x1b6>
mov    -0x18(%rbp),%rax
movsbl (%rax),%edi
call   1030 <char2int@plt>
mov    %rax,-0x30(%rbp)
imul   $0xa,-0x38(%rbp),%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    11c9 <str2dx+0xb9>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
jne    13fc <str2dx+0x2ec>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
jl     130f <str2dx+0x1ff>
mov    -0x20(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x39,%ecx
mov    %al,-0x47(%rbp)
jle    135f <str2dx+0x24f>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x61,%eax
jl     1334 <str2dx+0x224>
mov    -0x20(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x66,%ecx
mov    %al,-0x47(%rbp)
jle    135f <str2dx+0x24f>
mov    -0x20(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x41,%ecx
mov    %al,-0x48(%rbp)
jl     1359 <str2dx+0x249>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x46,%eax
setle  %al
mov    %al,-0x48(%rbp)
mov    -0x48(%rbp),%al
mov    %al,-0x47(%rbp)
mov    -0x47(%rbp),%al
test   $0x1,%al
jne    136f <str2dx+0x25f>
jmp    1385 <str2dx+0x275>
jmp    1374 <str2dx+0x264>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    12ea <str2dx+0x1da>
mov    -0x20(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x18(%rbp),%rax
je     13e7 <str2dx+0x2d7>
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1030 <char2int@plt>
mov    %rax,-0x30(%rbp)
cvtsi2sdq -0x30(%rbp),%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  0xc33(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
jmp    139c <str2dx+0x28c>
cvtsi2sdq -0x38(%rbp),%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    1412 <str2dx+0x302>
mov    -0x18(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
cvtsi2sdq -0x38(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsbl -0x21(%rbp),%edx
mov    $0x1,%eax
mov    $0xffffffff,%ecx
cmp    $0x2d,%edx
cmove  %ecx,%eax
cvtsi2sd %eax,%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<str2dx>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x10,%rsp
mov    %rsi,%r14
mov    %rdi,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rbx),%r15d
cmp    $0x20,%r15d
jne    1140 <str2dx+0x30>
add    $0x1,%rbx
jmp    1130 <str2dx+0x20>
cmp    $0x2b,%r15b
je     114c <str2dx+0x3c>
cmp    $0x2d,%r15b
jne    1152 <str2dx+0x42>
add    $0x1,%rbx
jmp    1158 <str2dx+0x48>
mov    $0x2b,%r15d
add    $0xffffffffffffffff,%rbx
nopl   0x0(%rax)
movzbl 0x1(%rbx),%eax
add    $0x1,%rbx
cmp    $0x30,%al
je     1160 <str2dx+0x50>
xor    %r12d,%r12d
movabs $0x1f8000001f80000,%rbp
jmp    1198 <str2dx+0x88>
nopl   0x0(%rax,%rax,1)
movsbl %al,%edi
call   1030 <char2int@plt>
lea    (%r12,%r12,4),%rcx
lea    (%rax,%rcx,2),%r12
movzbl 0x1(%rbx),%eax
add    $0x1,%rbx
lea    -0x30(%rax),%ecx
cmp    $0xa,%cl
jb     1180 <str2dx+0x70>
lea    -0x2e(%rax),%ecx
cmp    $0x38,%cl
ja     1243 <str2dx+0x133>
movzbl %cl,%ecx
bt     %rcx,%rbp
jb     1180 <str2dx+0x70>
test   %rcx,%rcx
jne    1243 <str2dx+0x133>
xor    %eax,%eax
movabs $0x3f0000003f,%rcx
xor    %ebp,%ebp
jmp    11d8 <str2dx+0xc8>
xchg   %ax,%ax
add    $0xffffffffffffffff,%rbp
add    $0x1,%rax
movzbl 0x1(%rbx,%rax,1),%edx
lea    -0x30(%rdx),%esi
cmp    $0x9,%sil
jbe    11d0 <str2dx+0xc0>
add    $0xbf,%dl
cmp    $0x25,%dl
ja     11f7 <str2dx+0xe7>
movzbl %dl,%edx
bt     %rdx,%rcx
jb     11d0 <str2dx+0xc0>
lea    (%rbx,%rax,1),%rcx
add    $0x1,%rcx
mov    %rcx,(%r14)
test   %rbp,%rbp
je     124d <str2dx+0x13d>
add    %rax,%rbx
xorps  %xmm1,%xmm1
nopl   (%rax)
movsd  %xmm1,0x8(%rsp)
movsbl (%rbx),%edi
call   1030 <char2int@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  0x8(%rsp),%xmm0
mulsd  0xdcc(%rip),%xmm0
add    $0xffffffffffffffff,%rbx
movapd %xmm0,%xmm1
inc    %rbp
jne    1210 <str2dx+0x100>
jmp    1251 <str2dx+0x141>
mov    %rbx,(%r14)
cvtsi2sd %r12,%xmm1
jmp    125d <str2dx+0x14d>
xorpd  %xmm0,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %r12,%xmm1
addsd  %xmm0,%xmm1
xor    %eax,%eax
cmp    $0x2d,%r15d
setne  %al
lea    -0x1(%rax,%rax,1),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  %xmm1,%xmm0
add    $0x10,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define double @str2dx(i8* %0, i8** nocapture writeonly %1) {
br label %3
3: ; preds = %6, %2
%4 = phi i8* [ %0, %2 ], [ %7, %6 ]
%5 = load i8, i8* %4
switch i8 %5, label %11 [
i8 32, label %6
i8 45, label %8
i8 43, label %8
]
6: ; preds = %3
%7 = getelementptr inbounds i8, i8* %4, i64 1
br label %3
8: ; preds = %3, %3
%9 = getelementptr inbounds i8, i8* %4, i64 1
%10 = zext i8 %5 to i32
br label %11
11: ; preds = %3, %8
%12 = phi i8* [ %9, %8 ], [ %4, %3 ]
%13 = phi i32 [ %10, %8 ], [ 43, %3 ]
br label %14
14: ; preds = %14, %11
%15 = phi i8* [ %12, %11 ], [ %18, %14 ]
%16 = load i8, i8* %15
%17 = icmp eq i8 %16, 48
%18 = getelementptr inbounds i8, i8* %15, i64 1
br i1 %17, label %14, label %19
19: ; preds = %14, %27
%20 = phi i8 [ %32, %27 ], [ %16, %14 ]
%21 = phi i8* [ %31, %27 ], [ %15, %14 ]
%22 = phi i64 [ %30, %27 ], [ 0, %14 ]
%23 = freeze i8 %20
%24 = add i8 %23, -48
%25 = icmp ult i8 %24, 10
br i1 %25, label %27, label %26
26: ; preds = %19
switch i8 %23, label %58 [
i8 102, label %27
i8 101, label %27
i8 100, label %27
i8 99, label %27
i8 98, label %27
i8 97, label %27
i8 70, label %27
i8 69, label %27
i8 68, label %27
i8 67, label %27
i8 66, label %27
i8 65, label %27
i8 46, label %33
]
27: ; preds = %26, %26, %26, %26, %26, %26, %26, %26, %26, %26, %26, %26, %19
%28 = tail call i64 @char2int(i8 signext %23)
%29 = mul nsw i64 %22, 10
%30 = add nsw i64 %28, %29
%31 = getelementptr inbounds i8, i8* %21, i64 1
%32 = load i8, i8* %31
br label %19
33: ; preds = %26, %40
%34 = phi i8* [ %35, %40 ], [ %21, %26 ]
%35 = getelementptr inbounds i8, i8* %34, i64 1
%36 = load i8, i8* %35
%37 = freeze i8 %36
%38 = add i8 %37, -48
%39 = icmp ult i8 %38, 10
br i1 %39, label %40, label %41
40: ; preds = %33, %41, %41, %41, %41, %41, %41, %41, %41, %41, %41, %41, %41
br label %33
41: ; preds = %33
switch i8 %37, label %42 [
i8 102, label %40
i8 101, label %40
i8 100, label %40
i8 99, label %40
i8 98, label %40
i8 97, label %40
i8 70, label %40
i8 69, label %40
i8 68, label %40
i8 67, label %40
i8 66, label %40
i8 65, label %40
]
42: ; preds = %41
store i8* %35, i8** %1
%43 = icmp eq i8* %34, %21
br i1 %43, label %54, label %44
44: ; preds = %42, %44
%45 = phi i8* [ %52, %44 ], [ %34, %42 ]
%46 = phi double [ %51, %44 ], [ 0.000000e+00, %42 ]
%47 = load i8, i8* %45
%48 = tail call i64 @char2int(i8 signext %47)
%49 = sitofp i64 %48 to double
%50 = fadd double %46, %49
%51 = fmul double %50, 1.000000e-01
%52 = getelementptr inbounds i8, i8* %45, i64 -1
%53 = icmp eq i8* %52, %21
br i1 %53, label %54, label %44
54: ; preds = %44, %42
%55 = phi double [ 0.000000e+00, %42 ], [ %51, %44 ]
%56 = sitofp i64 %22 to double
%57 = fadd double %55, %56
br label %60
58: ; preds = %26
store i8* %21, i8** %1
%59 = sitofp i64 %22 to double
br label %60
60: ; preds = %58, %54
%61 = phi double [ %57, %54 ], [ %59, %58 ]
%62 = icmp eq i32 %13, 45
%63 = select i1 %62, i32 -1, i32 1
%64 = sitofp i32 %63 to double
%65 = fmul double %61, %64
ret double %65
}