LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/Zarh[P]regps3iso/iso.c
// Function: UTF16_to_UTF8
static void UTF16_to_UTF8(u16 *stw, u8 *stb)
{
    while(SWAP_BE(stw[0])) {
        if((SWAP_BE(stw[0]) & 0xFF80) == 0) {
            *(stb++) = SWAP_BE(stw[0]) & 0xFF;   // utf16 00000000 0xxxxxxx utf8 0xxxxxxx
        } else if((SWAP_BE(stw[0]) & 0xF800) == 0) { // utf16 00000yyy yyxxxxxx utf8 110yyyyy 10xxxxxx
            *(stb++) = ((SWAP_BE(stw[0])>>6) & 0xFF) | 0xC0; *(stb++) = (SWAP_BE(stw[0]) & 0x3F) | 0x80;
        } else if((SWAP_BE(stw[0]) & 0xFC00) == 0xD800 && (SWAP_BE(stw[1]) & 0xFC00) == 0xDC00 ) { // utf16 110110ww wwzzzzyy 110111yy yyxxxxxx (wwww = uuuuu - 1) 
                                                                             // utf8 1111000uu 10uuzzzz 10yyyyyy 10xxxxxx  
            *(stb++)= (((SWAP_BE(stw[0]) + 64)>>8) & 0x3) | 0xF0; *(stb++)= (((SWAP_BE(stw[0])>>2) + 16) & 0x3F) | 0x80; 
            *(stb++)= ((SWAP_BE(stw[0])>>4) & 0x30) | 0x80 | ((SWAP_BE(stw[1])<<2) & 0xF); *(stb++)= (SWAP_BE(stw[1]) & 0x3F) | 0x80;
            stw++;
        } else { // utf16 zzzzyyyy yyxxxxxx utf8 1110zzzz 10yyyyyy 10xxxxxx
            *(stb++)= ((SWAP_BE(stw[0])>>12) & 0xF) | 0xE0; *(stb++)= ((SWAP_BE(stw[0])>>6) & 0x3F) | 0x80; *(stb++)= (SWAP_BE(stw[0]) & 0x3F) | 0x80;
        } 
        
        stw++;
    }
    
    *stb= 0;
}

