LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/parser.c
// Function: print_bitset
void print_bitset(bitset_t s, FILE* fp)
{
    if(s == unset_bitset)
        fprintf(fp, "{unset}\n");
    else
    {
        int i;
        fprintf(fp, "{");
        //fprintf(fp, "%llu {", s);
        bool first = true;
        for(i=0; i < NUM_TOKENS; ++i)
            if(bitset_has(s, i))
            {
                if(!first)
                    fprintf(fp, ", ");
                else
                    first = false;
                //fprintf(fp, "%s(%d)", GS_STRS[i], i);
                fprintf(fp, "%s", GS_STRS[i]);
            }
        fprintf(fp, "}\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $-0x1, -0x8(%rbp)
jne 0x7d8e
movq -0x10(%rbp), %rdi
leaq 0xcccc(%rip), %rsi      # 0x14a4e
movb $0x0, %al
callq 0x3120
jmp 0x7e21
movq -0x10(%rbp), %rdi
leaq 0xccbe(%rip), %rsi      # 0x14a57
movb $0x0, %al
callq 0x3120
movb $0x1, -0x15(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x3a, -0x14(%rbp)
jge 0x7e0f
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x7bb0
testb $0x1, %al
jne 0x7dc3
jmp 0x7e02
testb $0x1, -0x15(%rbp)
jne 0x7ddd
movq -0x10(%rbp), %rdi
leaq 0xd07b(%rip), %rsi      # 0x14e4f
movb $0x0, %al
callq 0x3120
jmp 0x7de1
movb $0x0, -0x15(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x12980(%rip), %rax     # 0x1a770
movq (%rax,%rcx,8), %rdx
leaq 0xde9d(%rip), %rsi      # 0x15c98
movb $0x0, %al
callq 0x3120
jmp 0x7e04
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7dab
movq -0x10(%rbp), %rdi
leaq 0xcc3a(%rip), %rsi      # 0x14a54
movb $0x0, %al
callq 0x3120
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/parser.c
// Function: print_firsts
void print_firsts(FILE* fp)
{
    int i;
    for(i=0; i < NUM_NONTERMS; ++i)
    {
        fprintf(fp, "%s: ", GS_STRS[NUM_TOKENS + i]);
        print_bitset(get_first_symb(NUM_TOKENS + i), fp);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x36, -0xc(%rbp)
jge 0x7e91
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
addl $0x3a, %eax
movslq %eax, %rcx
leaq 0x12913(%rip), %rax     # 0x1a770
movq (%rax,%rcx,8), %rdx
leaq 0xcbf1(%rip), %rsi      # 0x14a59
movb $0x0, %al
callq 0x3120
movl -0xc(%rbp), %edi
addl $0x3a, %edi
callq 0x79d0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x7d60
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7e43
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/parser.c
// Function: print_follows
void print_follows(FILE* fp)
{
    int i;
    for(i=0; i < NUM_NONTERMS; ++i)
    {
        fprintf(fp, "%s: ", GS_STRS[NUM_TOKENS + i]);
        print_bitset(follow[i], fp);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x36, -0xc(%rbp)
jge 0x7f02
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
addl $0x3a, %eax
movslq %eax, %rcx
leaq 0x128a3(%rip), %rax     # 0x1a770
movq (%rax,%rcx,8), %rdx
leaq 0xcb81(%rip), %rsi      # 0x14a59
movb $0x0, %al
callq 0x3120
movslq -0xc(%rbp), %rcx
leaq 0x14bc6(%rip), %rax     # 0x1cab0
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rsi
callq 0x7d60
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7eb3
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/parser.c
// Function: print_parse_table
void print_parse_table()
{
    for(int i=0; i<NUM_NONTERMS; i++)
        for(int j=0; j<NUM_TOKENS; j++)
            if(pt[i][j] != -1)
                printf("pt[%s][%s] = %d\n", GS_STRS[i+NUM_TOKENS], GS_STRS[j], pt[i][j]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x36, -0x4(%rbp)
jge 0x7fbf
movl $0x0, -0x8(%rbp)
cmpl $0x3a, -0x8(%rbp)
jge 0x7faf
movslq -0x4(%rbp), %rcx
leaq 0x14d1f(%rip), %rax     # 0x1cc60
imulq $0xe8, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x7fa2
movl -0x4(%rbp), %eax
addl $0x3a, %eax
movslq %eax, %rcx
leaq 0x1280b(%rip), %rax     # 0x1a770
movq (%rax,%rcx,8), %rsi
movslq -0x8(%rbp), %rcx
leaq 0x127fc(%rip), %rax     # 0x1a770
movq (%rax,%rcx,8), %rdx
movslq -0x4(%rbp), %rcx
leaq 0x14cdd(%rip), %rax     # 0x1cc60
imulq $0xe8, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
leaq 0xcac3(%rip), %rdi      # 0x14a5e
movb $0x0, %al
callq 0x30a0
jmp 0x7fa4
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x7f30
jmp 0x7fb1
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x7f1f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/parser.c
// Function: make_parse_table
bool make_parse_table()
{
    int i;
    tok_t j;
    bool is_ll1 = true;
    for(i=0; i < num_rules; ++i)
    {
        int ntid = get_nt_id(rules[i].lhs);
        bitset_t fa = get_first_str(rules[i].head);
        bitset_t terms;
        if(bitset_has(fa, T_EOF))
            terms = follow[ntid] | bitset_remove(fa, T_EOF);
        else
            terms = fa;
        for(j=0; j < NUM_TOKENS; ++j)
            if(bitset_has(terms, j))
            {
                if(pt[ntid][j] != -1)
                    is_ll1 = false;
                pt[ntid][j] = i;
            }
    }
    return is_ll1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb $0x1, -0x9(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x14908(%rip), %eax     # 0x1c8f4
jge 0x80f6
movslq -0x4(%rbp), %rcx
leaq 0x13f93(%rip), %rax     # 0x1bf90
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %edi
callq 0x6480
movl %eax, -0x10(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x13f77(%rip), %rax     # 0x1bf90
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x7b00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x7bb0
testb $0x1, %al
jne 0x8041
jmp 0x8072
movslq -0x10(%rbp), %rcx
leaq 0x14a64(%rip), %rax     # 0x1cab0
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x7be0
movq %rax, %rcx
movq -0x28(%rbp), %rax
orq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x807a
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x3a, -0x8(%rbp)
jae 0x80e6
movq -0x20(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0x7bb0
testb $0x1, %al
jne 0x8099
jmp 0x80d9
movslq -0x10(%rbp), %rcx
leaq 0x14bbc(%rip), %rax     # 0x1cc60
imulq $0xe8, %rcx, %rcx
addq %rcx, %rax
movl -0x8(%rbp), %ecx
cmpl $-0x1, (%rax,%rcx,4)
je 0x80bb
movb $0x0, -0x9(%rbp)
movl -0x4(%rbp), %edx
movslq -0x10(%rbp), %rcx
leaq 0x14b97(%rip), %rax     # 0x1cc60
imulq $0xe8, %rcx, %rcx
addq %rcx, %rax
movl -0x8(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
jmp 0x80db
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x8081
jmp 0x80e8
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x7fe3
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/parser.c
// Function: read_parse_table
void read_parse_table(const char* file_name){
    FILE * fp = fopen(file_name, "r");
    if(fp == NULL){
        fprintf(stderr, "File %s not found\n", file_name);
        return;
    }

    char nt_str[100];
    char t_str[100];
    int rule_no;
    while(fscanf(fp, "%s %s %d", nt_str, t_str, &rule_no) != EOF){
        int nt_id = get_nt_id(get_gsymb_id(nt_str));
        int t_id = get_gsymb_id(t_str);
        pt[nt_id][t_id] = rule_no;
    }
    fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xc763(%rip), %rsi      # 0x1488d
callq 0x3150
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x815b
movq 0x11eb7(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0xc920(%rip), %rsi      # 0x14a6f
movb $0x0, %al
callq 0x3120
jmp 0x81e1
jmp 0x815d
movq -0x10(%rbp), %rdi
leaq -0x80(%rbp), %rdx
leaq -0xf0(%rbp), %rcx
leaq 0xc90f(%rip), %rsi      # 0x14a82
leaq -0xf4(%rbp), %r8
movb $0x0, %al
callq 0x3060
cmpl $-0x1, %eax
je 0x81d8
leaq -0x80(%rbp), %rdi
callq 0x72f0
movl %eax, %edi
callq 0x6480
movl %eax, -0xf8(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x72f0
movl %eax, -0xfc(%rbp)
movl -0xf4(%rbp), %edx
movslq -0xf8(%rbp), %rcx
leaq 0x14a9e(%rip), %rax     # 0x1cc60
imulq $0xe8, %rcx, %rcx
addq %rcx, %rax
movslq -0xfc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x815d
movq -0x10(%rbp), %rdi
callq 0x3090
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/parser.c
// Function: handle_parse_error_1
parse_tree_node* handle_parse_error_1(const Token* ptok, int_stack* pst, parse_tree_node* tn)
// handle case where top of stack is a terminal and it doesn't match lookahead
{
    parser_error_count++;
    gsymb_t cur_st_top = int_stack_top(pst);
    static char err_msg[50];
    sprintf(err_msg, "Got %s instead of %s.", GS_STRS[ptok->tid], GS_STRS[cur_st_top]);
    print_error("parse", ERROR, 1, ptok->line, ptok->col, ptok->lexeme, NULL, err_msg);
    int_stack_pop(pst);
    return get_successor(tn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl 0x146e6(%rip), %eax     # 0x1c8f0
addl $0x1, %eax
movl %eax, 0x146dd(%rip)     # 0x1c8f0
movq -0x10(%rbp), %rdi
callq 0x4350
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movslq 0x18(%rax), %rcx
leaq 0x12542(%rip), %rax     # 0x1a770
movq (%rax,%rcx,8), %rdx
movl -0x1c(%rbp), %eax
movl %eax, %ecx
leaq 0x12532(%rip), %rax     # 0x1a770
movq (%rax,%rcx,8), %rcx
leaq 0x17b07(%rip), %rdi     # 0x1fd50
leaq 0xc83b(%rip), %rsi      # 0x14a8b
movb $0x0, %al
callq 0x3190
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x4(%rax), %r8d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r9
leaq 0xc82d(%rip), %rdi      # 0x14aa1
xorl %esi, %esi
movl $0x1, %edx
xorl %eax, %eax
leaq 0x17acc(%rip), %rax     # 0x1fd50
movq $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xba50
movq -0x10(%rbp), %rdi
callq 0x43a0
movq -0x18(%rbp), %rdi
callq 0x67b0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/parser.c
// Function: handle_parse_error_2
parse_tree_node* handle_parse_error_2(const Token* ptok, int_stack* pst, parse_tree_node* tn)
// handle case where there is no entry in parse table
{
    parser_error_count++;
    static char err_msg[50];
    sprintf(err_msg, "Token \'%s\' isn't expected here.", GS_STRS[ptok->tid]);
    print_error("parse", ERROR, 2, ptok->line, ptok->col, ptok->lexeme, NULL, err_msg);
    int_stack_pop(pst);
    return get_first_child_or_successor(tn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl 0x14626(%rip), %eax     # 0x1c8f0
addl $0x1, %eax
movl %eax, 0x1461d(%rip)     # 0x1c8f0
movq -0x8(%rbp), %rax
movslq 0x18(%rax), %rcx
leaq 0x1248e(%rip), %rax     # 0x1a770
movq (%rax,%rcx,8), %rdx
leaq 0x17aa3(%rip), %rdi     # 0x1fd90
leaq 0xc7b3(%rip), %rsi      # 0x14aa7
movb $0x0, %al
callq 0x3190
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x4(%rax), %r8d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r9
leaq 0xc789(%rip), %rdi      # 0x14aa1
xorl %esi, %esi
movl $0x2, %edx
xorl %eax, %eax
leaq 0x17a68(%rip), %rax     # 0x1fd90
movq $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xba50
movq -0x10(%rbp), %rdi
callq 0x43a0
movq -0x18(%rbp), %rdi
callq 0x6810
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/parser.c
// Function: print_tree_sub
void print_tree_sub(const parse_tree_node* root, FILE* fp)
{
    if(root != NULL)
    {
        parse_tree_node* n = root->first_child;
        if(n != NULL)
            print_tree_sub(n, fp);
        print_node_sub(root, fp);
        if(n != NULL)
            for(n = n->next_sibling; n != NULL; n = n->next_sibling)
                print_tree_sub(n, fp);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x884d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8807
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x87d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8600
cmpq $0x0, -0x18(%rbp)
je 0x884b
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8849
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x87d0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x8827
jmp 0x884b
jmp 0x884d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/parser.c
// Function: print_node
void print_node(const parse_tree_node* root, FILE* fp)
{
    if(root != NULL)
    {
        fprintf(fp, "%s  ", GS_STRS[root->value->sid]);
        if(root->value->rule_num >= 0)
            fprintf(fp, "(%2d)  ", root->value->rule_num);
        if(root->value->lexeme != NULL)
            fprintf(fp, "%s", root->value->lexeme);
        else if(root->value->sid == T_NUM)
            fprintf(fp, "%d", root->value->i);
        else if(root->value->sid == T_RNUM)
            fprintf(fp, "%lf", root->value->f);
        fprintf(fp, " (%d:%d)\n", root->value->line, root->value->col);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x897c
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq 0x10(%rax), %rcx
leaq 0x11edf(%rip), %rax     # 0x1a770
movq (%rax,%rcx,8), %rdx
leaq 0xc2a7(%rip), %rsi      # 0x14b43
movb $0x0, %al
callq 0x3120
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x18(%rax)
jl 0x88cc
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x18(%rax), %edx
leaq 0xc283(%rip), %rsi      # 0x14b48
movb $0x0, %al
callq 0x3120
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x88f9
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdx
leaq 0xd3a8(%rip), %rsi      # 0x15c98
movb $0x0, %al
callq 0x3120
jmp 0x8957
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x3, 0x10(%rax)
jne 0x8924
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x14(%rax), %edx
leaq 0xc16d(%rip), %rsi      # 0x14a88
movb $0x0, %al
callq 0x3120
jmp 0x8955
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x4, 0x10(%rax)
jne 0x8953
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movss 0x14(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xc204(%rip), %rsi      # 0x14b50
movb $0x1, %al
callq 0x3120
jmp 0x8955
jmp 0x8957
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %ecx
leaq 0xc1df(%rip), %rsi      # 0x14b54
movb $0x0, %al
callq 0x3120
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/parser.c
// Function: print_tree_helper
void print_tree_helper(const parse_tree_node* root, FILE* fp, int indent)
{
    if(root != NULL)
    {
        for(int i=0; i<indent; ++i)
            fprintf(fp, "  ");
        print_node(root, fp);
        parse_tree_node* p = root->first_child;
        for(; p != NULL; p = p->next_sibling)
            print_tree_helper(p, fp, indent + 1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8a19
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x89d6
movq -0x10(%rbp), %rdi
leaq 0xc460(%rip), %rsi      # 0x14e24
movb $0x0, %al
callq 0x3120
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x89b1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8860
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8a17
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x8990
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x89ef
jmp 0x8a19
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/parser.c
// Function: parser_main
int parser_main(FILE* ifp, FILE* ofp, int verbosity, parse_tree_printer tp)
{
    gsymb_t start_symb = init_parser();

    if(verbosity > 0)
    {
        print_firsts(stdout);
        printf("\n");
        print_follows(stdout);
        print_parse_table();
    }

    parse_tree_node* root = build_parse_tree(ifp, start_symb);
    tp(root, ofp);
    parse_tree_destroy(root);

    destroy_parser(true);
    return parser_error_count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
callq 0x76d0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x8ab6
movq 0x11544(%rip), %rax     # 0x19fd0
movq (%rax), %rdi
callq 0x7e30
leaq 0xc690(%rip), %rdi      # 0x1512b
movb $0x0, %al
callq 0x30a0
movq 0x11527(%rip), %rax     # 0x19fd0
movq (%rax), %rdi
callq 0x7ea0
callq 0x7f10
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x8360
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movq -0x30(%rbp), %rdi
callq 0x8c80
movl $0x1, %edi
callq 0x7990
movl 0x13e03(%rip), %eax     # 0x1c8f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/./util/tree.gen.c
// Function: parse_tree_get_node
TYPED(tree_node)* TYPED(tree_get_node)(TYPE value)
{
    TYPED(tree_node)* new_node = malloc(sizeof(TYPED(tree_node)));
    if(new_node == NULL){
        fprintf(stderr, "tree: No memory!\n");
    }else{
        new_node->value         = value;
        new_node->parent        = NULL;
        new_node->first_child   = NULL;
        new_node->next_sibling  = NULL;
        new_node->prev_sibling  = NULL;
        new_node->last_child    = NULL;
    }
    TYPED(tree_node_count)++;
    return new_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x30, %edi
callq 0x3130
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8b8b
movq 0x11480(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
leaq 0xbfdc(%rip), %rsi      # 0x14b5e
movb $0x0, %al
callq 0x3120
jmp 0x8bd2
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movl 0x171ec(%rip), %eax     # 0x1fdc4
addl $0x1, %eax
movl %eax, 0x171e3(%rip)     # 0x1fdc4
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/./util/tree.gen.c
// Function: parse_tree_insert
TYPED(tree_node)* TYPED(tree_insert)(TYPED(tree_node)* parent, TYPE value){
    TYPED(tree_node)* new_node = TYPED(tree_get_node)(value);
    new_node->parent = parent;
    if(parent->first_child == NULL && parent->last_child == NULL){
        parent->first_child = new_node;
    }else{
        new_node->prev_sibling = parent->last_child;
        parent->last_child->next_sibling = new_node;
    }
    parent->last_child = new_node;
    return new_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8b50
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x8c3d
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x8c3d
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x8c5d
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/./util/tree.gen.c
// Function: parse_tree_destroy
void TYPED(tree_destroy)(TYPED(tree_node)* root)
{
    if(root != NULL)
    {
        TYPED(tree_node)* sibling = root->next_sibling;
        TYPED(tree_node)* child = root->first_child;
        TYPED(destroy)(root->value);
        free(root);
        TYPED(tree_destroy)(child);
        TYPED(tree_destroy)(sibling);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8cd2
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x8b00
movq -0x8(%rbp), %rdi
callq 0x3030
movq -0x18(%rbp), %rdi
callq 0x8c80
movq -0x10(%rbp), %rdi
callq 0x8c80
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/./util/tree.gen.c
// Function: parse_tree_print_helper
void TYPED(tree_print_helper)(TYPED(tree_node)* root, FILE* fp, int indent, void printer(TYPE, FILE*)) {
    if(root != NULL) {
        int i;
        for(i=0; i<indent; ++i)
            fprintf(fp, "  ");
        printer(root->value, fp);
        fprintf(fp, "\n");
        TYPED(tree_print_helper)(root->first_child, fp, indent+1, printer);
        TYPED(tree_print_helper)(root->next_sibling, fp, indent, printer);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8d84
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x8d2e
movq -0x10(%rbp), %rdi
leaq 0xc108(%rip), %rsi      # 0x14e24
movb $0x0, %al
callq 0x3120
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8d09
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movq -0x10(%rbp), %rdi
leaq 0xc3e1(%rip), %rsi      # 0x1512b
movb $0x0, %al
callq 0x3120
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
movq -0x20(%rbp), %rcx
callq 0x8ce0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x8ce0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/./util/tree.gen.c
// Function: parse_tree_print
void TYPED(tree_print)(TYPED(tree_node)* root, FILE* fp) {
    if(root == NULL)
        fprintf(fp, "null_tree\n");
    else
        TYPED(tree_print_helper)(root, fp, 0, TYPED(print));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x8dbb
movq -0x10(%rbp), %rdi
leaq 0xbdbe(%rip), %rsi      # 0x14b70
movb $0x0, %al
callq 0x3120
jmp 0x8dd1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
leaq -0x2ac(%rip), %rcx      # 0x8b20
callq 0x8ce0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/ast.c
// Function: complain_ast_node_type
void complain_ast_node_type(const char* funcname, astn_t node_type) {
    if(node_type >= NUM_ASTN)
        fprintf(stderr, "%s: invalid node_type %d\n", funcname, node_type);
    else
        fprintf(stderr, "%s: invalid node_type %s (%d)\n", funcname, ASTN_STRS[node_type], node_type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x14, -0xc(%rbp)
jb 0x8e16
movq 0x111fc(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %ecx
leaq 0xbf93(%rip), %rsi      # 0x14da0
movb $0x0, %al
callq 0x3120
jmp 0x8e46
movq 0x111db(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x118a0(%rip), %rax     # 0x1a6d0
movq (%rax,%rcx,8), %rcx
movl -0xc(%rbp), %r8d
leaq 0xbf7b(%rip), %rsi      # 0x14dba
movb $0x0, %al
callq 0x3120
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/ast.c
// Function: get_next_ast_node
pAstNode get_next_ast_node(pAstNode p) {
    switch(p->base.node_type) {
        case ASTN_IDList: return ((IDListNode*)p)->next;
        case ASTN_IDTypeList: return ((IDTypeListNode*)p)->next;
        case ASTN_Module: return ((ModuleNode*)p)->next;
        case ASTN_Assn: return ((AssnNode*)p)->next;
        case ASTN_While: return ((WhileNode*)p)->next;
        case ASTN_For: return ((ForNode*)p)->next;
        case ASTN_Decl: return ((DeclNode*)p)->next;
        case ASTN_Input: return ((InputNode*)p)->next;
        case ASTN_Output: return ((OutputNode*)p)->next;
        case ASTN_FCall: return ((FCallNode*)p)->next;
        case ASTN_Switch: return ((SwitchNode*)p)->next;
        case ASTN_Case: return ((CaseNode*)p)->next;
        default:
            complain_ast_node_type(__func__, p->base.node_type);
            return NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $-0x7, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0xc, %eax
ja 0x945c
movq -0x18(%rbp), %rax
leaq 0xb82d(%rip), %rcx      # 0x14bcc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x9476
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x9476
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x9476
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x9476
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x9476
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x9476
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x9476
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x9476
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x9476
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x9476
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x9476
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x9476
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq 0xb97d(%rip), %rdi      # 0x14de6
callq 0x8de0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/ast.c
// Function: get_scope_beg_line
int get_scope_beg_line(pAstNode p) {
    if(p == NULL) {
        return 0;
    }
    switch(p->base.node_type) {
        case ASTN_Module: return ((ModuleNode*)p)->scope_beg_line;
        case ASTN_For: return ((ForNode*)p)->scope_beg_line;
        case ASTN_While: return ((WhileNode*)p)->scope_beg_line;
        case ASTN_Switch: return ((SwitchNode*)p)->scope_beg_line;
        default:
            complain_ast_node_type(__func__, p->base.node_type);
            return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x949c
movl $0x0, -0x4(%rbp)
jmp 0x950d
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $-0x9, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x9, %eax
ja 0x94f4
movq -0x18(%rbp), %rax
leaq 0xb745(%rip), %rcx      # 0x14c00
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x950d
movq -0x10(%rbp), %rax
movl 0x68(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x950d
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x950d
movq -0x10(%rbp), %rax
movl 0x58(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x950d
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq 0xb8f7(%rip), %rdi      # 0x14df8
callq 0x8de0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/ast.c
// Function: get_scope_end_line
int get_scope_end_line(pAstNode p) {
    if(p == NULL) {
        return 0;
    }
    switch(p->base.node_type) {
        case ASTN_Module: return ((ModuleNode*)p)->scope_end_line;
        case ASTN_For: return ((ForNode*)p)->scope_end_line;
        case ASTN_While: return ((WhileNode*)p)->scope_end_line;
        case ASTN_Switch: return ((SwitchNode*)p)->scope_end_line;
        default:
            complain_ast_node_type(__func__, p->base.node_type);
            return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x953c
movl $0x0, -0x4(%rbp)
jmp 0x95ad
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $-0x9, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x9, %eax
ja 0x9594
movq -0x18(%rbp), %rax
leaq 0xb6cd(%rip), %rcx      # 0x14c28
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movl 0x64(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x95ad
movq -0x10(%rbp), %rax
movl 0x6c(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x95ad
movq -0x10(%rbp), %rax
movl 0x54(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x95ad
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x95ad
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq 0xb86a(%rip), %rdi      # 0x14e0b
callq 0x8de0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/ast_gen.c
// Function: read_children
int read_children(parse_tree_node** nodes, parse_tree_node* root) {
    //for(i=0; i<n; ++i) nodes[i] = NULL;
    if(root == NULL) return -1;
    root = root->first_child;
    int n;
    for(n=0; root != NULL; ++n) {
        nodes[n] = root;
        root = root->next_sibling;
    }
    nodes[n] = NULL;
    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xa3ac
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa403
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa3ed
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa3bf
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/ast_gen.c
// Function: ast_gen_main
int ast_gen_main(FILE* ifp, FILE* ofp, FILE* statsfp, int verbosity)
{
    gsymb_t start_symb = init_parser();

    parse_tree_node* proot = build_parse_tree(ifp, start_symb);
    int parse_tree_size = parse_tree_node_count * (sizeof(parse_tree_node) + sizeof(Symbol));
    if(verbosity > 0 && statsfp != NULL) {
        fprintf(statsfp, "Parse tree: %d nodes = %d bytes.\n", parse_tree_node_count, parse_tree_size);
    }
    pAstNode ast = NULL;
    int parse_errors = error_count;
    if(parse_errors == 0) {
        build_ast(proot);
        ast = proot->value->tree;
        if(verbosity >= 1 && statsfp != NULL) {
            fprintf(statsfp, "AST: %d nodes = %d bytes.\n", ast_node_count, ast_mem_allocd);
            fprintf(statsfp, "Compression percent: %lf\n",
                100 * ((float)parse_tree_size - ast_mem_allocd) / (parse_tree_size));
        }
    }
    parse_tree_destroy(proot);
    destroy_parser(false);

    if(parse_errors == 0 && ofp != NULL) {
        print_ast(ofp, ast, 0);
    }

    destroy_ast(ast);
    pch_int_hmap_clear(&intern_table);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movb $0x0, %al
callq 0x76d0
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x8360
movq %rax, -0x28(%rbp)
leaq 0x1449c(%rip), %rax     # 0x1fdc4
movslq (%rax), %rax
imulq $0x70, %rax, %rax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0xb95d
cmpq $0x0, -0x18(%rbp)
je 0xb95d
movq -0x18(%rbp), %rdi
leaq 0x1447a(%rip), %rax     # 0x1fdc4
movl (%rax), %edx
movl -0x2c(%rbp), %ecx
leaq 0x9758(%rip), %rsi      # 0x150ae
movb $0x0, %al
callq 0x3120
movq $0x0, -0x38(%rbp)
leaq 0x1446c(%rip), %rax     # 0x1fdd8
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jne 0xba05
movq -0x28(%rbp), %rdi
callq 0xa410
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
cmpl $0x1, -0x1c(%rbp)
jl 0xba03
cmpq $0x0, -0x18(%rbp)
je 0xba03
movq -0x18(%rbp), %rdi
leaq 0x1441d(%rip), %rax     # 0x1fdc8
movl (%rax), %edx
leaq 0x14418(%rip), %rax     # 0x1fdcc
movl (%rax), %ecx
leaq 0x9713(%rip), %rsi      # 0x150d0
movb $0x0, %al
callq 0x3120
movq -0x18(%rbp), %rdi
cvtsi2ssl -0x2c(%rbp), %xmm1
leaq 0x143f8(%rip), %rax     # 0x1fdcc
cvtsi2ssl (%rax), %xmm0
subss %xmm0, %xmm1
movss 0x969c(%rip), %xmm0     # 0x15080
mulss %xmm1, %xmm0
cvtsi2ssl -0x2c(%rbp), %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x96ef(%rip), %rsi      # 0x150eb
movb $0x1, %al
callq 0x3120
jmp 0xba05
movq -0x28(%rbp), %rdi
callq 0x8c80
xorl %edi, %edi
callq 0x7990
cmpl $0x0, -0x3c(%rbp)
jne 0xba31
cmpq $0x0, -0x10(%rbp)
je 0xba31
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
xorl %edx, %edx
callq 0x95c0
movq -0x38(%rbp), %rdi
callq 0xa0b0
leaq 0x10277(%rip), %rdi     # 0x1bcb8
callq 0x33f0
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/symbol_table.c
// Function: pSTEntry_print
void pSTEntry_print(pSTEntry p, FILE* fp)
{
    fprintf(fp, "STEntry(%s: %s", p->lexeme, TYPE_STRS[p->addr->type]);
    if(p->addr->size > 0)
        fprintf(fp, "[%d]", p->addr->size);
    fprintf(fp, ", %d:%d, %d)", p->addr->line, p->addr->col, p->addr->offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x18(%rax), %eax
movl %eax, %ecx
leaq 0xef51(%rip), %rax      # 0x1abe0
movq (%rax,%rcx,8), %rcx
leaq 0x9493(%rip), %rsi      # 0x1512d
movb $0x0, %al
callq 0x3120
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
cmpl $0x0, 0x1c(%rax)
jle 0xbccc
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x1c(%rax), %edx
leaq 0x9486(%rip), %rsi      # 0x1514b
movb $0x0, %al
callq 0x3120
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x20(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x24(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x28(%rax), %r8d
leaq 0x9443(%rip), %rsi      # 0x1513c
movb $0x0, %al
callq 0x3120
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/symbol_table.c
// Function: pSTEntry_print_sub
void pSTEntry_print_sub(pSTEntry p, FILE* fp) {
    char type_str[10] = "";
    if(p->addr->size == 0)
        sprintf(type_str, "%s", TYPE_STRS[p->addr->type]);
    else
        sprintf(type_str, "%s[%d]", TYPE_STRS[p->addr->type], p->addr->size);
    int beg_line = p->addr->symbol_table->scope_beg_line;
    int end_line = p->addr->symbol_table->scope_end_line;
    const char* func_name = p->func_name == NULL ? "driver" : p->func_name;
    fprintf(fp, "%-10s %-12s %-10s %3d to %3d %6d %6d %7d\n", p->lexeme, type_str, func_name, beg_line, end_line,
        p->addr->symbol_table->level, get_type_width(p->addr->type, p->addr->size), p->addr->offset);
    //pSTEntry_print(p, fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x88, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x22(%rbp), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x30d0
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpl $0x0, 0x1c(%rax)
jne 0xbd6e
leaq -0x22(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x18(%rax), %eax
movl %eax, %ecx
leaq 0xee86(%rip), %rax      # 0x1abe0
movq (%rax,%rcx,8), %rdx
leaq 0x9f33(%rip), %rsi      # 0x15c98
movb $0x0, %al
callq 0x3190
jmp 0xbda3
leaq -0x22(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x18(%rax), %eax
movl %eax, %ecx
leaq 0xee5a(%rip), %rax      # 0x1abe0
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x1c(%rax), %ecx
leaq 0x93ad(%rip), %rsi      # 0x15149
movb $0x0, %al
callq 0x3190
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movl 0x3c(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movl 0x40(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xbddf
leaq 0x86d4(%rip), %rax      # 0x144ad
movq %rax, -0x40(%rbp)
jmp 0xbdeb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
leaq -0x22(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x2c(%rbp), %ebx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movl 0x38(%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x18(%rax), %edi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x1c(%rax), %esi
callq 0xff70
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rcx
movq -0x50(%rbp), %r8
movl -0x48(%rbp), %r9d
movl -0x44(%rbp), %r11d
movl %eax, %r10d
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x28(%rax), %eax
leaq 0x92d7(%rip), %rsi      # 0x15150
movl %ebx, (%rsp)
movl %r11d, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movb $0x0, %al
callq 0x3120
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/symbol_table.c
// Function: ST_init
void ST_init(pST pst, struct AstNode* scope, int level) {
    ST_hmap_init(&(pst->vmap), 10, false);
    AddrList_init(&(pst->addrs));
    pst->scope = scope;
    pst->scope_beg_line = get_scope_beg_line(scope);
    pst->scope_end_line = get_scope_end_line(scope);
    pst->beg_offset = pst->end_offset = pst->max_offset = 0;
    pst->level = level;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl $0xa, %esi
xorl %edx, %edx
callq 0xbf70
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0xfd40
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rdi
callq 0x9480
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x3c(%rax)
movq -0x10(%rbp), %rdi
callq 0x9520
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x44(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x38(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/symbol_table.c
// Function: ST_print
void ST_print(pST p, FILE* fp)
{
    fprintf(fp, "SymbolTable(off=%d:%d, maxoff=%d):\n", p->beg_offset, p->end_offset, p->max_offset);
    ST_hmap_print(&(p->vmap), fp);
    fprintf(fp, "AddrList:\n");
    AddrList_print(&(p->addrs), fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x44(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x48(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x4c(%rax), %r8d
leaq 0x8b79(%rip), %rsi      # 0x1517a
movb $0x0, %al
callq 0x3120
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc440
movq -0x10(%rbp), %rdi
leaq 0x8b7e(%rip), %rsi      # 0x1519e
movb $0x0, %al
callq 0x3120
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0xff10
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/symbol_table.c
// Function: ST_clear
void ST_clear(pST p)
{
    ST_hmap_clear(&(p->vmap));
    AddrList_clear(&(p->addrs));
    p->scope = NULL;
    p->level = 0;
    p->beg_offset = p->end_offset = p->max_offset = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbfd0
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0xfd70
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x44(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/symbol_table.c
// Function: SD_init
void SD_init(pSD psd) {
    psd->level = 0;
    psd->offset = 0;
#ifdef LOG_MEM
    fprintf(stderr, "Called %s(%p)\n", __func__, (void*)psd);
#endif

    pST pst = malloc(sizeof(ST));
#ifdef LOG_MEM
    fprintf(stderr, "%s: Allocated ST %p\n", __func__, (void*)pst);
#endif
    ST_init(pst, NULL, 0);
    psd->root = psd->active = ST_tree_get_node(pst);
    psd->first_entry = psd->last_entry = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
movl $0x50, %edi
callq 0x3130
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0xc530
movq -0x10(%rbp), %rdi
callq 0xc6d0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/symbol_table.c
// Function: SD_add_entry
bool SD_add_entry(pSD psd, pSTEntry pentry, int line, int col) {
    // pentry->addr is not yet initialized
    if(psd->active == NULL) {
        fprintf(stderr, "%s: No SymbolTable present in stack.\n", __func__);
        return false;
    }
    pST pst = psd->active->value;

    int old_size = pst->vmap.size;
    ST_hmap_node* node = ST_hmap_insert(&(pst->vmap), pentry->lexeme, pentry);
    if(pst->vmap.size == old_size) {
        char msg[80];
        sprintf(msg, "Variable has already been declared at line %d col %d.", node->value->addr->line, node->value->addr->col);
        print_error("semantic", ERROR, -1, line, col, pentry->lexeme, "ALREADY_DECL", msg);
        return false;
    }

    if(psd->first_entry == NULL) {
        psd->first_entry = psd->last_entry = pentry;
    }
    else {
        psd->last_entry->next = pentry;
        psd->last_entry = pentry;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xca2c
movq 0xd5ed(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
leaq 0x8794(%rip), %rsi      # 0x151a9
leaq 0x87b3(%rip), %rdx      # 0x151cf
movb $0x0, %al
callq 0x3120
movb $0x0, -0x1(%rbp)
jmp 0xcb1b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xc1a0
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0x2c(%rbp), %eax
jne 0xcada
leaq -0x90(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rax), %rax
movl 0x20(%rax), %edx
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rax), %rax
movl 0x24(%rax), %ecx
leaq 0x8747(%rip), %rsi      # 0x151dc
movb $0x0, %al
callq 0x3190
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x18(%rbp), %rax
movq (%rax), %r9
leaq -0x90(%rbp), %rax
leaq 0x875a(%rip), %rdi      # 0x15212
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
leaq 0x8755(%rip), %r10      # 0x1521b
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xba50
movb $0x0, -0x1(%rbp)
jmp 0xcb1b
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xcafb
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0xcb17
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/symbol_table.c
// Function: SD_add_addr
bool SD_add_addr(pSD psd, AddrNode* an) {
    if(psd->active == NULL) {
        fprintf(stderr, "%s: No SymbolTable present in stack.\n", __func__);
        return false;
    }
    pST pst = psd->active->value;

    if(pst->addrs.last == NULL) {
        an->id = 0;
    }
    else {
        an->id = pst->addrs.last->id + 1;
    }

    AddrList_add(&(pst->addrs), an);

    if(an->addr_type != ADDR_CONST) {
        an->offset = get_aligned_offset(psd->offset, an->type);
        psd->offset = an->offset + get_type_width(an->type, an->size);
        if((psd->offset) > (pst->max_offset)) {
            pst->max_offset = psd->offset;
        }
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xcb73
movq 0xd4a6(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
leaq 0x864d(%rip), %rsi      # 0x151a9
leaq 0x86c5(%rip), %rdx      # 0x15228
movb $0x0, %al
callq 0x3120
movb $0x0, -0x1(%rbp)
jmp 0xcc33
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xcb9a
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
jmp 0xcbaf
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0xfde0
movq -0x18(%rbp), %rax
cmpl $0x2, 0x14(%rax)
je 0xcc2f
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %esi
callq 0xffb0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x18(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %edi
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %esi
callq 0xff70
movl -0x24(%rbp), %ecx
addl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4c(%rcx), %eax
jle 0xcc2d
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4c(%rax)
jmp 0xcc2f
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/symbol_table.c
// Function: SD_get_entry
pSTEntry SD_get_entry(pSD psd, const char* lexeme) {
    ST_tree_node* n = psd->active;
    ST_hmap_node* res = NULL;
    while(n != NULL && res == NULL) {
        res = ST_hmap_query(&(n->value->vmap), lexeme);
        n = n->parent;
    }
    if(res == NULL)
        return NULL;
    else
        return res->value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x29(%rbp)
je 0xcc7b
cmpq $0x0, -0x28(%rbp)
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xcc84
jmp 0xcca6
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xc0a0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xcc64
cmpq $0x0, -0x28(%rbp)
jne 0xccb7
movq $0x0, -0x8(%rbp)
jmp 0xccc3
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)