#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 */
float atof(char *);
int /*<<< orphan*/ sprintf(char *, char *, float);
int /*<<< orphan*/ strcat(char *, char *);
void unroottree(char *tree) {
  int i = 0, j = 0, k = 0, l = 0, m = 0, basecount = 0, parentheses = 0;
  int foundopen = 0, foundclose = 0;
  float del_nodelen = 0;
  char length[100], restof[400000];
  restof[0] = '\0';
  length[0] = '\0';
  while (tree[i] != ';') {
    switch (tree[i]) {
    case '(':
      parentheses++;
      i++;
      break;
    case ')':
      parentheses--;
      i++;
      break;
    case ',':
      if (parentheses == 1) {
        basecount++;
      }
      i++;
      break;
    default:
      i++;
      break;
    }
  }
  if (basecount < 2) {
    i = 0;
    parentheses = 0;
    while (tree[i] != ';') {
      switch (tree[i]) {
      case '(':
        parentheses++;
        if (parentheses == 2 && !foundopen) {
          tree[i] = '^';
          foundopen = 1;
        }
        i++;
        break;
      case ')':
        if (parentheses == 2 && !foundclose) {
          tree[i] = '^';
          i++;
          while (tree[i] != ')' && tree[i] != '(' && tree[i] != ',' &&
                 tree[i] != ';' && tree[i] != ':') {
            tree[i] = '^';
            i++;
          }
          if (tree[i] == ':') {
            k = 0;
            length[0] = '\0';
            while (tree[i] != ')' && tree[i] != '(' && tree[i] != ',' &&
                   tree[i] != ';') {
              if (tree[i] != ':') {
                length[k] = tree[i];
                k++;
              }
              tree[i] = '^';
              i++;
            }
            length[k] = '\0';
          }
          if (length[0] != '\0') {
            del_nodelen = atof(length);
            k = i + 1;
            if (tree[k] == '(') {
              l = 1;
              k++;
              while ((l != 0 || tree[k - 1] != ')') && tree[k] != ';') {
                switch (tree[k]) {
                case '(':
                  l++;
                  k++;
                  break;
                case ')':
                  l--;
                  k++;
                  break;
                default:
                  k++;
                  break;
                }
              }
              k--;
              k++;
              while (tree[k] != ')' && tree[k] != '(' && tree[k] != ',' &&
                     tree[k] != ';' && tree[k] != ':')
                k++;
            } else {
              while (tree[k] != ')' && tree[k] != '(' && tree[k] != ',' &&
                     tree[k] != ';' && tree[k] != ':')
                k++;
            }
            if (tree[k] == ':') {
              m = k + 1;
              length[0] = '\0';
              l = 0;
              while (tree[m] != ')' && tree[m] != '(' && tree[m] != ',' &&
                     tree[m] != ';') {
                length[l] = tree[m];
                l++;
                m++;
              }
              length[l] = '\0';
              del_nodelen += atof(length);
            } else
              m = k;
            l = 0;
            while (tree[m] != ';' && tree[m] != '\0') {
              restof[l] = tree[m];
              m++;
              l++;
            }
            restof[l] = ';';
            restof[l + 1] = '\0';
            if (tree[k] == ':')
              tree[k] = '\0';
            else {
              tree[k] = '\0';
            }
            length[0] = '\0';
            sprintf(length, ":%f", del_nodelen);
            strcat(tree, length);
            strcat(tree, restof);
          }
          foundclose = 1;
        }
        i++;
        parentheses--;
        break;
      default:
        i++;
        break;
      }
    }
    i = 0;
    j = 0;
    while (tree[j] != ';') {
      if (tree[j] == '^') {
        while (tree[j] == '^')
          j++;
        if (i != j)
          tree[i] = tree[j];
        i++;
        j++;
      } else {
        if (i != j)
          tree[i] = tree[j];
        i++;
        j++;
      }
    }
    tree[i] = tree[j];
    tree[i + 1] = '\0';
  }
}


