double fcalc(const char **str, int *err, int _) {
  switch (_) {
  case 0:;
    const char *str1 = *str;
    int err1 = 0;
    double ret = fcalc(&str1, &err1, 1);
    while (*str1 != 0) {
      if (*str1 != ' ' && *str1 != '\n')
        err1 = 1;
      str1++;
    }
    if (err != 0)
      *err = err1;
    return ret;
  case -1:
    while (**str == ' ')
      (*str)++;
    switch (**str) {
    case '-':
      (*str)++;
      return -fcalc(str, err, -1);
    case '(':
      (*str)++;
      double ret = fcalc(str, err, 1);
      if (**str != ')') {
        *err = -1;
        return 0.0;
      }
      (*str)++;
      return ret;
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
    case '.':
      _ = 0;
      double dig = 0.0, bak = 1.0;
      for (;;) {
        if (**str == '.') {
          _ = 1;
          (*str)++;
        }
        if (!(**str >= '0' && **str <= '9'))
          break;
        if (_ == 1)
          bak /= 10.0;
        dig = dig * 10.0 + (**str - '0');
        (*str)++;
      }
      return dig * bak;
    case 'p':
    case 'P':
      (*str)++;
      if (**str != 'i' && **str != 'I') {
        *err = -1;
        return 0.0;
      }
      (*str)++;
      return 3.14159265358979;
    default:
      *err = -1;
      return 0.0;
    }
  default:;
    double lhs = fcalc(str, err, -1);
    if (*err)
      return 0.0;
    for (;;) {
      while (**str == ' ')
        (*str)++;
      if (1 >= _ && **str == '+') {
        (*str)++;
        double rhs = fcalc(str, err, (1 + 1));
        if (*err)
          return 0.0;
        lhs = lhs + rhs;
      } else if (1 >= _ && **str == '-') {
        (*str)++;
        double rhs = fcalc(str, err, (1 + 1));
        if (*err)
          return 0.0;
        lhs = lhs - rhs;
      } else if (2 >= _ && **str == '*') {
        (*str)++;
        double rhs = fcalc(str, err, (2 + 1));
        if (*err)
          return 0.0;
        lhs = lhs * rhs;
      } else if (2 >= _ && **str == '/') {
        (*str)++;
        double rhs = fcalc(str, err, (2 + 1));
        if (*err)
          return 0.0;
        lhs = lhs / rhs;
      } else
        return lhs;
    }
  }
}


x86 assembly (clang, -O0):
<fcalc>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x7c(%rbp)
sub    $0xffffffff,%eax
je     11de <fcalc+0xce>
jmp    113a <fcalc+0x2a>
mov    -0x7c(%rbp),%eax
test   %eax,%eax
jne    144f <fcalc+0x33f>
jmp    114a <fcalc+0x3a>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
lea    -0x28(%rbp),%rdi
lea    -0x2c(%rbp),%rsi
mov    $0x1,%edx
call   1030 <fcalc@plt>
movsd  %xmm0,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     11bb <fcalc+0xab>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
je     11aa <fcalc+0x9a>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
je     11aa <fcalc+0x9a>
movl   $0x1,-0x2c(%rbp)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1173 <fcalc+0x63>
cmpq   $0x0,-0x18(%rbp)
je     11cf <fcalc+0xbf>
mov    -0x2c(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    16a3 <fcalc+0x593>
jmp    11e3 <fcalc+0xd3>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
jne    1209 <fcalc+0xf9>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
jmp    11e3 <fcalc+0xd3>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
add    $0xffffffd8,%eax
mov    %eax,%ecx
mov    %rcx,-0x88(%rbp)
sub    $0x48,%eax
ja     1438 <fcalc+0x328>
mov    -0x88(%rbp),%rax
lea    0xde2(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    $0xffffffff,%edx
call   1030 <fcalc@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    16a3 <fcalc+0x593>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    $0x1,%edx
call   1030 <fcalc@plt>
movsd  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x29,%eax
je     12cf <fcalc+0x1bf>
mov    -0x18(%rbp),%rax
movl   $0xffffffff,(%rax)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    16a3 <fcalc+0x593>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    16a3 <fcalc+0x593>
movl   $0x0,-0x1c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xd05(%rip),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
jne    1330 <fcalc+0x220>
movl   $0x1,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
jl     1356 <fcalc+0x246>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x39,%eax
jle    135b <fcalc+0x24b>
jmp    13b9 <fcalc+0x2a9>
cmpl   $0x1,-0x1c(%rbp)
jne    137b <fcalc+0x26b>
movsd  -0x50(%rbp),%xmm0
movsd  0xc9e(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
sub    $0x30,%eax
cvtsi2sd %eax,%xmm1
movsd  0xc77(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
jmp    1308 <fcalc+0x1f8>
movsd  -0x48(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    16a3 <fcalc+0x593>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x69,%eax
je     1418 <fcalc+0x308>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x49,%eax
je     1418 <fcalc+0x308>
mov    -0x18(%rbp),%rax
movl   $0xffffffff,(%rax)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    16a3 <fcalc+0x593>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
movsd  0xbd2(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    16a3 <fcalc+0x593>
mov    -0x18(%rbp),%rax
movl   $0xffffffff,(%rax)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    16a3 <fcalc+0x593>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    $0xffffffff,%edx
call   1030 <fcalc@plt>
movsd  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
cmpl   $0x0,(%rax)
je     1480 <fcalc+0x370>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    16a3 <fcalc+0x593>
jmp    1485 <fcalc+0x375>
jmp    148a <fcalc+0x37a>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
jne    14b0 <fcalc+0x3a0>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
jmp    148a <fcalc+0x37a>
mov    $0x1,%eax
cmp    -0x1c(%rbp),%eax
jl     1524 <fcalc+0x414>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x2b,%eax
jne    1524 <fcalc+0x414>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    $0x2,%edx
call   1030 <fcalc@plt>
movsd  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
cmpl   $0x0,(%rax)
je     1510 <fcalc+0x400>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    16a3 <fcalc+0x593>
movsd  -0x58(%rbp),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    169e <fcalc+0x58e>
mov    $0x1,%eax
cmp    -0x1c(%rbp),%eax
jl     1598 <fcalc+0x488>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
jne    1598 <fcalc+0x488>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    $0x2,%edx
call   1030 <fcalc@plt>
movsd  %xmm0,-0x68(%rbp)
mov    -0x18(%rbp),%rax
cmpl   $0x0,(%rax)
je     1584 <fcalc+0x474>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    16a3 <fcalc+0x593>
movsd  -0x58(%rbp),%xmm0
subsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    1699 <fcalc+0x589>
mov    $0x2,%eax
cmp    -0x1c(%rbp),%eax
jl     160c <fcalc+0x4fc>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x2a,%eax
jne    160c <fcalc+0x4fc>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    $0x3,%edx
call   1030 <fcalc@plt>
movsd  %xmm0,-0x70(%rbp)
mov    -0x18(%rbp),%rax
cmpl   $0x0,(%rax)
je     15f8 <fcalc+0x4e8>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    16a3 <fcalc+0x593>
movsd  -0x58(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    1694 <fcalc+0x584>
mov    $0x2,%eax
cmp    -0x1c(%rbp),%eax
jl     1680 <fcalc+0x570>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x2f,%eax
jne    1680 <fcalc+0x570>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    $0x3,%edx
call   1030 <fcalc@plt>
movsd  %xmm0,-0x78(%rbp)
mov    -0x18(%rbp),%rax
cmpl   $0x0,(%rax)
je     166c <fcalc+0x55c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    16a3 <fcalc+0x593>
movsd  -0x58(%rbp),%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    168f <fcalc+0x57f>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    16a3 <fcalc+0x593>
jmp    1694 <fcalc+0x584>
jmp    1699 <fcalc+0x589>
jmp    169e <fcalc+0x58e>
jmp    1485 <fcalc+0x375>
movsd  -0x8(%rbp),%xmm0
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fcalc>:
push   %rbp
push   %r14
push   %rbx
sub    $0x20,%rsp
mov    %rsi,%r14
mov    %rdi,%rbx
test   %edx,%edx
je     11e3 <fcalc+0xd3>
mov    %edx,%ebp
cmp    $0xffffffff,%edx
jne    1249 <fcalc+0x139>
mov    (%rbx),%rax
mov    (%rax),%cl
cmp    $0x20,%cl
jne    1153 <fcalc+0x43>
add    $0x1,%rax
nop
mov    %rax,(%rbx)
movzbl (%rax),%ecx
add    $0x1,%rax
cmp    $0x20,%cl
je     1140 <fcalc+0x30>
add    $0xffffffffffffffff,%rax
movsbl %cl,%edx
add    $0xffffffd8,%edx
cmp    $0x48,%edx
ja     1423 <fcalc+0x313>
lea    0xec7(%rip),%rsi
movslq (%rsi,%rdx,4),%rdx
add    %rsi,%rdx
jmp    *%rdx
xor    %edx,%edx
xorpd  %xmm0,%xmm0
movsd  0xe88(%rip),%xmm3
movsd  0xe88(%rip),%xmm1
jmp    11b3 <fcalc+0xa3>
nopw   0x0(%rax,%rax,1)
movzbl %cl,%ecx
add    $0xffffffd0,%ecx
xorps  %xmm2,%xmm2
cvtsi2sd %ecx,%xmm2
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
lea    0x1(%rax),%rsi
mov    %rsi,(%rbx)
movzbl 0x1(%rax),%ecx
mov    %rsi,%rax
cmp    $0x2e,%cl
jne    11cb <fcalc+0xbb>
lea    0x1(%rax),%rsi
mov    %rsi,(%rbx)
movzbl 0x1(%rax),%ecx
mov    $0x1,%edx
mov    %rsi,%rax
lea    -0x30(%rcx),%esi
cmp    $0x9,%sil
ja     13bb <fcalc+0x2ab>
cmp    $0x1,%edx
jne    1190 <fcalc+0x80>
divsd  %xmm1,%xmm3
jmp    1190 <fcalc+0x80>
mov    (%rbx),%rax
mov    %rax,0x18(%rsp)
movl   $0x0,0x14(%rsp)
lea    0x18(%rsp),%rdi
lea    0x14(%rsp),%rsi
mov    $0x1,%edx
call   1030 <fcalc@plt>
movapd %xmm0,%xmm3
mov    0x18(%rsp),%rax
jmp    1225 <fcalc+0x115>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rax,0x18(%rsp)
add    $0x1,%rax
movzbl -0x1(%rax),%ecx
cmp    $0xa,%cl
je     1220 <fcalc+0x110>
cmp    $0x20,%cl
je     1220 <fcalc+0x110>
test   %cl,%cl
je     13ad <fcalc+0x29d>
movl   $0x1,0x14(%rsp)
jmp    1220 <fcalc+0x110>
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0xffffffff,%edx
call   1030 <fcalc@plt>
xorpd  %xmm3,%xmm3
cmpl   $0x0,(%r14)
jne    13bf <fcalc+0x2af>
jmp    12a3 <fcalc+0x193>
nopl   0x0(%rax)
add    $0x1,%rax
mov    %rax,(%rbx)
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x3,%edx
call   1030 <fcalc@plt>
cmpl   $0x0,(%r14)
movsd  0x8(%rsp),%xmm1
divsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
xorpd  %xmm3,%xmm3
jne    13bf <fcalc+0x2af>
mov    (%rbx),%rax
mov    (%rax),%cl
cmp    $0x20,%cl
jne    12d3 <fcalc+0x1c3>
add    $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rax,(%rbx)
movzbl (%rax),%ecx
add    $0x1,%rax
cmp    $0x20,%cl
je     12c0 <fcalc+0x1b0>
add    $0xffffffffffffffff,%rax
cmp    $0x1,%ebp
movsd  %xmm0,0x8(%rsp)
jg     1320 <fcalc+0x210>
cmp    $0x2b,%cl
jne    1320 <fcalc+0x210>
add    $0x1,%rax
mov    %rax,(%rbx)
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x2,%edx
call   1030 <fcalc@plt>
xorpd  %xmm3,%xmm3
cmpl   $0x0,(%r14)
movsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x8(%rsp),%xmm0
je     12a3 <fcalc+0x193>
jmp    13bf <fcalc+0x2af>
nop
cmp    $0x1,%ebp
jg     1370 <fcalc+0x260>
cmp    $0x2a,%cl
je     1383 <fcalc+0x273>
cmp    $0x2f,%cl
je     1270 <fcalc+0x160>
cmp    $0x2d,%cl
jne    13ef <fcalc+0x2df>
add    $0x1,%rax
mov    %rax,(%rbx)
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x2,%edx
call   1030 <fcalc@plt>
cmpl   $0x0,(%r14)
movsd  0x8(%rsp),%xmm1
subsd  %xmm0,%xmm1
jmp    1295 <fcalc+0x185>
cs nopw 0x0(%rax,%rax,1)
cmp    $0x2,%ebp
jne    13ef <fcalc+0x2df>
cmp    $0x2f,%cl
je     1270 <fcalc+0x160>
cmp    $0x2a,%cl
jne    13ef <fcalc+0x2df>
add    $0x1,%rax
mov    %rax,(%rbx)
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x3,%edx
call   1030 <fcalc@plt>
cmpl   $0x0,(%r14)
movsd  0x8(%rsp),%xmm1
mulsd  %xmm0,%xmm1
jmp    1295 <fcalc+0x185>
test   %r14,%r14
je     13bf <fcalc+0x2af>
mov    0x14(%rsp),%eax
mov    %eax,(%r14)
jmp    13bf <fcalc+0x2af>
mulsd  %xmm0,%xmm3
movapd %xmm3,%xmm0
add    $0x20,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret
lea    0x1(%rax),%rcx
mov    %rcx,(%rbx)
mov    0x1(%rax),%cl
or     $0x20,%cl
cmp    $0x69,%cl
jne    1423 <fcalc+0x313>
add    $0x2,%rax
mov    %rax,(%rbx)
movsd  0xc13(%rip),%xmm3
jmp    13bf <fcalc+0x2af>
movsd  0x8(%rsp),%xmm3
jmp    13bf <fcalc+0x2af>
add    $0x1,%rax
mov    %rax,(%rbx)
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x1,%edx
call   1030 <fcalc@plt>
mov    (%rbx),%rax
cmpb   $0x29,(%rax)
jne    1423 <fcalc+0x313>
movapd %xmm0,%xmm3
add    $0x1,%rax
mov    %rax,(%rbx)
jmp    13bf <fcalc+0x2af>
movl   $0xffffffff,(%r14)
xorpd  %xmm3,%xmm3
jmp    13bf <fcalc+0x2af>
add    $0x1,%rax
mov    %rax,(%rbx)
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0xffffffff,%edx
call   1030 <fcalc@plt>
movapd %xmm0,%xmm3
xorpd  0xbcd(%rip),%xmm3
jmp    13bf <fcalc+0x2af>

LLVM IR (-O0):
define double @fcalc(i8** %0, i32* %1, i32 %2) {
%4 = alloca double
%5 = alloca i8**
%6 = alloca i32*
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i32
%10 = alloca double
%11 = alloca double
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
store i8** %0, i8*** %5
store i32* %1, i32** %6
store i32 %2, i32* %7
%19 = load i32, i32* %7
switch i32 %19, label %163 [
i32 0, label %20
i32 -1, label %51
]
20: ; preds = %3
%21 = load i8**, i8*** %5
%22 = load i8*, i8** %21
store i8* %22, i8** %8
store i32 0, i32* %9
%23 = call double @fcalc(i8** %8, i32* %9, i32 1)
store double %23, double* %10
br label %24
24: ; preds = %40, %20
%25 = load i8*, i8** %8
%26 = load i8, i8* %25
%27 = sext i8 %26 to i32
%28 = icmp ne i32 %27, 0
br i1 %28, label %29, label %43
29: ; preds = %24
%30 = load i8*, i8** %8
%31 = load i8, i8* %30
%32 = sext i8 %31 to i32
%33 = icmp ne i32 %32, 32
br i1 %33, label %34, label %40
34: ; preds = %29
%35 = load i8*, i8** %8
%36 = load i8, i8* %35
%37 = sext i8 %36 to i32
%38 = icmp ne i32 %37, 10
br i1 %38, label %39, label %40
39: ; preds = %34
store i32 1, i32* %9
br label %40
40: ; preds = %39, %34, %29
%41 = load i8*, i8** %8
%42 = getelementptr inbounds i8, i8* %41, i32 1
store i8* %42, i8** %8
br label %24
43: ; preds = %24
%44 = load i32*, i32** %6
%45 = icmp ne i32* %44, null
br i1 %45, label %46, label %49
46: ; preds = %43
%47 = load i32, i32* %9
%48 = load i32*, i32** %6
store i32 %47, i32* %48
br label %49
49: ; preds = %46, %43
%50 = load double, double* %10
store double %50, double* %4
br label %285
51: ; preds = %3
br label %52
52: ; preds = %58, %51
%53 = load i8**, i8*** %5
%54 = load i8*, i8** %53
%55 = load i8, i8* %54
%56 = sext i8 %55 to i32
%57 = icmp eq i32 %56, 32
br i1 %57, label %58, label %62
58: ; preds = %52
%59 = load i8**, i8*** %5
%60 = load i8*, i8** %59
%61 = getelementptr inbounds i8, i8* %60, i32 1
store i8* %61, i8** %59
br label %52
62: ; preds = %52
%63 = load i8**, i8*** %5
%64 = load i8*, i8** %63
%65 = load i8, i8* %64
%66 = sext i8 %65 to i32
switch i32 %66, label %161 [
i32 45, label %67
i32 40, label %75
i32 48, label %94
i32 49, label %94
i32 50, label %94
i32 51, label %94
i32 52, label %94
i32 53, label %94
i32 54, label %94
i32 55, label %94
i32 56, label %94
i32 57, label %94
i32 46, label %94
i32 112, label %140
i32 80, label %140
]
67: ; preds = %62
%68 = load i8**, i8*** %5
%69 = load i8*, i8** %68
%70 = getelementptr inbounds i8, i8* %69, i32 1
store i8* %70, i8** %68
%71 = load i8**, i8*** %5
%72 = load i32*, i32** %6
%73 = call double @fcalc(i8** %71, i32* %72, i32 -1)
%74 = fneg double %73
store double %74, double* %4
br label %285
75: ; preds = %62
%76 = load i8**, i8*** %5
%77 = load i8*, i8** %76
%78 = getelementptr inbounds i8, i8* %77, i32 1
store i8* %78, i8** %76
%79 = load i8**, i8*** %5
%80 = load i32*, i32** %6
%81 = call double @fcalc(i8** %79, i32* %80, i32 1)
store double %81, double* %11
%82 = load i8**, i8*** %5
%83 = load i8*, i8** %82
%84 = load i8, i8* %83
%85 = sext i8 %84 to i32
%86 = icmp ne i32 %85, 41
br i1 %86, label %87, label %89
87: ; preds = %75
%88 = load i32*, i32** %6
store i32 -1, i32* %88
store double 0.000000e+00, double* %4
br label %285
89: ; preds = %75
%90 = load i8**, i8*** %5
%91 = load i8*, i8** %90
%92 = getelementptr inbounds i8, i8* %91, i32 1
store i8* %92, i8** %90
%93 = load double, double* %11
store double %93, double* %4
br label %285
94: ; preds = %62, %62, %62, %62, %62, %62, %62, %62, %62, %62, %62
store i32 0, i32* %7
store double 0.000000e+00, double* %12
store double 1.000000e+00, double* %13
br label %95
95: ; preds = %124, %94
%96 = load i8**, i8*** %5
%97 = load i8*, i8** %96
%98 = load i8, i8* %97
%99 = sext i8 %98 to i32
%100 = icmp eq i32 %99, 46
br i1 %100, label %101, label %105
101: ; preds = %95
store i32 1, i32* %7
%102 = load i8**, i8*** %5
%103 = load i8*, i8** %102
%104 = getelementptr inbounds i8, i8* %103, i32 1
store i8* %104, i8** %102
br label %105
105: ; preds = %101, %95
%106 = load i8**, i8*** %5
%107 = load i8*, i8** %106
%108 = load i8, i8* %107
%109 = sext i8 %108 to i32
%110 = icmp sge i32 %109, 48
br i1 %110, label %111, label %117
111: ; preds = %105
%112 = load i8**, i8*** %5
%113 = load i8*, i8** %112
%114 = load i8, i8* %113
%115 = sext i8 %114 to i32
%116 = icmp sle i32 %115, 57
br i1 %116, label %118, label %117
117: ; preds = %111, %105
br label %136
118: ; preds = %111
%119 = load i32, i32* %7
%120 = icmp eq i32 %119, 1
br i1 %120, label %121, label %124
121: ; preds = %118
%122 = load double, double* %13
%123 = fdiv double %122, 1.000000e+01
store double %123, double* %13
br label %124
124: ; preds = %121, %118
%125 = load double, double* %12
%126 = load i8**, i8*** %5
%127 = load i8*, i8** %126
%128 = load i8, i8* %127
%129 = sext i8 %128 to i32
%130 = sub nsw i32 %129, 48
%131 = sitofp i32 %130 to double
%132 = call double @llvm.fmuladd.f64(double %125, double 1.000000e+01, double %131)
store double %132, double* %12
%133 = load i8**, i8*** %5
%134 = load i8*, i8** %133
%135 = getelementptr inbounds i8, i8* %134, i32 1
store i8* %135, i8** %133
br label %95
136: ; preds = %117
%137 = load double, double* %12
%138 = load double, double* %13
%139 = fmul double %137, %138
store double %139, double* %4
br label %285
140: ; preds = %62, %62
%141 = load i8**, i8*** %5
%142 = load i8*, i8** %141
%143 = getelementptr inbounds i8, i8* %142, i32 1
store i8* %143, i8** %141
%144 = load i8**, i8*** %5
%145 = load i8*, i8** %144
%146 = load i8, i8* %145
%147 = sext i8 %146 to i32
%148 = icmp ne i32 %147, 105
br i1 %148, label %149, label %157
149: ; preds = %140
%150 = load i8**, i8*** %5
%151 = load i8*, i8** %150
%152 = load i8, i8* %151
%153 = sext i8 %152 to i32
%154 = icmp ne i32 %153, 73
br i1 %154, label %155, label %157
155: ; preds = %149
%156 = load i32*, i32** %6
store i32 -1, i32* %156
store double 0.000000e+00, double* %4
br label %285
157: ; preds = %149, %140
%158 = load i8**, i8*** %5
%159 = load i8*, i8** %158
%160 = getelementptr inbounds i8, i8* %159, i32 1
store i8* %160, i8** %158
store double 0x400921FB54442D11, double* %4
br label %285
161: ; preds = %62
%162 = load i32*, i32** %6
store i32 -1, i32* %162
store double 0.000000e+00, double* %4
br label %285
163: ; preds = %3
%164 = load i8**, i8*** %5
%165 = load i32*, i32** %6
%166 = call double @fcalc(i8** %164, i32* %165, i32 -1)
store double %166, double* %14
%167 = load i32*, i32** %6
%168 = load i32, i32* %167
%169 = icmp ne i32 %168, 0
br i1 %169, label %170, label %171
170: ; preds = %163
store double 0.000000e+00, double* %4
br label %285
171: ; preds = %163
br label %172
172: ; preds = %284, %171
br label %173
173: ; preds = %179, %172
%174 = load i8**, i8*** %5
%175 = load i8*, i8** %174
%176 = load i8, i8* %175
%177 = sext i8 %176 to i32
%178 = icmp eq i32 %177, 32
br i1 %178, label %179, label %183
179: ; preds = %173
%180 = load i8**, i8*** %5
%181 = load i8*, i8** %180
%182 = getelementptr inbounds i8, i8* %181, i32 1
store i8* %182, i8** %180
br label %173
183: ; preds = %173
%184 = load i32, i32* %7
%185 = icmp sge i32 1, %184
br i1 %185, label %186, label %207
186: ; preds = %183
%187 = load i8**, i8*** %5
%188 = load i8*, i8** %187
%189 = load i8, i8* %188
%190 = sext i8 %189 to i32
%191 = icmp eq i32 %190, 43
br i1 %191, label %192, label %207
192: ; preds = %186
%193 = load i8**, i8*** %5
%194 = load i8*, i8** %193
%195 = getelementptr inbounds i8, i8* %194, i32 1
store i8* %195, i8** %193
%196 = load i8**, i8*** %5
%197 = load i32*, i32** %6
%198 = call double @fcalc(i8** %196, i32* %197, i32 2)
store double %198, double* %15
%199 = load i32*, i32** %6
%200 = load i32, i32* %199
%201 = icmp ne i32 %200, 0
br i1 %201, label %202, label %203
202: ; preds = %192
store double 0.000000e+00, double* %4
br label %285
203: ; preds = %192
%204 = load double, double* %14
%205 = load double, double* %15
%206 = fadd double %204, %205
store double %206, double* %14
br label %284
207: ; preds = %186, %183
%208 = load i32, i32* %7
%209 = icmp sge i32 1, %208
br i1 %209, label %210, label %231
210: ; preds = %207
%211 = load i8**, i8*** %5
%212 = load i8*, i8** %211
%213 = load i8, i8* %212
%214 = sext i8 %213 to i32
%215 = icmp eq i32 %214, 45
br i1 %215, label %216, label %231
216: ; preds = %210
%217 = load i8**, i8*** %5
%218 = load i8*, i8** %217
%219 = getelementptr inbounds i8, i8* %218, i32 1
store i8* %219, i8** %217
%220 = load i8**, i8*** %5
%221 = load i32*, i32** %6
%222 = call double @fcalc(i8** %220, i32* %221, i32 2)
store double %222, double* %16
%223 = load i32*, i32** %6
%224 = load i32, i32* %223
%225 = icmp ne i32 %224, 0
br i1 %225, label %226, label %227
226: ; preds = %216
store double 0.000000e+00, double* %4
br label %285
227: ; preds = %216
%228 = load double, double* %14
%229 = load double, double* %16
%230 = fsub double %228, %229
store double %230, double* %14
br label %283
231: ; preds = %210, %207
%232 = load i32, i32* %7
%233 = icmp sge i32 2, %232
br i1 %233, label %234, label %255
234: ; preds = %231
%235 = load i8**, i8*** %5
%236 = load i8*, i8** %235
%237 = load i8, i8* %236
%238 = sext i8 %237 to i32
%239 = icmp eq i32 %238, 42
br i1 %239, label %240, label %255
240: ; preds = %234
%241 = load i8**, i8*** %5
%242 = load i8*, i8** %241
%243 = getelementptr inbounds i8, i8* %242, i32 1
store i8* %243, i8** %241
%244 = load i8**, i8*** %5
%245 = load i32*, i32** %6
%246 = call double @fcalc(i8** %244, i32* %245, i32 3)
store double %246, double* %17
%247 = load i32*, i32** %6
%248 = load i32, i32* %247
%249 = icmp ne i32 %248, 0
br i1 %249, label %250, label %251
250: ; preds = %240
store double 0.000000e+00, double* %4
br label %285
251: ; preds = %240
%252 = load double, double* %14
%253 = load double, double* %17
%254 = fmul double %252, %253
store double %254, double* %14
br label %282
255: ; preds = %234, %231
%256 = load i32, i32* %7
%257 = icmp sge i32 2, %256
br i1 %257, label %258, label %279
258: ; preds = %255
%259 = load i8**, i8*** %5
%260 = load i8*, i8** %259
%261 = load i8, i8* %260
%262 = sext i8 %261 to i32
%263 = icmp eq i32 %262, 47
br i1 %263, label %264, label %279
264: ; preds = %258
%265 = load i8**, i8*** %5
%266 = load i8*, i8** %265
%267 = getelementptr inbounds i8, i8* %266, i32 1
store i8* %267, i8** %265
%268 = load i8**, i8*** %5
%269 = load i32*, i32** %6
%270 = call double @fcalc(i8** %268, i32* %269, i32 3)
store double %270, double* %18
%271 = load i32*, i32** %6
%272 = load i32, i32* %271
%273 = icmp ne i32 %272, 0
br i1 %273, label %274, label %275
274: ; preds = %264
store double 0.000000e+00, double* %4
br label %285
275: ; preds = %264
%276 = load double, double* %14
%277 = load double, double* %18
%278 = fdiv double %276, %277
store double %278, double* %14
br label %281
279: ; preds = %258, %255
%280 = load double, double* %14
store double %280, double* %4
br label %285
281: ; preds = %275
br label %282
282: ; preds = %281, %251
br label %283
283: ; preds = %282, %227
br label %284
284: ; preds = %283, %203
br label %172
285: ; preds = %279, %274, %250, %226, %202, %170, %161, %157, %155, %136, %89, %87, %67, %49
%286 = load double, double* %4
ret double %286
}

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