LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/ammarfaizi2[P]riyuu/src/third_party/cjson/cJSON_Utils.c
// Function: decode_array_index_from_pointer(unsigned char const*, unsigned long*)
static cJSON_bool decode_array_index_from_pointer(const unsigned char * const pointer, size_t * const index)
{
    size_t parsed_index = 0;
    size_t position = 0;

    if ((pointer[0] == '0') && ((pointer[1] != '\0') && (pointer[1] != '/')))
    {
        /* leading zeroes are not permitted */
        return 0;
    }

    for (position = 0; (pointer[position] >= '0') && (pointer[0] <= '9'); position++)
    {
        parsed_index = (10 * parsed_index) + (size_t)(pointer[position] - '0');

    }

    if ((pointer[position] != '\0') && (pointer[position] != '/'))
    {
        return 0;
    }

    *index = parsed_index;

    return 1;
}

// Assembly:
movb (%rdi), %cl
cmpb $0x30, %cl
jne 0x6b99
movzbl 0x1(%rdi), %edx
cmpl $0x2f, %edx
je 0x6b99
xorl %eax, %eax
testl %edx, %edx
jne 0x6bf1
pushq %rbp
movq %rsp, %rbp
cmpb $0x3a, %cl
setae %r8b
movb (%rdi), %dl
cmpb $0x30, %dl
setb %r9b
xorl %eax, %eax
orb %r8b, %r9b
jne 0x6bd9
incq %rdi
xorl %r8d, %r8d
movzbl %dl, %edx
addl $-0x30, %edx
leaq (%r8,%r8,4), %r8
leaq (%rdx,%r8,2), %r8
movb (%rdi), %dl
cmpb $0x39, %cl
ja 0x6bdc
incq %rdi
cmpb $0x2f, %dl
ja 0x6bba
jmp 0x6bdc
xorl %r8d, %r8d
cmpb $0x2f, %dl
je 0x6be8
movzbl %dl, %ecx
testl %ecx, %ecx
jne 0x6bf0
movq %r8, (%rsi)
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ammarfaizi2[P]riyuu/src/third_party/cjson/cJSON_Utils.c
// Function: overwrite_item(cJSON*, cJSON)
static void overwrite_item(cJSON * const root, const cJSON replacement)
{
    if (root == NULL)
    {
        return;
    }

    if (root->string != NULL)
    {
        cJSON_free(root->string);
    }
    if (root->valuestring != NULL)
    {
        cJSON_free(root->valuestring);
    }
    if (root->child != NULL)
    {
        cJSON_Delete(root->child);
    }

    memcpy(root, &replacement, sizeof(cJSON));
}

