#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 atof(char *);
scalar_t__ isdigit(char);
double pow(double, double);
char *realloc(char *, unsigned int);
int /*<<< orphan*/ snprintf(char *, int, char *, double);
scalar_t__ strchr(char *, char);
int /*<<< orphan*/ strcpy(char *, char *);
unsigned int strlen(char *);
double expr(char *s) {
  double tmp, froms;
  unsigned opi, i, j, k, len, tmi, tlen;
  char op[] = "^r/*%+-", curop[10], tms[80];
  for (opi = 0; opi < 4; ++opi)
    for (i = 0; s[i]; ++i) {
      switch (opi) {
      case 0:
        strcpy(curop, "^");
        break;
      case 1:
        strcpy(curop, "r");
        break;
      case 2:
        strcpy(curop, "/*%");
        break;
      case 3:
        strcpy(curop, "+-");
        break;
      default:
        break;
      }
      tmp = s[i] == '-' ? -atof(s + i + 1) : atof(s + i);
      for (tmi = i; s[i]; ++i) {
        if (i && strchr(curop, s[i])) {
          len = strlen(s);
          froms = s[i + 1] == '-' ? -atof(s + i + 2) : atof(s + i + 1);
          tmp = (double)(s[i] == '+'   ? tmp + froms
                         : s[i] == '-' ? tmp - froms
                         : s[i] == '*' ? tmp * froms
                         : s[i] == '/' ? tmp / froms
                         : s[i] == '^' ? pow(tmp, froms)
                         : s[i] == 'r' ? pow(froms, 1.0 / tmp)
                         : s[i] == '%' ? (unsigned)tmp % (unsigned)froms
                                       : 0);
          snprintf(tms, 80, "%lf", tmp);
          tlen = strlen(tms);
          for (j = s[i + 1] == '-' ? i + 2 : i + 1;
               s[j] && (isdigit(s[j]) || s[j] == '.'); ++j)
            ;
          tlen += len - (j - tmi);
          if (len < tlen) {
            if (!(s = realloc(s, tlen + 1)))
              return 0.0;
            for (k = len - 1; k >= j; --k)
              s[k + (tlen - len)] = s[k];
          } else {
            for (k = j; k < len; ++k)
              s[k - (len - tlen)] = s[k];
            if (!(s = realloc(s, tlen + 1)))
              return 0.0;
          }
          for (k = 0; tms[k]; ++k)
            s[tmi + k] = tms[k];
          s[tlen] = '\0';
          i = tmi;
        } else if (i && strchr(op, s[i]) && !strchr(op, s[i - 1]))
          break;
      }
    }
  return atof(s);
}


x86 assembly (clang, -O0):
<expr>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
mov    %rdi,-0x10(%rbp)
mov    0xe82(%rip),%rax
mov    %rax,-0x44(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x4,-0x24(%rbp)
jae    180d <expr+0x68d>
movl   $0x0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
cmpb   $0x0,(%rax,%rcx,1)
je     17fa <expr+0x67a>
mov    -0x24(%rbp),%eax
mov    %rax,-0xa8(%rbp)
sub    $0x3,%rax
ja     1242 <expr+0xc2>
mov    -0xa8(%rbp),%rax
lea    0xe23(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    -0x4e(%rbp),%rdi
lea    0xe27(%rip),%rsi
call   1040 <strcpy@plt>
jmp    1247 <expr+0xc7>
lea    -0x4e(%rbp),%rdi
lea    0xe14(%rip),%rsi
call   1040 <strcpy@plt>
jmp    1247 <expr+0xc7>
lea    -0x4e(%rbp),%rdi
lea    0xe01(%rip),%rsi
call   1040 <strcpy@plt>
jmp    1247 <expr+0xc7>
lea    -0x4e(%rbp),%rdi
lea    0xde5(%rip),%rsi
call   1040 <strcpy@plt>
jmp    1247 <expr+0xc7>
jmp    1247 <expr+0xc7>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
jne    1292 <expr+0x112>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%eax
add    %rax,%rdi
add    $0x1,%rdi
call   1050 <atof@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    12a9 <expr+0x129>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%eax
add    %rax,%rdi
call   1050 <atof@plt>
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x18(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
cmpb   $0x0,(%rax,%rcx,1)
je     17e7 <expr+0x667>
cmpl   $0x0,-0x28(%rbp)
je     177f <expr+0x5ff>
lea    -0x4e(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
movsbl (%rax,%rcx,1),%esi
call   1070 <strchr@plt>
cmp    $0x0,%rax
je     177f <expr+0x5ff>
mov    -0x10(%rbp),%rdi
call   1060 <strlen@plt>
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
jne    1351 <expr+0x1d1>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%eax
add    %rax,%rdi
add    $0x2,%rdi
call   1050 <atof@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    136c <expr+0x1ec>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%eax
add    %rax,%rdi
add    $0x1,%rdi
call   1050 <atof@plt>
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2b,%eax
jne    13a4 <expr+0x224>
movsd  -0x18(%rbp),%xmm0
addsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    152e <expr+0x3ae>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
jne    13cf <expr+0x24f>
movsd  -0x18(%rbp),%xmm0
subsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    151e <expr+0x39e>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2a,%eax
jne    13fa <expr+0x27a>
movsd  -0x18(%rbp),%xmm0
mulsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
jmp    150e <expr+0x38e>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2f,%eax
jne    1425 <expr+0x2a5>
movsd  -0x18(%rbp),%xmm0
divsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    14fe <expr+0x37e>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5e,%eax
jne    1455 <expr+0x2d5>
movsd  -0x18(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
call   10a0 <pow@plt>
movsd  %xmm0,-0xe0(%rbp)
ff
jmp    14ee <expr+0x36e>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x72,%eax
jne    148d <expr+0x30d>
movsd  -0x20(%rbp),%xmm0
movsd  0xb8a(%rip),%xmm1
divsd  -0x18(%rbp),%xmm1
call   10a0 <pow@plt>
movsd  %xmm0,-0xe8(%rbp)
ff
jmp    14de <expr+0x35e>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x25,%eax
jne    14bc <expr+0x33c>
cvttsd2si -0x18(%rbp),%rax
cvttsd2si -0x20(%rbp),%rcx
xor    %edx,%edx
div    %ecx
mov    %edx,-0xec(%rbp)
jmp    14c9 <expr+0x349>
xor    %eax,%eax
mov    %eax,-0xec(%rbp)
jmp    14c9 <expr+0x349>
mov    -0xec(%rbp),%eax
mov    %eax,%eax
cvtsi2sd %rax,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x18(%rbp)
lea    -0xa0(%rbp),%rdi
movsd  -0x18(%rbp),%xmm0
mov    $0x50,%esi
lea    0xad5(%rip),%rdx
call   1080 <snprintf@plt>
lea    -0xa0(%rbp),%rdi
call   1060 <strlen@plt>
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
jne    1591 <expr+0x411>
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0xf0(%rbp)
jmp    159d <expr+0x41d>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf0(%rbp)
mov    -0xf0(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0xf1(%rbp)
je     160a <expr+0x48a>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movsbl (%rax,%rcx,1),%edi
call   1030 <isdigit@plt>
mov    %rax,%rcx
mov    $0x1,%al
cmp    $0x0,%rcx
mov    %al,-0xf2(%rbp)
jne    15fe <expr+0x47e>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2e,%eax
sete   %al
mov    %al,-0xf2(%rbp)
mov    -0xf2(%rbp),%al
mov    %al,-0xf1(%rbp)
mov    -0xf1(%rbp),%al
test   $0x1,%al
jne    161d <expr+0x49d>
jmp    1630 <expr+0x4b0>
jmp    1622 <expr+0x4a2>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    15a6 <expr+0x426>
mov    -0x34(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    -0x38(%rbp),%ecx
sub    %ecx,%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jae    16bd <expr+0x53d>
mov    -0x10(%rbp),%rdi
mov    -0x3c(%rbp),%esi
add    $0x1,%esi
call   1090 <realloc@plt>
mov    %rax,-0x10(%rbp)
cmp    $0x0,%rax
jne    1677 <expr+0x4f7>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    181b <expr+0x69b>
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jb     16b8 <expr+0x538>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x3c(%rbp),%esi
sub    -0x34(%rbp),%esi
add    %esi,%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    1680 <expr+0x500>
jmp    172a <expr+0x5aa>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jae    16fb <expr+0x57b>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x34(%rbp),%esi
sub    -0x3c(%rbp),%esi
sub    %esi,%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    16c3 <expr+0x543>
mov    -0x10(%rbp),%rdi
mov    -0x3c(%rbp),%esi
add    $0x1,%esi
call   1090 <realloc@plt>
mov    %rax,-0x10(%rbp)
cmp    $0x0,%rax
jne    1725 <expr+0x5a5>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    181b <expr+0x69b>
jmp    172a <expr+0x5aa>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmpb   $0x0,-0xa0(%rbp,%rax,1)
je     1769 <expr+0x5e9>
mov    -0x30(%rbp),%eax
mov    -0xa0(%rbp,%rax,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x30(%rbp),%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1731 <expr+0x5b1>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
movb   $0x0,(%rax,%rcx,1)
mov    -0x38(%rbp),%eax
mov    %eax,-0x28(%rbp)
jmp    17d4 <expr+0x654>
cmpl   $0x0,-0x28(%rbp)
je     17cf <expr+0x64f>
lea    -0x44(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
movsbl (%rax,%rcx,1),%esi
call   1070 <strchr@plt>
cmp    $0x0,%rax
je     17cf <expr+0x64f>
lea    -0x44(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%esi
call   1070 <strchr@plt>
cmp    $0x0,%rax
jne    17cf <expr+0x64f>
jmp    17e7 <expr+0x667>
jmp    17d4 <expr+0x654>
jmp    17d9 <expr+0x659>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    12bc <expr+0x13c>
jmp    17ec <expr+0x66c>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11b2 <expr+0x32>
jmp    17ff <expr+0x67f>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11a1 <expr+0x21>
mov    -0x10(%rbp),%rdi
call   1050 <atof@plt>
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<expr>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %rdi,%rbx
movabs $0x2d2b252a2f725e,%rax
mov    %rax,0x78(%rsp)
movl   $0x0,0xc(%rsp)
mov    (%rbx),%al
test   %al,%al
je     1980 <expr+0x800>
mov    0xc(%rsp),%ecx
shl    $0x2,%rcx
mov    %rcx,0x68(%rsp)
xor    %r14d,%r14d
mov    %rbx,%rbp
jmp    11ea <expr+0x6a>
nopw   0x0(%rax,%rax,1)
mov    %r14d,%r12d
add    $0x1,%r12d
lea    (%rbx,%r12,1),%rbp
mov    (%rbx,%r12,1),%al
mov    %r12d,%r14d
test   %al,%al
je     1980 <expr+0x800>
cmpl   $0x3,0xc(%rsp)
ja     1214 <expr+0x94>
lea    0xf08(%rip),%rax
mov    0x68(%rsp),%rcx
movslq (%rcx,%rax,1),%rsi
add    %rax,%rsi
lea    0x86(%rsp),%rdi
call   1040 <strcpy@plt>
mov    0x0(%rbp),%al
cmp    $0x2d,%al
jne    1230 <expr+0xb0>
add    $0x1,%rbp
mov    %rbp,%rdi
call   1050 <atof@plt>
xorpd  0xdd4(%rip),%xmm0
jmp    1238 <expr+0xb8>
xchg   %ax,%ax
mov    %rbp,%rdi
call   1050 <atof@plt>
mov    %r14d,%ebp
mov    (%rbx,%rbp,1),%al
test   %al,%al
je     11d0 <expr+0x50>
add    %rbx,%rbp
lea    -0x1(%r14),%ecx
mov    %rcx,0x70(%rsp)
lea    0x20(%r14),%ecx
mov    %rcx,0x60(%rsp)
lea    -0x21(%r14),%ecx
mov    %rcx,0x58(%rsp)
lea    -0x11(%r14),%ecx
mov    %rcx,0x50(%rsp)
lea    -0x31(%r14),%ecx
mov    %rcx,0x48(%rsp)
mov    %r14d,%r12d
mov    %r14,(%rsp)
jmp    1297 <expr+0x117>
nopl   0x0(%rax,%rax,1)
xor    %r12d,%r12d
add    $0x1,%r12d
lea    (%rbx,%r12,1),%rbp
mov    (%rbx,%r12,1),%al
test   %al,%al
je     11d3 <expr+0x53>
test   %r12d,%r12d
je     1280 <expr+0x100>
movapd %xmm0,0x10(%rsp)
movsbl %al,%esi
lea    0x86(%rsp),%rdi
call   1070 <strchr@plt>
test   %rax,%rax
je     12f0 <expr+0x170>
mov    %rbx,%rdi
call   1060 <strlen@plt>
mov    %rax,0x28(%rsp)
lea    0x1(%r12),%r13d
cmpb   $0x2d,(%rbx,%r13,1)
jne    132b <expr+0x1ab>
lea    0x2(%rbp),%rdi
call   1050 <atof@plt>
movapd %xmm0,%xmm2
xorpd  0xd1b(%rip),%xmm2
jmp    1338 <expr+0x1b8>
nopw   0x0(%rax,%rax,1)
movsbl 0x0(%rbp),%esi
lea    0x78(%rsp),%rbp
mov    %rbp,%rdi
call   1070 <strchr@plt>
test   %rax,%rax
je     136a <expr+0x1ea>
lea    -0x1(%r12),%eax
movsbl (%rbx,%rax,1),%esi
mov    %rbp,%rdi
call   1070 <strchr@plt>
test   %rax,%rax
movapd 0x10(%rsp),%xmm0
jne    1283 <expr+0x103>
jmp    11d3 <expr+0x53>
lea    0x1(%rbp),%rdi
call   1050 <atof@plt>
movapd %xmm0,%xmm2
mov    0x0(%rbp),%al
xor    %edx,%edx
lea    -0x25(%rax),%ecx
cmp    $0x39,%cl
ja     1375 <expr+0x1f5>
movzbl %cl,%eax
lea    0xcc9(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
cvttsd2si 0x10(%rsp),%rax
cvttsd2si %xmm2,%rcx
xor    %edx,%edx
div    %ecx
jmp    138d <expr+0x20d>
movapd 0x10(%rsp),%xmm0
jmp    1283 <expr+0x103>
cmp    $0x72,%al
jne    138d <expr+0x20d>
movsd  0xc8f(%rip),%xmm1
divsd  0x10(%rsp),%xmm1
movapd %xmm2,%xmm0
jmp    13d3 <expr+0x253>
mov    %edx,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
jmp    13d8 <expr+0x258>
movapd 0x10(%rsp),%xmm0
mulsd  %xmm2,%xmm0
jmp    13d8 <expr+0x258>
movapd 0x10(%rsp),%xmm0
addsd  %xmm2,%xmm0
jmp    13d8 <expr+0x258>
movapd 0x10(%rsp),%xmm0
subsd  %xmm2,%xmm0
jmp    13d8 <expr+0x258>
movapd 0x10(%rsp),%xmm0
divsd  %xmm2,%xmm0
jmp    13d8 <expr+0x258>
movapd 0x10(%rsp),%xmm0
movapd %xmm2,%xmm1
call   10a0 <pow@plt>
lea    0x90(%rsp),%rbp
mov    %rbp,%rdi
mov    $0x50,%esi
lea    0xd2c(%rip),%rdx
movapd %xmm0,0x10(%rsp)
call   1080 <snprintf@plt>
mov    %rbp,%rdi
call   1060 <strlen@plt>
mov    %eax,%r15d
add    $0x2,%r12d
cmpb   $0x2d,(%rbx,%r13,1)
cmovne %r13d,%r12d
mov    (%rbx,%r12,1),%al
test   %al,%al
je     1450 <expr+0x2d0>
lea    (%rbx,%r12,1),%rbp
jmp    1431 <expr+0x2b1>
add    $0x1,%r12d
lea    (%rbx,%r12,1),%rbp
movzbl (%rbx,%r12,1),%eax
test   %al,%al
je     1450 <expr+0x2d0>
movsbl %al,%edi
call   1030 <isdigit@plt>
test   %rax,%rax
jne    1420 <expr+0x2a0>
cmpb   $0x2e,0x0(%rbp)
je     1420 <expr+0x2a0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x28(%rsp),%rbp
lea    (%r14,%rbp,1),%r13d
add    %r15d,%r13d
sub    %r12d,%r13d
mov    %r13d,%r14d
sub    %ebp,%r14d
jbe    149a <expr+0x31a>
lea    0x1(%r13),%esi
mov    %rbx,%rdi
call   1090 <realloc@plt>
test   %rax,%rax
je     199e <expr+0x81e>
mov    %rax,%rbx
lea    -0x1(%rbp),%eax
cmp    %r12d,%eax
jae    1513 <expr+0x393>
mov    (%rsp),%r14
movapd 0x10(%rsp),%xmm0
jmp    193d <expr+0x7bd>
cmp    %ebp,%r12d
jae    191f <expr+0x79f>
mov    %r12d,%eax
mov    %ebp,%r11d
mov    %r11,%r8
sub    %rax,%r8
cmp    $0x8,%r8
jb     188d <expr+0x70d>
mov    %rax,%rdx
not    %rdx
add    %r11,%rdx
mov    (%rsp),%rsi
lea    (%rsi,%r15,1),%ebp
mov    %edx,%esi
add    %ebp,%esi
jb     188d <expr+0x70d>
shr    $0x20,%rdx
jne    188d <expr+0x70d>
lea    (%rbx,%rbp,1),%rdx
lea    (%rbx,%rax,1),%rcx
lea    (%rbx,%r11,1),%rsi
cmp    %rsi,%rdx
jae    1502 <expr+0x382>
lea    (%r11,%rbp,1),%rdx
sub    %rax,%rdx
add    %rbx,%rdx
cmp    %rdx,%rcx
jb     188d <expr+0x70d>
cmp    $0x20,%r8
jae    1773 <expr+0x5f3>
xor    %esi,%esi
jmp    1846 <expr+0x6c6>
mov    %r12d,%r9d
neg    %r9d
mov    $0x1,%r8d
sub    %ebp,%r8d
cmp    %r8d,%r9d
mov    %r8d,%r10d
cmova  %r9d,%r10d
add    %ebp,%r10d
cmp    $0x4,%r10d
movapd 0x10(%rsp),%xmm0
jae    156a <expr+0x3ea>
mov    (%rsp),%r14
add    %r14d,%r15d
sub    %r12d,%r15d
cs nopw 0x0(%rax,%rax,1)
nop
mov    %eax,%ecx
movzbl (%rbx,%rcx,1),%ecx
lea    (%r15,%rax,1),%edx
mov    %cl,(%rbx,%rdx,1)
add    $0xffffffff,%eax
cmp    %r12d,%eax
jae    1550 <expr+0x3d0>
jmp    193d <expr+0x7bd>
lea    -0x2(%rbp),%ecx
lea    -0x1(%r12),%r14d
mov    %ecx,%esi
sub    %r14d,%esi
mov    $0x0,%edx
cmovb  %edx,%esi
mov    0x70(%rsp),%rdx
lea    (%rdx,%rbp,1),%r11d
add    %r15d,%r11d
sub    %r12d,%r11d
cmp    %r11d,%esi
ja     153b <expr+0x3bb>
cmp    %eax,%esi
ja     153b <expr+0x3bb>
lea    (%rbx,%r11,1),%rbp
mov    %rbp,%rdi
sub    %rsi,%rdi
cmp    %rbp,%rdi
ja     153b <expr+0x3bb>
mov    %eax,%edi
lea    (%rbx,%rdi,1),%rdx
mov    %rdx,%rbp
sub    %rsi,%rbp
cmp    %rdx,%rbp
ja     153b <expr+0x3bb>
sub    %r14d,%ecx
mov    $0x0,%edx
cmovb  %edx,%ecx
mov    %r11,%rdx
sub    %rcx,%rdx
add    %rbx,%rdx
lea    (%rbx,%rdi,1),%rsi
add    $0x1,%rsi
cmp    %rsi,%rdx
jae    15ef <expr+0x46f>
lea    (%rbx,%r11,1),%rdx
add    $0x1,%rdx
sub    %rcx,%rdi
add    %rbx,%rdi
cmp    %rdx,%rdi
jb     153b <expr+0x3bb>
xor    %edi,%edi
cmp    $0x10,%r10d
mov    (%rsp),%r14
jb     171c <expr+0x59c>
mov    %r10d,%edi
and    $0xfffffff0,%edi
lea    -0x10(%rdi),%ebp
mov    %ebp,%edx
shr    $0x4,%edx
add    $0x1,%edx
mov    %edx,%ecx
and    $0x3,%ecx
xor    %esi,%esi
cmp    $0x30,%ebp
jb     16d8 <expr+0x558>
and    $0xfffffffc,%edx
mov    0x58(%rsp),%rsi
mov    0x28(%rsp),%rbp
add    %ebp,%esi
add    %r15d,%esi
sub    %r12d,%esi
mov    %rsi,0x40(%rsp)
lea    -0x1(%rbp),%r14d
mov    0x50(%rsp),%rsi
add    %ebp,%esi
add    %r15d,%esi
sub    %r12d,%esi
mov    %rsi,0x38(%rsp)
mov    0x48(%rsp),%rsi
add    %ebp,%esi
add    %r15d,%esi
sub    %r12d,%esi
mov    %rsi,0x30(%rsp)
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%r14,%rsi,1),%ebp
movups -0xf(%rbx,%rbp,1),%xmm1
lea    (%r11,%rsi,1),%ebp
movups %xmm1,-0xf(%rbx,%rbp,1)
lea    (%r14,%rsi,1),%ebp
add    $0xfffffff0,%ebp
movups -0xf(%rbx,%rbp,1),%xmm1
mov    0x38(%rsp),%rbp
lea    0x0(%rbp,%rsi,1),%ebp
movups %xmm1,-0xf(%rbx,%rbp,1)
lea    -0x20(%r14,%rsi,1),%ebp
movups -0xf(%rbx,%rbp,1),%xmm1
mov    0x40(%rsp),%rbp
add    %esi,%ebp
movups %xmm1,-0xf(%rbx,%rbp,1)
lea    -0x30(%r14,%rsi,1),%ebp
movupd -0xf(%rbx,%rbp,1),%xmm1
mov    0x30(%rsp),%rbp
add    %esi,%ebp
movupd %xmm1,-0xf(%rbx,%rbp,1)
add    $0xffffffc0,%esi
add    $0xfffffffc,%edx
jne    1670 <expr+0x4f0>
neg    %esi
mov    (%rsp),%r14
test   %ecx,%ecx
je     1709 <expr+0x589>
lea    (%r14,%r15,1),%edx
sub    %r12d,%edx
not    %esi
add    0x28(%rsp),%esi
nopl   0x0(%rax)
mov    %esi,%ebp
movupd -0xf(%rbx,%rbp,1),%xmm1
lea    (%rdx,%rsi,1),%ebp
movupd %xmm1,-0xf(%rbx,%rbp,1)
add    $0xfffffff0,%esi
add    $0xffffffff,%ecx
jne    16f0 <expr+0x570>
cmp    %edi,%r10d
je     193d <expr+0x7bd>
test   $0xc,%r10b
je     1978 <expr+0x7f8>
cmp    %r8d,%r9d
cmova  %r9d,%r8d
mov    0x28(%rsp),%rcx
add    %ecx,%r8d
mov    %r8d,%r9d
and    $0xfffffffc,%r9d
sub    %r9d,%eax
mov    %edi,%edx
sub    %r9d,%edx
not    %edi
add    %ecx,%edi
lea    (%r14,%r15,1),%esi
sub    %r12d,%esi
cs nopw 0x0(%rax,%rax,1)
nop
mov    %edi,%ebp
mov    -0x3(%rbx,%rbp,1),%ebp
lea    (%rsi,%rdi,1),%ecx
mov    %ebp,-0x3(%rbx,%rcx,1)
add    $0xfffffffc,%edi
add    $0x4,%edx
jne    1750 <expr+0x5d0>
cmp    %r9d,%r8d
jne    153f <expr+0x3bf>
jmp    193d <expr+0x7bd>
mov    %r8,%rsi
and    $0xffffffffffffffe0,%rsi
lea    -0x20(%rsi),%rdx
mov    %rdx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
test   %rdx,%rdx
mov    %rcx,0x40(%rsp)
mov    %rbp,0x30(%rsp)
mov    %rdi,0x38(%rsp)
je     187f <expr+0x6ff>
and    $0xfffffffffffffffe,%rdi
lea    (%rbx,%rax,1),%r10
add    $0x30,%r10
mov    0x60(%rsp),%rdx
lea    (%rdx,%r15,1),%ecx
mov    %rcx,0x28(%rsp)
mov    %ebp,%ecx
xor    %edx,%edx
nop
movups -0x30(%r10,%rdx,1),%xmm0
movups -0x20(%r10,%rdx,1),%xmm1
lea    (%rcx,%rdx,1),%r9d
movups %xmm0,(%rbx,%r9,1)
movups %xmm1,0x10(%rbx,%r9,1)
movupd -0x10(%r10,%rdx,1),%xmm0
movupd (%r10,%rdx,1),%xmm1
mov    0x28(%rsp),%rbp
add    %edx,%ebp
movupd %xmm0,(%rbx,%rbp,1)
movupd %xmm1,0x10(%rbx,%rbp,1)
add    $0x40,%rdx
add    $0xfffffffffffffffe,%rdi
jne    17c0 <expr+0x640>
testb  $0x1,0x38(%rsp)
je     182d <expr+0x6ad>
lea    (%rdx,%rax,1),%rdi
add    %r12d,%edx
add    %edx,%r14d
movupd (%rbx,%rdi,1),%xmm0
movupd 0x10(%rbx,%rdi,1),%xmm1
movupd %xmm0,(%rbx,%r14,1)
movupd %xmm1,0x10(%rbx,%r14,1)
cmp    %rsi,%r8
mov    0x40(%rsp),%rcx
je     191f <expr+0x79f>
test   $0x18,%r8b
mov    0x30(%rsp),%rbp
je     188a <expr+0x70a>
mov    %r11,%r8
sub    %rax,%r8
mov    %r8,%rdi
and    $0xfffffffffffffff8,%rdi
add    %rdi,%rax
mov    %ebp,%r9d
nopl   0x0(%rax)
mov    (%rcx,%rsi,1),%rdx
lea    (%r9,%rsi,1),%ebp
mov    %rdx,(%rbx,%rbp,1)
add    $0x8,%rsi
cmp    %rsi,%rdi
jne    1860 <expr+0x6e0>
cmp    %rdi,%r8
jne    188d <expr+0x70d>
jmp    191f <expr+0x79f>
xor    %edx,%edx
testb  $0x1,0x38(%rsp)
jne    180b <expr+0x68b>
jmp    182d <expr+0x6ad>
add    %rsi,%rax
mov    %r11d,%esi
sub    %eax,%esi
mov    %rax,%r8
not    %r8
add    %r11,%r8
and    $0x3,%rsi
je     18c4 <expr+0x744>
mov    (%rsp),%rcx
lea    (%rcx,%r15,1),%edi
sub    %r12d,%edi
nopl   0x0(%rax)
movzbl (%rbx,%rax,1),%edx
lea    (%rdi,%rax,1),%ebp
mov    %dl,(%rbx,%rbp,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    18b0 <expr+0x730>
cmp    $0x3,%r8
jb     191f <expr+0x79f>
add    (%rsp),%r15d
sub    %r12d,%r15d
lea    0x3(%rbx),%rdx
cs nopw 0x0(%rax,%rax,1)
nop
movzbl -0x3(%rdx,%rax,1),%ecx
lea    (%rax,%r15,1),%rsi
mov    %esi,%edi
mov    %cl,(%rbx,%rdi,1)
movzbl -0x2(%rdx,%rax,1),%ecx
lea    0x1(%rsi),%edi
mov    %cl,(%rbx,%rdi,1)
movzbl -0x1(%rdx,%rax,1),%ecx
lea    0x2(%rsi),%edi
mov    %cl,(%rbx,%rdi,1)
movzbl (%rdx,%rax,1),%ecx
add    $0x3,%esi
mov    %cl,(%rbx,%rsi,1)
add    $0xfffffffffffffffc,%r11
add    $0x4,%r15
add    $0x4,%rdx
cmp    %r11,%rax
jne    18e0 <expr+0x760>
lea    0x1(%r13),%esi
mov    %rbx,%rdi
call   1090 <realloc@plt>
mov    %rax,%rbx
test   %rax,%rax
mov    (%rsp),%r14
movapd 0x10(%rsp),%xmm0
je     199e <expr+0x81e>
mov    0x90(%rsp),%al
test   %al,%al
je     1969 <expr+0x7e9>
mov    $0x1,%ecx
mov    %r14d,%edx
mov    %edx,%esi
mov    %al,(%rbx,%rsi,1)
mov    %ecx,%eax
movzbl 0x90(%rsp,%rax,1),%eax
add    $0x1,%edx
add    $0x1,%ecx
test   %al,%al
jne    1950 <expr+0x7d0>
mov    %r13d,%eax
movb   $0x0,(%rbx,%rax,1)
mov    %r14d,%r12d
jmp    1283 <expr+0x103>
sub    %edi,%eax
jmp    153f <expr+0x3bf>
nop
mov    0xc(%rsp),%eax
add    $0x1,%eax
mov    %eax,0xc(%rsp)
cmp    $0x4,%eax
jne    11ab <expr+0x2b>
mov    %rbx,%rdi
call   1050 <atof@plt>
jmp    19a2 <expr+0x822>
xorpd  %xmm0,%xmm0
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@__const.expr.op = [8 x i8] c"^r/*%+-\00"
@.str = [2 x i8] c"^\00"
@.str.1 = [2 x i8] c"r\00"
@.str.2 = [4 x i8] c"/*%\00"
@.str.3 = [3 x i8] c"+-\00"
@.str.4 = [4 x i8] c"%lf\00"
define double @expr(i8* %0) {
%2 = alloca double
%3 = alloca i8*
%4 = alloca double
%5 = alloca double
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca [8 x i8]
%14 = alloca [10 x i8]
%15 = alloca [80 x i8]
store i8* %0, i8** %3
%16 = bitcast [8 x i8]* %13 to i8*
store i32 0, i32* %6
br label %17
17: ; preds = %404, %1
%18 = load i32, i32* %6
%19 = icmp ult i32 %18, 4
br i1 %19, label %20, label %407
20: ; preds = %17
store i32 0, i32* %7
br label %21
21: ; preds = %400, %20
%22 = load i8*, i8** %3
%23 = load i32, i32* %7
%24 = zext i32 %23 to i64
%25 = getelementptr inbounds i8, i8* %22, i64 %24
%26 = load i8, i8* %25
%27 = icmp ne i8 %26, 0
br i1 %27, label %28, label %403
28: ; preds = %21
%29 = load i32, i32* %6
switch i32 %29, label %42 [
i32 0, label %30
i32 1, label %33
i32 2, label %36
i32 3, label %39
]
30: ; preds = %28
%31 = getelementptr inbounds [10 x i8], [10 x i8]* %14, i64 0, i64 0
%32 = call i32 @strcpy(i8* %31, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
br label %43
33: ; preds = %28
%34 = getelementptr inbounds [10 x i8], [10 x i8]* %14, i64 0, i64 0
%35 = call i32 @strcpy(i8* %34, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
br label %43
36: ; preds = %28
%37 = getelementptr inbounds [10 x i8], [10 x i8]* %14, i64 0, i64 0
%38 = call i32 @strcpy(i8* %37, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0))
br label %43
39: ; preds = %28
%40 = getelementptr inbounds [10 x i8], [10 x i8]* %14, i64 0, i64 0
%41 = call i32 @strcpy(i8* %40, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0))
br label %43
42: ; preds = %28
br label %43
43: ; preds = %42, %39, %36, %33, %30
%44 = load i8*, i8** %3
%45 = load i32, i32* %7
%46 = zext i32 %45 to i64
%47 = getelementptr inbounds i8, i8* %44, i64 %46
%48 = load i8, i8* %47
%49 = sext i8 %48 to i32
%50 = icmp eq i32 %49, 45
br i1 %50, label %51, label %59
51: ; preds = %43
%52 = load i8*, i8** %3
%53 = load i32, i32* %7
%54 = zext i32 %53 to i64
%55 = getelementptr inbounds i8, i8* %52, i64 %54
%56 = getelementptr inbounds i8, i8* %55, i64 1
%57 = call double @atof(i8* %56)
%58 = fneg double %57
br label %65
59: ; preds = %43
%60 = load i8*, i8** %3
%61 = load i32, i32* %7
%62 = zext i32 %61 to i64
%63 = getelementptr inbounds i8, i8* %60, i64 %62
%64 = call double @atof(i8* %63)
br label %65
65: ; preds = %59, %51
%66 = phi double [ %58, %51 ], [ %64, %59 ]
store double %66, double* %4
%67 = load i32, i32* %7
store i32 %67, i32* %11
br label %68
68: ; preds = %396, %65
%69 = load i8*, i8** %3
%70 = load i32, i32* %7
%71 = zext i32 %70 to i64
%72 = getelementptr inbounds i8, i8* %69, i64 %71
%73 = load i8, i8* %72
%74 = icmp ne i8 %73, 0
br i1 %74, label %75, label %399
75: ; preds = %68
%76 = load i32, i32* %7
%77 = icmp ne i32 %76, 0
br i1 %77, label %78, label %371
78: ; preds = %75
%79 = getelementptr inbounds [10 x i8], [10 x i8]* %14, i64 0, i64 0
%80 = load i8*, i8** %3
%81 = load i32, i32* %7
%82 = zext i32 %81 to i64
%83 = getelementptr inbounds i8, i8* %80, i64 %82
%84 = load i8, i8* %83
%85 = call i64 @strchr(i8* %79, i8 signext %84)
%86 = icmp ne i64 %85, 0
br i1 %86, label %87, label %371
87: ; preds = %78
%88 = load i8*, i8** %3
%89 = call i32 @strlen(i8* %88)
store i32 %89, i32* %10
%90 = load i8*, i8** %3
%91 = load i32, i32* %7
%92 = add i32 %91, 1
%93 = zext i32 %92 to i64
%94 = getelementptr inbounds i8, i8* %90, i64 %93
%95 = load i8, i8* %94
%96 = sext i8 %95 to i32
%97 = icmp eq i32 %96, 45
br i1 %97, label %98, label %106
98: ; preds = %87
%99 = load i8*, i8** %3
%100 = load i32, i32* %7
%101 = zext i32 %100 to i64
%102 = getelementptr inbounds i8, i8* %99, i64 %101
%103 = getelementptr inbounds i8, i8* %102, i64 2
%104 = call double @atof(i8* %103)
%105 = fneg double %104
br label %113
106: ; preds = %87
%107 = load i8*, i8** %3
%108 = load i32, i32* %7
%109 = zext i32 %108 to i64
%110 = getelementptr inbounds i8, i8* %107, i64 %109
%111 = getelementptr inbounds i8, i8* %110, i64 1
%112 = call double @atof(i8* %111)
br label %113
113: ; preds = %106, %98
%114 = phi double [ %105, %98 ], [ %112, %106 ]
store double %114, double* %5
%115 = load i8*, i8** %3
%116 = load i32, i32* %7
%117 = zext i32 %116 to i64
%118 = getelementptr inbounds i8, i8* %115, i64 %117
%119 = load i8, i8* %118
%120 = sext i8 %119 to i32
%121 = icmp eq i32 %120, 43
br i1 %121, label %122, label %126
122: ; preds = %113
%123 = load double, double* %4
%124 = load double, double* %5
%125 = fadd double %123, %124
br label %215
126: ; preds = %113
%127 = load i8*, i8** %3
%128 = load i32, i32* %7
%129 = zext i32 %128 to i64
%130 = getelementptr inbounds i8, i8* %127, i64 %129
%131 = load i8, i8* %130
%132 = sext i8 %131 to i32
%133 = icmp eq i32 %132, 45
br i1 %133, label %134, label %138
134: ; preds = %126
%135 = load double, double* %4
%136 = load double, double* %5
%137 = fsub double %135, %136
br label %213
138: ; preds = %126
%139 = load i8*, i8** %3
%140 = load i32, i32* %7
%141 = zext i32 %140 to i64
%142 = getelementptr inbounds i8, i8* %139, i64 %141
%143 = load i8, i8* %142
%144 = sext i8 %143 to i32
%145 = icmp eq i32 %144, 42
br i1 %145, label %146, label %150
146: ; preds = %138
%147 = load double, double* %4
%148 = load double, double* %5
%149 = fmul double %147, %148
br label %211
150: ; preds = %138
%151 = load i8*, i8** %3
%152 = load i32, i32* %7
%153 = zext i32 %152 to i64
%154 = getelementptr inbounds i8, i8* %151, i64 %153
%155 = load i8, i8* %154
%156 = sext i8 %155 to i32
%157 = icmp eq i32 %156, 47
br i1 %157, label %158, label %162
158: ; preds = %150
%159 = load double, double* %4
%160 = load double, double* %5
%161 = fdiv double %159, %160
br label %209
162: ; preds = %150
%163 = load i8*, i8** %3
%164 = load i32, i32* %7
%165 = zext i32 %164 to i64
%166 = getelementptr inbounds i8, i8* %163, i64 %165
%167 = load i8, i8* %166
%168 = sext i8 %167 to i32
%169 = icmp eq i32 %168, 94
br i1 %169, label %170, label %174
170: ; preds = %162
%171 = load double, double* %4
%172 = load double, double* %5
%173 = call double @pow(double %171, double %172)
br label %207
174: ; preds = %162
%175 = load i8*, i8** %3
%176 = load i32, i32* %7
%177 = zext i32 %176 to i64
%178 = getelementptr inbounds i8, i8* %175, i64 %177
%179 = load i8, i8* %178
%180 = sext i8 %179 to i32
%181 = icmp eq i32 %180, 114
br i1 %181, label %182, label %187
182: ; preds = %174
%183 = load double, double* %5
%184 = load double, double* %4
%185 = fdiv double 1.000000e+00, %184
%186 = call double @pow(double %183, double %185)
br label %205
187: ; preds = %174
%188 = load i8*, i8** %3
%189 = load i32, i32* %7
%190 = zext i32 %189 to i64
%191 = getelementptr inbounds i8, i8* %188, i64 %190
%192 = load i8, i8* %191
%193 = sext i8 %192 to i32
%194 = icmp eq i32 %193, 37
br i1 %194, label %195, label %201
195: ; preds = %187
%196 = load double, double* %4
%197 = fptoui double %196 to i32
%198 = load double, double* %5
%199 = fptoui double %198 to i32
%200 = urem i32 %197, %199
br label %202
201: ; preds = %187
br label %202
202: ; preds = %201, %195
%203 = phi i32 [ %200, %195 ], [ 0, %201 ]
%204 = uitofp i32 %203 to double
br label %205
205: ; preds = %202, %182
%206 = phi double [ %186, %182 ], [ %204, %202 ]
br label %207
207: ; preds = %205, %170
%208 = phi double [ %173, %170 ], [ %206, %205 ]
br label %209
209: ; preds = %207, %158
%210 = phi double [ %161, %158 ], [ %208, %207 ]
br label %211
211: ; preds = %209, %146
%212 = phi double [ %149, %146 ], [ %210, %209 ]
br label %213
213: ; preds = %211, %134
%214 = phi double [ %137, %134 ], [ %212, %211 ]
br label %215
215: ; preds = %213, %122
%216 = phi double [ %125, %122 ], [ %214, %213 ]
store double %216, double* %4
%217 = getelementptr inbounds [80 x i8], [80 x i8]* %15, i64 0, i64 0
%218 = load double, double* %4
%219 = call i32 @snprintf(i8* %217, i32 80, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), double %218)
%220 = getelementptr inbounds [80 x i8], [80 x i8]* %15, i64 0, i64 0
%221 = call i32 @strlen(i8* %220)
store i32 %221, i32* %12
%222 = load i8*, i8** %3
%223 = load i32, i32* %7
%224 = add i32 %223, 1
%225 = zext i32 %224 to i64
%226 = getelementptr inbounds i8, i8* %222, i64 %225
%227 = load i8, i8* %226
%228 = sext i8 %227 to i32
%229 = icmp eq i32 %228, 45
br i1 %229, label %230, label %233
230: ; preds = %215
%231 = load i32, i32* %7
%232 = add i32 %231, 2
br label %236
233: ; preds = %215
%234 = load i32, i32* %7
%235 = add i32 %234, 1
br label %236
236: ; preds = %233, %230
%237 = phi i32 [ %232, %230 ], [ %235, %233 ]
store i32 %237, i32* %8
br label %238
238: ; preds = %267, %236
%239 = load i8*, i8** %3
%240 = load i32, i32* %8
%241 = zext i32 %240 to i64
%242 = getelementptr inbounds i8, i8* %239, i64 %241
%243 = load i8, i8* %242
%244 = sext i8 %243 to i32
%245 = icmp ne i32 %244, 0
br i1 %245, label %246, label %264
246: ; preds = %238
%247 = load i8*, i8** %3
%248 = load i32, i32* %8
%249 = zext i32 %248 to i64
%250 = getelementptr inbounds i8, i8* %247, i64 %249
%251 = load i8, i8* %250
%252 = call i64 @isdigit(i8 signext %251)
%253 = icmp ne i64 %252, 0
br i1 %253, label %262, label %254
254: ; preds = %246
%255 = load i8*, i8** %3
%256 = load i32, i32* %8
%257 = zext i32 %256 to i64
%258 = getelementptr inbounds i8, i8* %255, i64 %257
%259 = load i8, i8* %258
%260 = sext i8 %259 to i32
%261 = icmp eq i32 %260, 46
br label %262
262: ; preds = %254, %246
%263 = phi i1 [ true, %246 ], [ %261, %254 ]
br label %264
264: ; preds = %262, %238
%265 = phi i1 [ false, %238 ], [ %263, %262 ]
br i1 %265, label %266, label %270
266: ; preds = %264
br label %267
267: ; preds = %266
%268 = load i32, i32* %8
%269 = add i32 %268, 1
store i32 %269, i32* %8
br label %238
270: ; preds = %264
%271 = load i32, i32* %10
%272 = load i32, i32* %8
%273 = load i32, i32* %11
%274 = sub i32 %272, %273
%275 = sub i32 %271, %274
%276 = load i32, i32* %12
%277 = add i32 %276, %275
store i32 %277, i32* %12
%278 = load i32, i32* %10
%279 = load i32, i32* %12
%280 = icmp ult i32 %278, %279
br i1 %280, label %281, label %313
281: ; preds = %270
%282 = load i8*, i8** %3
%283 = load i32, i32* %12
%284 = add i32 %283, 1
%285 = call i8* @realloc(i8* %282, i32 %284)
store i8* %285, i8** %3
%286 = icmp ne i8* %285, null
br i1 %286, label %288, label %287
287: ; preds = %281
store double 0.000000e+00, double* %2
br label %410
288: ; preds = %281
%289 = load i32, i32* %10
%290 = sub i32 %289, 1
store i32 %290, i32* %9
br label %291
291: ; preds = %309, %288
%292 = load i32, i32* %9
%293 = load i32, i32* %8
%294 = icmp uge i32 %292, %293
br i1 %294, label %295, label %312
295: ; preds = %291
%296 = load i8*, i8** %3
%297 = load i32, i32* %9
%298 = zext i32 %297 to i64
%299 = getelementptr inbounds i8, i8* %296, i64 %298
%300 = load i8, i8* %299
%301 = load i8*, i8** %3
%302 = load i32, i32* %9
%303 = load i32, i32* %12
%304 = load i32, i32* %10
%305 = sub i32 %303, %304
%306 = add i32 %302, %305
%307 = zext i32 %306 to i64
%308 = getelementptr inbounds i8, i8* %301, i64 %307
store i8 %300, i8* %308
br label %309
309: ; preds = %295
%310 = load i32, i32* %9
%311 = add i32 %310, -1
store i32 %311, i32* %9
br label %291
312: ; preds = %291
br label %344
313: ; preds = %270
%314 = load i32, i32* %8
store i32 %314, i32* %9
br label %315
315: ; preds = %333, %313
%316 = load i32, i32* %9
%317 = load i32, i32* %10
%318 = icmp ult i32 %316, %317
br i1 %318, label %319, label %336
319: ; preds = %315
%320 = load i8*, i8** %3
%321 = load i32, i32* %9
%322 = zext i32 %321 to i64
%323 = getelementptr inbounds i8, i8* %320, i64 %322
%324 = load i8, i8* %323
%325 = load i8*, i8** %3
%326 = load i32, i32* %9
%327 = load i32, i32* %10
%328 = load i32, i32* %12
%329 = sub i32 %327, %328
%330 = sub i32 %326, %329
%331 = zext i32 %330 to i64
%332 = getelementptr inbounds i8, i8* %325, i64 %331
store i8 %324, i8* %332
br label %333
333: ; preds = %319
%334 = load i32, i32* %9
%335 = add i32 %334, 1
store i32 %335, i32* %9
br label %315
336: ; preds = %315
%337 = load i8*, i8** %3
%338 = load i32, i32* %12
%339 = add i32 %338, 1
%340 = call i8* @realloc(i8* %337, i32 %339)
store i8* %340, i8** %3
%341 = icmp ne i8* %340, null
br i1 %341, label %343, label %342
342: ; preds = %336
store double 0.000000e+00, double* %2
br label %410
343: ; preds = %336
br label %344
344: ; preds = %343, %312
store i32 0, i32* %9
br label %345
345: ; preds = %362, %344
%346 = load i32, i32* %9
%347 = zext i32 %346 to i64
%348 = getelementptr inbounds [80 x i8], [80 x i8]* %15, i64 0, i64 %347
%349 = load i8, i8* %348
%350 = icmp ne i8 %349, 0
br i1 %350, label %351, label %365
351: ; preds = %345
%352 = load i32, i32* %9
%353 = zext i32 %352 to i64
%354 = getelementptr inbounds [80 x i8], [80 x i8]* %15, i64 0, i64 %353
%355 = load i8, i8* %354
%356 = load i8*, i8** %3
%357 = load i32, i32* %11
%358 = load i32, i32* %9
%359 = add i32 %357, %358
%360 = zext i32 %359 to i64
%361 = getelementptr inbounds i8, i8* %356, i64 %360
store i8 %355, i8* %361
br label %362
362: ; preds = %351
%363 = load i32, i32* %9
%364 = add i32 %363, 1
store i32 %364, i32* %9
br label %345
365: ; preds = %345
%366 = load i8*, i8** %3
%367 = load i32, i32* %12
%368 = zext i32 %367 to i64
%369 = getelementptr inbounds i8, i8* %366, i64 %368
store i8 0, i8* %369
%370 = load i32, i32* %11
store i32 %370, i32* %7
br label %395
371: ; preds = %78, %75
%372 = load i32, i32* %7
%373 = icmp ne i32 %372, 0
br i1 %373, label %374, label %394
374: ; preds = %371
%375 = getelementptr inbounds [8 x i8], [8 x i8]* %13, i64 0, i64 0
%376 = load i8*, i8** %3
%377 = load i32, i32* %7
%378 = zext i32 %377 to i64
%379 = getelementptr inbounds i8, i8* %376, i64 %378
%380 = load i8, i8* %379
%381 = call i64 @strchr(i8* %375, i8 signext %380)
%382 = icmp ne i64 %381, 0
br i1 %382, label %383, label %394
383: ; preds = %374
%384 = getelementptr inbounds [8 x i8], [8 x i8]* %13, i64 0, i64 0
%385 = load i8*, i8** %3
%386 = load i32, i32* %7
%387 = sub i32 %386, 1
%388 = zext i32 %387 to i64
%389 = getelementptr inbounds i8, i8* %385, i64 %388
%390 = load i8, i8* %389
%391 = call i64 @strchr(i8* %384, i8 signext %390)
%392 = icmp ne i64 %391, 0
br i1 %392, label %394, label %393
393: ; preds = %383
br label %399
394: ; preds = %383, %374, %371
br label %395
395: ; preds = %394, %365
br label %396
396: ; preds = %395
%397 = load i32, i32* %7
%398 = add i32 %397, 1
store i32 %398, i32* %7
br label %68
399: ; preds = %393, %68
br label %400
400: ; preds = %399
%401 = load i32, i32* %7
%402 = add i32 %401, 1
store i32 %402, i32* %7
br label %21
403: ; preds = %21
br label %404
404: ; preds = %403
%405 = load i32, i32* %6
%406 = add i32 %405, 1
store i32 %406, i32* %6
br label %17
407: ; preds = %17
%408 = load i8*, i8** %3
%409 = call double @atof(i8* %408)
store double %409, double* %2
br label %410
410: ; preds = %407, %342, %287
%411 = load double, double* %2
ret double %411
}

LLVM IR (-O2):
@.str = [2 x i8] c"^\00"
@.str.1 = [2 x i8] c"r\00"
@.str.2 = [4 x i8] c"/*%\00"
@.str.3 = [3 x i8] c"+-\00"
@.str.4 = [4 x i8] c"%lf\00"
@reltable.expr = [4 x i32] [i32 trunc (i64 sub (i64 ptrtoint ([2 x i8]* @.str to i64), i64 ptrtoint ([4 x i32]* @reltable.expr to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([2 x i8]* @.str.1 to i64), i64 ptrtoint ([4 x i32]* @reltable.expr to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.2 to i64), i64 ptrtoint ([4 x i32]* @reltable.expr to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([3 x i8]* @.str.3 to i64), i64 ptrtoint ([4 x i32]* @reltable.expr to i64)) to i32)]
define double @expr(i8* %0) {
%2 = alloca i64
%3 = alloca [10 x i8]
%4 = alloca [80 x i8]
%5 = bitcast i64* %2 to i8*
store i64 12713812573516382, i64* %2
%6 = getelementptr inbounds [10 x i8], [10 x i8]* %3, i64 0, i64 0
%7 = getelementptr inbounds [80 x i8], [80 x i8]* %4, i64 0, i64 0
br label %8
8: ; preds = %1, %541
%9 = phi i8* [ %0, %1 ], [ %542, %541 ]
%10 = phi i32 [ 0, %1 ], [ %543, %541 ]
%11 = load i8, i8* %9
%12 = icmp eq i8 %11, 0
br i1 %12, label %541, label %13
13: ; preds = %8
%14 = icmp ult i32 %10, 4
%15 = zext i32 %10 to i64
%16 = shl i64 %15, 2
br label %17
17: ; preds = %13, %533
%18 = phi i8 [ %539, %533 ], [ %11, %13 ]
%19 = phi i8* [ %538, %533 ], [ %9, %13 ]
%20 = phi i8* [ %535, %533 ], [ %9, %13 ]
%21 = phi i32 [ %536, %533 ], [ 0, %13 ]
br i1 %14, label %22, label %26
22: ; preds = %17
%23 = call i8* @llvm.load.relative.i64(i8* bitcast ([4 x i32]* @reltable.expr to i8*), i64 %16)
%24 = call i32 @strcpy(i8* %6, i8* %23)
%25 = load i8, i8* %19
br label %26
26: ; preds = %17, %22
%27 = phi i8 [ %25, %22 ], [ %18, %17 ]
%28 = icmp eq i8 %27, 45
br i1 %28, label %29, label %33
29: ; preds = %26
%30 = getelementptr inbounds i8, i8* %19, i64 1
%31 = call double @atof(i8* %30)
%32 = fneg double %31
br label %35
33: ; preds = %26
%34 = call double @atof(i8* %19)
br label %35
35: ; preds = %33, %29
%36 = phi double [ %32, %29 ], [ %34, %33 ]
%37 = zext i32 %21 to i64
%38 = getelementptr inbounds i8, i8* %20, i64 %37
%39 = load i8, i8* %38
%40 = icmp eq i8 %39, 0
br i1 %40, label %533, label %41
41: ; preds = %35
%42 = add i32 %21, -1
%43 = add i32 %21, -1
br label %44
44: ; preds = %41, %524
%45 = phi i8 [ %531, %524 ], [ %39, %41 ]
%46 = phi i8* [ %530, %524 ], [ %38, %41 ]
%47 = phi i8* [ %527, %524 ], [ %20, %41 ]
%48 = phi i32 [ %528, %524 ], [ %21, %41 ]
%49 = phi double [ %525, %524 ], [ %36, %41 ]
%50 = icmp eq i32 %48, 0
br i1 %50, label %524, label %51
51: ; preds = %44
%52 = call i64 @strchr(i8* %6, i8 signext %45)
%53 = icmp eq i64 %52, 0
br i1 %53, label %513, label %54
54: ; preds = %51
%55 = call i32 @strlen(i8* %47)
%56 = add i32 %48, 1
%57 = zext i32 %56 to i64
%58 = getelementptr inbounds i8, i8* %47, i64 %57
%59 = load i8, i8* %58
%60 = icmp eq i8 %59, 45
br i1 %60, label %61, label %65
61: ; preds = %54
%62 = getelementptr inbounds i8, i8* %46, i64 2
%63 = call double @atof(i8* %62)
%64 = fneg double %63
br label %68
65: ; preds = %54
%66 = getelementptr inbounds i8, i8* %46, i64 1
%67 = call double @atof(i8* %66)
br label %68
68: ; preds = %65, %61
%69 = phi double [ %64, %61 ], [ %67, %65 ]
%70 = load i8, i8* %46
switch i8 %70, label %88 [
i8 43, label %71
i8 45, label %73
i8 42, label %75
i8 47, label %77
i8 94, label %79
i8 114, label %81
i8 37, label %84
]
71: ; preds = %68
%72 = fadd double %49, %69
br label %91
73: ; preds = %68
%74 = fsub double %49, %69
br label %91
75: ; preds = %68
%76 = fmul double %49, %69
br label %91
77: ; preds = %68
%78 = fdiv double %49, %69
br label %91
79: ; preds = %68
%80 = call double @pow(double %49, double %69)
br label %91
81: ; preds = %68
%82 = fdiv double 1.000000e+00, %49
%83 = call double @pow(double %69, double %82)
br label %91
84: ; preds = %68
%85 = fptoui double %49 to i32
%86 = fptoui double %69 to i32
%87 = urem i32 %85, %86
br label %88
88: ; preds = %68, %84
%89 = phi i32 [ %87, %84 ], [ 0, %68 ]
%90 = uitofp i32 %89 to double
br label %91
91: ; preds = %73, %77, %81, %88, %79, %75, %71
%92 = phi double [ %72, %71 ], [ %74, %73 ], [ %76, %75 ], [ %78, %77 ], [ %80, %79 ], [ %83, %81 ], [ %90, %88 ]
%93 = call i32 @snprintf(i8* %7, i32 80, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), double %92)
%94 = call i32 @strlen(i8* %7)
%95 = load i8, i8* %58
%96 = icmp eq i8 %95, 45
%97 = add i32 %48, 2
%98 = select i1 %96, i32 %97, i32 %56
%99 = zext i32 %98 to i64
%100 = getelementptr inbounds i8, i8* %47, i64 %99
%101 = load i8, i8* %100
%102 = icmp eq i8 %101, 0
br i1 %102, label %118, label %103
103: ; preds = %91, %112
%104 = phi i8 [ %116, %112 ], [ %101, %91 ]
%105 = phi i8* [ %115, %112 ], [ %100, %91 ]
%106 = phi i32 [ %113, %112 ], [ %98, %91 ]
%107 = call i64 @isdigit(i8 signext %104)
%108 = icmp eq i64 %107, 0
br i1 %108, label %109, label %112
109: ; preds = %103
%110 = load i8, i8* %105
%111 = icmp eq i8 %110, 46
br i1 %111, label %112, label %118
112: ; preds = %103, %109
%113 = add i32 %106, 1
%114 = zext i32 %113 to i64
%115 = getelementptr inbounds i8, i8* %47, i64 %114
%116 = load i8, i8* %115
%117 = icmp eq i8 %116, 0
br i1 %117, label %118, label %103
118: ; preds = %109, %112, %91
%119 = phi i32 [ %98, %91 ], [ %113, %112 ], [ %106, %109 ]
%120 = add i32 %55, %21
%121 = add i32 %120, %94
%122 = sub i32 %121, %119
%123 = icmp ugt i32 %122, %55
br i1 %123, label %271, label %124
124: ; preds = %118
%125 = icmp ult i32 %119, %55
br i1 %125, label %126, label %491
126: ; preds = %124
%127 = sub i32 %122, %55
%128 = zext i32 %119 to i64
%129 = zext i32 %55 to i64
%130 = sub nsw i64 %129, %128
%131 = icmp ult i64 %130, 8
br i1 %131, label %249, label %132
132: ; preds = %126
%133 = xor i64 %128, -1
%134 = add nsw i64 %133, %129
%135 = add i32 %21, %94
%136 = trunc i64 %134 to i32
%137 = xor i32 %135, -1
%138 = icmp ult i32 %137, %136
%139 = icmp ugt i64 %134, 4294967295
%140 = or i1 %138, %139
br i1 %140, label %249, label %141
141: ; preds = %132
%142 = add i32 %21, %94
%143 = zext i32 %142 to i64
%144 = getelementptr i8, i8* %47, i64 %143
%145 = add nuw nsw i64 %129, %143
%146 = sub nsw i64 %145, %128
%147 = getelementptr i8, i8* %47, i64 %146
%148 = getelementptr i8, i8* %47, i64 %128
%149 = getelementptr i8, i8* %47, i64 %129
%150 = icmp ult i8* %144, %149
%151 = icmp ult i8* %148, %147
%152 = and i1 %150, %151
br i1 %152, label %249, label %153
153: ; preds = %141
%154 = icmp ult i64 %130, 32
br i1 %154, label %226, label %155
155: ; preds = %153
%156 = and i64 %130, -32
%157 = add nsw i64 %156, -32
%158 = lshr exact i64 %157, 5
%159 = add nuw nsw i64 %158, 1
%160 = and i64 %159, 1
%161 = icmp eq i64 %157, 0
br i1 %161, label %201, label %162
162: ; preds = %155
%163 = and i64 %159, 1152921504606846974
br label %164
164: ; preds = %164, %162
%165 = phi i64 [ 0, %162 ], [ %198, %164 ]
%166 = phi i64 [ 0, %162 ], [ %199, %164 ]
%167 = add i64 %165, %128
%168 = trunc i64 %165 to i32
%169 = add i32 %119, %168
%170 = getelementptr inbounds i8, i8* %47, i64 %167
%171 = bitcast i8* %170 to <16 x i8>*
%172 = load <16 x i8>, <16 x i8>* %171
%173 = getelementptr inbounds i8, i8* %170, i64 16
%174 = bitcast i8* %173 to <16 x i8>*
%175 = load <16 x i8>, <16 x i8>* %174
%176 = add i32 %127, %169
%177 = zext i32 %176 to i64
%178 = getelementptr inbounds i8, i8* %47, i64 %177
%179 = bitcast i8* %178 to <16 x i8>*
store <16 x i8> %172, <16 x i8>* %179
%180 = getelementptr inbounds i8, i8* %178, i64 16
%181 = bitcast i8* %180 to <16 x i8>*
store <16 x i8> %175, <16 x i8>* %181
%182 = or i64 %165, 32
%183 = add i64 %182, %128
%184 = trunc i64 %182 to i32
%185 = add i32 %119, %184
%186 = getelementptr inbounds i8, i8* %47, i64 %183
%187 = bitcast i8* %186 to <16 x i8>*
%188 = load <16 x i8>, <16 x i8>* %187
%189 = getelementptr inbounds i8, i8* %186, i64 16
%190 = bitcast i8* %189 to <16 x i8>*
%191 = load <16 x i8>, <16 x i8>* %190
%192 = add i32 %127, %185
%193 = zext i32 %192 to i64
%194 = getelementptr inbounds i8, i8* %47, i64 %193
%195 = bitcast i8* %194 to <16 x i8>*
store <16 x i8> %188, <16 x i8>* %195
%196 = getelementptr inbounds i8, i8* %194, i64 16
%197 = bitcast i8* %196 to <16 x i8>*
store <16 x i8> %191, <16 x i8>* %197
%198 = add nuw i64 %165, 64
%199 = add i64 %166, 2
%200 = icmp eq i64 %199, %163
br i1 %200, label %201, label %164
201: ; preds = %164, %155
%202 = phi i64 [ 0, %155 ], [ %198, %164 ]
%203 = icmp eq i64 %160, 0
br i1 %203, label %220, label %204
204: ; preds = %201
%205 = add i64 %202, %128
%206 = trunc i64 %202 to i32
%207 = add i32 %119, %206
%208 = getelementptr inbounds i8, i8* %47, i64 %205
%209 = bitcast i8* %208 to <16 x i8>*
%210 = load <16 x i8>, <16 x i8>* %209
%211 = getelementptr inbounds i8, i8* %208, i64 16
%212 = bitcast i8* %211 to <16 x i8>*
%213 = load <16 x i8>, <16 x i8>* %212
%214 = add i32 %127, %207
%215 = zext i32 %214 to i64
%216 = getelementptr inbounds i8, i8* %47, i64 %215
%217 = bitcast i8* %216 to <16 x i8>*
store <16 x i8> %210, <16 x i8>* %217
%218 = getelementptr inbounds i8, i8* %216, i64 16
%219 = bitcast i8* %218 to <16 x i8>*
store <16 x i8> %213, <16 x i8>* %219
br label %220
220: ; preds = %201, %204
%221 = icmp eq i64 %130, %156
br i1 %221, label %491, label %222
222: ; preds = %220
%223 = add nsw i64 %156, %128
%224 = and i64 %130, 24
%225 = icmp eq i64 %224, 0
br i1 %225, label %249, label %226
226: ; preds = %153, %222
%227 = phi i64 [ %156, %222 ], [ 0, %153 ]
%228 = zext i32 %55 to i64
%229 = zext i32 %119 to i64
%230 = sub nsw i64 %228, %229
%231 = and i64 %230, -8
%232 = add nsw i64 %231, %128
br label %233
233: ; preds = %233, %226
%234 = phi i64 [ %227, %226 ], [ %245, %233 ]
%235 = add i64 %234, %128
%236 = trunc i64 %234 to i32
%237 = add i32 %119, %236
%238 = getelementptr inbounds i8, i8* %47, i64 %235
%239 = bitcast i8* %238 to <8 x i8>*
%240 = load <8 x i8>, <8 x i8>* %239
%241 = add i32 %127, %237
%242 = zext i32 %241 to i64
%243 = getelementptr inbounds i8, i8* %47, i64 %242
%244 = bitcast i8* %243 to <8 x i8>*
store <8 x i8> %240, <8 x i8>* %244
%245 = add nuw i64 %234, 8
%246 = icmp eq i64 %245, %231
br i1 %246, label %247, label %233
247: ; preds = %233
%248 = icmp eq i64 %230, %231
br i1 %248, label %491, label %249
249: ; preds = %141, %132, %126, %222, %247
%250 = phi i64 [ %128, %126 ], [ %128, %141 ], [ %128, %132 ], [ %223, %222 ], [ %232, %247 ]
%251 = sub i64 %129, %250
%252 = xor i64 %250, -1
%253 = add i64 %252, %129
%254 = and i64 %251, 3
%255 = icmp eq i64 %254, 0
br i1 %255, label %268, label %256
256: ; preds = %249, %256
%257 = phi i64 [ %265, %256 ], [ %250, %249 ]
%258 = phi i64 [ %266, %256 ], [ 0, %249 ]
%259 = getelementptr inbounds i8, i8* %47, i64 %257
%260 = load i8, i8* %259
%261 = trunc i64 %257 to i32
%262 = add i32 %127, %261
%263 = zext i32 %262 to i64
%264 = getelementptr inbounds i8, i8* %47, i64 %263
store i8 %260, i8* %264
%265 = add nuw nsw i64 %257, 1
%266 = add i64 %258, 1
%267 = icmp eq i64 %266, %254
br i1 %267, label %268, label %256
268: ; preds = %256, %249
%269 = phi i64 [ %250, %249 ], [ %265, %256 ]
%270 = icmp ult i64 %253, 3
br i1 %270, label %491, label %460
271: ; preds = %118
%272 = add i32 %122, 1
%273 = call i8* @realloc(i8* %47, i32 %272)
%274 = icmp eq i8* %273, null
br i1 %274, label %547, label %275
275: ; preds = %271
%276 = add i32 %55, -1
%277 = icmp ult i32 %276, %119
br i1 %277, label %495, label %278
278: ; preds = %275
%279 = sub i32 %122, %55
%280 = sub i32 0, %119
%281 = sub i32 1, %55
%282 = call i32 @llvm.umax.i32(i32 %280, i32 %281)
%283 = add i32 %282, %55
%284 = icmp ult i32 %283, 4
br i1 %284, label %448, label %285
285: ; preds = %278
%286 = add i32 %55, -2
%287 = add i32 %119, -1
%288 = call i32 @llvm.umin.i32(i32 %287, i32 %286)
%289 = sub i32 %286, %288
%290 = add i32 %42, %55
%291 = add i32 %290, %94
%292 = sub i32 %291, %119
%293 = icmp ugt i32 %289, %292
%294 = icmp ugt i32 %289, %276
%295 = zext i32 %292 to i64
%296 = getelementptr i8, i8* %273, i64 %295
%297 = zext i32 %289 to i64
%298 = sub nsw i64 0, %297
%299 = getelementptr i8, i8* %296, i64 %298
%300 = icmp ugt i8* %299, %296
%301 = zext i32 %276 to i64
%302 = getelementptr i8, i8* %273, i64 %301
%303 = zext i32 %289 to i64
%304 = sub nsw i64 0, %303
%305 = getelementptr i8, i8* %302, i64 %304
%306 = icmp ugt i8* %305, %302
%307 = or i1 %293, %294
%308 = or i1 %307, %300
%309 = or i1 %308, %306
br i1 %309, label %448, label %310
310: ; preds = %285
%311 = add i32 %43, %55
%312 = add i32 %311, %94
%313 = sub i32 %312, %119
%314 = zext i32 %313 to i64
%315 = add i32 %55, -2
%316 = add i32 %119, -1
%317 = call i32 @llvm.umin.i32(i32 %316, i32 %315)
%318 = sub i32 %315, %317
%319 = zext i32 %318 to i64
%320 = sub nsw i64 %314, %319
%321 = getelementptr i8, i8* %273, i64 %320
%322 = getelementptr i8, i8* %273, i64 1
%323 = getelementptr i8, i8* %322, i64 %314
%324 = zext i32 %276 to i64
%325 = sub nsw i64 %324, %319
%326 = getelementptr i8, i8* %273, i64 %325
%327 = getelementptr i8, i8* %273, i64 1
%328 = getelementptr i8, i8* %327, i64 %324
%329 = icmp ult i8* %321, %328
%330 = icmp ult i8* %326, %323
%331 = and i1 %329, %330
br i1 %331, label %448, label %332
332: ; preds = %310
%333 = icmp ult i32 %283, 16
br i1 %333, label %423, label %334
334: ; preds = %332
%335 = and i32 %283, -16
%336 = add i32 %335, -16
%337 = lshr exact i32 %336, 4
%338 = add nuw nsw i32 %337, 1
%339 = and i32 %338, 3
%340 = icmp ult i32 %336, 48
br i1 %340, label %396, label %341
341: ; preds = %334
%342 = and i32 %338, 536870908
%343 = getelementptr inbounds i8, i8* %273, i64 -15
%344 = getelementptr inbounds i8, i8* %273, i64 -15
%345 = getelementptr inbounds i8, i8* %273, i64 -15
%346 = getelementptr inbounds i8, i8* %273, i64 -15
%347 = getelementptr inbounds i8, i8* %273, i64 -15
%348 = getelementptr inbounds i8, i8* %273, i64 -15
%349 = getelementptr inbounds i8, i8* %273, i64 -15
%350 = getelementptr inbounds i8, i8* %273, i64 -15
br label %351
351: ; preds = %351, %341
%352 = phi i32 [ 0, %341 ], [ %393, %351 ]
%353 = phi i32 [ 0, %341 ], [ %394, %351 ]
%354 = sub i32 %276, %352
%355 = zext i32 %354 to i64
%356 = getelementptr inbounds i8, i8* %343, i64 %355
%357 = bitcast i8* %356 to <16 x i8>*
%358 = load <16 x i8>, <16 x i8>* %357
%359 = add i32 %279, %354
%360 = zext i32 %359 to i64
%361 = getelementptr inbounds i8, i8* %344, i64 %360
%362 = bitcast i8* %361 to <16 x i8>*
store <16 x i8> %358, <16 x i8>* %362
%363 = or i32 %352, 16
%364 = sub i32 %276, %363
%365 = zext i32 %364 to i64
%366 = getelementptr inbounds i8, i8* %345, i64 %365
%367 = bitcast i8* %366 to <16 x i8>*
%368 = load <16 x i8>, <16 x i8>* %367
%369 = add i32 %279, %364
%370 = zext i32 %369 to i64
%371 = getelementptr inbounds i8, i8* %346, i64 %370
%372 = bitcast i8* %371 to <16 x i8>*
store <16 x i8> %368, <16 x i8>* %372
%373 = or i32 %352, 32
%374 = sub i32 %276, %373
%375 = zext i32 %374 to i64
%376 = getelementptr inbounds i8, i8* %347, i64 %375
%377 = bitcast i8* %376 to <16 x i8>*
%378 = load <16 x i8>, <16 x i8>* %377
%379 = add i32 %279, %374
%380 = zext i32 %379 to i64
%381 = getelementptr inbounds i8, i8* %348, i64 %380
%382 = bitcast i8* %381 to <16 x i8>*
store <16 x i8> %378, <16 x i8>* %382
%383 = or i32 %352, 48
%384 = sub i32 %276, %383
%385 = zext i32 %384 to i64
%386 = getelementptr inbounds i8, i8* %349, i64 %385
%387 = bitcast i8* %386 to <16 x i8>*
%388 = load <16 x i8>, <16 x i8>* %387
%389 = add i32 %279, %384
%390 = zext i32 %389 to i64
%391 = getelementptr inbounds i8, i8* %350, i64 %390
%392 = bitcast i8* %391 to <16 x i8>*
store <16 x i8> %388, <16 x i8>* %392
%393 = add nuw i32 %352, 64
%394 = add i32 %353, 4
%395 = icmp eq i32 %394, %342
br i1 %395, label %396, label %351
396: ; preds = %351, %334
%397 = phi i32 [ 0, %334 ], [ %393, %351 ]
%398 = icmp eq i32 %339, 0
br i1 %398, label %417, label %399
399: ; preds = %396
%400 = getelementptr inbounds i8, i8* %273, i64 -15
%401 = getelementptr inbounds i8, i8* %273, i64 -15
br label %402
402: ; preds = %402, %399
%403 = phi i32 [ %397, %399 ], [ %414, %402 ]
%404 = phi i32 [ 0, %399 ], [ %415, %402 ]
%405 = sub i32 %276, %403
%406 = zext i32 %405 to i64
%407 = getelementptr inbounds i8, i8* %400, i64 %406
%408 = bitcast i8* %407 to <16 x i8>*
%409 = load <16 x i8>, <16 x i8>* %408
%410 = add i32 %279, %405
%411 = zext i32 %410 to i64
%412 = getelementptr inbounds i8, i8* %401, i64 %411
%413 = bitcast i8* %412 to <16 x i8>*
store <16 x i8> %409, <16 x i8>* %413
%414 = add nuw i32 %403, 16
%415 = add i32 %404, 1
%416 = icmp eq i32 %415, %339
br i1 %416, label %417, label %402
417: ; preds = %402, %396
%418 = icmp eq i32 %283, %335
br i1 %418, label %495, label %419
419: ; preds = %417
%420 = sub i32 %276, %335
%421 = and i32 %283, 12
%422 = icmp eq i32 %421, 0
br i1 %422, label %448, label %423
423: ; preds = %332, %419
%424 = phi i32 [ %335, %419 ], [ 0, %332 ]
%425 = sub i32 0, %119
%426 = sub i32 1, %55
%427 = call i32 @llvm.umax.i32(i32 %425, i32 %426)
%428 = add i32 %427, %55
%429 = and i32 %428, -4
%430 = sub i32 %276, %429
%431 = getelementptr inbounds i8, i8* %273, i64 -3
%432 = getelementptr inbounds i8, i8* %273, i64 -3
br label %433
433: ; preds = %433, %423
%434 = phi i32 [ %424, %423 ], [ %444, %433 ]
%435 = sub i32 %276, %434
%436 = zext i32 %435 to i64
%437 = getelementptr inbounds i8, i8* %431, i64 %436
%438 = bitcast i8* %437 to <4 x i8>*
%439 = load <4 x i8>, <4 x i8>* %438
%440 = add i32 %279, %435
%441 = zext i32 %440 to i64
%442 = getelementptr inbounds i8, i8* %432, i64 %441
%443 = bitcast i8* %442 to <4 x i8>*
store <4 x i8> %439, <4 x i8>* %443
%444 = add nuw i32 %434, 4
%445 = icmp eq i32 %444, %429
br i1 %445, label %446, label %433
446: ; preds = %433
%447 = icmp eq i32 %428, %429
br i1 %447, label %495, label %448
448: ; preds = %310, %285, %278, %419, %446
%449 = phi i32 [ %276, %278 ], [ %276, %310 ], [ %276, %285 ], [ %420, %419 ], [ %430, %446 ]
br label %450
450: ; preds = %448, %450
%451 = phi i32 [ %458, %450 ], [ %449, %448 ]
%452 = zext i32 %451 to i64
%453 = getelementptr inbounds i8, i8* %273, i64 %452
%454 = load i8, i8* %453
%455 = add i32 %279, %451
%456 = zext i32 %455 to i64
%457 = getelementptr inbounds i8, i8* %273, i64 %456
store i8 %454, i8* %457
%458 = add i32 %451, -1
%459 = icmp ult i32 %458, %119
br i1 %459, label %495, label %450
460: ; preds = %268, %460
%461 = phi i64 [ %489, %460 ], [ %269, %268 ]
%462 = getelementptr inbounds i8, i8* %47, i64 %461
%463 = load i8, i8* %462
%464 = trunc i64 %461 to i32
%465 = add i32 %127, %464
%466 = zext i32 %465 to i64
%467 = getelementptr inbounds i8, i8* %47, i64 %466
store i8 %463, i8* %467
%468 = add nuw nsw i64 %461, 1
%469 = getelementptr inbounds i8, i8* %47, i64 %468
%470 = load i8, i8* %469
%471 = trunc i64 %468 to i32
%472 = add i32 %127, %471
%473 = zext i32 %472 to i64
%474 = getelementptr inbounds i8, i8* %47, i64 %473
store i8 %470, i8* %474
%475 = add nuw nsw i64 %461, 2
%476 = getelementptr inbounds i8, i8* %47, i64 %475
%477 = load i8, i8* %476
%478 = trunc i64 %475 to i32
%479 = add i32 %127, %478
%480 = zext i32 %479 to i64
%481 = getelementptr inbounds i8, i8* %47, i64 %480
store i8 %477, i8* %481
%482 = add nuw nsw i64 %461, 3
%483 = getelementptr inbounds i8, i8* %47, i64 %482
%484 = load i8, i8* %483
%485 = trunc i64 %482 to i32
%486 = add i32 %127, %485
%487 = zext i32 %486 to i64
%488 = getelementptr inbounds i8, i8* %47, i64 %487
store i8 %484, i8* %488
%489 = add nuw nsw i64 %461, 4
%490 = icmp eq i64 %489, %129
br i1 %490, label %491, label %460
491: ; preds = %268, %460, %220, %247, %124
%492 = add i32 %122, 1
%493 = call i8* @realloc(i8* %47, i32 %492)
%494 = icmp eq i8* %493, null
br i1 %494, label %547, label %495
495: ; preds = %450, %417, %446, %275, %491
%496 = phi i8* [ %493, %491 ], [ %273, %275 ], [ %273, %446 ], [ %273, %417 ], [ %273, %450 ]
%497 = load i8, i8* %7
%498 = icmp eq i8 %497, 0
br i1 %498, label %510, label %499
499: ; preds = %495, %499
%500 = phi i8 [ %508, %499 ], [ %497, %495 ]
%501 = phi i32 [ %505, %499 ], [ 0, %495 ]
%502 = add i32 %501, %21
%503 = zext i32 %502 to i64
%504 = getelementptr inbounds i8, i8* %496, i64 %503
store i8 %500, i8* %504
%505 = add i32 %501, 1
%506 = zext i32 %505 to i64
%507 = getelementptr inbounds [80 x i8], [80 x i8]* %4, i64 0, i64 %506
%508 = load i8, i8* %507
%509 = icmp eq i8 %508, 0
br i1 %509, label %510, label %499
510: ; preds = %499, %495
%511 = zext i32 %122 to i64
%512 = getelementptr inbounds i8, i8* %496, i64 %511
store i8 0, i8* %512
br label %524
513: ; preds = %51
%514 = load i8, i8* %46
%515 = call i64 @strchr(i8* %5, i8 signext %514)
%516 = icmp eq i64 %515, 0
br i1 %516, label %524, label %517
517: ; preds = %513
%518 = add i32 %48, -1
%519 = zext i32 %518 to i64
%520 = getelementptr inbounds i8, i8* %47, i64 %519
%521 = load i8, i8* %520
%522 = call i64 @strchr(i8* %5, i8 signext %521)
%523 = icmp eq i64 %522, 0
br i1 %523, label %533, label %524
524: ; preds = %44, %510, %517, %513
%525 = phi double [ %92, %510 ], [ %49, %517 ], [ %49, %513 ], [ %49, %44 ]
%526 = phi i32 [ %21, %510 ], [ %48, %517 ], [ %48, %513 ], [ 0, %44 ]
%527 = phi i8* [ %496, %510 ], [ %47, %517 ], [ %47, %513 ], [ %47, %44 ]
%528 = add i32 %526, 1
%529 = zext i32 %528 to i64
%530 = getelementptr inbounds i8, i8* %527, i64 %529
%531 = load i8, i8* %530
%532 = icmp eq i8 %531, 0
br i1 %532, label %533, label %44
533: ; preds = %517, %524, %35
%534 = phi i32 [ %21, %35 ], [ %528, %524 ], [ %48, %517 ]
%535 = phi i8* [ %20, %35 ], [ %527, %524 ], [ %47, %517 ]
%536 = add i32 %534, 1
%537 = zext i32 %536 to i64
%538 = getelementptr inbounds i8, i8* %535, i64 %537
%539 = load i8, i8* %538
%540 = icmp eq i8 %539, 0
br i1 %540, label %541, label %17
541: ; preds = %533, %8
%542 = phi i8* [ %9, %8 ], [ %535, %533 ]
%543 = add nuw nsw i32 %10, 1
%544 = icmp eq i32 %543, 4
br i1 %544, label %545, label %8
545: ; preds = %541
%546 = call double @atof(i8* %542)
br label %547
547: ; preds = %491, %271, %545
%548 = phi double [ %546, %545 ], [ 0.000000e+00, %271 ], [ 0.000000e+00, %491 ]
ret double %548
}