LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/util/hmap.gen.c
// Function: pch_int_hmap_print
void ITYPED(hmap_print)(ITYPED(hmap)* phmap, FILE* fp) {
    int capacity = phmap->capacity;
    ITYPED(hmap_node)** plist = phmap->plist;
    ITYPED(hmap_node)* n = NULL;
    fprintf(fp, "hmap(size=%d, capacity=%d):\n", phmap->size, capacity);
    for(int i=0; i<capacity; ++i) {
        for(n = plist[i]; n != NULL; n = n->next) {
            fprintf(fp, "  ");
            KTYPED(print)(n->key, fp);
            fprintf(fp, ": ");
            VTYPED(print)(n->value, fp);
            fprintf(fp, "\n");
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edx
movl -0x14(%rbp), %ecx
leaq 0x1076d(%rip), %rsi     # 0x1400f
movb $0x0, %al
callq 0x3120
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3947
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x3937
movq -0x10(%rbp), %rdi
leaq 0x11546(%rip), %rsi     # 0x14e24
movb $0x0, %al
callq 0x3120
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4080
movq -0x10(%rbp), %rdi
leaq 0x1070b(%rip), %rsi     # 0x1400c
movb $0x0, %al
callq 0x3120
movq -0x28(%rbp), %rax
movl 0x10(%rax), %edi
movq -0x10(%rbp), %rsi
callq 0x4460
movq -0x10(%rbp), %rdi
leaq 0x11808(%rip), %rsi     # 0x1512b
movb $0x0, %al
callq 0x3120
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x38cc
jmp 0x3939
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x38b0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/util/pch.c
// Function: pch_hash
unsigned pch_hash(pch str)
{
    unsigned res = 0;
    for(int i=0; str[i] != '\0'; ++i)
        res = res * 307 + (int)(str[i]);
    //fprintf(stderr, "hash(%s) = %u\n", str, res);
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x407a
imull $0x133, -0xc(%rbp), %eax # imm = 0x133
movq -0x8(%rbp), %rcx
movslq -0x10(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4046
movl -0xc(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/util/stack.gen.c
// Function: int_stack_clear
void TYPED(stack_clear)(TYPED(stack) *ps)
{
    TYPED(stack_node) *p = ps->top, *todel = NULL;
    while(p != NULL)
    {
        todel = p;
        p = p->next;
        todel->next = NULL;
        TYPED(destroy)(todel->value);
        free(todel);
    }
    ps->top = NULL;
    ps->size = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x41ec
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x4420
movq -0x18(%rbp), %rdi
callq 0x3030
jmp 0x41af
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/util/stack.gen.c
// Function: int_stack_push
void TYPED(stack_push)(TYPED(stack)* ps, TYPE value)
{
    /*
    fprintf(stderr, "Pushing: ");
    TYPED(print)(value,stderr);
    fprintf(stderr, "\n");
    */
    if(ps->size > 100){
        fprintf(stderr,"stack size exceeded limit!\n");
        exit(1);
    }
    ps->top = TYPED(get_stack_node)(value, ps->top);
    (ps->size)++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x64, 0x8(%rax)
jle 0x427b
movq 0x15d98(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
leaq 0xfdc5(%rip), %rsi      # 0x1402f
movb $0x0, %al
callq 0x3120
movl $0x1, %edi
callq 0x31a0
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x4130
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/util/stack.gen.c
// Function: int_stack_print
void TYPED(stack_print)(TYPED(stack)* ps, FILE* fp)
{
    fprintf(fp, "[");
    TYPED(stack_node)* p = ps->top;
    if(p != NULL)
    {
        TYPED(print)(p->value, fp);
        p = p->next;
        while(p != NULL)
        {
            fprintf(fp, ", ");
            TYPED(print)(p->value, fp);
            p = p->next;
        }
    }
    fprintf(fp, "]\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xfd80(%rip), %rsi      # 0x1404b
movb $0x0, %al
callq 0x3120
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4337
movq -0x18(%rbp), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rsi
callq 0x4460
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4335
movq -0x10(%rbp), %rdi
leaq 0x10b3e(%rip), %rsi     # 0x14e4f
movb $0x0, %al
callq 0x3120
movq -0x18(%rbp), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rsi
callq 0x4460
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x42ff
jmp 0x4337
movq -0x10(%rbp), %rdi
leaq 0xfd0b(%rip), %rsi      # 0x1404d
movb $0x0, %al
callq 0x3120
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/util/stack.gen.c
// Function: int_stack_pop
TYPE TYPED(stack_pop)(TYPED(stack)* ps)
{
    if(ps->size == 0)
        fprintf(stderr, "pop called on empty stack\n");
    else
    {
        TYPED(stack_node)* tmp = ps->top;
        ps->top = tmp->next;
        TYPE v = tmp->value;
        free(tmp);
        (ps->size)--;
        /*
        fprintf(stderr, "Popping: ");
        TYPED(print)(v, stderr);
        fprintf(stderr, "\n");
        */
        return v;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x43d0
movq 0x15c3b(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
leaq 0xfca4(%rip), %rsi      # 0x1406b
movb $0x0, %al
callq 0x3120
jmp 0x440f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3030
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/lexer.c
// Function: precompute_cclass
void precompute_cclass(cclass_t* cclass)
// find character class of each character and store it in cclass
{
    int i;
    for(i=0; i < (1 << sizeof(char)); ++i)
        cclass[i] = C_REST;

    for(i='a'; i<='z'; ++i) cclass[i] = C_ALPHA;
    for(i='A'; i<='Z'; ++i) cclass[i] = C_ALPHA;
    cclass['e'] = C_E; cclass['E'] = C_E;
    cclass['_'] = C_UNSC;

    for(i='0'; i<='9'; ++i) cclass[i] = C_DIG;

    cclass[' '] = C_WS;  cclass['\t'] = C_WS; cclass['\r'] = C_WS;
    cclass['\0'] = C_EOF; cclass['\n'] = C_NL;

    cclass['('] = C_SCO; cclass[')'] = C_SCO;
    cclass['['] = C_SCO; cclass[']'] = C_SCO;
    cclass[','] = C_SCO; cclass[';'] = C_SCO;
    cclass['/'] = C_SCO;

    cclass['+'] = C_PM; cclass['-'] = C_PM;
    cclass['='] = C_EQ; cclass['!'] = C_EXCL;
    cclass['<'] = C_LT; cclass['>'] = C_GT;
    cclass['.'] = C_DOT;
    cclass['*'] = C_STAR;
    cclass[':'] = C_COLON;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jge 0x44bf
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x449f
movl $0x61, -0xc(%rbp)
cmpl $0x7a, -0xc(%rbp)
jg 0x44e6
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x44c6
movl $0x41, -0xc(%rbp)
cmpl $0x5a, -0xc(%rbp)
jg 0x450d
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x44ed
movq -0x8(%rbp), %rax
movl $0x2, 0x194(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0x114(%rax)
movq -0x8(%rbp), %rax
movl $0x3, 0x17c(%rax)
movl $0x30, -0xc(%rbp)
cmpl $0x39, -0xc(%rbp)
jg 0x455e
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl $0x4, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x453e
movq -0x8(%rbp), %rax
movl $0x5, 0x80(%rax)
movq -0x8(%rbp), %rax
movl $0x5, 0x24(%rax)
movq -0x8(%rbp), %rax
movl $0x5, 0x34(%rax)
movq -0x8(%rbp), %rax
movl $0x10, (%rax)
movq -0x8(%rbp), %rax
movl $0x6, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x7, 0xa0(%rax)
movq -0x8(%rbp), %rax
movl $0x7, 0xa4(%rax)
movq -0x8(%rbp), %rax
movl $0x7, 0x16c(%rax)
movq -0x8(%rbp), %rax
movl $0x7, 0x174(%rax)
movq -0x8(%rbp), %rax
movl $0x7, 0xb0(%rax)
movq -0x8(%rbp), %rax
movl $0x7, 0xec(%rax)
movq -0x8(%rbp), %rax
movl $0x7, 0xbc(%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0xac(%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0xb4(%rax)
movq -0x8(%rbp), %rax
movl $0x9, 0xf4(%rax)
movq -0x8(%rbp), %rax
movl $0xa, 0x84(%rax)
movq -0x8(%rbp), %rax
movl $0xe, 0xf0(%rax)
movq -0x8(%rbp), %rax
movl $0xf, 0xf8(%rax)
movq -0x8(%rbp), %rax
movl $0xb, 0xb8(%rax)
movq -0x8(%rbp), %rax
movl $0xc, 0xa8(%rax)
movq -0x8(%rbp), %rax
movl $0xd, 0xe8(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/lexer.c
// Function: precompute_final_states
void precompute_final_states(bool* is_final)
{
    static state_t final_states[] = {S_ID, S_I1, S_R1, S_R2, S_STAR, S_DOT2, S_COLON,
        S_LT, S_LT2, S_LT3, S_GT, S_GT2, S_GT3};

    int i, num_final_states = sizeof(final_states) / sizeof(state_t);
    for(i=0; i < NUM_STATES; ++i)
        is_final[i] = false;
    for(i=0; i < num_final_states; ++i)
        is_final[final_states[i]] = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0xd, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x16, -0xc(%rbp)
jge 0x46b3
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4696
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x46e3
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rdx
leaq 0x15fbf(%rip), %rcx     # 0x1a690
movl (%rcx,%rdx,4), %ecx
movb $0x1, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x46ba
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/lexer.c
// Function: init_lexer
void init_lexer()
{
    precompute_cclass(pc_cclass);
    precompute_final_states(is_final);
    precompute_dfa();
    precompute_token_hmap();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x167b5(%rip), %rdi     # 0x1b980
callq 0x4490
leaq 0x16199(%rip), %rdi     # 0x1b370
callq 0x4680
callq 0x46f0
callq 0x4c30
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/lexer.c
// Function: get_cclass
cclass_t get_cclass(char ch)
{
    if(ch == '\0')
        return C_EOF;
    else if(ch < 0 || ch > 127)
        return C_REST;
    else
        return pc_cclass[(int)ch];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x0, %eax
jne 0x522c
movl $0x10, -0x4(%rbp)
jmp 0x525b
movsbl -0x5(%rbp), %eax
cmpl $0x0, %eax
jl 0x523e
movsbl -0x5(%rbp), %eax
cmpl $0x7f, %eax
jle 0x5247
movl $0x0, -0x4(%rbp)
jmp 0x525b
movsbl -0x5(%rbp), %eax
movslq %eax, %rcx
leaq 0x1672b(%rip), %rax     # 0x1b980
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/lexer.c
// Function: get_character
char get_character(FILE* fp)
{
    char ch;
    //static char fmt_str[] = "input: \'%c\' (%d)\n";
    if(input_ptr == NULL || *input_ptr == '\0')
    {
        int read = fread(input_buffer, sizeof(char), INPUT_BUFSIZE-1, fp);
        input_buffer[read] = '\0';
        input_ptr = input_buffer;
        if(read == 0)
        {
            //fprintf(stderr, fmt_str, '\0', 0);
            return '\0';
        }
    }
    ch = *(input_ptr++);
    //fprintf(stderr, fmt_str, ch, (int)ch);
    return ch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, 0x1690c(%rip)     # 0x1bb80
je 0x5285
movq 0x16903(%rip), %rax     # 0x1bb80
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x52cd
movq -0x10(%rbp), %rcx
leaq 0x16900(%rip), %rdi     # 0x1bb90
movl $0x1, %esi
movl $0x63, %edx
callq 0x3070
movl %eax, -0x18(%rbp)
movslq -0x18(%rbp), %rcx
leaq 0x168e3(%rip), %rax     # 0x1bb90
movb $0x0, (%rax,%rcx)
leaq 0x168d8(%rip), %rax     # 0x1bb90
movq %rax, 0x168c1(%rip)     # 0x1bb80
cmpl $0x0, -0x18(%rbp)
jne 0x52cb
movb $0x0, -0x1(%rbp)
jmp 0x52ed
jmp 0x52cd
movq 0x168ac(%rip), %rax     # 0x1bb80
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x1689e(%rip)     # 0x1bb80
movb (%rax), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/lexer.c
// Function: put_character
void put_character(FILE * fp, char ch)
{
    if(output_ptr == OUTPUT_BUFSIZE-1)
    {
        fwrite(output_buffer, sizeof(char), OUTPUT_BUFSIZE, fp);
        output_ptr = -1;
        //output_buffer[OUTPUT_BUFFER] = '\0';
        memset(output_buffer, '\0', OUTPUT_BUFSIZE);
    }
    output_ptr ++;
    output_buffer[output_ptr] = ch;
    if(ch == '\0')
        fwrite(output_buffer, sizeof(char), output_ptr+1, fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
cmpl $0x63, 0x153ab(%rip)    # 0x1a6c4
jne 0x5352
movq -0x8(%rbp), %rcx
leaq 0x168da(%rip), %rdi     # 0x1bc00
movl $0x1, %esi
movl $0x64, %edx
callq 0x31b0
movl $0xffffffff, 0x15385(%rip) # imm = 0xFFFFFFFF
leaq 0x168ba(%rip), %rdi     # 0x1bc00
xorl %esi, %esi
movl $0x64, %edx
callq 0x30d0
movl 0x1536c(%rip), %eax     # 0x1a6c4
addl $0x1, %eax
movl %eax, 0x15363(%rip)     # 0x1a6c4
movb -0x9(%rbp), %dl
movslq 0x15359(%rip), %rcx     # 0x1a6c4
leaq 0x1688e(%rip), %rax     # 0x1bc00
movb %dl, (%rax,%rcx)
movsbl -0x9(%rbp), %eax
cmpl $0x0, %eax
jne 0x539f
movl 0x15340(%rip), %eax     # 0x1a6c4
addl $0x1, %eax
movslq %eax, %rdx
movq -0x8(%rbp), %rcx
leaq 0x1686b(%rip), %rdi     # 0x1bc00
movl $0x1, %esi
callq 0x31b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/lexer.c
// Function: predict_token_from_char
tok_t predict_token_from_char(char ch)
{
    switch(ch)
    {
    case '+': return T_PLUS;
    case '-': return T_MINUS;
    case '(': return T_BO;
    case ')': return T_BC;
    case '[': return T_SQBO;
    case ']': return T_SQBC;
    case ',': return T_COMMA;
    case ';': return T_SEMICOL;
    case '/': return T_DIV;

    case '=': return T_EQ;
    case '!': return T_NE;
    case ':': return T_ASSIGNOP;
    case '<': return T_LE;
    case '>': return T_GE;
    default: return T_ERR;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
addl $-0x21, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3c, %eax
ja 0x5462
movq -0x10(%rbp), %rax
leaq 0xecad(%rip), %rcx      # 0x14088
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x23, -0x4(%rbp)
jmp 0x5469
movl $0x24, -0x4(%rbp)
jmp 0x5469
movl $0x36, -0x4(%rbp)
jmp 0x5469
movl $0x37, -0x4(%rbp)
jmp 0x5469
movl $0x38, -0x4(%rbp)
jmp 0x5469
movl $0x39, -0x4(%rbp)
jmp 0x5469
movl $0x34, -0x4(%rbp)
jmp 0x5469
movl $0x33, -0x4(%rbp)
jmp 0x5469
movl $0x26, -0x4(%rbp)
jmp 0x5469
movl $0x2b, -0x4(%rbp)
jmp 0x5469
movl $0x2c, -0x4(%rbp)
jmp 0x5469
movl $0x35, -0x4(%rbp)
jmp 0x5469
movl $0x28, -0x4(%rbp)
jmp 0x5469
movl $0x2a, -0x4(%rbp)
jmp 0x5469
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/lexer.c
// Function: predict_token_from_state
tok_t predict_token_from_state(state_t s)
{
    switch(s)
    {
    case S_ID: return T_ID;
    case S_I1: return T_NUM;
    case S_R1:
    case S_R2: return T_RNUM;

    case S_STAR: return T_MUL;
    case S_DOT2: return T_RANGEOP;
    case S_COLON: return T_COLON;

    case S_LT: return T_LT;
    case S_LT2: return T_DEF;
    case S_LT3: return T_DRIVERDEF;
    case S_GT: return T_GT;
    case S_GT2: return T_ENDDEF;
    case S_GT3: return T_DRIVERENDDEF;

    default: return T_ERR;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x14, %eax
ja 0x550b
movq -0x10(%rbp), %rax
leaq 0xece6(%rip), %rcx      # 0x1417c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x2, -0x4(%rbp)
jmp 0x5512
movl $0x3, -0x4(%rbp)
jmp 0x5512
movl $0x4, -0x4(%rbp)
jmp 0x5512
movl $0x25, -0x4(%rbp)
jmp 0x5512
movl $0x32, -0x4(%rbp)
jmp 0x5512
movl $0x31, -0x4(%rbp)
jmp 0x5512
movl $0x27, -0x4(%rbp)
jmp 0x5512
movl $0x2d, -0x4(%rbp)
jmp 0x5512
movl $0x2e, -0x4(%rbp)
jmp 0x5512
movl $0x29, -0x4(%rbp)
jmp 0x5512
movl $0x2f, -0x4(%rbp)
jmp 0x5512
movl $0x30, -0x4(%rbp)
jmp 0x5512
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/lexer.c
// Function: swap_buffers
void swap_buffers(Dfa* pdfa, Token* ptok)
{
    char* p = pdfa->lexeme;
    pdfa->lexeme = ptok->lexeme;
    ptok->lexeme = p;
    int s = pdfa->size;
    pdfa->size = ptok->size;
    ptok->size = s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/lexer.c
// Function: init_dfa
void init_dfa(Dfa* pdfa)
{
    pdfa->s = S_START;
    pdfa->line = 1;
    pdfa->col = 1;
    pdfa->lexeme = buff1;
    pdfa->trunc = false;
    buff1[0] = '\0';
    pdfa->size = 0;
    pdfa->error_count = 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x8(%rbp), %rax
leaq 0x1630d(%rip), %rcx     # 0x1bc70
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x1c(%rax)
movb $0x0, 0x162fa(%rip)     # 0x1bc70
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/lexer.c
// Function: init_token
void init_token(Token* ptok)
{
    ptok->line = 0;
    ptok->col = 0;
    ptok->lexeme = buff2;
    buff2[0] = '\0';
    ptok->size = 0;
    ptok->dyn_lexeme = false;
    ptok->tid = T_ERR;
    ptok->f = 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
leaq 0x162d8(%rip), %rcx     # 0x1bc90
movq %rcx, 0x8(%rax)
movb $0x0, 0x162cd(%rip)     # 0x1bc90
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x1c(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/lexer.c
// Function: token_check
tok_t token_check(const char* s)
// returns correct token based on keyword
{
    pch_int_hmap_node* p = pch_int_hmap_query(&token_hmap, s);
    if(p == NULL)
        return T_ID;
    else
        return p->value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x15f61(%rip), %rdi     # 0x1b968
callq 0x34c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5a20
movl $0x2, -0x4(%rbp)
jmp 0x5a2a
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -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/lexer.c
// Function: post_process
void post_process(Dfa* pdfa, Token* ptok)
{
    if((ptok->tid) == T_ID)
    {
        ptok->tid = token_check(ptok->lexeme);
        if((ptok->tid) == T_ID && (ptok->size) > 8)
            print_lex_error(LERR_LONG_ID, pdfa, ptok);
        if((ptok->tid) == T_ID && ptok->lexeme[0] == '_')
            print_lex_error(LERR_ID_UNSC, pdfa, ptok);
        ptok->f = 0.0;
    }
    else if(ptok->tid == T_NUM)
        ptok->i = atoi(ptok->lexeme);
    else if(ptok->tid == T_RNUM)
        ptok->f = atof(ptok->lexeme);
    else
        ptok->f = 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, 0x18(%rax)
jne 0x5ad0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x59f0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpl $0x2, 0x18(%rax)
jne 0x5a96
movq -0x10(%rbp), %rax
cmpl $0x8, 0x14(%rax)
jle 0x5a96
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl $0x6, %edi
callq 0x5520
movq -0x10(%rbp), %rax
cmpl $0x2, 0x18(%rax)
jne 0x5ac2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x5f, %eax
jne 0x5ac2
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl $0x4, %edi
callq 0x5520
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x1c(%rax)
jmp 0x5b28
movq -0x10(%rbp), %rax
cmpl $0x3, 0x18(%rax)
jne 0x5af2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3170
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
jmp 0x5b26
movq -0x10(%rbp), %rax
cmpl $0x4, 0x18(%rax)
jne 0x5b18
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3080
cvtsd2ss %xmm0, %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x1c(%rax)
jmp 0x5b24
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x1c(%rax)
jmp 0x5b26
jmp 0x5b28
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/lexer.c
// Function: tick_dfa
bool tick_dfa(char ch, Dfa* pdfa, Token* ptok, bool debug)
// return true if token is ready
{
    cclass_t cclass = get_cclass(ch);
    state_t s2 = state_table[pdfa->s][cclass];
    action_t a = action_table[pdfa->s][cclass];
    execute_action(a, ch, pdfa, ptok);
    if(debug)
        fprintf(stderr, "\t%s %c %s %s\n", STATE_STRS[pdfa->s], ch, STATE_STRS[s2], ACTION_STRS[a]);
    pdfa->s = s2;
    (pdfa->col)++;
    return (a == A_TOKS || a == A_TOKF || a == A_TOKN || a == A_ERR);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movsbl -0x1(%rbp), %edi
callq 0x5210
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x15228(%rip), %rax     # 0x1ad90
imulq $0x44, %rcx, %rcx
addq %rcx, %rax
movl -0x20(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x15809(%rip), %rax     # 0x1b390
imulq $0x44, %rcx, %rcx
addq %rcx, %rax
movl -0x20(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %edi
movb -0x1(%rbp), %al
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movsbl %al, %esi
callq 0x5600
testb $0x1, -0x19(%rbp)
je 0x5c02
movq 0x1443e(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x14a14(%rip), %rax     # 0x1a5e0
movq (%rax,%rcx,8), %rdx
movsbl -0x1(%rbp), %ecx
movl -0x24(%rbp), %eax
movl %eax, %esi
leaq 0x14a00(%rip), %rax     # 0x1a5e0
movq (%rax,%rsi,8), %r8
movl -0x28(%rbp), %eax
movl %eax, %esi
leaq 0x149b0(%rip), %rax     # 0x1a5a0
movq (%rax,%rsi,8), %r9
leaq 0xeaad(%rip), %rsi      # 0x146a8
movb $0x0, %al
callq 0x3120
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movb $0x1, %al
cmpl $0x4, -0x28(%rbp)
movb %al, -0x29(%rbp)
je 0x5c43
movb $0x1, %al
cmpl $0x5, -0x28(%rbp)
movb %al, -0x29(%rbp)
je 0x5c43
movb $0x1, %al
cmpl $0x6, -0x28(%rbp)
movb %al, -0x29(%rbp)
je 0x5c43
cmpl $0x7, -0x28(%rbp)
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/lexer.c
// Function: get_token
void get_token(FILE* fp, Dfa* pdfa, Token* ptok, bool debug)
{
    while(true)
    {
        char ch = get_character(fp);
        if(ch == '\0')
        {
            ptok->line = pdfa->line;
            ptok->col = pdfa->col;
            ptok->lexeme[0] = '\0';
            ptok->size = 0;
            ptok->tid = T_EOF;
            break;
        }
        else if(tick_dfa(ch, pdfa, ptok, debug))
        {
            post_process(pdfa, ptok);
            break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5260
movb %al, -0x1a(%rbp)
movsbl -0x1a(%rbp), %eax
cmpl $0x0, %eax
jne 0x5cbe
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x18(%rax)
jmp 0x5cf5
movb -0x1a(%rbp), %cl
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movb -0x19(%rbp), %al
andb $0x1, %al
movsbl %cl, %edi
movzbl %al, %ecx
callq 0x5b30
testb $0x1, %al
jne 0x5cdf
jmp 0x5cee
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5a40
jmp 0x5cf5
jmp 0x5cf0
jmp 0x5c6b
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/lexer.c
// Function: print_token
void print_token(const Token* ptok, FILE* fp)
{
    fprintf(fp, "%2d %2d %s %s", ptok->line, ptok->col, TOK_STRS[ptok->tid], ptok->lexeme);
    if(ptok->tid == T_NUM)
        fprintf(fp, " %d\n", ptok->i);
    else if(ptok->tid == T_RNUM)
        fprintf(fp, " %lf\n", ptok->f);
    else
        fprintf(fp, "\n");
}

// 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 (%rax), %edx
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movslq 0x18(%rax), %rsi
leaq 0x14440(%rip), %rax     # 0x1a170
movq (%rax,%rsi,8), %r8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r9
leaq 0xe973(%rip), %rsi      # 0x146b6
movb $0x0, %al
callq 0x3120
movq -0x8(%rbp), %rax
cmpl $0x3, 0x18(%rax)
jne 0x5d6f
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %edx
leaq 0xe9ae(%rip), %rsi      # 0x14714
movb $0x0, %al
callq 0x3120
jmp 0x5dae
movq -0x8(%rbp), %rax
cmpl $0x4, 0x18(%rax)
jne 0x5d9a
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movss 0x1c(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xf36e(%rip), %rsi      # 0x150ff
movb $0x1, %al
callq 0x3120
jmp 0x5dac
movq -0x10(%rbp), %rdi
leaq 0xf386(%rip), %rsi      # 0x1512b
movb $0x0, %al
callq 0x3120
jmp 0x5dae
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/lexer.c
// Function: print_source_without_comments
void print_source_without_comments(FILE * ifp, FILE * ofp){
    int state = 0;
    char ch = get_character(ifp);
    int bch;
    int transition_mat[][4] = {{0,1},{0,2},{2,3},{2,0}};
    int action_mat[][4] = {{1,0},{2,0},{0,0},{0,0}};
    while(ch != '\0'){
        if(ch == '*') bch = 1;
        else bch = 0;
        if(action_mat[state][bch] == 0);
        else if(action_mat[state][bch] == 1) put_character(ofp, ch);
        else if(action_mat[state][bch] == 2){
            put_character(ofp, '*');
            put_character(ofp, ch);
        }
        state = transition_mat[state][bch];
        ch = get_character(ifp);
    }
    put_character(ofp,ch);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5260
movb %al, -0x15(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x30d0
movl $0x1, -0x5c(%rbp)
movl $0x2, -0x4c(%rbp)
movl $0x2, -0x40(%rbp)
movl $0x3, -0x3c(%rbp)
movl $0x2, -0x30(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x30d0
movl $0x1, -0xa0(%rbp)
movl $0x2, -0x90(%rbp)
movsbl -0x15(%rbp), %eax
cmpl $0x0, %eax
je 0x6414
movsbl -0x15(%rbp), %eax
cmpl $0x2a, %eax
jne 0x635f
movl $0x1, -0x1c(%rbp)
jmp 0x6366
movl $0x0, -0x1c(%rbp)
movslq -0x14(%rbp), %rcx
leaq -0xa0(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x6384
jmp 0x63ea
movslq -0x14(%rbp), %rcx
leaq -0xa0(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x63af
movq -0x10(%rbp), %rdi
movsbl -0x15(%rbp), %esi
callq 0x5300
jmp 0x63e8
movslq -0x14(%rbp), %rcx
leaq -0xa0(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
cmpl $0x2, (%rax,%rcx,4)
jne 0x63e6
movq -0x10(%rbp), %rdi
movl $0x2a, %esi
callq 0x5300
movq -0x10(%rbp), %rdi
movsbl -0x15(%rbp), %esi
callq 0x5300
jmp 0x63e8
jmp 0x63ea
movslq -0x14(%rbp), %rcx
leaq -0x60(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5260
movb %al, -0x15(%rbp)
jmp 0x6340
movq -0x10(%rbp), %rdi
movsbl -0x15(%rbp), %esi
callq 0x5300
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/parser.c
// Function: get_nt_id
int get_nt_id(gsymb_t s){
    if(s < 0)
        fprintf(stderr, "get_nt_id: got -ve input %d.\n", s);
    else if(s < (int)NUM_TOKENS)
        fprintf(stderr, "get_nt_id: got terminal input %d.\n", s);
    else if(s >= (int)NUM_GS)
        fprintf(stderr, "get_nt_id: got too big input %d.\n", s);
    else
        return s - NUM_TOKENS;
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jae 0x64ae
movq 0x13b60(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
movl -0x8(%rbp), %edx
leaq 0xe2ab(%rip), %rsi      # 0x14750
movb $0x0, %al
callq 0x3120
jmp 0x6503
cmpl $0x3a, -0x8(%rbp)
jae 0x64d1
movq 0x13b3d(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
movl -0x8(%rbp), %edx
leaq 0xe2a6(%rip), %rsi      # 0x1476e
movb $0x0, %al
callq 0x3120
jmp 0x6501
cmpl $0x70, -0x8(%rbp)
jb 0x64f4
movq 0x13b1a(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
movl -0x8(%rbp), %edx
leaq 0xe2a6(%rip), %rsi      # 0x14791
movb $0x0, %al
callq 0x3120
jmp 0x64ff
movl -0x8(%rbp), %eax
subl $0x3a, %eax
movl %eax, -0x4(%rbp)
jmp 0x650a
jmp 0x6501
jmp 0x6503
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/parser.c
// Function: init_symbol
void init_symbol(Symbol * symb){
    symb->line = 0;
    symb->col = 0;
    symb->lexeme = NULL;
    symb->sid = T_ERR;
    symb->f = 0.0;
    symb->rule_num = -1;
    symb->tree = symb->next = symb->driver = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/parser.c
// Function: make_symbol
Symbol * make_symbol(gsymb_t sid){
    Symbol * ret = (Symbol*)malloc(sizeof(Symbol));
    init_symbol(ret);
    ret->sid = sid;
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x40, %edi
callq 0x3130
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6560
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/parser.c
// Function: get_successor
parse_tree_node * get_successor(const parse_tree_node * curr){
    while(curr != NULL && curr->next_sibling == NULL)
        curr = curr->parent;
    if(curr != NULL)
        return curr->next_sibling;
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0x67d3
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x67dc
jmp 0x67ea
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x67b8
cmpq $0x0, -0x10(%rbp)
je 0x67ff
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6807
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/parser.c
// Function: get_gsymb_id
gsymb_t get_gsymb_id(const char* str)
{
    pch_int_hmap_node* hmap_n = pch_int_hmap_query(&gsymb_ht, str);
    if(hmap_n == NULL)
    {
        fprintf(stderr, "Unrecognized grammar symbol %s\n", str);
        return GS_LAST;
    }
    return hmap_n->value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x149c9(%rip), %rdi     # 0x1bcd0
callq 0x34c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x733c
movq 0x12cda(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0xd68b(%rip), %rsi      # 0x149b7
movb $0x0, %al
callq 0x3120
movl $0x70, -0x4(%rbp)
jmp 0x7346
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/parser.c
// Function: getRuleNode
RuleNode* getRuleNode(gsymb_t sid)
{
    RuleNode* n = malloc(sizeof(RuleNode));
    n->value = sid;
    n->next = NULL;
    n->first = unset_bitset;
    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x18, %edi
callq 0x3130
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $-0x1, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/parser.c
// Function: init_parser
gsymb_t init_parser()
{
    init_lexer();

    parser_error_count = 0;

    init_gsymb_ht();
    pch_int_hmap_init(&intern_table, 50, true);
    char str[100];
    FILE* gfp = fopen("data/grammar.txt", "r");
    fscanf(gfp, "%s", str);
    gsymb_t start_symb = get_gsymb_id(str);
    //fprintf(stderr, "start_symbol = %s\n", GS_STRS[start_symb]);
    num_rules = read_grammar(gfp);
    fclose(gfp);

    int i;
    for(i=0; i < NUM_NONTERMS; ++i)
    {
        first[i] = unset_bitset;
        follow[i] = empty_bitset;
    }

    update_follow(start_symb);

    for(int i=0; i<NUM_NONTERMS; i++)
        for(int j=0; j<NUM_TOKENS; j++)
            pt[i][j] = -1;

    bool is_ll1 = make_parse_table();
    //char pt_fname[] = "data/parse_table.txt";
    //read_parse_table(pt_fname);

    if(!is_ll1)
        fprintf(stderr, "The grammar is not LL1\n");

    return start_symb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb $0x0, %al
callq 0x51c0
movl $0x0, 0x15204(%rip)     # 0x1c8f0
callq 0x6850
leaq 0x145c0(%rip), %rdi     # 0x1bcb8
movl $0x32, %esi
movl $0x1, %edx
callq 0x3390
leaq 0xd2f9(%rip), %rdi      # 0x14a07
leaq 0xd178(%rip), %rsi      # 0x1488d
callq 0x3150
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
leaq -0x70(%rbp), %rdx
leaq 0xe56b(%rip), %rsi      # 0x15c98
movb $0x0, %al
callq 0x3060
leaq -0x70(%rbp), %rdi
callq 0x72f0
movl %eax, -0x7c(%rbp)
movq -0x78(%rbp), %rdi
callq 0x73a0
movl %eax, 0x151a5(%rip)     # 0x1c8f4
movq -0x78(%rbp), %rdi
callq 0x3090
movl $0x0, -0x80(%rbp)
cmpl $0x36, -0x80(%rbp)
jge 0x7796
movslq -0x80(%rbp), %rcx
leaq 0x15190(%rip), %rax     # 0x1c900
movq $-0x1, (%rax,%rcx,8)
movslq -0x80(%rbp), %rcx
leaq 0x1532d(%rip), %rax     # 0x1cab0
movq $0x0, (%rax,%rcx,8)
movl -0x80(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x80(%rbp)
jmp 0x775f
movl -0x7c(%rbp), %edi
callq 0x7850
movl $0x0, -0x84(%rbp)
cmpl $0x36, -0x84(%rbp)
jge 0x780e
movl $0x0, -0x88(%rbp)
cmpl $0x3a, -0x88(%rbp)
jge 0x77fb
movslq -0x84(%rbp), %rcx
leaq 0x1548e(%rip), %rax     # 0x1cc60
imulq $0xe8, %rcx, %rcx
addq %rcx, %rax
movslq -0x88(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x88(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x88(%rbp)
jmp 0x77bb
jmp 0x77fd
movl -0x84(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
jmp 0x77a8
callq 0x7fd0
andb $0x1, %al
movb %al, -0x89(%rbp)
testb $0x1, -0x89(%rbp)
jne 0x783c
movq 0x127cd(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
leaq 0xd1e3(%rip), %rsi      # 0x14a18
movb $0x0, %al
callq 0x3120
movl -0x7c(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/parser.c
// Function: update_follow
void update_follow(gsymb_t start_symb)
{
    follow[get_nt_id(start_symb)] = bitset_singleton(T_EOF);
    follow_changed = true;
    while(follow_changed)
    {
        follow_changed = false;
        int i;
        for(i=0; i<num_rules; ++i)
            update_follow_helper(i);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x1, %edi
callq 0x7ae0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %edi
callq 0x6480
movq -0x10(%rbp), %rdx
movslq %eax, %rcx
leaq 0x15231(%rip), %rax     # 0x1cab0
movq %rdx, (%rax,%rcx,8)
movb $0x1, 0x14426(%rip)     # 0x1bcb0
testb $0x1, 0x1441f(%rip)     # 0x1bcb0
je 0x78c1
movb $0x0, 0x14416(%rip)     # 0x1bcb0
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x1504a(%rip), %eax     # 0x1c8f4
jge 0x78bf
movl -0x8(%rbp), %edi
callq 0x7c10
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x78a1
jmp 0x788a
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/parser.c
// Function: destroy_rules
void destroy_rules()
{
    int i;
    for(i=0; i < NUM_RULES; ++i)
    {
        rules[i].tail = NULL;
        RuleNode *p = rules[i].head, *todel = NULL;
        rules[i].head = NULL;
        while(p != NULL)
        {
            todel = p;
            p = p->next;
            todel->next = NULL;
            free(todel);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x64, -0x4(%rbp)
jge 0x797f
movslq -0x4(%rbp), %rcx
leaq 0x1469c(%rip), %rax     # 0x1bf90
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x10(%rax)
movslq -0x4(%rbp), %rcx
leaq 0x14682(%rip), %rax     # 0x1bf90
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x14660(%rip), %rax     # 0x1bf90
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x796f
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rdi
callq 0x3030
jmp 0x793f
jmp 0x7971
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x78df
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/parser.c
// Function: destroy_parser
void destroy_parser(bool destroy_intern_table)
{
    destroy_lexer();
    pch_int_hmap_clear(&gsymb_ht);
    destroy_rules();
    if(destroy_intern_table) {
        pch_int_hmap_clear(&intern_table);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb $0x0, %al
callq 0x51f0
leaq 0x14322(%rip), %rdi     # 0x1bcd0
callq 0x33f0
callq 0x78d0
testb $0x1, -0x1(%rbp)
je 0x79ca
leaq 0x142f3(%rip), %rdi     # 0x1bcb8
callq 0x33f0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/parser.c
// Function: get_first_symb
bitset_t get_first_symb(gsymb_t sid)
// get first set of a symbol
{
    if(sid < 0 || sid >= NUM_GS)
    {
        fprintf(stderr, "get_first_nt: Invalid sid %d\n", sid);
        return empty_bitset;
    }
    else if(sid < (int)NUM_TOKENS)
        return bitset_singleton(sid);
    else
    {
        int ntid = get_nt_id(sid);
        if(first[ntid] == unset_bitset)
        {
            int i;
            first[ntid] = empty_bitset;
            for(i=rule_begin[ntid]; i < rule_end[ntid]; ++i)
                first[ntid] |= get_first_str(rules[i].head);
        }
        return first[ntid];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jb 0x79e7
cmpl $0x70, -0xc(%rbp)
jb 0x7a0f
movq 0x1260a(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
movl -0xc(%rbp), %edx
leaq 0xd035(%rip), %rsi      # 0x14a30
movb $0x0, %al
callq 0x3120
movq $0x0, -0x8(%rbp)
jmp 0x7ad2
cmpl $0x3a, -0xc(%rbp)
jae 0x7a26
movl -0xc(%rbp), %edi
callq 0x7ae0
movq %rax, -0x8(%rbp)
jmp 0x7ad2
movl -0xc(%rbp), %edi
callq 0x6480
movl %eax, -0x10(%rbp)
movslq -0x10(%rbp), %rcx
leaq 0x14ec4(%rip), %rax     # 0x1c900
cmpq $-0x1, (%rax,%rcx,8)
jne 0x7abf
movslq -0x10(%rbp), %rcx
leaq 0x14eb2(%rip), %rax     # 0x1c900
movq $0x0, (%rax,%rcx,8)
movslq -0x10(%rbp), %rcx
leaq 0x1428f(%rip), %rax     # 0x1bcf0
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movslq -0x10(%rbp), %rdx
leaq 0x1435b(%rip), %rcx     # 0x1bdd0
cmpl (%rcx,%rdx,4), %eax
jge 0x7abd
movslq -0x14(%rbp), %rcx
leaq 0x1450b(%rip), %rax     # 0x1bf90
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x7b00
movq %rax, %rdx
movslq -0x10(%rbp), %rcx
leaq 0x14e5d(%rip), %rax     # 0x1c900
orq (%rax,%rcx,8), %rdx
leaq 0x14e52(%rip), %rax     # 0x1c900
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7a67
jmp 0x7abf
movslq -0x10(%rbp), %rcx
leaq 0x14e36(%rip), %rax     # 0x1c900
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/parser.c
// Function: get_first_str
bitset_t get_first_str(RuleNode* node)
// get first set of a linked list string starting at node
{
    if(node == NULL)
        return bitset_singleton(T_EOF);

    if(node->first == unset_bitset)
    {
        int sid = node->value;
        bitset_t s = get_first_symb(sid);
        if(bitset_has(s, T_EOF))
            s = bitset_remove(s, T_EOF) | get_first_str(node->next);
        node->first = s;
    }
    return node->first;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7b23
movl $0x1, %edi
callq 0x7ae0
movq %rax, -0x8(%rbp)
jmp 0x7b9c
movq -0x10(%rbp), %rax
cmpq $-0x1, 0x10(%rax)
jne 0x7b90
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x79d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x7bb0
testb $0x1, %al
jne 0x7b58
jmp 0x7b84
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x7be0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x7b00
movq %rax, %rcx
movq -0x28(%rbp), %rax
orq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
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/sharmaeklavya2[P]cerplag/parser.c
// Function: update_follow_helper
void update_follow_helper(int rule_no)
// update follow using rule number i
{
    RuleNode* n = rules[rule_no].head;
    for(; n != NULL; n = n->next)
    {
        gsymb_t sid = n->value;
        if(sid >= (int)NUM_TOKENS)
        {
            int ntid = get_nt_id(sid);
            bitset_t s = get_first_str(n->next);
            bitset_t new_follow = bitset_remove(s, T_EOF) | follow[ntid];
            if(follow[ntid] != new_follow)
            {
                follow_changed = true;
                follow[ntid] = new_follow;
            }
            if(bitset_has(s, T_EOF))
            {
                bitset_t s3 = follow[get_nt_id(rules[rule_no].lhs)];
                new_follow = s3 | follow[ntid];
                if(new_follow != follow[ntid])
                {
                    follow_changed = true;
                    follow[ntid] = new_follow;
                }
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x1436a(%rip), %rax     # 0x1bf90
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7d5a
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x3a, -0x14(%rbp)
jb 0x7d48
movl -0x14(%rbp), %edi
callq 0x6480
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x7b00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x7be0
movslq -0x18(%rbp), %rdx
leaq 0x14e28(%rip), %rcx     # 0x1cab0
orq (%rcx,%rdx,8), %rax
movq %rax, -0x28(%rbp)
movslq -0x18(%rbp), %rcx
leaq 0x14e15(%rip), %rax     # 0x1cab0
movq (%rax,%rcx,8), %rax
cmpq -0x28(%rbp), %rax
je 0x7cbf
movb $0x1, 0x14004(%rip)     # 0x1bcb0
movq -0x28(%rbp), %rdx
movslq -0x18(%rbp), %rcx
leaq 0x14df5(%rip), %rax     # 0x1cab0
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x7bb0
testb $0x1, %al
jne 0x7cd3
jmp 0x7d46
movslq -0x4(%rbp), %rcx
leaq 0x142b2(%rip), %rax     # 0x1bf90
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %edi
callq 0x6480
movslq %eax, %rcx
leaq 0x14dba(%rip), %rax     # 0x1cab0
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movslq -0x18(%rbp), %rdx
leaq 0x14da3(%rip), %rcx     # 0x1cab0
orq (%rcx,%rdx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq -0x18(%rbp), %rdx
leaq 0x14d8c(%rip), %rcx     # 0x1cab0
cmpq (%rcx,%rdx,8), %rax
je 0x7d44
movb $0x1, 0x13f7f(%rip)     # 0x1bcb0
movq -0x28(%rbp), %rdx
movslq -0x18(%rbp), %rcx
leaq 0x14d70(%rip), %rax     # 0x1cab0
movq %rdx, (%rax,%rcx,8)
jmp 0x7d46
jmp 0x7d48
jmp 0x7d4a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x7c35
addq $0x30, %rsp
popq %rbp
retq