// Assembly:
testq %rdi, %rdi
je 0x6da9
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x6d63
callq 0x5174
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x6d71
callq 0x5174
leaq 0x10(%rbp), %r14
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x6d83
callq 0x2cdd
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ammarfaizi2[P]riyuu/src/third_party/cjson/cJSON_Utils.c
// Function: detach_path(cJSON*, unsigned char const*, int)
static cJSON *detach_path(cJSON *object, const unsigned char *path, const cJSON_bool case_sensitive)
{
    unsigned char *parent_pointer = NULL;
    unsigned char *child_pointer = NULL;
    cJSON *parent = NULL;
    cJSON *detached_item = NULL;

    /* copy path and split it in parent and child */
    parent_pointer = cJSONUtils_strdup(path);
    if (parent_pointer == NULL) {
        goto cleanup;
    }

    child_pointer = (unsigned char*)strrchr((char*)parent_pointer, '/'); /* last '/' */
    if (child_pointer == NULL)
    {
        goto cleanup;
    }
    /* split strings */
    child_pointer[0] = '\0';
    child_pointer++;

    parent = get_item_from_pointer(object, (char*)parent_pointer, case_sensitive);
    decode_pointer_inplace(child_pointer);

    if (cJSON_IsArray(parent))
    {
        size_t index = 0;
        if (!decode_array_index_from_pointer(child_pointer, &index))
        {
            goto cleanup;
        }
        detached_item = detach_item_from_array(parent, index);
    }
    else if (cJSON_IsObject(parent))
    {
        detached_item = cJSON_DetachItemFromObject(parent, (char*)child_pointer);
    }
    else
    {
        /* Couldn't find object to remove child from. */
        goto cleanup;
    }

cleanup:
    if (parent_pointer != NULL)
    {
        cJSON_free(parent_pointer);
    }

    return detached_item;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rdi, %r13
movq %rsi, %rdi
callq 0x5af5
movq %rax, %rbx
testq %rax, %rax
je 0x6ed2
movq %rbx, %rdi
movl $0x2f, %esi
callq 0x2270
testq %rax, %rax
je 0x6ed2
movq %rax, %r12
movb $0x0, (%rax)
leaq 0x1(%rax), %r15
movq %r13, %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x5b39
movq %rax, %r14
addq $0x2, %r12
movq %r15, %rax
movzbl (%rax), %ecx
cmpl $0x7e, %ecx
je 0x6e18
testl %ecx, %ecx
jne 0x6e36
jmp 0x6e3e
movzbl 0x1(%rax), %ecx
incq %rax
cmpl $0x31, %ecx
je 0x6e31
cmpl $0x30, %ecx
jne 0x6e44
movb $0x7e, -0x1(%r12)
jmp 0x6e36
movb $0x2f, (%r12)
incq %rax
incq %r12
jmp 0x6e0a
movb $0x0, -0x1(%r12)
movq %r14, %rdi
callq 0x4f5d
testl %eax, %eax
je 0x6eb6
leaq -0x30(%rbp), %rsi
movq $0x0, (%rsi)
movq %r15, %rdi
callq 0x6b83
testl %eax, %eax
je 0x6ed2
movq -0x30(%rbp), %rax
addq $0x10, %r14
movq %r14, %r15
movq (%r15), %r15
addq $-0x1, %rax
setb %cl
testq %r15, %r15
je 0x6e85
testb %cl, %cl
jne 0x6e72
testq %r15, %r15
je 0x6ed2
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x6e99
movq (%r15), %rcx
movq %rcx, (%rax)
movq (%r15), %rcx
testq %rcx, %rcx
je 0x6ea5
movq %rax, 0x8(%rcx)
cmpq (%r14), %r15
jne 0x6ead
movq %rcx, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
jmp 0x6ed5
movq %r14, %rdi
callq 0x4f71
testl %eax, %eax
je 0x6ed2
movq %r14, %rdi
movq %r15, %rsi
callq 0x4506
movq %rax, %r15
jmp 0x6ed5
xorl %r15d, %r15d
testq %rbx, %rbx
je 0x6ee2
movq %rbx, %rdi
callq 0x5174
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ammarfaizi2[P]riyuu/src/third_party/cjson/cJSON_Utils.c
// Function: compare_strings(unsigned char const*, unsigned char const*, int)
static int compare_strings(const unsigned char *string1, const unsigned char *string2, const cJSON_bool case_sensitive)
{
    if ((string1 == NULL) || (string2 == NULL))
    {
        return 1;
    }

    if (string1 == string2)
    {
        return 0;
    }

    if (case_sensitive)
    {
        return strcmp((const char*)string1, (const char*)string2);
    }

    for(; tolower(*string1) == tolower(*string2); (void)string1++, string2++)
    {
        if (*string1 == '\0')
        {
            return 0;
        }
    }

    return tolower(*string1) - tolower(*string2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movl $0x1, %r12d
jne 0x6ff2
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
cmpq %rsi, %rdi
je 0x6ff2
testl %edx, %edx
je 0x6fa1
movq %r15, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2210
movb (%r15), %r13b
movzbl %r13b, %edi
callq 0x2240
movl %eax, %r12d
movzbl (%r14), %edi
callq 0x2240
cmpl %eax, %r12d
jne 0x6fea
movl $0x1, %ebx
testb %r13b, %r13b
je 0x6fef
movb (%r15,%rbx), %r13b
movzbl %r13b, %edi
callq 0x2240
movl %eax, %r12d
movzbl (%r14,%rbx), %edi
callq 0x2240
incq %rbx
cmpl %eax, %r12d
je 0x6fc3
subl %eax, %r12d
jmp 0x6ff2
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ammarfaizi2[P]riyuu/src/riyuu/argv_parser.c
// Function: argv_parser(int, char**, char**, _riyuu_run*, unsigned char*)
bool argv_parser(int argc, char *argv[], char *envp[], riyuu_run *run, uint8_t *exit_code)
{
	int i;
	size_t len;
	run->command = no_command;
	run->config_file = NULL;

	for (i = 1; i < argc; i++) {

		len = strlen(argv[i]);

		if (len < 1) {
			printf("argv has been corrupted!\n");
			*exit_code = 1;
			return false;
		}

		if (argv[i][0] == '-') {
			if (len == 1) {
				printf(invalid_parameter, argv[i], i);
				*exit_code = 1;
				return false;
			}

			if (len == 2) {
				switch (argv[i][1]) {
					case 'v':
						show_version();
						return false;
					break;
				}
			}

		} else {
			COMMAND("server", run_server) else 
			COMMAND("connect", run_client) else {
				printf(invalid_command, argv[i], i);
			}
		}
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0x0, (%rcx)
movq %rcx, -0x38(%rbp)
movq $0x0, 0x8(%rcx)
cmpl $0x2, %edi
setl %r12b
jl 0x727a
movq %rsi, %r15
movq %r8, -0x30(%rbp)
movl %edi, %r14d
movl $0x1, %r13d
movq (%r15,%r13,8), %rbx
movq %rbx, %rdi
callq 0x2140
testq %rax, %rax
je 0x7267
cmpb $0x2d, (%rbx)
jne 0x71fb
cmpq $0x2, %rax
je 0x7237
cmpq $0x1, %rax
jne 0x7255
jmp 0x7290
leaq 0x10bc(%rip), %rdi      # 0x82be
movq %rbx, %rsi
callq 0x2210
testl %eax, %eax
je 0x723f
leaq 0x10b0(%rip), %rdi      # 0x82c5
movq %rbx, %rsi
callq 0x2210
testl %eax, %eax
je 0x724b
leaq 0x10ca(%rip), %rdi      # 0x82f2
movq %rbx, %rsi
movl %r13d, %edx
xorl %eax, %eax
callq 0x2030
jmp 0x7255
cmpb $0x76, 0x1(%rbx)
jne 0x7255
jmp 0x72a6
movq -0x38(%rbp), %rax
movl $0x1, (%rax)
jmp 0x7255
movq -0x38(%rbp), %rax
movl $0x2, (%rax)
incq %r13
cmpq %r14, %r13
setae %r12b
jne 0x71d0
jmp 0x727a
leaq 0x10a7(%rip), %rdi      # 0x8315
callq 0x22a0
movq -0x30(%rbp), %rax
movb $0x1, (%rax)
andb $0x1, %r12b
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1036(%rip), %rdi      # 0x82cd
movq %rbx, %rsi
movl %r13d, %edx
xorl %eax, %eax
callq 0x2030
jmp 0x7273
leaq 0x1006(%rip), %rdi      # 0x82b3
leaq 0x107e(%rip), %rsi      # 0x8332
xorl %eax, %eax
callq 0x2030
jmp 0x727a
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/ammarfaizi2[P]riyuu/src/riyuu/riyuu.c
// Function: riyuu_exec_run(_riyuu_run*)
uint8_t riyuu_exec_run(riyuu_run *run)
{
	switch (run->command) {
		case no_command:
		break;

		case run_server: {
			riyuu_server_config config;
			if (riyuu_server_config_parse(run, &config)) {
				return riyuu_server_run(&config);
			}
		}
		break;

		case run_client:
			riyuu_client_run();
		break;
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movl (%rdi), %eax
cmpl $0x2, %eax
je 0x72f3
cmpl $0x1, %eax
jne 0x72f8
leaq -0x18(%rbp), %rsi
callq 0x7498
movl %eax, %ebx
testb %bl, %bl
je 0x72ed
leaq -0x18(%rbp), %rdi
callq 0x76f8
testb %bl, %bl
je 0x72f8
jmp 0x72fa
callq 0x7304
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/ammarfaizi2[P]riyuu/src/riyuu/server/riyuu_server.c
// Function: riyuu_tcp_bind(char*, unsigned short)
void riyuu_tcp_bind(char *addr, uint16_t port)
{
	socklen_t clilen;
	int sockfd, *new_sock_fd;
	struct sockaddr_in serv_addr, cli_addr;
	threadpool thpool;

	sockfd = socket(AF_INET, SOCK_STREAM, 0);

	if (sockfd < 0) {
		perror("Error opening socket");
		exit(1);
	}

	bzero((char *) &serv_addr, sizeof(serv_addr));
	serv_addr.sin_family = AF_INET;
	serv_addr.sin_addr.s_addr = inet_addr(addr);
	serv_addr.sin_port = htons(port);
	if (bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) {
		perror("Error on binding");
		exit(1);
	}
	listen(sockfd, 5);
	clilen = sizeof(cli_addr);

	printf("Listening on %s:%d...\n", addr, port);

	thpool = thpool_init(5);

	// signal(SIGPIPE, SIG_IGN);

	while (1) {
		new_sock_fd = (int *)malloc(sizeof(int));

		*new_sock_fd = accept(sockfd, (struct sockaddr *)&cli_addr, &clilen);
		if (*new_sock_fd < 0) {
			perror("Error on accept");
		}

		thpool_add_work(thpool, riyuu_thread_worker, (void *)new_sock_fd);
	}

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %r12d
movq %rdi, %r15
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2170
testl %eax, %eax
js 0x77fe
movl %eax, %ebx
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %r14
movaps %xmm0, (%r14)
movw $0x2, (%r14)
movq %r15, %rdi
callq 0x2310
movl %eax, 0x4(%r14)
movl %r12d, %eax
rolw $0x8, %ax
movw %ax, 0x2(%r14)
movl %ebx, %edi
movq %r14, %rsi
movl $0x10, %edx
callq 0x2280
testl %eax, %eax
js 0x7807
movl %ebx, %edi
movl $0x5, %esi
callq 0x2300
leaq -0x2c(%rbp), %rax
movl $0x10, (%rax)
movzwl %r12w, %edx
leaq 0xd02(%rip), %rdi       # 0x84a0
movq %r15, %rsi
xorl %eax, %eax
callq 0x2030
movl $0x5, %edi
callq 0x2580
movq %rax, %r15
leaq -0x50(%rbp), %r12
leaq 0xce(%rip), %r13        # 0x788e
movl $0x4, %edi
callq 0x2350
movq %rax, %r14
movl %ebx, %edi
movq %r12, %rsi
leaq -0x2c(%rbp), %rdx
callq 0x2220
movl %eax, (%r14)
testl %eax, %eax
jns 0x77ee
leaq 0xcce(%rip), %rdi       # 0x84b7
callq 0x20d0
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x274d
jmp 0x77c0
leaq 0xc75(%rip), %rdi       # 0x847a
jmp 0x780e
leaq 0xc81(%rip), %rdi       # 0x848f
callq 0x20d0
movl $0x1, %edi
callq 0x21a0
// File: /workspace/github_c_makefile_star2_O1/ammarfaizi2[P]riyuu/src/riyuu/server/riyuu_server.c
// Function: riyuu_socket_setopt(int)
bool riyuu_socket_setopt(int sock_fd)
{
	struct timeval timeout;

	timeout.tv_sec = 30;
	timeout.tv_usec = 0;

	if (setsockopt(sock_fd, SOL_SOCKET, SO_RCVTIMEO, (void *)&timeout, sizeof(timeout)) < 0) {
		perror("setsockopt failed\n");
		return false;
	}

	if (setsockopt(sock_fd, SOL_SOCKET, SO_SNDTIMEO, (void *)&timeout, sizeof(timeout)) < 0) {
		perror("setsockopt failed\n");
		return false;
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
leaq -0x18(%rbp), %rcx
movq $0x1e, (%rcx)
movq $0x0, 0x8(%rcx)
movl $0x1, %esi
movl $0x14, %edx
movl $0x10, %r8d
callq 0x2060
testl %eax, %eax
js 0x787e
leaq -0x18(%rbp), %rcx
movl %ebx, %edi
movl $0x1, %esi
movl $0x15, %edx
movl $0x10, %r8d
callq 0x2060
movl %eax, %ecx
movb $0x1, %al
testl %ecx, %ecx
js 0x787e
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq 0xb90(%rip), %rdi       # 0x8415
callq 0x20d0
xorl %eax, %eax
jmp 0x7877
// File: /workspace/github_c_makefile_star2_O1/ammarfaizi2[P]riyuu/src/riyuu/server/riyuu_server.c
// Function: riyuu_thread_worker(void*)
void *riyuu_thread_worker(void *_fd)
{
	#define sock_fd (*((int *)_fd))

	riyuu_data *req;
	riyuu_data *tmp;
	bool exec_return = false;

	if (!riyuu_socket_setopt(sock_fd)) {
		goto out;
	}

	req = (riyuu_data *)malloc(sizeof(riyuu_data));
	if (req == NULL) {
		printf("Cannot allocate memory!\n");
		goto out;
	}

	printf("A new client connected with fd: %d\n", sock_fd);

	while (1) {
		ssize_t n;

		// Read data size.
		n = read(sock_fd, &(req->data_size), sizeof(uint32_t));
		if (n < 0) {
			perror("Error read");
			break;
		}

		write(sock_fd, "OK", 2);

		PRINTF_DEBUG("Got data length: %d\n", req->data_size);

		// Read data.
		req->data = (char *)malloc(sizeof(char) * req->data_size);

		n = read(sock_fd, req->data, req->data_size);
		if (n < 0) {
			perror("Error read");
			break;
		}
		
		PRINTF_DEBUG("Got data: %s\n", req->data);

		// // Process the request.
		// exec_return = riyuu_exec_request(sock_fd, req);
		// free(req);

		// if (!exec_return) break;
	}

	out:
	close(sock_fd);
	free(_fd);

	#undef sock_fd

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x781d
testb %al, %al
je 0x78c5
movl $0x10, %edi
callq 0x2350
testq %rax, %rax
jne 0x78e5
leaq 0xc07(%rip), %rdi       # 0x84c7
callq 0x22a0
movl (%rbx), %edi
callq 0x2080
movq %rbx, %rdi
callq 0x2340
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl (%rbx), %esi
leaq 0xb37(%rip), %rdi       # 0x8428
xorl %eax, %eax
callq 0x2030
movl (%rbx), %edi
movl $0x4, %edx
movq %r14, %rsi
callq 0x21e0
testq %rax, %rax
js 0x797c
leaq 0xb59(%rip), %r13       # 0x846c
movl (%rbx), %edi
movl $0x2, %edx
leaq 0xa33(%rip), %rsi       # 0x8354
callq 0x22b0
movl (%r14), %r12d
leaq 0xb27(%rip), %rdi       # 0x8457
movl %r12d, %esi
xorl %eax, %eax
callq 0x2030
movq %r12, %rdi
callq 0x2350
movq %rax, %r15
movq %rax, 0x8(%r14)
movl (%rbx), %edi
movq %rax, %rsi
movq %r12, %rdx
callq 0x21e0
testq %rax, %rax
js 0x797c
movq %r13, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2030
movl (%rbx), %edi
movl $0x4, %edx
movq %r14, %rsi
callq 0x21e0
testq %rax, %rax
jns 0x7913
leaq 0xac9(%rip), %rdi       # 0x844c
callq 0x20d0
jmp 0x78c5
// File: /workspace/github_c_makefile_star2_O1/ls4154[P]hash-c/sha224_check.c
// Function: main
int main(int argc, char **argv)
{
	int fd = STDIN_FILENO;
	if (argc > 1 && (fd = open(argv[1], O_RDONLY)) < 0) {
		fprintf(stderr, "%s : cannot access '%s'\n", argv[0], argv[1]);
		exit(EXIT_FAILURE);
	}

	struct sha224_ctx ctx;
	sha224_init(&ctx);

	int total = 0;
	int rd = 0;
	while ((rd = read(fd, buffer + total, CHUNK_SIZE - total)) > 0) {
		total += rd;
		if (total >= CHUNK_SIZE) {
			sha224_update(&ctx, buffer);
			total = 0;
		}
	}
	sha224_update_last(&ctx, buffer, total);

	for (int i = 0; i < WORD_CNT - 1; ++i)
		printf("%08x", ctx.h[i]);
	printf("\n");

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
xorl %ebx, %ebx
cmpl $0x2, %edi
jl 0x11fa
movq %rsi, %r14
movq 0x8(%rsi), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x1080
movl %eax, %ebx
testl %eax, %eax
js 0x12ac
leaq 0x8(%rsp), %rdi
callq 0x12b8
leaq 0x2e65(%rip), %r14      # 0x4070
movl $0x40, %edx
movl %ebx, %edi
movq %r14, %rsi
callq 0x1050
xorl %r13d, %r13d
testl %eax, %eax
jle 0x1259
leaq 0x8(%rsp), %r15
addl %r13d, %eax
cmpl $0x40, %eax
jl 0x123b
movq %r15, %rdi
movq %r14, %rsi
callq 0x12d6
xorl %eax, %eax
movl %eax, %r13d
movl %eax, %r12d
leaq (%r14,%r12), %rsi
movl $0x40, %edx
subl %eax, %edx
movl %ebx, %edi
callq 0x1050
testl %eax, %eax
jg 0x1226
jmp 0x125c
xorl %r12d, %r12d
leaq 0x2e0d(%rip), %rsi      # 0x4070
leaq 0x8(%rsp), %rdi
movq %r12, %rdx
callq 0x14ad
leaq 0xda6(%rip), %rbx       # 0x201d
xorl %r14d, %r14d
movl 0x8(%rsp,%r14,4), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1040
incq %r14
cmpq $0x7, %r14
jne 0x127a
movl $0xa, %edi
callq 0x1030
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x8(%r14), %rsi
movq %r14, %rdi
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/ls4154[P]hash-c/sha224.c
// Function: sha224_update_last
void sha224_update_last(struct sha224_ctx *ctx, byte_t *chunk, len_t len)
{
	ctx->len += len;
	len_t bit_len = ctx->len * 8;

	byte_t padding[64];
	memset(padding, 0, sizeof(padding));

	memcpy(padding, chunk, len);
	*(padding + len) = 0x80;

	if (len >= 56) {
		_sha224_iterate(ctx, padding);
		memset(padding, 0, sizeof(padding));
	}

	byte_t *ptr = padding + 56;
	for (int i = 7; i >= 0; --i) {
		*ptr = (bit_len >> 8 * i) & 0xFF;
		++ptr;
	}
	_sha224_iterate(ctx, padding);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %r15
addq %rdx, %r15
movq %r15, 0x20(%rdi)
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x1070
movb $-0x80, (%rsp,%r14)
cmpq $0x37, %r14
jbe 0x1510
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12e6
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
shlq $0x3, %r15
movl $0x38, %ecx
leaq 0x38(%rsp), %rax
movq %r15, %rdx
shrq %cl, %rdx
movb %dl, (%rax)
addq $-0x8, %rcx
incq %rax
cmpq $-0x8, %rcx
jne 0x151e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x12e6
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ls4154[P]hash-c/sha224.c
// Function: sha224_offline
void sha224_offline(struct sha224_ctx *ctx, byte_t *msg, len_t len)
{
	sha224_init(ctx);

	while (len >= 64) {
		sha224_update(ctx, msg);

		msg += 64;
		len -= 64;
	}

	sha224_update_last(ctx, msg, len);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movaps 0xad3(%rip), %xmm0      # 0x2030
movups %xmm0, (%rdi)
movaps 0xad9(%rip), %xmm0      # 0x2040
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
cmpq $0x40, %rdx
jb 0x1597
movq %r15, %rdi
movq %r14, %rsi
callq 0x12e6
addq $0x40, 0x20(%r15)
addq $0x40, %r14
addq $-0x40, %rbx
cmpq $0x3f, %rbx
ja 0x1579
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x14ad
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/audio.c
// Function: AUD_init
void AUD_init(Audio* audio, int sampleRate) {
    SDL_Init(SDL_INIT_AUDIO);

    audio->sampleRate = sampleRate;
    for (int i = 0; i < 4; ++i) {
        AudioChannel channel;
        channel.frequency = 0.0;
        channel.amplitude = 4400.0;
        channel.time = 0.0;
        audio->channels[i] = channel;
    }

    SDL_AudioSpec want;
    want.freq = audio->sampleRate;
    want.format = AUDIO_S16SYS;
    want.channels = 1;
    want.samples = 2048;
    want.callback = audioCallback;
    want.userdata = audio;

    SDL_AudioSpec have;
    //SDL_OpenAudio(&want, &have);
    audio->deviceId = SDL_OpenAudioDevice(NULL, 0, &want, &have, SDL_AUDIO_ALLOW_ANY_CHANGE);

    SDL_PauseAudioDevice(audio->deviceId, false);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl $0x10, %edi
callq 0x2140
movl %ebp, 0x4(%rbx)
movl $0x18, %eax
xorl %ecx, %ecx
movabsq $0x40b1300000000000, %rdx # imm = 0x40B1300000000000
movq %rcx, -0x10(%rbx,%rax)
movq %rdx, -0x8(%rbx,%rax)
movq %rcx, (%rbx,%rax)
addq $0x20, %rax
cmpq $0x98, %rax
jne 0x23c5
leaq 0x28(%rsp), %rdx
movl %ebp, (%rdx)
movw $0x8010, 0x4(%rdx)      # imm = 0x8010
movb $0x1, 0x6(%rdx)
movw $0x800, 0x8(%rdx)       # imm = 0x800
leaq 0x2e(%rip), %rax        # 0x242b
movq %rax, 0x10(%rdx)
movq %rbx, 0x18(%rdx)
leaq 0x8(%rsp), %rcx
xorl %edi, %edi
xorl %esi, %esi
movl $0xf, %r8d
callq 0x21d0
movl %eax, (%rbx)
movl %eax, %edi
xorl %esi, %esi
callq 0x21f0
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/audio.c
// Function: audioCallback
void audioCallback(void *user_data, uint8_t *raw_buffer, int bytes) {
    Audio* audio = user_data;
    int16_t* snd = (int16_t*) raw_buffer;
	int len = bytes / sizeof(*snd);

    for (int i = 0; i < len; ++i) {
        snd[i] = 0;

        for (int j = 0; j < 3; ++j) {
            AudioChannel* channel = &(audio->channels[j]);
            double sine = sin(channel->time);
            double ampMultiplier = (sine > 0) - (sine < 0);
            snd[i] += (channel->amplitude * ampMultiplier) / 3;

            channel->time += channel->frequency * 2.0f * M_PI / audio->sampleRate;
            if (channel->time >= (2.0f * M_PI)) channel->time -= (2.0f * M_PI);
        }
    }
}

// Assembly:
sarl %edx
testl %edx, %edx
jle 0x252d
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r15d
xorl %r12d, %r12d
movw $0x0, (%rbx,%r12,2)
movl $0x18, %r13d
movsd (%r14,%r13), %xmm0
callq 0x2090
movsd 0x5ba6(%rip), %xmm3     # 0x8010
movsd 0x5b96(%rip), %xmm2     # 0x8008
xorpd %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
seta %al
xorl %ecx, %ecx
ucomisd %xmm0, %xmm1
seta %cl
subl %ecx, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd -0x8(%r14,%r13), %xmm0
movswl (%rbx,%r12,2), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd %xmm2, %xmm0
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movw %ax, (%rbx,%r12,2)
movsd -0x10(%r14,%r13), %xmm0
addsd %xmm0, %xmm0
mulsd %xmm3, %xmm0
movsd 0x5b54(%rip), %xmm3     # 0x8020
movsd 0x5b44(%rip), %xmm2     # 0x8018
xorps %xmm1, %xmm1
cvtsi2sdl 0x4(%r14), %xmm1
divsd %xmm1, %xmm0
addsd (%r14,%r13), %xmm0
movapd %xmm0, %xmm1
addsd %xmm2, %xmm1
movapd %xmm3, %xmm2
cmpnlesd %xmm0, %xmm2
andpd %xmm2, %xmm0
andnpd %xmm1, %xmm2
orpd %xmm0, %xmm2
movlpd %xmm2, (%r14,%r13)
addq $0x20, %r13
cmpq $0x78, %r13
jne 0x2457
incq %r12
cmpq %r15, %r12
jne 0x244a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/audio.c
// Function: AUD_destroy
void AUD_destroy(Audio* audio) {
    SDL_PauseAudioDevice(audio->deviceId, true);
    SDL_AudioQuit();
    free(audio);
    audio = NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %edi
movl $0x1, %esi
callq 0x21f0
callq 0x2270
movq %rbx, %rdi
popq %rbx
jmp 0x21b0
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/audio.c
// Function: AUD_update
void AUD_update(Audio* audio, Memory* mem) {
    unsigned int x;

    x = ((mem->logicalMemory[REG_NR14] & 0x7) << 8) | mem->logicalMemory[REG_NR13];
    audio->channels[0].frequency = 131072.0 / (2048.0 - x);
    if (audio->channels[0].frequency < 100.0) audio->channels[0].frequency = 0.0;

    x = ((mem->logicalMemory[REG_NR24] & 0x7) << 8) | mem->logicalMemory[REG_NR23];
    audio->channels[1].frequency = 131072.0 / (2048.0 - x);
    if (audio->channels[1].frequency < 100.0) audio->channels[1].frequency = 0.0;

    x = ((mem->logicalMemory[REG_NR34] & 0x7) << 8) | mem->logicalMemory[REG_NR33];
    audio->channels[2].frequency = getBit(mem->logicalMemory[REG_NR30], 7) ? (65536.0 / (2048.0 - x)) : 0.0;
    if (audio->channels[0].frequency < 100.0) audio->channels[0].frequency = 0.0;
}

// Assembly:
movzbl 0xff14(%rsi), %eax
andl $0x7, %eax
shll $0x8, %eax
movzbl 0xff13(%rsi), %ecx
orl %eax, %ecx
cvtsi2sd %ecx, %xmm0
movsd 0x5aba(%rip), %xmm1     # 0x8028
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
movsd 0x5ab2(%rip), %xmm3     # 0x8030
movapd %xmm3, %xmm0
divsd %xmm2, %xmm0
movsd 0x5aaa(%rip), %xmm2     # 0x8038
movapd %xmm0, %xmm4
cmpltsd %xmm2, %xmm4
andnpd %xmm0, %xmm4
movlpd %xmm4, 0x8(%rdi)
movzbl 0xff19(%rsi), %eax
andl $0x7, %eax
shll $0x8, %eax
movzbl 0xff18(%rsi), %ecx
orl %eax, %ecx
xorps %xmm4, %xmm4
cvtsi2sd %ecx, %xmm4
movapd %xmm1, %xmm5
subsd %xmm4, %xmm5
divsd %xmm5, %xmm3
movapd %xmm3, %xmm4
cmpltsd %xmm2, %xmm4
andnpd %xmm3, %xmm4
movlpd %xmm4, 0x28(%rdi)
cmpb $0x0, 0xff1a(%rsi)
xorpd %xmm3, %xmm3
jns 0x2615
movzbl 0xff1e(%rsi), %eax
andl $0x7, %eax
shll $0x8, %eax
movzbl 0xff1d(%rsi), %ecx
orl %eax, %ecx
xorps %xmm3, %xmm3
cvtsi2sd %ecx, %xmm3
subsd %xmm3, %xmm1
movsd 0x5a2f(%rip), %xmm3     # 0x8040
divsd %xmm1, %xmm3
ucomisd %xmm0, %xmm2
movsd %xmm3, 0x48(%rdi)
jbe 0x2628
movq $0x0, 0x8(%rdi)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/cartridge.c
// Function: MBC1
static void MBC1(Memory* mem, uint16_t address, uint8_t value) {
    Cartridge* cart = mem->cartridge;

    if (address <= 0x1FFF) {
        cart->RAMG = value & 0xF;
        mem->extRamEnabled = (cart->RAMG == 0xA);

    } else if (address <= 0x3FFF) {
        cart->BANK1 = value & 0x1F;
        if (cart->BANK1 == 0x00) cart->BANK1 = 0x01;
        if (cart->MODE == 0) {
            MEM_setRomBank(mem, (cart->BANK2 << 5) | cart->BANK1);
        } else {
            MEM_setRomBank(mem, cart->BANK1);
        }

    } else if (address <= 0x5FFF) {
        cart->BANK2 = value & 0x3;
        if (cart->MODE == 0) {
            MEM_setRomBank(mem, (cart->BANK2 << 5) | cart->BANK1);
        } else {
            MEM_setRamBank(mem, cart->BANK2);
        }

    } else if (address <= 0x7FFF) {
        cart->MODE = value & 0x1;

    }
}

// Assembly:
movq 0x10038(%rdi), %rax
cmpl $0x1fff, %esi           # imm = 0x1FFF
ja 0x269c
andb $0xf, %dl
movb %dl, 0x14(%rax)
cmpb $0xa, %dl
sete 0x10034(%rdi)
retq
movzwl %si, %ecx
cmpl $0x3fff, %ecx           # imm = 0x3FFF
ja 0x26c9
andb $0x1f, %dl
movzbl %dl, %edx
cmpb $0x2, %dl
movl $0x1, %ecx
cmovael %edx, %ecx
movb %cl, 0x15(%rax)
cmpb $0x0, 0x17(%rax)
je 0x26f1
movzbl %cl, %esi
jmp 0x6eb5
cmpl $0x5fff, %ecx           # imm = 0x5FFF
ja 0x26e5
andb $0x3, %dl
movb %dl, 0x16(%rax)
cmpb $0x0, 0x17(%rax)
je 0x2701
movzbl %dl, %esi
jmp 0x6f09
testw %si, %si
js 0x26f0
andb $0x1, %dl
movb %dl, 0x17(%rax)
retq
movb 0x16(%rax), %al
shlb $0x5, %al
orb %cl, %al
movzbl %al, %esi
jmp 0x6eb5
shlb $0x5, %dl
orb 0x15(%rax), %dl
movzbl %dl, %esi
jmp 0x6eb5
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/cartridge.c
// Function: MBC3
static void MBC3(Memory* mem, uint16_t address, uint8_t value) {
    //unimplemented(MEM_getByte(mem, 0x0147)); // TODO: MBC3
    Cartridge* cart = mem->cartridge;

    if (address <= 0x1FFF) {
        cart->RAMG = value & 0xF;
        mem->extRamEnabled = (cart->RAMG == 0xA);

    } else if (address <= 0x3FFF) {
        cart->ROMB = value & 0x7F;
        if (cart->ROMB == 0) cart->ROMB = 1;
        MEM_setRomBank(mem, cart->ROMB);

    } else if (address <= 0x5FFF) {

    }
}

// Assembly:
movq 0x10038(%rdi), %rax
cmpl $0x1fff, %esi           # imm = 0x1FFF
ja 0x288d
andb $0xf, %dl
movb %dl, 0x14(%rax)
cmpb $0xa, %dl
sete 0x10034(%rdi)
retq
movzwl %si, %ecx
cmpl $0x3fff, %ecx           # imm = 0x3FFF
ja 0x28b4
andb $0x7f, %dl
movzbl %dl, %ecx
cmpb $0x2, %cl
movl $0x1, %edx
cmovael %ecx, %edx
movb %dl, 0x18(%rax)
movzbl %dl, %esi
jmp 0x6eb5
retq
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/cartridge.c
// Function: CART_mbcDispatch
void CART_mbcDispatch(Memory* mem, uint16_t address, uint8_t value) {
    uint8_t mbcCode = MEM_getByte(mem, 0x0147);
    void (*mbcFunction)(Memory*, uint16_t, uint8_t) = MBC_MAP[mbcCode];
    if (mbcFunction == NULL) {
        printf("Undefined MBC: 0x%x\n", mbcCode);
    } else {
        mbcFunction(mem, address, value);
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl $0x147, %esi            # imm = 0x147
callq 0x6a94
movzbl %al, %esi
leaq 0x96f8(%rip), %rax      # 0xc150
movq (%rax,%rsi,8), %rax
testq %rax, %rax
je 0x2a70
movzwl %bp, %esi
movzbl %bl, %edx
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
leaq 0x55d1(%rip), %rdi      # 0x8048
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x2050
nop
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/asm.h
// Function: ASM_INC_n
static inline void ASM_INC_n(CPU* cpu, uint8_t* reg) {
    uint8_t result = *reg + 1;
    CPU_setFlagZ(cpu, result == 0);
    CPU_setFlagN(cpu, 0);
    CPU_setFlagH(cpu, (*reg & 0x10) != (result & 0x10));
    *reg = result;
    cpu->PC += 1;
}

// Assembly:
movb (%rsi), %al
incb %al
sete %cl
movb 0x2(%rdi), %dl
andb $0x3f, %dl
shlb $0x7, %cl
orb %dl, %cl
movb %cl, 0x2(%rdi)
movb (%rsi), %dl
xorb %al, %dl
andb $-0x61, %cl
addb %dl, %dl
andb $0x20, %dl
orb %cl, %dl
movb %dl, 0x2(%rdi)
movb %al, (%rsi)
incw 0xc(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/asm.h
// Function: ASM_DEC_n
static inline void ASM_DEC_n(CPU* cpu, uint8_t* reg) {
    uint8_t result = *reg - 1;
    CPU_setFlagZ(cpu, result == 0);
    CPU_setFlagN(cpu, 1);
    CPU_setFlagH(cpu, (*reg & 0x10) != (result & 0x10));
    *reg = result;
    cpu->PC += 1;
}

// Assembly:
movb (%rsi), %al
decb %al
sete %cl
movb 0x2(%rdi), %dl
andb $0x3f, %dl
shlb $0x7, %cl
orb %dl, %cl
orb $0x40, %cl
movb %cl, 0x2(%rdi)
movb (%rsi), %dl
xorb %al, %dl
andb $-0x21, %cl
addb %dl, %dl
andb $0x20, %dl
orb %cl, %dl
movb %dl, 0x2(%rdi)
movb %al, (%rsi)
incw 0xc(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/asm.h
// Function: ASM_LD_nn_SP
static inline void ASM_LD_nn_SP(CPU* cpu, Memory* mem) {
    //cpu->SP = (MEM_getByte(mem, cpu->PC + 2) << 8) | MEM_getByte(mem, cpu->PC + 1);
    uint16_t address = (MEM_getByte(mem, cpu->PC + 2) << 8) | MEM_getByte(mem, cpu->PC + 1);
    MEM_setByte(mem, address, cpu->SP & 0xFF);
    MEM_setByte(mem, address + 1, (cpu->SP & 0xFF00) >> 8);
    cpu->PC += 3;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0xc(%rdi), %esi
addl $0x2, %esi
movl $0xffff, %ebp           # imm = 0xFFFF
andl %ebp, %esi
movq %r14, %rdi
callq 0x6a94
movzbl %al, %r15d
shll $0x8, %r15d
movl 0xc(%rbx), %esi
incl %esi
andl %ebp, %esi
movq %r14, %rdi
callq 0x6a94
movzbl %al, %r12d
leal (%r15,%r12), %esi
movzbl 0xa(%rbx), %edx
andl %ebp, %esi
movq %r14, %rdi
callq 0x6b05
leal (%r15,%r12), %esi
incl %esi
movzbl 0xb(%rbx), %edx
andl %ebp, %esi
movq %r14, %rdi
callq 0x6b05
addw $0x3, 0xc(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/asm.h
// Function: ASM_ADD_HL_n
static inline void ASM_ADD_HL_n(CPU* cpu, uint16_t* reg) {
    uint16_t result = cpu->HL + *reg;
    CPU_setFlagN(cpu, 0);
    CPU_setFlagH(cpu, ((cpu->HL ^ *reg ^ (result & 0xFFFF)) & 0x1000) != 0);
    CPU_setFlagC(cpu, result < cpu->HL);
    cpu->HL = result;
    cpu->PC += 1;
}

// Assembly:
movzwl 0x8(%rdi), %eax
movzwl (%rsi), %ecx
addw %ax, %cx
setb %dl
movb 0x2(%rdi), %r8b
movl %r8d, %r9d
andb $-0x41, %r9b
movb %r9b, 0x2(%rdi)
xorw (%rsi), %ax
xorl %ecx, %eax
andb $-0x71, %r8b
shrl $0x7, %eax
andb $0x20, %al
shlb $0x4, %dl
orb %r8b, %dl
orb %al, %dl
movb %dl, 0x2(%rdi)
movw %cx, 0x8(%rdi)
incw 0xc(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/asm.h
// Function: ASM_JP_cc_nn
static inline int ASM_JP_cc_nn(CPU* cpu, Memory* mem, int ccCode) {
    int cond = 0;
    switch (ccCode) {
        case PARAM_CC_Z:
            cond = CPU_getFlagZ(cpu);
            break;
        case PARAM_CC_NZ:
            cond = !CPU_getFlagZ(cpu);
            break;
        case PARAM_CC_C:
            cond = CPU_getFlagC(cpu);
            break;
        case PARAM_CC_NC:
            cond = !CPU_getFlagC(cpu);
            break;
    }
    if (cond) {
        cpu->PC = (MEM_getByte(mem, cpu->PC + 2) << 8) | MEM_getByte(mem, cpu->PC + 1);
        return 1;
    } else {
        cpu->PC += 3;
        return 0;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0x2(%rdi), %eax
addl $-0x64, %edx
leaq 0x3e63(%rip), %rcx      # 0x8878
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
xorl %ecx, %ecx
testb %al, %al
setns %cl
jmp 0x4a2e
xorl %ecx, %ecx
testb $0x10, %al
sete %cl
movl %ecx, %eax
jmp 0x4a3d
shrl $0x4, %eax
andl $0x1, %eax
jmp 0x4a3d
shrl $0x7, %eax
movzwl 0xc(%rbx), %esi
testl %eax, %eax
je 0x4a7b
addl $0x2, %esi
movl $0xffff, %ebp           # imm = 0xFFFF
andl %ebp, %esi
movq %r14, %rdi
callq 0x6a94
movzbl %al, %r15d
shll $0x8, %r15d
movl 0xc(%rbx), %esi
incl %esi
andl %ebp, %esi
movq %r14, %rdi
callq 0x6a94
movzbl %al, %esi
orl %r15d, %esi
movl $0x1, %eax
jmp 0x4a80
addl $0x3, %esi
xorl %eax, %eax
movw %si, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/asm.h
// Function: ASM_JR_cc_n
static inline int ASM_JR_cc_n(CPU* cpu, Memory* mem, int ccCode) {
    int cond = 0;
    switch (ccCode) {
        case PARAM_CC_Z:
            cond = CPU_getFlagZ(cpu);
            break;
        case PARAM_CC_NZ:
            cond = !CPU_getFlagZ(cpu);
            break;
        case PARAM_CC_C:
            cond = CPU_getFlagC(cpu);
            break;
        case PARAM_CC_NC:
            cond = !CPU_getFlagC(cpu);
            break;
    }
    if (cond) {
        cpu->PC += ((int8_t) MEM_getByte(mem, cpu->PC + 1)) + 2;
        return 1;
    } else {
        cpu->PC += 2;
        return 0;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movzbl 0x2(%rdi), %eax
addl $-0x64, %edx
leaq 0x3de7(%rip), %rcx      # 0x8888
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
xorl %ecx, %ecx
testb %al, %al
setns %cl
jmp 0x4aba
xorl %ecx, %ecx
testb $0x10, %al
sete %cl
movl %ecx, %eax
jmp 0x4ac9
shrl $0x4, %eax
andl $0x1, %eax
jmp 0x4ac9
shrl $0x7, %eax
movzwl 0xc(%rbx), %ecx
testl %eax, %eax
je 0x4af1
incl %ecx
movzwl %cx, %eax
movq %rsi, %rdi
movl %eax, %esi
callq 0x6a94
movsbl %al, %ecx
addw 0xc(%rbx), %cx
addl $0x2, %ecx
movl $0x1, %eax
jmp 0x4af6
addl $0x2, %ecx
xorl %eax, %eax
movw %cx, 0xc(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/asm.h
// Function: ASM_LDI_HL_A
static inline void ASM_LDI_HL_A(CPU* cpu, Memory* mem) {
    uint16_t address = (cpu->H << 8) | cpu->L;
    MEM_setByte(mem, address, cpu->A);
    ++address;
    cpu->H = (address & 0xFF00) >> 8;
    cpu->L = address & 0x00FF;
    cpu->PC += 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzwl 0x8(%rdi), %ebp
movzbl 0x3(%rdi), %edx
movq %rsi, %rdi
movl %ebp, %esi
callq 0x6b05
incl %ebp
movw %bp, 0x8(%rbx)
incw 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/asm.h
// Function: ASM_LDI_A_HL
static inline void ASM_LDI_A_HL(CPU* cpu, Memory* mem) {
    uint16_t address = (cpu->H << 8) | cpu->L;
    cpu->A = MEM_getByte(mem, address);
    ++address;
    cpu->H = (address & 0xFF00) >> 8;
    cpu->L = address & 0x00FF;
    cpu->PC += 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbp
movzwl 0x8(%rdi), %ebx
movq %rsi, %rdi
movl %ebx, %esi
callq 0x6a94
movb %al, 0x3(%rbp)
incl %ebx
movb %bh, 0x9(%rbp)
movb %bl, 0x8(%rbp)
incw 0xc(%rbp)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/asm.h
// Function: ASM_LDD_HL_A
static inline void ASM_LDD_HL_A(CPU* cpu, Memory* mem) {
    uint16_t address = (cpu->H << 8) | cpu->L;
    MEM_setByte(mem, address, cpu->A);
    --address;
    cpu->H = (address & 0xFF00) >> 8;
    cpu->L = address & 0x00FF;
    cpu->PC += 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzwl 0x8(%rdi), %ebp
movzbl 0x3(%rdi), %edx
movq %rsi, %rdi
movl %ebp, %esi
callq 0x6b05
decl %ebp
movw %bp, 0x8(%rbx)
incw 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/asm.h
// Function: ASM_INC_m
static inline void ASM_INC_m(CPU* cpu, Memory* mem, uint16_t address) {
    uint8_t result = MEM_getByte(mem, address) + 1;
    CPU_setFlagZ(cpu, result == 0);
    CPU_setFlagN(cpu, 0);
    CPU_setFlagH(cpu, (MEM_getByte(mem, address) & 0x10) != (result & 0x10));
    MEM_setByte(mem, address, result);
    cpu->PC += 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
callq 0x6a94
movl %eax, %r15d
incb %r15b
sete %al
movb 0x2(%rbx), %cl
andb $0x3f, %cl
shlb $0x7, %al
orb %cl, %al
movb %al, 0x2(%rbx)
movq %r14, %rdi
movl %ebp, %esi
callq 0x6a94
xorb %r15b, %al
movb 0x2(%rbx), %cl
andb $-0x21, %cl
addb %al, %al
andb $0x20, %al
orb %cl, %al
movb %al, 0x2(%rbx)
movzbl %r15b, %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0x6b05
incw 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/asm.h
// Function: ASM_DEC_m
static inline void ASM_DEC_m(CPU* cpu, Memory* mem, uint16_t address) {
    uint8_t result = MEM_getByte(mem, address) - 1;
    CPU_setFlagZ(cpu, result == 0);
    CPU_setFlagN(cpu, 1);
    CPU_setFlagH(cpu, (MEM_getByte(mem, address) & 0x10) != (result & 0x10));
    MEM_setByte(mem, address, result);
    cpu->PC += 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
callq 0x6a94
movl %eax, %r15d
decb %r15b
sete %al
movb 0x2(%rbx), %cl
andb $0x3f, %cl
shlb $0x7, %al
orb %cl, %al
orb $0x40, %al
movb %al, 0x2(%rbx)
movq %r14, %rdi
movl %ebp, %esi
callq 0x6a94
xorb %r15b, %al
movb 0x2(%rbx), %cl
andb $-0x21, %cl
addb %al, %al
andb $0x20, %al
orb %cl, %al
movb %al, 0x2(%rbx)
movzbl %r15b, %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0x6b05
incw 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/asm.h
// Function: ASM_ADD_A_n
static inline void ASM_ADD_A_n(CPU* cpu, uint8_t* reg) {
    uint16_t result = cpu->A + *reg;
    CPU_setFlagZ(cpu, ((uint8_t) result) == 0);
    CPU_setFlagN(cpu, 0);
    CPU_setFlagH(cpu, (((cpu->A & 0xF) + (*reg & 0xF)) & 0x10) == 0x10);
    CPU_setFlagC(cpu, result > 0xFF);
    cpu->A = (uint8_t) result;
    cpu->PC += 1;
}

// Assembly:
movzbl 0x3(%rdi), %edx
movzbl (%rsi), %eax
addl %edx, %eax
cmpl $0x100, %eax            # imm = 0x100
setae %cl
testb %al, %al
sete %r8b
movb 0x2(%rdi), %r9b
andb $0x3f, %r9b
shlb $0x7, %r8b
orb %r9b, %r8b
movb %r8b, 0x2(%rdi)
andb $0xf, %dl
movb (%rsi), %sil
andb $0xf, %sil
addb %dl, %sil
cmpb $0x10, %sil
setae %dl
andb $-0x71, %r8b
shlb $0x5, %dl
shlb $0x4, %cl
orb %dl, %cl
orb %r8b, %cl
movb %cl, 0x2(%rdi)
movb %al, 0x3(%rdi)
incw 0xc(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/asm.h
// Function: ASM_ADD_A_m
static inline void ASM_ADD_A_m(CPU* cpu, Memory* mem, uint16_t address) {
    uint16_t result = cpu->A + MEM_getByte(mem, address);
    CPU_setFlagZ(cpu, ((uint8_t) result) == 0);
    CPU_setFlagN(cpu, 0);
    CPU_setFlagH(cpu, (((cpu->A & 0xF) + (MEM_getByte(mem, address) & 0xF)) & 0x10) == 0x10);
    CPU_setFlagC(cpu, result > 0xFF);
    cpu->A = (uint8_t) result;
    cpu->PC += 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0x3(%rdi), %r12d
movq %rsi, %rdi
movl %edx, %esi
callq 0x6a94
movzbl %al, %r15d
addl %r12d, %r15d
cmpl $0x100, %r15d           # imm = 0x100
setae %r12b
testb %r15b, %r15b
sete %al
movb 0x2(%rbx), %cl
movb 0x3(%rbx), %r13b
andb $0x3f, %cl
shlb $0x7, %al
orb %cl, %al
movb %al, 0x2(%rbx)
andb $0xf, %r13b
movq %r14, %rdi
movl %ebp, %esi
callq 0x6a94
andb $0xf, %al
addb %r13b, %al
cmpb $0x10, %al
setae %al
movb 0x2(%rbx), %cl
andb $-0x31, %cl
shlb $0x5, %al
shlb $0x4, %r12b
orb %cl, %r12b
orb %al, %r12b
movb %r12b, 0x2(%rbx)
movb %r15b, 0x3(%rbx)
incw 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/asm.h
// Function: ASM_ADC_A_n
static inline void ASM_ADC_A_n(CPU* cpu, uint8_t* reg) {
    int carry = CPU_getFlagC(cpu);
    uint16_t result = cpu->A + *reg + carry;
    CPU_setFlagZ(cpu, ((uint8_t) result) == 0);
    CPU_setFlagN(cpu, 0);
    CPU_setFlagH(cpu, (((cpu->A & 0xF) + (*reg & 0xF) + (carry & 0xF)) & 0x10) == 0x10);
    CPU_setFlagC(cpu, result > 0xFF);
    cpu->A = (uint8_t) result;
    cpu->PC += 1;
}

// Assembly:
movzbl 0x2(%rdi), %r8d
movl %r8d, %ecx
shrl $0x4, %ecx
andl $0x1, %ecx
movzbl 0x3(%rdi), %r9d
movzbl (%rsi), %eax
addl %r9d, %eax
addl %ecx, %eax
cmpl $0x100, %eax            # imm = 0x100
setae %dl
testb %al, %al
sete %r10b
andb $0x3f, %r8b
shlb $0x7, %r10b
orb %r8b, %r10b
movb %r10b, 0x2(%rdi)
andb $0xf, %r9b
movb (%rsi), %sil
andb $0xf, %sil
addb %r9b, %sil
addb %cl, %sil
andb $-0x71, %r10b
addb %sil, %sil
andb $0x20, %sil
shlb $0x4, %dl
orb %sil, %dl
orb %r10b, %dl
movb %dl, 0x2(%rdi)
movb %al, 0x3(%rdi)
incw 0xc(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/asm.h
// Function: ASM_ADC_A_m
static inline void ASM_ADC_A_m(CPU* cpu, Memory* mem, uint16_t address) {
    int carry = CPU_getFlagC(cpu);
    uint16_t result = cpu->A + MEM_getByte(mem, address) + carry;
    CPU_setFlagZ(cpu, ((uint8_t) result) == 0);
    CPU_setFlagN(cpu, 0);
    CPU_setFlagH(cpu, (((cpu->A & 0xF) + (MEM_getByte(mem, address) & 0xF) + (carry & 0xF)) & 0x10) == 0x10);
    CPU_setFlagC(cpu, result > 0xFF);
    cpu->A = (uint8_t) result;
    cpu->PC += 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, 0x4(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0x2(%rdi), %r12d
shrl $0x4, %r12d
andl $0x1, %r12d
movzbl 0x3(%rdi), %r13d
movq %rsi, %rdi
movl %edx, %esi
callq 0x6a94
movzbl %al, %r15d
addl %r13d, %r15d
addl %r12d, %r15d
cmpl $0x100, %r15d           # imm = 0x100
setae %r13b
testb %r15b, %r15b
sete %al
movb 0x2(%rbx), %cl
movb 0x3(%rbx), %bpl
andb $0x3f, %cl
shlb $0x7, %al
orb %cl, %al
movb %al, 0x2(%rbx)
andb $0xf, %bpl
movq %r14, %rdi
movl 0x4(%rsp), %esi
callq 0x6a94
andb $0xf, %al
addb %bpl, %al
addb %r12b, %al
movb 0x2(%rbx), %cl
andb $-0x31, %cl
addb %al, %al
andb $0x20, %al
shlb $0x4, %r13b
orb %cl, %r13b
orb %al, %r13b
movb %r13b, 0x2(%rbx)
movb %r15b, 0x3(%rbx)
incw 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/asm.h
// Function: ASM_SUB_m
static inline void ASM_SUB_m(CPU* cpu, Memory* mem, uint16_t address) {
    uint8_t result = cpu->A - MEM_getByte(mem, address);
    CPU_setFlagZ(cpu, result == 0);
    CPU_setFlagN(cpu, 1);
    CPU_setFlagH(cpu, (cpu->A & 0x0F) < (MEM_getByte(mem, address) & 0x0F));
    CPU_setFlagC(cpu, result > cpu->A);
    cpu->A = result;
    cpu->PC += 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movb 0x3(%rdi), %r15b
movq %rsi, %rdi
movl %edx, %esi
callq 0x6a94
subb %al, %r15b
setne %al
movb 0x2(%rbx), %cl
movb 0x3(%rbx), %r12b
andb $0x3f, %cl
shlb $0x7, %al
orb %cl, %al
addb $-0x40, %al
movb %al, 0x2(%rbx)
andb $0xf, %r12b
movq %r14, %rdi
movl %ebp, %esi
callq 0x6a94
andb $0xf, %al
cmpb %al, %r12b
setb %al
movb 0x2(%rbx), %cl
andb $-0x31, %cl
shlb $0x5, %al
orb %cl, %al
cmpb 0x3(%rbx), %r15b
seta %cl
shlb $0x4, %cl
orb %al, %cl
movb %cl, 0x2(%rbx)
movb %r15b, 0x3(%rbx)
incw 0xc(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/asm.h
// Function: ASM_SBC_A_n
static inline void ASM_SBC_A_n(CPU* cpu, uint8_t* reg) {
    int carry = CPU_getFlagC(cpu);
    int result = cpu->A - *reg - carry;
    CPU_setFlagZ(cpu, result == 0);
    CPU_setFlagN(cpu, 1);
    CPU_setFlagH(cpu, ((cpu->A & 0x0F) - (*reg & 0x0F) - carry) < 0);
    CPU_setFlagC(cpu, result < 0);
    cpu->A = (uint8_t) result;
    cpu->PC += 1;
}

// Assembly:
movzbl 0x2(%rdi), %ecx
movl %ecx, %edx
shrl $0x4, %edx
andl $0x1, %edx
movzbl 0x3(%rdi), %r8d
movzbl (%rsi), %r9d
addl %edx, %r9d
movl %r8d, %eax
subl %r9d, %eax
sete %r9b
andb $0x3f, %cl
shlb $0x7, %r9b
orb %cl, %r9b
orb $0x40, %r9b
movb %r9b, 0x2(%rdi)
andb $0xf, %r8b
movb (%rsi), %cl
andb $0xf, %cl
addb %dl, %cl
cmpb %r8b, %cl
seta %cl
andb $-0x31, %r9b
shlb $0x5, %cl
orb %r9b, %cl
movl %eax, %edx
shrl $0x1b, %edx
andb $0x10, %dl
orb %cl, %dl
movb %dl, 0x2(%rdi)
movb %al, 0x3(%rdi)
incw 0xc(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/asm.h
// Function: ASM_SBC_A_m
static inline void ASM_SBC_A_m(CPU* cpu, Memory* mem, uint16_t address) {
    int carry = CPU_getFlagC(cpu);
    int result = cpu->A - MEM_getByte(mem, address) - carry;
    CPU_setFlagZ(cpu, result == 0);
    CPU_setFlagN(cpu, 1);
    CPU_setFlagH(cpu, ((cpu->A & 0x0F) - (MEM_getByte(mem, address) & 0x0F) - carry) < 0);
    CPU_setFlagC(cpu, result < 0);
    cpu->A = (uint8_t) result;
    cpu->PC += 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0x2(%rdi), %r12d
shrl $0x4, %r12d
andl $0x1, %r12d
movzbl 0x3(%rdi), %r15d
movq %rsi, %rdi
movl %edx, %esi
callq 0x6a94
movzbl %al, %eax
addl %r12d, %eax
subl %eax, %r15d
sete %al
movb 0x2(%rbx), %cl
movb 0x3(%rbx), %r13b
andb $0x3f, %cl
shlb $0x7, %al
orb %cl, %al
orb $0x40, %al
movb %al, 0x2(%rbx)
andb $0xf, %r13b
movq %r14, %rdi
movl %ebp, %esi
callq 0x6a94
andb $0xf, %al
addb %r12b, %al
cmpb %r13b, %al
seta %al
movb 0x2(%rbx), %cl
andb $-0x31, %cl
shlb $0x5, %al
movl %r15d, %edx
shrl $0x1b, %edx
andb $0x10, %dl
orb %cl, %dl
orb %al, %dl
movb %dl, 0x2(%rbx)
movb %r15b, 0x3(%rbx)
incw 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/asm.h
// Function: ASM_AND_m
static inline void ASM_AND_m(CPU* cpu, Memory* mem, uint16_t address) {
    uint8_t result = cpu->A & MEM_getByte(mem, address);
    CPU_setFlagZ(cpu, result == 0);
    CPU_setFlagN(cpu, 0);
    CPU_setFlagH(cpu, 1);
    CPU_setFlagC(cpu, 0);
    cpu->A = result;
    cpu->PC += 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x3(%rdi), %bpl
movq %rsi, %rdi
movl %edx, %esi
callq 0x6a94
andb %bpl, %al
sete %cl
movb 0x2(%rbx), %dl
andb $0xf, %dl
shlb $0x7, %cl
orb %dl, %cl
orb $0x20, %cl
movb %cl, 0x2(%rbx)
movb %al, 0x3(%rbx)
incw 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/qad114[P]yobeboy/src/asm.h
// Function: ASM_XOR_m
static inline void ASM_XOR_m(CPU* cpu, Memory* mem, uint16_t address) {
    uint8_t result = MEM_getByte(mem, address) ^ cpu->A;
    CPU_setFlagZ(cpu, result == 0);
    CPU_setFlagN(cpu, 0);
    CPU_setFlagH(cpu, 0);
    CPU_setFlagC(cpu, 0);
    cpu->A = result;
    cpu->PC += 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
callq 0x6a94
movb 0x2(%rbx), %cl
movb 0x3(%rbx), %dl
movl %edx, %esi
xorb %al, %sil
cmpb %dl, %al
sete %al
andb $0xf, %cl
shlb $0x7, %al
orb %cl, %al
movb %al, 0x2(%rbx)
movb %sil, 0x3(%rbx)
incw 0xc(%rbx)
popq %rbx
retq