user: Converte this assembly snippet into its equivalent C code:

```asm
<main>:
  endbr64
  push   %r15
  lea    D382(%rip),%rdi
  push   %r14
  push   %r13
  lea    D46(%rip),%r13
  push   %r12
  lea    D3(%rip),%r12
  push   %rbp
  lea    D80(%rip),%rbp
  push   %rbx
  sub    $0xd8,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,0xc8(%rsp)
  xor    %eax,%eax
  lea    0x70(%rsp),%rbx
  lea    0x90(%rsp),%r14
  call   <logComment@plt>
  lea    0x68(%rsp),%rax
  mov    %r13,%rdx
  mov    %rbp,%rdi
  mov    %rax,%rcx
  lea    D73(%rip),%rsi
  mov    %rax,(%rsp)
  lea    0x98(%rsp),%r15
  call   <logVarInScope@plt>
  mov    %rbx,%rcx
  mov    %r13,%rdx
  mov    %rbp,%rdi
  lea    D264(%rip),%rsi
  mov    %rbx,0x8(%rsp)
  lea    D78(%rip),%rbx
  call   <logVarInScope@plt>
  lea    0x78(%rsp),%rdx
  mov    %rbp,%rdi
  lea    D209(%rip),%rsi
  mov    %rdx,0x10(%rsp)
  mov    %rdx,%rcx
  mov    %r12,%rdx
  call   <logVarInScope@plt>
  lea    0x80(%rsp),%rsi
  mov    %r12,%rdx
  mov    %rbp,%rdi
  mov    %rsi,0x18(%rsp)
  mov    %rsi,%rcx
  lea    D49(%rip),%rsi
  call   <logVarInScope@plt>
  lea    0x88(%rsp),%rdi
  mov    %r12,%rdx
  lea    D403(%rip),%rsi
  mov    %rdi,0x20(%rsp)
  mov    %rdi,%rcx
  mov    %rbp,%rdi
  call   <logVarInScope@plt>
  mov    %r14,%rcx
  mov    %r12,%rdx
  mov    %rbp,%rdi
  lea    D303(%rip),%rsi
  mov    %r14,0x28(%rsp)
  lea    D95(%rip),%r14
  call   <logVarInScope@plt>
  mov    %r15,%rcx
  mov    %r12,%rdx
  mov    %rbp,%rdi
  lea    D30(%rip),%rsi
  mov    %r15,0x30(%rsp)
  lea    D298(%rip),%r15
  call   <logVarInScope@plt>
  lea    0xa0(%rsp),%r10
  mov    %r12,%rdx
  mov    %rbp,%rdi
  mov    %r10,%rcx
  lea    D326(%rip),%rsi
  mov    %r10,0x38(%rsp)
  call   <logVarInScope@plt>
  lea    0xa8(%rsp),%r11
  mov    %r12,%rdx
  mov    %rbp,%rdi
  mov    %r11,%rcx
  lea    D311(%rip),%rsi
  mov    %r11,0x40(%rsp)
  call   <logVarInScope@plt>
  mov    %r12,%rdx
  mov    %rbp,%rdi
  mov    %r15,%rsi
  lea    0xb0(%rsp),%r8
  mov    %r8,%rcx
  mov    %r8,0x48(%rsp)
  call   <logVarInScope@plt>
  lea    D48(%rip),%r11
  mov    %r12,%rdx
  mov    %rbp,%rdi
  lea    0xb8(%rsp),%r9
  mov    %r11,%rsi
  mov    %r9,%rcx
  mov    %r9,0x50(%rsp)
  call   <logVarInScope@plt>
  mov    %r12,%rdx
  mov    %rbp,%rdi
  mov    %r14,%rsi
  lea    0xc0(%rsp),%r10
  lea    D418(%rip),%rbp
  mov    %r10,%rcx
  mov    %r10,0x58(%rsp)
  call   <logVarInScope@plt>
  xor    %eax,%eax
  call   <create@plt>
  mov    $0x39,%esi
  mov    %rbp,%rdi
  mov    %rax,0x70(%rsp)
  call   <logBlockEntry@plt>
  sub    $0x8,%rsp
  mov    %r13,%rcx
  mov    %rbp,%rdi
  lea    D187(%rip),%r9
  push   $0x0
  mov    $0x39,%esi
  lea    D264(%rip),%r8
  push   %r9
  push   %rbx
  mov    0x28(%rsp),%rdx
  mov    0x90(%rsp),%r9
  call   <logAssignNoOffset@plt>
  add    $0x20,%rsp
  xor    %eax,%eax
  call   <dumpVarsOutOfScope@plt>
  mov    0x70(%rsp),%r9
  mov    %r13,%rcx
  mov    %rbp,%rdi
  lea    D264(%rip),%rax
  lea    D73(%rip),%r8
  mov    $0x39,%esi
  mov    %r9,0x68(%rsp)
  sub    $0x8,%rsp
  lea    D130(%rip),%r13
  push   $0x0
  push   %rax
  push   %rbx
  mov    0x20(%rsp),%rdx
  lea    D293(%rip),%rbx
  call   <logAssignNoOffset@plt>
  add    $0x20,%rsp
  mov    $0x3b,%esi
  mov    %rbp,%rdi
  call   <logBlockExit@plt>
  mov    $0x1,%edi
  call   <node_malloc@plt>
  mov    $0x3b,%esi
  mov    %rbp,%rdi
  mov    %rax,0x80(%rsp)
  call   <logBlockEntry@plt>
  sub    $0x8,%rsp
  mov    %r12,%rcx
  mov    %rbp,%rdi
  push   $0x0
  lea    D49(%rip),%r8
  mov    $0x3b,%esi
  push   %r13
  push   %rbx
  mov    0x38(%rsp),%rdx
  mov    0xa0(%rsp),%r9
  call   <logAssignNoOffset@plt>
  add    $0x20,%rsp
  xor    %eax,%eax
  call   <dumpVarsOutOfScope@plt>
  mov    %r12,%rcx
  mov    $0x3b,%esi
  mov    %rbp,%rdi
  mov    0x80(%rsp),%r9
  lea    D49(%rip),%rax
  lea    D209(%rip),%r8
  mov    %r9,0x78(%rsp)
  sub    $0x8,%rsp
  push   $0x0
  push   %rax
  push   %rbx
  mov    0x30(%rsp),%rdx
  call   <logAssignNoOffset@plt>
  add    $0x20,%rsp
  mov    $0x3c,%esi
  mov    %rbp,%rdi
  call   <logBlockExit@plt>
  mov    $0x2,%edi
  call   <node_malloc@plt>
  mov    $0x3c,%esi
  mov    %rbp,%rdi
  mov    %rax,0x90(%rsp)
  call   <logBlockEntry@plt>
  sub    $0x8,%rsp
  mov    %r12,%rcx
  mov    %rbp,%rdi
  push   $0x0
  lea    D303(%rip),%r8
  mov    $0x3c,%esi
  push   %r13
  push   %rbx
  mov    0x48(%rsp),%rdx
  mov    0xb0(%rsp),%r9
  call   <logAssignNoOffset@plt>
  add    $0x20,%rsp
  xor    %eax,%eax
  call   <dumpVarsOutOfScope@plt>
  mov    %r12,%rcx
  mov    $0x3c,%esi
  mov    %rbp,%rdi
  mov    0x90(%rsp),%r9
  lea    D303(%rip),%rax
  lea    D403(%rip),%r8
  mov    %r9,0x88(%rsp)
  sub    $0x8,%rsp
  push   $0x0
  push   %rax
  push   %rbx
  mov    0x40(%rsp),%rdx
  call   <logAssignNoOffset@plt>
  add    $0x20,%rsp
  mov    $0x3d,%esi
  mov    %rbp,%rdi
  call   <logBlockExit@plt>
  mov    $0x3,%edi
  call   <node_malloc@plt>
  mov    $0x3d,%esi
  mov    %rbp,%rdi
  mov    %rax,0xa0(%rsp)
  call   <logBlockEntry@plt>
  sub    $0x8,%rsp
  mov    %r12,%rcx
  mov    %rbp,%rdi
  push   $0x0
  lea    D326(%rip),%r8
  mov    $0x3d,%esi
  push   %r13
  push   %rbx
  mov    0x58(%rsp),%rdx
  mov    0xc0(%rsp),%r9
  call   <logAssignNoOffset@plt>
  add    $0x20,%rsp
  xor    %eax,%eax
  call   <dumpVarsOutOfScope@plt>
  mov    %r12,%rcx
  mov    $0x3d,%esi
  mov    %rbp,%rdi
  mov    0xa0(%rsp),%r9
  lea    D326(%rip),%rax
  lea    D30(%rip),%r8
  mov    %r9,0x98(%rsp)
  sub    $0x8,%rsp
  push   $0x0
  push   %rax
  push   %rbx
  mov    0x50(%rsp),%rdx
  call   <logAssignNoOffset@plt>
  add    $0x20,%rsp
  mov    $0x3e,%esi
  mov    %rbp,%rdi
  call   <logBlockExit@plt>
  mov    $0x4,%edi
  call   <node_malloc@plt>
  mov    $0x3e,%esi
  mov    %rbp,%rdi
  mov    %rax,0xb0(%rsp)
  call   <logBlockEntry@plt>
  sub    $0x8,%rsp
  mov    %r12,%rcx
  mov    %r15,%r8
  push   $0x0
  mov    $0x3e,%esi
  mov    %rbp,%rdi
  push   %r13
  push   %rbx
  mov    0x68(%rsp),%rdx
  mov    0xd0(%rsp),%r9
  call   <logAssignNoOffset@plt>
  add    $0x20,%rsp
  xor    %eax,%eax
  call   <dumpVarsOutOfScope@plt>
  mov    %r12,%rcx
  mov    $0x3e,%esi
  mov    %rbp,%rdi
  mov    0xb0(%rsp),%r9
  lea    D311(%rip),%r8
  mov    %r9,0xa8(%rsp)
  sub    $0x8,%rsp
  push   $0x0
  push   %r15
  push   %rbx
  mov    0x60(%rsp),%rdx
  call   <logAssignNoOffset@plt>
  add    $0x20,%rsp
  mov    $0x3f,%esi
  mov    %rbp,%rdi
  call   <logBlockExit@plt>
  mov    $0x5,%edi
  call   <node_malloc@plt>
  mov    $0x3f,%esi
  mov    %rbp,%rdi
  mov    %rax,0xc0(%rsp)
  call   <logBlockEntry@plt>
  sub    $0x8,%rsp
  mov    %r12,%rcx
  mov    %r14,%r8
  push   $0x0
  mov    $0x3f,%esi
  mov    %rbp,%rdi
  push   %r13
  push   %rbx
  mov    0x78(%rsp),%rdx
  mov    0xe0(%rsp),%r9
  call   <logAssignNoOffset@plt>
  add    $0x20,%rsp
  xor    %eax,%eax
  call   <dumpVarsOutOfScope@plt>
  mov    %r12,%rcx
  mov    $0x3f,%esi
  mov    %rbp,%rdi
  mov    0xc0(%rsp),%r9
  lea    D48(%rip),%r11
  lea    D356(%rip),%r12
  mov    %r11,%r8
  mov    %r9,0xb8(%rsp)
  sub    $0x8,%rsp
  push   $0x0
  push   %r14
  push   %rbx
  mov    0x70(%rsp),%rbx
  mov    %rbx,%rdx
  call   <logAssignNoOffset@plt>
  add    $0x20,%rsp
  mov    $0x40,%esi
  mov    %rbp,%rdi
  call   <logBlockExit@plt>
  mov    0x78(%rsp),%rsi
  mov    0x68(%rsp),%rdi
  call   <insertHead@plt>
  mov    $0xffffffff,%esi
  mov    %r12,%rdi
  call   <logBlockEntry@plt>
  xor    %eax,%eax
  call   <dumpVarsOutOfScope@plt>
  mov    $0x41,%esi
  mov    %rbp,%rdi
  call   <logBlockExit@plt>
  mov    0x88(%rsp),%rsi
  mov    0x68(%rsp),%rdi
  call   <insertHead@plt>
  mov    $0xffffffff,%esi
  mov    %r12,%rdi
  call   <logBlockEntry@plt>
  xor    %eax,%eax
  call   <dumpVarsOutOfScope@plt>
  mov    $0x42,%esi
  mov    %rbp,%rdi
  call   <logBlockExit@plt>
  mov    0x98(%rsp),%rsi
  mov    0x68(%rsp),%rdi
  call   <insertHead@plt>
  mov    $0xffffffff,%esi
  mov    %r12,%rdi
  call   <logBlockEntry@plt>
  xor    %eax,%eax
  call   <dumpVarsOutOfScope@plt>
  mov    $0x43,%esi
  mov    %rbp,%rdi
  call   <logBlockExit@plt>
  mov    0xa8(%rsp),%rsi
  mov    0x68(%rsp),%rdi
  call   <insertHead@plt>
  mov    $0xffffffff,%esi
  mov    %r12,%rdi
  call   <logBlockEntry@plt>
  xor    %eax,%eax
  call   <dumpVarsOutOfScope@plt>
  mov    $0x44,%esi
  mov    %rbp,%rdi
  call   <logBlockExit@plt>
  mov    0xb8(%rsp),%rsi
  mov    0x68(%rsp),%rdi
  call   <insertHead@plt>
  mov    $0xffffffff,%esi
  mov    %r12,%rdi
  call   <logBlockEntry@plt>
  xor    %eax,%eax
  call   <dumpVarsOutOfScope@plt>
  mov    $0xffffffff,%esi
  mov    %r12,%rdi
  call   <logBlockExit@plt>
  mov    (%rsp),%rsi
  lea    D73(%rip),%rdi
  call   <logVarOutOfScope@plt>
  mov    0x8(%rsp),%rsi
  lea    D264(%rip),%rdi
  call   <logVarOutOfScope@plt>
  mov    0x10(%rsp),%rsi
  lea    D209(%rip),%rdi
  call   <logVarOutOfScope@plt>
  mov    0x18(%rsp),%rsi
  lea    D49(%rip),%rdi
  call   <logVarOutOfScope@plt>
  mov    0x20(%rsp),%rsi
  lea    D403(%rip),%rdi
  call   <logVarOutOfScope@plt>
  mov    0x28(%rsp),%rsi
  lea    D303(%rip),%rdi
  call   <logVarOutOfScope@plt>
  mov    0x30(%rsp),%rsi
  lea    D30(%rip),%rdi
  call   <logVarOutOfScope@plt>
  mov    0x38(%rsp),%rsi
  lea    D326(%rip),%rdi
  call   <logVarOutOfScope@plt>
  mov    0x40(%rsp),%rsi
  lea    D311(%rip),%rdi
  call   <logVarOutOfScope@plt>
  mov    0x48(%rsp),%rsi
  mov    %r15,%rdi
  call   <logVarOutOfScope@plt>
  lea    D48(%rip),%r11
  mov    %rbx,%rsi
  mov    %r11,%rdi
  call   <logVarOutOfScope@plt>
  mov    0x58(%rsp),%rsi
  mov    %r14,%rdi
  call   <logVarOutOfScope@plt>
  lea    D77(%rip),%rdi
  call   <logComment@plt>
  mov    0xc8(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L7
  add    $0xd8,%rsp
  xor    %eax,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L7:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: read_data
arguments: tag: D382
data_type: string
name: read_data
arguments: tag: D46
data_type: string
name: read_data
arguments: tag: D3
data_type: string
name: read_data
arguments: tag: D80
data_type: string
name: read_data
arguments: tag: D73
data_type: string
name: read_data
arguments: tag: D264
data_type: string
name: read_data
arguments: tag: D78
data_type: string
name: read_data
arguments: tag: D209
data_type: string
name: read_data
arguments: tag: D49
data_type: string
name: read_data
arguments: tag: D403
data_type: string
name: read_data
arguments: tag: D303
data_type: string
name: read_data
arguments: tag: D95
data_type: string
name: read_data
arguments: tag: D30
data_type: string
name: read_data
arguments: tag: D298
data_type: string
name: read_data
arguments: tag: D326
data_type: string
name: read_data
arguments: tag: D311
data_type: string
name: read_data
arguments: tag: D48
data_type: string
name: read_data
arguments: tag: D418
data_type: string
name: read_data
arguments: tag: D187
data_type: string
name: read_data
arguments: tag: D130
data_type: string
name: read_data
arguments: tag: D293
data_type: string
name: read_data
arguments: tag: D356
data_type: string
name: read_data
arguments: tag: D77
data_type: string

tool: D382: Function Entered

tool: D46: struct dll *

tool: D3: struct node *

tool: D80: local

tool: D73: dll

tool: D264: tmp

tool: D78: struct dll

tool: D209: n1

tool: D49: tmp___0

tool: D403: n2

tool: D303: tmp___1

tool: D95: tmp___4

tool: D30: n3

tool: D298: tmp___3

tool: D326: tmp___2

tool: D311: n4

tool: D48: n5

tool: D418: dll_2.c

tool: D187: create

tool: D130: node_malloc

tool: D293: struct node

tool: 

tool: D77: Function Exited

assistant: ```c
int main(void) {
  struct dll *dll;
  struct dll *tmp;
  struct node *n1;
  struct node *tmp___0;
  struct node *n2;
  struct node *tmp___1;
  struct node *n3;
  struct node *tmp___2;
  struct node *n4;
  struct node *tmp___3;
  struct node *n5;
  struct node *tmp___4;
  {
    logComment("Function Entered");
    logVarInScope("local", "dll", "struct dll *", &dll);
    logVarInScope("local", "tmp", "struct dll *", &tmp);
    logVarInScope("local", "n1", "struct node *", &n1);
    logVarInScope("local", "tmp___0", "struct node *", &tmp___0);
    logVarInScope("local", "n2", "struct node *", &n2);
    logVarInScope("local", "tmp___1", "struct node *", &tmp___1);
    logVarInScope("local", "n3", "struct node *", &n3);
    logVarInScope("local", "tmp___2", "struct node *", &tmp___2);
    logVarInScope("local", "n4", "struct node *", &n4);
    logVarInScope("local", "tmp___3", "struct node *", &tmp___3);
    logVarInScope("local", "n5", "struct node *", &n5);
    logVarInScope("local", "tmp___4", "struct node *", &tmp___4);
    tmp = create();
    logBlockEntry("dll_2.c", 57);
    logAssignNoOffset("dll_2.c", 57, &tmp, "struct dll *", "tmp", tmp, "struct dll", "create", 0);
    dumpVarsOutOfScope();
    dll = tmp;
    logAssignNoOffset("dll_2.c", 57, &dll, "struct dll *", "dll", dll, "struct dll", "tmp", 0);
    logBlockExit("dll_2.c", 59);
    tmp___0 = node_malloc(1);
    logBlockEntry("dll_2.c", 59);
    logAssignNoOffset("dll_2.c", 59, &tmp___0, "struct node *", "tmp___0", tmp___0, "struct node", "node_malloc", 0);
    dumpVarsOutOfScope();
    n1 = tmp___0;
    logAssignNoOffset("dll_2.c", 59, &n1, "struct node *", "n1", n1, "struct node", "tmp___0", 0);
    logBlockExit("dll_2.c", 60);
    tmp___1 = node_malloc(2);
    logBlockEntry("dll_2.c", 60);
    logAssignNoOffset("dll_2.c", 60, &tmp___1, "struct node *", "tmp___1", tmp___1, "struct node", "node_malloc", 0);
    dumpVarsOutOfScope();
    n2 = tmp___1;
    logAssignNoOffset("dll_2.c", 60, &n2, "struct node *", "n2", n2, "struct node", "tmp___1", 0);
    logBlockExit("dll_2.c", 61);
    tmp___2 = node_malloc(3);
    logBlockEntry("dll_2.c", 61);
    logAssignNoOffset("dll_2.c", 61, &tmp___2, "struct node *", "tmp___2", tmp___2, "struct node", "node_malloc", 0);
    dumpVarsOutOfScope();
    n3 = tmp___2;
    logAssignNoOffset("dll_2.c", 61, &n3, "struct node *", "n3", n3, "struct node", "tmp___2", 0);
    logBlockExit("dll_2.c", 62);
    tmp___3 = node_malloc(4);
    logBlockEntry("dll_2.c", 62);
    logAssignNoOffset("dll_2.c", 62, &tmp___3, "struct node *", "tmp___3", tmp___3, "struct node", "node_malloc", 0);
    dumpVarsOutOfScope();
    n4 = tmp___3;
    logAssignNoOffset("dll_2.c", 62, &n4, "struct node *", "n4", n4, "struct node", "tmp___3", 0);
    logBlockExit("dll_2.c", 63);
    tmp___4 = node_malloc(5);
    logBlockEntry("dll_2.c", 63);
    logAssignNoOffset("dll_2.c", 63, &tmp___4, "struct node *", "tmp___4", tmp___4, "struct node", "node_malloc", 0);
    dumpVarsOutOfScope();
    n5 = tmp___4;
    logAssignNoOffset("dll_2.c", 63, &n5, "struct node *", "n5", n5, "struct node", "tmp___4", 0);
    logBlockExit("dll_2.c", 64);
    insertHead(dll, n1);
    logBlockEntry("", -1);
    dumpVarsOutOfScope();
    logBlockExit("dll_2.c", 65);
    insertHead(dll, n2);
    logBlockEntry("", -1);
    dumpVarsOutOfScope();
    logBlockExit("dll_2.c", 66);
    insertHead(dll, n3);
    logBlockEntry("", -1);
    dumpVarsOutOfScope();
    logBlockExit("dll_2.c", 67);
    insertHead(dll, n4);
    logBlockEntry("", -1);
    dumpVarsOutOfScope();
    logBlockExit("dll_2.c", 68);
    insertHead(dll, n5);
    logBlockEntry("", -1);
    dumpVarsOutOfScope();
    logBlockExit("", -1);
    {
      logVarOutOfScope("dll", &dll);
      logVarOutOfScope("tmp", &tmp);
      logVarOutOfScope("n1", &n1);
      logVarOutOfScope("tmp___0", &tmp___0);
      logVarOutOfScope("n2", &n2);
      logVarOutOfScope("tmp___1", &tmp___1);
      logVarOutOfScope("n3", &n3);
      logVarOutOfScope("tmp___2", &tmp___2);
      logVarOutOfScope("n4", &n4);
      logVarOutOfScope("tmp___3", &tmp___3);
      logVarOutOfScope("n5", &n5);
      logVarOutOfScope("tmp___4", &tmp___4);
      {
        logComment("Function Exited");
        return (0);
      }
    }
  }
}
```