x86 assembly (clang, -O0):
<unroottree>:
push   %rbp
mov    %rsp,%rbp
sub    $0x61b40,%rsp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
movb   $0x0,-0x61b20(%rbp)
movb   $0x0,-0xa0(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3b,%eax
je     124e <unroottree+0x11e>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x61b24(%rbp)
sub    $0x28,%eax
je     11f1 <unroottree+0xc1>
jmp    11c9 <unroottree+0x99>
mov    -0x61b24(%rbp),%eax
sub    $0x29,%eax
je     1208 <unroottree+0xd8>
jmp    11dd <unroottree+0xad>
mov    -0x61b24(%rbp),%eax
sub    $0x2c,%eax
je     121f <unroottree+0xef>
jmp    1240 <unroottree+0x110>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1249 <unroottree+0x119>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1249 <unroottree+0x119>
cmpl   $0x1,-0x24(%rbp)
jne    1232 <unroottree+0x102>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1249 <unroottree+0x119>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1194 <unroottree+0x64>
cmpl   $0x2,-0x20(%rbp)
jge    1a95 <unroottree+0x965>
movl   $0x0,-0xc(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3b,%eax
je     199c <unroottree+0x86c>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x61b28(%rbp)
sub    $0x28,%eax
je     12af <unroottree+0x17f>
jmp    129b <unroottree+0x16b>
mov    -0x61b28(%rbp),%eax
sub    $0x29,%eax
je     12ed <unroottree+0x1bd>
jmp    198e <unroottree+0x85e>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x2,-0x24(%rbp)
jne    12df <unroottree+0x1af>
cmpl   $0x0,-0x28(%rbp)
jne    12df <unroottree+0x1af>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movb   $0x5e,(%rax,%rcx,1)
movl   $0x1,-0x28(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1997 <unroottree+0x867>
cmpl   $0x2,-0x24(%rbp)
jne    1977 <unroottree+0x847>
cmpl   $0x0,-0x2c(%rbp)
jne    1977 <unroottree+0x847>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movb   $0x5e,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x29,%ecx
mov    %al,-0x61b29(%rbp)
je     13a2 <unroottree+0x272>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x28,%ecx
mov    %al,-0x61b29(%rbp)
je     13a2 <unroottree+0x272>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x2c,%ecx
mov    %al,-0x61b29(%rbp)
je     13a2 <unroottree+0x272>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x3b,%ecx
mov    %al,-0x61b29(%rbp)
je     13a2 <unroottree+0x272>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3a,%eax
setne  %al
mov    %al,-0x61b29(%rbp)
mov    -0x61b29(%rbp),%al
test   $0x1,%al
jne    13b5 <unroottree+0x285>
jmp    13cf <unroottree+0x29f>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movb   $0x5e,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1316 <unroottree+0x1e6>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3a,%eax
jne    14ce <unroottree+0x39e>
movl   $0x0,-0x14(%rbp)
movb   $0x0,-0xa0(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x29,%ecx
mov    %al,-0x61b2a(%rbp)
je     1461 <unroottree+0x331>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x28,%ecx
mov    %al,-0x61b2a(%rbp)
je     1461 <unroottree+0x331>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x2c,%ecx
mov    %al,-0x61b2a(%rbp)
je     1461 <unroottree+0x331>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3b,%eax
setne  %al
mov    %al,-0x61b2a(%rbp)
mov    -0x61b2a(%rbp),%al
test   $0x1,%al
jne    1474 <unroottree+0x344>
jmp    14c2 <unroottree+0x392>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3a,%eax
je     14a8 <unroottree+0x378>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x14(%rbp),%rax
mov    %cl,-0xa0(%rbp,%rax,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movb   $0x5e,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    13f2 <unroottree+0x2c2>
movslq -0x14(%rbp),%rax
movb   $0x0,-0xa0(%rbp,%rax,1)
movsbl -0xa0(%rbp),%eax
cmp    $0x0,%eax
je     1970 <unroottree+0x840>
lea    -0xa0(%rbp),%rdi
call   1030 <atof@plt>
movss  %xmm0,-0x30(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x28,%eax
jne    16a8 <unroottree+0x578>
movl   $0x1,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x18(%rbp)
jne    1549 <unroottree+0x419>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x29,%ecx
mov    %al,-0x61b2b(%rbp)
je     1561 <unroottree+0x431>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3b,%eax
setne  %al
mov    %al,-0x61b2b(%rbp)
mov    -0x61b2b(%rbp),%al
test   $0x1,%al
jne    1574 <unroottree+0x444>
jmp    15e4 <unroottree+0x4b4>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x61b30(%rbp)
sub    $0x28,%eax
je     15a8 <unroottree+0x478>
jmp    1594 <unroottree+0x464>
mov    -0x61b30(%rbp),%eax
sub    $0x29,%eax
je     15bf <unroottree+0x48f>
jmp    15d6 <unroottree+0x4a6>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    15df <unroottree+0x4af>
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    15df <unroottree+0x4af>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    151d <unroottree+0x3ed>
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x29,%ecx
mov    %al,-0x61b31(%rbp)
je     1682 <unroottree+0x552>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x28,%ecx
mov    %al,-0x61b31(%rbp)
je     1682 <unroottree+0x552>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x2c,%ecx
mov    %al,-0x61b31(%rbp)
je     1682 <unroottree+0x552>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x3b,%ecx
mov    %al,-0x61b31(%rbp)
je     1682 <unroottree+0x552>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3a,%eax
setne  %al
mov    %al,-0x61b31(%rbp)
mov    -0x61b31(%rbp),%al
test   $0x1,%al
jne    1695 <unroottree+0x565>
jmp    16a3 <unroottree+0x573>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    15f6 <unroottree+0x4c6>
jmp    175f <unroottree+0x62f>
jmp    16ad <unroottree+0x57d>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x29,%ecx
mov    %al,-0x61b32(%rbp)
je     1739 <unroottree+0x609>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x28,%ecx
mov    %al,-0x61b32(%rbp)
je     1739 <unroottree+0x609>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x2c,%ecx
mov    %al,-0x61b32(%rbp)
je     1739 <unroottree+0x609>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x3b,%ecx
mov    %al,-0x61b32(%rbp)
je     1739 <unroottree+0x609>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3a,%eax
setne  %al
mov    %al,-0x61b32(%rbp)
mov    -0x61b32(%rbp),%al
test   $0x1,%al
jne    174c <unroottree+0x61c>
jmp    175a <unroottree+0x62a>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    16ad <unroottree+0x57d>
jmp    175f <unroottree+0x62f>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3a,%eax
jne    1861 <unroottree+0x731>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
movb   $0x0,-0xa0(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x29,%ecx
mov    %al,-0x61b33(%rbp)
je     17fa <unroottree+0x6ca>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x28,%ecx
mov    %al,-0x61b33(%rbp)
je     17fa <unroottree+0x6ca>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x2c,%ecx
mov    %al,-0x61b33(%rbp)
je     17fa <unroottree+0x6ca>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3b,%eax
setne  %al
mov    %al,-0x61b33(%rbp)
mov    -0x61b33(%rbp),%al
test   $0x1,%al
jne    180d <unroottree+0x6dd>
jmp    183a <unroottree+0x70a>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x18(%rbp),%rax
mov    %cl,-0xa0(%rbp,%rax,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    178b <unroottree+0x65b>
movslq -0x18(%rbp),%rax
movb   $0x0,-0xa0(%rbp,%rax,1)
lea    -0xa0(%rbp),%rdi
call   1030 <atof@plt>
addss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
jmp    1867 <unroottree+0x737>
mov    -0x14(%rbp),%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x3b,%ecx
mov    %al,-0x61b34(%rbp)
je     18a3 <unroottree+0x773>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x61b34(%rbp)
mov    -0x61b34(%rbp),%al
test   $0x1,%al
jne    18b6 <unroottree+0x786>
jmp    18e3 <unroottree+0x7b3>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x18(%rbp),%rax
mov    %cl,-0x61b20(%rbp,%rax,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    186e <unroottree+0x73e>
movslq -0x18(%rbp),%rax
movb   $0x3b,-0x61b20(%rbp,%rax,1)
3b
mov    -0x18(%rbp),%eax
add    $0x1,%eax
cltq
movb   $0x0,-0x61b20(%rbp,%rax,1)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3a,%eax
jne    1925 <unroottree+0x7f5>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    1931 <unroottree+0x801>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movb   $0x0,-0xa0(%rbp)
lea    -0xa0(%rbp),%rdi
movss  -0x30(%rbp),%xmm0
lea    0x6b5(%rip),%rsi
call   1050 <sprintf@plt>
mov    -0x8(%rbp),%rdi
lea    -0xa0(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x8(%rbp),%rdi
lea    -0x61b20(%rbp),%rsi
call   1040 <strcat@plt>
movl   $0x1,-0x2c(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1997 <unroottree+0x867>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1266 <unroottree+0x136>
movl   $0x0,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x3b,%eax
je     1a6e <unroottree+0x93e>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5e,%eax
jne    1a35 <unroottree+0x905>
jmp    19d9 <unroottree+0x8a9>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5e,%eax
jne    19fc <unroottree+0x8cc>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    19d9 <unroottree+0x8a9>
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
je     1a1e <unroottree+0x8ee>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1a69 <unroottree+0x939>
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
je     1a57 <unroottree+0x927>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    19aa <unroottree+0x87a>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
add    $0x61b40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<unroottree>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x61b08,%rsp
mov    %rdi,%rbx
movb   $0x0,0x80(%rsp)
movb   $0x0,0x10(%rsp)
mov    (%rdi),%dil
cmp    $0x3b,%dil
je     11b7 <unroottree+0x87>
lea    0x1(%rbx),%rcx
xor    %edx,%edx
mov    %edi,%eax
xor    %esi,%esi
jmp    117e <unroottree+0x4e>
cs nopw 0x0(%rax,%rax,1)
add    $0xffffffff,%edx
movzbl (%rcx),%eax
add    $0x1,%rcx
cmp    $0x3b,%al
je     11ac <unroottree+0x7c>
movsbl %al,%eax
cmp    $0x2c,%eax
je     11a0 <unroottree+0x70>
cmp    $0x29,%eax
je     1170 <unroottree+0x40>
cmp    $0x28,%eax
jne    1173 <unroottree+0x43>
add    $0x1,%edx
jmp    1173 <unroottree+0x43>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %eax,%eax
cmp    $0x1,%edx
sete   %al
add    %eax,%esi
jmp    1173 <unroottree+0x43>
cmp    $0x1,%esi
jg     1216 <unroottree+0xe6>
cmp    $0x3b,%dil
jne    1228 <unroottree+0xf8>
xor    %eax,%eax
xor    %ecx,%ecx
jmp    11ca <unroottree+0x9a>
nopl   (%rax)
mov    %dl,(%rbx,%rax,1)
add    $0x1,%ecx
add    $0x1,%rax
movslq %ecx,%rsi
mov    (%rbx,%rsi,1),%dl
cmp    $0x5e,%dl
je     11f0 <unroottree+0xc0>
cmp    $0x3b,%dl
je     1209 <unroottree+0xd9>
mov    %ecx,%esi
cmp    %rsi,%rax
jne    11c0 <unroottree+0x90>
jmp    11c3 <unroottree+0x93>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl 0x1(%rbx,%rsi,1),%edx
add    $0x1,%rsi
cmp    $0x5e,%dl
je     11f0 <unroottree+0xc0>
mov    %esi,%edi
mov    %esi,%ecx
cmp    %rdi,%rax
jne    11c0 <unroottree+0x90>
jmp    11c3 <unroottree+0x93>
mov    %eax,%ecx
movb   $0x3b,(%rbx,%rcx,1)
add    $0x1,%eax
movb   $0x0,(%rbx,%rax,1)
add    $0x61b08,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movabs $0x100000000,%r13
lea    0x1(%rbx),%rax
mov    %rax,0x8(%rsp)
xor    %edx,%edx
movabs $0x800130000000000,%rsi
movabs $0xc00130000000000,%r15
mov    %rbx,%rcx
xor    %ebp,%ebp
xor    %r14d,%r14d
xor    %r12d,%r12d
jmp    12ee <unroottree+0x1be>
mov    %eax,%ecx
movb   $0x3b,0x80(%rsp,%rcx,1)
3b
add    $0x1,%eax
movb   $0x0,0x80(%rsp,%rax,1)
movb   $0x0,(%rbx,%r15,1)
movb   $0x0,0x10(%rsp)
lea    0x10(%rsp),%rbp
mov    %rbp,%rdi
lea    0xd71(%rip),%rsi
call   1050 <sprintf@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
call   1040 <strcat@plt>
mov    %rbx,%rdi
lea    0x80(%rsp),%rsi
call   1040 <strcat@plt>
movabs $0x800130000000000,%rsi
movabs $0xc00130000000000,%r15
mov    0x4(%rsp),%ebp
mov    $0x1,%edx
add    $0xffffffff,%r14d
movslq %r12d,%rax
lea    0x1(%rax),%r12
lea    (%rbx,%rax,1),%rcx
add    $0x1,%rcx
mov    0x1(%rbx,%rax,1),%dil
cmp    $0x3b,%dil
je     11b7 <unroottree+0x87>
movsbl %dil,%eax
cmp    $0x29,%eax
je     1320 <unroottree+0x1f0>
cmp    $0x28,%eax
jne    12d0 <unroottree+0x1a0>
add    $0x1,%r14d
cmp    $0x2,%r14d
jne    12d0 <unroottree+0x1a0>
test   %ebp,%ebp
jne    12d0 <unroottree+0x1a0>
movb   $0x5e,(%rcx)
mov    $0x1,%ebp
mov    $0x2,%r14d
jmp    12d0 <unroottree+0x1a0>
nopw   0x0(%rax,%rax,1)
cmp    $0x2,%r14d
jne    12cc <unroottree+0x19c>
test   %edx,%edx
jne    12cc <unroottree+0x19c>
movb   $0x5e,(%rcx)
movslq %r12d,%rcx
lea    0x1(%rcx),%r12
shl    $0x20,%rcx
jmp    1349 <unroottree+0x219>
nopw   0x0(%rax,%rax,1)
movb   $0x5e,(%rbx,%r12,1)
add    $0x1,%r12
add    %r13,%rcx
movzbl (%rbx,%r12,1),%eax
cmp    $0x3b,%rax
ja     1340 <unroottree+0x210>
bt     %rax,%rsi
jb     13b1 <unroottree+0x281>
cmp    $0x3a,%rax
jne    1340 <unroottree+0x210>
movb   $0x0,0x10(%rsp)
sar    $0x20,%rcx
xor    %eax,%eax
mov    %rcx,%r12
jmp    1393 <unroottree+0x263>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %eax,%rdx
mov    %cl,0x10(%rsp,%rdx,1)
add    $0x1,%eax
movb   $0x5e,(%rbx,%r12,1)
add    $0x1,%r12
movzbl (%rbx,%r12,1),%ecx
cmp    $0x3b,%rcx
ja     1380 <unroottree+0x250>
cmp    $0x3a,%rcx
je     138a <unroottree+0x25a>
bt     %rcx,%rsi
jae    1380 <unroottree+0x250>
cltq
movb   $0x0,0x10(%rsp,%rax,1)
mov    $0x1,%edx
cmpb   $0x0,0x10(%rsp)
je     12cc <unroottree+0x19c>
mov    %ebp,0x4(%rsp)
lea    0x10(%rsp),%rdi
call   1030 <atof@plt>
mov    %r12,%rsi
shl    $0x20,%rsi
lea    (%rsi,%r13,1),%rax
sar    $0x20,%rax
mov    (%rbx,%rax,1),%cl
cmp    $0x28,%cl
jne    1449 <unroottree+0x319>
movabs $0x200000000,%rax
add    %rax,%rsi
mov    %rsi,%rcx
sar    $0x20,%rcx
add    %rbx,%rcx
mov    $0x1,%edx
mov    %rsi,%rax
jmp    141a <unroottree+0x2ea>
nopw   0x0(%rax,%rax,1)
add    $0xffffffff,%edx
add    %r13,%rax
add    $0x1,%rcx
test   %edx,%edx
jne    1424 <unroottree+0x2f4>
cmpb   $0x29,-0x1(%rcx)
je     1459 <unroottree+0x329>
movsbl (%rcx),%esi
cmp    $0x3b,%esi
je     1459 <unroottree+0x329>
cmp    $0x29,%esi
je     1410 <unroottree+0x2e0>
cmp    $0x28,%esi
jne    1413 <unroottree+0x2e3>
add    $0x1,%edx
jmp    1413 <unroottree+0x2e3>
nopl   0x0(%rax,%rax,1)
movzbl 0x1(%rbx,%rax,1),%ecx
add    $0x1,%rax
cmp    $0x3b,%cl
ja     1440 <unroottree+0x310>
movzbl %cl,%ecx
bt     %rcx,%r15
jae    1440 <unroottree+0x310>
jmp    1474 <unroottree+0x344>
sar    $0x20,%rax
jmp    1464 <unroottree+0x334>
nop
add    $0x1,%rax
movzbl (%rbx,%rax,1),%ecx
cmp    $0x3b,%rcx
ja     1460 <unroottree+0x330>
bt     %rcx,%r15
jae    1460 <unroottree+0x330>
movslq %eax,%r15
cmpb   $0x3a,(%rbx,%r15,1)
mov    %r15,%rbp
jne    14f8 <unroottree+0x3c8>
movb   $0x0,0x10(%rsp)
mov    %r15,%rbp
shl    $0x20,%rbp
add    %r13,%rbp
mov    0x8(%rsp),%rax
add    %r15,%rax
xor    %ecx,%ecx
movabs $0x800130000000000,%rsi
jmp    14bb <unroottree+0x38b>
cs nopw 0x0(%rax,%rax,1)
mov    %dl,0x10(%rsp,%rcx,1)
add    $0x1,%rcx
add    %r13,%rbp
movzbl (%rax,%rcx,1),%edx
cmp    $0x3b,%rdx
ja     14b0 <unroottree+0x380>
bt     %rdx,%rsi
jae    14b0 <unroottree+0x380>
mov    %ecx,%eax
movb   $0x0,0x10(%rsp,%rax,1)
lea    0x10(%rsp),%rdi
movss  %xmm0,(%rsp)
call   1030 <atof@plt>
movss  (%rsp),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rsp)
movss  (%rsp),%xmm0
sar    $0x20,%rbp
add    %rbx,%rbp
xor    %eax,%eax
nopl   (%rax)
movzbl 0x0(%rbp,%rax,1),%ecx
test   %cl,%cl
je     1261 <unroottree+0x131>
cmp    $0x3b,%cl
je     1261 <unroottree+0x131>
mov    %cl,0x80(%rsp,%rax,1)
add    $0x1,%rax
jmp    1500 <unroottree+0x3d0>

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

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