LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/teodorst[P]app-huffman/huffman_decodification_pthreads.c
// Function: main
int main (int argc, char *argv[]) {
    if (argc == 4) {
        fprintf(stderr, "%s %s %s\n", argv[INPUT_FILE], argv[OUTPUT_FILE], argv[CODIFICATION]);
        huffman_decodification_pthreads(argv[INPUT_FILE], argv[OUTPUT_FILE], argv[CODIFICATION]);
    }
    else {
        printf("Bad arguments\n");
        printf("Usage huffman_serial operation[compress/decompress] input_file ouput_file codification_file_name\n");
        return 1;
    }
    return 0;
    /* Last thing that main() should do */
    pthread_exit(NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x4, -0x8(%rbp)
jne 0x176b
movq 0x38d5(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %r8
leaq 0x1933(%rip), %rsi      # 0x3078
movb $0x0, %al
callq 0x10c0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x13b0
jmp 0x1790
leaq 0x1910(%rip), %rdi      # 0x3082
movb $0x0, %al
callq 0x1080
leaq 0x1911(%rip), %rdi      # 0x3091
movb $0x0, %al
callq 0x1080
movl $0x1, -0x4(%rbp)
jmp 0x1797
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/keithnoguchi[P]pearls-in-action/0x1/main.c
// Function: main
int main(void)
{
	int fail = 0;
	int i = 0;

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

	if (bitmap_test(&i))
		fail++;

	puts("");

	return fail;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq 0xe80(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
leaq 0xe93(%rip), %rdi       # 0x2025
movb $0x0, %al
callq 0x1040
leaq 0xe64(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
leaq -0xc(%rbp), %rdi
callq 0x12f0
cmpl $0x0, %eax
je 0x11be
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
leaq 0xe80(%rip), %rdi       # 0x2045
callq 0x1030
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/keithnoguchi[P]pearls-in-action/0x1/bitmap_test.c
// Function: bitmap_test
int bitmap_test(int *i)
{
	const struct test {
		const char	*name;
		int		pos;
	} tests[] = {
		{
			.name	= "min value in the range",
			.pos	= min(),
		},
		{
			.name	= "max value in the range",
			.pos	= max(),
		},
		{
			.name	= "middle value in the range",
			.pos	= (min()+max())/2,
		},
		{ /* sentry */ },
	};
	const struct test *t;

	for (t = tests; t->name; t++) {
		int j;

		printf("%2d) %-70s", ++(*i), t->name);
		reset();
		set(t->pos);
		/* make sure it's set */
		assert(is_set(t->pos));
		/* make sure others are not set */
		for (j = min(); j <= max(); j++)
			if (j != t->pos)
				assert(!is_set(j));
		puts("PASS");
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xd43(%rip), %rax       # 0x2046
movq %rax, -0x50(%rbp)
movb $0x0, %al
callq 0x1220
movl %eax, -0x48(%rbp)
leaq 0xd45(%rip), %rax       # 0x205d
movq %rax, -0x40(%rbp)
movb $0x0, %al
callq 0x1230
movl %eax, -0x38(%rbp)
leaq 0xd47(%rip), %rax       # 0x2074
movq %rax, -0x30(%rbp)
movb $0x0, %al
callq 0x1220
movl %eax, -0x60(%rbp)
movb $0x0, %al
callq 0x1230
movl %eax, %ecx
movl -0x60(%rbp), %eax
addl %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1464
movq -0x8(%rbp), %rax
movl (%rax), %esi
addl $0x1, %esi
movl %esi, (%rax)
movq -0x58(%rbp), %rax
movq (%rax), %rdx
leaq 0xcfc(%rip), %rdi       # 0x208e
movb $0x0, %al
callq 0x1040
movb $0x0, %al
callq 0x11e0
movq -0x58(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x1240
movq -0x58(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x12c0
cmpl $0x0, %eax
je 0x13bf
jmp 0x13de
leaq 0xcd3(%rip), %rdi       # 0x2099
leaq 0xcdb(%rip), %rsi       # 0x20a8
movl $0x25, %edx
leaq 0xcdd(%rip), %rcx       # 0x20b6
callq 0x1050
movb $0x0, %al
callq 0x1220
movl %eax, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
movl %eax, -0x64(%rbp)
movb $0x0, %al
callq 0x1230
movl %eax, %ecx
movl -0x64(%rbp), %eax
cmpl %ecx, %eax
jg 0x1447
movl -0x5c(%rbp), %eax
movq -0x58(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0x143a
movl -0x5c(%rbp), %edi
callq 0x12c0
cmpl $0x0, %eax
jne 0x1419
jmp 0x1438
leaq 0xcad(%rip), %rdi       # 0x20cd
leaq 0xc81(%rip), %rsi       # 0x20a8
movl $0x29, %edx
leaq 0xc83(%rip), %rcx       # 0x20b6
callq 0x1050
jmp 0x143a
jmp 0x143c
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x13e8
leaq 0xc8a(%rip), %rdi       # 0x20d8
callq 0x1030
movq -0x58(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x58(%rbp)
jmp 0x136b
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/lbn2pbn/lbn2pbn.c
// Function: usage
__attribute__((noreturn))
#endif
static void usage(const char* prog)
{
    fprintf(stderr, "%s -T tracks -S sectors -B sector_size"
                    " -i interleave -k track_skew [-r] infile outfile\n", prog);

    fprintf(stderr, "\nTypical parameters:\n"
                    "RX01:                   -T 77 -S 26 -B 128 -i 2 -k 6\n"
                    "RX02 (single density):  -T 77 -S 26 -B 128 -i 2 -k 6\n"
                    "RX02 (double density):  -T 77 -S 26 -B 256 -i 2 -k 6\n"
                    "RX50:                   -T 80 -S 10 -B 512 -i 2 -k 2\n"
                    "\nSupported sector sizes (in bytes): 128, 256, 512\n");
    exit(2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x2975(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0xa74(%rip), %rsi       # 0x2105
movb $0x0, %al
callq 0x1090
movq 0x2959(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xab4(%rip), %rsi       # 0x215d
movb $0x0, %al
callq 0x1090
movl $0x2, %edi
callq 0x1100
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/lbn2pbn/lbn2pbn.c
// Function: lbn2pbn
static int lbn2pbn(int lbn)
{
    int track;
    int sector;

    track   = lbn / sectors;

    /* interleave */
    sector  = lbn % sectors;
    sector *= interleave;
    sector += sector / round;

    /* track skew */
    sector += track * track_skew;

    /* PBN */
    sector %= sectors;
    track++;
    track  %= tracks;

    return track * sectors + sector;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
cltd
idivl 0x2947(%rip)            # 0x40a8
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
cltd
idivl 0x293a(%rip)            # 0x40a8
movl %edx, -0xc(%rbp)
movl 0x2939(%rip), %eax      # 0x40b0
imull -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cltd
idivl 0x2930(%rip)            # 0x40b8
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
imull 0x291c(%rip), %eax      # 0x40b4
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl 0x2904(%rip), %ecx      # 0x40a8
movl -0xc(%rbp), %eax
cltd
idivl %ecx
movl %edx, -0xc(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl 0x28e8(%rip), %ecx      # 0x40a4
movl -0x8(%rbp), %eax
cltd
idivl %ecx
movl %edx, -0x8(%rbp)
movl -0x8(%rbp), %eax
imull 0x28d9(%rip), %eax      # 0x40a8
addl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/lbn2pbn/lbn2pbn.c
// Function: gcd
static int gcd(int a, int b)
{
    while (a  &&  b) {
        if (a > b)
            a %= b;
        else
            b %= a;
    }
    return a + b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x4(%rbp)
movb %al, -0x9(%rbp)
je 0x17ff
cmpl $0x0, -0x8(%rbp)
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x1808
jmp 0x182c
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jle 0x181e
movl -0x8(%rbp), %ecx
movl -0x4(%rbp), %eax
cltd
idivl %ecx
movl %edx, -0x4(%rbp)
jmp 0x182a
movl -0x4(%rbp), %ecx
movl -0x8(%rbp), %eax
cltd
idivl %ecx
movl %edx, -0x8(%rbp)
jmp 0x17ea
movl -0x4(%rbp), %eax
addl -0x8(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hoomanist[P]carrot/rm.c
// Function: main
int 
main(int argc, char **argv)
{
	if(argc <= 1)
	{
		fprintf(stderr, "usage : %s filename[s]...\n", argv[0]);
		return 1;
	}
	
	for(int i = 1; i < argc; i++)
		if(remove(argv[i]) == -1)
			fprintf(stderr, "oops something went wrong.");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jg 0x1194
movq 0x2e85(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xe80(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1040
movl $0x1, -0x4(%rbp)
jmp 0x11e5
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x11de
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
cmpl $-0x1, %eax
jne 0x11d1
movq 0x2e38(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xe55(%rip), %rsi       # 0x201f
movb $0x0, %al
callq 0x1040
jmp 0x11d3
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x119b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/main.c
// Function: do_sh_null
void do_sh_null() {
	SH_BareItem* bi;

	int err = 0;

	printf("+ NULL item\n");

	bi = SH_BareItem__init_null(&err);
	if ((SH_BareItem*)0 == bi || err) {
		printf("  * unable to init SH_BareItem: [%llX] 0x%08X\n", (long long)bi, err);
	} else {
		printf("  + init SH_BareItem: [%llX]\n", (long long)bi);
		do_sh_bareitem(bi);
		SH_BareItem__destroy(bi, SH_FALSE, 0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0xc(%rbp)
leaq 0x6bda(%rip), %rdi      # 0x8140
movb $0x0, %al
callq 0x1050
leaq -0xc(%rbp), %rdi
callq 0x49b0
movq %rax, -0x8(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
je 0x1588
cmpl $0x0, -0xc(%rbp)
je 0x159f
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq 0x6bb7(%rip), %rdi      # 0x814d
movb $0x0, %al
callq 0x1050
jmp 0x15c9
movq -0x8(%rbp), %rsi
leaq 0x6bd2(%rip), %rdi      # 0x817c
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x11e0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x4eb0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/main.c
// Function: do_sh_bytesequence
void do_sh_bytesequence(sh_byte_t* value, size_t n) {
	SH_ByteSequence* obj;
	SH_BareItem* bi;

	uint16_t u;
	sh_char_t* s;

	int err = 0;

	obj = SH_ByteSequence__init(value, n, &err);
	if ((SH_ByteSequence*)0 == obj || err) {
		printf("* unable to init SH_ByteSequence({...");
		printf("}, %lu): [%llX] 0x%08X\n", n, (long long)obj, err);
	} else {
		printf("+ init SH_ByteSequence({...");
		printf("}, %lu): [%llX]\n", n, (long long)obj);

		u = SH_ByteSequence__length(obj, 0);
		printf("  - length =: %hu\n", u);

		s = SH_ByteSequence__to_s(obj, &err);
		if ((sh_char_t*)0 == s || err) {
			printf("  * unable to to_s: [%llX] 0x%08X\n", (long long)s, err);
		} else {
			printf("  - to_s =:\n");
			hexdump_string(s);
			free(s);
		}

		bi = SH_BareItem__init_bytesequence(obj, &err);
		if ((SH_BareItem*)0 == bi || err) {
			printf("  * unable to init SH_BareItem: [%llX] 0x%08X\n", (long long)bi, err);
		} else {
			printf("  + init SH_BareItem: [%llX]\n", (long long)bi);
			do_sh_bareitem(bi);
			SH_BareItem__destroy(bi, SH_FALSE, 0);
		}

		SH_ByteSequence__destroy(obj, 0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x34(%rbp), %rdx
callq 0x3c50
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x1cda
cmpl $0x0, -0x34(%rbp)
je 0x1d06
leaq 0x6692(%rip), %rdi      # 0x8373
movb $0x0, %al
callq 0x1050
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x34(%rbp), %ecx
leaq 0x669f(%rip), %rdi      # 0x8399
movb $0x0, %al
callq 0x1050
jmp 0x1e10
leaq 0x66a4(%rip), %rdi      # 0x83b1
movb $0x0, %al
callq 0x1050
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x66aa(%rip), %rdi      # 0x83cd
movb $0x0, %al
callq 0x1050
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3dd0
movw %ax, -0x22(%rbp)
movzwl -0x22(%rbp), %esi
leaq 0x65ec(%rip), %rdi      # 0x8332
movb $0x0, %al
callq 0x1050
movq -0x18(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x3e20
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq -0x30(%rbp), %rax
je 0x1d6c
cmpl $0x0, -0x34(%rbp)
je 0x1d83
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %edx
leaq 0x6394(%rip), %rdi      # 0x810e
movb $0x0, %al
callq 0x1050
jmp 0x1da3
leaq 0x63a9(%rip), %rdi      # 0x8133
movb $0x0, %al
callq 0x1050
movq -0x30(%rbp), %rdi
callq 0x1380
movq -0x30(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x4cd0
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x1dc2
cmpl $0x0, -0x34(%rbp)
je 0x1dd9
movq -0x20(%rbp), %rsi
movl -0x34(%rbp), %edx
leaq 0x637d(%rip), %rdi      # 0x814d
movb $0x0, %al
callq 0x1050
jmp 0x1e03
movq -0x20(%rbp), %rsi
leaq 0x6398(%rip), %rdi      # 0x817c
movb $0x0, %al
callq 0x1050
movq -0x20(%rbp), %rdi
callq 0x11e0
movq -0x20(%rbp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x4eb0
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3d70
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/main.c
// Function: _display_item
void __display_item(SH_Item* obj) {
	int err = 0;
	sh_char_t* s;

	s = SH_Item__to_s(obj, &err);
	if ((sh_char_t*)0 == s) {
		printf("<<ERR:%08x>>\n", err);
	} else {
		printf("%s\n", s);
		free(s);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x5a80
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x1fff
movl -0xc(%rbp), %esi
leaq 0x6472(%rip), %rdi      # 0x8468
movb $0x0, %al
callq 0x1050
jmp 0x201a
movq -0x18(%rbp), %rsi
leaq 0x646c(%rip), %rdi      # 0x8476
movb $0x0, %al
callq 0x1050
movq -0x18(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/main.c
// Function: _do_sh_item
void __do_sh_item(SH_Item* obj) {
	int err = 0;

	SH_Key  *key1, *key2, *key3;
	SH_Item *val1, *val2, *val3;

	__display_item(obj);

	key1 = SH_Key__init((unsigned char*)"key1", 4, &err);
	val1 = SH_Item__init(SH_BareItem__init_boolean(SH_Boolean__init(SH_FALSE, &err), &err), 0, &err);

	SH_Item__add_param(obj, key1, val1, &err);
	__display_item(obj);

	key2 = SH_Key__init((unsigned char*)"k2", 2, &err);
	val2 = SH_Item__init(SH_BareItem__init_boolean(SH_Boolean__init(SH_TRUE, &err), &err), 0, &err);

	SH_Item__add_param(obj, key2, val2, &err);
	__display_item(obj);

	key3 = SH_Key__init((unsigned char*)"three", 5, &err);
	val3 = SH_Item__init(SH_BareItem__init_integer(SH_Integer__init(1234, &err), &err), 0, &err);

	SH_Item__add_param(obj, key3, val3, &err);
	__display_item(obj);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1fc0
leaq 0x6437(%rip), %rdi      # 0x847a
movl $0x4, %esi
leaq -0xc(%rbp), %rdx
callq 0x5ce0
movq %rax, -0x18(%rbp)
xorl %edi, %edi
leaq -0xc(%rbp), %rsi
callq 0x4110
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0x4d70
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0xc(%rbp), %rdx
callq 0x5610
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0xc(%rbp), %rcx
callq 0x5850
movq -0x8(%rbp), %rdi
callq 0x1fc0
leaq 0x63da(%rip), %rdi      # 0x847f
movl $0x2, %esi
leaq -0xc(%rbp), %rdx
callq 0x5ce0
movq %rax, -0x20(%rbp)
movl $0xff, %edi
leaq -0xc(%rbp), %rsi
callq 0x4110
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0x4d70
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0xc(%rbp), %rdx
callq 0x5610
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0xc(%rbp), %rcx
callq 0x5850
movq -0x8(%rbp), %rdi
callq 0x1fc0
leaq 0x6378(%rip), %rdi      # 0x8482
movl $0x5, %esi
leaq -0xc(%rbp), %rdx
callq 0x5ce0
movq %rax, -0x28(%rbp)
movl $0x4d2, %edi            # imm = 0x4D2
leaq -0xc(%rbp), %rsi
callq 0x2b80
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0x4a50
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0xc(%rbp), %rdx
callq 0x5610
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq -0xc(%rbp), %rcx
callq 0x5850
movq -0x8(%rbp), %rdi
callq 0x1fc0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/main.c
// Function: print_list
void _print_list(SH_List* list) {
	sh_char_t* s;
	int err = 0;

	printf("  - count = %lu\n", list->count);

	s = SH_List__to_s(list, &err);
	if ((sh_char_t*)0 == s || err) {
		printf("  * unable to to_s: [%llX] 0x%08X\n", (long long)s, err);
	} else {
		printf("  - to_s =:\n");
		hexdump_string(s);
		free(s);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x2000(%rax), %rsi
leaq 0x6135(%rip), %rdi      # 0x864a
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x6e90
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x253b
cmpl $0x0, -0x14(%rbp)
je 0x2552
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq 0x5bc5(%rip), %rdi      # 0x810e
movb $0x0, %al
callq 0x1050
jmp 0x2572
leaq 0x5bda(%rip), %rdi      # 0x8133
movb $0x0, %al
callq 0x1050
movq -0x10(%rbp), %rdi
callq 0x1380
movq -0x10(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/main.c
// Function: print_innerlist
void _print_innerlist(SH_InnerList* list) {
	sh_char_t* s;
	int err = 0;

	printf("  - count = %lu\n", list->count);

	s = SH_InnerList__to_s(list, &err);
	if ((sh_char_t*)0 == s || err) {
		printf("  * unable to to_s: [%llX] 0x%08X\n", (long long)s, err);
	} else {
		printf("  - to_s =:\n");
		hexdump_string(s);
		free(s);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x800(%rax), %rsi
leaq 0x5eb5(%rip), %rdi      # 0x864a
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x47b0
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x27bb
cmpl $0x0, -0x14(%rbp)
je 0x27d2
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq 0x5945(%rip), %rdi      # 0x810e
movb $0x0, %al
callq 0x1050
jmp 0x27f2
leaq 0x595a(%rip), %rdi      # 0x8133
movb $0x0, %al
callq 0x1050
movq -0x10(%rbp), %rdi
callq 0x1380
movq -0x10(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/src/integer.c
// Function: SH_Integer__init
SH_Integer*
SH_Integer__init(sh_int_t value, int* err) {
	SH_Integer* obj;

	__cascade(err, (SH_Integer*)0);

	if (value < SH_INT_MIN || value > SH_INT_MAX) {
		__raise(err, SH_E_INTEGER_OUT_OF_BOUNDS);
		return (SH_Integer*)0;
	}

	obj = (SH_Integer*)malloc(sizeof(SH_Integer));
	if ((SH_Integer*)0 == obj) {
		__raise(err, SH_E_MALLOC_ERROR);
		return (SH_Integer*)0;
	}

	obj->value = value;

	__clear(err);
	return obj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x2baf
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x2baf
movq $0x0, -0x8(%rbp)
jmp 0x2c42
movabsq $-0x38d7ea4c67fff, %rax # imm = 0xFFFC72815B398001
cmpq %rax, -0x10(%rbp)
jl 0x2bcf
movabsq $0x38d7ea4c67fff, %rax  # imm = 0x38D7EA4C67FFF
cmpq %rax, -0x10(%rbp)
jle 0x2beb
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x2be1
movq -0x18(%rbp), %rax
movl $0x110001, (%rax)       # imm = 0x110001
movq $0x0, -0x8(%rbp)
jmp 0x2c42
movl $0x8, %edi
callq 0x1090
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x2c1d
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x2c13
movq -0x18(%rbp), %rax
movl $0x80000001, (%rax)     # imm = 0x80000001
movq $0x0, -0x8(%rbp)
jmp 0x2c42
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x2c3a
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/src/integer.c
// Function: SH_Integer__abs
sh_int_t
SH_Integer__abs(SH_Integer* obj, int* err) {
	__cascade(err, SH_INT_C(0));
	if (SH_Integer__negative(obj, err)) {
		__clear(err);
		return -(obj->value);
	} else {
		__clear(err);
		return obj->value;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x2d6c
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x2d6c
movq $0x0, -0x8(%rbp)
jmp 0x2dbb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2cf0
cmpb $0x0, %al
je 0x2d9e
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x2d8f
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
subq (%rcx), %rax
movq %rax, -0x8(%rbp)
jmp 0x2dbb
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x2db0
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/src/string.c
// Function: SH_String__init
SH_String*
SH_String__init(sh_char_t* value, size_t n, int* err) {
	SH_String* obj;
	sh_char_t* ptr;
	sh_char_t  c;
	size_t m;

	__cascade(err, (SH_String*)0);

	if (n > SH_STRING_LENGTH_MAX) {
		__raise(err, SH_E_STRING_TOO_LONG);
		return (SH_String*)0;
	}

	ptr = value;
	m = 0;
	while (m < n) {
		c = *ptr;
		if (c >= SH_CHAR_C(0x20) && c <= SH_CHAR_C(0x7E)) {
			ptr++;
			m++;
		} else {
			__raise(err, SH_E_STRING_BAD_CHAR);
			return (SH_String*)0;
		}
	}

	obj = (SH_String*)malloc(sizeof(SH_String));
	if ((SH_String*)0 == obj) {
		__raise(err, SH_E_MALLOC_ERROR);
		return (SH_String*)0;
	}

	obj->value = (sh_char_t*)calloc(sizeof(sh_char_t), m + 1);
	if ((sh_char_t*)0 == obj->value) {
		free(obj);
		__raise(err, SH_E_MALLOC_ERROR);
		return (SH_String*)0;
	}

	memcpy((void*)obj->value, (const void*)value, m);
	obj->value[m] = SH_CHAR_C(0);
	obj->length = m;

	__clear(err);
	return obj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x3603
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x3603
movq $0x0, -0x8(%rbp)
jmp 0x3766
cmpq $0x400, -0x18(%rbp)     # imm = 0x400
jbe 0x362c
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x361f
movq -0x20(%rbp), %rax
movl $0x130001, (%rax)       # imm = 0x130001
movq $0x0, -0x8(%rbp)
jmp 0x3766
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x369c
movq -0x30(%rbp), %rax
movb (%rax), %al
movb %al, -0x31(%rbp)
movzbl -0x31(%rbp), %eax
cmpl $0x20, %eax
jl 0x367b
movzbl -0x31(%rbp), %eax
cmpl $0x7e, %eax
jg 0x367b
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x369a
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x368d
movq -0x20(%rbp), %rax
movl $0x130002, (%rax)       # imm = 0x130002
movq $0x0, -0x8(%rbp)
jmp 0x3766
jmp 0x363c
movl $0x10, %edi
callq 0x1090
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jne 0x36d1
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x36c4
movq -0x20(%rbp), %rax
movl $0x80000001, (%rax)     # imm = 0x80000001
movq $0x0, -0x8(%rbp)
jmp 0x3766
movq -0x40(%rbp), %rsi
addq $0x1, %rsi
movl $0x1, %edi
callq 0x1070
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x371d
movq -0x28(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x3713
movq -0x20(%rbp), %rax
movl $0x80000001, (%rax)     # imm = 0x80000001
movq $0x0, -0x8(%rbp)
jmp 0x3766
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x1080
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x40(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x375e
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/src/string.c
// Function: SH_String__destroy
void
SH_String__destroy(SH_String* obj, int* err) {
	__cascade(err,);
	if ((sh_char_t*)0 != obj->value) {
		free(obj->value);
	}
	free(obj);
	__clear(err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x3794
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x3794
jmp 0x37c6
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x37ab
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x37c6
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/examples/foobar.c
// Function: main
int main(int argc, char** argv) {

    mpc_result_t r;
    mpc_parser_t* Foobar;

    if (argc != 2) {
      printf("Usage: ./foobar <foo/bar>\n");
      exit(0);
    }

    Foobar = mpc_new("foobar");
    mpca_lang(MPCA_LANG_DEFAULT, "foobar : \"foo\" | \"bar\";", Foobar);
    
    if (mpc_parse("<stdin>", argv[1], Foobar, &r)) {
        mpc_ast_print(r.output);
        mpc_ast_delete(r.output);
    } else {
        mpc_err_print(r.error);
        mpc_err_delete(r.error);
    }
    
    mpc_cleanup(1, Foobar);
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x1311
leaq 0xdd01(%rip), %rdi      # 0xf004
movb $0x0, %al
callq 0x1090
xorl %edi, %edi
callq 0x11b0
leaq 0xdd07(%rip), %rdi      # 0xf01f
callq 0x3820
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
xorl %edi, %edi
leaq 0xdcf8(%rip), %rsi      # 0xf026
movb $0x0, %al
callq 0xa440
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
leaq 0xdcf6(%rip), %rdi      # 0xf03e
leaq -0x18(%rbp), %rcx
callq 0x2d70
cmpl $0x0, %eax
je 0x136a
movq -0x18(%rbp), %rdi
callq 0x84c0
movq -0x18(%rbp), %rdi
callq 0x7d40
jmp 0x137c
movq -0x18(%rbp), %rdi
callq 0x1420
movq -0x18(%rbp), %rdi
callq 0x13a0
movq -0x20(%rbp), %rsi
movl $0x1, %edi
movb $0x0, %al
callq 0x3f20
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/ArtifexSoftware[P]mujs/pp.c
// Function: main
int
main(int argc, char **argv)
{
	js_State *J;
	int i;

	if (argc < 2) {
		fprintf(stderr, "usage: mujs-pp [-m | -mm | -s | -c] input.js\n");
		fprintf(stderr, "  -m\tminify output\n");
		fprintf(stderr, "  -mm\tminify output more\n");
		fprintf(stderr, "  -s\tprint syntax tree\n");
		fprintf(stderr, "  -c\tprint bytecode\n");
	}

	J = js_newstate(NULL, NULL, 0);

	for (i = 1; i < argc; ++i) {
		if (!strcmp(argv[i], "-m"))
			format = 0, minify = 1;
		else if (!strcmp(argv[i], "-mm"))
			format = 0, minify = 2;
		else if (!strcmp(argv[i], "-s"))
			format = 1, minify = 0;
		else if (!strcmp(argv[i], "-c"))
			format = 2, minify = 0;
		else
			js_tryppfile(J, argv[i]);
	}

	js_gc(J, 0);
	js_freestate(J);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x44f4
movq 0x46b75(%rip), %rax     # 0x4aff8
movq (%rax), %rdi
leaq 0x3219f(%rip), %rsi     # 0x3662c
movb $0x0, %al
callq 0x41f0
movq 0x46b5d(%rip), %rax     # 0x4aff8
movq (%rax), %rdi
leaq 0x321b5(%rip), %rsi     # 0x3665a
movb $0x0, %al
callq 0x41f0
movq 0x46b45(%rip), %rax     # 0x4aff8
movq (%rax), %rdi
leaq 0x321b1(%rip), %rsi     # 0x3666e
movb $0x0, %al
callq 0x41f0
movq 0x46b2d(%rip), %rax     # 0x4aff8
movq (%rax), %rdi
leaq 0x321b3(%rip), %rsi     # 0x36688
movb $0x0, %al
callq 0x41f0
movq 0x46b15(%rip), %rax     # 0x4aff8
movq (%rax), %rdi
leaq 0x321b3(%rip), %rsi     # 0x366a0
movb $0x0, %al
callq 0x41f0
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
movq %rsi, %rdi
callq 0x1c2d0
movq %rax, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x4613
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x32189(%rip), %rsi     # 0x366b5
callq 0x41e0
cmpl $0x0, %eax
jne 0x454f
movl $0x0, 0x47e4c(%rip)     # 0x4c38c
movl $0x1, 0x47e46(%rip)     # 0x4c390
jmp 0x4603
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x32156(%rip), %rsi     # 0x366b8
callq 0x41e0
cmpl $0x0, %eax
jne 0x4582
movl $0x0, 0x47e16(%rip)     # 0x4c38c
movl $0x2, 0x47e10(%rip)     # 0x4c390
jmp 0x4601
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x32127(%rip), %rsi     # 0x366bc
callq 0x41e0
cmpl $0x0, %eax
jne 0x45b5
movl $0x1, 0x47de3(%rip)     # 0x4c38c
movl $0x0, 0x47ddd(%rip)     # 0x4c390
jmp 0x45ff
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x320f7(%rip), %rsi     # 0x366bf
callq 0x41e0
cmpl $0x0, %eax
jne 0x45e8
movl $0x2, 0x47db0(%rip)     # 0x4c38c
movl $0x0, 0x47daa(%rip)     # 0x4c390
jmp 0x45fd
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x4630
jmp 0x45ff
jmp 0x4601
jmp 0x4603
jmp 0x4605
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x450d
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0xf470
movq -0x18(%rbp), %rdi
callq 0x10110
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ArtifexSoftware[P]mujs/pp.c
// Function: js_tryppfile
static void js_tryppfile(js_State *J, const char *file)
{
	if (js_try(J)) {
		js_report(J, js_trystring(J, -1, "Error"));
		js_pop(J, 1);
		return;
	}
	js_ppfile(J, file);
	js_endtry(J);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16c00
movq %rax, %rdi
callq 0x41d0
cmpl $0x0, %eax
je 0x468f
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x3ac9b(%rip), %rdx     # 0x3f309
callq 0x1bcf0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x100d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6d90
jmp 0x46a5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x46b0
movq -0x8(%rbp), %rdi
callq 0x173a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArtifexSoftware[P]mujs/pp.c
// Function: js_ppstring
static void js_ppstring(js_State *J, const char *filename, const char *source)
{
	js_Ast *P;
	js_Function *F;

	if (js_try(J)) {
		jsP_freeparse(J);
		js_throw(J);
	}

	P = jsP_parse(J, filename, source);
	F = jsC_compilescript(J, P, J->default_strict);

	switch (format) {
	case 0:
		jsP_dumpsyntax(J, P);
		break;
	case 1:
		jsP_dumplist(J, P);
		break;
	case 2:
		jsC_dumpfunction(J, F);
		break;
	}

	jsP_freeparse(J);
	js_endtry(J);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16c00
movq %rax, %rdi
callq 0x41d0
cmpl $0x0, %eax
je 0x48ac
movq -0x8(%rbp), %rdi
callq 0x144d0
movq -0x8(%rbp), %rdi
callq 0xb640
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x14580
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl 0x30(%rdi), %edx
callq 0xb980
movq %rax, -0x28(%rbp)
movl 0x47ab1(%rip), %eax     # 0x4c38c
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x48f8
jmp 0x48e4
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0x4907
jmp 0x48ee
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0x4916
jmp 0x4923
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4940
jmp 0x4923
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x49a0
jmp 0x4923
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x49f0
movq -0x8(%rbp), %rdi
callq 0x144d0
movq -0x8(%rbp), %rdi
callq 0x173a0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArtifexSoftware[P]mujs/pp.c
// Function: jsP_dumpsyntax
static void jsP_dumpsyntax(js_State *J, js_Ast *prog)
{
	if (prog) {
		if (prog->type == AST_LIST)
			pstmlist(-1, prog);
		else {
			pstm(0, prog);
			nl();
		}
	}
	if (minify > 1)
		putchar('\n');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4982
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x4970
movq -0x10(%rbp), %rsi
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x4db0
jmp 0x4980
movq -0x10(%rbp), %rsi
xorl %edi, %edi
callq 0x4e20
callq 0x5530
jmp 0x4982
cmpl $0x1, 0x47a07(%rip)     # 0x4c390
jle 0x4995
movl $0xa, %edi
callq 0x4040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArtifexSoftware[P]mujs/pp.c
// Function: jsP_dumplist
static void jsP_dumplist(js_State *J, js_Ast *prog)
{
	if (prog) {
		if (prog->type == AST_LIST)
			sblock(0, prog);
		else
			snode(0, prog);
		nl();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x49dd
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x49cd
movq -0x10(%rbp), %rsi
xorl %edi, %edi
callq 0x6940
jmp 0x49d8
movq -0x10(%rbp), %rsi
xorl %edi, %edi
callq 0x69f0
callq 0x5530
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArtifexSoftware[P]mujs/pp.c
// Function: pstmlist
static void pstmlist(int d, js_Ast *list)
{
	while (list) {
		assert(list->type == AST_LIST);
		pstm(d+1, list->a);
		nl();
		list = list->b;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4e16
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x4dd1
jmp 0x4df0
leaq 0x31989(%rip), %rdi     # 0x36761
leaq 0x31999(%rip), %rsi     # 0x36778
movl $0x2f3, %edx            # imm = 0x2F3
leaq 0x31992(%rip), %rcx     # 0x3677d
callq 0x4150
movl -0x4(%rbp), %edi
addl $0x1, %edi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x4e20
callq 0x5530
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x4dbf
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ArtifexSoftware[P]mujs/pp.c
// Function: pblock
static void pblock(int d, js_Ast *block)
{
	assert(block->type == STM_BLOCK);
	pc('{'); nl();
	pstmlist(d, block->a);
	in(d); pc('}');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x47, (%rax)
jne 0x556a
jmp 0x5589
leaq 0x31252(%rip), %rdi     # 0x367c3
leaq 0x31200(%rip), %rsi     # 0x36778
movl $0x23a, %edx            # imm = 0x23A
leaq 0x31258(%rip), %rcx     # 0x367dc
callq 0x4150
movl $0x7b, %edi
callq 0x5660
callq 0x5530
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x4db0
movl -0x4(%rbp), %edi
callq 0x55c0
movl $0x7d, %edi
callq 0x5660
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ArtifexSoftware[P]mujs/pp.c
// Function: pargs
static void pargs(int d, js_Ast *list)
{
	while (list) {
		assert(list->type == AST_LIST);
		pexpi(d, COMMA, list->a);
		list = list->b;
		if (list)
			comma();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x56ef
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x56a1
jmp 0x56c0
leaq 0x310b9(%rip), %rdi     # 0x36761
leaq 0x310c9(%rip), %rsi     # 0x36778
movl $0x139, %edx            # imm = 0x139
leaq 0x3121f(%rip), %rcx     # 0x368da
callq 0x4150
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movl $0xf, %esi
callq 0x58a0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x56ed
callq 0x68a0
jmp 0x568f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArtifexSoftware[P]mujs/pp.c
// Function: pvarlist
static void pvarlist(int d, js_Ast *list)
{
	while (list) {
		assert(list->type == AST_LIST);
		pvar(d, list->a);
		list = list->b;
		if (list)
			comma();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x578a
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x5741
jmp 0x5760
leaq 0x31019(%rip), %rdi     # 0x36761
leaq 0x31029(%rip), %rsi     # 0x36778
movl $0x230, %edx            # imm = 0x230
leaq 0x31199(%rip), %rcx     # 0x368f4
callq 0x4150
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x68c0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5788
callq 0x68a0
jmp 0x572f
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ArtifexSoftware[P]mujs/pp.c
// Function: pstmh
static void pstmh(int d, js_Ast *stm)
{
	if (stm->type == STM_BLOCK) {
		sp();
		pblock(d, stm);
	} else {
		nl();
		pstm(d+1, stm);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x47, (%rax)
jne 0x57bb
callq 0x5700
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x5550
jmp 0x57cf
callq 0x5530
movl -0x4(%rbp), %edi
addl $0x1, %edi
movq -0x10(%rbp), %rsi
callq 0x4e20
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArtifexSoftware[P]mujs/pp.c
// Function: pcaselist
static void pcaselist(int d, js_Ast *list)
{
	while (list) {
		js_Ast *stm = list->a;
		if (stm->type == STM_CASE) {
			in(d); ps("case "); pexp(d, stm->a); pc(':'); nl();
			pstmlist(d, stm->b);
		}
		if (stm->type == STM_DEFAULT) {
			in(d); ps("default:"); nl();
			pstmlist(d, stm->a);
		}
		list = list->b;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5895
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x5a, (%rax)
jne 0x5852
movl -0x4(%rbp), %edi
callq 0x55c0
leaq 0x31121(%rip), %rdi     # 0x3693f
callq 0x5600
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x5630
movl $0x3a, %edi
callq 0x5660
callq 0x5530
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x4db0
movq -0x18(%rbp), %rax
cmpl $0x5b, (%rax)
jne 0x5884
movl -0x4(%rbp), %edi
callq 0x55c0
leaq 0x310db(%rip), %rdi     # 0x36945
callq 0x5600
callq 0x5530
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x4db0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x57ef
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArtifexSoftware[P]mujs/pp.c
// Function: pstr
static void pstr(const char *s)
{
	static const char *HEX = "0123456789ABCDEF";
	Rune c;
	pc(minify ? '\'' : '"');
	while (*s) {
		s += chartorune(&c, s);
		switch (c) {
		case '\'': ps("\\'"); break;
		case '"': ps("\\\""); break;
		case '\\': ps("\\\\"); break;
		case '\b': ps("\\b"); break;
		case '\f': ps("\\f"); break;
		case '\n': ps("\\n"); break;
		case '\r': ps("\\r"); break;
		case '\t': ps("\\t"); break;
		default:
			if (c < ' ' || c > 127) {
				ps("\\u");
				pc(HEX[(c>>12)&15]);
				pc(HEX[(c>>8)&15]);
				pc(HEX[(c>>4)&15]);
				pc(HEX[c&15]);
			} else {
				pc(c); break;
			}
		}
	}
	pc(minify ? '\'' : '"');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0x460fe(%rip), %ecx     # 0x4c390
movl $0x22, %edi
movl $0x27, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edi
callq 0x5660
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x6457
movq -0x8(%rbp), %rsi
leaq -0xc(%rbp), %rdi
callq 0x1c6b0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x8, %eax
je 0x636a
jmp 0x62e2
movl -0x10(%rbp), %eax
subl $0x9, %eax
je 0x63ae
jmp 0x62f0
movl -0x10(%rbp), %eax
subl $0xa, %eax
je 0x638c
jmp 0x62fe
movl -0x10(%rbp), %eax
subl $0xc, %eax
je 0x637b
jmp 0x6308
movl -0x10(%rbp), %eax
subl $0xd, %eax
je 0x639d
jmp 0x6316
movl -0x10(%rbp), %eax
subl $0x22, %eax
je 0x6348
jmp 0x6320
movl -0x10(%rbp), %eax
subl $0x27, %eax
je 0x6337
jmp 0x632a
movl -0x10(%rbp), %eax
subl $0x5c, %eax
je 0x6359
jmp 0x63bf
leaq 0x30540(%rip), %rdi     # 0x3687e
callq 0x5600
jmp 0x6452
leaq 0x30532(%rip), %rdi     # 0x36881
callq 0x5600
jmp 0x6452
leaq 0x30524(%rip), %rdi     # 0x36884
callq 0x5600
jmp 0x6452
leaq 0x30516(%rip), %rdi     # 0x36887
callq 0x5600
jmp 0x6452
leaq 0x30508(%rip), %rdi     # 0x3688a
callq 0x5600
jmp 0x6452
leaq 0x304fa(%rip), %rdi     # 0x3688d
callq 0x5600
jmp 0x6452
leaq 0x304ec(%rip), %rdi     # 0x36890
callq 0x5600
jmp 0x6452
leaq 0x304de(%rip), %rdi     # 0x36893
callq 0x5600
jmp 0x6452
cmpl $0x20, -0xc(%rbp)
jl 0x63cb
cmpl $0x7f, -0xc(%rbp)
jle 0x6446
leaq 0x304c4(%rip), %rdi     # 0x36896
callq 0x5600
movq 0x44de2(%rip), %rax     # 0x4b1c0
movl -0xc(%rbp), %ecx
sarl $0xc, %ecx
andl $0xf, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edi
callq 0x5660
movq 0x44dc6(%rip), %rax     # 0x4b1c0
movl -0xc(%rbp), %ecx
sarl $0x8, %ecx
andl $0xf, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edi
callq 0x5660
movq 0x44daa(%rip), %rax     # 0x4b1c0
movl -0xc(%rbp), %ecx
sarl $0x4, %ecx
andl $0xf, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edi
callq 0x5660
movq 0x44d8e(%rip), %rax     # 0x4b1c0
movl -0xc(%rbp), %ecx
andl $0xf, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edi
callq 0x5660
jmp 0x6450
movl -0xc(%rbp), %edi
callq 0x5660
jmp 0x6452
jmp 0x6452
jmp 0x62a7
movl 0x45f33(%rip), %ecx     # 0x4c390
movl $0x22, %edi
movl $0x27, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edi
callq 0x5660
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArtifexSoftware[P]mujs/pp.c
// Function: pregexp
static void pregexp(const char *prog, int flags)
{
	pc('/');
	while (*prog) {
		if (*prog == '/')
			pc('\\');
		pc(*prog);
		++prog;
	}
	pc('/');
	if (flags & JS_REGEXP_G) pc('g');
	if (flags & JS_REGEXP_I) pc('i');
	if (flags & JS_REGEXP_M) pc('m');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x2f, %edi
callq 0x5660
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x64d2
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x64b8
movl $0x5c, %edi
callq 0x5660
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x5660
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x6499
movl $0x2f, %edi
callq 0x5660
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x64f1
movl $0x67, %edi
callq 0x5660
movl -0xc(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x6506
movl $0x69, %edi
callq 0x5660
movl -0xc(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x651b
movl $0x6d, %edi
callq 0x5660
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArtifexSoftware[P]mujs/pp.c
// Function: parray
static void parray(int d, js_Ast *list)
{
	pc('[');
	while (list) {
		assert(list->type == AST_LIST);
		pexpi(d, COMMA, list->a);
		list = list->b;
		if (list)
			comma();
	}
	pc(']');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x5b, %edi
callq 0x5660
cmpq $0x0, -0x10(%rbp)
je 0x67d9
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x678b
jmp 0x67aa
leaq 0x2ffcf(%rip), %rdi     # 0x36761
leaq 0x2ffdf(%rip), %rsi     # 0x36778
movl $0x145, %edx            # imm = 0x145
leaq 0x3011a(%rip), %rcx     # 0x368bf
callq 0x4150
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movl $0xf, %esi
callq 0x58a0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x67d7
callq 0x68a0
jmp 0x6779
movl $0x5d, %edi
callq 0x5660
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ArtifexSoftware[P]mujs/pp.c
// Function: pbin
static void pbin(int d, int p, js_Ast *exp, const char *op)
{
	pexpi(d, p, exp->a);
	sp();
	ps(op);
	sp();
	pexpi(d, p, exp->b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x58a0
callq 0x5700
movq -0x18(%rbp), %rdi
callq 0x5600
callq 0x5700
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x58a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArtifexSoftware[P]mujs/pp.c
// Function: pvar
static void pvar(int d, js_Ast *var)
{
	assert(var->type == EXP_VAR);
	pexp(d, var->a);
	if (var->b) {
		sp(); pc('='); sp();
		pexp(d, var->b);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x46, (%rax)
jne 0x68da
jmp 0x68f9
leaq 0x30030(%rip), %rdi     # 0x36911
leaq 0x2fe90(%rip), %rsi     # 0x36778
movl $0x225, %edx            # imm = 0x225
leaq 0x30032(%rip), %rcx     # 0x36926
callq 0x4150
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x5630
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x6938
callq 0x5700
movl $0x3d, %edi
callq 0x5660
callq 0x5700
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x5630
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ArtifexSoftware[P]mujs/pp.c
// Function: sblock
static void sblock(int d, js_Ast *list)
{
	ps("[\n");
	in(d+1);
	while (list) {
		assert(list->type == AST_LIST);
		snode(d+1, list->a);
		list = list->b;
		if (list) {
			nl();
			in(d+1);
		}
	}
	nl(); in(d); pc(']');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x2fff8(%rip), %rdi     # 0x3694e
callq 0x5600
movl -0x4(%rbp), %edi
addl $0x1, %edi
callq 0x55c0
cmpq $0x0, -0x10(%rbp)
je 0x69cf
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x6978
jmp 0x6997
leaq 0x2fde2(%rip), %rdi     # 0x36761
leaq 0x2fdf2(%rip), %rsi     # 0x36778
movl $0x344, %edx            # imm = 0x344
leaq 0x2ffbf(%rip), %rcx     # 0x36951
callq 0x4150
movl -0x4(%rbp), %edi
addl $0x1, %edi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x69f0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x69cd
callq 0x5530
movl -0x4(%rbp), %edi
addl $0x1, %edi
callq 0x55c0
jmp 0x6966
callq 0x5530
movl -0x4(%rbp), %edi
callq 0x55c0
movl $0x5d, %edi
callq 0x5660
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ArtifexSoftware[P]mujs/pp.c
// Function: slist
static void slist(int d, js_Ast *list)
{
	pc('[');
	while (list) {
		assert(list->type == AST_LIST);
		snode(d, list->a);
		list = list->b;
		if (list)
			pc(' ');
	}
	pc(']');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x5b, %edi
callq 0x5660
cmpq $0x0, -0x10(%rbp)
je 0x6ca9
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x6c5b
jmp 0x6c7a
leaq 0x2faff(%rip), %rdi     # 0x36761
leaq 0x2fb0f(%rip), %rsi     # 0x36778
movl $0x336, %edx            # imm = 0x336
leaq 0x2fcfd(%rip), %rcx     # 0x36972
callq 0x4150
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x69f0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6ca7
movl $0x20, %edi
callq 0x5660
jmp 0x6c49
movl $0x5d, %edi
callq 0x5660
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)