// Assembly:
leaq 0xf2e93(%rip), %rcx     # 0x4f6c20
leaq 0xf264c(%rip), %rax     # 0x4f63e0
movzwl (%rcx), %edx
testw %dx, %dx
je 0x403e88
testw $0x80ff, %dx            # imm = 0x80FF
je 0x403e2f
testb $-0x8, %dl
je 0x403e63
movl %edx, %esi
andl $0xfc, %esi
cmpw $0xd8, %si
jne 0x403e36
movzwl 0x2(%rcx), %esi
andl $0xfc, %esi
cmpw $0xdc, %si
jne 0x403e36
rolw $0x8, %dx
addl $0x40, %edx
shrl $0x8, %edx
andb $0x3, %dl
orb $-0x10, %dl
movb %dl, (%rax)
movzwl (%rcx), %edx
shrl $0xa, %edx
addb $0x10, %dl
andb $0x3f, %dl
orb $-0x80, %dl
movb %dl, 0x1(%rax)
movzwl (%rcx), %edx
movzwl 0x2(%rcx), %esi
movb 0x3(%rcx), %dil
addq $0x2, %rcx
shll $0x4, %edx
andl $0x30, %edx
shrl $0x6, %esi
andl $0xc, %esi
orl %edx, %esi
orb $-0x80, %sil
movb %sil, 0x2(%rax)
andb $0x3f, %dil
orb $-0x80, %dil
movb %dil, 0x3(%rax)
addq $0x4, %rax
jmp 0x403e7f
movb %dh, (%rax)
incq %rax
jmp 0x403e7f
shrb $0x4, %dl
orb $-0x20, %dl
movb %dl, (%rax)
movzwl (%rcx), %edx
rolw $0x8, %dx
shrl $0x6, %edx
andb $0x3f, %dl
orb $-0x80, %dl
movb %dl, 0x1(%rax)
movb 0x1(%rcx), %dl
andb $0x3f, %dl
orb $-0x80, %dl
movb %dl, 0x2(%rax)
addq $0x3, %rax
jmp 0x403e7f
rolw $0x8, %dx
shrl $0x6, %edx
orb $-0x40, %dl
movb %dl, (%rax)
movb 0x1(%rcx), %dl
andb $0x3f, %dl
orb $-0x80, %dl
movb %dl, 0x1(%rax)
addq $0x2, %rax
addq $0x2, %rcx
jmp 0x403d94
movb $0x0, (%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/eiselekd[P]MinimalLisp/l.c
// Function: main
int
main(int argc, char **argv) 
{
    ctx cctx; 
    FILE *f; char *m = 0, *lft; long l, val; int c, ad = 1, i; 
    v *cl = mkCons(0,0), *v, *n, *r;
    memset(&cctx, 0, sizeof(cctx));
    
    if (argv[1] && (f = fopen(argv[1],"r"))) {
        fseek(f, 0, SEEK_END); 
        l = ftell(f);
        fseek(f, 0, SEEK_SET); 
        m = (char *)malloc(l+1);
        fread(m, 1, l, f);
        m[l] = 0;
        fclose(f);
        printf("%s", m);
    }
    v = scan(&cctx, m);
    
    print(&cctx, stderr, v ); printf("\n");

    l_init(&cctx) ;
    
    evlist(&cctx, v, cctx.env);
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
xorl %ebx, %ebx
xorl %edi, %edi
xorl %esi, %esi
callq 0x1312
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x2764
leaq 0xabb(%rip), %rsi       # 0x31af
callq 0x1140
testq %rax, %rax
je 0x2762
movq %rax, %r14
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x1130
movq %r14, %rdi
callq 0x10c0
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1130
leaq 0x1(%r15), %rdi
callq 0x10f0
movq %rax, %rbx
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1050
movb $0x0, (%rbx,%r15)
movq %r14, %rdi
callq 0x1060
leaq 0x9b3(%rip), %rdi       # 0x3109
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1080
jmp 0x2764
xorl %ebx, %ebx
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x235b
movq %rax, %rbx
movq 0x287b(%rip), %rax      # 0x4ff8
movq (%rax), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x179f
pushq $0xa
popq %rdi
callq 0x1030
movq %r14, %rdi
callq 0x263b
movq 0x8(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1de4
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/keithnoguchi[P]pearls-in-action/0x9/main_test.c
// Function: main
int main(void)
{
	int fail = 0;
	int i = 0;

	printf("===============================\n");
	printf("Programming Pearls: Chapter 0x9\n");
	printf("===============================\n");

	if (test_find_first_10(&i))
		fail++;
	if (test_find_first_1000(&i))
		fail++;
	if (test_find_first1000(&i))
		fail++;
	if (test_find_first1023_512(&i))
		fail++;
	if (test_find_first1023_1000(&i))
		fail++;
	if (test_find_first_flat_1023(&i))
		fail++;

	return fail;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rbx
andl $0x0, (%rbx)
leaq 0xeb1(%rip), %r14       # 0x2024
movq %r14, %rdi
callq 0x1030
leaq 0xe82(%rip), %rdi       # 0x2004
callq 0x1030
movq %r14, %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1240
xorl %r14d, %r14d
testl %eax, %eax
setne %r14b
movq %rbx, %rdi
callq 0x135d
leal 0x1(%r14), %ebp
testl %eax, %eax
cmovel %r14d, %ebp
movq %rbx, %rdi
callq 0x1460
cmpl $0x1, %eax
sbbl $-0x1, %ebp
movq %rbx, %rdi
callq 0x15f0
cmpl $0x1, %eax
sbbl $-0x1, %ebp
movq %rbx, %rdi
callq 0x16fc
cmpl $0x1, %eax
sbbl $-0x1, %ebp
movq %rbx, %rdi
callq 0x186c
cmpl $0x1, %eax
sbbl $-0x1, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/keithnoguchi[P]pearls-in-action/0x9/find_first.c
// Function: find_first
int find_first(int v, const int x[], int n)
{
	int l, u;

	l = -1, u = n;
	while (l+1 != u) {
		int m = (l+u)/2;

		if (x[m] < v)
			l = m;
		else
			u = m;
	}

	if (u >= n || x[u] != v)
		return -1;
	return u;
}

// Assembly:
movl %edx, %ecx
pushq $-0x1
popq %r9
pushq $0x2
popq %r10
movl %edx, %r8d
leal 0x1(%r9), %eax
cmpl %r8d, %eax
je 0x1228
leal (%r8,%r9), %eax
cltd
idivl %r10d
cltq
cmpl %edi, (%rsi,%rax,4)
cmovll %eax, %r9d
cmovll %r8d, %eax
movl %eax, %r8d
jmp 0x1205
cmpl %ecx, %r8d
jge 0x123b
movslq %r8d, %rax
cmpl %edi, (%rsi,%rax,4)
pushq $-0x1
popq %rax
cmovel %r8d, %eax
retq
pushq $-0x1
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/keithnoguchi[P]pearls-in-action/0x9/find_first_test.c
// Function: generate_array
static void generate_array(int x[], int n, enum dup_pos p, int count)
{
	int i, value, start;

	for (i = 0; i < n; i++)
		x[i] = i;
	if (count == 1)
		goto out;

	/* create duplicate */
	switch (p) {
	case DUPLICATE_FRONT:
		value = x[0];
		start = 0;
		break;
	case DUPLICATE_MIDDLE:
		value = x[(n-1)/2];
		start = (n-count)/2;
		break;
	case DUPLICATE_BACK:
		value = x[n-1];
		start = n-count;
		break;
	}
	for (i = 0; i < count; i++)
		x[start+i] = value;
out:
	dump_array(x, n);
}

// Assembly:
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %r8d
cmovgl %esi, %r8d
cmpq %rax, %r8
je 0x1303
movl %eax, (%rdi,%rax,4)
incq %rax
jmp 0x12f6
cmpl $0x1, %ecx
jne 0x1309
retq
cmpl $0x2, %edx
je 0x1337
cmpl $0x1, %edx
je 0x131e
testl %edx, %edx
jne 0x1341
movl (%rdi), %r8d
xorl %esi, %esi
jmp 0x1341
leal -0x1(%rsi), %eax
shrl %eax
movl (%rdi,%rax,4), %r8d
subl %ecx, %esi
pushq $0x2
popq %r9
movl %esi, %eax
cltd
idivl %r9d
movl %eax, %esi
jmp 0x1341
movslq %esi, %rax
movl -0x4(%rdi,%rax,4), %r8d
subl %ecx, %esi
movslq %esi, %rdx
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
leaq (%rdi,%rdx,4), %rdx
cmpq %rax, %rcx
je 0x1308
movl %r8d, (%rdx,%rax,4)
incq %rax
jmp 0x134f
// File: /workspace/github_c_makefile_star2_O2/keithnoguchi[P]pearls-in-action/0x9/find_first1000.c
// Function: find_first1000
int find_first1000(int t, const int x[])
{
	int l, i, p;

	i = 512;
	l = -1;
	if (x[511] < t)
		l = 1000-512;
	while (i != 1) {
		i /= 2;
		if (x[l+i] < t)
			l += i;
	}
	p = l+1;
	if (p == 1000 || x[p] != t)
		p = -1;

	return p;
}

// Assembly:
xorl %ecx, %ecx
cmpl %edi, 0x7fc(%rsi)
setge %cl
negl %ecx
orl $0x1e8, %ecx            # imm = 0x1E8
movl $0x200, %eax            # imm = 0x200
pushq $0x2
popq %r8
cmpl $0x1, %eax
je 0x1446
cltd
idivl %r8d
movl %eax, %edx
addl %ecx, %edx
movslq %edx, %rdx
cmpl %edi, (%rsi,%rdx,4)
cmovgel %ecx, %edx
movl %edx, %ecx
jmp 0x142c
incl %ecx
cmpl $0x3e8, %ecx            # imm = 0x3E8
je 0x1458
movslq %ecx, %rax
cmpl %edi, (%rsi,%rax,4)
je 0x145b
pushq $-0x1
popq %rcx
movl %ecx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/keithnoguchi[P]pearls-in-action/0x9/find_first1023.c
// Function: find_first1023
int find_first1023(int t, const int x[], unsigned int nr)
{
	int l, i, p;

	assert(512 <= nr && nr < 1024);

	i = 512;
	l = -1;
	if (x[511] < t)
		l = nr-512;
	while (i != 1) {
		i /= 2;
		if (x[l+i] < t)
			l += i;
	}
	p = l+1;
	if (p >= nr || x[p] != t)
		p = -1;
	return p;
}

// Assembly:
movl %edx, %eax
andl $0xfffffe00, %eax       # imm = 0xFFFFFE00
cmpl $0x200, %eax            # imm = 0x200
jne 0x15d1
movl %edx, %r8d
leal -0x200(%r8), %ecx
cmpl %edi, 0x7fc(%rsi)
pushq $-0x1
popq %r9
cmovgel %r9d, %ecx
movl $0x200, %eax            # imm = 0x200
pushq $0x2
popq %r10
cmpl $0x1, %eax
je 0x15bd
cltd
idivl %r10d
movl %eax, %edx
addl %ecx, %edx
movslq %edx, %rdx
cmpl %edi, (%rsi,%rdx,4)
cmovgel %ecx, %edx
movl %edx, %ecx
jmp 0x15a3
incl %ecx
cmpl %r8d, %ecx
jae 0x15cb
movl %ecx, %eax
cmpl %edi, (%rsi,%rax,4)
je 0x15ce
movl %r9d, %ecx
movl %ecx, %eax
retq
pushq %rax
leaq 0xbc1(%rip), %rdi       # 0x219a
leaq 0xbd1(%rip), %rsi       # 0x21b1
leaq 0xbdb(%rip), %rcx       # 0x21c2
pushq $0xb
popq %rdx
callq 0x1050
nop
// File: /workspace/github_c_makefile_star2_O2/keithnoguchi[P]pearls-in-action/0x9/find_first1023_test.c
// Function: generate_array1023
static void generate_array1023(int x[], unsigned int nr, enum dup_pos p, int count)
{
	int i, value, start;

	for (i = 0; i < nr; i++)
		x[i] = i;

	/* create duplicate */
	switch (p) {
	case DUPLICATE_FRONT:
		value = x[0];
		start = 0;
		break;
	case DUPLICATE_MIDDLE:
		value = x[(nr-1)/2];
		start = (nr-count)/2;
		break;
	case DUPLICATE_BACK:
		value = x[nr-1];
		start = nr-count;
		break;
	}
	for (i = 0; i < count; i++)
		x[start+i] = value;

	dump_array1023(x, nr);
}

// Assembly:
movl %esi, %eax
xorl %r8d, %r8d
cmpq %r8, %rax
je 0x16b5
movl %r8d, (%rdi,%r8,4)
incq %r8
jmp 0x16a7
cmpl $0x2, %edx
je 0x16d7
cmpl $0x1, %edx
je 0x16c9
testl %edx, %edx
jne 0x16e0
movl (%rdi), %eax
xorl %esi, %esi
jmp 0x16e0
leal -0x1(%rsi), %eax
shrl %eax
movl (%rdi,%rax,4), %eax
subl %ecx, %esi
shrl %esi
jmp 0x16e0
movslq %esi, %rax
movl -0x4(%rdi,%rax,4), %eax
subl %ecx, %esi
movslq %esi, %rsi
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
leaq (%rdi,%rsi,4), %rsi
cmpq %rdx, %rcx
je 0x16fb
movl %eax, (%rsi,%rdx,4)
incq %rdx
jmp 0x16ee
retq
// File: /workspace/github_c_makefile_star2_O2/keithnoguchi[P]pearls-in-action/0x9/find_first_flat.c
// Function: find_first_flat
int find_first_flat(int t, const int x[], int nr)
{
	int l = -1;

	if (x[l+512] < t) l  = nr-512;
	if (x[l+256] < t) l += 256;
	if (x[l+128] < t) l += 128;
	if (x[l+64]  < t) l += 64;
	if (x[l+32]  < t) l += 32;
	if (x[l+16]  < t) l += 16;
	if (x[l+8]   < t) l += 8;
	if (x[l+4]   < t) l += 4;
	if (x[l+2]   < t) l += 2;
	if (x[l+1]   < t) l += 1;

	if (l+1 >= nr || x[l+1] != t)
		return -1;
	return l+1;
}

// Assembly:
cmpl %edi, 0x7fc(%rsi)
leal -0x200(%rdx), %ecx
pushq $-0x1
popq %rax
cmovgel %eax, %ecx
movslq %ecx, %r8
addl $0x100, %ecx            # imm = 0x100
cmpl %edi, 0x400(%rsi,%r8,4)
cmovll %ecx, %r8d
movslq %r8d, %rcx
subl $-0x80, %r8d
cmpl %edi, 0x200(%rsi,%rcx,4)
cmovll %r8d, %ecx
movslq %ecx, %r8
addl $0x40, %ecx
cmpl %edi, 0x100(%rsi,%r8,4)
cmovll %ecx, %r8d
movslq %r8d, %rcx
addl $0x20, %r8d
cmpl %edi, 0x80(%rsi,%rcx,4)
cmovll %r8d, %ecx
movslq %ecx, %r8
addl $0x10, %ecx
cmpl %edi, 0x40(%rsi,%r8,4)
cmovll %ecx, %r8d
movslq %r8d, %rcx
addl $0x8, %r8d
cmpl %edi, 0x20(%rsi,%rcx,4)
cmovll %r8d, %ecx
movslq %ecx, %r8
addl $0x4, %ecx
cmpl %edi, 0x10(%rsi,%r8,4)
cmovll %ecx, %r8d
movslq %r8d, %r9
addl $0x2, %r8d
cmpl %edi, 0x8(%rsi,%r9,4)
cmovll %r8d, %r9d
movslq %r9d, %rcx
incl %r9d
cmpl %edi, 0x4(%rsi,%rcx,4)
cmovll %r9d, %ecx
incl %ecx
cmpl %edx, %ecx
jge 0x186a
movslq %ecx, %rax
cmpl %edi, (%rsi,%rax,4)
pushq $-0x1
popq %rax
cmovel %ecx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/niho[P]elmc/src/elmc.c
// Function: main
int main (int argc, char **argv) {
    if (argc <= 1) {
        print_usage();
    } else if (strcmp(argv[1], "-v") == 0) {
        print_version();
    } else {
        return handle_script(&argv[1]);
    } 
    return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
cmpl $0x1, %edi
jg 0x1352
leaq 0x9cc7(%rip), %rdi      # 0xb004
leaq 0x9d73(%rip), %rsi      # 0xb0b7
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x10b0
jmp 0x13ee
movq 0x8(%rsi), %rdi
cmpb $0x2d, (%rdi)
jne 0x136d
cmpb $0x76, 0x1(%rdi)
jne 0x1367
cmpb $0x0, 0x2(%rdi)
je 0x13c8
cmpb $0x0, 0x1(%rdi)
je 0x13a8
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x2b96
movq (%rbx), %rdi
testl %eax, %eax
je 0x1394
callq 0x1eea
movq 0x8(%rsp), %rdi
callq 0x1a8c
xorl %ebx, %ebx
jmp 0x13ee
callq 0x2bfa
movq 0x8(%rsp), %rdi
callq 0x2c0a
pushq $0x1
popq %rbx
jmp 0x13ee
movq 0xfc31(%rip), %rax      # 0x10fe0
movq (%rax), %rsi
leaq 0x9d18(%rip), %rdi      # 0xb0d1
leaq 0x8(%rsp), %rbx
movq %rbx, %rdx
callq 0x2b2d
jmp 0x137a
leaq 0x9ced(%rip), %rdi      # 0xb0bc
leaq 0x9cee(%rip), %rsi      # 0xb0c4
leaq 0x9cee(%rip), %rdx      # 0xb0cb
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x10b0
pushq $0xa
popq %rdi
callq 0x1030
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/niho[P]elmc/src/east.c
// Function: elm_ast_new
elm_ast_t *elm_ast_new(int tag, elm_ast_val_t *contents) {
    elm_ast_t *node = malloc(sizeof(elm_ast_t));
    node->tag = tag;
    node->contents = contents;
    node->children_num = 0;
    node->children = NULL;
    return node;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
pushq $0x20
popq %rdi
callq 0x1170
movl %ebp, (%rax)
movq %rbx, 0x8(%rax)
andl $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/niho[P]elmc/src/east.c
// Function: elm_ast_expr
elm_ast_val_t *elm_ast_expr(int i, elm_ast_val_t **xs) {
    elm_ast_t *node = elm_ast_new(ELM_AST_EXPR, NULL);
    for (int x = 0; x < i; x++) {
        elm_ast_add_child(node, xs[x]);
    }
    return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
xorl %r15d, %r15d
pushq $0x7
popq %rdi
xorl %esi, %esi
callq 0x13f8
movq %rax, %r14
testl %ebp, %ebp
movl $0x0, %r12d
cmovgl %ebp, %r12d
cmpq %r15, %r12
je 0x1503
movq (%rbx,%r15,8), %rsi
movq %r14, %rdi
callq 0x141e
incq %r15
jmp 0x14ed
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/niho[P]elmc/src/east.c
// Function: elm_ast_list
elm_ast_val_t *elm_ast_list(int i, elm_ast_val_t **xs) {
    elm_ast_t *node = elm_ast_new(ELM_AST_LIST, NULL);
    for (int x = 0; x < i; x++) {
        elm_ast_add_child(node, xs[x]);
    }
    return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
xorl %r15d, %r15d
pushq $0x8
popq %rdi
xorl %esi, %esi
callq 0x13f8
movq %rax, %r14
testl %ebp, %ebp
movl $0x0, %r12d
cmovgl %ebp, %r12d
cmpq %r15, %r12
je 0x1559
movq (%rbx,%r15,8), %rsi
movq %r14, %rdi
callq 0x141e
incq %r15
jmp 0x1543
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/niho[P]elmc/src/east.c
// Function: elm_ast_list_cons
elm_ast_val_t *elm_ast_list_cons(int i, elm_ast_val_t **xs) {
    elm_ast_t *node = elm_ast_new(ELM_AST_LIST, NULL);
    for (int x = 0; x < i; x++) {
        elm_ast_t *nx = (elm_ast_t *)xs[x];
        if (nx->tag == ELM_AST_LIST) {
            for (int y = 0; y < nx->children_num; y++) {
                elm_ast_add_child(node, nx->children[y]);
            }
            elm_ast_delete_no_children(nx);
        } else {
            elm_ast_add_child(node, xs[x]);
        }
    }
    return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
xorl %r13d, %r13d
pushq $0x8
popq %rdi
xorl %esi, %esi
callq 0x13f8
movq %rax, %r15
testl %r14d, %r14d
cmovlel %r13d, %r14d
cmpq %r14, %r13
je 0x15d9
movq (%rbx,%r13,8), %r12
cmpl $0x8, (%r12)
jne 0x15c9
xorl %ebp, %ebp
movslq 0x10(%r12), %rax
cmpq %rax, %rbp
jge 0x15bf
movq 0x18(%r12), %rax
movq (%rax,%rbp,8), %rsi
movq %r15, %rdi
callq 0x141e
incq %rbp
jmp 0x159f
movq %r12, %rdi
callq 0x15eb
jmp 0x15d4
movq %r15, %rdi
movq %r12, %rsi
callq 0x141e
incq %r13
jmp 0x158d
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_O2/niho[P]elmc/src/east.c
// Function: elm_ast_tuple
elm_ast_val_t *elm_ast_tuple(int i, elm_ast_val_t **xs) {
    elm_ast_t *node = elm_ast_new(ELM_AST_TUPLE, NULL);
    for (int x = 0; x < i; x++) {
        elm_ast_add_child(node, xs[x]);
    }
    return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
xorl %r15d, %r15d
pushq $0x9
popq %rdi
xorl %esi, %esi
callq 0x13f8
movq %rax, %r14
testl %ebp, %ebp
movl $0x0, %r12d
cmovgl %ebp, %r12d
cmpq %r15, %r12
je 0x1649
movq (%rbx,%r15,8), %rsi
movq %r14, %rdi
callq 0x141e
incq %r15
jmp 0x1633
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/niho[P]elmc/src/east.c
// Function: elm_ast_tuple_cons
elm_ast_val_t *elm_ast_tuple_cons(int i, elm_ast_val_t **xs) {
    elm_ast_t *node = elm_ast_new(ELM_AST_TUPLE, NULL);
    for (int x = 0; x < i; x++) {
        elm_ast_t *nx = (elm_ast_t *)xs[x];
        if (nx->tag == ELM_AST_TUPLE) {
            for (int y = 0; y < nx->children_num; y++) {
                elm_ast_add_child(node, nx->children[y]);
            }
            elm_ast_delete_no_children(nx);
        } else {
            elm_ast_add_child(node, xs[x]);
        }
    }
    return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
xorl %r13d, %r13d
pushq $0x9
popq %rdi
xorl %esi, %esi
callq 0x13f8
movq %rax, %r15
testl %r14d, %r14d
cmovlel %r13d, %r14d
cmpq %r14, %r13
je 0x16c9
movq (%rbx,%r13,8), %r12
cmpl $0x9, (%r12)
jne 0x16b9
xorl %ebp, %ebp
movslq 0x10(%r12), %rax
cmpq %rax, %rbp
jge 0x16af
movq 0x18(%r12), %rax
movq (%rax,%rbp,8), %rsi
movq %r15, %rdi
callq 0x141e
incq %rbp
jmp 0x168f
movq %r12, %rdi
callq 0x15eb
jmp 0x16c4
movq %r15, %rdi
movq %r12, %rsi
callq 0x141e
incq %r13
jmp 0x167d
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_O2/niho[P]elmc/src/east.c
// Function: elm_ast_if
elm_ast_val_t *elm_ast_if(int i, elm_ast_val_t **xs) {
    assert(i == 6);
    elm_ast_t *node = elm_ast_new(ELM_AST_IF, NULL);
    elm_ast_add_child(node, xs[1]);
    elm_ast_add_child(node, xs[3]);
    elm_ast_add_child(node, xs[5]);
    free(xs[0]);
    free(xs[2]);
    free(xs[4]);
    return node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x6, %edi
jne 0x173d
movq %rsi, %rbx
pushq $0xa
popq %rdi
xorl %esi, %esi
callq 0x13f8
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x141e
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x141e
movq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x141e
movq (%rbx), %rdi
callq 0x1230
movq 0x10(%rbx), %rdi
callq 0x1230
movq 0x20(%rbx), %rdi
callq 0x1230
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x99e1(%rip), %rdi      # 0xb125
leaq 0x99e1(%rip), %rsi      # 0xb12c
leaq 0x99e1(%rip), %rcx      # 0xb133
pushq $0x7c
popq %rdx
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O2/niho[P]elmc/src/east.c
// Function: elm_ast_case
elm_ast_val_t *elm_ast_case(int i, elm_ast_val_t **xs) {
    assert(i == 4);
    //assert(((elm_ast_t *)(xs[1]))->tag == ELM_AST_EXPR);
    assert(((elm_ast_t *)(xs[3]))->tag == ELM_AST_CASE);
    
    elm_ast_t *node = elm_ast_new(ELM_AST_CASE, NULL);
    elm_ast_add_child(node, xs[1]);
    
    elm_ast_t *branches = (elm_ast_t *)xs[3];
    for (int x = 0; x < branches->children_num; x++) {
        elm_ast_add_child(node, branches->children[x]);
    } 
    
    free(xs[0]);
    free(xs[2]);
    elm_ast_delete_no_children(xs[3]);
    
    return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x4, %edi
jne 0x17e0
movq %rsi, %rbx
movq 0x18(%rsi), %rax
cmpl $0xb, (%rax)
jne 0x17ff
xorl %r15d, %r15d
pushq $0xb
popq %rdi
xorl %esi, %esi
callq 0x13f8
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x141e
movq 0x18(%rbx), %r12
movslq 0x10(%r12), %rax
cmpq %rax, %r15
jge 0x17b7
movq 0x18(%r12), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x141e
incq %r15
jmp 0x1797
movq (%rbx), %rdi
callq 0x1230
movq 0x10(%rbx), %rdi
callq 0x1230
movq 0x18(%rbx), %rdi
callq 0x15eb
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x997d(%rip), %rdi      # 0xb164
leaq 0x993e(%rip), %rsi      # 0xb12c
leaq 0x9976(%rip), %rcx      # 0xb16b
movl $0x88, %edx
callq 0x10c0
leaq 0x9998(%rip), %rdi      # 0xb19e
leaq 0x991f(%rip), %rsi      # 0xb12c
leaq 0x9957(%rip), %rcx      # 0xb16b
movl $0x8a, %edx
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O2/niho[P]elmc/src/east.c
// Function: elm_ast_branches
elm_ast_val_t *elm_ast_branches(int i, elm_ast_val_t **xs) {
    elm_ast_t *node = elm_ast_new(ELM_AST_CASE, NULL);
    for (int x = 0; x < i; x++) {
        elm_ast_add_child(node, xs[x]);
    }
    return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
xorl %r15d, %r15d
pushq $0xb
popq %rdi
xorl %esi, %esi
callq 0x13f8
movq %rax, %r14
testl %ebp, %ebp
movl $0x0, %r12d
cmovgl %ebp, %r12d
cmpq %r15, %r12
je 0x185d
movq (%rbx,%r15,8), %rsi
movq %r14, %rdi
callq 0x141e
incq %r15
jmp 0x1847
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/niho[P]elmc/src/east.c
// Function: elm_ast_branch
elm_ast_val_t *elm_ast_branch(int i, elm_ast_val_t **xs) {
    assert(i == 3);
    assert(((elm_ast_t *)(xs[i - 1]))->tag == ELM_AST_EXPR);

    elm_ast_t *node = elm_ast_new(ELM_AST_BRANCH, NULL);
    elm_ast_add_child(node, xs[0]);
    elm_ast_add_child(node, xs[2]);

    free(xs[1]);
    
    return node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x3, %edi
jne 0x18b6
movq %rsi, %rbx
movq 0x10(%rsi), %rax
cmpl $0x7, (%rax)
jne 0x18d5
pushq $0xc
popq %rdi
xorl %esi, %esi
callq 0x13f8
movq %rax, %r14
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x141e
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x141e
movq 0x8(%rbx), %rdi
callq 0x1230
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x990d(%rip), %rdi      # 0xb1ca
leaq 0x9868(%rip), %rsi      # 0xb12c
leaq 0x9906(%rip), %rcx      # 0xb1d1
movl $0xa4, %edx
callq 0x10c0
leaq 0x992a(%rip), %rdi      # 0xb206
leaq 0x9849(%rip), %rsi      # 0xb12c
leaq 0x98e7(%rip), %rcx      # 0xb1d1
movl $0xa5, %edx
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O2/niho[P]elmc/src/east.c
// Function: elm_ast_decl
elm_ast_val_t *elm_ast_decl(int i, elm_ast_val_t **xs) {
    assert(i == 3);
    assert(((elm_ast_t *)(xs[0]))->tag == ELM_AST_FUNC);
    assert(((elm_ast_t *)(xs[2]))->tag == ELM_AST_EXPR);

    elm_ast_t *node = elm_ast_new(ELM_AST_DECL, NULL);
    elm_ast_add_child(node, xs[0]);
    elm_ast_add_child(node, xs[2]);

    free(xs[1]);

    return node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x3, %edi
jne 0x1970
movq %rsi, %rbx
movq (%rsi), %rax
cmpl $0xf, (%rax)
jne 0x198f
movq 0x10(%rbx), %rax
cmpl $0x7, (%rax)
jne 0x19ae
pushq $0xe
popq %rdi
xorl %esi, %esi
callq 0x13f8
movq %rax, %r14
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x141e
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x141e
movq 0x8(%rbx), %rdi
callq 0x1230
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x9853(%rip), %rdi      # 0xb1ca
leaq 0x97ae(%rip), %rsi      # 0xb12c
leaq 0x98b1(%rip), %rcx      # 0xb236
movl $0xb7, %edx
callq 0x10c0
leaq 0x98d3(%rip), %rdi      # 0xb269
leaq 0x978f(%rip), %rsi      # 0xb12c
leaq 0x9892(%rip), %rcx      # 0xb236
movl $0xb8, %edx
callq 0x10c0
leaq 0x98e0(%rip), %rdi      # 0xb295
leaq 0x9770(%rip), %rsi      # 0xb12c
leaq 0x9873(%rip), %rcx      # 0xb236
movl $0xb9, %edx
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O2/niho[P]elmc/src/east.c
// Function: elm_ast_func
elm_ast_val_t *elm_ast_func(int i, elm_ast_val_t **xs) {
    elm_ast_t *node = elm_ast_new(ELM_AST_FUNC, NULL);

    assert(((elm_ast_t *)(xs[0]))->tag == ELM_AST_VAR);
    assert(((elm_ast_t *)(xs[0]))->contents != NULL);

    node->contents = malloc(sizeof(char) * strlen(((elm_ast_t *)(xs[0]))->contents));
    strcpy(node->contents, ((elm_ast_t *)(xs[0]))->contents);
    elm_ast_delete(xs[0]);

    if (i > 1) {
        for (int x = 1; x < i; x++) {
            elm_ast_add_child(node, xs[x]);
        }
    }

    return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
pushq $0xf
popq %rdi
xorl %esi, %esi
callq 0x13f8
movq (%rbx), %r15
cmpl $0x6, (%r15)
jne 0x1a4e
movq 0x8(%r15), %r12
testq %r12, %r12
je 0x1a6d
movq %rax, %r14
movq %r12, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1170
movq %rax, 0x8(%r14)
movq %rax, %rdi
movq %r12, %rsi
callq 0x1050
movq %r15, %rdi
callq 0x1a8c
cmpl $0x2, %ebp
jl 0x1a42
movl %ebp, %r15d
pushq $0x1
popq %r12
cmpq %r12, %r15
je 0x1a42
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
callq 0x141e
incq %r12
jmp 0x1a2c
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x986c(%rip), %rdi      # 0xb2c1
leaq 0x96d0(%rip), %rsi      # 0xb12c
leaq 0x9889(%rip), %rcx      # 0xb2ec
movl $0xc7, %edx
callq 0x10c0
leaq 0x98ab(%rip), %rdi      # 0xb31f
leaq 0x96b1(%rip), %rsi      # 0xb12c
leaq 0x986a(%rip), %rcx      # 0xb2ec
movl $0xc8, %edx
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O2/niho[P]elmc/src/east.c
// Function: elm_ast_delete
void elm_ast_delete(elm_ast_t *a) {
    if (a == NULL) { return; }

    for (int i = 0; i < a->children_num; i++) {
        elm_ast_delete(a->children[i]);
    }

    free(a->children);
    free(a->contents);
    free(a);
}

// Assembly:
testq %rdi, %rdi
je 0x1ad3
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movslq 0x10(%rbx), %rax
movq 0x18(%rbx), %rdi
cmpq %rax, %r14
jge 0x1ab6
movq (%rdi,%r14,8), %rdi
callq 0x1a8c
incq %r14
jmp 0x1a9b
callq 0x1230
movq 0x8(%rbx), %rdi
callq 0x1230
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1230
retq
// File: /workspace/github_c_makefile_star2_O2/niho[P]elmc/src/east.c
// Function: elm_ast_module
elm_ast_val_t *elm_ast_module(int i, elm_ast_val_t **xs) {
    elm_ast_t *node = elm_ast_new(ELM_AST_MODULE, NULL);
    for (int x = 0; x < i; x++) {
        elm_ast_add_child(node, xs[x]);
    }
    return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
xorl %r15d, %r15d
pushq $0x10
popq %rdi
xorl %esi, %esi
callq 0x13f8
movq %rax, %r14
testl %ebp, %ebp
movl $0x0, %r12d
cmovgl %ebp, %r12d
cmpq %r15, %r12
je 0x1b13
movq (%rbx,%r15,8), %rsi
movq %r14, %rdi
callq 0x141e
incq %r15
jmp 0x1afd
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/niho[P]elmc/src/east.c
// Function: elm_ast_traverse_start
elm_ast_trav_t *elm_ast_traverse_start(elm_ast_t *ast, elm_ast_trav_order_t order) {
    elm_ast_trav_t *trav;
    trav = malloc(sizeof(elm_ast_trav_t));
    trav->curr_node = ast;
    trav->parent = NULL;
    trav->curr_child = 0;
    trav->order = order;
    return trav;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
pushq $0x18
popq %rdi
callq 0x1170
movq %r14, (%rax)
andq $0x0, 0x8(%rax)
andl $0x0, 0x10(%rax)
movl %ebx, 0x14(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/niho[P]elmc/src/east.c
// Function: elm_ast_traverse_next
elm_ast_t *elm_ast_traverse_next(elm_ast_trav_t **trav) {
    elm_ast_trav_t *n_trav, *to_free;
    elm_ast_t *ret = NULL;
    int cchild;

    if(*trav == NULL) return NULL;

    switch((*trav)->order) {
        case ELM_AST_TRAV_ORDER_PRE:
            ret = (*trav)->curr_node;
            
            while(*trav != NULL &&
                    (*trav)->curr_child >= (*trav)->curr_node->children_num)
            {
                to_free = *trav;
                *trav = (*trav)->parent;
                free(to_free);
            }
            
            if(*trav == NULL) {
                break;
            }

            n_trav = malloc(sizeof(elm_ast_trav_t));

            cchild = (*trav)->curr_child;
            n_trav->curr_node = (*trav)->curr_node->children[cchild];
            n_trav->parent = *trav;
            n_trav->curr_child = 0;
            n_trav->order = (*trav)->order;

            (*trav)->curr_child++;
            *trav = n_trav;

            break;
        case ELM_AST_TRAV_ORDER_POST:
            break;
    }

    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x1f39
cmpl $0x0, 0x14(%r15)
je 0x1f48
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rdi, %r14
movq (%r15), %rbx
testq %r15, %r15
je 0x1f3b
movslq 0x10(%r15), %r12
movq (%r15), %r13
cmpl 0x10(%r13), %r12d
jl 0x1f74
movq 0x8(%r15), %rax
movq %rax, (%r14)
movq %r15, %rdi
callq 0x1230
movq (%r14), %r15
jmp 0x1f4e
pushq $0x18
popq %rdi
callq 0x1170
movq 0x18(%r13), %rcx
movq (%rcx,%r12,8), %rcx
movq %rcx, (%rax)
movq %r15, 0x8(%rax)
andl $0x0, 0x10(%rax)
movl 0x14(%r15), %ecx
movl %ecx, 0x14(%rax)
leal 0x1(%r12), %ecx
movl %ecx, 0x10(%r15)
movq %rax, (%r14)
jmp 0x1f3b
// File: /workspace/github_c_makefile_star2_O2/niho[P]elmc/src/east.c
// Function: elm_ast_traverse_free
void elm_ast_traverse_free(elm_ast_trav_t **trav) {
    elm_ast_trav_t *n_trav;

    while(*trav != NULL) {
        n_trav = (*trav)->parent;
        free(*trav);
        *trav = n_trav;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1fc4
movq 0x8(%rdi), %r14
callq 0x1230
movq %r14, (%rbx)
movq %r14, %rdi
jmp 0x1fae
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/niho[P]elmc/src/eparse.c
// Function: elm_parse
int elm_parse(const char *filename, const char *string, elm_result_t *r) {
    elm_parser_t *p = elm_parser_init();
    mpc_result_t result;
    if (mpc_parse(filename, string, p->Module, &result)) {
        r->output = (elm_ast_t *)result.output;
        elm_parser_cleanup(p);
        return 1;
    } else {
        r->error = elm_error(result.error);  
        elm_parser_cleanup(p);
        return 0;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
callq 0x2035
movq %rax, %r14
movq 0x80(%rax), %rdx
movq %rsp, %r13
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rcx
callq 0x3f6e
movl %eax, %ecx
movq (%r13), %rax
testl %ecx, %ecx
je 0x200f
pushq $0x1
popq %rbp
jmp 0x2019
movq %rax, %rdi
callq 0x2ab3
xorl %ebp, %ebp
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x2a14
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/niho[P]elmc/src/eparse.c
// Function: elm_parse_file
int elm_parse_file(const char *filename, FILE *file, elm_result_t *r) {
    elm_parser_t *p = elm_parser_init();
    mpc_result_t result;
    if (mpc_parse_file(filename, file, p->Module, &result)) {
        r->output = (elm_ast_t *)result.output;
        elm_parser_cleanup(p);
        return 1;
    } else {
        r->error = elm_error(result.error);  
        elm_parser_cleanup(p);
        return 0;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
callq 0x2035
movq %rax, %r14
movq 0x80(%rax), %rdx
movq %rsp, %r13
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rcx
callq 0x418c
movl %eax, %ecx
movq (%r13), %rax
testl %ecx, %ecx
je 0x2b07
pushq $0x1
popq %rbp
jmp 0x2b11
movq %rax, %rdi
callq 0x2ab3
xorl %ebp, %ebp
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x2a14
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/niho[P]elmc/src/eparse.c
// Function: elm_parse_pipe
int elm_parse_pipe(const char *filename, FILE *pipe, elm_result_t *r) {
    elm_parser_t *p = elm_parser_init();
    mpc_result_t result;
    if (mpc_parse_pipe(filename, pipe, p->Module, &result)) {
        r->output = (elm_ast_t *)result.output;
        elm_parser_cleanup(p);
        return 1;
    } else {
        r->error = elm_error(result.error);  
        elm_parser_cleanup(p);
        return 0;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
callq 0x2035
movq %rax, %r14
movq 0x80(%rax), %rdx
movq %rsp, %r13
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rcx
callq 0x4252
movl %eax, %ecx
movq (%r13), %rax
testl %ecx, %ecx
je 0x2b70
pushq $0x1
popq %rbp
jmp 0x2b7a
movq %rax, %rdi
callq 0x2ab3
xorl %ebp, %ebp
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x2a14
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/niho[P]elmc/src/eparse.c
// Function: elm_parse_contents
int elm_parse_contents(const char *filename, elm_result_t *r) {
    elm_parser_t *p = elm_parser_init();
    mpc_result_t result;
    if (mpc_parse_contents(filename, p->Module, &result)) {
        r->output = (elm_ast_t *)result.output;
        elm_parser_cleanup(p);
        return 1;
    } else {
        r->error = elm_error(result.error);
        elm_parser_cleanup(p);
        return 0;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
callq 0x2035
movq %rax, %r14
movq 0x80(%rax), %rsi
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x4318
movl %eax, %ecx
movq (%r12), %rax
testl %ecx, %ecx
je 0x2bd6
pushq $0x1
popq %rbp
jmp 0x2be0
movq %rax, %rdi
callq 0x2ab3
xorl %ebp, %ebp
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x2a14
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/niho[P]elmc/src/eparse.c
// Function: is_unreserved
static int is_unreserved(mpc_val_t **xs) {
    if (strcmp(xs[0], "if") == 0)
        return 0;
    if (strcmp(xs[0], "then") == 0)
        return 0;
    if (strcmp(xs[0], "else") == 0)
        return 0;
    if (strcmp(xs[0], "case") == 0)
        return 0;
    if (strcmp(xs[0], "of") == 0)
        return 0;
    if (strcmp(xs[0], "->") == 0)
        return 0;
    if (strcmp(xs[0], "_") == 0)
        return 0;
    if (strcmp(xs[0], "=") == 0)
        return 0;
    return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rbx
movzbl (%rbx), %ebp
cmpl $0x69, %ebp
jne 0x2c45
cmpb $0x66, 0x1(%rbx)
jne 0x2c45
cmpb $0x0, 0x2(%rbx)
je 0x2ca0
leaq 0x88d0(%rip), %rsi      # 0xb51c
movq %rbx, %rdi
callq 0x1120
testl %eax, %eax
je 0x2ca0
leaq 0x88c2(%rip), %rsi      # 0xb521
movq %rbx, %rdi
callq 0x1120
testl %eax, %eax
je 0x2ca0
leaq 0x8828(%rip), %rsi      # 0xb49a
movq %rbx, %rdi
callq 0x1120
testl %eax, %eax
je 0x2ca0
movb $0x1, %al
cmpl $0x2d, %ebp
je 0x2cb5
cmpl $0x3d, %ebp
je 0x2cac
cmpl $0x5f, %ebp
je 0x2cac
cmpl $0x6f, %ebp
jne 0x2ca2
cmpb $0x66, 0x1(%rbx)
jne 0x2ca2
cmpb $0x0, 0x2(%rbx)
jne 0x2ca2
xorl %eax, %eax
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpb $0x0, 0x1(%rbx)
setne %al
jmp 0x2ca2
cmpb $0x3e, 0x1(%rbx)
jne 0x2ca2
cmpb $0x0, 0x2(%rbx)
jmp 0x2cb0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/TeaInside[P]teavpn/src/teavpn/main.c
// Function: main
int main(int argc, char **_argv, char **envp)
{
	uint8_t exit_code;
	teavpn_config config;

	argv = _argv;

	if (!argv_parser(&config, argc, _argv, envp)) {
		exit_code = 1;
		goto ret;
	}

	switch (config.type) {
		case teavpn_server_config:
			exit_code = teavpn_tcp_server(&(config.config.server));
			break;
		case teavpn_client_config:
			exit_code = teavpn_tcp_client(&(config.config.client));
			break;
		default:
			printf("Invalid config type\n");
			exit_code = 1;
			break;
	}

	ret:
	return exit_code;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movl %edi, %esi
movq %fs:0x28, %rax
movq %rax, -0x10(%rbp)
movq %rdx, 0x8d17(%rip)      # 0xb258
leaq -0x58(%rbp), %rdi
callq 0x2ea4
movb $0x1, %bl
testb %al, %al
je 0x2580
movl -0x18(%rbp), %eax
cmpl $0x1, %eax
je 0x2567
testl %eax, %eax
jne 0x2574
leaq -0x58(%rbp), %rdi
callq 0x3ffc
jmp 0x2570
leaq -0x58(%rbp), %rdi
callq 0x34a0
movl %eax, %ebx
jmp 0x2580
leaq 0x4a89(%rip), %rdi      # 0x7004
callq 0x2090
movq %fs:0x28, %rax
cmpq -0x10(%rbp), %rax
jne 0x2599
movzbl %bl, %eax
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
callq 0x2110
nop
// File: /workspace/github_c_makefile_star2_O2/TeaInside[P]teavpn/src/teavpn/helpers.c
// Function: ip_read_conv
uint32_t ip_read_conv(const char *read)
{
	uint32_t ret = 0;
	uint8_t bufptr = 0, i = 0;
	char buf[4] = "\0\0\0";

	while (((*read) != '\0') && ((*read) != '/')) {
		buf[bufptr] = *read;
		read++;
		bufptr++;
		if ((bufptr == 3) || ((*read) == '.')) {
			bufptr = 0;
			ret |= atoi(buf) << i;
			i += 8;
			read++; // skip dot
		}
	}

	if (i < 32) {
		ret |= atoi(buf) << i;
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
leaq -0x2c(%rbp), %r15
andl $0x0, (%r15)
movq %rdi, %r12
xorl %ebx, %ebx
xorl %r14d, %r14d
addq $0x2, %r12
xorl %eax, %eax
movq %r12, %rcx
movq %rcx, %r12
movzbl -0x2(%rcx), %ecx
testl %ecx, %ecx
je 0x266e
cmpl $0x2f, %ecx
je 0x266e
movb %cl, -0x2c(%rbp,%rax)
cmpb $0x2, %al
je 0x2659
leaq 0x1(%r12), %rcx
incq %rax
cmpb $0x2e, -0x1(%r12)
jne 0x2631
movq %r15, %rdi
callq 0x2380
movl %r14d, %ecx
shll %cl, %eax
orl %eax, %ebx
addb $0x8, %r14b
jmp 0x2628
cmpb $0x1f, %r14b
ja 0x2684
leaq -0x2c(%rbp), %rdi
callq 0x2380
movl %r14d, %ecx
shll %cl, %eax
orl %eax, %ebx
movq %fs:0x28, %rax
cmpq -0x28(%rbp), %rax
jne 0x26a2
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x2110
nop
// File: /workspace/github_c_makefile_star2_O2/TeaInside[P]teavpn/src/teavpn/cli_arg.c
// Function: show_help_command
static void show_help_command(char *appname)
{
	printf("Usage: %s [command] [options]\n\n", appname);
	printf("Available commands:\n");
	printf("\tserver\t\tMake TeaVPN server.\n");
	printf("\tconnect\t\tConnect to TeaVPN server.\n");
	printf("\nDetailed information: %s [command] --help\n", appname);
	fflush(stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3e53(%rip), %rdi      # 0x729e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2150
leaq 0x3e8e(%rip), %rdi      # 0x72ea
callq 0x2090
leaq 0x3e96(%rip), %rdi      # 0x72fe
callq 0x2090
leaq 0x3ea7(%rip), %rdi      # 0x731b
callq 0x2090
leaq 0x3e3e(%rip), %rdi      # 0x72be
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2150
movq 0x7b3f(%rip), %rax      # 0xafd0
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x22d0
nop
// File: /workspace/github_c_makefile_star2_O2/TeaInside[P]teavpn/src/teavpn/server/tcp.c
// Function: connection_zero
static void connection_zero(register uint16_t i)
{
	connections[i].fd = -1;
	connections[i].connected = false;
	connections[i].error = 0;
	connections[i].seq = 0;
	connections[i].priv_ip = 0;
	memset(&(connections[i].addr), 0, sizeof(connections[i].addr));
	memset(&(connections[i].mutex), 0, sizeof(connections[i].mutex));
	pthread_mutex_init(&(connections[i].mutex), NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x5aa8(%rip), %rax      # 0xb378
movl %edi, %ecx
imulq $0x50, %rcx, %rcx
leaq (%rax,%rcx), %rdi
addq $0x18, %rdi
orl $-0x1, -0x18(%rdi)
andw $0x0, -0x14(%rdi)
andq $0x0, -0x10(%rdi)
andl $0x0, -0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x30(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
xorl %esi, %esi
popq %rbp
jmp 0x23d0
// File: /workspace/github_c_makefile_star2_O2/TeaInside[P]teavpn/src/teavpn/server/tcp.c
// Function: get_bufchan_index
static int16_t get_bufchan_index()
{
	static bool sleep_state = false;
	static uint8_t buf_chan_wait = 0;

	for (int16_t i = 0; i < BUFCHAN_ALLOC; i++) {
		if (bufchan[i].ref_count == 0) {
			if (buf_chan_wait > 0) buf_chan_wait--;
			return i;
		}
	}

	if (buf_chan_wait > 30) {
		sleep_state = true;
	} else {
		if (buf_chan_wait <= 100) buf_chan_wait++;
	}

	if (sleep_state) {
		debug_log(1, "Buffer channel got sleep state...\n");
		usleep(10000);
		buf_chan_wait--;
		if (buf_chan_wait <= 20) {
			debug_log(1, "Sleep state has been released\n");
			sleep_state = false;
		}
	}

	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x5a57(%rip), %rax      # 0xb370
xorl %ebx, %ebx
cmpq $0x18, %rbx
je 0x5932
cmpw $0x0, (%rax)
je 0x5945
incq %rbx
addq $0x1030, %rax           # imm = 0x1030
jmp 0x591b
movb 0x5aeb(%rip), %al       # 0xb423
cmpb $0x1f, %al
jb 0x5959
movb $0x1, 0x5adf(%rip)      # 0xb422
jmp 0x596e
movb 0x5ad8(%rip), %al       # 0xb423
testb %al, %al
je 0x59c4
decb %al
movb %al, 0x5acc(%rip)       # 0xb423
jmp 0x59c4
incb %al
movb %al, 0x5ac2(%rip)       # 0xb423
movw $0xffff, %bx            # imm = 0xFFFF
cmpb $0x1, 0x5ab6(%rip)      # 0xb422
jne 0x59c4
leaq 0x5aaf(%rip), %r14      # 0xb424
cmpb $0x0, (%r14)
je 0x5989
leaq 0x2976(%rip), %rdi      # 0x82f8
xorl %eax, %eax
callq 0x5aec
movl $0x2710, %edi           # imm = 0x2710
callq 0x2400
movb 0x5a8a(%rip), %al       # 0xb423
decb %al
movb %al, 0x5a82(%rip)       # 0xb423
movw $0xffff, %bx            # imm = 0xFFFF
cmpb $0x14, %al
ja 0x59c4
cmpb $0x0, (%r14)
je 0x59bd
leaq 0x2965(%rip), %rdi      # 0x831b
xorl %eax, %eax
callq 0x5aec
movb $0x0, 0x5a5e(%rip)      # 0xb422
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/TeaInside[P]teavpn/src/teavpn/server/auth.c
// Function: teavpn_auth_check
FILE *teavpn_auth_check(server_config *config, struct teavpn_packet_auth *auth)
{
	size_t len;
	FILE *h1 = NULL, *h2 = NULL;
	char file[512], buffer[255];

	sprintf(file, "%s/users/%s/password", config->data_dir, auth->username);

	// printf("%s\n", file);
	// fflush(stdout);

	h1 = fopen(file, "r");
	if (h1 == NULL) {
		return NULL;
	}

	if (fgets(buffer, 254, h1)) {
		len = strlen(buffer);

		if (buffer[len - 1] == '\n') {
			buffer[len - 1] = '\0';
		}

		// printf("rpassword: \"%s\"\n", buffer);
		// printf("auth_pas: \"%s\"\n", auth->password);
		// fflush(stdout);

		if (!strcmp(auth->password, buffer)) {
			sprintf(file, "%s/users/%s/ip", config->data_dir, auth->username);
			h2 = fopen(file, "r");
		}
	}

	fclose(h1);
	return h2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x308, %rsp            # imm = 0x308
movq %rsi, %r12
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq 0x18(%rdi), %rdx
leaq 0x2(%rsi), %r14
leaq 0x2938(%rip), %rsi      # 0x833a
xorl %r13d, %r13d
leaq -0x230(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2390
leaq 0x166f(%rip), %rsi      # 0x708f
movq %rbx, %rdi
callq 0x2340
testq %rax, %rax
je 0x5ac0
movq %rax, %rbx
leaq -0x330(%rbp), %r13
movq %r13, %rdi
movl $0xfe, %esi
movq %rax, %rdx
callq 0x21e0
testq %rax, %rax
je 0x5a82
movq %r13, %rdi
callq 0x2100
cmpb $0xa, -0x1(%rax,%r13)
jne 0x5a68
movb $0x0, -0x331(%rbp,%rax)
addq $0x102, %r12            # imm = 0x102
leaq -0x330(%rbp), %rsi
movq %r12, %rdi
callq 0x2220
testl %eax, %eax
je 0x5a87
xorl %r13d, %r13d
jmp 0x5ab8
movq 0x18(%r15), %rdx
leaq 0x28bd(%rip), %rsi      # 0x834f
leaq -0x230(%rbp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2390
leaq 0x15e2(%rip), %rsi      # 0x708f
movq %r15, %rdi
callq 0x2340
movq %rax, %r13
movq %rbx, %rdi
callq 0x20f0
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x5ae4
movq %r13, %rax
addq $0x308, %rsp            # imm = 0x308
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2110
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/TeaInside[P]teavpn/src/teavpn/teavpn.c
// Function: _internal_debug_log
uint8_t __internal_debug_log(const char *msg, ...)
{
	va_list argp;
	time_t rawtime;
	struct tm *timeinfo;

	time(&rawtime);
	timeinfo = localtime(&rawtime);
	char *time = asctime(timeinfo);
	time[24] = '\0';

	va_start(argp, msg);
	fprintf(stdout, "[%s]: ", time);
	vfprintf(stdout, msg, argp);
	fprintf(stdout, "\n");
	va_end(argp);
	fflush(stdout);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
andq $-0x10, %rsp
subq $0xf0, %rsp
movq %rdi, %rbx
movq %rsp, %r15
movq %rsi, 0x8(%r15)
movq %rdx, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r8, 0x20(%r15)
movq %r9, 0x28(%r15)
testb %al, %al
je 0x5b4f
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %fs:0x28, %rax
movq %rax, 0xe0(%rsp)
leaq 0xb8(%rsp), %r14
movq %r14, %rdi
callq 0x2280
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2130
movb $0x0, 0x18(%rax)
movabsq $0x3000000008, %rcx     # imm = 0x3000000008
leaq 0xc0(%rsp), %r14
movq %rcx, (%r14)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%r14)
movq %r15, 0x10(%r14)
movq 0x5424(%rip), %r15      # 0xafd0
movq (%r15), %rdi
leaq 0x27a8(%rip), %rsi      # 0x835e
movq %rax, %rdx
xorl %eax, %eax
callq 0x2240
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2360
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x21c0
movq (%r15), %rdi
callq 0x22d0
movq %fs:0x28, %rax
cmpq 0xe0(%rsp), %rax
jne 0x5c01
xorl %eax, %eax
leaq -0x18(%rbp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2110
// File: /workspace/github_c_makefile_star2_O2/TeaInside[P]teavpn/src/teavpn/teavpn.c
// Function: tun_alloc
int tun_alloc(char *dev, int flags)
{
	struct ifreq ifr;
	int fd, err;

	if ((fd = open("/dev/net/tun", O_RDWR)) < 0) {
		perror("Opening /dev/net/tun");
		return fd;
	}

	memset(&ifr, 0, sizeof(ifr));

	ifr.ifr_flags = flags;

	if (*dev) {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstringop-truncation"
		strncpy(ifr.ifr_name, dev, IFNAMSIZ);
#pragma GCC diagnostic pop
	}

	if ((err = ioctl(fd, TUNSETIFF, (void *)&ifr)) < 0) {
		perror("ioctl(TUNSETIFF)");
		close(fd);
		return err;
	}

	strcpy(dev, ifr.ifr_name);
	return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %esi, %r15d
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
leaq 0x2740(%rip), %rdi      # 0x836d
pushq $0x2
popq %rsi
xorl %eax, %eax
callq 0x2320
movl %eax, %ebx
testl %eax, %eax
js 0x5ca5
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
andq $0x0, -0x30(%rbp)
movaps %xmm0, -0x50(%rbp)
movw %r15w, -0x40(%rbp)
cmpb $0x0, (%r14)
je 0x5c67
leaq -0x50(%rbp), %rdi
pushq $0x10
popq %rdx
movq %r14, %rsi
callq 0x2060
leaq -0x50(%rbp), %rdx
movl $0x400454ca, %esi       # imm = 0x400454CA
movl %ebx, %edi
xorl %eax, %eax
callq 0x2190
testl %eax, %eax
js 0x5cb3
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
callq 0x2070
movq %fs:0x28, %rax
cmpq -0x20(%rbp), %rax
jne 0x5cce
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x26b9(%rip), %rdi      # 0x8365
callq 0x2350
jmp 0x5c89
movl %eax, %r15d
leaq 0x26bd(%rip), %rdi      # 0x837a
callq 0x2350
movl %ebx, %edi
callq 0x21a0
movl %r15d, %ebx
jmp 0x5c89
callq 0x2110
nop