LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/Encryptr[P]O-plus-plus/opp/lexer/lexer.c
// Function: dump_tokens
void dump_tokens(struct Opp_Scan* s)
{
	do {
		opp_next(s);
		printf("%s:%d:%d ", s->io.fname, s->line, s->colum);
		if (s->t.id == TFLOAT)
			printf("FLOAT %lf\n", s->t.real);
		else if (s->t.id == TINTEGER)
			printf("INT %ld\n", s->t.num);
		else if (s->t.id == TIDENT)
			printf("IDENT %s\n", s->t.buffer.buf);
		else if (s->t.id == TSTR)
			printf("STRING \"%s\"\n", s->t.buffer.buf);
		else if (s->t.id > 5 && s->t.id <= 38)
			printf("CHAR %d\n", s->t.id);

	} while (s->t.id != FEND);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x24a9(%rip), %r14      # 0xc004
leaq 0x23b2(%rip), %r12      # 0xbf14
leaq 0x24b0(%rip), %r13      # 0xc019
leaq 0x249e(%rip), %rbp      # 0xc00e
leaq 0x24b5(%rip), %r15      # 0xc02c
movq %rbx, %rdi
callq 0x95cd
movq 0x10(%rbx), %rsi
movl 0x28(%rbx), %edx
movl 0x2c(%rbx), %ecx
movq %r14, %rdi
xorl %eax, %eax
callq 0x10e0
movl 0x30(%rbx), %esi
leal -0x1(%rsi), %eax
cmpl $0x4, %eax
ja 0x9be6
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq 0x38(%rbx), %rsi
leaq 0x2470(%rip), %rdi      # 0xc022
jmp 0x9bd5
movsd 0x48(%rbx), %xmm0
movq %rbp, %rdi
movb $0x1, %al
callq 0x10e0
jmp 0x9bdc
movq 0x48(%rbx), %rsi
movq %r13, %rdi
jmp 0x9bd5
movq 0x38(%rbx), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x10e0
movl 0x30(%rbx), %esi
cmpl $0x40, %esi
jne 0x9b77
jmp 0x9bfe
leal -0x6(%rsi), %eax
cmpl $0x20, %eax
ja 0x9bdf
leaq 0x2444(%rip), %rdi      # 0xc039
xorl %eax, %eax
callq 0x10e0
jmp 0x9bdc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/Encryptr[P]O-plus-plus/opp/env/env.c
// Function: hash_str
unsigned int hash_str(char *string, unsigned int size)
{
	unsigned int h = 0;
	while (*string) {
		h = ((h<<5)-h)^(unsigned char)*(string++);
	}
	h = h % size;
	
	return h;
}

// Assembly:
xorl %eax, %eax
movzbl (%rdi), %ecx
testl %ecx, %ecx
je 0x9c23
imull $0x1f, %eax, %eax
incq %rdi
xorl %ecx, %eax
jmp 0x9c12
xorl %edx, %edx
divl %esi
movl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/Encryptr[P]O-plus-plus/opp/env/env.c
// Function: init_namespace
struct Opp_Namespace* init_namespace(struct Opp_Namespace* parent, void* (*xmalloc)(size_t))
{
	struct Opp_Namespace* ns = (struct Opp_Namespace*)
		xmalloc(sizeof(struct Opp_Namespace));

	if (ns == NULL) 
		INTERNAL_ERROR("Malloc Fail");

	ns->xmalloc = xmalloc;
	ns->parent = parent;
	ns->items = (struct Opp_Bucket**)
		xmalloc(sizeof(struct Opp_Bucket*)*HASH_SIZE);

	if (ns->items == NULL)
		INTERNAL_ERROR("Malloc Fail");

	ns->size = HASH_SIZE;
	
	for (int i = 0; i < HASH_SIZE; i++)
		ns->items[i] = NULL;

	return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x20
popq %rdi
callq *%rsi
movq %rax, %rbx
testq %rax, %rax
jne 0x9c55
leaq 0x947(%rip), %rdi       # 0xa590
leaq 0x244c(%rip), %rsi      # 0xc09c
callq 0x9287
movq %r14, 0x18(%rbx)
movq %r15, 0x10(%rbx)
movl $0xa00, %edi            # imm = 0xA00
callq *%r14
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0x9c81
leaq 0x91b(%rip), %rdi       # 0xa590
leaq 0x2420(%rip), %rsi      # 0xc09c
callq 0x9287
movq $0x140, (%rbx)          # imm = 0x140
xorl %eax, %eax
cmpq $0x140, %rax            # imm = 0x140
je 0x9ca0
movq 0x8(%rbx), %rcx
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0x9c8a
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Encryptr[P]O-plus-plus/opp/env/env.c
// Function: env_add_item
struct Opp_Bucket* env_add_item(struct Opp_Namespace* ns, char* name)
{
	unsigned int loc = hash_str(name, ns->size);

	if (ns->items[loc] != NULL) {
		struct Opp_Bucket* pos = ns->items[loc];

		while (pos) {
			if (!strcmp(pos->key, name)) 
				return NULL;
			else if (pos->next == NULL) {
				pos->next = (struct Opp_Bucket*)
					ns->xmalloc(sizeof(struct Opp_Bucket));

				if (!pos->next)
					INTERNAL_ERROR("Malloc fail");

				pos->next->key = name;
				pos->next->next = NULL;
				return pos->next;
			}
			else
				pos = pos->next;
		}
	}
	else {
		struct Opp_Bucket* node = (struct Opp_Bucket*)
			ns->xmalloc(sizeof(struct Opp_Bucket));

		if (node == NULL)
			INTERNAL_ERROR("Malloc fail");

		node->key = name;
		node->next = NULL;
		ns->items[loc] = node;

		return node;
	}

	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %esi
movq %rbx, %rdi
callq 0x9c10
movq 0x8(%r14), %rcx
movl %eax, %r12d
movq (%rcx,%r12,8), %rax
testq %rax, %rax
je 0x9d28
xorl %r15d, %r15d
movq %rax, %r12
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x1140
testl %eax, %eax
je 0x9d5a
movq 0x30(%r12), %rax
testq %rax, %rax
jne 0x9cd4
pushq $0x38
popq %rdi
callq *0x18(%r14)
movq %rax, 0x30(%r12)
testq %rax, %rax
jne 0x9d19
leaq 0x31f(%rip), %rdi       # 0xa027
leaq 0x239c(%rip), %rsi      # 0xc0ab
callq 0x9287
movq 0x30(%r12), %rax
movq %rbx, (%rax)
andq $0x0, 0x30(%rax)
movq 0x30(%r12), %r15
jmp 0x9d5a
pushq $0x38
popq %rdi
callq *0x18(%r14)
movq %rax, %r15
testq %rax, %rax
jne 0x9d4a
leaq 0x2e9(%rip), %rdi       # 0xa027
leaq 0x2366(%rip), %rsi      # 0xc0ab
callq 0x9287
movq %rbx, (%r15)
andq $0x0, 0x30(%r15)
movq 0x8(%r14), %rax
movq %r15, (%rax,%r12,8)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Encryptr[P]O-plus-plus/opp/env/env.c
// Function: env_get_item
struct Opp_Bucket* env_get_item(struct Opp_Namespace* ns, char* name)
{
	unsigned int loc = hash_str(name, ns->size);

	struct Opp_Namespace* scope = ns;

	while (scope != NULL)
	{
		if (scope->items[loc] != NULL) 
		{
			struct Opp_Bucket* node = scope->items[loc];

			while (node) {
				if (!strcmp(node->key, name)) 
					return node;
				else if (node->next != NULL)
					node = node->next;
				else 
					break;
			}
		}
		scope = scope->parent;
	}

	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %esi
movq %rbx, %rdi
callq 0x9c10
movl %eax, %r12d
testq %r14, %r14
je 0x9db1
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %r15
testq %r15, %r15
je 0x9dab
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x1140
testl %eax, %eax
je 0x9db4
movq 0x30(%r15), %r15
jmp 0x9d91
movq 0x10(%r14), %r14
jmp 0x9d84
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/dxwc[P]sfeed/sfeed_mbox.c
// Function: main
int
main(int argc, char *argv[])
{
	struct tm tm;
	time_t t;
	FILE *fp;
	char *name;
	int i;

	if (pledge(argc == 1 ? "stdio" : "stdio rpath", NULL) == -1)
		err(1, "pledge");

	if (!(user = getenv("USER")))
		user = "you";
	if (gethostname(host, sizeof(host)) == -1)
		err(1, "gethostname");
	if ((t = time(NULL)) == -1)
		err(1, "time");
	if (!gmtime_r(&t, &tm))
		errx(1, "gmtime_r: can't get current time");
	if (!strftime(mtimebuf, sizeof(mtimebuf), "%a %b %d %H:%M:%S %Y", &tm))
		errx(1, "strftime: can't format current time");

	if (argc == 1) {
		printfeed(stdin, "");
	} else {
		for (i = 1; i < argc; i++) {
			if (!(fp = fopen(argv[i], "r")))
				err(1, "fopen: %s", argv[i]);
			name = ((name = strrchr(argv[i], '/'))) ? name + 1 : argv[i];
			printfeed(fp, name);
			if (ferror(fp))
				err(1, "ferror: %s", argv[i]);
			fclose(fp);
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xcde(%rip), %rdi       # 0x2004
callq 0x1030
testq %rax, %rax
leaq 0xcd4(%rip), %rcx       # 0x2009
cmovneq %rax, %rcx
movq %rcx, 0x2df0(%rip)      # 0x4130
leaq 0x2df9(%rip), %rdi      # 0x4140
movl $0x100, %esi            # imm = 0x100
callq 0x11e0
cmpl $-0x1, %eax
je 0x145d
xorl %edi, %edi
callq 0x1170
movq %rax, 0x8(%rsp)
cmpq $-0x1, %rax
je 0x1466
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x10e0
testq %rax, %rax
je 0x1477
leaq 0x2eb1(%rip), %rdi      # 0x4240
leaq 0xca4(%rip), %rdx       # 0x203a
pushq $0x20
popq %rsi
leaq 0x10(%rsp), %rcx
callq 0x11a0
testq %rax, %rax
je 0x1480
cmpl $0x1, %ebp
jne 0x13d8
movq 0x2c28(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
leaq 0xd7b(%rip), %rsi       # 0x213d
callq 0x1491
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq %ebp, %r14
pushq $0x1
popq %r13
pushq $0x2f
popq %rbp
cmpq %r14, %r13
jge 0x13c7
movq (%rbx,%r13,8), %rdi
leaq 0xc81(%rip), %rsi       # 0x2073
callq 0x11b0
movq (%rbx,%r13,8), %r12
testq %rax, %rax
je 0x1439
movq %rax, %r15
movq %r12, %rdi
movl %ebp, %esi
callq 0x10d0
leaq 0x1(%rax), %rsi
testq %rax, %rax
cmoveq %r12, %rsi
movq %r15, %rdi
callq 0x1491
movq %r15, %rdi
callq 0x1060
testl %eax, %eax
jne 0x1448
movq %r15, %rdi
callq 0x1070
incq %r13
jmp 0x13e2
leaq 0xc35(%rip), %rsi       # 0x2075
pushq $0x1
popq %rdi
movq %r12, %rdx
jmp 0x1456
movq (%rbx,%r13,8), %rdx
leaq 0xc2c(%rip), %rsi       # 0x207f
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x1190
leaq 0xba9(%rip), %rsi       # 0x200d
jmp 0x146d
leaq 0xc01(%rip), %rsi       # 0x206e
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x1190
leaq 0xb9b(%rip), %rsi       # 0x2019
jmp 0x1487
leaq 0xbc8(%rip), %rsi       # 0x204f
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x1090
// File: /workspace/github_c_makefile_star2_O2/teodorst[P]app-huffman/huffman_decodification_pthreads.c
// Function: open_file
FILE* open_file(char *filename, char *mode) {
    FILE* fp;
    fp = fopen(filename, mode);
    if (fp == NULL)
        exit(EXIT_FAILURE);

    return fp;
}

// Assembly:
pushq %rax
callq 0x1170
testq %rax, %rax
je 0x12e9
popq %rcx
retq
pushq $0x1
popq %rdi
callq 0x11a0
// File: /workspace/github_c_makefile_star2_O2/teodorst[P]app-huffman/huffman_decodification_pthreads.c
// Function: decodification_thread
void *decodification_thread(void *huffman_info_thread) {
    huffman_thread_struct* thread_arg = (huffman_thread_struct*) huffman_info_thread;
    int id = thread_arg->thread_id;

    int index_input = thread_arg->input_indexes[id];
    int thread_size_output = thread_arg->output_buffer_size / NUM_THREADS;
    int index_output = id * thread_size_output;
    unsigned long long int nbits = thread_arg->nbits_buffer[id];
    
    char *input_buffer = thread_arg->input_buffer;
    char *output_buffer = thread_arg->output_buffer;

    printf("Hy! %d start %d, size %d !\n", id, index_input, index_output);

    decode_bytes_for_chunk_pthreads(thread_arg->root, input_buffer + index_input, nbits, output_buffer + index_output);

    pthread_exit(NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq (%rdi), %rsi
movq 0x10(%rdi), %rax
movslq (%rax,%rsi,4), %r8
movl 0x20(%rdi), %eax
pushq $0x4
popq %rcx
cltd
idivl %ecx
imull %esi, %eax
movq 0x28(%rdi), %rcx
movq %r8, %r14
addq 0x8(%rdi), %r14
movq (%rcx,%rsi,8), %r15
movslq %eax, %rcx
movq 0x18(%rdi), %r12
addq %rcx, %r12
leaq 0x1cd1(%rip), %rdi      # 0x3004
movl %r8d, %edx
xorl %eax, %eax
callq 0x10a0
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x176e
xorl %edi, %edi
callq 0x1110
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
cmpl $0x4, %edi
je 0x15ab
leaq 0x1af2(%rip), %rdi      # 0x3080
callq 0x1060
leaq 0x1af4(%rip), %rdi      # 0x308e
callq 0x1060
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rsi, %rbx
movq 0x3a43(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq 0x8(%rsi), %rdx
movq 0x10(%rsi), %rcx
movq 0x18(%rsi), %r8
leaq 0x1a8f(%rip), %rsi      # 0x305a
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x10f0
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
callq 0x1356
jmp 0x15a2
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
leaq 0x4(%rsp), %rbx
andl $0x0, (%rbx)
leaq 0xea5(%rip), %r14       # 0x2024
movq %r14, %rdi
callq 0x1040
leaq 0xe76(%rip), %rdi       # 0x2004
callq 0x1040
movq %r14, %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x122c
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
pushq $0xa
popq %rdi
callq 0x1030
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
xorl %eax, %eax
callq 0x11d8
movq %rsp, %r12
movl %eax, 0x8(%r12)
leaq 0xe0a(%rip), %rax       # 0x205b
movq %rax, 0x10(%r12)
xorl %eax, %eax
callq 0x11db
movl %eax, 0x18(%r12)
leaq 0xe09(%rip), %rax       # 0x2072
movq %rax, 0x20(%r12)
xorl %eax, %eax
callq 0x11d8
movl %eax, %ebp
xorl %eax, %eax
callq 0x11db
addl %ebp, %eax
pushq $0x2
popq %rcx
cltd
idivl %ecx
movl %eax, 0x28(%r12)
andq $0x0, 0x30(%r12)
andl $0x0, 0x38(%r12)
leaq 0xda6(%rip), %rdx       # 0x2044
leaq 0xde7(%rip), %r14       # 0x208c
leaq 0xe2a(%rip), %r15       # 0x20d6
testq %rdx, %rdx
je 0x131d
movl (%rbx), %esi
incl %esi
movl %esi, (%rbx)
movq %r14, %rdi
xorl %eax, %eax
callq 0x1050
xorl %eax, %eax
callq 0x11bc
movl 0x8(%r12), %edi
callq 0x11e1
movl 0x8(%r12), %edi
callq 0x1211
testl %eax, %eax
je 0x1349
xorl %eax, %eax
callq 0x11d8
movl %eax, %ebp
xorl %eax, %eax
callq 0x11db
cmpl %eax, %ebp
jg 0x130a
cmpl 0x8(%r12), %ebp
je 0x1306
movl %ebp, %edi
callq 0x1211
testl %eax, %eax
jne 0x132c
incl %ebp
jmp 0x12e9
movq %r15, %rdi
callq 0x1040
movq 0x10(%r12), %rdx
addq $0x10, %r12
jmp 0x12ac
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd98(%rip), %rdi       # 0x20cb
leaq 0xd6c(%rip), %rsi       # 0x20a6
leaq 0xd73(%rip), %rcx       # 0x20b4
pushq $0x29
popq %rdx
callq 0x1060
leaq 0xd47(%rip), %rdi       # 0x2097
leaq 0xd4f(%rip), %rsi       # 0x20a6
leaq 0xd56(%rip), %rcx       # 0x20b4
pushq $0x25
jmp 0x1343
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x2, %edi
jl 0x11c6
movl %edi, %r13d
pushq $0x1
popq %rbp
leaq 0xea3(%rip), %r15       # 0x201f
pushq $0x1a
popq %r12
movq %rbp, %r14
cmpq %r14, %r13
je 0x11b5
movq (%rbx,%r14,8), %rdi
callq 0x1030
cmpl $-0x1, %eax
je 0x119b
incq %r14
jmp 0x1183
movq 0x2e56(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x1050
jmp 0x1196
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2e2b(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq (%rbx), %rdx
leaq 0xe2a(%rip), %rsi       # 0x2004
xorl %eax, %eax
callq 0x1040
pushq $0x1
popq %rax
jmp 0x11b7
// File: /workspace/github_c_makefile_star2_O2/phluid61[P]hsf/main.c
// Function: do_sh_bareitem
void do_sh_bareitem(SH_BareItem* obj) {
	SH_Item_type t;
	sh_char_t* s;
	void* x;

	int err = 0;

	t = SH_BareItem__type(obj, 0);
	printf("    - type =: %u\n", (unsigned int)t);

	x = (void*)SH_BareItem__get_integer(obj, &err);
	printf("    o get_integer: [%llX] 0x%08X\n", (long long)x, err);
	err = 0;

	x = (void*)SH_BareItem__get_decimal(obj, &err);
	printf("    o get_decimal: [%llX] 0x%08X\n", (long long)x, err);
	err = 0;

	x = (void*)SH_BareItem__get_string(obj, &err);
	printf("    o get_string: [%llX] 0x%08X\n", (long long)x, err);
	err = 0;

	x = (void*)SH_BareItem__get_token(obj, &err);
	printf("    o get_token: [%llX] 0x%08X\n", (long long)x, err);
	err = 0;

	x = (void*)SH_BareItem__get_bytesequence(obj, &err);
	printf("    o get_bytesequence: [%llX] 0x%08X\n", (long long)x, err);
	err = 0;

	x = (void*)SH_BareItem__get_boolean(obj, &err);
	printf("    o get_boolean: [%llX] 0x%08X\n", (long long)x, err);
	err = 0;

	s = SH_BareItem__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);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x4(%rsp), %rbx
andl $0x0, (%rbx)
xorl %esi, %esi
callq 0x39af
leaq 0x3e46(%rip), %rdi      # 0x502c
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %r14, %rdi
movq %rbx, %rsi
callq 0x39b2
movl (%rbx), %edx
leaq 0x3e3b(%rip), %rdi      # 0x503e
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
andl $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x39d9
movl (%rbx), %edx
leaq 0x3e3c(%rip), %rdi      # 0x5060
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
andl $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3a00
movl (%rbx), %edx
leaq 0x3e3d(%rip), %rdi      # 0x5082
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
andl $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3a27
movl (%rbx), %edx
leaq 0x3e3d(%rip), %rdi      # 0x50a3
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
andl $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3a4e
movl (%rbx), %edx
leaq 0x3e3c(%rip), %rdi      # 0x50c3
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
andl $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3a75
movl (%rbx), %edx
leaq 0x3e42(%rip), %rdi      # 0x50ea
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
andl $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3ac3
movq %rax, %r14
testq %rax, %rax
sete %al
movl (%rbx), %edx
testl %edx, %edx
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x12ea
leaq 0x3e2e(%rip), %rdi      # 0x510c
movq %r14, %rsi
xorl %eax, %eax
callq 0x1060
jmp 0x1306
leaq 0x44dd(%rip), %rdi      # 0x57ce
callq 0x1040
movq %r14, %rdi
callq 0x130e
movq %r14, %rdi
callq 0x1030
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/phluid61[P]hsf/main.c
// Function: hexdump_string
void hexdump_string(const sh_char_t* str) {
	sh_char_t* ptr = (sh_char_t*)str;
	int n = 0;
	int i, j;
	char line[HEXDUMP_LEN];

	if ((sh_char_t*)0 == ptr) {
		printf("NULL\n");
		return;
	}
	if (SH_CHAR_C(0) == *ptr) {
		printf("\"\"\n");
		return;
	}

	printf("%s\n", hexdump_rule);

	while (SH_CHAR_C(0) != *ptr) {
		if (n == 0) {
			memcpy((void*)line, (const void*)hexdump_line, sizeof(char)*74);
			i = 2;
			j = 54;
		}
		if (n == 8) {
			i += 2;
			j ++;
		}

		line[i++] = hexdump_char[((*ptr) & 0xF0) >> 4];
		line[i++] = hexdump_char[ (*ptr) & 0x0F];
		i++;

		if (*ptr >= SH_CHAR_C(0x20) && *ptr < SH_CHAR_C(0x7F)) {
			line[j++] = (char)(*ptr);
		} else {
			line[j++] = '.';
		}

		ptr++;
		n++;
		if (n == 16) {
			printf("%s\n", line);
			n = 0;
		}
	}

	if (n != 0) {
		printf("%s\n", line);
	}

	printf("%s\n", hexdump_rule);
}

// Assembly:
testq %rdi, %rdi
je 0x13f1
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x13fd
leaq 0x4538(%rip), %rdi      # 0x5870
callq 0x1040
xorl %eax, %eax
movq %rsp, %r13
leaq 0x45c7(%rip), %r15      # 0x5910
pushq $0x2e
popq %r12
movzbl (%r14), %edx
testq %rdx, %rdx
je 0x13dc
testl %eax, %eax
jne 0x1377
pushq $0x4a
popq %rcx
movq %r13, %rdi
leaq 0x4555(%rip), %rsi      # 0x58c0
rep  movsb (%rsi), %es:(%rdi)
pushq $0x2
popq %rcx
movl %ecx, %ebx
pushq $0x36
popq %rcx
movl %ecx, %ebp
leal 0x2(%rbx), %esi
xorl %ecx, %ecx
cmpl $0x8, %eax
sete %cl
cmovnel %ebx, %esi
leal (%rcx,%rbp), %edi
movl %edx, %r8d
shrl $0x4, %r8d
movb (%r8,%r15), %r8b
movslq %esi, %rbx
movb %r8b, (%rsp,%rbx)
movl %edx, %esi
andl $0xf, %esi
movb (%rsi,%r15), %sil
movb %sil, 0x1(%rsp,%rbx)
addl $0x3, %ebx
leal -0x20(%rdx), %esi
cmpb $0x5f, %sil
movslq %edi, %rsi
movl %r12d, %edi
cmovbl %edx, %edi
movb %dil, (%rsp,%rsi)
addl %ecx, %ebp
incl %ebp
incq %r14
incl %eax
cmpl $0x10, %eax
jne 0x134d
movq %r13, %rdi
callq 0x1040
xorl %eax, %eax
jmp 0x134d
testl %eax, %eax
je 0x13e8
movq %rsp, %rdi
callq 0x1040
leaq 0x4481(%rip), %rdi      # 0x5870
jmp 0x1404
leaq 0x43e7(%rip), %rdi      # 0x57df
jmp 0x1040
leaq 0x43d8(%rip), %rdi      # 0x57dc
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
leaq 0x4(%rsp), %r14
andl $0x0, (%r14)
leaq 0x43b9(%rip), %rdi      # 0x57e4
callq 0x1040
movq %r14, %rdi
callq 0x368c
movq %rax, %rbx
testq %rax, %rax
sete %al
movl (%r14), %edx
testl %edx, %edx
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x1463
leaq 0x3cda(%rip), %rdi      # 0x5131
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1060
jmp 0x1488
leaq 0x3cf6(%rip), %rdi      # 0x5160
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x11c9
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x38c6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/phluid61[P]hsf/main.c
// Function: do_sh_integer
void do_sh_integer(sh_int_t value) {
	SH_Integer* obj;
	SH_BareItem* bi;

	sh_int_t i;
	sh_bool_t b;
	sh_char_t* s;

	int err = 0;

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

		i = SH_Integer__int(obj, 0);
		printf("  - int =: %lld\n", (long long)i);

		b = SH_Integer__negative(obj, 0);
		printf("  - negative =: %hhu\n", (unsigned char)b);

		i = SH_Integer__abs(obj, 0);
		printf("  - abs =: %lld\n", (long long)i);

		s = SH_Integer__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_integer(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_Integer__destroy(obj, 0);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0xc(%rsp), %r15
andl $0x0, (%r15)
movq %r15, %rsi
callq 0x28b0
movq %rax, %rbx
testq %rax, %rax
sete %al
movl (%r15), %ecx
testl %ecx, %ecx
setne %dl
orb %al, %dl
cmpb $0x1, %dl
jne 0x14de
leaq 0x3cb2(%rip), %rdi      # 0x517e
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1060
jmp 0x1604
leaq 0x3ccb(%rip), %rdi      # 0x51b0
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
callq 0x294f
leaq 0x3cce(%rip), %rdi      # 0x51d1
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2960
movzbl %al, %esi
leaq 0x3cc1(%rip), %rdi      # 0x51e2
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2975
leaq 0x3cbf(%rip), %rdi      # 0x51f8
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2997
movq %rax, %r14
testq %rax, %rax
sete %al
movl (%r15), %edx
testl %edx, %edx
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x157e
leaq 0x3b9c(%rip), %rdi      # 0x510e
movq %r14, %rsi
xorl %eax, %eax
callq 0x1060
jmp 0x159a
leaq 0x424b(%rip), %rdi      # 0x57d0
callq 0x1040
movq %r14, %rdi
callq 0x130e
movq %r14, %rdi
callq 0x1030
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x36c7
movq %rax, %r14
testq %rax, %rax
sete %al
movl (%r15), %edx
testl %edx, %edx
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x15d5
leaq 0x3b68(%rip), %rdi      # 0x5131
movq %r14, %rsi
xorl %eax, %eax
callq 0x1060
jmp 0x15fa
leaq 0x3b84(%rip), %rdi      # 0x5160
movq %r14, %rsi
xorl %eax, %eax
callq 0x1060
movq %r14, %rdi
callq 0x11c9
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x38c6
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2933
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/phluid61[P]hsf/main.c
// Function: do_sh_token
void do_sh_token(sh_char_t* value, size_t n) {
	SH_Token* obj;
	SH_BareItem* bi;

	/* used to printf() value, looks like "%#{n}s" */
	char template[8];

	sh_char_t* s;

	int err = 0;

	snprintf(template, 8, "%%%lus", n);

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

		s = SH_Token__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_token(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_Token__destroy(obj, 0);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4(%rsp), %rbx
andl $0x0, (%rbx)
leaq 0x392d(%rip), %rdx      # 0x52b6
leaq 0x8(%rsp), %rdi
pushq $0x8
popq %rsi
movq %r14, %rcx
xorl %eax, %eax
callq 0x1070
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2e80
movq %rax, %rbx
testq %rax, %rax
je 0x1a24
cmpl $0x0, 0x4(%rsp)
jne 0x1a24
leaq 0x3986(%rip), %rdi      # 0x5345
xorl %eax, %eax
callq 0x1060
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1060
leaq 0x3929(%rip), %rdi      # 0x5305
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1060
leaq 0x4(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2fed
movq %rax, %r14
testq %rax, %rax
sete %al
movl (%r15), %edx
testl %edx, %edx
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x1a5e
leaq 0x36f6(%rip), %rdi      # 0x510e
movq %r14, %rsi
xorl %eax, %eax
callq 0x1060
jmp 0x1a7a
leaq 0x38fe(%rip), %rdi      # 0x5329
xorl %eax, %eax
callq 0x1060
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1060
movl 0x4(%rsp), %ecx
leaq 0x388e(%rip), %rdi      # 0x52da
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1060
jmp 0x1ae4
leaq 0x3d6b(%rip), %rdi      # 0x57d0
callq 0x1040
movq %r14, %rdi
callq 0x130e
movq %r14, %rdi
callq 0x1030
leaq 0x4(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x37a2
movq %rax, %r14
testq %rax, %rax
sete %al
movl (%r15), %edx
testl %edx, %edx
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x1ab5
leaq 0x3688(%rip), %rdi      # 0x5131
movq %r14, %rsi
xorl %eax, %eax
callq 0x1060
jmp 0x1ada
leaq 0x36a4(%rip), %rdi      # 0x5160
movq %r14, %rsi
xorl %eax, %eax
callq 0x1060
movq %r14, %rdi
callq 0x11c9
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x38c6
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2fa6
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
leaq 0xc(%rsp), %rdx
andl $0x0, (%rdx)
callq 0x3054
movq %rax, %rbx
testq %rax, %rax
je 0x1b8e
cmpl $0x0, 0xc(%rsp)
jne 0x1b8e
leaq 0x3878(%rip), %rdi      # 0x5395
xorl %eax, %eax
callq 0x1060
leaq 0x3886(%rip), %rdi      # 0x53b1
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
callq 0x313d
movzwl %ax, %esi
leaq 0x37ca(%rip), %rdi      # 0x5316
xorl %eax, %eax
callq 0x1060
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x314f
movq %rax, %r14
testq %rax, %rax
sete %al
movl (%r15), %edx
testl %edx, %edx
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x1bb9
leaq 0x358c(%rip), %rdi      # 0x510e
movq %r14, %rsi
xorl %eax, %eax
callq 0x1060
jmp 0x1bd5
leaq 0x37c2(%rip), %rdi      # 0x5357
xorl %eax, %eax
callq 0x1060
movl 0xc(%rsp), %ecx
leaq 0x37d6(%rip), %rdi      # 0x537d
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1060
jmp 0x1c3f
leaq 0x3c10(%rip), %rdi      # 0x57d0
callq 0x1040
movq %r14, %rdi
callq 0x130e
movq %r14, %rdi
callq 0x1030
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x37eb
movq %rax, %r14
testq %rax, %rax
sete %al
movl (%r15), %edx
testl %edx, %edx
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x1c10
leaq 0x352d(%rip), %rdi      # 0x5131
movq %r14, %rsi
xorl %eax, %eax
callq 0x1060
jmp 0x1c35
leaq 0x3549(%rip), %rdi      # 0x5160
movq %r14, %rsi
xorl %eax, %eax
callq 0x1060
movq %r14, %rdi
callq 0x11c9
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x38c6
movq %rbx, %rdi
xorl %esi, %esi
callq 0x30f6
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/phluid61[P]hsf/main.c
// Function: do_sh_boolean
void do_sh_boolean(sh_bool_t value) {
	SH_Boolean* obj;
	SH_BareItem* bi;

	sh_bool_t b;
	sh_char_t* s;

	int err = 0;

	obj = SH_Boolean__init(value, &err);
	if ((SH_Boolean*)0 == obj || err) {
		printf("* unable to init SH_Boolean(%hhu): [%llX] 0x%08X\n", (unsigned char)value, (long long)obj, err);
	} else {
		printf("+ init SH_Boolean(%hhu): [%llX]\n", (unsigned char)value, (long long)obj);

		b = SH_Boolean__bool(obj, 0);
		printf("  - bool =: %hhu\n", b);

		b = SH_Boolean__true(obj, 0);
		printf("  - true =: %hhu\n", b);

		b = SH_Boolean__false(obj, 0);
		printf("  - false =: %hhu\n", b);

		s = SH_Boolean__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_boolean(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_Boolean__destroy(obj, 0);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebp
leaq 0x4(%rsp), %r14
andl $0x0, (%r14)
movq %r14, %rsi
callq 0x3268
movq %rax, %rbx
testq %rax, %rax
sete %al
movl (%r14), %ecx
testl %ecx, %ecx
setne %dl
orb %al, %dl
cmpb $0x1, %dl
jne 0x1c93
leaq 0x3740(%rip), %rdi      # 0x53c2
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1060
jmp 0x1db8
leaq 0x375a(%rip), %rdi      # 0x53f4
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
callq 0x32d0
movzbl %al, %esi
leaq 0x375b(%rip), %rdi      # 0x5415
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
callq 0x32e0
movzbl %al, %esi
leaq 0x3752(%rip), %rdi      # 0x5427
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
callq 0x32f4
movzbl %al, %esi
leaq 0x3749(%rip), %rdi      # 0x5439
xorl %eax, %eax
callq 0x1060
leaq 0x4(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3309
movq %rax, %r14
testq %rax, %rax
sete %al
movl (%r15), %edx
testl %edx, %edx
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x1d32
leaq 0x33e8(%rip), %rdi      # 0x510e
movq %r14, %rsi
xorl %eax, %eax
callq 0x1060
jmp 0x1d4e
leaq 0x3a97(%rip), %rdi      # 0x57d0
callq 0x1040
movq %r14, %rdi
callq 0x130e
movq %r14, %rdi
callq 0x1030
leaq 0x4(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3834
movq %rax, %r14
testq %rax, %rax
sete %al
movl (%r15), %edx
testl %edx, %edx
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x1d89
leaq 0x33b4(%rip), %rdi      # 0x5131
movq %r14, %rsi
xorl %eax, %eax
callq 0x1060
jmp 0x1dae
leaq 0x33d0(%rip), %rdi      # 0x5160
movq %r14, %rsi
xorl %eax, %eax
callq 0x1060
movq %r14, %rdi
callq 0x11c9
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x38c6
movq %rbx, %rdi
xorl %esi, %esi
callq 0x32b4
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rsi
andl $0x0, (%rsi)
callq 0x3e3d
testq %rax, %rax
je 0x1def
movq %rax, %rbx
movq %rax, %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x1030
jmp 0x1e01
movl 0xc(%rsp), %esi
leaq 0x3652(%rip), %rdi      # 0x544c
xorl %eax, %eax
callq 0x1060
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
andl $0x0, (%r14)
callq 0x1dc3
leaq 0x3632(%rip), %rdi      # 0x545a
pushq $0x4
popq %rsi
movq %r14, %rdx
callq 0x3fb4
movq %rax, %r15
xorl %edi, %edi
movq %r14, %rsi
callq 0x3268
movq %rax, %rdi
movq %r14, %rsi
callq 0x3834
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x3b84
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x3cb5
movq %rbx, %rdi
callq 0x1dc3
leaq 0x35e7(%rip), %rdi      # 0x545f
pushq $0x2
popq %rsi
movq %r14, %rdx
callq 0x3fb4
movq %rax, %r15
movl $0xff, %edi
movq %r14, %rsi
callq 0x3268
movq %rax, %rdi
movq %r14, %rsi
callq 0x3834
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x3b84
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x3cb5
movq %rbx, %rdi
callq 0x1dc3
leaq 0x3597(%rip), %rdi      # 0x5462
pushq $0x5
popq %rsi
movq %r14, %rdx
callq 0x3fb4
movq %rax, %r15
movl $0x4d2, %edi            # imm = 0x4D2
movq %r14, %rsi
callq 0x28b0
movq %rax, %rdi
movq %r14, %rsi
callq 0x36c7
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x3b84
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x3cb5
movq %rbx, %rdi
callq 0x1dc3
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
andl $0x0, (%r14)
movq 0x2000(%rdi), %rsi
leaq 0x3389(%rip), %rdi      # 0x5626
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
movq %r14, %rsi
callq 0x48e7
movq %rax, %rbx
testq %rax, %rax
sete %al
movl (%r14), %edx
testl %edx, %edx
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x22da
leaq 0x2e40(%rip), %rdi      # 0x510e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1060
jmp 0x22f6
leaq 0x34ef(%rip), %rdi      # 0x57d0
callq 0x1040
movq %rbx, %rdi
callq 0x130e
movq %rbx, %rdi
callq 0x1030
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
andl $0x0, (%r14)
movq 0x800(%rdi), %rsi
leaq 0x3113(%rip), %rdi      # 0x5626
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
movq %r14, %rsi
callq 0x358b
movq %rax, %rbx
testq %rax, %rax
sete %al
movl (%r14), %edx
testl %edx, %edx
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x2550
leaq 0x2bca(%rip), %rdi      # 0x510e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1060
jmp 0x256c
leaq 0x3279(%rip), %rdi      # 0x57d0
callq 0x1040
movq %rbx, %rdi
callq 0x130e
movq %rbx, %rdi
callq 0x1030
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x28e9
cmpl $0x0, (%rbx)
jne 0x2905
movabsq $-0x38d7ea4c68000, %rax # imm = 0xFFFC72815B398000
addq %r14, %rax
movabsq $-0x71afd498cffff, %rcx # imm = 0xFFF8E502B6730001
cmpq %rcx, %rax
jae 0x2909
movl $0x110001, %ecx         # imm = 0x110001
xorl %eax, %eax
jmp 0x2929
movabsq $-0x38d7ea4c68000, %rax # imm = 0xFFFC72815B398000
addq %r14, %rax
movabsq $-0x71afd498cffff, %rcx # imm = 0xFFF8E502B6730001
cmpq %rcx, %rax
jae 0x2909
xorl %eax, %eax
jmp 0x292b
pushq $0x8
popq %rdi
callq 0x10a0
testq %rax, %rax
je 0x291d
xorl %ecx, %ecx
movq %r14, (%rax)
jmp 0x2924
movl $0x80000001, %ecx       # imm = 0x80000001
xorl %eax, %eax
testq %rbx, %rbx
je 0x292b
movl %ecx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rsi, %rsi
je 0x2982
cmpl $0x0, (%rsi)
je 0x2987
xorl %eax, %eax
retq
movq (%rdi), %rax
jmp 0x298d
movq (%rdi), %rax
andl $0x0, (%rsi)
testq %rax, %rax
js 0x2993
retq
negq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/phluid61[P]hsf/src/integer.c
// Function: SH_Integer__to_s
sh_char_t*
SH_Integer__to_s(SH_Integer* obj, int* err) {
	sh_char_t* str;
	sh_char_t* ptr;
	sh_char_t  buffer[17]; /* sign(1) + digits(15) + null(1) */
	size_t n;
	sh_int_t v;

	__cascade(err, (sh_char_t*)0);

	if (obj->value == SH_INT_C(0)) {
		str = (sh_char_t*)malloc(sizeof(sh_char_t) * 2);
		if ((sh_char_t*)0 == str) {
			__raise(err, SH_E_MALLOC_ERROR);
			return (sh_char_t*)0;
		}

		str[0] = (sh_char_t)'0';
		str[1] = SH_CHAR_C(0);
		__clear(err);
		return str;
	}

	n = 0;
	v = SH_Integer__abs(obj, err);

	buffer[n++] = SH_CHAR_C(0);

	while (v > SH_INT_C(0) && n <= 16) {
		buffer[n++] = (sh_char_t)(v % 10) + (sh_char_t)'0';
		v /= SH_INT_C(10);
	}

	/* FIXME: if v > 0: invalid state? */

	if (SH_Integer__negative(obj, err)) {
		buffer[n++] = (sh_char_t)'-';
	}

	str = (sh_char_t*)malloc(sizeof(sh_char_t) * n);
	if ((sh_char_t*)0 == str) {
		__raise(err, SH_E_MALLOC_ERROR);
		return (sh_char_t*)0;
	}

	ptr = str;
	while (n > 0) {
		n--;
		*ptr = buffer[n];
		ptr++;
	}

	__clear(err);
	return str;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r15
testq %rsi, %rsi
je 0x29b7
cmpl $0x0, (%rbx)
je 0x29b7
xorl %eax, %eax
jmp 0x2a59
cmpq $0x0, (%r15)
je 0x2a30
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2975
movb $0x0, (%rsp)
pushq $0x1
popq %r14
pushq $0xa
popq %rcx
testq %rax, %rax
jle 0x29ef
cmpq $0x10, %r14
ja 0x29ef
xorl %edx, %edx
divq %rcx
orb $0x30, %dl
movb %dl, (%rsp,%r14)
incq %r14
jmp 0x29d3
testq %rbx, %rbx
je 0x29f9
cmpl $0x0, (%rbx)
jne 0x2a07
cmpq $0x0, (%r15)
jns 0x2a07
movb $0x2d, (%rsp,%r14)
incq %r14
movq %r14, %rdi
callq 0x10a0
testq %rax, %rax
je 0x2a4b
movq %rax, %rcx
movq %r14, %rdx
subq $0x1, %rdx
jb 0x2a42
movb -0x1(%rsp,%r14), %sil
movb %sil, (%rcx)
incq %rcx
movq %rdx, %r14
jmp 0x2a1a
pushq $0x2
popq %rdi
callq 0x10a0
testq %rax, %rax
je 0x2a4b
movw $0x30, (%rax)
testq %rbx, %rbx
je 0x2a59
xorl %ecx, %ecx
jmp 0x2a57
movl $0x80000001, %ecx       # imm = 0x80000001
xorl %eax, %eax
testq %rbx, %rbx
je 0x2a59
movl %ecx, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
testq %rdx, %rdx
je 0x2d23
cmpl $0x0, (%rbx)
jne 0x2d2c
cmpq $0x400, %r15            # imm = 0x400
jbe 0x2d31
movl $0x130001, %eax         # imm = 0x130001
xorl %r14d, %r14d
jmp 0x2da0
cmpq $0x400, %r15            # imm = 0x400
jbe 0x2d31
xorl %r14d, %r14d
jmp 0x2da2
xorl %eax, %eax
cmpq %rax, %r15
je 0x2d49
movb (%r12,%rax), %cl
addb $-0x20, %cl
cmpb $0x5e, %cl
ja 0x2d8c
incq %rax
jmp 0x2d33
pushq $0x10
popq %rdi
callq 0x10a0
testq %rax, %rax
je 0x2d93
movq %rax, %r14
leaq 0x1(%r15), %rsi
pushq $0x1
popq %rdi
callq 0x1080
movq %rax, (%r14)
testq %rax, %rax
je 0x2daf
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1090
xorl %eax, %eax
movb $0x0, (%r13,%r15)
movq %r15, 0x8(%r14)
jmp 0x2d9b
movl $0x130002, %eax         # imm = 0x130002
jmp 0x2d98
movl $0x80000001, %eax       # imm = 0x80000001
xorl %r14d, %r14d
testq %rbx, %rbx
je 0x2da2
movl %eax, (%rbx)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x1030
xorl %r14d, %r14d
movl $0x80000001, %eax       # imm = 0x80000001
jmp 0x2d9b
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x2df1
movq %rsi, %r14
cmpl $0x0, (%rsi)
jne 0x2de9
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
andl $0x0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jne 0x13af
movq %rsi, %r14
leaq 0x7cc5(%rip), %rdi      # 0x9004
callq 0x2b72
movq %rax, %rbx
leaq 0x7cbd(%rip), %rsi      # 0x900b
xorl %edi, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x70f6
movq 0x8(%r14), %rsi
leaq 0x7cbe(%rip), %rdi      # 0x9023
movq %rsp, %r14
movq %rbx, %rdx
movq %r14, %rcx
callq 0x25c1
movq (%r14), %rdi
testl %eax, %eax
je 0x138a
callq 0x5c49
movq (%rsp), %rdi
callq 0x5847
jmp 0x1398
callq 0x140f
movq (%rsp), %rdi
callq 0x13c4
pushq $0x1
popq %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2f66
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x7c75(%rip), %rdi      # 0x902b
callq 0x1060
xorl %edi, %edi
callq 0x11f0
nop