#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 multiply_convert_str_to_float(double *value_out, const char *str,
                                  const size_t len) {
  int sign = 0;
  int part = 0;
  double value_integer = 0.0;
  double value_decimal = 0.0;
  double value_decimal_idx = 0.0;
  int base = 10;
  int digit = 0;
  const char *str_p = str, *str_endp = str + len;
  char ch;
  if ((len >= 1) && (*str_p == '-')) {
    sign = 1;
    str_p++;
  }
  while (str_p != str_endp) {
    ch = *str_p;
    if (ch == '.') {
      part = 1;
      switch (base) {
      case 2:
        value_decimal_idx = 1.0 / 2;
        break;
      case 8:
        value_decimal_idx = 1.0 / 8;
        break;
      case 10:
        value_decimal_idx = 1.0 / 10;
        break;
      case 16:
        value_decimal_idx = 1.0 / 16;
        break;
      }
    } else {
      switch (base) {
      case 2:
      case 8:
        if (ch < '0' && ch >= base) {
          return -1;
        } else {
          if (part == 0) {
            value_integer = (value_integer * base) + (ch - (int)('0'));
          } else {
            value_decimal =
                value_decimal + value_decimal_idx * (ch - (int)('0'));
            value_decimal_idx /= base;
          }
        }
        break;
      case 10:
        if (ch < '0' && ch >= base) {
          return -1;
        } else {
          if (part == 0) {
            value_integer = (value_integer * 10) + (ch - (int)('0'));
          } else {
            value_decimal =
                value_decimal + value_decimal_idx * (ch - (int)('0'));
            value_decimal_idx /= base;
          }
        }
        break;
      case 16:
        if (ch >= '0' && ch <= '9') {
          digit = ch - (int)('0');
        } else if (ch >= 'a' && ch <= 'f') {
          digit = ch - (int)('a') + 10;
        } else if (ch >= 'A' && ch <= 'F') {
          digit = ch - (int)('A') + 10;
        } else {
          return -1;
        }
        if (part == 0) {
          value_integer = value_integer * base + digit;
        } else {
          value_decimal = value_decimal + value_decimal_idx * (ch - (int)('0'));
          value_decimal_idx /= base;
        }
        break;
      default:
        break;
      }
    }
    str_p++;
  }
  if (sign != 0)
    *value_out = -(value_integer + value_decimal);
  else
    *value_out = value_integer + value_decimal;
  return 0;
}


x86 assembly (clang, -O0):
<multiply_convert_str_to_float>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0xa,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x18(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x58(%rbp)
cmpq   $0x1,-0x20(%rbp)
jb     1186 <multiply_convert_str_to_float+0x86>
mov    -0x50(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
jne    1186 <multiply_convert_str_to_float+0x86>
movl   $0x1,-0x24(%rbp)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    118b <multiply_convert_str_to_float+0x8b>
mov    -0x50(%rbp),%rax
cmp    -0x58(%rbp),%rax
je     1496 <multiply_convert_str_to_float+0x396>
mov    -0x50(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x59(%rbp)
movsbl -0x59(%rbp),%eax
cmp    $0x2e,%eax
jne    1227 <multiply_convert_str_to_float+0x127>
movl   $0x1,-0x28(%rbp)
mov    -0x44(%rbp),%eax
add    $0xfffffffe,%eax
mov    %eax,%ecx
mov    %rcx,-0x68(%rbp)
sub    $0xe,%eax
ja     1222 <multiply_convert_str_to_float+0x122>
mov    -0x68(%rbp),%rax
lea    0xe8e(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movsd  0xe39(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    1222 <multiply_convert_str_to_float+0x122>
movsd  0xe1f(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    1222 <multiply_convert_str_to_float+0x122>
movsd  0xe05(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    1222 <multiply_convert_str_to_float+0x122>
movsd  0xdeb(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    1485 <multiply_convert_str_to_float+0x385>
mov    -0x44(%rbp),%eax
add    $0xfffffffe,%eax
mov    %eax,%ecx
mov    %rcx,-0x70(%rbp)
sub    $0xe,%eax
ja     147b <multiply_convert_str_to_float+0x37b>
mov    -0x70(%rbp),%rax
lea    0xde1(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movsbl -0x59(%rbp),%eax
cmp    $0x30,%eax
jge    1276 <multiply_convert_str_to_float+0x176>
movsbl -0x59(%rbp),%eax
cmp    -0x44(%rbp),%eax
jl     1276 <multiply_convert_str_to_float+0x176>
movl   $0xffffffff,-0x4(%rbp)
jmp    14e7 <multiply_convert_str_to_float+0x3e7>
cmpl   $0x0,-0x28(%rbp)
jne    12a7 <multiply_convert_str_to_float+0x1a7>
movsd  -0x30(%rbp),%xmm0
cvtsi2sdl -0x44(%rbp),%xmm2
movsbl -0x59(%rbp),%eax
sub    $0x30,%eax
cvtsi2sd %eax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
jmp    12dc <multiply_convert_str_to_float+0x1dc>
movsd  -0x38(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
movsbl -0x59(%rbp),%eax
sub    $0x30,%eax
cvtsi2sd %eax,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
cvtsi2sdl -0x44(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    12e1 <multiply_convert_str_to_float+0x1e1>
jmp    1480 <multiply_convert_str_to_float+0x380>
movsbl -0x59(%rbp),%eax
cmp    $0x30,%eax
jge    130c <multiply_convert_str_to_float+0x20c>
movsbl -0x59(%rbp),%eax
cmp    -0x44(%rbp),%eax
jl     130c <multiply_convert_str_to_float+0x20c>
movl   $0xffffffff,-0x4(%rbp)
jmp    14e7 <multiply_convert_str_to_float+0x3e7>
cmpl   $0x0,-0x28(%rbp)
jne    1340 <multiply_convert_str_to_float+0x240>
movsd  -0x30(%rbp),%xmm0
movsbl -0x59(%rbp),%eax
sub    $0x30,%eax
cvtsi2sd %eax,%xmm1
movsd  0xcd2(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
jmp    1375 <multiply_convert_str_to_float+0x275>
movsd  -0x38(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
movsbl -0x59(%rbp),%eax
sub    $0x30,%eax
cvtsi2sd %eax,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
cvtsi2sdl -0x44(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    137a <multiply_convert_str_to_float+0x27a>
jmp    1480 <multiply_convert_str_to_float+0x380>
movsbl -0x59(%rbp),%eax
cmp    $0x30,%eax
jl     13a8 <multiply_convert_str_to_float+0x2a8>
movsbl -0x59(%rbp),%eax
cmp    $0x39,%eax
jg     13a8 <multiply_convert_str_to_float+0x2a8>
movsbl -0x59(%rbp),%eax
sub    $0x30,%eax
mov    %eax,-0x48(%rbp)
jmp    1416 <multiply_convert_str_to_float+0x316>
movsbl -0x59(%rbp),%eax
cmp    $0x61,%eax
jl     13d4 <multiply_convert_str_to_float+0x2d4>
movsbl -0x59(%rbp),%eax
cmp    $0x66,%eax
jg     13d4 <multiply_convert_str_to_float+0x2d4>
movsbl -0x59(%rbp),%eax
sub    $0x61,%eax
add    $0xa,%eax
mov    %eax,-0x48(%rbp)
jmp    1411 <multiply_convert_str_to_float+0x311>
movsbl -0x59(%rbp),%eax
cmp    $0x41,%eax
jl     1400 <multiply_convert_str_to_float+0x300>
movsbl -0x59(%rbp),%eax
cmp    $0x46,%eax
jg     1400 <multiply_convert_str_to_float+0x300>
movsbl -0x59(%rbp),%eax
sub    $0x41,%eax
add    $0xa,%eax
mov    %eax,-0x48(%rbp)
jmp    140c <multiply_convert_str_to_float+0x30c>
movl   $0xffffffff,-0x4(%rbp)
jmp    14e7 <multiply_convert_str_to_float+0x3e7>
jmp    1411 <multiply_convert_str_to_float+0x311>
jmp    1416 <multiply_convert_str_to_float+0x316>
cmpl   $0x0,-0x28(%rbp)
jne    1441 <multiply_convert_str_to_float+0x341>
movsd  -0x30(%rbp),%xmm0
cvtsi2sdl -0x44(%rbp),%xmm2
cvtsi2sdl -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
jmp    1476 <multiply_convert_str_to_float+0x376>
movsd  -0x38(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
movsbl -0x59(%rbp),%eax
sub    $0x30,%eax
cvtsi2sd %eax,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
cvtsi2sdl -0x44(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    1480 <multiply_convert_str_to_float+0x380>
jmp    1480 <multiply_convert_str_to_float+0x380>
jmp    1485 <multiply_convert_str_to_float+0x385>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    118b <multiply_convert_str_to_float+0x8b>
cmpl   $0x0,-0x24(%rbp)
je     14ce <multiply_convert_str_to_float+0x3ce>
movsd  -0x30(%rbp),%xmm0
addsd  -0x38(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    14e0 <multiply_convert_str_to_float+0x3e0>
movsd  -0x30(%rbp),%xmm0
addsd  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<multiply_convert_str_to_float>:
lea    (%rsi,%rdx,1),%r9
test   %rdx,%rdx
je     11a9 <multiply_convert_str_to_float+0xa9>
xor    %eax,%eax
cmpb   $0x2d,(%rsi)
setne  %r8b
sete   %al
add    %rax,%rsi
cmp    %r9,%rsi
je     11b5 <multiply_convert_str_to_float+0xb5>
xorpd  %xmm3,%xmm3
xor    %edx,%edx
movsd  0xecd(%rip),%xmm1
movsd  0xecd(%rip),%xmm2
xorpd  %xmm4,%xmm4
xorpd  %xmm0,%xmm0
jmp    1160 <multiply_convert_str_to_float+0x60>
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm1,%xmm3
add    $0x1,%rsi
mov    %r10d,%edx
cmp    %r9,%rsi
je     119e <multiply_convert_str_to_float+0x9e>
movsbl (%rsi),%ecx
mov    $0x1,%r10d
cmp    $0x2e,%ecx
je     1150 <multiply_convert_str_to_float+0x50>
lea    -0xa(%rcx),%eax
cmp    $0x26,%al
jb     11cd <multiply_convert_str_to_float+0xcd>
add    $0xffffffd0,%ecx
xorps  %xmm5,%xmm5
cvtsi2sd %ecx,%xmm5
test   %edx,%edx
je     1191 <multiply_convert_str_to_float+0x91>
mulsd  %xmm3,%xmm5
addsd  %xmm5,%xmm4
divsd  %xmm2,%xmm3
jmp    1154 <multiply_convert_str_to_float+0x54>
mulsd  %xmm2,%xmm0
addsd  %xmm5,%xmm0
xor    %r10d,%r10d
jmp    1154 <multiply_convert_str_to_float+0x54>
addsd  %xmm4,%xmm0
test   %r8b,%r8b
je     11be <multiply_convert_str_to_float+0xbe>
jmp    11c6 <multiply_convert_str_to_float+0xc6>
mov    $0x1,%r8b
cmp    %r9,%rsi
jne    1125 <multiply_convert_str_to_float+0x25>
xorpd  %xmm0,%xmm0
test   %r8b,%r8b
jne    11c6 <multiply_convert_str_to_float+0xc6>
xorpd  0xe4a(%rip),%xmm0
movsd  %xmm0,(%rdi)
xor    %eax,%eax
ret
mov    $0xffffffff,%eax
ret

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

LLVM IR (-O2):
define i32 @multiply_convert_str_to_float(double* nocapture writeonly %0, i8* %1, i64 %2) {
%4 = getelementptr inbounds i8, i8* %1, i64 %2
%5 = icmp eq i64 %2, 0
br i1 %5, label %12, label %6
6: ; preds = %3
%7 = load i8, i8* %1
%8 = icmp eq i8 %7, 45
%9 = zext i1 %8 to i64
%10 = getelementptr i8, i8* %1, i64 %9
%11 = xor i1 %8, true
br label %12
12: ; preds = %6, %3
%13 = phi i8* [ %1, %3 ], [ %10, %6 ]
%14 = phi i1 [ true, %3 ], [ %11, %6 ]
%15 = icmp eq i8* %13, %4
br i1 %15, label %46, label %16
16: ; preds = %12, %37
%17 = phi i8* [ %42, %37 ], [ %13, %12 ]
%18 = phi i32 [ %41, %37 ], [ 0, %12 ]
%19 = phi double [ %40, %37 ], [ 0.000000e+00, %12 ]
%20 = phi double [ %39, %37 ], [ 0.000000e+00, %12 ]
%21 = phi double [ %38, %37 ], [ 0.000000e+00, %12 ]
%22 = load i8, i8* %17
%23 = sext i8 %22 to i32
%24 = icmp eq i8 %22, 46
br i1 %24, label %37, label %25
25: ; preds = %16
%26 = add i8 %22, -10
%27 = icmp ult i8 %26, 38
br i1 %27, label %50, label %28
28: ; preds = %25
%29 = icmp eq i32 %18, 0
%30 = add nsw i32 %23, -48
%31 = sitofp i32 %30 to double
br i1 %29, label %32, label %34
32: ; preds = %28
%33 = tail call double @llvm.fmuladd.f64(double %21, double 1.000000e+01, double %31)
br label %37
34: ; preds = %28
%35 = tail call double @llvm.fmuladd.f64(double %19, double %31, double %20)
%36 = fdiv double %19, 1.000000e+01
br label %37
37: ; preds = %16, %32, %34
%38 = phi double [ %33, %32 ], [ %21, %34 ], [ %21, %16 ]
%39 = phi double [ %20, %32 ], [ %35, %34 ], [ %20, %16 ]
%40 = phi double [ %19, %32 ], [ %36, %34 ], [ 1.000000e-01, %16 ]
%41 = phi i32 [ 0, %32 ], [ 1, %34 ], [ 1, %16 ]
%42 = getelementptr inbounds i8, i8* %17, i64 1
%43 = icmp eq i8* %42, %4
br i1 %43, label %44, label %16
44: ; preds = %37
%45 = fadd double %38, %39
br label %46
46: ; preds = %44, %12
%47 = phi double [ %45, %44 ], [ 0.000000e+00, %12 ]
%48 = fneg double %47
%49 = select i1 %14, double %47, double %48
store double %49, double* %0
br label %50
50: ; preds = %25, %46
%51 = phi i32 [ 0, %46 ], [ -1, %25 ]
ret i32 %51
}