user: What is the c source code of the assembly code below:

```asm
<unroottree>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  lea    -0x61000(%rsp),%r11
L280:
  sub    $0x1000,%rsp
  orq    $0x0,(%rsp)
  cmp    %r11,%rsp
  jne    L280
  sub    $0xb28,%rsp
  mov    %rdi,%rbx
  mov    %fs:0x28,%rax
  mov    %rax,0x61b18(%rsp)
  xor    %eax,%eax
  movb   $0x0,0x90(%rsp)
  movb   $0x0,0x20(%rsp)
  movzbl (%rdi),%esi
  cmp    $0x3b,%sil
  je     L707
  mov    %esi,%eax
  mov    $0x1,%ecx
  mov    $0x0,%edi
  mov    $0x0,%r8d
  jmp    L461
L792:
  sub    $0x1,%edi
  mov    %ecx,%edx
L117:
  movslq %edx,%rdx
  movzbl (%rbx,%rdx,1),%eax
  add    $0x1,%ecx
  cmp    $0x3b,%al
  je     L651
L461:
  cmp    $0x29,%al
  je     L792
  cmp    $0x2c,%al
  je     L523
  mov    %ecx,%edx
  cmp    $0x28,%al
  jne    L117
  add    $0x1,%edi
  jmp    L117
L523:
  cmp    $0x1,%edi
  sete   %al
  movzbl %al,%eax
  add    %eax,%r8d
  mov    %ecx,%edx
  jmp    L117
L651:
  cmp    $0x1,%r8d
  jle    L152
L417:
  mov    0x61b18(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L333
  add    $0x61b28,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L152:
  mov    %rbx,%rax
  mov    $0x0,%edx
  mov    $0x0,%r14d
  mov    $0x0,%r12d
  mov    $0x0,%ebp
  movabs $0x800130000000000,%r15
  movabs $0xc00130000000000,%r13
  jmp    L281
L268:
  add    $0x1,%r12d
  cmp    $0x2,%r12d
  jne    L739
  test   %r14d,%r14d
  jne    L739
  movb   $0x5e,(%rax)
  mov    $0x1,%r14d
L739:
  add    $0x1,%ebp
  jmp    L694
L126:
  cmp    $0x2,%r12d
  jne    L418
  test   %edx,%edx
  je     L165
L418:
  add    $0x1,%ebp
  sub    $0x1,%r12d
L694:
  movslq %ebp,%rax
  add    %rbx,%rax
  movzbl (%rax),%esi
  cmp    $0x3b,%sil
  je     L687
L281:
  cmp    $0x28,%sil
  je     L268
  cmp    $0x29,%sil
  je     L126
  add    $0x1,%ebp
  jmp    L694
L165:
  movb   $0x5e,(%rax)
  lea    0x1(%rbp),%eax
  movslq %eax,%rcx
  add    %rbx,%rcx
  movzbl (%rcx),%edx
  cmp    $0x3b,%dl
  ja     L413
  bt     %rdx,%r13
  jb     L790
L413:
  lea    0x2(%rbp),%eax
  cltq
  jmp    L628
L790:
  mov    %eax,%ebp
  jmp    L32
L613:
  movb   $0x0,0x20(%rsp)
  movslq %ebp,%rsi
  add    %rbx,%rsi
  movzbl (%rsi),%ecx
  cmp    $0x3b,%cl
  ja     L153
  mov    %r15,%rax
  shr    %cl,%rax
  and    $0x1,%eax
  mov    $0x0,%edx
  je     L156
  mov    $0x0,%edx
  jmp    L53
L153:
  mov    $0x0,%eax
  mov    $0x0,%edx
L156:
  lea    0x1(%rbp),%r8d
  jmp    L343
L636:
  lea    0x2(%rbp),%esi
  movslq %esi,%rsi
  add    %rbx,%rsi
  lea    0x3(%rbp),%ecx
  mov    $0x1,%edi
  jmp    L631
L484:
  add    $0x1,%edi
  mov    %ecx,%eax
L642:
  test   %edi,%edi
  jne    L766
  movslq %eax,%rdx
  cmpb   $0x29,-0x1(%rbx,%rdx,1)
  je     L680
L766:
  add    $0x1,%rsi
  add    $0x1,%ecx
L631:
  lea    -0x1(%rcx),%eax
  movzbl (%rsi),%edx
  cmp    $0x3b,%dl
  je     L21
  cmp    $0x28,%dl
  je     L484
  cmp    $0x29,%dl
  je     L98
  mov    %ecx,%eax
  jmp    L642
L98:
  sub    $0x1,%edi
  mov    %ecx,%eax
  jmp    L642
L680:
  movzbl (%rbx,%rdx,1),%edx
  cmp    $0x3b,%dl
  ja     L6
  bt     %rdx,%r13
  jb     L21
L6:
  lea    0x1(%rax),%edx
  movslq %edx,%rdx
  jmp    L697
L712:
  lea    0x1(%rax),%esi
  mov    %esi,0x1c(%rsp)
  movb   $0x0,0x20(%rsp)
  movslq %esi,%rdx
  movzbl (%rbx,%rdx,1),%ecx
  cmp    $0x3b,%cl
  ja     L710
  mov    $0x0,%esi
  bt     %rcx,%r15
  jb     L426
L710:
  lea    0x2(%rax),%edx
  movslq %edx,%rdx
  lea    0x20(%rsp),%r8
  sub    %rdi,%r8
  jmp    L378
L208:
  mov    $0x0,%esi
  jmp    L539
L687:
  movzbl (%rbx),%edx
  cmp    $0x3b,%dl
  je     L714
  mov    $0x1,%esi
  mov    $0x0,%ecx
  mov    $0x0,%eax
  jmp    L36
L726:
  movslq %eax,%rdx
  movzbl (%rbx,%rdx,1),%edi
  cmp    $0x5e,%dil
  jne    L330
  add    $0x1,%eax
  movslq %eax,%rdx
L320:
  mov    %edx,%eax
  add    $0x1,%rdx
  movzbl -0x1(%rbx,%rdx,1),%edi
  cmp    $0x5e,%dil
  je     L320
L330:
  cmp    %ecx,%eax
  je     L107
  mov    %dil,(%rbx,%rcx,1)
L107:
  mov    %esi,%edi
  add    $0x1,%eax
  jmp    L436
L108:
  mov    %esi,%edi
  add    $0x1,%eax
L436:
  movslq %eax,%rdx
  movzbl (%rbx,%rdx,1),%edx
  add    $0x1,%rcx
  add    $0x1,%esi
  cmp    $0x3b,%dl
  je     L650
L36:
  cmp    $0x5e,%dl
  je     L726
  cmp    %ecx,%eax
  je     L108
  mov    %dl,(%rbx,%rcx,1)
  jmp    L108
L707:
  mov    $0x0,%edi
L650:
  movslq %edi,%rdi
  movb   $0x3b,(%rbx,%rdi,1)
  movb   $0x0,0x1(%rbx,%rdi,1)
  jmp    L417
L714:
  mov    $0x0,%edi
  jmp    L650
L172:
  add    $0x1,%rdx
L378:
  mov    %cl,-0x2(%r8,%rdx,1)
  mov    %edx,%ecx
  sub    %eax,%ecx
  lea    -0x1(%rcx),%esi
  mov    %edx,0x1c(%rsp)
  movzbl (%rbx,%rdx,1),%ecx
  cmp    $0x3b,%cl
  ja     L172
  add    $0x1,%rdx
  bt     %rcx,%r15
  jae    L378
L426:
  movslq %esi,%rcx
  movb   $0x0,0x20(%rsp,%rcx,1)
  lea    0x20(%rsp),%rdi
  call   <atof@plt>
  addss  0x8(%rsp),%xmm0
  movss  %xmm0,0x8(%rsp)
  mov    0x1c(%rsp),%eax
  jmp    L696
L404:
  add    $0x1,%rdx
L697:
  mov    %edx,%eax
  movzbl (%rbx,%rdx,1),%ecx
  cmp    $0x3b,%cl
  ja     L404
  add    $0x1,%rdx
  bt     %rcx,%r13
  jae    L697
  jmp    L21
L786:
  add    $0x1,%rdx
L323:
  mov    %edx,%eax
  movzbl (%rbx,%rdx,1),%ecx
  cmp    $0x3b,%cl
  ja     L786
  add    $0x1,%rdx
  bt     %rcx,%r13
  jae    L323
L21:
  movslq %eax,%rdi
  lea    (%rbx,%rdi,1),%rsi
  mov    %rsi,0x10(%rsp)
  cmpb   $0x3a,(%rsi)
  je     L712
L696:
  cltq
  lea    (%rbx,%rax,1),%rdx
  movzbl (%rdx),%ecx
  cmp    $0x3b,%cl
  je     L208
  test   %cl,%cl
  je     L208
  mov    $0x1,%eax
  lea    0x8f(%rsp),%rdi
L362:
  mov    %cl,(%rdi,%rax,1)
  mov    %eax,%esi
  movzbl (%rdx,%rax,1),%ecx
  add    $0x1,%rax
  cmp    $0x3b,%cl
  je     L539
  test   %cl,%cl
  jne    L362
L539:
  movslq %esi,%rax
  movb   $0x3b,0x90(%rsp,%rax,1)
  lea    0x1(%rsi),%eax
  cltq
  movb   $0x0,0x90(%rsp,%rax,1)
  mov    0x10(%rsp),%rax
  movb   $0x0,(%rax)
  movb   $0x0,0x20(%rsp)
  lea    0x20(%rsp),%rax
  movss  0x8(%rsp),%xmm0
  lea    D1(%rip),%rsi
  mov    %rax,0x8(%rsp)
  mov    %rax,%rdi
  call   <sprintf@plt>
  mov    0x8(%rsp),%rsi
  mov    %rbx,%rdi
  call   <strcat@plt>
  lea    0x90(%rsp),%rsi
  mov    %rbx,%rdi
  call   <strcat@plt>
  mov    $0x1,%edx
  jmp    L418
L290:
  add    $0x1,%rax
L343:
  cmp    $0x3a,%cl
  je     L595
  movslq %edx,%rdi
  mov    %cl,0x20(%rsp,%rdi,1)
  add    $0x1,%edx
L595:
  movb   $0x5e,(%rsi,%rax,1)
  lea    (%r8,%rax,1),%ebp
  movzbl 0x1(%rsi,%rax,1),%ecx
  cmp    $0x3b,%cl
  ja     L290
  add    $0x1,%rax
  bt     %rcx,%r15
  jae    L343
L53:
  movslq %edx,%rdx
  movb   $0x0,0x20(%rsp,%rdx,1)
  jmp    L372
L346:
  add    $0x1,%rax
L628:
  movb   $0x5e,(%rcx)
  mov    %eax,%ebp
  lea    (%rbx,%rax,1),%rcx
  movzbl (%rbx,%rax,1),%edx
  cmp    $0x3b,%dl
  ja     L346
  add    $0x1,%rax
  bt     %rdx,%r13
  jae    L628
L32:
  cmp    $0x3a,%dl
  je     L613
L372:
  mov    $0x1,%edx
  cmpb   $0x0,0x20(%rsp)
  je     L418
  lea    0x20(%rsp),%rdi
  call   <atof@plt>
  movss  %xmm0,0x8(%rsp)
  lea    0x1(%rbp),%eax
  movslq %eax,%rdx
  movzbl (%rbx,%rdx,1),%edx
  cmp    $0x28,%dl
  je     L636
  cmp    $0x3b,%dl
  ja     L158
  bt     %rdx,%r13
  jb     L21
L158:
  lea    0x2(%rbp),%edx
  movslq %edx,%rdx
  jmp    L323
L333:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: disassemble_data
arguments: data_label: D1
type_infered: string

tool: D1: :%f

assistant: ```c
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';
  }
}
```