LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/hcmiya[P]opuscomment/src/ocutil.c
// Function: test_tag_field
bool test_tag_field(uint8_t *line, size_t n, bool upcase, bool *on_field, bool *upcase_applied_) {
	// フィールドの使用文字チェック・大文字化
	if (!upcase) {
		return test_tag_field_keepcase(line, n, on_field);
	}
	
	bool dummy_, *upcase_applied;
	upcase_applied = upcase_applied_ ? upcase_applied_ : &dummy_;
	
	size_t i;
	bool valid = true;
	for (i = 0; i < n && line[i] != 0x3d; i++) {
		if (!(line[i] >= 0x20 && line[i] <= 0x7d)) {
			valid = false;
		}
		if (line[i] >= 0x61 && line[i] <= 0x7a) {
			line[i] -= 32;
			*upcase_applied = true;
		}
	}
	if (i < n) *on_field = false;
	return valid;
}

// Assembly:
testl %edx, %edx
je 0x59bf
testq %rsi, %rsi
je 0x59eb
movb $0x1, %al
xorl %edx, %edx
movb (%rdi,%rdx), %r10b
cmpb $0x3d, %r10b
je 0x59ef
leal -0x20(%r10), %r11d
cmpb $0x5e, %r11b
setb %r9b
addb $-0x61, %r10b
cmpb $0x19, %r10b
ja 0x59b2
movb %r11b, (%rdi,%rdx)
testq %r8, %r8
je 0x59b2
movb $0x1, (%r8)
andb %r9b, %al
incq %rdx
cmpq %rdx, %rsi
jne 0x5985
jmp 0x59f2
testq %rsi, %rsi
je 0x59eb
movb $0x1, %al
xorl %edx, %edx
movb (%rdi,%rdx), %r8b
cmpb $0x3d, %r8b
je 0x59ef
addb $-0x20, %r8b
cmpb $0x5e, %r8b
setb %r8b
andb %r8b, %al
incq %rdx
cmpq %rdx, %rsi
jne 0x59c8
jmp 0x59f2
movb $0x1, %al
jmp 0x59f2
movb $0x0, (%rcx)
andb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O3/hcmiya[P]opuscomment/src/ocutil.c
// Function: test_non_opus
bool test_non_opus(ogg_page *og) {
	if (ogg_page_serialno(og) == opus_sno) {
		if (ogg_page_bos(og)) {
			opuserror(err_opus_bad_stream);
		}
		if (opst != PAGE_SOUND && ogg_page_pageno(og) != opus_idx) {
			opuserror(err_opus_discontinuous, ogg_page_pageno(og), opus_idx);
		}
		return true;
	}
// 	have_multi_streams = true;
	
	int pno = ogg_page_pageno(og);
	if (pno == 0) {
		if (leave_header_packets) {
			opuserror(err_opus_bad_stream);
		}
		if (!ogg_page_bos(og) || ogg_page_eos(og) || ogg_page_granulepos(og) != 0) {
			opuserror(err_opus_bad_stream);
		}
	}
	else if (pno == 1) {
		// 複数論理ストリームの先頭は全て0で始まるため、何かが1ページ目を始めたら今後0ページ目は来ないはずである。
		leave_header_packets = true;
	}
	else {
		if (!leave_header_packets) {
			// 他で1ページ目が始まってないのに2ページ目以上が来た場合
			opuserror(err_opus_bad_stream);
		}
	}
	
	if (pno && ogg_page_bos(og)) {
		// Opusが続いているストリーム途中でBOSが来るはずがない
		opuserror(err_opus_bad_stream);
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x2420
movl %eax, %ebx
leaq 0x16caa(%rip), %rax     # 0x1c6d4
movl (%rax), %ebp
movq %r14, %rdi
cmpl %ebp, %ebx
jne 0x5a92
callq 0x2040
testl %eax, %eax
je 0x5a48
movl $0x5, %edi
xorl %eax, %eax
callq 0x6dcc
leaq 0x16c7d(%rip), %rax     # 0x1c6cc
cmpl $0x4, (%rax)
je 0x5b1b
movq %r14, %rdi
callq 0x2080
leaq 0x16c69(%rip), %r15     # 0x1c6d0
movl (%r15), %ecx
cmpq %rcx, %rax
je 0x5b1b
movq %r14, %rdi
callq 0x2080
movl (%r15), %edx
movl $0xa, %edi
movq %rax, %rsi
xorl %eax, %eax
callq 0x6dcc
jmp 0x5b1b
callq 0x2080
cmpl $0x1, %eax
je 0x5adf
testl %eax, %eax
jne 0x5aeb
leaq 0x16c35(%rip), %rax     # 0x1c6dc
cmpb $0x1, (%rax)
jne 0x5ab8
movl $0x5, %edi
xorl %eax, %eax
callq 0x6dcc
movq %r14, %rdi
callq 0x2040
testl %eax, %eax
je 0x5b0f
movq %r14, %rdi
callq 0x24a0
testl %eax, %eax
jne 0x5b0f
movq %r14, %rdi
callq 0x22b0
testq %rax, %rax
jne 0x5b0f
jmp 0x5b1b
leaq 0x16bf6(%rip), %rax     # 0x1c6dc
movb $0x1, (%rax)
jmp 0x5b03
leaq 0x16bea(%rip), %rax     # 0x1c6dc
cmpb $0x0, (%rax)
jne 0x5b03
movl $0x5, %edi
xorl %eax, %eax
callq 0x6dcc
movq %r14, %rdi
callq 0x2040
testl %eax, %eax
je 0x5b1b
movl $0x5, %edi
xorl %eax, %eax
callq 0x6dcc
cmpl %ebp, %ebx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hcmiya[P]opuscomment/src/ocutil.c
// Function: write_page
void write_page(ogg_page *og, FILE *fp) {
	size_t ret;
	ret = fwrite(og->header, 1, og->header_len, fp);
	if (ret != og->header_len) {
		oserror();
	}
	ret = fwrite(og->body, 1, og->body_len, fp);
	if (ret != og->body_len) {
		oserror();
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rdx
movl $0x1, %esi
movq %r14, %rcx
callq 0x2460
cmpq 0x8(%rbx), %rax
je 0x5b54
callq 0x6f57
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rdx
movl $0x1, %esi
movq %r14, %rcx
callq 0x2460
cmpq 0x18(%rbx), %rax
jne 0x5b77
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6f57
// File: /workspace/github_c_makefile_star2_O3/hcmiya[P]opuscomment/src/retrieve-tags.c
// Function: rtcopy_list
static bool rtcopy_list(FILE *packet_input, void *listfd_) {
	static size_t idx = 1;
	int listfd = *(int*)listfd_;
	uint32_t len = rtchunk(packet_input);
	uint8_t buf[STACK_BUF_LEN];
	bool first = true;
	bool field = true;
	bool copy;
	while (len) {
		size_t rl = rtfill(buf, len, STACK_BUF_LEN, packet_input);
		if (first) {
			if (*buf == 0x3d) opuserror(err_opus_bad_tag, idx);
			first = false;
			copy = !O.tag_ignore_picture || !test_mbp(buf, len);
			if (copy) {
				write(listfd, &len, 4);
			}
		}
		if (copy) {
			if (field) {
				if(!test_tag_field(buf, rl, O.tag_toupper, &field, &upcase_applied) && O.tag_verify) {
					opuserror(err_opus_bad_tag, idx);
				}
			}
			write(listfd, buf, rl);
		}
		len -= rl;
	}
	if (O.tag_verify && field) {
		opuserror(err_opus_bad_tag, idx);
	}
	idx++;
	return copy;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1028, %rsp           # imm = 0x1028
movq %rdi, %rdx
movl (%rsi), %eax
movl %eax, 0x10(%rsp)
leaq 0x20(%rsp), %r14
movl $0x4, %esi
movq %r14, %rdi
movq %rdx, 0x18(%rsp)
callq 0x609d
movl (%r14), %edi
callq 0x6ce7
movl %eax, 0x14(%rsp)
movb $0x1, 0xf(%rsp)
testl %eax, %eax
je 0x6234
movl %eax, %r14d
leaq 0x5c7f(%rip), %rax      # 0xbd98
movq (%rax), %rbp
movb $0x1, %bl
leaq 0x20(%rsp), %r15
movl $0x1000, %eax           # imm = 0x1000
cmpl %eax, %r14d
movl $0x1000, %r13d          # imm = 0x1000
cmovbl %r14d, %r13d
movq %r15, %rdi
movq %r13, %rsi
movq 0x18(%rsp), %rdx
callq 0x609d
testb $0x1, %bl
je 0x61bb
cmpb $0x3d, 0x20(%rsp)
jne 0x6164
movq 0x6140(%rip), %rsi      # 0xc298
movl $0xd, %edi
xorl %eax, %eax
callq 0x6dcc
cmpl $0x17, %r14d
jb 0x61a3
leaq 0x16517(%rip), %rax     # 0x1c688
cmpb $0x0, 0xe(%rax)
je 0x61a3
xorl %eax, %eax
movb (%rbp,%rax), %cl
testb %cl, %cl
je 0x622f
movzbl 0x20(%rsp,%rax), %edx
leal -0x61(%rdx), %esi
leal -0x20(%rdx), %edi
cmpb $0x1a, %sil
movzbl %dil, %esi
cmovael %edx, %esi
incq %rax
cmpb %sil, %cl
je 0x6179
movl $0x4, %edx
movl 0x10(%rsp), %edi
leaq 0x14(%rsp), %rsi
callq 0x2100
movb $0x1, %r12b
jmp 0x61c1
testb $0x1, %r12b
je 0x621d
cmpb $0x1, 0xf(%rsp)
jne 0x620e
leaq 0x164b9(%rip), %rax     # 0x1c688
movzbl 0x16(%rax), %edx
movq %r15, %rdi
movq %r13, %rsi
leaq 0xf(%rsp), %rcx
leaq 0x16473(%rip), %r8      # 0x1c658
callq 0x5978
testb %al, %al
jne 0x620e
leaq 0x16493(%rip), %rax     # 0x1c688
cmpb $0x1, 0x21(%rax)
jne 0x620e
movq 0x6096(%rip), %rsi      # 0xc298
movl $0xd, %edi
xorl %eax, %eax
callq 0x6dcc
movl 0x10(%rsp), %edi
movq %r15, %rsi
movq %r13, %rdx
callq 0x2100
xorl %ebx, %ebx
subl %r13d, %r14d
movl %r14d, 0x14(%rsp)
jne 0x6123
jmp 0x6234
xorl %r12d, %r12d
jmp 0x621d
leaq 0x1644d(%rip), %rax     # 0x1c688
cmpb $0x1, 0x21(%rax)
jne 0x625b
cmpb $0x1, 0xf(%rsp)
jne 0x625b
movq 0x6049(%rip), %rsi      # 0xc298
movl $0xd, %edi
xorl %eax, %eax
callq 0x6dcc
incq 0x6036(%rip)            # 0xc298
andb $0x1, %r12b
movl %r12d, %eax
addq $0x1028, %rsp           # imm = 0x1028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hcmiya[P]opuscomment/src/retrieve-tags.c
// Function: rt_del_args
void rt_del_args(uint8_t *buf, size_t len, bool term) {
	static uint32_t recordlen = 0;
	static bool field = true;
	if (!buf) {
		if (!recordlen) {
			opterror('d', catgets(catd, 7, 3, "invalid tag format"));
		}
		recordlen = oi32(recordlen);
		fwrite(&recordlen, 4, 1, dellist_len);
		uint8_t f = field;
		fwrite(&f, 1, 1, dellist_len);
		recordlen = 0;
		field = true;
		return;
	}
	dellist_len = dellist_len ? dellist_len : tmpfile();
	dellist_str = dellist_str ? dellist_str : tmpfile();
	
	recordlen += len;
	if (field && !test_tag_field(buf, len, true, &field, &upcase_applied)) {
		opterror('d', catgets(catd, 7, 3, "invalid tag format"));
	}
	fwrite(buf, 1, len, dellist_str);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x680d
movq %rsi, %rbx
movq %rdi, %r14
movq 0x15eea(%rip), %rax     # 0x1c650
testq %rax, %rax
jne 0x6770
callq 0x2230
movq %rax, 0x15ed9(%rip)     # 0x1c650
movq 0x15ec2(%rip), %rax     # 0x1c640
testq %rax, %rax
jne 0x6788
callq 0x2230
addl %ebx, 0x15ece(%rip)     # 0x1c65c
movq %rax, 0x15eab(%rip)     # 0x1c640
cmpb $0x1, 0x5af4(%rip)      # 0xc290
jne 0x67ef
leaq 0x5aeb(%rip), %rcx      # 0xc290
leaq 0x15eac(%rip), %r8      # 0x1c658
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x5978
testb %al, %al
jne 0x67ef
leaq 0x15eb9(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x192f(%rip), %rcx      # 0x8100
movl $0x7, %esi
movl $0x3, %edx
callq 0x2440
movl $0x64, %edi
movq %rax, %rsi
xorl %eax, %eax
callq 0x707c
movq 0x15e4a(%rip), %rcx     # 0x1c640
movl $0x1, %esi
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2460
movl 0x15e49(%rip), %edi     # 0x1c65c
testl %edi, %edi
jne 0x684c
leaq 0x15e62(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x18d8(%rip), %rcx      # 0x8100
movl $0x7, %esi
movl $0x3, %edx
callq 0x2440
movl $0x64, %edi
movq %rax, %rsi
xorl %eax, %eax
callq 0x707c
movl 0x15e10(%rip), %edi     # 0x1c65c
callq 0x6ce7
movl %eax, 0x15e05(%rip)     # 0x1c65c
leaq 0x15dfe(%rip), %rdi     # 0x1c65c
movq 0x15deb(%rip), %rcx     # 0x1c650
movl $0x4, %esi
movl $0x1, %edx
callq 0x2460
movzbl 0x5a15(%rip), %edi      # 0xc290
movq 0x15dce(%rip), %rsi     # 0x1c650
callq 0x21f0
movl $0x0, 0x15dcb(%rip)     # 0x1c65c
movb $0x1, 0x59f8(%rip)      # 0xc290
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/hcmiya[P]opuscomment/src/select-codec.c
// Function: select_codec_by_name
bool select_codec_by_name(char const *name) {
	static locale_t clocale = (locale_t)0;
	if (!clocale) {
		clocale = newlocale(LC_ALL, "C", (locale_t)0);
		if (!clocale) {
			oserror();
		}
	}
	for (codec = set; codec->name != NULL && strcasecmp_l(name, codec->name, clocale) != 0; codec++) {}
	return !!codec->name;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x15d4e(%rip)     # 0x1c660
jne 0x6938
leaq 0x1bbc(%rip), %rsi      # 0x84d7
movl $0x6, %edi
xorl %edx, %edx
callq 0x2160
movq %rax, 0x15d32(%rip)     # 0x1c660
testq %rax, %rax
jne 0x6938
callq 0x6f57
leaq 0x5971(%rip), %rax      # 0xc2b0
leaq 0x15d2a(%rip), %r15     # 0x1c670
movq %rax, (%r15)
movq 0x5970(%rip), %rsi      # 0xc2c0
testq %rsi, %rsi
je 0x6988
leaq 0x5994(%rip), %r12      # 0xc2f0
movq 0x15cfd(%rip), %r14     # 0x1c660
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2330
testl %eax, %eax
sete %al
je 0x698a
movq %r12, (%r15)
movq 0x10(%r12), %rsi
addq $0x40, %r12
testq %rsi, %rsi
jne 0x6963
jmp 0x698a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hcmiya[P]opuscomment/src/select-codec.c
// Function: check_opus
static void check_opus(ogg_page *og) {
	if (og->body_len < 19) {
		opuserror(err_opus_bad_content);
	}
	if ((og->body[8] & 0xf0) != 0) {
		opuserror(err_opus_version);
	}
	if (O.gain_put) {
		if (O.gain_q78) {
			fprintf(stderr, "%d", (int16_t)oi16(*(int16_t*)(&og->body[16])));
		}
		else {
			fprintf(stderr, "%.8g", (int16_t)oi16(*(int16_t*)(&og->body[16])) / 256.0);
		}
	}
	if (O.gain_fix) {
		int16_t gi;
		if (O.gain_relative) {
			int gain = (int16_t)oi16(*(int16_t*)(&og->body[16]));
			gain += O.gain_val;
			if (gain > 32767) {
				gain = 32767;
			}
			else if (gain < -32768) {
				gain = -32768;
			}
			gi = gain;
		}
		else {
			gi = O.gain_val;
		}
		if (O.gain_not_zero && gi == 0) {
			gi = O.gain_val_sign ? -1 : 1;
		}
		
		*(int16_t*)(&og->body[16]) = oi16(gi);
		ogg_page_checksum_set(og);
		
		if (O.gain_put) {
			if (O.gain_q78) {
				fprintf(stderr, "\t%d", (int)gi);
			}
			else {
				fprintf(stderr, "\t%.8g", gi / 256.0);
			}
		}
	}
	if (O.gain_put) {
		fputc('\n', stderr);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x12, 0x18(%rdi)
jg 0x69b3
movl $0xc, %edi
xorl %eax, %eax
callq 0x6dcc
movq 0x10(%rbx), %rax
cmpb $0x10, 0x8(%rax)
jb 0x69c9
movl $0x6, %edi
xorl %eax, %eax
callq 0x6dcc
leaq 0x15cb8(%rip), %r15     # 0x1c688
cmpb $0x1, 0xd(%r15)
je 0x6a85
cmpb $0x1, 0x4(%r15)
jne 0x6a55
cmpb $0x1, 0x5(%r15)
jne 0x6a17
movq 0x10(%rbx), %rax
movzwl 0x10(%rax), %edi
callq 0x6ce4
movswl %ax, %ecx
addl 0x8(%r15), %ecx
cmpl $0xffff8001, %ecx       # imm = 0xFFFF8001
movl $0xffff8000, %eax       # imm = 0xFFFF8000
cmovgel %ecx, %eax
movl $0x7fff, %ecx           # imm = 0x7FFF
cmpl %ecx, %eax
cmovgel %ecx, %eax
jmp 0x6a1b
movl 0x8(%r15), %eax
movzbl 0xc(%r15), %ebp
andl $0x1, %ebp
negl %ebp
orl $0x1, %ebp
testw %ax, %ax
cmovnel %eax, %ebp
cmpb $0x0, 0x6(%r15)
cmovel %eax, %ebp
movzwl %bp, %edi
callq 0x6ce4
movq 0x10(%rbx), %rcx
movw %ax, 0x10(%rcx)
movq %rbx, %rdi
callq 0x2110
cmpb $0x1, 0xd(%r15)
je 0x6abf
cmpb $0x1, 0xd(%r15)
jne 0x6a7a
movq 0x5595(%rip), %rax      # 0xbff8
movq (%rax), %rsi
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21f0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movb 0x7(%r15), %bpl
movq 0x5568(%rip), %rax      # 0xbff8
movq (%rax), %r14
movq 0x10(%rbx), %rax
movzwl 0x10(%rax), %edi
callq 0x6ce4
cmpb $0x1, %bpl
jne 0x6ae6
movswl %ax, %edx
leaq 0x176e(%rip), %rsi      # 0x821e
movq %r14, %rdi
xorl %eax, %eax
callq 0x2260
jmp 0x69db
movq 0x5532(%rip), %rax      # 0xbff8
movq (%rax), %rdi
cmpb $0x1, 0x7(%r15)
jne 0x6b09
movswl %bp, %edx
leaq 0x1743(%rip), %rsi      # 0x821d
xorl %eax, %eax
callq 0x2260
jmp 0x6a55
cwtl
cvtsi2sd %eax, %xmm0
mulsd 0x1625(%rip), %xmm0     # 0x8118
leaq 0x1728(%rip), %rsi      # 0x8222
movq %r14, %rdi
movb $0x1, %al
callq 0x2260
jmp 0x69db
movswl %bp, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x15fd(%rip), %xmm0     # 0x8118
leaq 0x16ff(%rip), %rsi      # 0x8221
movb $0x1, %al
callq 0x2260
jmp 0x6a55
// File: /workspace/github_c_makefile_star2_O3/hcmiya[P]opuscomment/src/select-codec.c
// Function: check_theora
static void check_theora(ogg_page *og) {
	if (og->body_len != 42) {
		opuserror(err_opus_bad_content);
	}
	// major 3, minor 2
	if (og->body[7] != 3 || og->body[8] != 2) {
		opuserror(err_opus_version);
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x2a, 0x18(%rdi)
je 0x6b45
movl $0xc, %edi
xorl %eax, %eax
callq 0x6dcc
movq 0x10(%rbx), %rax
cmpb $0x3, 0x7(%rax)
jne 0x6b57
cmpb $0x2, 0x8(%rax)
jne 0x6b57
popq %rbx
retq
movl $0x6, %edi
xorl %eax, %eax
popq %rbx
jmp 0x6dcc
// File: /workspace/github_c_makefile_star2_O3/hcmiya[P]opuscomment/src/select-codec.c
// Function: check_vorbis
static void check_vorbis(ogg_page *og) {
// 0-6 "\x1" "\x76\x6f\x72\x62\x69\x73" 
/*7-10   1) [vorbis_version] = read 32 bits as unsigned integer
11   2) [audio_channels] = read 8 bit integer as unsigned
12-15   3) [audio_sample_rate] = read 32 bits as unsigned integer
16   4) [bitrate_maximum] = read 32 bits as signed integer
20   5) [bitrate_nominal] = read 32 bits as signed integer
24   6) [bitrate_minimum] = read 32 bits as signed integer
28.0-3   7) [blocksize_0] = 2 exponent (read 4 bits as unsigned integer)
28.4-7   8) [blocksize_1] = 2 exponent (read 4 bits as unsigned integer)
29   9) [framing_flag] = read one bit
*/
	if (og->body_len != 30) opuserror(err_opus_bad_content);
	if (oi32(*(uint32_t*)&og->body[7]) != 0) opuserror(err_opus_version);
	if (!og->body[11]) opuserror(err_opus_bad_content);
	if (oi32(*(uint32_t*)&og->body[12]) == 0) opuserror(err_opus_bad_content);
	if (!og->body[29]) opuserror(err_opus_bad_content);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x1e, 0x18(%rdi)
je 0x6b7b
movl $0xc, %edi
xorl %eax, %eax
callq 0x6dcc
movq 0x10(%rbx), %rax
movl 0x7(%rax), %edi
callq 0x6ce7
testl %eax, %eax
je 0x6b97
movl $0x6, %edi
xorl %eax, %eax
callq 0x6dcc
movq 0x10(%rbx), %rax
cmpb $0x0, 0xb(%rax)
jne 0x6bb1
movl $0xc, %edi
xorl %eax, %eax
callq 0x6dcc
movq 0x10(%rbx), %rax
movl 0xc(%rax), %edi
callq 0x6ce7
testl %eax, %eax
jne 0x6bc9
movl $0xc, %edi
xorl %eax, %eax
callq 0x6dcc
movq 0x10(%rbx), %rax
cmpb $0x0, 0x1d(%rax)
je 0x6bd5
popq %rbx
retq
movl $0xc, %edi
xorl %eax, %eax
popq %rbx
jmp 0x6dcc
// File: /workspace/github_c_makefile_star2_O3/hcmiya[P]opuscomment/src/select-codec.c
// Function: check_vp8
static void check_vp8(ogg_page *og) {
	// https://people.freedesktop.org/~slomo/ogg-vp8/ogg-vp8.pdf
	// ヘッダ長、ヘッダ種類
	if (og->body_len < 26 || og->body[5] != 1) opuserror(err_opus_bad_content);
	// major 1
	if (og->body[6] != 1) opuserror(err_opus_version);
	// minor 0。0ならば必ずサイズは26
	if (og->body[7] == 0 && og->body_len != 26) opuserror(err_opus_bad_content);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x1a, 0x18(%rdi)
jl 0x6c9f
movq 0x10(%rbx), %rax
cmpb $0x1, 0x5(%rax)
je 0x6caf
movl $0xc, %edi
xorl %eax, %eax
callq 0x6dcc
movq 0x10(%rbx), %rax
cmpb $0x1, 0x6(%rax)
je 0x6cc1
movl $0x6, %edi
xorl %eax, %eax
callq 0x6dcc
movq 0x10(%rbx), %rax
cmpb $0x0, 0x7(%rax)
jne 0x6cd2
cmpq $0x1a, 0x18(%rbx)
jne 0x6cd4
popq %rbx
retq
movl $0xc, %edi
xorl %eax, %eax
popq %rbx
jmp 0x6dcc
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/hcmiya[P]opuscomment/src/error.c
// Function: mainerror
noreturn void mainerror(int e, ...) {
	va_list ap;
	va_start(ap, e);
	errorprefix();
	char const *msg[] = {
#define LIST(I, E, S) S,
#include "errordef/main.tab"
#undef LIST
	};
	vfprintf(stderr, catgets(catd, 2, e, msg[e]), ap);
	fputc('\n', stderr);
	exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %edi, %ebx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x6d54
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 %rsp, %r14
movq %rdi, 0x10(%r14)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
callq 0x24f0
movq 0x5278(%rip), %r12      # 0xbff8
movq (%r12), %r15
leaq 0x158f5(%rip), %rax     # 0x1c680
movq (%rax), %rdi
movslq %ebx, %rdx
leaq 0x4e88(%rip), %rax      # 0xbc20
movq (%rax,%rdx,8), %rcx
movl $0x2, %esi
callq 0x2440
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x2400
movq (%r12), %rsi
movl $0xa, %edi
callq 0x21f0
movl $0x1, %edi
callq 0x2450
// File: /workspace/github_c_makefile_star2_O3/hcmiya[P]opuscomment/src/error.c
// Function: opuserror
noreturn void opuserror(int e, ...) {
	va_list ap;
	va_start(ap, e);
	errorprefix();
	
	struct {
		bool report_page;
		char const *default_message;
	} msg[] = {
#define LIST(I, B, E, S) {B, S},
#include "errordef/opus.tab"
#undef LIST
	};
	if (msg[e].report_page && codec->type != CODEC_FLAC) {
		fprintf(stderr, catgets(catd, 1, 4, "%s format error: page %u: "), codec->name, opus_idx);
	}
	else {
		fprintf(stderr, catgets(catd, 1, 8, "%s format error: "), codec->name);
	}
	vfprintf(stderr, catgets(catd, 3, e, msg[e].default_message), ap);
	fputc('\n', stderr);
	exit(2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %edi, %ebx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x6e30
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 %rdi, 0x10(%rsp)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsp)
callq 0x24f0
movslq %ebx, %rax
shlq $0x4, %rax
leaq 0x4e3d(%rip), %rcx      # 0xbca0
leaq (%rcx,%rax), %r15
cmpb $0x1, (%rax,%rcx)
jne 0x6e7d
leaq 0x157fc(%rip), %r12     # 0x1c670
movq (%r12), %rax
cmpl $0x2, (%rax)
jne 0x6ec4
movq 0x5174(%rip), %rax      # 0xbff8
movq (%rax), %r14
leaq 0x157f2(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x165c(%rip), %rcx      # 0x84f4
movl $0x1, %esi
movl $0x8, %edx
callq 0x2440
leaq 0x157c2(%rip), %rcx     # 0x1c670
movq (%rcx), %rcx
movq 0x10(%rcx), %rdx
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x2260
jmp 0x6f0c
movq 0x512d(%rip), %rax      # 0xbff8
movq (%rax), %r14
leaq 0x157ab(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x15fa(%rip), %rcx      # 0x84d9
movl $0x1, %esi
movl $0x4, %edx
callq 0x2440
movq (%r12), %rcx
movq 0x10(%rcx), %rdx
leaq 0x157d3(%rip), %rcx     # 0x1c6d0
movl (%rcx), %ecx
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x2260
movq 0x50e5(%rip), %r12      # 0xbff8
movq (%r12), %r14
leaq 0x15762(%rip), %rax     # 0x1c680
movq (%rax), %rdi
movq 0x8(%r15), %rcx
movl $0x3, %esi
movl %ebx, %edx
callq 0x2440
movq %rsp, %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x2400
movq (%r12), %rsi
movl $0xa, %edi
callq 0x21f0
movl $0x2, %edi
callq 0x2450
// File: /workspace/github_c_makefile_star2_O3/hcmiya[P]opuscomment/src/error.c
// Function: fileerror
noreturn void fileerror(char const *file) {
	errorprefix();
	fprintf(stderr, catgets(catd, 1, 5, "%s: "), file);
	perror(NULL);
	exit(3);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x24f0
movq 0x4fc0(%rip), %rax      # 0xbff8
movq (%rax), %r14
leaq 0x1563e(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x11db(%rip), %rcx      # 0x8227
movl $0x1, %esi
movl $0x5, %edx
callq 0x2440
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2260
xorl %edi, %edi
callq 0x23d0
movl $0x3, %edi
callq 0x2450
// File: /workspace/github_c_makefile_star2_O3/hcmiya[P]opuscomment/src/error.c
// Function: opterror
noreturn void opterror(int c, char const *e, ...) {
	va_list ap;
	va_start(ap, e);
	errorprefix();
	fprintf(stderr, catgets(catd, 1, 7, "-%c: "), c);
	vfprintf(stderr, e, ap);
	fputc('\n', stderr);
	exit(1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x70e0
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 %rsp, %r14
movq %rsi, 0x10(%r14)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r14)
callq 0x24f0
movq 0x4eec(%rip), %r12      # 0xbff8
movq (%r12), %r15
leaq 0x15569(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x13e5(%rip), %rcx      # 0x8506
movl $0x1, %esi
movl $0x7, %edx
callq 0x2440
movq %r15, %rdi
movq %rax, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x2260
movq (%r12), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2400
movq (%r12), %rsi
movl $0xa, %edi
callq 0x21f0
movl $0x1, %edi
callq 0x2450
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]sxhkd/src/sxhkd.c
// Function: hold
void hold(int sig)
{
	if (sig == SIGHUP || sig == SIGINT || sig == SIGTERM)
		running = false;
	else if (sig == SIGUSR1)
		reload = true;
	else if (sig == SIGUSR2)
		toggle_grab = true;
	else if (sig == SIGALRM)
		bell = true;
}

// Assembly:
decl %edi
cmpl $0xe, %edi
ja 0xeb1d
leaq 0x253b(%rip), %rax      # 0x11040
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movb $0x0, 0x13970(%rip)     # 0x22485
retq
movb $0x1, 0x13965(%rip)     # 0x22482
retq
movb $0x1, 0x1395f(%rip)     # 0x22484
retq
movb $0x1, 0x13956(%rip)     # 0x22483
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]sxhkd/src/sxhkd.c
// Function: setup
void setup(void)
{
	int screen_idx;
	dpy = xcb_connect(NULL, &screen_idx);
	if (xcb_connection_has_error(dpy))
		err("Can't open display.\n");
	xcb_screen_t *screen = NULL;
	xcb_screen_iterator_t screen_iter = xcb_setup_roots_iterator(xcb_get_setup(dpy));
	for (; screen_iter.rem; xcb_screen_next(&screen_iter), screen_idx--) {
		if (screen_idx == 0) {
			screen = screen_iter.data;
			break;
		}
	}
	if (screen == NULL)
		err("Can't acquire screen.\n");
	root = screen->root;
	if ((shell = getenv(SXHKD_SHELL_ENV)) == NULL && (shell = getenv(SHELL_ENV)) == NULL)
		err("The '%s' environment variable is not defined.\n", SHELL_ENV);
	symbols = xcb_key_symbols_alloc(dpy);
	hotkeys_head = hotkeys_tail = NULL;
	progress[0] = '\0';

	snprintf(sxhkd_pid, MAXLEN, "%i", getpid());
	setenv("SXHKD_PID", sxhkd_pid, 1);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
leaq 0xc(%rsp), %rsi
xorl %edi, %edi
callq 0xe100
movq %rax, 0x13932(%rip)     # 0x22478
movq %rax, %rdi
callq 0xe310
testl %eax, %eax
jne 0xec56
movq 0x1391b(%rip), %rdi     # 0x22478
callq 0xe350
movq %rax, %rdi
callq 0xe210
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
testl %edx, %edx
je 0xeb9e
movl 0xc(%rsp), %eax
leaq 0x10(%rsp), %rbx
testl %eax, %eax
je 0xebac
movq %rbx, %rdi
callq 0xe1b0
movl 0xc(%rsp), %eax
decl %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0x18(%rsp)
jne 0xeb81
leaq 0x25f1(%rip), %rdi      # 0x11196
xorl %eax, %eax
callq 0xf2a4
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xeb9e
movl (%rax), %eax
movl %eax, 0x138da(%rip)     # 0x22498
leaq 0x25e8(%rip), %rdi      # 0x111ad
callq 0xe030
movq %rax, 0x138cf(%rip)     # 0x224a0
testq %rax, %rax
jne 0xebee
leaq 0x25d6(%rip), %rdi      # 0x111b3
callq 0xe030
movq %rax, 0x138b7(%rip)     # 0x224a0
testq %rax, %rax
je 0xec62
movq 0x13883(%rip), %rdi     # 0x22478
callq 0xe110
movq %rax, 0x13887(%rip)     # 0x22488
xorl %eax, %eax
movq %rax, 0x1389e(%rip)     # 0x224a8
movq %rax, 0x1389f(%rip)     # 0x224b0
movb $0x0, 0x138a8(%rip)     # 0x224c0
callq 0xe0c0
leaq 0x13b9c(%rip), %rbx     # 0x227c0
leaq 0x2471(%rip), %rdx      # 0x1109c
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
movl %eax, %ecx
xorl %eax, %eax
callq 0xe170
leaq 0x25a5(%rip), %rdi      # 0x111e8
movq %rbx, %rsi
movl $0x1, %edx
callq 0xe0b0
addq $0x20, %rsp
popq %rbx
retq
leaq 0x2524(%rip), %rdi      # 0x11181
jmp 0xeba5
leaq 0x2550(%rip), %rdi      # 0x111b9
leaq 0x2543(%rip), %rsi      # 0x111b3
xorl %eax, %eax
callq 0xf2a4
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]sxhkd/src/sxhkd.c
// Function: key_button_event
void key_button_event(xcb_generic_event_t *evt, uint8_t event_type)
{
	xcb_keysym_t keysym = XCB_NO_SYMBOL;
	xcb_button_t button = XCB_NONE;
	bool replay_event = false;
	uint16_t modfield = 0;
	uint16_t lockfield = num_lock | caps_lock | scroll_lock;
	parse_event(evt, event_type, &keysym, &button, &modfield);
	modfield &= ~lockfield & MOD_STATE_FIELD;
	if (keysym != XCB_NO_SYMBOL || button != XCB_NONE) {
		hotkey_t *hk = find_hotkey(keysym, button, modfield, event_type, &replay_event);
		if (hk != NULL) {
			run(hk->command, hk->sync);
			put_status(COMMAND_PREFIX, hk->command);
		}
	}
	switch (event_type) {
		case XCB_BUTTON_PRESS:
		case XCB_BUTTON_RELEASE:
			if (replay_event)
				xcb_allow_events(dpy, XCB_ALLOW_REPLAY_POINTER, XCB_CURRENT_TIME);
			else
				xcb_allow_events(dpy, XCB_ALLOW_SYNC_POINTER, XCB_CURRENT_TIME);
			break;
		case XCB_KEY_PRESS:
		case XCB_KEY_RELEASE:
			if (replay_event)
				xcb_allow_events(dpy, XCB_ALLOW_REPLAY_KEYBOARD, XCB_CURRENT_TIME);
			else
				xcb_allow_events(dpy, XCB_ALLOW_SYNC_KEYBOARD, XCB_CURRENT_TIME);
			break;
	}
	xcb_flush(dpy);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
leaq 0xc(%rsp), %r14
movl $0x0, (%r14)
xorl %eax, %eax
leaq 0x9(%rsp), %r15
movb %al, (%r15)
movb %al, 0x8(%rsp)
leaq 0xa(%rsp), %r12
movw $0x0, (%r12)
movzbl 0x137de(%rip), %eax     # 0x22490
movzbl 0x137d9(%rip), %ecx     # 0x22492
orl %eax, %ecx
movzbl 0x137d2(%rip), %ebp     # 0x22494
orl %ecx, %ebp
notl %ebp
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0xf91e
movzbl (%r12), %eax
andl %ebp, %eax
movw %ax, (%r12)
movl (%r14), %edi
testl %edi, %edi
setne %dl
movb (%r15), %cl
testb %cl, %cl
setne %sil
orb %dl, %sil
movzbl %bl, %ebx
cmpb $0x1, %sil
jne 0xed37
movzbl %cl, %esi
movzwl %ax, %edx
leaq 0x8(%rsp), %r8
movl %ebx, %ecx
callq 0x10794
testq %rax, %rax
je 0xed37
movq %rax, %r14
addq $0x8, %r14
movzbl 0x208(%rax), %esi
movq %r14, %rdi
callq 0xf33e
movl $0x43, %edi
movq %r14, %rsi
callq 0xee68
leal -0x2(%rbx), %eax
cmpl $0x2, %eax
jb 0xed5c
addl $-0x4, %ebx
cmpl $0x1, %ebx
ja 0xed84
movq 0x1372a(%rip), %rdi     # 0x22478
cmpb $0x1, 0x8(%rsp)
jne 0xed71
movl $0x2, %esi
jmp 0xed7d
movq 0x13715(%rip), %rdi     # 0x22478
cmpb $0x1, 0x8(%rsp)
jne 0xed78
movl $0x5, %esi
jmp 0xed7d
movl $0x1, %esi
jmp 0xed7d
movl $0x4, %esi
xorl %edx, %edx
callq 0xe120
movq 0x136ed(%rip), %rdi     # 0x22478
callq 0xe140
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]sxhkd/src/sxhkd.c
// Function: mapping_notify
void mapping_notify(xcb_generic_event_t *evt)
{
	if (!mapping_count)
		return;
	xcb_mapping_notify_event_t *e = (xcb_mapping_notify_event_t *) evt;
	PRINTF("mapping notify %u %u\n", e->request, e->count);
	if (e->request == XCB_MAPPING_POINTER)
		return;
	if (xcb_refresh_keyboard_mapping(symbols, e) == 1) {
		destroy_chord(abort_chord);
		get_lock_fields();
		reload_cmd();
		abort_chord = make_chord(abort_keysym, XCB_NONE, 0, XCB_KEY_PRESS, false, false);
		if (mapping_count > 0)
			mapping_count--;
	}
}

// Assembly:
cmpl $0x0, 0x135ac(%rip)     # 0x22350
je 0xee0e
movq %rdi, %rsi
cmpb $0x2, 0x4(%rdi)
je 0xee0e
pushq %rax
movq 0x136d1(%rip), %rdi     # 0x22488
callq 0xe050
cmpl $0x1, %eax
jne 0xee0a
movq 0x136a8(%rip), %rdi     # 0x22470
callq 0x10f89
callq 0x1069b
callq 0xee0f
movl 0x13583(%rip), %edi     # 0x22360
xorl %esi, %esi
xorl %edx, %edx
movl $0x2, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x10c64
movq %rax, 0x13678(%rip)     # 0x22470
movl 0x13552(%rip), %eax     # 0x22350
testl %eax, %eax
jle 0xee0a
decl %eax
movl %eax, 0x13546(%rip)     # 0x22350
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]sxhkd/src/sxhkd.c
// Function: reload_cmd
void reload_cmd(void)
{
	PUTS("reload");
	cleanup();
	load_config(config_file);
	for (int i = 0; i < num_extra_confs; i++)
		load_config(extra_confs[i]);
	ungrab();
	grab();
}

// Assembly:
pushq %rbx
callq 0xee99
leaq 0x13554(%rip), %rdi     # 0x22370
callq 0xf4b0
cmpl $0x0, 0x1353c(%rip)     # 0x22364
jle 0xee4b
xorl %ebx, %ebx
movq 0x13535(%rip), %rax     # 0x22368
movq (%rax,%rbx,8), %rdi
callq 0xf4b0
incq %rbx
movslq 0x1351e(%rip), %rax     # 0x22364
cmpq %rax, %rbx
jl 0xee2c
callq 0xf252
popq %rbx
jmp 0xeeec
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]sxhkd/src/sxhkd.c
// Function: cleanup
void cleanup(void)
{
	PUTS("cleanup");
	hotkey_t *hk = hotkeys_head;
	while (hk != NULL) {
		hotkey_t *next = hk->next;
		destroy_chain(hk->chain);
		free(hk->cycle);
		free(hk);
		hk = next;
	}
	hotkeys_head = hotkeys_tail = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x1360c(%rip), %rbx     # 0x224b0
testq %rbx, %rbx
je 0xeed4
movq 0x218(%rbx), %r14
movq (%rbx), %rdi
callq 0x10f57
movq 0x210(%rbx), %rdi
callq 0xe040
movq %rbx, %rdi
callq 0xe040
movq %r14, %rbx
testq %r14, %r14
jne 0xeea9
xorl %eax, %eax
movq %rax, 0x135cb(%rip)     # 0x224a8
movq %rax, 0x135cc(%rip)     # 0x224b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]sxhkd/src/grab.c
// Function: grab
void grab(void)
{
	PUTS("grab");
	for (hotkey_t *hk = hotkeys_head; hk != NULL; hk = hk->next)
		grab_chord(hk->chain->head);
	xcb_flush(dpy);
	grabbed = true;
}

// Assembly:
pushq %rbx
leaq 0x135bc(%rip), %rax     # 0x224b0
movq (%rax), %rbx
testq %rbx, %rbx
je 0xef10
movq (%rbx), %rax
movq (%rax), %rdi
callq 0xef2b
movq 0x218(%rbx), %rbx
jmp 0xeef7
leaq 0x13561(%rip), %rax     # 0x22478
movq (%rax), %rdi
callq 0xe140
leaq 0x13432(%rip), %rax     # 0x22358
movb $0x1, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]sxhkd/src/grab.c
// Function: grab_chord
void grab_chord(chord_t *chord)
{
	for (chord_t *c = chord; c != NULL; c = c->more) {
		if (c->button == XCB_NONE) {
			xcb_keycode_t *keycodes = keycodes_from_keysym(c->keysym);
			if (keycodes != NULL)
				for (xcb_keycode_t *kc = keycodes; *kc != XCB_NO_SYMBOL; kc++)
					if (c->keysym == xcb_key_symbols_get_keysym(symbols, *kc, 0))
						grab_key_button(*kc, c->button, c->modfield);
			free(keycodes);
		} else {
			grab_key_button(XCB_NONE, c->button, c->modfield);
		}
	}
}

// Assembly:
testq %rdi, %rdi
je 0xefde
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x13542(%rip), %r15     # 0x22488
movb 0x104(%rbx), %al
testb %al, %al
je 0xef63
movzwl 0x106(%rbx), %edx
movzbl %al, %esi
xorl %edi, %edi
callq 0xefdf
jmp 0xefc6
movl 0x100(%rbx), %edi
callq 0x106d4
movq %rax, %r14
testq %rax, %rax
je 0xefbe
movb (%r14), %al
testb %al, %al
je 0xefbe
movq %r14, %r12
incq %r12
movl 0x100(%rbx), %ebp
movq (%r15), %rdi
movzbl %al, %esi
xorl %edx, %edx
callq 0xe250
cmpl %eax, %ebp
jne 0xefb3
movzbl -0x1(%r12), %edi
movzbl 0x104(%rbx), %esi
movzwl 0x106(%rbx), %edx
callq 0xefdf
movb (%r12), %al
incq %r12
testb %al, %al
jne 0xef83
movq %r14, %rdi
callq 0xe040
movq 0x118(%rbx), %rbx
testq %rbx, %rbx
jne 0xef46
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]sxhkd/src/grab.c
// Function: grab_key_button
void grab_key_button(xcb_keycode_t keycode, xcb_button_t button, uint16_t modfield)
{
	grab_key_button_checked(keycode, button, modfield);
	if (modfield == XCB_MOD_MASK_ANY)
		return;
	if (num_lock != 0)
		grab_key_button_checked(keycode, button, modfield | num_lock);
	if (caps_lock != 0)
		grab_key_button_checked(keycode, button, modfield | caps_lock);
	if (scroll_lock != 0)
		grab_key_button_checked(keycode, button, modfield | scroll_lock);
	if (num_lock != 0 && caps_lock != 0)
		grab_key_button_checked(keycode, button, modfield | num_lock | caps_lock);
	if (caps_lock != 0 && scroll_lock != 0)
		grab_key_button_checked(keycode, button, modfield | caps_lock | scroll_lock);
	if (num_lock != 0 && scroll_lock != 0)
		grab_key_button_checked(keycode, button, modfield | num_lock | scroll_lock);
	if (num_lock != 0 && caps_lock != 0 && scroll_lock != 0)
		grab_key_button_checked(keycode, button, modfield | num_lock | caps_lock | scroll_lock);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movl %edi, %ebp
callq 0xf159
cmpl $0x8000, %ebx           # imm = 0x8000
je 0xf14a
leaq 0x13487(%rip), %r15     # 0x22490
movzwl (%r15), %eax
movzbl %bpl, %ebp
movzbl %r14b, %r14d
testw %ax, %ax
je 0xf029
orl %ebx, %eax
movzwl %ax, %edx
movl %ebp, %edi
movl %r14d, %esi
callq 0xf159
leaq 0x13462(%rip), %r12     # 0x22492
movzwl (%r12), %eax
testw %ax, %ax
je 0xf049
orl %ebx, %eax
movzwl %ax, %edx
movl %ebp, %edi
movl %r14d, %esi
callq 0xf159
leaq 0x13444(%rip), %r13     # 0x22494
movzwl (%r13), %eax
testw %ax, %ax
je 0xf069
orl %ebx, %eax
movzwl %ax, %edx
movl %ebp, %edi
movl %r14d, %esi
callq 0xf159
movzwl (%r15), %eax
testw %ax, %ax
setne %dl
movzwl (%r12), %ecx
testw %cx, %cx
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0xf09e
orl %ebx, %eax
orl %eax, %ecx
movzwl %cx, %edx
movl %ebp, %edi
movl %r14d, %esi
callq 0xf159
movzwl (%r12), %ecx
testw %cx, %cx
setne %dl
movzwl (%r13), %eax
testw %ax, %ax
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0xf0cf
orl %ebx, %ecx
orl %ecx, %eax
movzwl %ax, %edx
movl %ebp, %edi
movl %r14d, %esi
callq 0xf159
movzwl (%r13), %eax
movzwl (%r15), %ecx
testw %cx, %cx
setne %dl
testw %ax, %ax
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0xf103
orl %ebx, %ecx
orl %ecx, %eax
movzwl %ax, %edx
movl %ebp, %edi
movl %r14d, %esi
callq 0xf159
movzwl (%r15), %ecx
movzwl (%r13), %eax
testw %cx, %cx
setne %sil
movzwl (%r12), %edx
testw %dx, %dx
setne %dil
andb %sil, %dil
testw %ax, %ax
setne %sil
andb %dil, %sil
cmpb $0x1, %sil
jne 0xf14a
orl %ebx, %ecx
orl %edx, %eax
orl %ecx, %eax
movzwl %ax, %edx
movl %ebp, %edi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf159
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]sxhkd/src/grab.c
// Function: grab_key_button_checked
void grab_key_button_checked(xcb_keycode_t keycode, xcb_button_t button, uint16_t modfield)
{
	xcb_generic_error_t *err;
	if (button == XCB_NONE)
		err = xcb_request_check(dpy, xcb_grab_key_checked(dpy, true, root, modfield, keycode, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_SYNC));
	else
		err = xcb_request_check(dpy, xcb_grab_button_checked(dpy, true, root, XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE, XCB_GRAB_MODE_SYNC, XCB_GRAB_MODE_ASYNC, XCB_NONE, XCB_NONE, button, modfield));
	unsigned int value = (button == XCB_NONE ? keycode : button);
	char *type = (button == XCB_NONE ? "key" : "button");
	if (err != NULL) {
		warn("Could not grab %s %u with modfield %u: ", type, value, modfield);
		if (err->error_code == XCB_ACCESS)
			warn("the combination is already grabbed.\n");
		else
			warn("error %u encountered.\n", err->error_code);
		free(err);
	} else {
		PRINTF("grab %s %u %u\n", type, value, modfield);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %eax
leaq 0x1330f(%rip), %rcx     # 0x22478
movq (%rcx), %r14
leaq 0x13325(%rip), %rcx     # 0x22498
movl (%rcx), %edx
movzbl %sil, %r15d
movzwl %ax, %ebx
movzbl %dil, %ebp
testl %esi, %esi
je 0xf1ac
xorl %eax, %eax
movq %r14, %rdi
movl $0x1, %esi
movl $0xc, %ecx
xorl %r8d, %r8d
movl $0x1, %r9d
pushq %rbx
pushq %r15
pushq %rax
pushq %rax
callq 0xe3b0
addq $0x20, %rsp
jmp 0xf1ce
subq $0x8, %rsp
movq %r14, %rdi
movl $0x1, %esi
movl %ebx, %ecx
movl %ebp, %r8d
movl $0x1, %r9d
pushq $0x0
callq 0xe0a0
addq $0x10, %rsp
movq %r14, %rdi
movl %eax, %esi
callq 0xe2a0
testq %rax, %rax
je 0xf227
movq %rax, %r14
testb %r15b, %r15b
leaq 0x2158(%rip), %rax      # 0x11342
leaq 0x2078(%rip), %rsi      # 0x11269
cmoveq %rax, %rsi
cmovnel %r15d, %ebp
movzbl %bpl, %edx
leaq 0x206c(%rip), %rdi      # 0x11270
movl %ebx, %ecx
xorl %eax, %eax
callq 0xe410
movzbl 0x1(%r14), %esi
cmpl $0xa, %esi
jne 0xf232
leaq 0x207a(%rip), %rdi      # 0x11298
xorl %eax, %eax
callq 0xe410
jmp 0xf240
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2084(%rip), %rdi      # 0x112bd
xorl %eax, %eax
callq 0xe410
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe040
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]sxhkd/src/grab.c
// Function: ungrab
void ungrab(void)
{
	PUTS("ungrab");
	xcb_ungrab_key(dpy, XCB_GRAB_ANY, root, XCB_BUTTON_MASK_ANY);
	xcb_ungrab_button(dpy, XCB_BUTTON_INDEX_ANY, root, XCB_MOD_MASK_ANY);
	xcb_flush(dpy);
	grabbed = false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x1321b(%rip), %rbx     # 0x22478
movq (%rbx), %rdi
leaq 0x13231(%rip), %r14     # 0x22498
movl (%r14), %edx
xorl %esi, %esi
movl $0x8000, %ecx           # imm = 0x8000
callq 0xe390
movq (%rbx), %rdi
movl (%r14), %edx
xorl %esi, %esi
movl $0x8000, %ecx           # imm = 0x8000
callq 0xe2f0
movq (%rbx), %rdi
callq 0xe140
leaq 0x130c1(%rip), %rax     # 0x22358
movb $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]sxhkd/src/helpers.c
// Function: spawn
void spawn(char *cmd[], bool sync)
{
	if (fork() == 0) {
		if (dpy != NULL)
			close(xcb_get_file_descriptor(dpy));
		if (sync) {
			execute(cmd);
		} else {
			if (fork() == 0) {
				execute(cmd);
			}
			exit(EXIT_SUCCESS);
		}
	}
	wait(NULL);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0xe3e0
testl %eax, %eax
je 0xf394
xorl %edi, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe3c0
leaq 0x130dd(%rip), %rax     # 0x22478
movq (%rax), %rdi
testq %rdi, %rdi
je 0xf3af
callq 0xe060
movl %eax, %edi
callq 0xe1d0
testb %bpl, %bpl
jne 0xf3bd
callq 0xe3e0
testl %eax, %eax
jne 0xf3c5
movq %rbx, %rdi
callq 0xf3cc
xorl %edi, %edi
callq 0xe3a0
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]sxhkd/src/helpers.c
// Function: execute
void execute(char *cmd[])
{
	setsid();
	if (redir_fd != -1) {
		dup2(redir_fd, STDOUT_FILENO);
		dup2(redir_fd, STDERR_FILENO);
	}
	execvp(cmd[0], cmd);
	err("Spawning failed.\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xe1e0
leaq 0x12f7d(%rip), %r14     # 0x2235c
movl (%r14), %edi
cmpl $-0x1, %edi
je 0xf3fe
movl $0x1, %esi
callq 0xe150
movl (%r14), %edi
movl $0x2, %esi
callq 0xe150
movq (%rbx), %rdi
movq %rbx, %rsi
callq 0xe360
leaq 0x1ec7(%rip), %rdi      # 0x112d7
xorl %eax, %eax
callq 0xf2a4
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]sxhkd/src/helpers.c
// Function: lgraph
char *lgraph(char *s)
{
	size_t len = strlen(s);
	unsigned int i = 0;
	while (i < len && !isgraph(s[i]))
		i++;
	if (i < len)
		return (s + i);
	else
		return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xe130
testq %rax, %rax
je 0xf453
movq %rax, %r14
callq 0xe3f0
movq (%rax), %rcx
movl $0x1, %edx
xorl %eax, %eax
xorl %esi, %esi
movsbq (%rbx,%rsi), %rdi
cmpw $0x0, (%rcx,%rdi,2)
js 0xf457
movl %edx, %esi
incl %edx
cmpq %rsi, %r14
ja 0xf43c
jmp 0xf45d
xorl %eax, %eax
jmp 0xf45d
addq %rsi, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]sxhkd/src/parse.c
// Function: load_config
void load_config(const char *config_file)
{
	PRINTF("load configuration '%s'\n", config_file);
	FILE *cfg = fopen(config_file, "r");
	if (cfg == NULL)
		err("Can't open configuration file: '%s'.\n", config_file);

	char buf[3 * MAXLEN];
	char chain[MAXLEN] = {0};
	char command[2 * MAXLEN] = {0};
	int offset = 0;
	char first;

	while (fgets(buf, sizeof(buf), cfg) != NULL) {
		first = buf[0];
		if (strlen(buf) < 2 || first == START_COMMENT) {
			continue;
		} else {
			char *start = lgraph(buf);
			if (start == NULL)
				continue;
			char *end = rgraph(buf);
			*(end + 1) = '\0';

			if (isgraph(first))
				snprintf(chain + offset, sizeof(chain) - offset, "%s", start);
			else
				snprintf(command + offset, sizeof(command) - offset, "%s", start);

			if (*end == PARTIAL_LINE) {
				offset += end - start;
				continue;
			} else {
				offset = 0;
			}

			if (isspace(first) && strlen(chain) > 0 && strlen(command) > 0) {
				process_hotkey(chain, command);
				chain[0] = '\0';
				command[0] = '\0';
			}
		}
	}

	fclose(cfg);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x628, %rsp            # imm = 0x628
movq %rdi, %r14
leaq 0x39b9(%rip), %rsi      # 0x12e84
callq 0xe330
testq %rax, %rax
je 0xf643
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0xe190
leaq 0x120(%rsp), %r15
movl $0x200, %edx            # imm = 0x200
movq %r15, %rdi
xorl %esi, %esi
callq 0xe190
leaq 0x320(%rsp), %r12
xorl %r13d, %r13d
movq %r12, %rdi
movl $0x300, %esi            # imm = 0x300
movq %rbx, %rdx
callq 0xe1f0
testq %rax, %rax
je 0xf629
movb 0x320(%rsp), %r14b
movq %r12, %rdi
callq 0xe130
cmpq $0x2, %rax
setb %al
cmpb $0x23, %r14b
sete %cl
orb %al, %cl
jne 0xf50f
movq %r12, %rdi
callq 0xf417
testq %rax, %rax
je 0xf50f
movq %rax, %rbp
movsbq %r14b, %r14
movq %r12, %rdi
callq 0xf465
movq %rax, 0x18(%rsp)
movb $0x0, 0x1(%rax)
callq 0xe3f0
movq %rax, 0x8(%rsp)
movq (%rax), %rax
xorl %esi, %esi
movq %r14, 0x10(%rsp)
cmpw $0x0, (%rax,%r14,2)
setns %sil
movslq %r13d, %rax
leaq 0x20(%rsp), %rdi
cmovnsq %r15, %rdi
shll $0x8, %esi
addq %rax, %rdi
subq %rax, %rsi
addq $0x100, %rsi            # imm = 0x100
leaq 0x1b77(%rip), %rdx      # 0x11127
movq %rbp, %rcx
xorl %eax, %eax
callq 0xe170
movq 0x18(%rsp), %r14
cmpb $0x5c, (%r14)
jne 0xf5d0
subl %ebp, %r14d
addl %r14d, %r13d
jmp 0xf50f
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
movl $0x0, %r13d
je 0xf50f
cmpb $0x0, 0x20(%rsp)
je 0xf50f
cmpb $0x0, 0x120(%rsp)
je 0xf50f
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0xf654
xorl %r13d, %r13d
movb %r13b, 0x20(%rsp)
movb %r13b, 0x120(%rsp)
jmp 0xf50f
movq %rbx, %rdi
callq 0xe0f0
addq $0x628, %rsp            # imm = 0x628
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7ca1(%rip), %rdi      # 0x172eb
movq %r14, %rsi
xorl %eax, %eax
callq 0xf2a4
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]sxhkd/src/parse.c
// Function: parse_event
void parse_event(xcb_generic_event_t *evt, uint8_t event_type, xcb_keysym_t *keysym, xcb_button_t *button, uint16_t *modfield)
{
	if (event_type == XCB_KEY_PRESS) {
		xcb_key_press_event_t *e = (xcb_key_press_event_t *) evt;
		xcb_keycode_t keycode = e->detail;
		*modfield = e->state;
		*keysym = xcb_key_symbols_get_keysym(symbols, keycode, 0);
		PRINTF("key press %u %u\n", keycode, *modfield);
	} else if (event_type == XCB_KEY_RELEASE) {
		xcb_key_release_event_t *e = (xcb_key_release_event_t *) evt;
		xcb_keycode_t keycode = e->detail;
		*modfield = e->state & ~modfield_from_keycode(keycode);
		*keysym = xcb_key_symbols_get_keysym(symbols, keycode, 0);
		PRINTF("key release %u %u\n", keycode, *modfield);
	} else if (event_type == XCB_BUTTON_PRESS) {
		xcb_button_press_event_t *e = (xcb_button_press_event_t *) evt;
		*button = e->detail;
		*modfield = e->state;
		PRINTF("button press %u %u\n", *button, *modfield);
	} else if (event_type == XCB_BUTTON_RELEASE) {
		xcb_button_release_event_t *e = (xcb_button_release_event_t *) evt;
		*button = e->detail;
		*modfield = e->state;
		PRINTF("button release %u %u\n", *button, *modfield);
	}
}

// Assembly:
addl $-0x2, %esi
cmpl $0x3, %esi
ja 0xf9a3
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rdx, %rbx
leaq 0x19b2(%rip), %rax      # 0x112ec
movslq (%rax,%rsi,4), %rdx
addq %rax, %rdx
jmpq *%rdx
movb 0x1(%rdi), %al
movb %al, (%rcx)
movzwl 0x1c(%rdi), %eax
movw %ax, (%r14)
jmp 0xf999
movzbl 0x1(%rdi), %esi
movzwl 0x1c(%rdi), %eax
movw %ax, (%r14)
leaq 0x12b23(%rip), %rax     # 0x22488
movq (%rax), %rdi
jmp 0xf990
movzbl 0x1(%rdi), %ebp
movzwl 0x1c(%rdi), %r15d
movl %ebp, %edi
callq 0xf9a4
notl %eax
andw %r15w, %ax
movw %ax, (%r14)
leaq 0x12afd(%rip), %rax     # 0x22488
movq (%rax), %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0xe250
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]sxhkd/src/parse.c
// Function: modfield_from_keycode
int16_t modfield_from_keycode(xcb_keycode_t keycode)
{
	uint16_t modfield = 0;
	xcb_keycode_t *mod_keycodes = NULL;
	xcb_get_modifier_mapping_reply_t *reply = NULL;
	if ((reply = xcb_get_modifier_mapping_reply(dpy, xcb_get_modifier_mapping(dpy), NULL)) != NULL && reply->keycodes_per_modifier > 0) {
		if ((mod_keycodes = xcb_get_modifier_mapping_keycodes(reply)) != NULL) {
			unsigned int num_mod = xcb_get_modifier_mapping_keycodes_length(reply) / reply->keycodes_per_modifier;
			for (unsigned int i = 0; i < num_mod; i++) {
				for (unsigned int j = 0; j < reply->keycodes_per_modifier; j++) {
					xcb_keycode_t mkc = mod_keycodes[i * reply->keycodes_per_modifier + j];
					if (mkc == XCB_NO_SYMBOL)
						continue;
					if (keycode == mkc)
						modfield |= (1 << i);
				}
			}

		}
	}
	free(reply);
	return modfield;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebp
leaq 0x12ac0(%rip), %rax     # 0x22478
movq (%rax), %rbx
movq %rbx, %rdi
callq 0xe0d0
xorl %r14d, %r14d
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0xe3d0
movq %rax, %rbx
testq %rax, %rax
je 0xfa55
cmpb $0x0, 0x1(%rbx)
je 0xfa52
movq %rbx, %rdi
callq 0xe080
testq %rax, %rax
je 0xfa52
movq %rax, %r15
movq %rbx, %rdi
callq 0xe0e0
movzbl 0x1(%rbx), %esi
cltd
idivl %esi
xorl %edx, %edx
testl %eax, %eax
je 0xfa52
cmpl $0x1, %esi
movl %esi, %edi
adcl $0x0, %edi
xorl %r14d, %r14d
xorl %ecx, %ecx
movl $0x1, %r8d
shll %cl, %r8d
movq %rdi, %r9
movl %edx, %r10d
movl %r10d, %r11d
movb (%r15,%r11), %r13b
xorl %r11d, %r11d
movl %r8d, %r12d
cmpb %bpl, %r13b
je 0xfa36
xorl %r12d, %r12d
testb %r13b, %r13b
cmovel %r11d, %r12d
orl %r12d, %r14d
incl %r10d
decq %r9
jne 0xfa21
incl %ecx
addl %esi, %edx
cmpl %eax, %ecx
jne 0xfa12
jmp 0xfa55
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0xe040
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq