#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 */
typedef int /*<<< orphan*/ input;

/* Variables and functions */
int /*<<< orphan*/ S(char *, char *, char const *, ...);
double atof(char *);
scalar_t__ isdigit(unsigned char);
unsigned int strlen(unsigned char *);
int /*<<< orphan*/ strncpy(unsigned char *, char *, int);
void do_math(const char *who, char *target, char *math) {
  char number_string[512] = {0};
  char op = 0;
  unsigned char input[512] = {0};
  unsigned int index = 0;
  unsigned int to = 0;
  unsigned int input_length = 0;
  unsigned int number_length = 0;
  double result = 0.0;
  double number = 0.0;
  strncpy(input, math, sizeof(input));
  input_length = strlen(input);
  for (to = 0, index = 0; index <= input_length; index++)
    if (*(input + index) != ' ')
      *(input + to++) = *(input + index);
  input_length = strlen(input);
  index = 0;
  if (input[index] == '=')
    index++;
  else {
    number_length = 0;
    if (input[index] == '+' || input[index] == '-')
      *(number_string + number_length++) = *(input + index++);
    for (; isdigit(*(input + index)); index++)
      *(number_string + number_length++) = *(input + index);
    if (*(input + index) == '.') {
      *(number_string + number_length++) = *(input + index++);
      for (; isdigit(*(input + index)); index++)
        *(number_string + number_length++) = *(input + index);
    }
    *(number_string + number_length) = '\0';
    if (number_length > 0)
      result = atof(number_string);
  }
  for (; index < input_length;) {
    op = *(input + index++);
    number_length = 0;
    if (input[index] == '+' || input[index] == '-')
      *(number_string + number_length++) = *(input + index++);
    for (; isdigit(*(input + index)); index++)
      *(number_string + number_length++) = *(input + index);
    if (*(input + index) == '.') {
      *(number_string + number_length++) = *(input + index++);
      for (; isdigit(*(input + index)); index++)
        *(number_string + number_length++) = *(input + index);
    }
    *(number_string + number_length) = '\0';
    number = atof(number_string);
    switch (op) {
    case '+':
      result += number;
      break;
    case '-':
      result -= number;
      break;
    case '*':
      result *= number;
      break;
    case '/':
      if (number == 0) {
        S("PRIVMSG %s :%s: Division by zero error!\n", target, who);
        return;
      } else
        result /= number;
      break;
    case '%':
      if ((long)number == 0) {
        S("PRIVMSG %s :%s: Division by zero error!\n", target, who);
        return;
      } else
        result = (double)((long)result % (long)number);
      break;
    default:
      S("PRIVMSG %s :%s: Illegal operation!\n", target, who);
      return;
    }
  }
  S("PRIVMSG %s :%s\2:\2 %f\n", target, who, result);
}


x86 assembly (clang, -O0):
<do_math>:
push   %rbp
mov    %rsp,%rbp
sub    $0x460,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
lea    -0x220(%rbp),%rdi
xor    %esi,%esi
mov    $0x200,%edx
call   1070 <memset@plt>
movb   $0x0,-0x221(%rbp)
lea    -0x430(%rbp),%rdi
xor    %esi,%esi
mov    $0x200,%edx
call   1070 <memset@plt>
movl   $0x0,-0x434(%rbp)
movl   $0x0,-0x438(%rbp)
movl   $0x0,-0x43c(%rbp)
movl   $0x0,-0x440(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x448(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x450(%rbp)
ff
lea    -0x430(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    $0x200,%edx
call   1030 <strncpy@plt>
lea    -0x430(%rbp),%rdi
call   1060 <strlen@plt>
mov    %eax,-0x43c(%rbp)
movl   $0x0,-0x438(%rbp)
movl   $0x0,-0x434(%rbp)
mov    -0x434(%rbp),%eax
cmp    -0x43c(%rbp),%eax
ja     1286 <do_math+0x126>
mov    -0x434(%rbp),%eax
movzbl -0x430(%rbp,%rax,1),%eax
ff
cmp    $0x20,%eax
je     126d <do_math+0x10d>
mov    -0x434(%rbp),%eax
mov    -0x430(%rbp,%rax,1),%cl
mov    -0x438(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x438(%rbp)
mov    %eax,%eax
mov    %cl,-0x430(%rbp,%rax,1)
jmp    1272 <do_math+0x112>
mov    -0x434(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x434(%rbp)
jmp    121d <do_math+0xbd>
lea    -0x430(%rbp),%rdi
call   1060 <strlen@plt>
mov    %eax,-0x43c(%rbp)
movl   $0x0,-0x434(%rbp)
mov    -0x434(%rbp),%eax
movzbl -0x430(%rbp,%rax,1),%eax
ff
cmp    $0x3d,%eax
jne    12cd <do_math+0x16d>
mov    -0x434(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x434(%rbp)
jmp    1472 <do_math+0x312>
movl   $0x0,-0x440(%rbp)
mov    -0x434(%rbp),%eax
movzbl -0x430(%rbp,%rax,1),%eax
ff
cmp    $0x2b,%eax
je     1305 <do_math+0x1a5>
mov    -0x434(%rbp),%eax
movzbl -0x430(%rbp,%rax,1),%eax
ff
cmp    $0x2d,%eax
jne    1339 <do_math+0x1d9>
mov    -0x434(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x434(%rbp)
mov    %eax,%eax
mov    -0x430(%rbp,%rax,1),%cl
mov    -0x440(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x440(%rbp)
mov    %eax,%eax
mov    %cl,-0x220(%rbp,%rax,1)
jmp    133e <do_math+0x1de>
mov    -0x434(%rbp),%eax
movzbl -0x430(%rbp,%rax,1),%edi
ff
call   1040 <isdigit@plt>
cmp    $0x0,%rax
je     1396 <do_math+0x236>
mov    -0x434(%rbp),%eax
mov    -0x430(%rbp,%rax,1),%cl
mov    -0x440(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x440(%rbp)
mov    %eax,%eax
mov    %cl,-0x220(%rbp,%rax,1)
mov    -0x434(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x434(%rbp)
jmp    133e <do_math+0x1de>
mov    -0x434(%rbp),%eax
movzbl -0x430(%rbp,%rax,1),%eax
ff
cmp    $0x2e,%eax
jne    143e <do_math+0x2de>
mov    -0x434(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x434(%rbp)
mov    %eax,%eax
mov    -0x430(%rbp,%rax,1),%cl
mov    -0x440(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x440(%rbp)
mov    %eax,%eax
mov    %cl,-0x220(%rbp,%rax,1)
mov    -0x434(%rbp),%eax
movzbl -0x430(%rbp,%rax,1),%edi
ff
call   1040 <isdigit@plt>
cmp    $0x0,%rax
je     1439 <do_math+0x2d9>
mov    -0x434(%rbp),%eax
mov    -0x430(%rbp,%rax,1),%cl
mov    -0x440(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x440(%rbp)
mov    %eax,%eax
mov    %cl,-0x220(%rbp,%rax,1)
mov    -0x434(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x434(%rbp)
jmp    13e1 <do_math+0x281>
jmp    143e <do_math+0x2de>
mov    -0x440(%rbp),%eax
movb   $0x0,-0x220(%rbp,%rax,1)
cmpl   $0x0,-0x440(%rbp)
jbe    146d <do_math+0x30d>
lea    -0x220(%rbp),%rdi
call   1050 <atof@plt>
movsd  %xmm0,-0x448(%rbp)
ff
jmp    1472 <do_math+0x312>
jmp    1477 <do_math+0x317>
mov    -0x434(%rbp),%eax
cmp    -0x43c(%rbp),%eax
jae    1798 <do_math+0x638>
mov    -0x434(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x434(%rbp)
mov    %eax,%eax
mov    -0x430(%rbp,%rax,1),%al
mov    %al,-0x221(%rbp)
movl   $0x0,-0x440(%rbp)
mov    -0x434(%rbp),%eax
movzbl -0x430(%rbp,%rax,1),%eax
ff
cmp    $0x2b,%eax
je     14e1 <do_math+0x381>
mov    -0x434(%rbp),%eax
movzbl -0x430(%rbp,%rax,1),%eax
ff
cmp    $0x2d,%eax
jne    1515 <do_math+0x3b5>
mov    -0x434(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x434(%rbp)
mov    %eax,%eax
mov    -0x430(%rbp,%rax,1),%cl
mov    -0x440(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x440(%rbp)
mov    %eax,%eax
mov    %cl,-0x220(%rbp,%rax,1)
jmp    151a <do_math+0x3ba>
mov    -0x434(%rbp),%eax
movzbl -0x430(%rbp,%rax,1),%edi
ff
call   1040 <isdigit@plt>
cmp    $0x0,%rax
je     1572 <do_math+0x412>
mov    -0x434(%rbp),%eax
mov    -0x430(%rbp,%rax,1),%cl
mov    -0x440(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x440(%rbp)
mov    %eax,%eax
mov    %cl,-0x220(%rbp,%rax,1)
mov    -0x434(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x434(%rbp)
jmp    151a <do_math+0x3ba>
mov    -0x434(%rbp),%eax
movzbl -0x430(%rbp,%rax,1),%eax
ff
cmp    $0x2e,%eax
jne    161a <do_math+0x4ba>
mov    -0x434(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x434(%rbp)
mov    %eax,%eax
mov    -0x430(%rbp,%rax,1),%cl
mov    -0x440(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x440(%rbp)
mov    %eax,%eax
mov    %cl,-0x220(%rbp,%rax,1)
mov    -0x434(%rbp),%eax
movzbl -0x430(%rbp,%rax,1),%edi
ff
call   1040 <isdigit@plt>
cmp    $0x0,%rax
je     1615 <do_math+0x4b5>
mov    -0x434(%rbp),%eax
mov    -0x430(%rbp,%rax,1),%cl
mov    -0x440(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x440(%rbp)
mov    %eax,%eax
mov    %cl,-0x220(%rbp,%rax,1)
mov    -0x434(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x434(%rbp)
jmp    15bd <do_math+0x45d>
jmp    161a <do_math+0x4ba>
mov    -0x440(%rbp),%eax
movb   $0x0,-0x220(%rbp,%rax,1)
lea    -0x220(%rbp),%rdi
call   1050 <atof@plt>
movsd  %xmm0,-0x450(%rbp)
ff
movsbl -0x221(%rbp),%eax
add    $0xffffffdb,%eax
mov    %eax,%ecx
mov    %rcx,-0x458(%rbp)
sub    $0xa,%eax
ja     1778 <do_math+0x618>
mov    -0x458(%rbp),%rax
lea    0x99a(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movsd  -0x450(%rbp),%xmm0
ff
addsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x448(%rbp)
ff
jmp    1793 <do_math+0x633>
movsd  -0x450(%rbp),%xmm1
ff
movsd  -0x448(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x448(%rbp)
ff
jmp    1793 <do_math+0x633>
movsd  -0x450(%rbp),%xmm0
ff
mulsd  -0x448(%rbp),%xmm0
ff
movsd  %xmm0,-0x448(%rbp)
ff
jmp    1793 <do_math+0x633>
movsd  -0x450(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1700 <do_math+0x5a0>
jp     1700 <do_math+0x5a0>
mov    -0x10(%rbp),%rsi
mov    -0x8(%rbp),%rdx
lea    0x938(%rip),%rdi
mov    $0x0,%al
call   1080 <S@plt>
jmp    17b6 <do_math+0x656>
movsd  -0x450(%rbp),%xmm1
ff
movsd  -0x448(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x448(%rbp)
ff
jmp    1793 <do_math+0x633>
cvttsd2si -0x450(%rbp),%rax
ff ff
cmp    $0x0,%rax
jne    174f <do_math+0x5ef>
mov    -0x10(%rbp),%rsi
mov    -0x8(%rbp),%rdx
lea    0x8e9(%rip),%rdi
mov    $0x0,%al
call   1080 <S@plt>
jmp    17b6 <do_math+0x656>
cvttsd2si -0x448(%rbp),%rax
ff ff
cvttsd2si -0x450(%rbp),%rcx
ff ff
cqto
idiv   %rcx
cvtsi2sd %rdx,%xmm0
movsd  %xmm0,-0x448(%rbp)
ff
jmp    1793 <do_math+0x633>
mov    -0x10(%rbp),%rsi
mov    -0x8(%rbp),%rdx
lea    0x8ce(%rip),%rdi
mov    $0x0,%al
call   1080 <S@plt>
jmp    17b6 <do_math+0x656>
jmp    1477 <do_math+0x317>
mov    -0x10(%rbp),%rsi
mov    -0x8(%rbp),%rdx
movsd  -0x448(%rbp),%xmm0
ff
lea    0x8ca(%rip),%rdi
mov    $0x1,%al
call   1080 <S@plt>
add    $0x460,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<do_math>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x428,%rsp
mov    %rdx,%r14
mov    %rsi,%r12
mov    %rdi,%r15
lea    0x220(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x200,%edx
xor    %esi,%esi
call   1070 <memset@plt>
lea    0x20(%rsp),%rbp
mov    $0x200,%edx
mov    %rbp,%rdi
xor    %esi,%esi
call   1070 <memset@plt>
mov    %rbp,%rdi
mov    %r14,%rsi
mov    $0x200,%edx
call   1030 <strncpy@plt>
mov    %rbp,%rdi
call   1060 <strlen@plt>
lea    0x1(%rax),%esi
test   %eax,%eax
je     1201 <do_math+0xa1>
mov    %esi,%edx
and    $0xfffffffe,%edx
xor    %eax,%eax
xor    %ebx,%ebx
jmp    11d9 <do_math+0x79>
xchg   %ax,%ax
add    $0x2,%rax
cmp    %rax,%rdx
je     1203 <do_math+0xa3>
movzbl 0x20(%rsp,%rax,1),%ecx
cmp    $0x20,%cl
je     11ec <do_math+0x8c>
mov    %ebx,%edi
add    $0x1,%ebx
mov    %cl,0x20(%rsp,%rdi,1)
movzbl 0x21(%rsp,%rax,1),%ecx
cmp    $0x20,%cl
je     11d0 <do_math+0x70>
mov    %ebx,%edi
add    $0x1,%ebx
mov    %cl,0x20(%rsp,%rdi,1)
jmp    11d0 <do_math+0x70>
xor    %eax,%eax
test   $0x1,%sil
je     1217 <do_math+0xb7>
mov    0x20(%rsp,%rax,1),%al
cmp    $0x20,%al
je     1217 <do_math+0xb7>
mov    %ebx,%ecx
mov    %al,0x20(%rsp,%rcx,1)
lea    0x20(%rsp),%rdi
call   1060 <strlen@plt>
mov    %eax,%r13d
xorpd  %xmm0,%xmm0
mov    0x20(%rsp),%al
cmp    $0x2b,%al
je     123e <do_math+0xde>
cmp    $0x3d,%al
je     130a <do_math+0x1aa>
xor    %ebx,%ebx
cmp    $0x2d,%al
jne    124e <do_math+0xee>
mov    %al,0x220(%rsp)
mov    $0x1,%ebx
mov    0x21(%rsp),%al
mov    %ebx,%ecx
lea    (%rsp,%rcx,1),%rbp
add    $0x20,%rbp
movzbl %al,%edi
nopl   0x0(%rax,%rax,1)
call   1040 <isdigit@plt>
test   %rax,%rax
je     1289 <do_math+0x129>
movzbl 0x0(%rbp),%eax
mov    %ebx,%ecx
add    $0x1,%ebx
mov    %al,0x220(%rsp,%rcx,1)
lea    (%rsp,%rbx,1),%rbp
add    $0x20,%rbp
movzbl 0x20(%rsp,%rbx,1),%edi
jmp    1260 <do_math+0x100>
cmpb   $0x2e,0x0(%rbp)
jne    12e7 <do_math+0x187>
mov    %ebx,%eax
movb   $0x2e,0x220(%rsp,%rax,1)
2e
add    $0x1,%ebx
movzbl 0x20(%rsp,%rbx,1),%edi
call   1040 <isdigit@plt>
test   %rax,%rax
je     12e7 <do_math+0x187>
lea    (%rsp,%rbx,1),%rbp
add    $0x20,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl 0x0(%rbp),%eax
mov    %ebx,%ecx
mov    %al,0x220(%rsp,%rcx,1)
add    $0x1,%ebx
lea    (%rsp,%rbx,1),%rbp
add    $0x20,%rbp
movzbl 0x20(%rsp,%rbx,1),%edi
call   1040 <isdigit@plt>
test   %rax,%rax
jne    12c0 <do_math+0x160>
mov    %ebx,%eax
movb   $0x0,0x220(%rsp,%rax,1)
test   %ebx,%ebx
je     1304 <do_math+0x1a4>
lea    0x220(%rsp),%rdi
call   1050 <atof@plt>
jmp    130f <do_math+0x1af>
xorpd  %xmm0,%xmm0
jmp    130f <do_math+0x1af>
mov    $0x1,%ebx
cmp    %r13d,%ebx
mov    %r15,0x18(%rsp)
mov    %r12,0x10(%rsp)
jb     135d <do_math+0x1fd>
lea    0xd5c(%rip),%rdi
mov    0x10(%rsp),%rsi
mov    0x18(%rsp),%rdx
mov    $0x1,%al
call   1080 <S@plt>
add    $0x428,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movsd  0x8(%rsp),%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
mov    %r13d,%esi
cmp    %esi,%ebx
jae    131e <do_math+0x1be>
mov    %ebx,%eax
mov    0x21(%rsp,%rax,1),%cl
cmp    $0x2d,%cl
movsd  %xmm0,0x8(%rsp)
je     1377 <do_math+0x217>
lea    0x1(%rax),%rdx
cmp    $0x2b,%cl
jne    1390 <do_math+0x230>
add    $0x2,%ebx
mov    %cl,0x220(%rsp)
mov    0x20(%rsp,%rbx,1),%cl
mov    $0x1,%r15d
mov    %rbx,%rdx
jmp    1395 <do_math+0x235>
mov    %edx,%ebx
xor    %r15d,%r15d
movsbl 0x20(%rsp,%rax,1),%r14d
lea    (%rsp,%rdx,1),%r12
add    $0x20,%r12
movzbl %cl,%edi
cs nopw 0x0(%rax,%rax,1)
call   1040 <isdigit@plt>
test   %rax,%rax
je     13e0 <do_math+0x280>
movzbl (%r12),%eax
mov    %r15d,%ecx
add    $0x1,%r15d
mov    %al,0x220(%rsp,%rcx,1)
add    $0x1,%ebx
lea    (%rsp,%rbx,1),%r12
add    $0x20,%r12
movzbl 0x20(%rsp,%rbx,1),%edi
jmp    13b0 <do_math+0x250>
nop
cmpb   $0x2e,(%r12)
jne    143c <do_math+0x2dc>
mov    %r15d,%eax
movb   $0x2e,0x220(%rsp,%rax,1)
2e
add    $0x1,%r15d
add    $0x1,%ebx
movzbl 0x20(%rsp,%rbx,1),%edi
call   1040 <isdigit@plt>
test   %rax,%rax
je     143c <do_math+0x2dc>
lea    (%rsp,%rbx,1),%rbp
add    $0x20,%rbp
movzbl 0x0(%rbp),%eax
mov    %r15d,%ecx
mov    %al,0x220(%rsp,%rcx,1)
add    $0x1,%r15d
add    $0x1,%ebx
lea    (%rsp,%rbx,1),%rbp
add    $0x20,%rbp
movzbl 0x20(%rsp,%rbx,1),%edi
call   1040 <isdigit@plt>
test   %rax,%rax
jne    1410 <do_math+0x2b0>
mov    %r15d,%eax
movb   $0x0,0x220(%rsp,%rax,1)
lea    0x220(%rsp),%rdi
call   1050 <atof@plt>
add    $0xffffffdb,%r14d
cmp    $0xa,%r14d
ja     14f4 <do_math+0x394>
lea    0xb9f(%rip),%rcx
movslq (%rcx,%r14,4),%rax
add    %rcx,%rax
jmp    *%rax
cvttsd2si %xmm0,%rcx
test   %rcx,%rcx
je     14eb <do_math+0x38b>
cvttsd2si 0x8(%rsp),%rax
mov    %rax,%rdx
or     %rcx,%rdx
shr    $0x20,%rdx
mov    %r13d,%esi
je     14d2 <do_math+0x372>
cqto
idiv   %rcx
jmp    14d6 <do_math+0x376>
movsd  0x8(%rsp),%xmm1
mulsd  %xmm0,%xmm1
jmp    1352 <do_math+0x1f2>
movsd  0x8(%rsp),%xmm1
subsd  %xmm0,%xmm1
jmp    1352 <do_math+0x1f2>
ucomisd 0xb41(%rip),%xmm0
jne    14c3 <do_math+0x363>
jnp    14eb <do_math+0x38b>
movsd  0x8(%rsp),%xmm1
divsd  %xmm0,%xmm1
jmp    1352 <do_math+0x1f2>
xor    %edx,%edx
div    %ecx
xorps  %xmm0,%xmm0
cvtsi2sd %rdx,%xmm0
cmp    %esi,%ebx
jb     135d <do_math+0x1fd>
jmp    131e <do_math+0x1be>
lea    0xb42(%rip),%rdi
jmp    14fb <do_math+0x39b>
lea    0xb62(%rip),%rdi
mov    0x10(%rsp),%rsi
mov    0x18(%rsp),%rdx
xor    %eax,%eax
call   1080 <S@plt>
jmp    1336 <do_math+0x1d6>

LLVM IR (-O0):
@.str = [41 x i8] c"PRIVMSG %s :%s: Division by zero error!\0A\00"
@.str.1 = [36 x i8] c"PRIVMSG %s :%s: Illegal operation!\0A\00"
@.str.2 = [22 x i8] c"PRIVMSG %s :%s\02:\02 %f\0A\00"
define void @do_math(i8* %0, i8* %1, i8* %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca [512 x i8]
%8 = alloca i8
%9 = alloca [512 x i8]
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca double
%15 = alloca double
store i8* %0, i8** %4
store i8* %1, i8** %5
store i8* %2, i8** %6
%16 = bitcast [512 x i8]* %7 to i8*
store i8 0, i8* %8
%17 = bitcast [512 x i8]* %9 to i8*
store i32 0, i32* %10
store i32 0, i32* %11
store i32 0, i32* %12
store i32 0, i32* %13
store double 0.000000e+00, double* %14
store double 0.000000e+00, double* %15
%18 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 0
%19 = load i8*, i8** %6
%20 = call i32 @strncpy(i8* %18, i8* %19, i32 512)
%21 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 0
%22 = call i32 @strlen(i8* %21)
store i32 %22, i32* %12
store i32 0, i32* %11
store i32 0, i32* %10
br label %23
23: ; preds = %47, %3
%24 = load i32, i32* %10
%25 = load i32, i32* %12
%26 = icmp ule i32 %24, %25
br i1 %26, label %27, label %50
27: ; preds = %23
%28 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 0
%29 = load i32, i32* %10
%30 = zext i32 %29 to i64
%31 = getelementptr inbounds i8, i8* %28, i64 %30
%32 = load i8, i8* %31
%33 = zext i8 %32 to i32
%34 = icmp ne i32 %33, 32
br i1 %34, label %35, label %46
35: ; preds = %27
%36 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 0
%37 = load i32, i32* %10
%38 = zext i32 %37 to i64
%39 = getelementptr inbounds i8, i8* %36, i64 %38
%40 = load i8, i8* %39
%41 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 0
%42 = load i32, i32* %11
%43 = add i32 %42, 1
store i32 %43, i32* %11
%44 = zext i32 %42 to i64
%45 = getelementptr inbounds i8, i8* %41, i64 %44
store i8 %40, i8* %45
br label %46
46: ; preds = %35, %27
br label %47
47: ; preds = %46
%48 = load i32, i32* %10
%49 = add i32 %48, 1
store i32 %49, i32* %10
br label %23
50: ; preds = %23
%51 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 0
%52 = call i32 @strlen(i8* %51)
store i32 %52, i32* %12
store i32 0, i32* %10
%53 = load i32, i32* %10
%54 = zext i32 %53 to i64
%55 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 %54
%56 = load i8, i8* %55
%57 = zext i8 %56 to i32
%58 = icmp eq i32 %57, 61
br i1 %58, label %59, label %62
59: ; preds = %50
%60 = load i32, i32* %10
%61 = add i32 %60, 1
store i32 %61, i32* %10
br label %165
62: ; preds = %50
store i32 0, i32* %13
%63 = load i32, i32* %10
%64 = zext i32 %63 to i64
%65 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 %64
%66 = load i8, i8* %65
%67 = zext i8 %66 to i32
%68 = icmp eq i32 %67, 43
br i1 %68, label %76, label %69
69: ; preds = %62
%70 = load i32, i32* %10
%71 = zext i32 %70 to i64
%72 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 %71
%73 = load i8, i8* %72
%74 = zext i8 %73 to i32
%75 = icmp eq i32 %74, 45
br i1 %75, label %76, label %88
76: ; preds = %69, %62
%77 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 0
%78 = load i32, i32* %10
%79 = add i32 %78, 1
store i32 %79, i32* %10
%80 = zext i32 %78 to i64
%81 = getelementptr inbounds i8, i8* %77, i64 %80
%82 = load i8, i8* %81
%83 = getelementptr inbounds [512 x i8], [512 x i8]* %7, i64 0, i64 0
%84 = load i32, i32* %13
%85 = add i32 %84, 1
store i32 %85, i32* %13
%86 = zext i32 %84 to i64
%87 = getelementptr inbounds i8, i8* %83, i64 %86
store i8 %82, i8* %87
br label %88
88: ; preds = %76, %69
br label %89
89: ; preds = %108, %88
%90 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 0
%91 = load i32, i32* %10
%92 = zext i32 %91 to i64
%93 = getelementptr inbounds i8, i8* %90, i64 %92
%94 = load i8, i8* %93
%95 = call i64 @isdigit(i8 zeroext %94)
%96 = icmp ne i64 %95, 0
br i1 %96, label %97, label %111
97: ; preds = %89
%98 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 0
%99 = load i32, i32* %10
%100 = zext i32 %99 to i64
%101 = getelementptr inbounds i8, i8* %98, i64 %100
%102 = load i8, i8* %101
%103 = getelementptr inbounds [512 x i8], [512 x i8]* %7, i64 0, i64 0
%104 = load i32, i32* %13
%105 = add i32 %104, 1
store i32 %105, i32* %13
%106 = zext i32 %104 to i64
%107 = getelementptr inbounds i8, i8* %103, i64 %106
store i8 %102, i8* %107
br label %108
108: ; preds = %97
%109 = load i32, i32* %10
%110 = add i32 %109, 1
store i32 %110, i32* %10
br label %89
111: ; preds = %89
%112 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 0
%113 = load i32, i32* %10
%114 = zext i32 %113 to i64
%115 = getelementptr inbounds i8, i8* %112, i64 %114
%116 = load i8, i8* %115
%117 = zext i8 %116 to i32
%118 = icmp eq i32 %117, 46
br i1 %118, label %119, label %154
119: ; preds = %111
%120 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 0
%121 = load i32, i32* %10
%122 = add i32 %121, 1
store i32 %122, i32* %10
%123 = zext i32 %121 to i64
%124 = getelementptr inbounds i8, i8* %120, i64 %123
%125 = load i8, i8* %124
%126 = getelementptr inbounds [512 x i8], [512 x i8]* %7, i64 0, i64 0
%127 = load i32, i32* %13
%128 = add i32 %127, 1
store i32 %128, i32* %13
%129 = zext i32 %127 to i64
%130 = getelementptr inbounds i8, i8* %126, i64 %129
store i8 %125, i8* %130
br label %131
131: ; preds = %150, %119
%132 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 0
%133 = load i32, i32* %10
%134 = zext i32 %133 to i64
%135 = getelementptr inbounds i8, i8* %132, i64 %134
%136 = load i8, i8* %135
%137 = call i64 @isdigit(i8 zeroext %136)
%138 = icmp ne i64 %137, 0
br i1 %138, label %139, label %153
139: ; preds = %131
%140 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 0
%141 = load i32, i32* %10
%142 = zext i32 %141 to i64
%143 = getelementptr inbounds i8, i8* %140, i64 %142
%144 = load i8, i8* %143
%145 = getelementptr inbounds [512 x i8], [512 x i8]* %7, i64 0, i64 0
%146 = load i32, i32* %13
%147 = add i32 %146, 1
store i32 %147, i32* %13
%148 = zext i32 %146 to i64
%149 = getelementptr inbounds i8, i8* %145, i64 %148
store i8 %144, i8* %149
br label %150
150: ; preds = %139
%151 = load i32, i32* %10
%152 = add i32 %151, 1
store i32 %152, i32* %10
br label %131
153: ; preds = %131
br label %154
154: ; preds = %153, %111
%155 = getelementptr inbounds [512 x i8], [512 x i8]* %7, i64 0, i64 0
%156 = load i32, i32* %13
%157 = zext i32 %156 to i64
%158 = getelementptr inbounds i8, i8* %155, i64 %157
store i8 0, i8* %158
%159 = load i32, i32* %13
%160 = icmp ugt i32 %159, 0
br i1 %160, label %161, label %164
161: ; preds = %154
%162 = getelementptr inbounds [512 x i8], [512 x i8]* %7, i64 0, i64 0
%163 = call double @atof(i8* %162)
store double %163, double* %14
br label %164
164: ; preds = %161, %154
br label %165
165: ; preds = %164, %59
br label %166
166: ; preds = %321, %165
%167 = load i32, i32* %10
%168 = load i32, i32* %12
%169 = icmp ult i32 %167, %168
br i1 %169, label %170, label %322
170: ; preds = %166
%171 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 0
%172 = load i32, i32* %10
%173 = add i32 %172, 1
store i32 %173, i32* %10
%174 = zext i32 %172 to i64
%175 = getelementptr inbounds i8, i8* %171, i64 %174
%176 = load i8, i8* %175
store i8 %176, i8* %8
store i32 0, i32* %13
%177 = load i32, i32* %10
%178 = zext i32 %177 to i64
%179 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 %178
%180 = load i8, i8* %179
%181 = zext i8 %180 to i32
%182 = icmp eq i32 %181, 43
br i1 %182, label %190, label %183
183: ; preds = %170
%184 = load i32, i32* %10
%185 = zext i32 %184 to i64
%186 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 %185
%187 = load i8, i8* %186
%188 = zext i8 %187 to i32
%189 = icmp eq i32 %188, 45
br i1 %189, label %190, label %202
190: ; preds = %183, %170
%191 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 0
%192 = load i32, i32* %10
%193 = add i32 %192, 1
store i32 %193, i32* %10
%194 = zext i32 %192 to i64
%195 = getelementptr inbounds i8, i8* %191, i64 %194
%196 = load i8, i8* %195
%197 = getelementptr inbounds [512 x i8], [512 x i8]* %7, i64 0, i64 0
%198 = load i32, i32* %13
%199 = add i32 %198, 1
store i32 %199, i32* %13
%200 = zext i32 %198 to i64
%201 = getelementptr inbounds i8, i8* %197, i64 %200
store i8 %196, i8* %201
br label %202
202: ; preds = %190, %183
br label %203
203: ; preds = %222, %202
%204 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 0
%205 = load i32, i32* %10
%206 = zext i32 %205 to i64
%207 = getelementptr inbounds i8, i8* %204, i64 %206
%208 = load i8, i8* %207
%209 = call i64 @isdigit(i8 zeroext %208)
%210 = icmp ne i64 %209, 0
br i1 %210, label %211, label %225
211: ; preds = %203
%212 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 0
%213 = load i32, i32* %10
%214 = zext i32 %213 to i64
%215 = getelementptr inbounds i8, i8* %212, i64 %214
%216 = load i8, i8* %215
%217 = getelementptr inbounds [512 x i8], [512 x i8]* %7, i64 0, i64 0
%218 = load i32, i32* %13
%219 = add i32 %218, 1
store i32 %219, i32* %13
%220 = zext i32 %218 to i64
%221 = getelementptr inbounds i8, i8* %217, i64 %220
store i8 %216, i8* %221
br label %222
222: ; preds = %211
%223 = load i32, i32* %10
%224 = add i32 %223, 1
store i32 %224, i32* %10
br label %203
225: ; preds = %203
%226 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 0
%227 = load i32, i32* %10
%228 = zext i32 %227 to i64
%229 = getelementptr inbounds i8, i8* %226, i64 %228
%230 = load i8, i8* %229
%231 = zext i8 %230 to i32
%232 = icmp eq i32 %231, 46
br i1 %232, label %233, label %268
233: ; preds = %225
%234 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 0
%235 = load i32, i32* %10
%236 = add i32 %235, 1
store i32 %236, i32* %10
%237 = zext i32 %235 to i64
%238 = getelementptr inbounds i8, i8* %234, i64 %237
%239 = load i8, i8* %238
%240 = getelementptr inbounds [512 x i8], [512 x i8]* %7, i64 0, i64 0
%241 = load i32, i32* %13
%242 = add i32 %241, 1
store i32 %242, i32* %13
%243 = zext i32 %241 to i64
%244 = getelementptr inbounds i8, i8* %240, i64 %243
store i8 %239, i8* %244
br label %245
245: ; preds = %264, %233
%246 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 0
%247 = load i32, i32* %10
%248 = zext i32 %247 to i64
%249 = getelementptr inbounds i8, i8* %246, i64 %248
%250 = load i8, i8* %249
%251 = call i64 @isdigit(i8 zeroext %250)
%252 = icmp ne i64 %251, 0
br i1 %252, label %253, label %267
253: ; preds = %245
%254 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 0
%255 = load i32, i32* %10
%256 = zext i32 %255 to i64
%257 = getelementptr inbounds i8, i8* %254, i64 %256
%258 = load i8, i8* %257
%259 = getelementptr inbounds [512 x i8], [512 x i8]* %7, i64 0, i64 0
%260 = load i32, i32* %13
%261 = add i32 %260, 1
store i32 %261, i32* %13
%262 = zext i32 %260 to i64
%263 = getelementptr inbounds i8, i8* %259, i64 %262
store i8 %258, i8* %263
br label %264
264: ; preds = %253
%265 = load i32, i32* %10
%266 = add i32 %265, 1
store i32 %266, i32* %10
br label %245
267: ; preds = %245
br label %268
268: ; preds = %267, %225
%269 = getelementptr inbounds [512 x i8], [512 x i8]* %7, i64 0, i64 0
%270 = load i32, i32* %13
%271 = zext i32 %270 to i64
%272 = getelementptr inbounds i8, i8* %269, i64 %271
store i8 0, i8* %272
%273 = getelementptr inbounds [512 x i8], [512 x i8]* %7, i64 0, i64 0
%274 = call double @atof(i8* %273)
store double %274, double* %15
%275 = load i8, i8* %8
%276 = sext i8 %275 to i32
switch i32 %276, label %317 [
i32 43, label %277
i32 45, label %281
i32 42, label %285
i32 47, label %289
i32 37, label %301
]
277: ; preds = %268
%278 = load double, double* %15
%279 = load double, double* %14
%280 = fadd double %279, %278
store double %280, double* %14
br label %321
281: ; preds = %268
%282 = load double, double* %15
%283 = load double, double* %14
%284 = fsub double %283, %282
store double %284, double* %14
br label %321
285: ; preds = %268
%286 = load double, double* %15
%287 = load double, double* %14
%288 = fmul double %287, %286
store double %288, double* %14
br label %321
289: ; preds = %268
%290 = load double, double* %15
%291 = fcmp oeq double %290, 0.000000e+00
br i1 %291, label %292, label %296
292: ; preds = %289
%293 = load i8*, i8** %5
%294 = load i8*, i8** %4
%295 = call i32 (i8*, i8*, i8*, ...) @S(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i8* %293, i8* %294)
br label %327
296: ; preds = %289
%297 = load double, double* %15
%298 = load double, double* %14
%299 = fdiv double %298, %297
store double %299, double* %14
br label %300
300: ; preds = %296
br label %321
301: ; preds = %268
%302 = load double, double* %15
%303 = fptosi double %302 to i64
%304 = icmp eq i64 %303, 0
br i1 %304, label %305, label %309
305: ; preds = %301
%306 = load i8*, i8** %5
%307 = load i8*, i8** %4
%308 = call i32 (i8*, i8*, i8*, ...) @S(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i8* %306, i8* %307)
br label %327
309: ; preds = %301
%310 = load double, double* %14
%311 = fptosi double %310 to i64
%312 = load double, double* %15
%313 = fptosi double %312 to i64
%314 = srem i64 %311, %313
%315 = sitofp i64 %314 to double
store double %315, double* %14
br label %316
316: ; preds = %309
br label %321
317: ; preds = %268
%318 = load i8*, i8** %5
%319 = load i8*, i8** %4
%320 = call i32 (i8*, i8*, i8*, ...) @S(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.1, i64 0, i64 0), i8* %318, i8* %319)
br label %327
321: ; preds = %316, %300, %285, %281, %277
br label %166
322: ; preds = %166
%323 = load i8*, i8** %5
%324 = load i8*, i8** %4
%325 = load double, double* %14
%326 = call i32 (i8*, i8*, i8*, ...) @S(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.2, i64 0, i64 0), i8* %323, i8* %324, double %325)
br label %327
327: ; preds = %322, %317, %305, %292
ret void
}

LLVM IR (-O2):
@.str = [41 x i8] c"PRIVMSG %s :%s: Division by zero error!\0A\00"
@.str.1 = [36 x i8] c"PRIVMSG %s :%s: Illegal operation!\0A\00"
@.str.2 = [22 x i8] c"PRIVMSG %s :%s\02:\02 %f\0A\00"
define void @do_math(i8* %0, i8* %1, i8* %2) {
%4 = alloca [512 x i8]
%5 = alloca [512 x i8]
%6 = getelementptr inbounds [512 x i8], [512 x i8]* %4, i64 0, i64 0
%7 = getelementptr inbounds [512 x i8], [512 x i8]* %5, i64 0, i64 0
%8 = call i32 @strncpy(i8* %7, i8* %2, i32 512)
%9 = call i32 @strlen(i8* %7)
%10 = add nuw i32 %9, 1
%11 = zext i32 %10 to i64
%12 = and i64 %11, 1
%13 = icmp eq i32 %9, 0
br i1 %13, label %42, label %14
14: ; preds = %3
%15 = and i64 %11, 4294967294
br label %16
16: ; preds = %37, %14
%17 = phi i64 [ 0, %14 ], [ %39, %37 ]
%18 = phi i32 [ 0, %14 ], [ %38, %37 ]
%19 = phi i64 [ 0, %14 ], [ %40, %37 ]
%20 = getelementptr inbounds [512 x i8], [512 x i8]* %5, i64 0, i64 %17
%21 = load i8, i8* %20
%22 = icmp eq i8 %21, 32
br i1 %22, label %27, label %23
23: ; preds = %16
%24 = add i32 %18, 1
%25 = zext i32 %18 to i64
%26 = getelementptr inbounds [512 x i8], [512 x i8]* %5, i64 0, i64 %25
store i8 %21, i8* %26
br label %27
27: ; preds = %16, %23
%28 = phi i32 [ %24, %23 ], [ %18, %16 ]
%29 = or i64 %17, 1
%30 = getelementptr inbounds [512 x i8], [512 x i8]* %5, i64 0, i64 %29
%31 = load i8, i8* %30
%32 = icmp eq i8 %31, 32
br i1 %32, label %37, label %33
33: ; preds = %27
%34 = add i32 %28, 1
%35 = zext i32 %28 to i64
%36 = getelementptr inbounds [512 x i8], [512 x i8]* %5, i64 0, i64 %35
store i8 %31, i8* %36
br label %37
37: ; preds = %33, %27
%38 = phi i32 [ %34, %33 ], [ %28, %27 ]
%39 = add nuw nsw i64 %17, 2
%40 = add i64 %19, 2
%41 = icmp eq i64 %40, %15
br i1 %41, label %42, label %16
42: ; preds = %37, %3
%43 = phi i64 [ 0, %3 ], [ %39, %37 ]
%44 = phi i32 [ 0, %3 ], [ %38, %37 ]
%45 = icmp eq i64 %12, 0
br i1 %45, label %53, label %46
46: ; preds = %42
%47 = getelementptr inbounds [512 x i8], [512 x i8]* %5, i64 0, i64 %43
%48 = load i8, i8* %47
%49 = icmp eq i8 %48, 32
br i1 %49, label %53, label %50
50: ; preds = %46
%51 = zext i32 %44 to i64
%52 = getelementptr inbounds [512 x i8], [512 x i8]* %5, i64 0, i64 %51
store i8 %48, i8* %52
br label %53
53: ; preds = %46, %50, %42
%54 = call i32 @strlen(i8* %7)
%55 = load i8, i8* %7
switch i8 %55, label %59 [
i8 61, label %114
i8 43, label %56
i8 45, label %56
]
56: ; preds = %53, %53
store i8 %55, i8* %6
%57 = getelementptr inbounds [512 x i8], [512 x i8]* %5, i64 0, i64 1
%58 = load i8, i8* %57
br label %59
59: ; preds = %53, %56
%60 = phi i8 [ %58, %56 ], [ %55, %53 ]
%61 = phi i32 [ 1, %56 ], [ 0, %53 ]
%62 = zext i32 %61 to i64
%63 = getelementptr inbounds [512 x i8], [512 x i8]* %5, i64 0, i64 %62
%64 = call i64 @isdigit(i8 zeroext %60)
%65 = icmp eq i64 %64, 0
br i1 %65, label %78, label %66
66: ; preds = %59, %66
%67 = phi i8* [ %74, %66 ], [ %63, %59 ]
%68 = phi i32 [ %70, %66 ], [ %61, %59 ]
%69 = load i8, i8* %67
%70 = add i32 %68, 1
%71 = zext i32 %68 to i64
%72 = getelementptr inbounds [512 x i8], [512 x i8]* %4, i64 0, i64 %71
store i8 %69, i8* %72
%73 = zext i32 %70 to i64
%74 = getelementptr inbounds [512 x i8], [512 x i8]* %5, i64 0, i64 %73
%75 = load i8, i8* %74
%76 = call i64 @isdigit(i8 zeroext %75)
%77 = icmp eq i64 %76, 0
br i1 %77, label %78, label %66
78: ; preds = %66, %59
%79 = phi i32 [ %61, %59 ], [ %70, %66 ]
%80 = phi i8* [ %63, %59 ], [ %74, %66 ]
%81 = load i8, i8* %80
%82 = icmp eq i8 %81, 46
br i1 %82, label %83, label %106
83: ; preds = %78
%84 = zext i32 %79 to i64
%85 = getelementptr inbounds [512 x i8], [512 x i8]* %4, i64 0, i64 %84
store i8 46, i8* %85
%86 = add i32 %79, 1
%87 = zext i32 %86 to i64
%88 = getelementptr inbounds [512 x i8], [512 x i8]* %5, i64 0, i64 %87
%89 = load i8, i8* %88
%90 = call i64 @isdigit(i8 zeroext %89)
%91 = icmp eq i64 %90, 0
br i1 %91, label %106, label %92
92: ; preds = %83, %92
%93 = phi i8* [ %102, %92 ], [ %88, %83 ]
%94 = phi i32 [ %100, %92 ], [ %86, %83 ]
%95 = phi i32 [ %99, %92 ], [ %86, %83 ]
%96 = load i8, i8* %93
%97 = zext i32 %95 to i64
%98 = getelementptr inbounds [512 x i8], [512 x i8]* %4, i64 0, i64 %97
store i8 %96, i8* %98
%99 = add i32 %95, 1
%100 = add i32 %94, 1
%101 = zext i32 %100 to i64
%102 = getelementptr inbounds [512 x i8], [512 x i8]* %5, i64 0, i64 %101
%103 = load i8, i8* %102
%104 = call i64 @isdigit(i8 zeroext %103)
%105 = icmp eq i64 %104, 0
br i1 %105, label %106, label %92
106: ; preds = %92, %83, %78
%107 = phi i32 [ %79, %78 ], [ %86, %83 ], [ %100, %92 ]
%108 = phi i32 [ %79, %78 ], [ %86, %83 ], [ %99, %92 ]
%109 = zext i32 %108 to i64
%110 = getelementptr inbounds [512 x i8], [512 x i8]* %4, i64 0, i64 %109
store i8 0, i8* %110
%111 = icmp eq i32 %108, 0
br i1 %111, label %114, label %112
112: ; preds = %106
%113 = call double @atof(i8* %6)
br label %114
114: ; preds = %53, %106, %112
%115 = phi i32 [ %107, %112 ], [ %107, %106 ], [ 1, %53 ]
%116 = phi double [ %113, %112 ], [ 0.000000e+00, %106 ], [ 0.000000e+00, %53 ]
%117 = icmp ult i32 %115, %54
br i1 %117, label %118, label %218
118: ; preds = %114, %215
%119 = phi double [ %216, %215 ], [ %116, %114 ]
%120 = phi i32 [ %186, %215 ], [ %115, %114 ]
%121 = add nuw i32 %120, 1
%122 = zext i32 %120 to i64
%123 = getelementptr inbounds [512 x i8], [512 x i8]* %5, i64 0, i64 %122
%124 = load i8, i8* %123
%125 = zext i32 %121 to i64
%126 = getelementptr inbounds [512 x i8], [512 x i8]* %5, i64 0, i64 %125
%127 = load i8, i8* %126
switch i8 %127, label %133 [
i8 43, label %128
i8 45, label %128
]
128: ; preds = %118, %118
%129 = add i32 %120, 2
store i8 %127, i8* %6
%130 = zext i32 %129 to i64
%131 = getelementptr inbounds [512 x i8], [512 x i8]* %5, i64 0, i64 %130
%132 = load i8, i8* %131
br label %133
133: ; preds = %118, %128
%134 = phi i8 [ %127, %118 ], [ %132, %128 ]
%135 = phi i64 [ %125, %118 ], [ %130, %128 ]
%136 = phi i32 [ %121, %118 ], [ %129, %128 ]
%137 = phi i32 [ 0, %118 ], [ 1, %128 ]
%138 = getelementptr inbounds [512 x i8], [512 x i8]* %5, i64 0, i64 %135
%139 = call i64 @isdigit(i8 zeroext %134)
%140 = icmp eq i64 %139, 0
br i1 %140, label %155, label %141
141: ; preds = %133, %141
%142 = phi i8* [ %151, %141 ], [ %138, %133 ]
%143 = phi i32 [ %146, %141 ], [ %137, %133 ]
%144 = phi i32 [ %149, %141 ], [ %136, %133 ]
%145 = load i8, i8* %142
%146 = add i32 %143, 1
%147 = zext i32 %143 to i64
%148 = getelementptr inbounds [512 x i8], [512 x i8]* %4, i64 0, i64 %147
store i8 %145, i8* %148
%149 = add i32 %144, 1
%150 = zext i32 %149 to i64
%151 = getelementptr inbounds [512 x i8], [512 x i8]* %5, i64 0, i64 %150
%152 = load i8, i8* %151
%153 = call i64 @isdigit(i8 zeroext %152)
%154 = icmp eq i64 %153, 0
br i1 %154, label %155, label %141
155: ; preds = %141, %133
%156 = phi i32 [ %136, %133 ], [ %149, %141 ]
%157 = phi i32 [ %137, %133 ], [ %146, %141 ]
%158 = phi i8* [ %138, %133 ], [ %151, %141 ]
%159 = load i8, i8* %158
%160 = icmp eq i8 %159, 46
br i1 %160, label %161, label %185
161: ; preds = %155
%162 = zext i32 %157 to i64
%163 = getelementptr inbounds [512 x i8], [512 x i8]* %4, i64 0, i64 %162
store i8 46, i8* %163
%164 = add i32 %157, 1
%165 = add i32 %156, 1
%166 = zext i32 %165 to i64
%167 = getelementptr inbounds [512 x i8], [512 x i8]* %5, i64 0, i64 %166
%168 = load i8, i8* %167
%169 = call i64 @isdigit(i8 zeroext %168)
%170 = icmp eq i64 %169, 0
br i1 %170, label %185, label %171
171: ; preds = %161, %171
%172 = phi i8* [ %181, %171 ], [ %167, %161 ]
%173 = phi i32 [ %179, %171 ], [ %165, %161 ]
%174 = phi i32 [ %178, %171 ], [ %164, %161 ]
%175 = load i8, i8* %172
%176 = zext i32 %174 to i64
%177 = getelementptr inbounds [512 x i8], [512 x i8]* %4, i64 0, i64 %176
store i8 %175, i8* %177
%178 = add i32 %174, 1
%179 = add i32 %173, 1
%180 = zext i32 %179 to i64
%181 = getelementptr inbounds [512 x i8], [512 x i8]* %5, i64 0, i64 %180
%182 = load i8, i8* %181
%183 = call i64 @isdigit(i8 zeroext %182)
%184 = icmp eq i64 %183, 0
br i1 %184, label %185, label %171
185: ; preds = %171, %161, %155
%186 = phi i32 [ %156, %155 ], [ %165, %161 ], [ %179, %171 ]
%187 = phi i32 [ %157, %155 ], [ %164, %161 ], [ %178, %171 ]
%188 = zext i32 %187 to i64
%189 = getelementptr inbounds [512 x i8], [512 x i8]* %4, i64 0, i64 %188
store i8 0, i8* %189
%190 = call double @atof(i8* %6)
%191 = sext i8 %124 to i32
switch i32 %191, label %213 [
i32 43, label %192
i32 45, label %194
i32 42, label %196
i32 47, label %198
i32 37, label %204
]
192: ; preds = %185
%193 = fadd double %119, %190
br label %215
194: ; preds = %185
%195 = fsub double %119, %190
br label %215
196: ; preds = %185
%197 = fmul double %119, %190
br label %215
198: ; preds = %185
%199 = fcmp oeq double %190, 0.000000e+00
br i1 %199, label %200, label %202
200: ; preds = %198
%201 = call i32 (i8*, i8*, i8*, ...) @S(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i8* %1, i8* %0)
br label %221
202: ; preds = %198
%203 = fdiv double %119, %190
br label %215
204: ; preds = %185
%205 = fptosi double %190 to i64
%206 = icmp eq i64 %205, 0
br i1 %206, label %207, label %209
207: ; preds = %204
%208 = call i32 (i8*, i8*, i8*, ...) @S(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str, i64 0, i64 0), i8* %1, i8* %0)
br label %221
209: ; preds = %204
%210 = fptosi double %119 to i64
%211 = srem i64 %210, %205
%212 = sitofp i64 %211 to double
br label %215
213: ; preds = %185
%214 = call i32 (i8*, i8*, i8*, ...) @S(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.1, i64 0, i64 0), i8* %1, i8* %0)
br label %221
215: ; preds = %209, %202, %196, %194, %192
%216 = phi double [ %212, %209 ], [ %203, %202 ], [ %197, %196 ], [ %195, %194 ], [ %193, %192 ]
%217 = icmp ult i32 %186, %54
br i1 %217, label %118, label %218
218: ; preds = %215, %114
%219 = phi double [ %116, %114 ], [ %216, %215 ]
%220 = call i32 (i8*, i8*, i8*, ...) @S(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.2, i64 0, i64 0), i8* %1, i8* %0, double %219)
br label %221
221: ; preds = %218, %213, %207, %200
ret void
}