LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/c2xml.c
// Function: examine_members
static inline void examine_members(struct symbol_list *list, xmlNodePtr node)
{
	struct symbol *sym;

	FOR_EACH_PTR(list, sym) {
		examine_symbol(sym, node);
	} END_FOR_EACH_PTR(sym);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x12061
jmp 0x120da
jmp 0x12063
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x120c6
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x120ae
cmpq $0x0, -0x18(%rbp)
jne 0x120ae
jmp 0x120bb
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11920
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1206a
jmp 0x120c8
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x12063
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/accre[P]Cprogramming/pass_command_line_options.c
// Function: main
int main(int argc, char **argv)
{

   // argc captures the number of command-line arguments
   // note: The executable command (./command_line) is 
   // always the first argument, and the remaining arguments
   // are separated by spaces      
   printf("argc: %d\n",argc);
   if ( argc != 3 ) {
      printf("Usage: ./pass_command_line_options arg1 arg2\n");
      printf("where arg1 is an integer and arg2 is a floating point number\n");
      exit(0);
   }
   
   // argv captures each argument in an array of characters
   // Here we loop over all arguments and print the value
   int i;
   for (i=0;i<argc;i++) {
      // %d is for integers, %s is for an array of characters
      printf("i: %d argv[i]: %s\n",i,argv[i]); 
   }

   // since command-line arguments are read in as an 
   // array of characters, they must be converted
   // to the appropriate type (e.g. int, float)
   i = 1;
   int myarg_int = 0;
   float myarg_float = 0.0;
   if ( argc > 1 ) myarg_int = atoi(argv[i]);
   ++i; 
   if ( argc > 2 ) myarg_float = atof(argv[i]);

   // %d is for integer
   // %10.5f is for the floating point number, 10 is the width of the number
   // and 5 is the precision after the decimal point. If more precision is 
   // needed, 10.5 can be changed.
   printf("myarg_int: %d myarg_float: %10.5f\n",myarg_int,myarg_float);

   return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %esi
leaq 0xe74(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
cmpl $0x3, -0x8(%rbp)
je 0x11c0
leaq 0xe6a(%rip), %rdi       # 0x200e
movb $0x0, %al
callq 0x1040
leaq 0xe8a(%rip), %rdi       # 0x203c
movb $0x0, %al
callq 0x1040
xorl %edi, %edi
callq 0x1060
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x11f7
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0xe95(%rip), %rdi       # 0x207a
movb $0x0, %al
callq 0x1040
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11c7
movl $0x1, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x1227
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1050
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x2, -0x8(%rbp)
jle 0x1250
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movl -0x18(%rbp), %esi
movss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xe2a(%rip), %rdi       # 0x208d
movb $0x1, %al
callq 0x1040
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/ast.c
// Function: ast_new
struct ast *ast_new(struct loc *loc, enum ast_tag tag)
{
    struct ast *ast = malloc(sizeof *ast);
    ast->loc = loc;
    ast->tag = tag;
    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x18, %edi
callq 0x2170
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/ast.c
// Function: ast_new_s
struct ast *ast_new_s(struct loc *loc, enum ast_tag tag, char *s)
{
    struct ast_s *ast = malloc(sizeof *ast);
    ast->ast.tag = tag;
    ast->ast.loc = loc;
    ast->s = strdup(s);
    return (struct ast *)ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x20, %edi
callq 0x2170
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x2210
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/ast.c
// Function: ast_new_chars
struct ast *ast_new_chars(struct loc *loc, enum ast_tag tag, char *s, size_t n)
{
    struct ast_chars *ast = malloc(sizeof *ast);
    ast->ast.tag = tag;
    ast->ast.loc = loc;
    ast->s = strdup(s);
    ast->n = n;
    return (struct ast *)ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x28, %edi
callq 0x2170
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x2210
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/ast.c
// Function: ast_new_i
struct ast *ast_new_i(struct loc *loc, enum ast_tag tag, long long int i)
{
    struct ast_i *ast = malloc(sizeof *ast);
    ast->ast.tag = tag;
    ast->ast.loc = loc;
    ast->i = i;
    return (struct ast *)ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x20, %edi
callq 0x2170
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/ast.c
// Function: ast_new_f
struct ast *ast_new_f(struct loc *loc, enum ast_tag tag, double f)
{
    struct ast_f *ast = malloc(sizeof *ast);
    ast->ast.tag = tag;
    ast->ast.loc = loc;
    ast->f = f;
    return (struct ast *)ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movl $0x20, %edi
callq 0x2170
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/ast.c
// Function: ast_new_ast
struct ast *ast_new_ast(struct loc *loc, enum ast_tag tag, size_t n_childs, ...)
{
    struct ast_ast *ast = malloc(sizeof *ast + n_childs * sizeof *ast->childs);
    ast->ast.tag = tag;
    ast->ast.loc = loc;
    ast->n_childs = n_childs;
    
    va_list va;
    va_start(va, n_childs);

    for (size_t i = 0; i < n_childs; i++)
        ast->childs[i] = va_arg(va, struct ast *);

    va_end(va);
    return (struct ast *)ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
testb %al, %al
je 0x254e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
shlq $0x3, %rdi
addq $0x20, %rdi
callq 0x2170
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
leaq -0x40(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x265e
leaq -0x40(%rbp), %rax
movq %rax, -0x110(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x104(%rbp)
cmpl $0x28, %eax
ja 0x2619
movq -0x110(%rbp), %rcx
movl -0x104(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x118(%rbp)
jmp 0x2636
movq -0x110(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x118(%rbp)
movq -0x118(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rdx, 0x20(%rax,%rcx,8)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x25d0
movq -0x20(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/ast.c
// Function: ast_new_list
struct ast *ast_new_list(struct loc *loc, enum ast_tag tag, struct ast_list *ast_list)
{
    size_t n_childs = 0;
    for (struct ast_list *i = ast_list; i != NULL; i = i->next)
        n_childs++;

    struct ast_ast *ast = malloc(sizeof *ast + n_childs * sizeof *ast->childs);
    ast->ast.tag = tag;
    ast->ast.loc = loc;
    ast->n_childs = n_childs;

    size_t i = 0;
    for (struct ast_list *j = ast_list; j != NULL; j = j->next)
        ast->childs[i++] = ast_ref(j->ast);

    ast_list_del(ast_list);
    return (struct ast *)ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x26b4
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x2693
movq -0x20(%rbp), %rdi
shlq $0x3, %rdi
addq $0x20, %rdi
callq 0x2170
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x2736
movq -0x40(%rbp), %rax
movq (%rax), %rdi
callq 0x2750
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x38(%rbp)
movq %rdx, 0x20(%rax,%rcx,8)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x26fa
movq -0x18(%rbp), %rdi
callq 0x2760
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/ast.c
// Function: ast_list_del
void ast_list_del(struct ast_list *ast_list)
{
    if (ast_list == NULL)
        return;

    ast_unref(ast_list->ast);
    ast_list_del(ast_list->next);
    free(ast_list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2775
jmp 0x2797
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x27e0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2760
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/ast.c
// Function: ast_chars
const char *ast_chars(struct ast *ast, size_t *n)
{
    assert(ast_has_chars(ast->tag));
    struct ast_chars *a = (struct ast_chars *)ast;
    *n = a->n;
    return a->s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x28f0
testb $0x1, %al
jne 0x28c7
leaq 0xf75e(%rip), %rdi      # 0x12004
leaq 0xf779(%rip), %rsi      # 0x12026
movl $0x7a, %edx
leaq 0xf78d(%rip), %rcx      # 0x12046
leaq 0xf79e(%rip), %r8       # 0x1205e
movb $0x0, %al
callq 0x6510
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/ast.c
// Function: ast_asts
struct ast **ast_asts(struct ast *ast, size_t *n_childs)
{
    assert(ast_has_ast(ast->tag));
    assert(n_childs);

    *n_childs = ((struct ast_ast *)ast)->n_childs;
    return ((struct ast_ast *)ast)->childs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x2aa0
testb $0x1, %al
jne 0x2b17
leaq 0xf50e(%rip), %rdi      # 0x12004
leaq 0xf529(%rip), %rsi      # 0x12026
movl $0x99, %edx
leaq 0xf593(%rip), %rcx      # 0x1209c
leaq 0xf5aa(%rip), %r8       # 0x120ba
movb $0x0, %al
callq 0x6510
cmpq $0x0, -0x10(%rbp)
jne 0x2b46
leaq 0xf4df(%rip), %rdi      # 0x12004
leaq 0xf4fa(%rip), %rsi      # 0x12026
movl $0x9a, %edx
leaq 0xf58b(%rip), %rcx      # 0x120c3
leaq 0xf57b(%rip), %r8       # 0x120ba
movb $0x0, %al
callq 0x6510
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
addq $0x20, %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/ast.c
// Function: ast_print_childs
static void ast_print_childs(struct ast *ast, int indent)
{
    size_t n_childs;
    struct ast **childs = ast_asts(ast, &n_childs);

    for (size_t i = 0; i < n_childs; i++) {
        ast_print(childs[i], indent + 1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2ad0
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x3857
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x3620
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3828
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/codegen.c
// Function: new_lbl
struct lbl *new_lbl(const char *name, bool defined)
{
    struct lbl *lbl = malloc(sizeof *lbl);
    lbl->name = strdup(name);
    lbl->c_name = gen_c_ident();
    lbl->defined = defined;
    lbl->next = lbl_list;
    lbl_list = lbl;

    strmap_add(zc_func_labels, name, lbl);

    return lbl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movl $0x28, %edi
callq 0x2170
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2210
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
callq 0x3b10
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movb -0x9(%rbp), %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x10(%rax)
movq 0x162a7(%rip), %rcx     # 0x19d80
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x16294(%rip)     # 0x19d80
leaq 0x16325(%rip), %rax     # 0x19e18
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf860
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/codegen.c
// Function: check_lbl_list
void check_lbl_list(struct lbl *lbl_node)
{
    if (lbl_node == NULL)
        return;

    if (!lbl_node->defined)
        fatal(lbl_node->first_use->loc, "undefined label %s", lbl_node->name);

    free(lbl_node->name);
    free(lbl_node->c_name);
    check_lbl_list(lbl_node->next);
    free(lbl_node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3b75
jmp 0x3bcf
movq -0x8(%rbp), %rax
testb $0x1, 0x10(%rax)
jne 0x3ba0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0xe8b5(%rip), %rsi      # 0x1244e
movb $0x0, %al
callq 0x6610
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3b60
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/codegen.c
// Function: goto_label
const char *goto_label(const char *name, struct ast *goto_stmt)
{
    struct lbl *lbl = strmap_get(zc_func_labels, name);

    if (lbl != NULL)
        return lbl->c_name;

    lbl = new_lbl(name, false);
    lbl->first_use = goto_stmt;

    return lbl->c_name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x16221(%rip), %rax     # 0x19e18
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xf760
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3c1c
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3c43
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3a80
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/codegen.c
// Function: define_label
const char *define_label(const char *name)
{
    struct lbl *lbl = strmap_get(zc_func_labels, name);

    if (lbl != NULL) {
        lbl->defined = true;
        return lbl->c_name;
    }

    lbl = new_lbl(name, true);
    return lbl->c_name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x161b5(%rip), %rax     # 0x19e18
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xf760
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3c90
movq -0x18(%rbp), %rax
movb $0x1, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3cae
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x3a80
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/codegen.c
// Function: add_indent_lev
struct rope *add_indent_lev(struct rope *rope, size_t lev)
{
    if (rope == NULL)
        return NULL;
    for (int i = 0; i < lev; i++)
        rope = rope_new_tree(indent_rope, rope);
    return rope;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3d31
movq $0x0, -0x8(%rbp)
jmp 0x3d69
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x3d61
movq -0x10(%rbp), %rsi
leaq 0x15523(%rip), %rdi     # 0x19270
callq 0xf2a0
movq %rax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3d38
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/codegen.c
// Function: ptr_type_to_c
struct rope *ptr_type_to_c(struct rope *decl, struct ptr_type *type)
{
    decl = rope_new_tree(star_rope, decl);
    if (is_func_type(type->to) || is_array_type(type->to))
        decl = add_paren(decl);

    return type_to_c(decl, type->to);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x15845(%rip), %rdi     # 0x19650
callq 0xf2a0
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3e60
testb $0x1, %al
jne 0x3e38
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3e80
testb $0x1, %al
jne 0x3e38
jmp 0x3e45
movq -0x8(%rbp), %rdi
callq 0x3ea0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3ee0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/codegen.c
// Function: type_to_c
struct rope *type_to_c(struct rope *decl, struct type *type)
{
    switch (type_type(type->tag)) {
        case PTR_TYPE_FLAG:
            return ptr_type_to_c(decl, (struct ptr_type *)type);
        case ARRAY_TYPE_FLAG:
            return array_type_to_c(decl, (struct array_type *)type);
        case FUNC_TYPE_FLAG:
            return func_type_to_c(decl, (struct func_type *)type);
        case STRUCT_TYPE_FLAG:
            return struct_type_to_c(decl, (struct struct_type *)type);
        case VOID_TYPE_FLAG:
        case BOOL_TYPE_FLAG:
        case INT_TYPE_FLAG:
        case FLOAT_TYPE_FLAG:
        case EXTERN_TYPE_FLAG:
            return basic_type_to_c(decl, type);
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x4340
movl %eax, %ecx
movl %ecx, %eax
decl %eax
movl %ecx, -0x1c(%rbp)
subl $0x2, %eax
jb 0x3fa9
jmp 0x3f0f
movl -0x1c(%rbp), %eax
subl $0x4, %eax
je 0x3fa9
jmp 0x3f1d
movl -0x1c(%rbp), %eax
subl $0x8, %eax
je 0x3f5d
jmp 0x3f27
movl -0x1c(%rbp), %eax
subl $0x10, %eax
je 0x3f70
jmp 0x3f31
movl -0x1c(%rbp), %eax
subl $0x20, %eax
je 0x3f83
jmp 0x3f3b
movl -0x1c(%rbp), %eax
subl $0x40, %eax
je 0x3f96
jmp 0x3f45
movl -0x1c(%rbp), %eax
subl $0x80, %eax
je 0x3fa9
jmp 0x3f51
movl -0x1c(%rbp), %eax
subl $0x200, %eax            # imm = 0x200
je 0x3fa9
jmp 0x3fbc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3df0
movq %rax, -0x8(%rbp)
jmp 0x3fc4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3fd0
movq %rax, -0x8(%rbp)
jmp 0x3fc4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4030
movq %rax, -0x8(%rbp)
jmp 0x3fc4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4280
movq %rax, -0x8(%rbp)
jmp 0x3fc4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x42f0
movq %rax, -0x8(%rbp)
jmp 0x3fc4
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/codegen.c
// Function: func_type_to_c
struct rope *func_type_to_c(struct rope *decl, struct func_type *type)
{
    decl = rope_new_tree(decl, lparen_rope);

    if (type->n_params == 0) {
        if (!type->has_vararg)
            decl = rope_new_tree(decl, void_rope);
    } else {
        for (size_t i = 0; i < type->n_params; ++i) {
            struct rope *param = type_to_c(NULL, type->params[i]);
            decl = rope_new_tree(decl, param);

            if (i != type->n_params - 1)
                decl = rope_new_tree(decl, comma_sp_rope);
        }
        if (type->has_vararg) {
            decl = rope_new_tree(decl, comma_sp_rope);
            decl = rope_new_tree(decl, ellipsis_rope);
        }
    }

    decl = rope_new_tree(decl, rparen_rope);

    return type_to_c(decl, type->ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x15245(%rip), %rsi     # 0x19290
callq 0xf2a0
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x4082
movq -0x10(%rbp), %rax
testb $0x1, 0x18(%rax)
jne 0x407d
movq -0x8(%rbp), %rdi
leaq 0x154dc(%rip), %rsi     # 0x19550
callq 0xf2a0
movq %rax, -0x8(%rbp)
jmp 0x4130
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x40fc
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x20(%rax,%rcx,8), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x3ee0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xf2a0
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
je 0x40ec
movq -0x8(%rbp), %rdi
leaq 0x1540d(%rip), %rsi     # 0x194f0
callq 0xf2a0
movq %rax, -0x8(%rbp)
jmp 0x40ee
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x408a
movq -0x10(%rbp), %rax
testb $0x1, 0x18(%rax)
je 0x412e
movq -0x8(%rbp), %rdi
leaq 0x153df(%rip), %rsi     # 0x194f0
callq 0xf2a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1540b(%rip), %rsi     # 0x19530
callq 0xf2a0
movq %rax, -0x8(%rbp)
jmp 0x4130
movq -0x8(%rbp), %rdi
leaq 0x15175(%rip), %rsi     # 0x192b0
callq 0xf2a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3ee0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/codegen.c
// Function: struct_def_to_c
struct rope *struct_def_to_c(struct struct_type *type)
{
    struct rope *rope;
    rope = rope_new_tree(struct_sp_rope, rope_new_s(type->cname));
    rope = rope_new_tree(rope, sp_rope);
    rope = rope_new_tree(rope, lcurly_nl_rope);

    for (size_t i = 0; i < type->n_fields; ++i)
        rope = rope_new_tree(rope, field_to_c(&type->fields[i]));

    return rope_new_tree(rope, rcurly_rope);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xf2f0
movq %rax, %rsi
leaq 0x1550d(%rip), %rdi     # 0x196f0
callq 0xf2a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x15479(%rip), %rsi     # 0x19670
callq 0xf2a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x15145(%rip), %rsi     # 0x19350
callq 0xf2a0
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x4268
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x4160
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0xf2a0
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x421c
movq -0x10(%rbp), %rdi
leaq 0x1513d(%rip), %rsi     # 0x193b0
callq 0xf2a0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/codegen.c
// Function: struct_type_to_c
struct rope *struct_type_to_c(struct rope *decl, struct struct_type *type)
{
    struct rope *rope = rope_new_tree(struct_sp_rope, rope_new_s(type->cname));
    if (decl != NULL) {
        rope = rope_new_tree(rope, sp_rope);
        rope = rope_new_tree(rope, decl);
    }
    return rope;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xf2f0
movq %rax, %rsi
leaq 0x15449(%rip), %rdi     # 0x196f0
callq 0xf2a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x42dc
movq -0x18(%rbp), %rdi
leaq 0x153ae(%rip), %rsi     # 0x19670
callq 0xf2a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xf2a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/codegen.c
// Function: expr_stmt_to_c
struct rope *expr_stmt_to_c(struct ast *ast)
{
    if (ast->tag == INIT_EXPR)
        return NULL;

    struct expr expr = eval_expr(NULL, ast);
    if (ast->tag == DECL)
        return NULL;
    return add_indent_nl(rope_new_tree(expr.rope, semi_rope));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x42f6, (%rax)         # imm = 0x42F6
jne 0x43c2
movq $0x0, -0x8(%rbp)
jmp 0x4409
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x81b0
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x4000, (%rax)         # imm = 0x4000
jne 0x43ed
movq $0x0, -0x8(%rbp)
jmp 0x4409
movq -0x18(%rbp), %rdi
leaq 0x150d8(%rip), %rsi     # 0x194d0
callq 0xf2a0
movq %rax, %rdi
callq 0x3db0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/codegen.c
// Function: if_stmt_to_c
struct rope *if_stmt_to_c(struct ast *ast)
{
    struct rope *rope = if_sp_lparen_rope;
    struct ast *expr_ast = ast_ast(ast, 0);
    struct ast *then_block_ast = ast_ast(ast, 1);
    struct ast *else_block_ast = ast_ast(ast, 2);

    push_scope();

    if (expr_ast != NULL) {
        struct expr expr = eval_expr(NULL, expr_ast);
        if (!is_bool_type(expr.type))
            fatal(ast->loc, "condition has to be of boolean type");
        rope = rope_new_tree(rope, expr.rope);
    } else {
        rope = rope_new_tree(rope, one_rope);
    }

    rope = rope_new_tree(rope, rparen_sp_rope);
    rope = rope_new_tree(rope, block_to_c(then_block_ast));

    if (else_block_ast) {
        rope = rope_new_tree(rope, sp_else_sp_rope);
        if (else_block_ast->tag == IF_STMT)
            rope = rope_new_tree(rope, if_stmt_to_c(else_block_ast));
        else 
            rope = rope_new_tree(rope, block_to_c(else_block_ast));
    }

    pop_scope();

    return add_indent_nl(rope);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1513d(%rip), %rax     # 0x19570
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a40
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x2a40
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x2a40
movq %rax, -0x28(%rbp)
callq 0x3cc0
cmpq $0x0, -0x18(%rbp)
je 0x44c3
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x81b0
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rdi
callq 0x4590
testb $0x1, %al
jne 0x44b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xdfbe(%rip), %rsi      # 0x12467
movb $0x0, %al
callq 0x6610
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xf2a0
movq %rax, -0x10(%rbp)
jmp 0x44d7
movq -0x10(%rbp), %rdi
leaq 0x15262(%rip), %rsi     # 0x19730
callq 0xf2a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x14e0e(%rip), %rsi     # 0x192f0
callq 0xf2a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x45b0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xf2a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4579
movq -0x10(%rbp), %rdi
leaq 0x150d2(%rip), %rsi     # 0x195f0
callq 0xf2a0
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x4101, (%rax)         # imm = 0x4101
jne 0x4556
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4420
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xf2a0
movq %rax, -0x10(%rbp)
jmp 0x4577
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
callq 0x45b0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xf2a0
movq %rax, -0x10(%rbp)
jmp 0x4579
callq 0x3cf0
movq -0x10(%rbp), %rdi
callq 0x3db0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/codegen.c
// Function: block_to_c
struct rope *block_to_c(struct ast *ast)
{
    struct rope *rope = lcurly_nl_rope;
    zc_indent_level++;

    rope = stmt_list_to_c(rope, ast, NULL);

    zc_indent_level--;
    rope = rope_new_tree(rope, add_indent(rcurly_rope));

    return rope;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x14d8d(%rip), %rax     # 0x19350
movq %rax, -0x10(%rbp)
leaq 0x157fe(%rip), %rax     # 0x19dcc
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x157f2(%rip), %rax     # 0x19dcc
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4810
movq %rax, -0x10(%rbp)
leaq 0x157d4(%rip), %rax     # 0x19dcc
movl (%rax), %ecx
addl $-0x1, %ecx
leaq 0x157c8(%rip), %rax     # 0x19dcc
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x14d9b(%rip), %rdi     # 0x193b0
callq 0x3d80
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0xf2a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/codegen.c
// Function: stmt_list_to_c
struct rope *stmt_list_to_c(struct rope *rope, struct ast *ast,
        bool *fallthrough)
{
    size_t n_stmt_asts;
    struct ast **stmt_asts = ast_asts(ast, &n_stmt_asts);

    for (size_t i = 0; i < n_stmt_asts; ++i) {
        if (stmt_asts[i]->tag == FALLTHROUGH_STMT) {
            if (fallthrough == NULL || i != n_stmt_asts - 1)
                fatal(stmt_asts[i]->loc, "fallthrough not allowed here");

            *fallthrough = true;
            break;
        }

        struct rope *c_stmt = stmt_to_c(stmt_asts[i]);
        rope = rope_new_tree(rope, c_stmt);
    }

    return rope;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2ad0
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x48d2
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x5, (%rax)
jne 0x489b
cmpq $0x0, -0x18(%rbp)
je 0x4874
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
je 0x4892
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
leaq 0xdcd2(%rip), %rsi      # 0x1255d
movb $0x0, %al
callq 0x6610
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
jmp 0x48d2
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4ed0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xf2a0
movq %rax, -0x8(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x483d
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/codegen.c
// Function: switch_block_to_c
struct rope *switch_block_to_c(struct ast *ast)
{
    struct rope *rope = lcurly_nl_rope;

    size_t n_clause_asts;
    struct ast **clause_asts = ast_asts(ast, &n_clause_asts);

    for (size_t i = 0; i < n_clause_asts; ++i) {
        struct rope *c_clause = clause_to_c(clause_asts[i]);
	if (rope != NULL)
	    rope = rope_new_tree(rope, c_clause);
    }

    rope = rope_new_tree(rope, add_indent(rcurly_rope));

    return rope;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x14a5d(%rip), %rax     # 0x19350
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2ad0
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x4957
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4640
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4947
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xf2a0
movq %rax, -0x10(%rbp)
jmp 0x4949
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4910
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x14a4a(%rip), %rdi     # 0x193b0
callq 0x3d80
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xf2a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/codegen.c
// Function: switch_stmt_to_c
struct rope *switch_stmt_to_c(struct ast *ast)
{
    struct rope *rope = switch_sp_lparen_rope;
    struct ast *expr_ast = ast_ast(ast, 0);
    struct ast *block_ast = ast_ast(ast, 1);

    push_scope();

    struct expr expr = eval_expr(NULL, expr_ast);
    if (!is_bool_type(expr.type) && !is_int_type(expr.type))
        fatal(ast->loc, "expression has to be of boolean or integer type");

    rope = rope_new_tree(rope, expr.rope);
    rope = rope_new_tree(rope, rparen_sp_rope);

    rope = rope_new_tree(rope, switch_block_to_c(block_ast));

    pop_scope();

    return add_indent_nl(rope);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x152cd(%rip), %rax     # 0x19c70
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a40
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x2a40
movq %rax, -0x20(%rbp)
callq 0x3cc0
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x81b0
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x30(%rbp), %rdi
callq 0x4590
testb $0x1, %al
jne 0x4a14
movq -0x30(%rbp), %rdi
callq 0x4a70
testb $0x1, %al
jne 0x4a14
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xda7e(%rip), %rsi      # 0x1248b
movb $0x0, %al
callq 0x6610
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xf2a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x148c0(%rip), %rsi     # 0x192f0
callq 0xf2a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x48e0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xf2a0
movq %rax, -0x10(%rbp)
callq 0x3cf0
movq -0x10(%rbp), %rdi
callq 0x3db0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/codegen.c
// Function: return_stmt_to_c
struct rope *return_stmt_to_c(struct ast *ast)
{
    struct ast *expr_ast = ast_ast(ast, 0);

    if (expr_ast == NULL) {
        if (zc_func_ret_type != void_type)
            fatal(ast->loc, "missing return value in non-void function");
        return return_semi_rope;
    }

    struct expr expr = eval_expr(zc_func_ret_type, expr_ast);

    if (zc_func_ret_type == void_type)
        fatal(ast->loc, "return with value in function returning void");
    if (common_type(zc_func_ret_type, expr.type) != zc_func_ret_type)
        fatal(ast->loc, "invalid type for return");

    struct rope *rope = rope_new_tree(return_sp_rope, expr.rope);
    rope = rope_new_tree(rope, semi_rope);
    return add_indent_nl(rope);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a40
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4cbd
leaq 0x150cd(%rip), %rcx     # 0x19d58
leaq 0x15156(%rip), %rax     # 0x19de8
cmpq %rcx, (%rax)
je 0x4cad
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xd815(%rip), %rsi      # 0x124bb
movb $0x0, %al
callq 0x6610
leaq 0x1479c(%rip), %rax     # 0x19450
movq %rax, -0x8(%rbp)
jmp 0x4d6b
leaq 0x15124(%rip), %rax     # 0x19de8
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x81b0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0x15079(%rip), %rcx     # 0x19d58
leaq 0x15102(%rip), %rax     # 0x19de8
cmpq %rcx, (%rax)
jne 0x4d01
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xd7eb(%rip), %rsi      # 0x124e5
movb $0x0, %al
callq 0x6610
leaq 0x150e0(%rip), %rax     # 0x19de8
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x6b60
leaq 0x150cd(%rip), %rcx     # 0x19de8
cmpq (%rcx), %rax
je 0x4d36
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xd7e3(%rip), %rsi      # 0x12512
movb $0x0, %al
callq 0x6610
movq -0x20(%rbp), %rsi
leaq 0x1476f(%rip), %rdi     # 0x194b0
callq 0xf2a0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x1477b(%rip), %rsi     # 0x194d0
callq 0xf2a0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3db0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/codegen.c
// Function: label_stmt_to_c
struct rope *label_stmt_to_c(struct ast *ast)
{
    struct ast *name_ast = ast_ast(ast, 0);
    const char *name = ast_s(name_ast);
    const char *c_name = define_label(name);

    struct ast *stmt_ast = ast_ast(ast, 1);

    struct rope *rope = rope_new_s(c_name);
    rope = rope_new_tree(rope, colon_nl_rope);

    if (stmt_ast)
        rope = rope_new_tree(rope, stmt_to_c(stmt_ast));
    else
        rope = rope_new_tree(rope, add_indent_nl(semi_rope));

    return rope;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x27f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3c50
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x2a40
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xf2f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x14e6f(%rip), %rsi     # 0x19cd0
callq 0xf2a0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4e94
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4ed0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xf2a0
movq %rax, -0x30(%rbp)
jmp 0x4eb8
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x1462d(%rip), %rdi     # 0x194d0
callq 0x3db0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xf2a0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/codegen.c
// Function: stmt_to_c
struct rope *stmt_to_c(struct ast *ast)
{
    switch (ast->tag) {
        default:
            return expr_stmt_to_c(ast);
        case TYPE_DEF:
	    handle_type_def(ast);
	    return NULL;
        case ALIAS_DEF:
	    handle_alias_def(ast);
	    return NULL;
        case IF_STMT:
            return if_stmt_to_c(ast);
        case SWITCH_STMT:
            return switch_stmt_to_c(ast);
        case FOR_STMT:
            return for_stmt_to_c(ast);
        case RETURN_STMT:
            return return_stmt_to_c(ast);
        case BREAK_STMT:
            return break_stmt_to_c(ast);
        case CONTINUE_STMT:
            return continue_stmt_to_c(ast);
        case GOTO_STMT:
            return goto_stmt_to_c(ast);
        case LABEL_STMT:
            return label_stmt_to_c(ast);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x3, %eax
je 0x4ff1
jmp 0x4ef0
movl -0x14(%rbp), %eax
subl $0x4, %eax
je 0x5000
jmp 0x4efe
movl -0x14(%rbp), %eax
subl $0x4002, %eax           # imm = 0x4002
je 0x4f8c
jmp 0x4f0e
movl -0x14(%rbp), %eax
subl $0x4003, %eax           # imm = 0x4003
je 0x4fa2
jmp 0x4f1e
movl -0x14(%rbp), %eax
subl $0x4101, %eax           # imm = 0x4101
je 0x4fb5
jmp 0x4f2e
movl -0x14(%rbp), %eax
subl $0x4104, %eax           # imm = 0x4104
je 0x4fd3
jmp 0x4f3e
movl -0x14(%rbp), %eax
subl $0x4105, %eax           # imm = 0x4105
je 0x4fe2
jmp 0x4f4e
movl -0x14(%rbp), %eax
subl $0x4106, %eax           # imm = 0x4106
je 0x500f
jmp 0x4f5e
movl -0x14(%rbp), %eax
subl $0x4108, %eax           # imm = 0x4108
je 0x4fc4
jmp 0x4f6a
movl -0x14(%rbp), %eax
subl $0x410b, %eax           # imm = 0x410B
je 0x501e
jmp 0x4f7a
movq -0x10(%rbp), %rdi
callq 0x43a0
movq %rax, -0x8(%rbp)
jmp 0x502b
movq -0x10(%rbp), %rdi
callq 0x50d0
movq $0x0, -0x8(%rbp)
jmp 0x502b
movq -0x10(%rbp), %rdi
callq 0x5130
movq $0x0, -0x8(%rbp)
jmp 0x502b
movq -0x10(%rbp), %rdi
callq 0x4420
movq %rax, -0x8(%rbp)
jmp 0x502b
movq -0x10(%rbp), %rdi
callq 0x4990
movq %rax, -0x8(%rbp)
jmp 0x502b
movq -0x10(%rbp), %rdi
callq 0x4a90
movq %rax, -0x8(%rbp)
jmp 0x502b
movq -0x10(%rbp), %rdi
callq 0x4c60
movq %rax, -0x8(%rbp)
jmp 0x502b
movq -0x10(%rbp), %rdi
callq 0x4d80
movq %rax, -0x8(%rbp)
jmp 0x502b
movq -0x10(%rbp), %rdi
callq 0x4dc0
movq %rax, -0x8(%rbp)
jmp 0x502b
movq -0x10(%rbp), %rdi
callq 0x5040
movq %rax, -0x8(%rbp)
jmp 0x502b
movq -0x10(%rbp), %rdi
callq 0x4e00
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/codegen.c
// Function: goto_stmt_to_c
struct rope *goto_stmt_to_c(struct ast *ast)
{
    struct ast *name_ast = ast_ast(ast, 0);
    const char *name = ast_s(name_ast);
    const char *c_name = goto_label(name, ast);

    struct rope *rope = goto_sp_rope;
    rope = rope_new_tree(rope, rope_new_s(c_name));
    rope = rope_new_tree(rope, semi_nl_rope);

    return add_indent(rope);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x27f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3be0
movq %rax, -0x20(%rbp)
leaq 0x14c6e(%rip), %rax     # 0x19cf0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0xf2f0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xf2a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x145fe(%rip), %rsi     # 0x196b0
callq 0xf2a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3d80
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/codegen.c
// Function: func_body_to_c
struct rope *func_body_to_c(struct ast *ast)
{
    zc_func_labels = strmap_new(32);
    lbl_list = NULL;

    struct rope *rope = lcurly_nl_rope;
    zc_func_decls_rope = NULL;

    zc_indent_level++;

    struct rope *stmts_rope = NULL;
    stmts_rope = stmt_list_to_c(stmts_rope, ast, NULL);

    rope = rope_new_tree(rope, zc_func_decls_rope);
    rope = rope_new_tree(rope, stmts_rope);

    zc_indent_level--;
    rope = rope_new_tree(rope, add_indent(rcurly_rope));

    strmap_del(zc_func_labels, NULL);
    check_lbl_list(lbl_list);

    return rope;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x20, %edi
callq 0xf710
movq %rax, %rcx
leaq 0x14c68(%rip), %rax     # 0x19e18
movq %rcx, (%rax)
movq $0x0, 0x14bc2(%rip) # 0x19d80
leaq 0x1418b(%rip), %rax     # 0x19350
movq %rax, -0x10(%rbp)
leaq 0x14c40(%rip), %rax     # 0x19e10
movq $0x0, (%rax)
leaq 0x14bee(%rip), %rax     # 0x19dcc
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x14be2(%rip), %rax     # 0x19dcc
movl %ecx, (%rax)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4810
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x14bfc(%rip), %rax     # 0x19e10
movq (%rax), %rsi
callq 0xf2a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xf2a0
movq %rax, -0x10(%rbp)
leaq 0x14b94(%rip), %rax     # 0x19dcc
movl (%rax), %ecx
addl $-0x1, %ecx
leaq 0x14b88(%rip), %rax     # 0x19dcc
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x1415b(%rip), %rdi     # 0x193b0
callq 0x3d80
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0xf2a0
movq %rax, -0x10(%rbp)
leaq 0x14ba7(%rip), %rax     # 0x19e18
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xf950
movq 0x14afc(%rip), %rdi     # 0x19d80
callq 0x3b60
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryvnf[P]czc/codegen.c
// Function: add_global_decl
void add_global_decl(struct decl_sym *decl)
{
    if (is_void_type(decl->type))
        fatal(decl->sym.loc->loc, "cannot declare a variable of void type");

    if (is_extern_type(decl->type))
        fatal(decl->sym.loc->loc, "cannot declare a variable of incomplete type");

    add_type_decl(decl->type);
    struct rope *rope = decl_to_c(decl);
    rope = rope_new_tree(extern_sp_rope, rope);
    rope = rope_new_tree(rope, semi_nl_rope);
    zc_prog_decls_rope = rope_new_tree(zc_prog_decls_rope, rope);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x5370
testb $0x1, %al
jne 0x52bf
jmp 0x52d9
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xd2a8(%rip), %rsi      # 0x1257a
movb $0x0, %al
callq 0x6610
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x5390
testb $0x1, %al
jne 0x52ec
jmp 0x5306
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xd2a2(%rip), %rsi      # 0x125a1
movb $0x0, %al
callq 0x6610
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x53b0
movq -0x8(%rbp), %rdi
callq 0x4360
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x143a5(%rip), %rdi     # 0x196d0
callq 0xf2a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x14371(%rip), %rsi     # 0x196b0
callq 0xf2a0
movq %rax, -0x10(%rbp)
leaq 0x14ab1(%rip), %rax     # 0x19e00
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xf2a0
movq %rax, %rcx
leaq 0x14a9b(%rip), %rax     # 0x19e00
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nop