LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]yahs/sdict.c
// Function: sd_coordinate_rev_conversion
int sd_coordinate_rev_conversion(asm_dict_t *d, uint32_t id, uint64_t pos, uint32_t *s, uint32_t *p, int count_gap)
{
    *s = UINT32_MAX;
    *p = UINT32_MAX;

    if (id >= d->n)
        return SEQ_NOT_FOUND;

    sd_seg_t *seg = d->seg + d->s[id].s;
    uint32_t i = 0, n = d->s[id].n;
    uint64_t offset = 0;

    if (count_gap) {
        while (i < n && pos >= seg[i].b)
            ++i;
        seg = &seg[i-1];
        offset = pos - seg->b;
    } else {
        while (i < n && pos >= seg[i].a)
            ++i;
        seg = &seg[i-1];
        offset = pos - seg->a;
    }
    
    // check if in gap or exceeds seq length
    if (offset >= seg->y)
        return POS_NOT_IN_RANGE;

    *s = seg->c >> 1;
    *p = seg->c & 1? seg->y - 1 - offset : seg->x + offset;

    return CC_SUCCESS;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, (%rcx)
movl %eax, (%r8)
movl $0x1, %eax
cmpl %esi, (%rdi)
jbe 0x6def
movq 0x8(%rdi), %rax
movq 0x20(%rdi), %rdi
movl %esi, %esi
imulq $0x58, %rsi, %rsi
movl 0x18(%rax,%rsi), %r10d
movl 0x1c(%rax,%rsi), %eax
leaq (%rax,%rax,2), %r11
shlq $0x4, %r11
leaq (%rdi,%r11), %rax
testl %r9d, %r9d
je 0x6d78
movl $0x10, %esi
testq %r10, %r10
je 0x6da4
leaq (%r11,%rdi), %r9
addq $0x10, %r9
xorl %edi, %edi
cmpq %rdx, (%r9)
ja 0x6da0
incq %rdi
addq $0x30, %r9
cmpq %rdi, %r10
jne 0x6d65
jmp 0x6d9d
movl $0x8, %esi
testq %r10, %r10
je 0x6da4
leaq (%r11,%rdi), %r9
addq $0x8, %r9
xorl %edi, %edi
cmpq %rdx, (%r9)
ja 0x6da0
incq %rdi
addq $0x30, %r9
cmpq %rdi, %r10
jne 0x6d8c
movl %r10d, %edi
decl %edi
jmp 0x6da9
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl %edi, %edi
leaq (%rdi,%rdi,2), %r9
shlq $0x4, %r9
leaq (%rax,%r9), %rdi
subq (%rsi,%rdi), %rdx
movl 0x20(%rax,%r9), %esi
movl $0x2, %eax
cmpq %rsi, %rdx
jae 0x6def
movl 0x18(%rdi), %eax
shrl %eax
movl %eax, (%rcx)
testb $0x1, 0x18(%rdi)
jne 0x6de2
movl 0x1c(%rdi), %eax
addq %rax, %rdx
movq %rdx, %rax
jmp 0x6dea
movl 0x20(%rdi), %eax
decl %eax
subq %rdx, %rax
movl %eax, (%r8)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]yahs/sdict.c
// Function: sd_stats
void sd_stats(sdict_t *d, uint64_t *n_stats, uint32_t *l_stats)
{
    // n_stats and l_stats are of at least size 10
    uint32_t i, n;
    uint64_t *s;

    n = d->n;
    s = (uint64_t *) calloc(n, sizeof(uint64_t));
    for (i = 0; i < n; ++i)
        s[i] = d->s[i].len;
    nl_stats(s, n, n_stats, l_stats);
    
    free(s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r13
movl (%rdi), %r15d
movl $0x8, %esi
movq %r15, %rdi
callq 0x21d0
movq %rax, %r12
testq %r15, %r15
je 0x6e47
movq 0x8(%r13), %rax
addq $0x10, %rax
xorl %ecx, %ecx
movl (%rax), %edx
movq %rdx, (%r12,%rcx,8)
incq %rcx
addq $0x18, %rax
cmpq %rcx, %r15
jne 0x6e35
movq %r12, %rdi
movl %r15d, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x6e69
movq %r12, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]yahs/sdict.c
// Function: nl_stats
static void nl_stats(uint64_t *s, uint32_t n, uint64_t *n_stats, uint32_t *l_stats)
{
    uint32_t i, j;
    double b, a, bs;
    
    bs = 0;
    for (i = 0; i < n; ++i)
        bs += s[i];

    qsort(s, n, sizeof(uint64_t), cmp_uint64_d);

    b = 0;
    j = 0;
    a = .1 * (++j) * bs;
    for (i = 0; i < n; ++i) {
        b += s[i];
        while (b >= a) {
            l_stats[j - 1] = i + 1;
            n_stats[j - 1] = s[i];
            a = .1 * (++j) * bs;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, %r14d
testl %esi, %esi
je 0x6f72
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
xorpd %xmm2, %xmm2
xorl %eax, %eax
movsd (%rbx,%rax,8), %xmm0
unpcklps 0x3553(%rip), %xmm0     # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x355b(%rip), %xmm0     # 0xa400
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
addsd %xmm1, %xmm2
incq %rax
cmpq %rax, %r14
jne 0x6e91
leaq -0xd4(%rip), %rcx       # 0x6df0
movl $0x8, %edx
movq %rbx, %rdi
movq %r14, %rsi
movsd %xmm2, 0x8(%rsp)
callq 0x20b0
movapd 0x351e(%rip), %xmm7     # 0xa400
movq 0x3506(%rip), %xmm6     # 0xa3f0
movsd 0x8(%rsp), %xmm5
testl %ebp, %ebp
je 0x6f65
movsd 0x3514(%rip), %xmm2     # 0xa410
mulsd %xmm5, %xmm2
movl $0x1, %eax
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
movsd 0x34fd(%rip), %xmm0     # 0xa410
movapd %xmm1, %xmm3
movq (%rbx,%rcx,8), %rdx
movq %rdx, %xmm4
punpckldq %xmm6, %xmm4    # xmm4 = xmm4[0],xmm6[0],xmm4[1],xmm6[1]
subpd %xmm7, %xmm4
movapd %xmm4, %xmm1
unpckhpd %xmm4, %xmm1            # xmm1 = xmm1[1],xmm4[1]
addsd %xmm4, %xmm1
addsd %xmm3, %xmm1
incq %rcx
ucomisd %xmm2, %xmm1
jb 0x6f60
leal -0x1(%rax), %esi
movl %ecx, (%r15,%rsi,4)
movq %rdx, (%r12,%rsi,8)
incl %eax
xorps %xmm2, %xmm2
cvtsi2sd %rax, %xmm2
mulsd %xmm0, %xmm2
mulsd %xmm5, %xmm2
jmp 0x6f3b
cmpq %r14, %rcx
jne 0x6f13
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x189(%rip), %rcx      # 0x6df0
movl $0x8, %edx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20b0
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]yahs/sdict.c
// Function: write_sorted_agp
void write_sorted_agp(asm_dict_t *dict, FILE *fo)
{
    int i, j;
    uint32_t s;
    char s_name[32];
    c_pair_t *c_pairs;

    c_pairs = (c_pair_t *) malloc(dict->n * sizeof(c_pair_t));
    for(i = 0; i < dict->n; ++i) {
        c_pair_t pair = {dict->s[i].len, i};
        c_pairs[i] = pair;
    }
    radix_sort_pair(c_pairs, c_pairs + dict->n);
    s = 0;
    for (i = dict->n - 1; i >= 0; --i) {
        j = c_pairs[i].y;
        sprintf(s_name, "scaffold_%u", ++s);
        write_segs_to_agp(dict->seg + dict->s[j].s, dict->s[j].n, &dict->s[j], dict->sdict, s_name, fo);
    }
    free(c_pairs);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %r15d
movq %r15, %r12
shlq $0x4, %r12
movq %r12, %rdi
callq 0x2250
testq %r15, %r15
je 0x7f3a
movq 0x8(%r14), %rdi
leaq 0x8(%rax), %rcx
addq $0x8, %rdi
xorl %edx, %edx
movq (%rdi), %rsi
movq %rsi, -0x8(%rcx)
movq %rdx, (%rcx)
incq %rdx
addq $0x10, %rcx
addq $0x58, %rdi
cmpq %rdx, %r15
jne 0x7f20
addq %rax, %r12
movq %rax, 0x8(%rsp)
movq %rax, %rdi
movq %r12, %rsi
callq 0x5694
movl (%r14), %eax
movq %rax, (%rsp)
decl %eax
js 0x7feb
movl %eax, %eax
shlq $0x4, %rax
movq 0x8(%rsp), %rcx
leaq (%rax,%rcx), %r12
addq $0x8, %r12
movq (%rsp), %rax
negl %eax
movq %rax, (%rsp)
movl $0x1, %r13d
leaq 0x10(%rsp), %rbp
movq %rbx, %r15
movslq (%r12), %rbx
movq %rbp, %rdi
leaq 0x2920(%rip), %rsi      # 0xa8b5
movl %r13d, %edx
xorl %eax, %eax
callq 0x2350
imulq $0x58, %rbx, %rax
movq %r15, %rbx
movq 0x8(%r14), %rdi
movq 0x38(%r14), %rcx
leaq (%rdi,%rax), %rdx
movl 0x18(%rdi,%rax), %esi
movl 0x1c(%rdi,%rax), %eax
leaq (%rax,%rax,2), %rdi
shlq $0x4, %rdi
addq 0x20(%r14), %rdi
movq %rbp, %r8
movq %r15, %r9
callq 0x757a
addq $-0x10, %r12
movq (%rsp), %rax
addl %r13d, %eax
incl %eax
movl %r13d, %ecx
incl %ecx
movl %ecx, %r13d
cmpl $0x1, %eax
jne 0x7f84
movq 0x8(%rsp), %rdi
callq 0x2050
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]yahs/sdict.c
// Function: write_sdict_to_agp
void write_sdict_to_agp(sdict_t *sdict, FILE *fo)
{
    int i;
    for (i = 0; i < sdict->n; ++i)
        fprintf(fo, "scaffold_%u\t1\t%u\t1\t%s\t%s\t1\t%u\t+\n", i + 1, sdict->s[i].len, 
                agp_component_type_val(DEFAULT_AGP_SEQ_COMPONENT_TYPE), sdict->s[i].name, sdict->s[i].len);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, (%rdi)
je 0x80db
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %r12d
leaq 0x2896(%rip), %r15      # 0xa8c1
leaq 0x236a(%rip), %rbp      # 0xa39c
xorl %edx, %edx
movq 0x8(%r14), %rsi
movl (%rsi,%r12), %ecx
movl 0x61de(%rip), %eax      # 0xe220
leal -0x2b609(%rax), %edi
cmpl $0x13, %edi
ja 0x8060
movslq (%rbp,%rdi,4), %rdi
addq %rbp, %rdi
jmpq *%rdi
leaq 0x290f(%rip), %r8       # 0xa96d
jmp 0x80ad
leaq 0x2904(%rip), %r8       # 0xa96b
cmpl $0x2b606, %eax          # imm = 0x2B606
je 0x80ad
jmp 0x80ea
leaq 0x2900(%rip), %r8       # 0xa977
jmp 0x80ad
leaq 0x269d(%rip), %r8       # 0xa71d
jmp 0x80ad
leaq 0x28e6(%rip), %r8       # 0xa96f
jmp 0x80ad
leaq 0x2689(%rip), %r8       # 0xa71b
jmp 0x80ad
leaq 0x28da(%rip), %r8       # 0xa975
jmp 0x80ad
leaq 0x28cf(%rip), %r8       # 0xa973
jmp 0x80ad
leaq 0x28c4(%rip), %r8       # 0xa971
leaq 0x1(%rdx), %r13
movq -0x10(%rsi,%r12), %r9
incl %edx
movl %ecx, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2200
movl (%r14), %eax
addq $0x18, %r12
movq %r13, %rdx
cmpq %rax, %r13
jb 0x8034
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2cc1(%rip), %rdi      # 0xadb2
leaq 0x2ce4(%rip), %rsi      # 0xaddc
movl %eax, %edx
xorl %eax, %eax
callq 0x8f28
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]yahs/sdict.c
// Function: write_asm_dict_to_fasta
uint64_t write_asm_dict_to_fasta(asm_dict_t *dict, int line_wd, FILE *fo)
{
    uint32_t i;
    uint64_t len = 0;
    for (i = 0; i < dict->n; ++i)
        len += write_segs_to_fasta(dict->seg + dict->s[i].s, dict->s[i].n, 
                &dict->s[i], dict->sdict, 0, line_wd, fo);
    return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, (%rdi)
je 0x8650
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
xorl %r12d, %r12d
xorl %r13d, %r13d
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq 0x38(%r14), %rcx
leaq (%rax,%r12), %rdx
movl 0x18(%rax,%r12), %esi
movl 0x1c(%rax,%r12), %eax
leaq (%rax,%rax,2), %rdi
shlq $0x4, %rdi
addq 0x20(%r14), %rdi
movq %rbx, (%rsp)
xorl %r8d, %r8d
movl %ebp, %r9d
callq 0x8101
addq %rax, %r15
incq %r13
movl (%r14), %eax
addq $0x58, %r12
cmpq %rax, %r13
jb 0x860b
jmp 0x8653
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]yahs/sdict.c
// Function: write_sequence_dictionary
uint64_t write_sequence_dictionary(FILE *fo, sdict_t *dict)
{
    uint32_t i;
    uint64_t l;
    // write number of sequences
    fwrite(&dict->n, sizeof(uint32_t), 1, fo);
    // write sequence lengths
    for (i = 0; i < dict->n; ++i)
        fwrite(&dict->s[i].len, sizeof(uint32_t), 1, fo);
    l = dict->n;
    for (i = 0; i < dict->n; ++i)
        l += strlen(dict->s[i].name);
    // write total length of sequence names
    fwrite(&l, sizeof(uint64_t), 1, fo);
    // write sequence name with a appending white space
    const unsigned char space = ' ';
    for (i = 0; i < dict->n; ++i) {
        fwrite(dict->s[i].name, 1, strlen(dict->s[i].name), fo);
        fwrite(&space, 1, 1, fo);
    }

    return sizeof(uint32_t) * (dict->n + 3) + l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x2380
cmpl $0x0, (%rbx)
je 0x86ef
movl $0x10, %r12d
xorl %r13d, %r13d
movq 0x8(%rbx), %rdi
addq %r12, %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x2380
incq %r13
movl (%rbx), %r15d
addq $0x18, %r12
cmpq %r15, %r13
jb 0x8699
testq %r15, %r15
je 0x86ef
movq 0x8(%rbx), %r12
leaq (,%r15,8), %rax
leaq (%rax,%rax,2), %r13
xorl %ebp, %ebp
movq (%r12,%rbp), %rdi
callq 0x2110
addq %rax, %r15
addq $0x18, %rbp
cmpq %rbp, %r13
jne 0x86d8
jmp 0x86f2
xorl %r15d, %r15d
movq %rsp, %rdi
movq %r15, (%rdi)
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x2380
cmpl $0x0, (%rbx)
je 0x875c
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
movq (%rax,%r12), %r15
movq %r15, %rdi
callq 0x2110
movl $0x1, %esi
movq %r15, %rdi
movq %rax, %rdx
movq %r14, %rcx
callq 0x2380
movl $0x20, %edi
movq %r14, %rsi
callq 0x21a0
incq %r13
movl (%rbx), %eax
addq $0x18, %r12
cmpq %rax, %r13
jb 0x8715
addl $0x3, %eax
shlq $0x2, %rax
jmp 0x8761
movl $0xc, %eax
addq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]yahs/sdict.c
// Function: file_seek_skip_sdict
void file_seek_skip_sdict(FILE *fp)
{
    uint32_t n;
    uint64_t l, m;
    m = fread(&n, sizeof(uint32_t), 1, fp);
    if (m != 1) bin_fread_error();
    fseek(fp, sizeof(uint32_t) * n, SEEK_CUR);
    m = fread(&l, sizeof(uint64_t), 1, fp);
    if (m != 1) bin_fread_error();
    fseek(fp, l, SEEK_CUR);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x20c0
cmpq $0x1, %rax
je 0x87a0
xorl %eax, %eax
callq 0x2d21
movl 0x4(%rsp), %esi
shlq $0x2, %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x2270
leaq 0x8(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x20c0
cmpq $0x1, %rax
je 0x87d9
xorl %eax, %eax
callq 0x2d21
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
movl $0x1, %edx
addq $0x10, %rsp
popq %rbx
jmp 0x2270
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]yahs/agp_to_fasta.c
// Function: print_help
static void print_help(FILE *fp_help)
{
    fprintf(fp_help, "Usage: agp_to_fasta [options] <scaffolds.agp> <contigs.fa>\n");
    fprintf(fp_help, "Options:\n");
    fprintf(fp_help, "    -l INT            line width [60]\n");
    fprintf(fp_help, "    -u                allow sequence components with unknown orientations\n");
    fprintf(fp_help, "    -o STR            output to file [stdout]\n");
    fprintf(fp_help, "    --version         show version number\n");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x17f9(%rip), %rdi      # 0xaf12
movl $0x3b, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2380
leaq 0x181c(%rip), %rdi      # 0xaf4e
movl $0x9, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2380
leaq 0x180d(%rip), %rdi      # 0xaf58
movl $0x26, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2380
leaq 0x181b(%rip), %rdi      # 0xaf7f
movl $0x4a, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2380
leaq 0x184d(%rip), %rdi      # 0xafca
movl $0x2e, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2380
leaq 0x1863(%rip), %rdi      # 0xaff9
movl $0x2a, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
jmp 0x2380
// File: /workspace/github_c_makefile_star2_O3/giometti[P]mastering_UNIX_programming/chapter_09/scdu_modlut.c
// Function: mod_crypt
void mod_crypt(char *text, size_t n)
{
        int i;

	for (i = 0; i < n; i++) {
                if ((text[i] >= 'a') && (text[i] <= 'z'))
                        text[i] = lut[text[i] - 'a' + 26];
                else if ((text[i] >= 'A') && (text[i] <= 'Z'))
                        text[i] = lut[text[i] - 'A'];
                else
                        continue;
        }
}

// Assembly:
testq %rsi, %rsi
je 0x105c
xorl %eax, %eax
movq 0x2fca(%rip), %rcx      # 0x3ff8
movb (%rdi,%rax), %dl
leal -0x61(%rdx), %r8d
cmpb $0x19, %r8b
ja 0x1043
addb $0x39, %dl
andb $0x3f, %dl
jmp 0x104b
addb $-0x41, %dl
cmpb $0x19, %dl
ja 0x1054
movzbl %dl, %edx
movb (%rcx,%rdx), %dl
movb %dl, (%rdi,%rax)
incq %rax
cmpq %rax, %rsi
jne 0x102e
retq
// File: /workspace/github_c_makefile_star2_O3/giometti[P]mastering_UNIX_programming/chapter_09/scdu_modlut.c
// Function: mod_decrypt
void mod_decrypt(char *text, size_t n)
{
        int i;
	char *ptr;
	int base;

        for (i = 0; i < n; i++) {
		ptr = strchr(lut, text[i]);
		if (!ptr)
			continue;

        	base = ptr - lut;
		if (base < 26)
			text[i] = base + 'A';
		else if (base >= 26)
			text[i] = base - 26 + 'a';
        }
}

// Assembly:
testq %rsi, %rsi
je 0x10c5
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movq 0x2f7b(%rip), %r15      # 0x3ff8
movl 0x2f75(%rip), %ebp      # 0x3ff8
movl $0x41, %r13d
movsbl (%r14,%r12), %esi
movq %r15, %rdi
callq 0x1010
testq %rax, %rax
je 0x10af
subl %ebp, %eax
cmpl $0x1a, %eax
movl $0x47, %ecx
cmovll %r13d, %ecx
addb %al, %cl
movb %cl, (%r14,%r12)
incq %r12
cmpq %r12, %rbx
jne 0x1089
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/preprocessor.c
// Function: SkipDelimiterTokensInLogicalLine
static struct Node *SkipDelimiterTokensInLogicalLine(struct Node *t) {
  while (t && t->token_type == kTokenDelimiter &&
         !IsEqualTokenWithCStr(t, "\n"))
    t = t->next_token;
  return t;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8965
movq %rdi, %rbx
leaq 0x2972(%rip), %r14      # 0xb2b3
cmpl $0x1, 0x108(%rbx)
jne 0x8967
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9210
testl %eax, %eax
jne 0x8967
movq 0x110(%rbx), %rbx
testq %rbx, %rbx
jne 0x8941
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/struct.c
// Function: ResolveTypesOfMembersOfStruct.cold.1
static int CalcStructSizeFromDict(struct Node *dict) {
  if (!GetSizeOfList(dict)) return 0;
  struct Node *last_kv = GetNodeAt(dict, GetSizeOfList(dict) - 1);
  struct Node *last_member = last_kv->value;
  return last_member->struct_member_ent_ofs +
         GetSizeOfType(last_member->struct_member_ent_type);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x68(%rdi), %r15
movq 0xe405(%rip), %rax      # 0x10ff8
movq (%rax), %rcx
leaq 0x99dd(%rip), %rdi      # 0xc5da
pushq $0x1d
popq %rsi
pushq $0x1
popq %rdx
callq 0x21b0
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x47d2
movq %rax, %r12
movq %r15, %rdi
callq 0x48ee
testl %eax, %eax
jle 0x2cd0
movq %r15, %rdi
movl %ebp, %esi
callq 0x4918
movq %rax, %r13
movq 0xa0(%rax), %rbx
movq 0x78(%rbx), %rsi
movq 0x10(%rsp), %rdi
callq 0xa8c7
testq %rax, %rax
je 0x2ce8
movq %rax, %r14
cmpq $0x0, 0x18(%rax)
je 0x2ce8
movq %r14, %rdi
callq 0xa0a1
movq %rax, 0x70(%rbx)
movq %r12, %rdi
callq 0x48ee
testl %eax, %eax
je 0x2c98
movq %r14, %rdi
callq 0xa2f8
movl %eax, %r14d
movq %r12, %rdi
callq 0x8b09
leal (%rax,%r14), %ecx
decl %ecx
movl %ecx, %eax
cltd
idivl %r14d
subl %edx, %ecx
jmp 0x2c9a
xorl %ecx, %ecx
movl %ecx, 0x80(%rbx)
movq %rbx, %rdi
callq 0x441a
movq 0x98(%r13), %rsi
movq 0xa0(%r13), %rdx
movq %r12, %rdi
callq 0x488d
incl %ebp
movq %r15, %rdi
callq 0x48ee
cmpl %eax, %ebp
jl 0x2c24
movq 0x8(%rsp), %rax
movq %r12, 0x68(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x97f6(%rip), %rdi      # 0xc4e5
leaq 0x97e6(%rip), %rsi      # 0xc4dc
pushq $0x4b
popq %rdx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/symbol.c
// Function: AddGlobalVar
void AddGlobalVar(struct SymbolEntry **ctx, const char *key,
                  struct Node *var_type) {
  fprintf(stderr, "Gvar: %s: ", key);
  PrintASTNode(var_type);
  fprintf(stderr, "\n");
  assert(ctx);
  struct SymbolEntry *e = AllocSymbolEntry(kSymbolGlobalVar, key, var_type);
  PushSymbol(ctx, e);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0xe2e2(%rip), %r12      # 0x10ff8
movq (%r12), %rdi
leaq 0x9952(%rip), %rsi      # 0xc673
movq %r15, %rdx
xorl %eax, %eax
callq 0x2110
movq %r14, %rdi
callq 0x441a
movq (%r12), %rsi
pushq $0xa
popq %rdi
callq 0x20d0
testq %rbx, %rbx
je 0x2d73
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x20f0
movl $0x1, (%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x98f5(%rip), %rdi      # 0xc66f
leaq 0x98e5(%rip), %rsi      # 0xc666
pushq $0x2d
popq %rdx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/symbol.c
// Function: AddExternVar
void AddExternVar(struct SymbolEntry **ctx, const char *key,
                  struct Node *var_type) {
  fprintf(stderr, "Evar: %s: ", key);
  PrintASTNode(var_type);
  fprintf(stderr, "\n");
  assert(ctx);
  struct SymbolEntry *e = AllocSymbolEntry(kSymbolExternVar, key, var_type);
  PushSymbol(ctx, e);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0xe257(%rip), %r12      # 0x10ff8
movq (%r12), %rdi
leaq 0x98d2(%rip), %rsi      # 0xc67e
movq %r15, %rdx
xorl %eax, %eax
callq 0x2110
movq %r14, %rdi
callq 0x441a
movq (%r12), %rsi
pushq $0xa
popq %rdi
callq 0x20d0
testq %rbx, %rbx
je 0x2dfe
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x20f0
movl $0x2, (%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x986a(%rip), %rdi      # 0xc66f
leaq 0x985a(%rip), %rsi      # 0xc666
pushq $0x36
popq %rdx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/type.c
// Function: CreateTypeFromInput
static struct Node *CreateTypeFromInput(const char *s) {
  fprintf(stderr, "CreateTypeFromInput: %s\n", s);
  struct Node *tokens = Tokenize(s);
  InitParser(&tokens);
  return CreateTypeFromDecl(ParseDecl());
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0xe13f(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x9fbe(%rip), %rsi      # 0xce81
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2110
movq %rbx, %rdi
callq 0x9ecd
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x7f57
callq 0x7ea2
movq %rax, %rdi
callq 0xa629
addq $0x10, %rsp
popq %rbx
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/analyzer.c
// Function: Analyze
struct SymbolEntry *Analyze(struct Node *ast) {
  // Returns root context of symbols (including global vars)
  struct SymbolEntry *root_ctx = NULL;
  in_function = NULL;
  AnalyzeNode(ast, &root_ctx);
  return root_ctx;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
xorl %eax, %eax
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq %rax, 0xe2be(%rip)      # 0x112c0
movq %rbx, %rsi
callq 0x3013
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/ast.c
// Function: CreateASTBinOp
struct Node *CreateASTBinOp(struct Node *t, struct Node *left,
                            struct Node *right) {
  if (!right) ErrorWithToken(t, "Expected expression after binary operator");
  struct Node *op = AllocNode(kASTExpr);
  op->op = t;
  op->left = left;
  op->right = right;
  return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdx, %rdx
je 0x3f61
movq %rdx, %r14
movq %rsi, %r15
movl $0x1, %edi
movl $0x138, %esi            # imm = 0x138
callq 0x20f0
movl $0x4, (%rax)
movq %rbx, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x73f0(%rip), %rsi      # 0xb358
movq %rbx, %rdi
xorl %eax, %eax
callq 0x470c
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/ast.c
// Function: CreateASTUnaryPrefixOp
struct Node *CreateASTUnaryPrefixOp(struct Node *t, struct Node *right) {
  if (!right) ErrorWithToken(t, "Expected expression after prefix operator");
  struct Node *op = AllocNode(kASTExpr);
  op->op = t;
  op->right = right;
  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x3fa6
movq %rsi, %r14
movl $0x1, %edi
movl $0x138, %esi            # imm = 0x138
callq 0x20f0
movl $0x4, (%rax)
movq %rbx, 0x10(%rax)
movq %r14, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x73d5(%rip), %rsi      # 0xb382
movq %rbx, %rdi
xorl %eax, %eax
callq 0x470c
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/ast.c
// Function: CreateASTUnaryPostfixOp
struct Node *CreateASTUnaryPostfixOp(struct Node *left, struct Node *t) {
  assert(IsToken(t));
  if (!left) ErrorWithToken(t, "Expected expression before prefix operator");
  struct Node *op = AllocNode(kASTExpr);
  op->op = t;
  op->left = left;
  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x90c4
testb %al, %al
je 0x3ff7
testq %r14, %r14
je 0x400f
movl $0x1, %edi
movl $0x138, %esi            # imm = 0x138
callq 0x20f0
movl $0x4, (%rax)
movq %rbx, 0x10(%rax)
movq %r14, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x73ae(%rip), %rdi      # 0xb3ac
leaq 0x73b2(%rip), %rsi      # 0xb3b7
movl $0x27, %edx
callq 0x46d0
leaq 0x73a7(%rip), %rsi      # 0xb3bd
movq %rbx, %rdi
xorl %eax, %eax
callq 0x470c
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/ast.c
// Function: CreateASTFuncDef
struct Node *CreateASTFuncDef(struct Node *func_decl, struct Node *func_body) {
  assert(func_decl && func_decl->type == kASTDecl);
  assert(IsASTList(func_body));
  struct Node *n = AllocNode(kASTFuncDef);
  n->func_body = func_body;
  struct Node *type = CreateTypeFromDecl(func_decl);
  assert(type);
  n->func_name_token = type->left;
  assert(IsToken(n->func_name_token));
  n->func_type = GetTypeWithoutAttr(type);
  assert(n->func_type && n->func_type->type == kTypeFunction);
  return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x40ec
movq %rdi, %r14
cmpl $0xd, (%rdi)
jne 0x40ec
movq %rsi, %r15
testq %rsi, %rsi
je 0x4104
cmpl $0x6, (%r15)
jne 0x4104
movl $0x1, %edi
movl $0x138, %esi            # imm = 0x138
callq 0x20f0
movq %rax, %rbx
movl $0x10, (%rax)
movq %r15, 0xd0(%rax)
movq %r14, %rdi
callq 0xa629
testq %rax, %rax
je 0x4134
movq %rax, %r14
movq 0x18(%rax), %rdi
movq %rdi, 0xe0(%rbx)
callq 0x90c4
testb %al, %al
je 0x414c
movq %r14, %rdi
callq 0xa0a1
movq %rax, 0xd8(%rbx)
testq %rax, %rax
je 0x411c
cmpl $0x17, (%rax)
jne 0x411c
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x72f5(%rip), %rdi      # 0xb3e8
leaq 0x72bd(%rip), %rsi      # 0xb3b7
movl $0x37, %edx
callq 0x46d0
leaq 0x7306(%rip), %rdi      # 0xb411
leaq 0x72a5(%rip), %rsi      # 0xb3b7
movl $0x38, %edx
callq 0x46d0
leaq 0x731f(%rip), %rdi      # 0xb442
leaq 0x728d(%rip), %rsi      # 0xb3b7
movl $0x40, %edx
callq 0x46d0
leaq 0x6f1b(%rip), %rdi      # 0xb056
leaq 0x7275(%rip), %rsi      # 0xb3b7
movl $0x3c, %edx
callq 0x46d0
leaq 0x72d3(%rip), %rdi      # 0xb426
leaq 0x725d(%rip), %rsi      # 0xb3b7
movl $0x3e, %edx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/ast.c
// Function: CreateTypeFunction
struct Node *CreateTypeFunction(struct Node *return_type,
                                struct Node *arg_type_list) {
  assert(IsASTList(arg_type_list));
  struct Node *n = AllocNode(kTypeFunction);
  n->left = return_type;
  n->right = arg_type_list;
  return n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x425d
movq %rsi, %rbx
cmpl $0x6, (%rsi)
jne 0x425d
movq %rdi, %r14
movl $0x1, %edi
movl $0x138, %esi            # imm = 0x138
callq 0x20f0
movl $0x17, (%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x7212(%rip), %rdi      # 0xb476
leaq 0x714c(%rip), %rsi      # 0xb3b7
movl $0x66, %edx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/ast.c
// Function: CreateTypeStruct
struct Node *CreateTypeStruct(struct Node *tag_token,
                              struct Node *struct_spec) {
  assert(IsToken(tag_token));
  struct Node *n = AllocNode(kTypeStruct);
  n->tag = tag_token;
  n->type_struct_spec = struct_spec;
  return n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x90c4
testb %al, %al
je 0x4303
movl $0x1, %edi
movl $0x138, %esi            # imm = 0x138
callq 0x20f0
movl $0x19, (%rax)
movq %r14, 0xe8(%rax)
movq %rbx, 0xf0(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x71b3(%rip), %rdi      # 0xb4bd
leaq 0x70a6(%rip), %rsi      # 0xb3b7
movl $0x79, %edx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/ast.c
// Function: CreateTypeAttrIdent
struct Node *CreateTypeAttrIdent(struct Node *ident_token, struct Node *type) {
  assert(ident_token && IsToken(ident_token));
  struct Node *n = AllocNode(kTypeAttrIdent);
  n->left = ident_token;
  n->right = type;
  return n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4358
movq %rsi, %rbx
movq %rdi, %r14
callq 0x90c4
testb %al, %al
je 0x4358
movl $0x1, %edi
movl $0x138, %esi            # imm = 0x138
callq 0x20f0
movl $0x18, (%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x7171(%rip), %rdi      # 0xb4d0
leaq 0x7051(%rip), %rsi      # 0xb3b7
movl $0x81, %edx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/ast.c
// Function: CreateASTIdent
struct Node *CreateASTIdent(struct Node *ident) {
  assert(IsToken(ident));
  struct Node *n = AllocNode(kASTIdent);
  n->op = ident;
  return n;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x90c4
testb %al, %al
je 0x4398
movl $0x1, %edi
movl $0x138, %esi            # imm = 0x138
callq 0x20f0
movl $0xa, (%rax)
movq %rbx, 0x10(%rax)
popq %rbx
retq
leaq 0x7155(%rip), %rdi      # 0xb4f4
leaq 0x7011(%rip), %rsi      # 0xb3b7
movl $0x89, %edx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/compilium.c
// Function: Error
_Noreturn void Error(const char *fmt, ...) {
  fflush(stdout);
  fprintf(stderr, "Error: ");
  va_list ap;
  va_start(ap, fmt);
  vfprintf(stderr, fmt, ap);
  va_end(ap);
  fputc('\n', stderr);
  exit(EXIT_FAILURE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
testb %al, %al
je 0x4646
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
movq 0xc96a(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
callq 0x2150
movq 0xc983(%rip), %r15      # 0x10ff8
movq (%r15), %rcx
leaq 0x6f64(%rip), %rdi      # 0xb5e3
movl $0x7, %esi
movl $0x1, %edx
callq 0x21b0
movq %rsp, %rdx
movq %r14, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x2180
movq (%r15), %rsi
movl $0xa, %edi
callq 0x20d0
movl $0x1, %edi
callq 0x21a0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/compilium.c
// Function: ErrorWithToken
_Noreturn void ErrorWithToken(struct Node *t, const char *fmt, ...) {
  PrintTokenLine(t);

  fprintf(stderr, "Error: ");
  va_list ap;
  va_start(ap, fmt);
  vfprintf(stderr, fmt, ap);
  va_end(ap);
  fputc('\n', stderr);
  exit(EXIT_FAILURE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
leaq 0x20(%rsp), %r14
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x476b
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
callq 0x46e7
movq 0xc881(%rip), %r15      # 0x10ff8
movq (%r15), %rcx
leaq 0x6e62(%rip), %rdi      # 0xb5e3
movl $0x7, %esi
movl $0x1, %edx
callq 0x21b0
movq %rsp, %rdx
movq %r14, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x2180
movq (%r15), %rsi
movl $0xa, %edi
callq 0x20d0
movl $0x1, %edi
callq 0x21a0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/compilium.c
// Function: ExpandListSizeIfNeeded
void ExpandListSizeIfNeeded(struct Node *list) {
  if (list->size < list->capacity) return;
  list->capacity = (list->capacity + 1) * 2;
  list->nodes = realloc(list->nodes, sizeof(struct Node *) * list->capacity);
  assert(list->nodes);
  assert(list->size < list->capacity);
}

// Assembly:
pushq %rbx
movl 0x84(%rdi), %eax
cmpl %eax, 0x88(%rdi)
jl 0x4828
movq %rdi, %rbx
leal 0x2(,%rax,2), %eax
movl %eax, 0x84(%rdi)
movq 0x90(%rdi), %rdi
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x2160
movq %rax, 0x90(%rbx)
testq %rax, %rax
je 0x482a
movl 0x88(%rbx), %eax
cmpl 0x84(%rbx), %eax
jge 0x4842
popq %rbx
retq
leaq 0x6def(%rip), %rdi      # 0xb620
leaq 0x6dd2(%rip), %rsi      # 0xb60a
movl $0x6e, %edx
callq 0x46d0
leaq 0x6de3(%rip), %rdi      # 0xb62c
leaq 0x6dba(%rip), %rsi      # 0xb60a
movl $0x6f, %edx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/compilium.c
// Function: GetNodeByTokenKey
struct Node *GetNodeByTokenKey(struct Node *list, struct Node *key) {
  assert(list && list->type == kASTList);
  for (int i = 0; i < list->size; i++) {
    struct Node *n = list->nodes[i];
    if (n->type != kASTKeyValue) continue;
    if (IsEqualTokenWithCStr(key, n->key)) return n->value;
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x49ea
movq %rdi, %r14
cmpl $0x6, (%rdi)
jne 0x49ea
movl 0x88(%r14), %eax
testl %eax, %eax
jle 0x49d1
movq %rsi, %rbx
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x90(%r14), %rcx
movq (%rcx,%r12,8), %r13
cmpl $0x11, (%r13)
jne 0x49c4
movq 0x98(%r13), %rsi
movq %rbx, %rdi
callq 0x9210
testl %eax, %eax
jne 0x49d6
movl 0x88(%r14), %eax
incq %r12
movslq %eax, %rcx
cmpq %rcx, %r12
jl 0x4998
jmp 0x49dd
xorl %r15d, %r15d
jmp 0x49dd
movq 0xa0(%r13), %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x6c64(%rip), %rdi      # 0xb655
leaq 0x6c12(%rip), %rsi      # 0xb60a
movl $0x8a, %edx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/compilium.c
// Function: GetNodeByKey
struct Node *GetNodeByKey(struct Node *list, const char *key) {
  assert(list && list->type == kASTList);
  for (int i = 0; i < list->size; i++) {
    struct Node *n = list->nodes[i];
    if (n->type != kASTKeyValue) continue;
    if (strcmp(n->key, key) == 0) return n->value;
  }
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4a78
cmpl $0x6, (%rdi)
jne 0x4a78
movslq 0x88(%rdi), %r15
testq %r15, %r15
jle 0x4a5a
movq %rsi, %rbx
movq 0x90(%rdi), %r12
xorl %r14d, %r14d
xorl %r13d, %r13d
movq (%r12,%r13,8), %rbp
cmpl $0x11, (%rbp)
jne 0x4a50
movq 0x98(%rbp), %rdi
movq %rbx, %rsi
callq 0x2100
testl %eax, %eax
je 0x4a5f
incq %r13
cmpq %r13, %r15
jne 0x4a33
jmp 0x4a66
xorl %r14d, %r14d
jmp 0x4a66
movq 0xa0(%rbp), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6bd6(%rip), %rdi      # 0xb655
leaq 0x6b84(%rip), %rsi      # 0xb60a
movl $0x94, %edx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/compilium.c
// Function: ReadFile
const char *ReadFile(FILE *fp) {
  int buf_size = INITIAL_INPUT_SIZE;
  char *input = malloc(buf_size);
  int input_size = 0;
  int c;
  while ((c = fgetc(fp)) != EOF) {
    input[input_size++] = c;
    if (input_size == buf_size) {
      buf_size <<= 1;
      assert((input = realloc(input, buf_size)));
    }
  }
  assert(input_size < buf_size);
  input[input_size] = 0;
  return input;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x2000, %edi           # imm = 0x2000
callq 0x2140
movq %rax, %rbx
movq %r14, %rdi
callq 0x20c0
cmpl $-0x1, %eax
je 0x4e45
movl $0x2000, %ebp           # imm = 0x2000
xorl %r15d, %r15d
movb %al, (%rbx,%r15)
incq %r15
movl %ebp, %eax
cmpq %rax, %r15
jne 0x4e1b
addl %ebp, %ebp
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0x2160
movq %rax, %rbx
testq %rax, %rax
je 0x4e5d
movq %r14, %rdi
callq 0x20c0
cmpl $-0x1, %eax
jne 0x4df8
cmpl %r15d, %ebp
jg 0x4e48
leaq 0x6a51(%rip), %rdi      # 0xb885
leaq 0x67cf(%rip), %rsi      # 0xb60a
movl $0x109, %edx            # imm = 0x109
callq 0x46d0
xorl %r15d, %r15d
movl %r15d, %eax
movb $0x0, (%rbx,%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x69fe(%rip), %rdi      # 0xb862
leaq 0x679f(%rip), %rsi      # 0xb60a
movl $0x106, %edx            # imm = 0x106
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/compilium.c
// Function: main
int main(int argc, char *argv[]) {
  struct Node *replacement_list = ParseCompilerArgs(argc, argv);
  const char *input = ReadFile(stdin);

  struct Node *tokens = Tokenize(input);

  fputs("Preprocess begin\n", stderr);
  Preprocess(&tokens, replacement_list);
  if (is_preprocess_only) {
    OutputTokenSequenceAsCSource(tokens);
    return 0;
  }

  fputs("Parse begin\n", stderr);
  struct Node *ast = Parse(&tokens);
  PrintASTNode(ast);
  fputc('\n', stderr);

  fputs("Analyze begin\n", stderr);
  struct SymbolEntry *ctx = Analyze(ast);
  PrintASTNode(ast);
  fputc('\n', stderr);

  Generate(ast, ctx);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x6, %edi
callq 0x3f11
movq %rax, (%rsp)
leaq 0x6a4a(%rip), %rax      # 0xb8e4
movq %rax, 0xc4b7(%rip)      # 0x11358
cmpl $0x2, %ebp
jl 0x4fff
movl $0x1, %r13d
movslq %r13d, %r15
movq (%rbx,%r15,8), %r12
movq %r12, %rdi
leaq 0x6a08(%rip), %rsi      # 0xb8c9
callq 0x2100
testl %eax, %eax
je 0x4f3d
movb (%r12), %r14b
cmpb $0x2d, %r14b
jne 0x4ee8
cmpb $0x49, 0x1(%r12)
jne 0x4ee8
cmpb $0x0, 0x2(%r12)
je 0x4fbe
movq %r12, %rdi
leaq 0x6a5e(%rip), %rsi      # 0xb950
callq 0x2100
testl %eax, %eax
je 0x502a
movq %r12, %rdi
leaq 0x6a5b(%rip), %rsi      # 0xb964
callq 0x2100
testl %eax, %eax
je 0x4f7f
cmpb $0x2d, %r14b
jne 0x5019
cmpb $0x45, 0x1(%r12)
jne 0x5019
cmpb $0x0, 0x2(%r12)
jne 0x5019
movb $0x1, 0xc415(%rip)      # 0x11350
jmp 0x4fb0
incl %r13d
movq 0x8(%rbx,%r15,8), %r12
movq %r12, %rdi
leaq 0x6986(%rip), %rsi      # 0xb8d5
callq 0x2100
testl %eax, %eax
je 0x4f86
movq %r12, %rdi
leaq 0x6984(%rip), %rsi      # 0xb8e6
callq 0x2100
testl %eax, %eax
jne 0x502f
leaq 0x633e(%rip), %rax      # 0xb2b4
movq %rax, 0xc3db(%rip)      # 0x11358
jmp 0x4fb0
callq 0xa8fa
jmp 0x4fb0
leaq 0x6957(%rip), %rax      # 0xb8e4
movq %rax, 0xc3c4(%rip)      # 0x11358
xorl %edi, %edi
xorl %esi, %esi
callq 0x43e5
movq (%rsp), %rdi
leaq 0x6934(%rip), %rsi      # 0xb8dc
movq %rax, %rdx
callq 0x488d
incl %r13d
cmpl %ebp, %r13d
jl 0x4eb0
jmp 0x4fff
movq 0x8(%rbx,%r15,8), %r12
movq %r12, 0xc396(%rip)      # 0x11360
testq %r12, %r12
je 0x5038
movq %r12, %rdi
callq 0x2080
cmpb $0x2f, -0x1(%r12,%rax)
jne 0x5050
incl %r13d
movq 0xc00f(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x694b(%rip), %rsi      # 0xb93e
movq %r12, %rdx
xorl %eax, %eax
callq 0x2110
jmp 0x4fb0
movq (%rsp), %rdi
callq 0x298c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6958(%rip), %rdi      # 0xb978
movq %r12, %rsi
xorl %eax, %eax
callq 0x45fc
callq 0x4a90
leaq 0x68b6(%rip), %rdi      # 0xb8ec
jmp 0x5020
leaq 0x68c0(%rip), %rdi      # 0xb8ff
leaq 0x65c4(%rip), %rsi      # 0xb60a
movl $0x2c, %edx
callq 0x46d0
leaq 0x68b5(%rip), %rdi      # 0xb90c
xorl %eax, %eax
callq 0x45fc
nop
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/generator.c
// Function: GetParamRegName
const char *GetParamRegName(struct Node *type, int idx) {
  assert(0 <= idx && idx < NUM_OF_PARAM_REGISTERS);
  int size = GetSizeOfType(type);
  if (size == 8) return param_reg_names_64[idx];
  if (size == 4) return param_reg_names_32[idx];
  if (size == 1) return param_reg_names_8[idx];
  ErrorWithToken(GetIdentifierTokenFromTypeAttr(type),
                 "Assigning %d bytes is not implemented.", size);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x6, %esi
jae 0x50a8
movl %esi, %ebx
movq %rdi, %r14
callq 0xa1c5
cmpl $0x1, %eax
je 0x5096
movl %eax, %ebp
cmpl $0x8, %eax
je 0x508d
cmpl $0x4, %ebp
jne 0x50c0
leaq 0xc1c5(%rip), %rax      # 0x11250
jmp 0x509d
leaq 0xc18c(%rip), %rax      # 0x11220
jmp 0x509d
leaq 0xc1e3(%rip), %rax      # 0x11280
movl %ebx, %ecx
movq (%rax,%rcx,8), %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6909(%rip), %rdi      # 0xb9b8
leaq 0x692b(%rip), %rsi      # 0xb9e1
movl $0xb4, %edx
callq 0x46d0
movq %r14, %rdi
callq 0xa0c1
leaq 0x691e(%rip), %rsi      # 0xb9ed
movq %rax, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x470c
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/generator.c
// Function: Generate
void Generate(struct Node *ast, struct SymbolEntry *toplevel_names) {
  label_to_break = 0;
  label_to_continue = 0;
  str_list = AllocList();
  printf(".intel_syntax noprefix\n");
  printf(".text\n");
  GenerateForNode(ast);
  GenerateDataSection(toplevel_names);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
movl %eax, 0xc274(%rip)      # 0x11368
movl %eax, 0xc272(%rip)      # 0x1136c
xorl %eax, %eax
callq 0x47d2
movq %rax, 0xc268(%rip)      # 0x11370
leaq 0x6ff6(%rip), %rdi      # 0xc105
callq 0x2060
leaq 0x7001(%rip), %rdi      # 0xc11c
callq 0x2060
movq %r14, %rdi
callq 0x51df
leaq 0x7077(%rip), %rdi      # 0xc1a6
callq 0x2060
movq 0xc235(%rip), %rdi      # 0x11370
callq 0x48ee
testl %eax, %eax
jle 0x51cb
leaq 0x6f7f(%rip), %r14      # 0xc0ce
leaq 0x6f7e(%rip), %r15      # 0xc0d4
movq 0xbe73(%rip), %r13      # 0x10fd0
xorl %ebp, %ebp
movq 0xc20a(%rip), %rdi      # 0x11370
movl %ebp, %esi
callq 0x4918
movq %rax, %r12
movl 0xac(%rax), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2090
movq %r15, %rdi
xorl %eax, %eax
callq 0x2090
movq 0x10(%r12), %rdi
movq (%r13), %rsi
callq 0x9335
movl $0xa, %edi
callq 0x2030
incl %ebp
movq 0xc1c5(%rip), %rdi      # 0x11370
callq 0x48ee
cmpl %eax, %ebp
jl 0x515f
jmp 0x51cb
cmpl $0x1, (%rbx)
je 0x51c1
movq 0x8(%rbx), %rbx
jmp 0x51cb
movq %rbx, %rdi
callq 0x2a59
jmp 0x51bb
testq %rbx, %rbx
jne 0x51b6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/generator.c
// Function: GenerateForNodeRValue
static void GenerateForNodeRValue(struct Node *node) {
  GenerateForNode(node);
  if (!node->expr_type) return;
  if (node->expr_type->type != kTypeLValue) return;
  if (node->expr_type->type == kTypeLValue &&
      node->expr_type->right->type == kTypeArray)
    return;
  int size = GetSizeOfType(GetRValueType(node->expr_type));
  if (size == 8) {
    printf("mov %s, [%s]\n", reg_names_64[node->reg], reg_names_64[node->reg]);
    return;
  } else if (size == 4) {
    printf("movsxd %s, dword ptr[%s]\n", reg_names_64[node->reg],
           reg_names_64[node->reg]);
    return;
  } else if (size == 1) {
    printf("movsx %s, byte ptr[%s]\n", reg_names_64[node->reg],
           reg_names_64[node->reg]);
    return;
  }
  ErrorWithToken(node->op, "Dereferencing %d bytes is not implemented.", size);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x51df
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x68b3
cmpl $0x15, (%rdi)
jne 0x68b3
movq 0x20(%rdi), %rax
cmpl $0x1a, (%rax)
jne 0x68b5
popq %rbx
retq
callq 0xa0d3
movq %rax, %rdi
callq 0xa1c5
cmpl $0x1, %eax
je 0x68e3
cmpl $0x8, %eax
je 0x68da
cmpl $0x4, %eax
jne 0x6904
leaq 0x5592(%rip), %rdi      # 0xbe6a
jmp 0x68ea
leaq 0x557b(%rip), %rdi      # 0xbe5c
jmp 0x68ea
leaq 0x559a(%rip), %rdi      # 0xbe84
movslq 0x4(%rbx), %rax
leaq 0xa80b(%rip), %rcx      # 0x11100
movq (%rcx,%rax,8), %rdx
movq %rdx, %rsi
xorl %eax, %eax
popq %rbx
jmp 0x2090
movq 0x10(%rbx), %rdi
leaq 0x558d(%rip), %rsi      # 0xbe9c
movl %eax, %edx
xorl %eax, %eax
callq 0x470c
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/generator.c
// Function: EmitConvertToBool
static void EmitConvertToBool(int dst, int src) {
  // This code also sets zero flag as boolean value
  printf("cmp %s, 0\n", reg_names_64[src]);
  printf("setnz %s\n", reg_names_8[src]);
  printf("movzx %s, %s\n", reg_names_64[dst], reg_names_8[src]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movslq %esi, %r14
leaq 0xa7d4(%rip), %r15      # 0x11100
movq (%r15,%r14,8), %rsi
leaq 0x5590(%rip), %rdi      # 0xbec7
xorl %eax, %eax
callq 0x2090
leaq 0xa87b(%rip), %r12      # 0x111c0
movq (%r12,%r14,8), %rsi
leaq 0x5582(%rip), %rdi      # 0xbed2
xorl %eax, %eax
callq 0x2090
movslq %ebx, %rax
movq (%r15,%rax,8), %rsi
movq (%r12,%r14,8), %rdx
leaq 0x5573(%rip), %rdi      # 0xbedc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2090
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/generator.c
// Function: EmitMoveToMemory
static void EmitMoveToMemory(struct Node *op, int dst, int src, int size) {
  if (size == 8) {
    printf("mov [%s], %s\n", reg_names_64[dst], reg_names_64[src]);
    return;
  }
  if (size == 4) {
    printf("mov [%s], %s # 4 byte store\n", reg_names_64[dst],
           reg_names_32[src]);
    return;
  }
  if (size == 1) {
    printf("mov [%s], %s\n", reg_names_64[dst], reg_names_8[src]);
    return;
  }
  ErrorWithToken(op, "Assigning %d bytes is not implemented.", size);
}

// Assembly:
movq %rdi, %rax
leaq 0x5523(%rip), %rdi      # 0xbf95
leaq 0xa687(%rip), %r8       # 0x11100
cmpl $0x1, %ecx
je 0x6a9b
movq %r8, %r9
cmpl $0x8, %ecx
je 0x6aa2
cmpl $0x4, %ecx
jne 0x6ab7
leaq 0x5511(%rip), %rdi      # 0xbfa3
leaq 0xa6c7(%rip), %r9       # 0x11160
jmp 0x6aa2
leaq 0xa71e(%rip), %r9       # 0x111c0
movslq %esi, %rax
movq (%r8,%rax,8), %rsi
movslq %edx, %rax
movq (%r9,%rax,8), %rdx
xorl %eax, %eax
jmp 0x2090
pushq %rax
leaq 0x4f2e(%rip), %rsi      # 0xb9ed
movq %rax, %rdi
movl %ecx, %edx
xorl %eax, %eax
callq 0x470c
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/generator.c
// Function: EmitAddToMemory
static void EmitAddToMemory(struct Node *op, int dst, int src, int size) {
  if (size == 8) {
    printf("add qword ptr [%s], %s\n", reg_names_64[dst], reg_names_64[src]);
    return;
  }
  if (size == 4) {
    printf("add dword ptr [%s], %s\n", reg_names_64[dst], reg_names_32[src]);
    return;
  }
  if (size == 1) {
    printf("add byte ptr [%s], %s\n", reg_names_64[dst], reg_names_8[src]);
    return;
  }
  ErrorWithToken(op, "Assigning %d bytes is not implemented.", size);
}

// Assembly:
leaq 0xa62e(%rip), %rax      # 0x11100
cmpl $0x1, %ecx
je 0x6afd
cmpl $0x8, %ecx
je 0x6af1
cmpl $0x4, %ecx
jne 0x6b20
leaq 0x54f0(%rip), %rdi      # 0xbfd8
leaq 0xa671(%rip), %rcx      # 0x11160
jmp 0x6b0b
leaq 0x54c8(%rip), %rdi      # 0xbfc0
movq %rax, %rcx
jmp 0x6b0b
leaq 0x54ec(%rip), %rdi      # 0xbff0
leaq 0xa6b5(%rip), %rcx      # 0x111c0
movslq %esi, %rsi
movq (%rax,%rsi,8), %rsi
movslq %edx, %rax
movq (%rcx,%rax,8), %rdx
xorl %eax, %eax
jmp 0x2090
pushq %rax
leaq 0x4ec5(%rip), %rsi      # 0xb9ed
movl %ecx, %edx
xorl %eax, %eax
callq 0x470c
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/generator.c
// Function: EmitSubFromMemory
static void EmitSubFromMemory(struct Node *op, int dst, int src, int size) {
  if (size == 8) {
    printf("sub qword ptr [%s], %s\n", reg_names_64[dst], reg_names_64[src]);
    return;
  }
  if (size == 4) {
    printf("sub dword ptr [%s], %s\n", reg_names_64[dst], reg_names_32[src]);
    return;
  }
  if (size == 1) {
    printf("sub byte ptr [%s], %s\n", reg_names_64[dst], reg_names_8[src]);
    return;
  }
  ErrorWithToken(op, "Assigning %d bytes is not implemented.", size);
}

// Assembly:
leaq 0xa5c8(%rip), %rax      # 0x11100
cmpl $0x1, %ecx
je 0x6b63
cmpl $0x8, %ecx
je 0x6b57
cmpl $0x4, %ecx
jne 0x6b86
leaq 0x54d1(%rip), %rdi      # 0xc01f
leaq 0xa60b(%rip), %rcx      # 0x11160
jmp 0x6b71
leaq 0x54a9(%rip), %rdi      # 0xc007
movq %rax, %rcx
jmp 0x6b71
leaq 0x54cd(%rip), %rdi      # 0xc037
leaq 0xa64f(%rip), %rcx      # 0x111c0
movslq %esi, %rsi
movq (%rax,%rsi,8), %rsi
movslq %edx, %rax
movq (%rcx,%rax,8), %rdx
xorl %eax, %eax
jmp 0x2090
pushq %rax
leaq 0x4e5f(%rip), %rsi      # 0xb9ed
movl %ecx, %edx
xorl %eax, %eax
callq 0x470c