LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/maandree[P]libkeccak/hmac/libkeccak_hmac_set_key.c
// Function: libkeccak_hmac_set_key
int
libkeccak_hmac_set_key(struct libkeccak_hmac_state *restrict state, const void *restrict key, size_t key_length)
{
	size_t i, size, new_key_length, key_bytes;
	void *new;

	size = (size_t)(state->sponge.r) > key_length ? (size_t)(state->sponge.r) : key_length;
	new_key_length = size;
	size = (size + 7) >> 3;
	key_bytes = (key_length + 7) >> 3;

	if (size != key_bytes) {
		new = realloc(state->key_opad, 2 * size);
		if (!new)
			return -1;
		state->key_opad = new;
		state->key_ipad = state->key_opad + size;
	}

	memcpy(state->key_opad, key, key_bytes);
	if (key_length & 7)
		state->key_opad[(key_bytes >> 3) - 1] &= (unsigned char)((1 << (key_length & 7)) - 1);

	if ((size_t)(state->sponge.r) > key_length)
		__builtin_memset(state->key_opad + key_bytes, 0, size - key_bytes);

	for (i = 0; i < size; i++) {
		state->key_ipad[i] = state->key_opad[i] ^ HMAC_INNER_PAD;
		state->key_opad[i] ^= HMAC_OUTER_PAD;
	}

	state->key_length = new_key_length;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rdi, %rbx
movq 0xe0(%rdi), %rcx
cmpq %rdx, %rcx
movq %rdx, %rax
movq %rcx, 0x18(%rsp)
cmovaq %rcx, %rax
movq (%rdi), %r14
movq %rax, 0x20(%rsp)
leaq 0x7(%rax), %r13
shrq $0x3, %r13
leaq 0x7(%rdx), %rbp
movq %rbp, %r12
shrq $0x3, %r12
movq %r13, %rax
subq %r12, %rax
movq %rax, 0x10(%rsp)
je 0x642e
movq %rsi, 0x8(%rsp)
leaq (,%r13,2), %rsi
movq %r14, %rdi
callq 0x21c0
testq %rax, %rax
je 0x64a3
movq %rax, %r14
movq %rax, (%rbx)
addq %r13, %rax
movq %rax, 0x8(%rbx)
movq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x2170
movq %r15, %rcx
andq $0x7, %rcx
je 0x6451
movb $-0x1, %al
shlb %cl, %al
notb %al
shrq $0x6, %rbp
andb %al, -0x1(%r14,%rbp)
cmpq %r15, 0x18(%rsp)
jbe 0x646a
addq %r14, %r12
movq %r12, %rdi
xorl %esi, %esi
movq 0x10(%rsp), %rdx
callq 0x2110
xorl %eax, %eax
cmpq %rax, %r13
je 0x6489
movb (%r14,%rax), %cl
xorb $0x36, %cl
movq 0x8(%rbx), %rdx
movb %cl, (%rdx,%rax)
xorb $0x5c, (%r14,%rax)
incq %rax
jmp 0x646c
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
popq %rax
jmp 0x6494
// File: /workspace/github_c_makefile_star2_O2/maandree[P]libkeccak/hmac/libkeccak_hmac_unmarshal.c
// Function: libkeccak_hmac_unmarshal
size_t
libkeccak_hmac_unmarshal(struct libkeccak_hmac_state *restrict state, const void *restrict data_)
{
	const unsigned char *restrict data = data_;
	size_t parsed, size, i;

	state->key_opad = NULL;
	state->key_ipad = NULL;

	parsed = libkeccak_state_unmarshal(state ? &state->sponge : NULL, data);
	if (!parsed)
		return 0;
	data += parsed;

	__builtin_memcpy(&size, data, sizeof(size));
	data += sizeof(size_t);
	if (state)
		size = state->key_length;
	size = (state->key_length + 7) >> 3;

	if (state) {
		state->key_opad = malloc(2 * size);
		if (!state->key_opad) {
			libkeccak_state_destroy(&state->sponge);
			return 0;
		}
		memcpy(state->key_opad, data, size);
		data += size;

		if (data[0]) {
			state->key_ipad = &state->key_opad[size];
			memcpy(state->key_ipad, state->key_opad, size);
			for (i = 0; i < size; i++)
				state->key_ipad[i] ^= (char)(HMAC_OUTER_PAD ^ HMAC_INNER_PAD);
		}

		state->leftover = data[1];
		state->buffer = NULL;
		state->buffer_size = 0;
	}

	return parsed + sizeof(size_t) + size + 2 * sizeof(char);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x18(%rdi), %r13
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %r13, %rdi
callq 0x2240
testq %rax, %rax
je 0x6568
movq %rax, %r14
movq 0x10(%rbx), %r15
addq $0x7, %r15
shrq $0x3, %r15
leaq (%r15,%r15), %rdi
callq 0x21a0
movq %rax, (%rbx)
testq %rax, %rax
je 0x6560
movq %rax, %rbp
leaq (%r12,%r14), %r13
addq $0x8, %r13
addq %r14, %r12
movq %rax, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x2170
cmpb $0x0, 0x8(%r15,%r12)
je 0x6541
addq %r15, %rbp
movq %rbp, 0x8(%rbx)
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x2170
xorl %eax, %eax
cmpq %rax, %r15
je 0x6541
movq 0x8(%rbx), %rcx
xorb $0x6a, (%rcx,%rax)
incq %rax
jmp 0x652f
movb 0x1(%r13,%r15), %al
movb %al, 0x148(%rbx)
leaq (%r14,%r15), %rax
addq $0xa, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x138(%rbx)
jmp 0x656a
movq %r13, %rdi
callq 0x2120
xorl %eax, %eax
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/maandree[P]libkeccak/hmac/libkeccak_hmac_update.c
// Function: libkeccak_hmac_update
int
libkeccak_hmac_update(struct libkeccak_hmac_state *restrict state, const void *restrict msg_, size_t msglen)
{
	const unsigned char *restrict msg = msg_;
	size_t i;
	int n, cn, r;

	if (state->key_ipad) {
		if (libkeccak_update(&state->sponge, state->key_ipad, state->key_length >> 3) < 0)
			return -1;
		if (state->key_length & 7)
			state->leftover = state->key_ipad[state->key_length >> 3];
		state->key_ipad = NULL;
	}

	if (!msg || !msglen)
		return 0;

	if (!(state->key_length & 7))
		return libkeccak_update(&state->sponge, msg, msglen);

	if (msglen != state->buffer_size) {
		free(state->buffer);
		state->buffer = malloc(state->buffer_size = msglen);
		if (!state->buffer)
			return -1;
	}

	n = (int)(state->key_length & 7);
	cn = 8 - n;
	for (i = 1; i < msglen; i++)
		state->buffer[i] = (unsigned char)((msg[i - 1] >> cn) | (msg[i] << n));
	state->buffer[0] = (unsigned char)((state->leftover & ((1 << n) - 1)) | (msg[0] << n));
	state->leftover = (unsigned char)(msg[msglen - 1] >> cn);

	r = libkeccak_update(&state->sponge, state->buffer, msglen);
	my_explicit_bzero(state->buffer, msglen);
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rsi
pushq $-0x1
popq %rbp
testq %rsi, %rsi
je 0x65d0
leaq 0x18(%r14), %rdi
movq 0x10(%r14), %rdx
shrq $0x3, %rdx
callq 0x21b0
testl %eax, %eax
js 0x66c8
movq 0x10(%r14), %rax
testb $0x7, %al
je 0x65cb
movq 0x8(%r14), %rcx
shrq $0x3, %rax
movb (%rcx,%rax), %al
movb %al, 0x148(%r14)
andq $0x0, 0x8(%r14)
testq %r15, %r15
sete %cl
testq %rbx, %rbx
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x66ca
movq 0x10(%r14), %rax
testb $0x7, %al
je 0x66d5
cmpq %rbx, 0x140(%r14)
je 0x662f
movq 0x138(%r14), %rdi
callq 0x2040
movq %rbx, 0x140(%r14)
movq %rbx, %rdi
callq 0x21a0
movq %rax, %rcx
movq %rax, 0x138(%r14)
movl %ebp, %eax
testq %rcx, %rcx
je 0x66ca
movq 0x10(%r14), %rax
andl $0x7, %eax
pushq $0x8
popq %rdx
subl %eax, %edx
pushq $0x1
popq %rsi
cmpq %rbx, %rsi
jae 0x6666
movzbl -0x1(%r15,%rsi), %edi
movl %edx, %ecx
shrl %cl, %edi
movzbl (%r15,%rsi), %r8d
movl %eax, %ecx
shll %cl, %r8d
orl %edi, %r8d
movq 0x138(%r14), %rcx
movb %r8b, (%rcx,%rsi)
incq %rsi
jmp 0x663a
pushq $-0x1
popq %rsi
movl %eax, %ecx
shll %cl, %esi
movzbl 0x148(%r14), %ecx
notl %esi
andl %ecx, %esi
movzbl (%r15), %edi
movl %eax, %ecx
shll %cl, %edi
orl %esi, %edi
movq 0x138(%r14), %rax
movb %dil, (%rax)
movzbl -0x1(%r15,%rbx), %eax
movl %edx, %ecx
shrl %cl, %eax
movb %al, 0x148(%r14)
leaq 0x18(%r14), %rdi
movq 0x138(%r14), %rsi
movq %rbx, %rdx
callq 0x21b0
movl %eax, %ebp
movq 0x138(%r14), %rdi
movq 0x3a87(%rip), %rax      # 0xa148
xorl %esi, %esi
movq %rbx, %rdx
callq *%rax
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq $0x18, %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21b0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/maandree[P]libkeccak/hmac/libkeccak_hmac_wipe.c
// Function: libkeccak_hmac_wipe
void
libkeccak_hmac_wipe(volatile struct libkeccak_hmac_state *state)
{
	volatile unsigned char *restrict key_pads;
	size_t i, size;

	key_pads = state->key_opad;
	size = 2 * ((state->key_length + 7) >> 3);

	libkeccak_state_wipe(&state->sponge);
	for (i = 0; i < size; i++)
		key_pads[i] = 0;
	state->leftover = 0;
	__builtin_memset(state->buffer, 0, state->buffer_size);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x10(%rdi), %r15
addq $0x7, %r15
shrq $0x2, %r15
andq $-0x2, %r15
addq $0x18, %rdi
callq 0x2160
xorl %eax, %eax
cmpq %rax, %r15
je 0x6729
movb $0x0, (%r14,%rax)
incq %rax
jmp 0x671a
movb $0x0, 0x148(%rbx)
movq 0x138(%rbx), %rdi
movq 0x140(%rbx), %rdx
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x2110
nop
// File: /workspace/github_c_makefile_star2_O2/maandree[P]libkeccak/spec/../libkeccak/keccak.h
// Function: libkeccak_spec_check
inline int
libkeccak_spec_check(const struct libkeccak_spec *spec)
{
	unsigned long int state_size = (unsigned long int)(spec->capacity + spec->bitrate);
	uint32_t word_size = (uint32_t)(state_size / 25U);

	if (spec->bitrate <= 0)  return LIBKECCAK_SPEC_ERROR_BITRATE_NONPOSITIVE;
	if (spec->bitrate % 8)   return LIBKECCAK_SPEC_ERROR_BITRATE_MOD_8;
	if (spec->capacity <= 0) return LIBKECCAK_SPEC_ERROR_CAPACITY_NONPOSITIVE;
	if (spec->capacity % 8)  return LIBKECCAK_SPEC_ERROR_CAPACITY_MOD_8;
	if (spec->output <= 0)   return LIBKECCAK_SPEC_ERROR_OUTPUT_NONPOSITIVE;
	if (state_size > 1600)   return LIBKECCAK_SPEC_ERROR_STATE_TOO_LARGE;
	if (state_size % 25)     return LIBKECCAK_SPEC_ERROR_STATE_MOD_25;
	if (word_size % 8)       return LIBKECCAK_SPEC_ERROR_WORD_MOD_8;

	if ((word_size & -word_size) != word_size)
		return LIBKECCAK_SPEC_ERROR_WORD_NON_2_POTENT;

	return 0;
}

// Assembly:
movq (%rdi), %r9
movq 0x8(%rdi), %r8
leaq (%r9,%r8), %rsi
pushq $0x19
popq %rcx
movq %rsi, %rax
xorl %edx, %edx
divq %rcx
testq %r9, %r9
jle 0x6a01
testb $0x7, %r9b
je 0x6a05
pushq $0x2
jmp 0x6a03
pushq $0x1
popq %rax
retq
testq %r8, %r8
jle 0x6a14
testb $0x7, %r8b
je 0x6a18
pushq $0x4
jmp 0x6a03
pushq $0x3
jmp 0x6a03
cmpq $0x0, 0x10(%rdi)
jle 0x6a2c
cmpq $0x640, %rsi            # imm = 0x640
jbe 0x6a30
pushq $0x6
jmp 0x6a03
pushq $0x5
jmp 0x6a03
movq %rax, %rcx
movw $0x19, %di
movl %esi, %eax
xorl %edx, %edx
divw %di
testw %dx, %dx
je 0x6a47
pushq $0x7
jmp 0x6a03
testb $0x7, %cl
je 0x6a50
pushq $0x9
jmp 0x6a03
leal 0x7f(%rcx), %edx
xorl %eax, %eax
testl %ecx, %edx
setne %al
shll $0x3, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ryuichiueda[P]glueutils/src_con12/con12.c
// Function: thread_read
void thread_read(void *arg)
{
	int *fd = (int *)arg;
	char buf[1024];
	int ret = 1;
	while (ret > 0){
		ret = read(*fd, &buf, 1024);
		for(int i=0;i<ret;i++){
			putchar(buf[i]);
		}
	}
	fflush(stdout);

	if(ret == -1){
		fputs("Error: reading error\n", stderr);
		exit(1);
	}
	try_close(*fd);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdi, %rbx
pushq $0x1
popq %r15
movq %rsp, %r14
testl %r15d, %r15d
jle 0x1307
movl (%rbx), %edi
movl $0x400, %edx            # imm = 0x400
movq %r14, %rsi
callq 0x10a0
movq %rax, %r15
testl %r15d, %r15d
movl $0x0, %r12d
cmovgl %r15d, %r12d
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x12cc
movsbl (%rsp,%r13), %edi
callq 0x1030
incq %r13
jmp 0x12f3
movq 0x2cca(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
callq 0x10c0
cmpl $-0x1, %r15d
je 0x1333
movl (%rbx), %edi
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1280
movq 0x2cbe(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xd86(%rip), %rdi       # 0x20ca
callq 0x1070
pushq $0x1
popq %rdi
callq 0x1100
// File: /workspace/github_c_makefile_star2_O2/teodorst[P]app-huffman/huffman_decodification_mpi.c
// Function: main
int main (int argc, char* argv[]) {
	
	MPI_Init (&argc, &argv);

	if (argc == 4) {
		huffman_decompress(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");
		MPI_Finalize();
		return 1;
	}
	MPI_Finalize();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
leaq -0x14(%rbp), %rbx
movl %edi, (%rbx)
leaq -0x10(%rbp), %rax
movq %rsi, (%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10f0
cmpl $0x4, (%rbx)
jne 0x17c5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
callq 0x1354
xorl %ebx, %ebx
jmp 0x17e0
leaq 0x1891(%rip), %rdi      # 0x305d
callq 0x1080
leaq 0x1893(%rip), %rdi      # 0x306b
callq 0x1080
pushq $0x1
popq %rbx
callq 0x11a0
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ikbenlike[P]nngutils/src/tac.c
// Function: parse_arg
struct tac_args *parse_arg(struct tac_args *args, int argc, char **argv){
    args->files = calloc(1, sizeof(char*) * argc);
    args->nfiles = 0;
    for(int i = 1; i < argc; i++){
        if(argv[i][0] == '-'){
            if(!strcmp(argv[i], "-b")){
                args->before = true;
            }
            else if(!strcmp(argv[i], "-r")){
                args->regex = true;
            }
            else if(!strcmp(argv[i], "-s")){
                args->separator = true;
                if(i + 1 < argc){
                    args->sep = argv[++i];
                }
                else {
                    fprintf(stderr, "%s: missing operand after '-s'\n");
                    exit(1);
                }
           }
        }
        else {

        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movslq %esi, %rsi
shlq $0x3, %rsi
pushq $0x1
popq %rdi
callq 0x1030
movq %rax, 0x10(%r15)
andl $0x0, 0x18(%r15)
pushq $0x1
popq %rax
cmpl %r14d, %eax
jge 0x11e7
movslq %eax, %rcx
movq (%rbx,%rcx,8), %rcx
cmpb $0x2d, (%rcx)
jne 0x11e3
cmpb $0x62, 0x1(%rcx)
jne 0x11a7
cmpb $0x0, 0x2(%rcx)
je 0x11d8
cmpb $0x72, 0x1(%rcx)
jne 0x11b3
cmpb $0x0, 0x2(%rcx)
je 0x11de
cmpb $0x73, 0x1(%rcx)
jne 0x11e3
cmpb $0x0, 0x2(%rcx)
jne 0x11e3
movb $0x1, 0x2(%r15)
incl %eax
cmpl %r14d, %eax
jge 0x11f2
movslq %eax, %rcx
movq (%rbx,%rcx,8), %rcx
movq %rcx, 0x8(%r15)
jmp 0x11e3
movb $0x1, (%r15)
jmp 0x11e3
movb $0x1, 0x1(%r15)
incl %eax
jmp 0x118a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x2dff(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xe01(%rip), %rsi       # 0x2004
xorl %eax, %eax
callq 0x1040
pushq $0x1
popq %rdi
callq 0x1050
// File: /workspace/github_c_makefile_star2_O2/arachsys[P]containers/console.c
// Function: getconsole
int getconsole(void) {
  int master, null;

  if ((null = open("/dev/null", O_RDWR)) < 0)
    errx(EXIT_FAILURE, "Failed to open /dev/null");

  if (fcntl(STDIN_FILENO, F_GETFD) < 0)
    dup2(null, STDIN_FILENO);
  if (fcntl(STDOUT_FILENO, F_GETFD) < 0)
    dup2(null, STDOUT_FILENO);
  if (fcntl(STDERR_FILENO, F_GETFD) < 0)
    dup2(null, STDERR_FILENO);

  if (null != STDIN_FILENO)
    if (null != STDOUT_FILENO)
      if (null != STDERR_FILENO)
        close(null);

  if ((master = posix_openpt(O_RDWR | O_NOCTTY)) < 0)
    errx(EXIT_FAILURE, "Failed to allocate a console pseudo-terminal");
  grantpt(master);
  unlockpt(master);
  return master;
}

// Assembly:
pushq %rbx
leaq 0x1990(%rip), %rdi      # 0x4368
pushq $0x2
popq %rsi
xorl %eax, %eax
callq 0x23e0
testl %eax, %eax
js 0x2a64
movl %eax, %ebx
pushq $0x1
popq %rsi
xorl %edi, %edi
xorl %eax, %eax
callq 0x20e0
testl %eax, %eax
jns 0x2a01
movl %ebx, %edi
xorl %esi, %esi
callq 0x21c0
pushq $0x1
popq %rdi
movl %edi, %esi
xorl %eax, %eax
callq 0x20e0
testl %eax, %eax
jns 0x2a1b
pushq $0x1
popq %rsi
movl %ebx, %edi
callq 0x21c0
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
xorl %eax, %eax
callq 0x20e0
testl %eax, %eax
jns 0x2a36
pushq $0x2
popq %rsi
movl %ebx, %edi
callq 0x21c0
cmpl $0x3, %ebx
jb 0x2a42
movl %ebx, %edi
callq 0x2210
movl $0x102, %edi            # imm = 0x102
callq 0x2490
testl %eax, %eax
js 0x2a6d
movl %eax, %ebx
movl %eax, %edi
callq 0x2430
movl %ebx, %edi
callq 0x2270
movl %ebx, %eax
popq %rbx
retq
leaq 0x18ee(%rip), %rsi      # 0x4359
jmp 0x2a74
leaq 0x18fe(%rip), %rsi      # 0x4372
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O2/arachsys[P]containers/console.c
// Function: setconsole
void setconsole(char *name) {
  int console;
  struct termios termios;

  setsid();

  if ((console = open(name, O_RDWR)) < 0)
    errx(EXIT_FAILURE, "Failed to open console in container");
  ioctl(console, TIOCSCTTY, NULL);

  if (tcgetattr(console, &termios) < 0)
    err(EXIT_FAILURE, "tcgetattr");
  termios.c_iflag |= IGNBRK | IUTF8;
  tcsetattr(console, TCSANOW, &termios);

  dup2(console, STDIN_FILENO);
  dup2(console, STDOUT_FILENO);
  dup2(console, STDERR_FILENO);
  if (console != STDIN_FILENO)
    if (console != STDOUT_FILENO)
      if (console != STDERR_FILENO)
        close(console);
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
callq 0x2230
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x23e0
testl %eax, %eax
js 0x2b01
movl %eax, %ebx
movl $0x540e, %esi           # imm = 0x540E
movl %eax, %edi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2200
leaq 0x4(%rsp), %rsi
movl %ebx, %edi
callq 0x23c0
testl %eax, %eax
js 0x2b12
leaq 0x4(%rsp), %rdx
orl $0x4001, (%rdx)         # imm = 0x4001
movl %ebx, %edi
xorl %esi, %esi
callq 0x23d0
movl %ebx, %edi
xorl %esi, %esi
callq 0x21c0
pushq $0x1
popq %rsi
movl %ebx, %edi
callq 0x21c0
pushq $0x2
popq %rsi
movl %ebx, %edi
callq 0x21c0
cmpl $0x3, %ebx
jb 0x2afb
movl %ebx, %edi
callq 0x2210
addq $0x40, %rsp
popq %rbx
retq
leaq 0x1897(%rip), %rsi      # 0x439f
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x21b0
leaq 0x18aa(%rip), %rsi      # 0x43c3
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x2310
// File: /workspace/github_c_makefile_star2_O2/arachsys[P]containers/mount.c
// Function: bindnode
static void bindnode(char *src, char *dst) {
  int fd;

  if ((fd = open(dst, O_WRONLY | O_CREAT, 0600)) >= 0)
    close(fd);
  if (mount(src, dst, NULL, MS_BIND, NULL) < 0)
    errx(EXIT_FAILURE, "Failed to bind %s into new /dev filesystem", src);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x41
popq %rsi
movq %r14, %rdi
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x23e0
testl %eax, %eax
js 0x3ae0
movl %eax, %edi
callq 0x2210
movl $0x1000, %ecx           # imm = 0x1000
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x2180
testl %eax, %eax
js 0x3b01
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xca1(%rip), %rsi       # 0x47a9
pushq $0x1
popq %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O2/arachsys[P]containers/mount.c
// Function: enterroot
void enterroot(void) {
  if (syscall(__NR_pivot_root, ".", "dev/tmp") < 0)
    errx(EXIT_FAILURE, "Failed to pivot into new root filesystem");

  if (chdir("/dev/tmp") >= 0) {
    while (*root == '/')
      root++;
    rmdir(root);
  }

  root = NULL;

  if (chdir("/") < 0 || umount2("/dev/tmp", MNT_DETACH) < 0)
    errx(EXIT_FAILURE, "Failed to detach old root filesystem");
  else
    rmdir("/dev/tmp");
}

// Assembly:
pushq %rax
leaq 0xbb3(%rip), %rsi       # 0x46d0
leaq 0xbd8(%rip), %rdx       # 0x46fc
movl $0x9b, %edi
xorl %eax, %eax
callq 0x22a0
testq %rax, %rax
js 0x3ba3
leaq 0xbbf(%rip), %rdi       # 0x46fb
callq 0x2190
testl %eax, %eax
js 0x3b62
movq 0x376c(%rip), %rdi      # 0x72b8
cmpb $0x2f, (%rdi)
jne 0x3b5d
incq %rdi
movq %rdi, 0x375d(%rip)      # 0x72b8
jmp 0x3b4c
callq 0x2160
andq $0x0, 0x374e(%rip)      # 0x72b8
leaq 0xb93(%rip), %rdi       # 0x4704
callq 0x2190
testl %eax, %eax
js 0x3b9a
leaq 0xb7a(%rip), %rdi       # 0x46fb
pushq $0x2
popq %rsi
callq 0x2120
testl %eax, %eax
js 0x3b9a
leaq 0xb67(%rip), %rdi       # 0x46fb
popq %rax
jmp 0x2160
leaq 0xb65(%rip), %rsi       # 0x4706
jmp 0x3baa
leaq 0xb28(%rip), %rsi       # 0x46d2
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O2/arachsys[P]containers/mount.c
// Function: mountproc
void mountproc(void) {
  mode_t mask;

  mask = umask(0);
  mkdir("proc" , 0755);
  umask(mask);

  if (mount("proc", "proc", "proc", 0, NULL) < 0)
    errx(EXIT_FAILURE, "Failed to mount /proc in new root filesystem");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %edi, %edi
callq 0x22c0
movl %eax, %ebx
leaq 0xb63(%rip), %r14       # 0x472b
movq %r14, %rdi
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x20b0
movl %ebx, %edi
callq 0x22c0
movq %r14, %rdi
movq %r14, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2180
testl %eax, %eax
js 0x3bfb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xb2e(%rip), %rsi       # 0x4730
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O2/arachsys[P]containers/mount.c
// Function: mountsys
void mountsys(void) {
  mode_t mask;

  mask = umask(0);
  mkdir("sys" , 0755);
  umask(mask);

  if (mount("sysfs", "sys", "sysfs", 0, NULL) < 0)
    errx(EXIT_FAILURE, "Failed to mount /sys in new root filesystem");
  mount("cgroup2", "sys/fs/cgroup", "cgroup2", 0, NULL);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %edi, %edi
callq 0x22c0
movl %eax, %ebx
leaq 0xb3d(%rip), %r14       # 0x475d
movq %r14, %rdi
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x20b0
movl %ebx, %edi
callq 0x22c0
leaq 0xb26(%rip), %rdi       # 0x4761
movq %r14, %rsi
movq %rdi, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2180
testl %eax, %eax
js 0x3c71
leaq 0xb45(%rip), %rsi       # 0x479b
leaq 0xb36(%rip), %rdi       # 0x4793
movq %rdi, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2180
leaq 0xaef(%rip), %rsi       # 0x4767
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x21b0
nop
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/mksimtape/mksimtape.c
// Function: error
static VOID error(PCHAR mes, ...)
{	va_list ap;

	fprintf(stderr, "%s: ", progname);

	va_start(ap, mes);
	vfprintf(stderr, mes, ap);
	va_end(ap);

	fputc('\n', stderr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x151b
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x2ace(%rip), %r15      # 0x3ff0
movq (%r15), %rdi
movq 0x2b7c(%rip), %rdx      # 0x40a8
leaq 0xbb9(%rip), %rsi       # 0x20ec
xorl %eax, %eax
callq 0x10a0
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %r14, 0x10(%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x10f0
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x1090
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/mksimtape/mksimtape.c
// Function: putusage
static VOID putusage(VOID)
{	PCHAR *p = (PCHAR *) helpinfo;
	PCHAR q;

	for(;;) {
		q = *p++;
		if(*q == '\0') break;

		fprintf(stderr, q, progname, DEFBLKSIZE);
		fputc('\n', stderr);
	}
	fprintf(stderr, "\nThis is version %d.%d\n", VERSION, EDIT);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x2807(%rip), %r15      # 0x3d90
movq 0x2a60(%rip), %r14      # 0x3ff0
pushq $0xa
popq %rbx
movq (%r15), %rsi
cmpb $0x0, (%rsi)
je 0x15c1
addq $0x8, %r15
movq (%r14), %rdi
movq 0x2aff(%rip), %rdx      # 0x40a8
movl $0x2800, %ecx           # imm = 0x2800
xorl %eax, %eax
callq 0x10a0
movq (%r14), %rsi
movl %ebx, %edi
callq 0x1090
jmp 0x1593
movq (%r14), %rdi
leaq 0xb26(%rip), %rsi       # 0x20f1
pushq $0x1
popq %rdx
xorl %ecx, %ecx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x10a0
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/mksimtape/mksimtape.c
// Function: tape_mark
static BOOL tape_mark(VOID)
{	INT n;
	UCHAR sbuf[4] = { 0,0,0,0 };

	n = fwrite(sbuf, 1, 4, stdout);
	if(n != 4) {
		error("Error writing to tape image");
		return(FALSE);
	}

	return(TRUE);
}

// Assembly:
pushq %rax
leaq 0x4(%rsp), %rdi
andl $0x0, (%rdi)
movq 0x29e4(%rip), %rax      # 0x3fd0
movq (%rax), %rcx
pushq $0x1
popq %rsi
pushq $0x4
popq %rdx
callq 0x1110
cmpl $0x4, %eax
jne 0x1601
popq %rax
retq
leaq 0xac8(%rip), %rdi       # 0x20d0
xorl %eax, %eax
popq %rcx
jmp 0x14b8
// File: /workspace/github_c_makefile_star2_O2/CheneyThinker[P]jbyte/src/jbyte_attribute.c
// Function: generator_attributes
void generator_attributes(FILE* pWriteFile) {
  PUT_U2(attributes_count, 0x0001)
  PUT_U2(attribute_name_index, 0x0011)
  PUT_U4(attribute_length, 0x00000002)
  PUT_U2(sourcefile_index, 0x0001)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movw $0x100, %r12w           # imm = 0x100
leaq -0x26(%rbp), %rdi
movw %r12w, (%rdi)
pushq $0x2
popq %r14
pushq $0x1
popq %r15
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x1120
leaq -0x24(%rbp), %rdi
movw $0x1100, (%rdi)         # imm = 0x1100
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x1120
leaq -0x2c(%rbp), %rdi
movl $0x2000000, (%rdi)      # imm = 0x2000000
pushq $0x4
popq %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x1120
leaq -0x22(%rbp), %rdi
movw %r12w, (%rdi)
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x1120
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/CheneyThinker[P]jbyte/src/jbyte_attribute.c
// Function: InnerClasses_attribute
void InnerClasses_attribute(FILE* pReadFile) {
  PRINTF_U2(number_of_classes)
  if (number_of_classes > 0) {
    for (u2 number_of_classes_index = 0; number_of_classes_index < number_of_classes; number_of_classes_index++) {
      PRINTF_U2(inner_class_info_index)
      PRINTF_U2(outer_class_info_index)
      PRINTF_U2(inner_name_index)
      PRINTF_U2(inner_class_access_flags)
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq -0x32(%rbp), %r14
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %r15d
movl %r15d, %r14d
rolw $0x8, %r14w
movzwl %r14w, %esi
leaq 0x47f8(%rip), %rdi      # 0x859d
xorl %eax, %eax
callq 0x10b0
testw %r15w, %r15w
je 0x3e7d
pushq $0x1
popq %r15
pushq $0x2
popq %r12
leaq 0x4845(%rip), %r13      # 0x860a
subw $0x1, %r14w
jb 0x3e7d
leaq -0x30(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1080
movzwl -0x30(%rbp), %eax
rolw $0x8, %ax
movzwl %ax, %esi
leaq 0x47c2(%rip), %rdi      # 0x85b6
xorl %eax, %eax
callq 0x10b0
leaq -0x2e(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1080
movzwl -0x2e(%rbp), %eax
rolw $0x8, %ax
movzwl %ax, %esi
leaq 0x47b5(%rip), %rdi      # 0x85d4
xorl %eax, %eax
callq 0x10b0
leaq -0x2c(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1080
movzwl -0x2c(%rbp), %eax
rolw $0x8, %ax
movzwl %ax, %esi
leaq 0x47a8(%rip), %rdi      # 0x85f2
xorl %eax, %eax
callq 0x10b0
leaq -0x2a(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1080
movzwl -0x2a(%rbp), %eax
rolw $0x8, %ax
movzwl %ax, %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x10b0
jmp 0x3dc5
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/CheneyThinker[P]jbyte/src/jbyte_attribute.c
// Function: SourceDebugExtension_attribute
void SourceDebugExtension_attribute(FILE* pReadFile, u4 attribute_length) {
  u1 debug_extension[attribute_length];
  for (u4 attribute_length_index = 0; attribute_length_index < attribute_length; attribute_length_index++) {
    fread(&debug_extension[attribute_length_index], 1, sizeof(u1), pReadFile);
    printf("debug_extension[%04x]: %02x\n", attribute_length_index, debug_extension[attribute_length_index]);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %r13d
movq %rsp, %r15
leaq 0xf(%r13), %rax
andq $-0x10, %rax
subq %rax, %r15
movq %r15, %rsp
pushq $0x1
popq %r14
xorl %r12d, %r12d
cmpq %r12, %r13
je 0x3fe4
leaq (%r15,%r12), %rdi
movq %r14, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1080
movzbl (%r15,%r12), %edx
leaq 0x4698(%rip), %rdi      # 0x866d
movl %r12d, %esi
xorl %eax, %eax
callq 0x10b0
incq %r12
jmp 0x3fb2
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/CheneyThinker[P]jbyte/src/jbyte_attribute.c
// Function: LineNumberTable_attribute
void LineNumberTable_attribute(FILE* pReadFile) {
  PRINTF_U2(line_number_table_length)
  if (line_number_table_length > 0) {
    for (u2 line_number_table_length_index = 0; line_number_table_length_index < line_number_table_length; line_number_table_length_index++) {
      PRINTF_U2(start_pc)
      PRINTF_U2(line_number)
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x2e(%rbp), %r14
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %r15d
movl %r15d, %r14d
rolw $0x8, %r14w
movzwl %r14w, %esi
leaq 0x465a(%rip), %rdi      # 0x868a
xorl %eax, %eax
callq 0x10b0
testw %r15w, %r15w
je 0x40a7
pushq $0x1
popq %r15
pushq $0x2
popq %r12
leaq 0x465e(%rip), %r13      # 0x86aa
subw $0x1, %r14w
jb 0x40a7
leaq -0x2c(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1080
movzwl -0x2c(%rbp), %eax
rolw $0x8, %ax
movzwl %ax, %esi
leaq 0x4407(%rip), %rdi      # 0x847e
xorl %eax, %eax
callq 0x10b0
leaq -0x2a(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1080
movzwl -0x2a(%rbp), %eax
rolw $0x8, %ax
movzwl %ax, %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x10b0
jmp 0x404c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/CheneyThinker[P]jbyte/src/jbyte_attribute.c
// Function: LocalVariableTable_attribute
void LocalVariableTable_attribute(FILE* pReadFile) {
  PRINTF_U2(local_variable_table_length)
  if (local_variable_table_length > 0) {
    for (u2 local_variable_table_length_index = 0; local_variable_table_length_index < local_variable_table_length; local_variable_table_length_index++) {
      PRINTF_U2(start_pc)
      PRINTF_U2(length)
      PRINTF_U2(name_index)
      PRINTF_U2(descriptor_index)
      PRINTF_U2(index)
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq -0x34(%rbp), %r14
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %r15d
movl %r15d, %r14d
rolw $0x8, %r14w
movzwl %r14w, %esi
leaq 0x45c7(%rip), %rdi      # 0x86bd
xorl %eax, %eax
callq 0x10b0
testw %r15w, %r15w
je 0x41f9
pushq $0x1
popq %r15
pushq $0x2
popq %r12
leaq 0x451b(%rip), %r13      # 0x8631
subw $0x1, %r14w
jb 0x41f9
leaq -0x32(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1080
movzwl -0x32(%rbp), %eax
rolw $0x8, %ax
movzwl %ax, %esi
leaq 0x4339(%rip), %rdi      # 0x847e
xorl %eax, %eax
callq 0x10b0
leaq -0x30(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1080
movzwl -0x30(%rbp), %eax
rolw $0x8, %ax
movzwl %ax, %esi
leaq 0x4562(%rip), %rdi      # 0x86d2
xorl %eax, %eax
callq 0x10b0
leaq -0x2e(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1080
movzwl -0x2e(%rbp), %eax
rolw $0x8, %ax
movzwl %ax, %esi
leaq 0x47cc(%rip), %rdi      # 0x8967
xorl %eax, %eax
callq 0x10b0
leaq -0x2c(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1080
movzwl -0x2c(%rbp), %eax
rolw $0x8, %ax
movzwl %ax, %esi
leaq 0x451a(%rip), %rdi      # 0x86e0
xorl %eax, %eax
callq 0x10b0
leaq -0x2a(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1080
movzwl -0x2a(%rbp), %eax
rolw $0x8, %ax
movzwl %ax, %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x10b0
jmp 0x4116
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/CheneyThinker[P]jbyte/src/jbyte_attribute.c
// Function: LocalVariableTypeTable_attribute
void LocalVariableTypeTable_attribute(FILE* pReadFile) {
  PRINTF_U2(local_variable_type_table_length)
  if (local_variable_type_table_length > 0) {
    for (u2 local_variable_type_table_length_index = 0; local_variable_type_table_length_index < local_variable_type_table_length; local_variable_type_table_length_index++) {
      PRINTF_U2(start_pc)
      PRINTF_U2(length)
      PRINTF_U2(name_index)
      PRINTF_U2(signature_index)
      PRINTF_U2(index)
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq -0x34(%rbp), %r14
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %r15d
movl %r15d, %r14d
rolw $0x8, %r14w
movzwl %r14w, %esi
leaq 0x44b0(%rip), %rdi      # 0x86f8
xorl %eax, %eax
callq 0x10b0
testw %r15w, %r15w
je 0x434b
pushq $0x1
popq %r15
pushq $0x2
popq %r12
leaq 0x43c9(%rip), %r13      # 0x8631
subw $0x1, %r14w
jb 0x434b
leaq -0x32(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1080
movzwl -0x32(%rbp), %eax
rolw $0x8, %ax
movzwl %ax, %esi
leaq 0x41e7(%rip), %rdi      # 0x847e
xorl %eax, %eax
callq 0x10b0
leaq -0x30(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1080
movzwl -0x30(%rbp), %eax
rolw $0x8, %ax
movzwl %ax, %esi
leaq 0x4410(%rip), %rdi      # 0x86d2
xorl %eax, %eax
callq 0x10b0
leaq -0x2e(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1080
movzwl -0x2e(%rbp), %eax
rolw $0x8, %ax
movzwl %ax, %esi
leaq 0x467a(%rip), %rdi      # 0x8967
xorl %eax, %eax
callq 0x10b0
leaq -0x2c(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1080
movzwl -0x2c(%rbp), %eax
rolw $0x8, %ax
movzwl %ax, %esi
leaq 0x4326(%rip), %rdi      # 0x863e
xorl %eax, %eax
callq 0x10b0
leaq -0x2a(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1080
movzwl -0x2a(%rbp), %eax
rolw $0x8, %ax
movzwl %ax, %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x10b0
jmp 0x4268
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/CheneyThinker[P]jbyte/src/jbyte_attribute.c
// Function: BootstrapMethods_attribute
void BootstrapMethods_attribute(FILE* pReadFile) {
  PRINTF_U2(num_bootstrap_methods)
  if (num_bootstrap_methods > 0) {
    for (u2 num_bootstrap_methods_index = 0; num_bootstrap_methods_index < num_bootstrap_methods; num_bootstrap_methods_index++) {
      PRINTF_U2(bootstrap_method_ref)
      PRINTF_U2(num_bootstrap_arguments)
      PRINTF_U2_ARRAY(num_bootstrap_arguments, bootstrap_arguments)
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq -0x36(%rbp), %r14
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %r14d
movl %r14d, %eax
rolw $0x8, %ax
movw %ax, -0x2a(%rbp)
movzwl %ax, %esi
leaq 0x44e9(%rip), %rdi      # 0x88d1
xorl %eax, %eax
callq 0x10b0
testw %r14w, %r14w
je 0x44e2
pushq $0x2
popq %r12
xorl %r15d, %r15d
cmpw -0x2a(%rbp), %r15w
je 0x44e2
leaq -0x2e(%rbp), %rdi
pushq $0x1
popq %r14
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1080
movzwl -0x2e(%rbp), %eax
rolw $0x8, %ax
movzwl %ax, %esi
leaq 0x44bb(%rip), %rdi      # 0x88ee
xorl %eax, %eax
callq 0x10b0
leaq -0x2c(%rbp), %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1080
movzwl -0x2c(%rbp), %r14d
movl %r14d, %eax
rolw $0x8, %ax
movzwl %ax, %r13d
leaq 0x44a7(%rip), %rdi      # 0x890a
movl %r13d, %esi
xorl %eax, %eax
callq 0x10b0
testw %r14w, %r14w
je 0x44da
movl %r15d, -0x34(%rbp)
movq %rsp, -0x40(%rbp)
leal 0xf(,%r13,2), %eax
andl $-0x10, %eax
movq %rsp, %r14
subq %rax, %r14
movq %r14, %rsp
xorl %r15d, %r15d
subq $0x1, %r13
jb 0x44d2
movq %r14, %rdi
pushq $0x1
popq %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %eax
rolw $0x8, %ax
movw %ax, (%r14)
movzwl %ax, %edx
leaq 0x446a(%rip), %rdi      # 0x8929
movl %r15d, %esi
xorl %eax, %eax
callq 0x10b0
addq $0x2, %r14
incl %r15d
jmp 0x4492
movq -0x40(%rbp), %rsp
movl -0x34(%rbp), %r15d
incl %r15d
jmp 0x4400
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/CheneyThinker[P]jbyte/src/jbyte_attribute.c
// Function: MethodParameters_attribute
void MethodParameters_attribute(FILE* pReadFile) {
  PRINTF_U1(parameters_count)
  if (parameters_count > 0) {
    for (u1 parameters_count_index = 0; parameters_count_index < parameters_count; parameters_count_index++) {
      PRINTF_U2(name_index)
      PRINTF_U2(access_flags)
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x2d(%rbp), %r14
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rdx, %rsi
movq %rbx, %rcx
callq 0x1080
movzbl (%r14), %r14d
leaq 0x4426(%rip), %rdi      # 0x8948
movl %r14d, %esi
xorl %eax, %eax
callq 0x10b0
testl %r14d, %r14d
je 0x459a
pushq $0x1
popq %r12
pushq $0x2
popq %r13
leaq 0x40d6(%rip), %r15      # 0x8616
subb $0x1, %r14b
jb 0x459a
leaq -0x2c(%rbp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x1080
movzwl -0x2c(%rbp), %eax
rolw $0x8, %ax
movzwl %ax, %esi
leaq 0x43fd(%rip), %rdi      # 0x8967
xorl %eax, %eax
callq 0x10b0
leaq -0x2a(%rbp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x1080
movzwl -0x2a(%rbp), %eax
rolw $0x8, %ax
movzwl %ax, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x10b0
jmp 0x4540
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/CheneyThinker[P]jbyte/src/jbyte_attribute.c
// Function: verification_type_info
void verification_type_info(FILE* pReadFile) {
  PRINTF_U1(tag)
  switch (tag) {
    case 0x00:
      break;
    case 0x01:
      break;
    case 0x02:
      break;
    case 0x03:
      break;
    case 0x04:
      break;
    case 0x05:
      break;
    case 0x06:
      break;
    case 0x07:
      {
        PRINTF_U2(cpool_index)
      }
      break;
    case 0x08:
      {
        PRINTF_U2(offset)
      }
      break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x11(%rbp), %r14
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rdx, %rsi
movq %rbx, %rcx
callq 0x1080
movzbl (%r14), %r14d
leaq 0x3779(%rip), %rdi      # 0x8534
movl %r14d, %esi
xorl %eax, %eax
callq 0x10b0
cmpl $0x8, %r14d
je 0x4dfa
cmpl $0x7, %r14d
jne 0x4e28
leaq -0x16(%rbp), %r14
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %eax
rolw $0x8, %ax
movzwl %ax, %esi
leaq 0x3747(%rip), %rdi      # 0x853f
jmp 0x4e21
leaq -0x14(%rbp), %r14
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %eax
rolw $0x8, %ax
movzwl %ax, %esi
leaq 0x3731(%rip), %rdi      # 0x8552
xorl %eax, %eax
callq 0x10b0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/CheneyThinker[P]jbyte/src/jbyte_attribute.c
// Function: parameter_annotations
void parameter_annotations(FILE* pReadFile) {
  PRINTF_U1(num_parameters)
  if (num_parameters > 0) {
    for (u1 num_parameters_index = 0; num_parameters_index < num_parameters; num_parameters_index++) {
      annotations(pReadFile);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x11(%rbp), %r14
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rdx, %rsi
movq %rbx, %rcx
callq 0x1080
movzbl (%r14), %r14d
leaq 0x3869(%rip), %rdi      # 0x8720
movl %r14d, %esi
xorl %eax, %eax
callq 0x10b0
testl %r14d, %r14d
je 0x4ed6
subb $0x1, %r14b
jb 0x4ed6
movq %rbx, %rdi
callq 0x4e31
jmp 0x4ec6
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/CheneyThinker[P]jbyte/src/jbyte_attribute.c
// Function: annotation
void annotation(FILE* pReadFile) {
  PRINTF_U2(type_index)
  PRINTF_U2(num_element_value_pairs)
  if (num_element_value_pairs > 0) {
    for (u2 num_element_value_pairs_index = 0; num_element_value_pairs_index < num_element_value_pairs; num_element_value_pairs_index++) {
      PRINTF_U2(element_name_index)
      element_value(pReadFile);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x2e(%rbp), %r14
pushq $0x1
popq %r15
pushq $0x2
popq %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %eax
rolw $0x8, %ax
movzwl %ax, %esi
leaq 0x424c(%rip), %rdi      # 0x916b
xorl %eax, %eax
callq 0x10b0
leaq -0x2c(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %r15d
movl %r15d, %r14d
rolw $0x8, %r14w
movzwl %r14w, %esi
leaq 0x38ec(%rip), %rdi      # 0x883e
xorl %eax, %eax
callq 0x10b0
testw %r15w, %r15w
je 0x4fa2
pushq $0x1
popq %r15
leaq 0x38f3(%rip), %r13      # 0x885d
subw $0x1, %r14w
jb 0x4fa2
leaq -0x2a(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1080
movzwl -0x2a(%rbp), %eax
rolw $0x8, %ax
movzwl %ax, %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x10b0
movq %rbx, %rdi
callq 0x5441
jmp 0x4f6a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/CheneyThinker[P]jbyte/src/jbyte_attribute.c
// Function: element_value
void element_value(FILE* pReadFile) {
  PRINTF_U1(tag)
  switch (tag) {
    case 'B':
    case 'C':
    case 'D':
    case 'F':
    case 'I':
    case 'J':
    case 'S':
    case 'Z':
    case 's':
      {
        PRINTF_U2(const_value_index)
      }
      break;
    case 'e':
      {
        PRINTF_U2(type_name_index)
        PRINTF_U2(const_name_index)
      }
      break;
    case 'c':
      {
        PRINTF_U2(class_info_index)
      }
      break;
    case '@':
      {
        annotation(pReadFile);
      }
      break;
    case '[':
      {
        PRINTF_U2(num_values)
        if (num_values > 0) {
          for (u2 num_values_index = 0; num_values_index < num_values; num_values_index++) {
            element_value(pReadFile);
          }
        }
      }
      break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x21(%rbp), %r14
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rdx, %rsi
movq %rbx, %rcx
callq 0x1080
movzbl (%r14), %r14d
leaq 0x30c1(%rip), %rdi      # 0x8534
movl %r14d, %esi
xorl %eax, %eax
callq 0x10b0
leal -0x42(%r14), %eax
cmpl $0x3, %eax
jb 0x54cb
leal -0x49(%r14), %eax
cmpl $0x2, %eax
jb 0x54cb
cmpl $0x40, %r14d
je 0x55e0
cmpl $0x46, %r14d
je 0x54cb
cmpl $0x53, %r14d
je 0x54cb
cmpl $0x73, %r14d
je 0x54cb
cmpl $0x5b, %r14d
je 0x5506
cmpl $0x63, %r14d
je 0x55b4
cmpl $0x65, %r14d
je 0x5552
cmpl $0x5a, %r14d
jne 0x54f9
leaq -0x2c(%rbp), %r14
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %eax
rolw $0x8, %ax
movzwl %ax, %esi
leaq 0x3385(%rip), %rdi      # 0x8877
xorl %eax, %eax
callq 0x10b0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x24(%rbp), %r14
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %r15d
movl %r15d, %r14d
rolw $0x8, %r14w
movzwl %r14w, %esi
leaq 0x338d(%rip), %rdi      # 0x88bf
xorl %eax, %eax
callq 0x10b0
testw %r15w, %r15w
jne 0x5549
jmp 0x54f9
movq %rbx, %rdi
callq 0x5441
subw $0x1, %r14w
jae 0x5541
jmp 0x54f9
leaq -0x2a(%rbp), %r14
pushq $0x1
popq %r15
pushq $0x2
popq %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %eax
rolw $0x8, %ax
movzwl %ax, %esi
leaq 0x330f(%rip), %rdi      # 0x8890
xorl %eax, %eax
callq 0x10b0
leaq -0x28(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %eax
rolw $0x8, %ax
movzwl %ax, %esi
leaq 0x32f8(%rip), %rdi      # 0x88a7
jmp 0x54f2
leaq -0x26(%rbp), %r14
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1080
movzwl (%r14), %eax
rolw $0x8, %ax
movzwl %ax, %esi
leaq 0x2fe1(%rip), %rdi      # 0x85bc
jmp 0x54f2
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4edf
// File: /workspace/github_c_makefile_star2_O2/CheneyThinker[P]jbyte/src/jbyte_cp.c
// Function: addConstantUtf8
void addConstantUtf8(u1* utf8_value, FILE* pWriteFile) {
  PUT_U1(tag, CONSTANT_UTF8_TAG)
  u2 utf8_length = (u2) strlen(utf8_value);
  PUT_U2(length, utf8_length)
  for (u2 utf8_length_index = 0; utf8_length_index < utf8_length; utf8_length_index++) {
    PUT_U1(bytes, utf8_value[utf8_length_index])
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rdi
callq 0x10c0
movq %r14, %rdi
callq 0x10a0
movzwl %ax, %r15d
movl %r15d, %eax
rolw $0x8, %ax
leaq -0x22(%rbp), %rdi
movw %ax, (%rdi)
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x1120
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x5803
movsbl (%r14,%r12), %edi
movq %rbx, %rsi
callq 0x10c0
incq %r12
jmp 0x57ec
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/CheneyThinker[P]jbyte/src/jbyte_cp.c
// Function: free_constant_pool
void free_constant_pool(pcp_info pcp) {
  for (u2 constant_pool_count_index = 0; constant_pool_count_index < pcp->constant_pool_count; constant_pool_count_index++) {
    if (pcp->constant_pool[constant_pool_count_index]) {
      free(pcp->constant_pool[constant_pool_count_index]);
      pcp->constant_pool[constant_pool_count_index] = NULL;
    }
  }
  if (pcp->constant_pool) {
    free(pcp->constant_pool);
    pcp->constant_pool = NULL;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movzwl 0x8(%rbx), %eax
movq (%rbx), %rdi
cmpq %rax, %r14
jae 0x638c
movq (%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x6387
callq 0x1030
movq (%rbx), %rax
andq $0x0, (%rax,%r14,8)
incq %r14
jmp 0x6365
testq %rdi, %rdi
je 0x639a
callq 0x1030
andq $0x0, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/CheneyThinker[P]jbyte/src/jbyte_field.c
// Function: analyzer_fields
void analyzer_fields(FILE* pReadFile, u1** constant_pool) {
  PRINTF_U2(fields_count)
  if (fields_count > 0) {
    for (u2 fields_count_index = 0; fields_count_index < fields_count; fields_count_index++) {
      PRINTF_U2(access_flags)
      PRINTF_U2(name_index)
      PRINTF_U2(descriptor_index)
      analyzer_attributes(pReadFile, constant_pool);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x30(%rbp), %r15
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
movq %r15, %rdi
movq %r14, %rcx
callq 0x1080
movzwl (%r15), %r12d
movl %r12d, %r15d
rolw $0x8, %r15w
movzwl %r15w, %esi
leaq 0x2e54(%rip), %rdi      # 0x9258
xorl %eax, %eax
callq 0x10b0
testw %r12w, %r12w
je 0x64b9
pushq $0x1
popq %r12
pushq $0x2
popq %r13
subw $0x1, %r15w
jb 0x64b9
leaq -0x2e(%rbp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x1080
movzwl -0x2e(%rbp), %eax
rolw $0x8, %ax
movzwl %ax, %esi
leaq 0x21ca(%rip), %rdi      # 0x8616
xorl %eax, %eax
callq 0x10b0
leaq -0x2c(%rbp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x1080
movzwl -0x2c(%rbp), %eax
rolw $0x8, %ax
movzwl %ax, %esi
leaq 0x24f0(%rip), %rdi      # 0x8967
xorl %eax, %eax
callq 0x10b0
leaq -0x2a(%rbp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x1080
movzwl -0x2a(%rbp), %eax
rolw $0x8, %ax
movzwl %ax, %esi
leaq 0x223e(%rip), %rdi      # 0x86e0
xorl %eax, %eax
callq 0x10b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12b3
jmp 0x641d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq