LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/hcmiya[P]opuscomment/src/parse-tags.c
// Function: append_buffer
static void append_buffer(uint8_t *line, size_t n) {
	if (store_picture) {
		decode_base64(line, n);
		return;
	}
	editlen += n;
	if (editlen > TAG_LENGTH_LIMIT__OUTPUT) {
		exceed_output_limit();
	}
	recordlen += n;
	fwrite(line, 1, n, strstore);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x8c12(%rip)      # 0xc574
jne 0x3ab3
addq %r14, %rbx
leaq 0x842e(%rip), %rax      # 0xbda0
movq (%rax), %r15
leaq 0x8c4b(%rip), %rbp      # 0xc5c7
leaq 0x5(%rsp), %r12
pushq $0x1
popq %r13
cmpq %rbx, %r14
jae 0x3afa
movzbl (%r14), %esi
movq %r15, %rdi
callq 0x2140
testq %rax, %rax
je 0x3b09
movb 0x8bee(%rip), %sil      # 0xc598
movb 0x8bc5(%rip), %cl       # 0xc575
testb %cl, %cl
sete %dl
andb %sil, %dl
cmpb $0x1, %dl
je 0x3b09
subq %r15, %rax
movsbq %cl, %rdx
movzbl %al, %edi
cmpq $0x40, %rdi
sete %r8b
cmpb $0x2, %dl
setl %r9b
andb %r8b, %r9b
cmpb $0x1, %r9b
je 0x3b09
cmpl $0x40, %edi
sete %r8b
cmpb $0x2, %cl
sete %r9b
movb $0x1, %dil
testb %r9b, %r8b
je 0x3a11
movb $0x1, 0x8b94(%rip)      # 0xc598
xorl %eax, %eax
movl %edi, %esi
movb %sil, 0x8bb7(%rip)      # 0xc5c6
jmp 0x3a29
cmpb $0x3, %cl
jne 0x3a29
testb %sil, %sil
je 0x3aa0
cmpb $0x40, %al
jne 0x3b09
xorl %eax, %eax
incq %r14
incb %cl
movb %cl, 0x8b41(%rip)       # 0xc575
movb %al, (%rdx,%rbp)
cmpb $0x4, %cl
jne 0x3985
movb 0x8b81(%rip), %al       # 0xc5c7
shlb $0x2, %al
movb 0x8b79(%rip), %cl       # 0xc5c8
movl %ecx, %edx
shrb $0x4, %dl
orb %al, %dl
movb %dl, 0x5(%rsp)
shlb $0x4, %cl
movb 0x8b66(%rip), %al       # 0xc5c9
movl %eax, %edx
shrb $0x2, %dl
orb %cl, %dl
shlb $0x6, %al
orb 0x8b57(%rip), %al       # 0xc5ca
movb %dl, 0x6(%rsp)
movb %al, 0x7(%rsp)
movzbl 0x8b44(%rip), %edx      # 0xc5c6
movq 0x8ac7(%rip), %rcx      # 0xc550
movq %r12, %rdi
movq %r13, %rsi
callq 0x2460
movb $0x0, 0x8ada(%rip)      # 0xc575
jmp 0x3985
movb $0x3, %sil
movb $0x2, %dil
cmpb $0x40, %al
je 0x39fd
jmp 0x3a08
movq 0x8ae6(%rip), %rax      # 0xc5a0
addq %rbx, %rax
movq %rax, 0x8adc(%rip)      # 0xc5a0
cmpq $0x2800001, %rax        # imm = 0x2800001
jb 0x3ad1
callq 0x69b7
addl %ebx, 0x8aa9(%rip)      # 0xc580
movq 0x8a62(%rip), %rcx      # 0xc540
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2460
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3b7d
// File: /workspace/github_c_makefile_star2_O2/hcmiya[P]opuscomment/src/parse-tags.c
// Function: tagerror
static noreturn void tagerror(char *e) {
	errorprefix();
	fprintf(stderr, catgets(catd, 1, 6, "editing input #%zu: "), tagnum + 1);
	fputs(e, stderr);
	fputc('\n', stderr);
	exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x6524
movq 0x84d3(%rip), %r12      # 0xbff8
movq (%r12), %r15
leaq 0x18b50(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x451d(%rip), %rcx      # 0x8057
pushq $0x1
popq %rbx
pushq $0x6
popq %rdx
movl %ebx, %esi
callq 0x2440
movq 0x8a0a(%rip), %rdx      # 0xc558
incq %rdx
movq %r15, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x2260
movq (%r12), %rsi
movq %r14, %rdi
callq 0x2180
movq (%r12), %rsi
pushq $0xa
popq %rdi
callq 0x21f0
movl %ebx, %edi
callq 0x2450
// File: /workspace/github_c_makefile_star2_O2/hcmiya[P]opuscomment/src/read.c
// Function: move_file
void move_file(void) {
	if (fclose(built_stream) == EOF) {
		fileerror(O.out ? O.out : outtmp);
	}
	if (O.out || !input_is_regular_file) {
	}
	else {
		int fd = fileno(stream_input);
		struct stat st;
		fstat(fd, &st);
		if (!rename(outtmp, O.in)) {
			// rename(2)は移動先が存在していてもunlink(2)の必要はない
			remove_tmp = false;
			if (!chmod(O.in, st.st_mode)) {
				return;
			}
		}
		oserror();
	}
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
leaq 0x18b11(%rip), %rax     # 0x1c6e0
movq (%rax), %rdi
callq 0x2120
cmpl $-0x1, %eax
jne 0x3bf8
leaq 0x18aa5(%rip), %rax     # 0x1c688
movq 0x30(%rax), %rdi
testq %rdi, %rdi
jne 0x3bf3
movq 0x89dd(%rip), %rdi      # 0xc5d0
callq 0x687e
leaq 0x18a89(%rip), %rbx     # 0x1c688
cmpq $0x0, 0x30(%rbx)
jne 0x3c5c
leaq 0x18abb(%rip), %rax     # 0x1c6c8
cmpb $0x1, (%rax)
jne 0x3c5c
leaq 0x18aa7(%rip), %rax     # 0x1c6c0
movq (%rax), %rdi
callq 0x22d0
movq %rsp, %rsi
movl %eax, %edi
callq 0x24b0
movq 0x899e(%rip), %rdi      # 0xc5d0
movq 0x28(%rbx), %rsi
callq 0x23e0
testl %eax, %eax
jne 0x3c57
movb $0x0, 0x8992(%rip)      # 0xc5d8
movq 0x28(%rbx), %rdi
movl 0x18(%rsp), %esi
callq 0x2380
testl %eax, %eax
je 0x3c5c
callq 0x67b6
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/hcmiya[P]opuscomment/src/read.c
// Function: put_left
static noreturn void put_left(long rew) {
	clearerr(stream_input);
	if (fseek(stream_input, seeked_len - rew, SEEK_SET)) {
		oserror();
	}
	
	size_t l;
	uint8_t buf[STACK_BUF_LEN];
	while (l = fread(buf, 1, STACK_BUF_LEN, stream_input)) {
		size_t ret = fwrite(buf, 1, l, built_stream);
		if (ret != l) {
			oserror();
		}
	}
	if (ferror(stream_input)) {
		oserror();
	}
	move_file();
	exit(0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rdi, %rbx
leaq 0x185c6(%rip), %r12     # 0x1c6c0
movq (%r12), %rdi
callq 0x2290
movq (%r12), %rdi
movq 0x84ea(%rip), %rsi      # 0xc5f8
subq %rbx, %rsi
xorl %edx, %edx
callq 0x2320
testl %eax, %eax
je 0x4121
callq 0x67b6
movq %rsp, %rbx
pushq $0x1
popq %r14
leaq 0x185b1(%rip), %r13     # 0x1c6e0
movq (%r12), %rcx
movl $0x1000, %edx           # imm = 0x1000
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20e0
testq %rax, %rax
je 0x4169
movq %rax, %r15
movq (%r13), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2460
cmpq %r15, %rax
je 0x412f
callq 0x67b6
jmp 0x412f
movq (%r12), %rdi
callq 0x20c0
testl %eax, %eax
je 0x417b
callq 0x67b6
callq 0x3bc0
xorl %edi, %edi
callq 0x2450
// File: /workspace/github_c_makefile_star2_O2/hcmiya[P]opuscomment/src/read.c
// Function: parse_page_sound
bool parse_page_sound(ogg_page *og) {
	set_pageno(og, ogg_page_pageno(og) + opus_idx_diff);
	ogg_page_checksum_set(og);
	write_page(og, built_stream);
	if (ogg_page_eos(og)) {
		if (input_is_regular_file) {
			put_left(0);
			/* NOTREACHED */
		}
		else {
			opus_idx_diff = 0;
		}
	}
	return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2080
leaq 0x17f83(%rip), %r14     # 0x1c6d8
addl (%r14), %eax
movq %rbx, %rdi
movl %eax, %esi
callq 0x55d7
movq %rbx, %rdi
callq 0x2110
leaq 0x17f6f(%rip), %rax     # 0x1c6e0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x5583
movq %rbx, %rdi
callq 0x24a0
testl %eax, %eax
je 0x4798
leaq 0x17f39(%rip), %rax     # 0x1c6c8
cmpb $0x1, (%rax)
je 0x47a2
andl $0x0, (%r14)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %edi, %edi
callq 0x40e0
// File: /workspace/github_c_makefile_star2_O2/hcmiya[P]opuscomment/src/read.c
// Function: parse_comment
bool parse_comment(ogg_page *og) {
	if (ogg_page_eos(og) || opus_idx > 1 && !ogg_page_continued(og)) {
		opuserror(err_opus_bad_stream);
	}
	opus_idx++;
	bool packet_break_in_page;
	if (copy_tag_packet(og, &packet_break_in_page)) {
		return parse_comment_term(og, packet_break_in_page);
	}
	
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x24a0
testl %eax, %eax
je 0x47cf
pushq $0x5
popq %rdi
xorl %eax, %eax
callq 0x6639
jmp 0x47e7
leaq 0x17efa(%rip), %rax     # 0x1c6d0
cmpl $0x2, (%rax)
jb 0x47e7
movq %rbx, %rdi
callq 0x2470
testl %eax, %eax
je 0x47c3
leaq 0x17ee2(%rip), %rax     # 0x1c6d0
incl (%rax)
movq (%rbx), %rax
movzbl 0x1a(%rax), %ecx
testq %rcx, %rcx
je 0x496b
movq 0x10(%rbx), %r14
movq %rcx, 0x8(%rsp)
decl %ecx
movzbl %cl, %r12d
pushq $0x9
popq %rbp
pushq $0x78
popq %r15
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x486c
cmpb $-0x1, 0x1b(%rax,%r13)
movl 0x7df6(%rip), %ecx      # 0xc620
jne 0x487c
cmpl $0x7800001, %ecx        # imm = 0x7800001
jb 0x4840
movl %ebp, %edi
movl %r15d, %esi
xorl %eax, %eax
callq 0x6639
movl 0x7dca(%rip), %edi      # 0xc610
movl $0xff, %edx
movq %r14, %rsi
callq 0x2100
incq %r13
addq $0xff, %r14
addl $0xff, 0x7db9(%rip)     # 0xc620
movq (%rbx), %rax
jmp 0x4819
movl 0x7dae(%rip), %ecx      # 0xc620
movq 0x8(%rsp), %r15
movl %r15d, %ebp
jmp 0x4888
leal 0x1(%r13), %ebp
movq %r13, %r12
movq 0x8(%rsp), %r15
movzbl 0x1b(%r12,%rax), %eax
addl %eax, %ecx
movl %ecx, 0x7d8a(%rip)      # 0xc620
cmpl $0x7800001, %ecx        # imm = 0x7800001
jb 0x48b3
pushq $0x9
popq %rdi
pushq $0x78
popq %rsi
xorl %eax, %eax
callq 0x6639
movq (%rbx), %rax
movb 0x1b(%rax,%r12), %al
movl 0x7d57(%rip), %edi      # 0xc610
movzbl %al, %edx
movq %r14, %rsi
callq 0x2100
cmpb %r15b, %bpl
jne 0x48d8
movq (%rbx), %rax
cmpb $-0x1, 0x1a(%rax,%r15)
je 0x496b
movl 0x7d32(%rip), %edi      # 0xc610
callq 0x21c0
movq 0x7d2e(%rip), %rdi      # 0xc618
leaq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0x2490
leaq 0x17dfa(%rip), %rax     # 0x1c6f8
movq (%rax), %rdi
movq %rsp, %rsi
callq 0x2490
leaq 0x17d78(%rip), %rax     # 0x1c688
cmpl $0x3, (%rax)
movq (%r14), %rsi
jne 0x4944
cmpq $0x0, 0x20(%rsi)
movq (%rsp), %rdx
jne 0x4948
cmpq $0x0, 0x18(%rdx)
jne 0x4948
cmpq $0x0, 0x30(%rax)
jne 0x4948
cmpb $0x0, 0x4(%rax)
jne 0x4948
cmpb $0x0, 0x28(%rsi)
jne 0x4948
xorl %edi, %edi
callq 0x2450
movq (%rsp), %rdx
xorl %ecx, %ecx
cmpb %r15b, %bpl
setne %cl
movq %rbx, %rdi
callq 0x3c65
movq 0x10(%rsp), %rdi
callq 0x2030
movq (%rsp), %rdi
callq 0x2030
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hcmiya[P]opuscomment/src/read.c
// Function: read_page
void read_page(ogg_sync_state *oy) {
	int seeklen;
	ogg_page og;
	while ((seeklen = ogg_sync_pageseek(oy, &og)) != 0) {
		if (seeklen > 0) {
			seeked_len += seeklen;
			parse_page(&og);
		}
		else seeked_len += -seeklen;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
leaq 0x17d33(%rip), %r12     # 0x1c6cc
pushq $0x5
popq %rbp
leaq 0x17d3d(%rip), %r13     # 0x1c6e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2360
testl %eax, %eax
je 0x4a86
jle 0x49ff
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rax, 0x7c34(%rip)      # 0xc5f8
cmpl $0x0, (%r12)
je 0x4a0a
movq %r14, %rdi
callq 0x5474
testb %al, %al
je 0x4a44
movl (%r12), %eax
movb $0x1, %r15b
cmpl $0x4, %eax
je 0x4a7c
cmpl $0x2, %eax
je 0x4a72
cmpl $0x1, %eax
jne 0x4a15
movq %r14, %rdi
callq 0x45b5
jmp 0x4a15
negl %eax
addq %rax, 0x7bf0(%rip)      # 0xc5f8
jmp 0x49a3
movq %r14, %rdi
callq 0x43f1
movl %eax, %r15d
testb %r15b, %r15b
je 0x4a3b
cmpl $0x3, (%r12)
ja 0x4a3b
movq %r14, %rdi
callq 0x24a0
testl %eax, %eax
je 0x4a3b
movl %ebp, %edi
xorl %eax, %eax
callq 0x6639
jmp 0x49a3
testb %r15b, %r15b
jne 0x49a3
movq %r14, %rdi
callq 0x2080
movq 0x7b8d(%rip), %rsi      # 0xc5e0
testq %rsi, %rsi
movq (%r13), %rcx
cmoveq %rcx, %rsi
testq %rax, %rax
cmoveq %rcx, %rsi
movq %r14, %rdi
callq 0x5583
jmp 0x49a3
movq %r14, %rdi
callq 0x47a9
jmp 0x4a15
movq %r14, %rdi
callq 0x4742
jmp 0x4a15
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hcmiya[P]opuscomment/src/read.c
// Function: put_non_opus_stream
static void put_non_opus_stream() {
	rewind(non_opus_stream);
	uint8_t buf[STACK_BUF_LEN];
	size_t readlen;
	while (readlen = fread(buf, 1, STACK_BUF_LEN, non_opus_stream)) {
		if (fwrite(buf, 1, readlen, built_stream) != readlen) {
			oserror();
		}
	}
	fclose(non_opus_stream);
	non_opus_stream = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq 0x7b36(%rip), %rdi      # 0xc5e0
callq 0x2150
movq %rsp, %rbx
pushq $0x1
popq %r14
leaq 0x17c23(%rip), %r12     # 0x1c6e0
movq 0x7b1c(%rip), %rcx      # 0xc5e0
movl $0x1000, %edx           # imm = 0x1000
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20e0
testq %rax, %rax
je 0x4afa
movq %rax, %r15
movq (%r12), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2460
cmpq %r15, %rax
je 0x4abd
callq 0x67b6
jmp 0x4abd
movq 0x7adf(%rip), %rdi      # 0xc5e0
callq 0x2120
andq $0x0, 0x7ad2(%rip)      # 0xc5e0
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/hcmiya[P]opuscomment/src/read-flac.c
// Function: get_metadata_header
bool get_metadata_header(uint8_t *type, size_t *len) {
	size_t readlen = fread(gbuf, 1, 4, stream_input);
	if (readlen == (size_t)-1) oserror();
	if (readlen != 4) {
		opuserror(err_opus_non_flac);
	}
	
	bool last = 0x80 & gbuf[0];
	*type = 0x7f & gbuf[0];
	gbuf[0] = 0;
	*len = htonl(*(uint32_t*)gbuf);
	gbuf[0] = *type; // 「最後のヘッダ」標識を削除
	return last;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x17b8f(%rip), %rax     # 0x1c6c0
movq (%rax), %rcx
leaq 0x7af5(%rip), %rdi      # 0xc630
pushq $0x1
popq %rsi
pushq $0x4
popq %rdx
callq 0x20e0
cmpq $0x4, %rax
je 0x4b61
cmpq $-0x1, %rax
jne 0x4b57
callq 0x67b6
pushq $0xf
popq %rdi
xorl %eax, %eax
callq 0x6639
movb 0x7ac9(%rip), %al       # 0xc630
movl %eax, %ecx
andb $0x7f, %cl
movb %cl, (%rbx)
movb $0x0, 0x7abb(%rip)      # 0xc630
movl 0x7ab5(%rip), %ecx      # 0xc630
bswapl %ecx
movq %rcx, (%r14)
movb (%rbx), %cl
movb %cl, 0x7aa8(%rip)       # 0xc630
shrb $0x7, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/hcmiya[P]opuscomment/src/read-flac.c
// Function: store_tags_flac
void store_tags_flac(struct rettag_st *rst, struct edit_st *est) {
	size_t readlen;
	if (rst) {
		store_tags(NULL, rst, est, false);
		uint32_t left = ftell(rst->tag);
		*(uint32_t*)gbuf = ntohl(left);
		gbuf[0] = 4;
		write_buffer(gbuf, 4, built_stream);
		rewind(rst->tag);
		while (readlen = fread(gbuf, 1, gbuflen, rst->tag)) {
			write_buffer(gbuf, readlen, built_stream);
		}
	}
	rewind(est->pict);
	while (readlen = fread(gbuf, 1, gbuflen, est->pict)) {
		write_buffer(gbuf, readlen, built_stream);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
je 0x4c1f
movq %rdi, %r14
xorl %edi, %edi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x3c65
movq (%r14), %rdi
callq 0x2280
bswapl %eax
movl %eax, 0x7a6a(%rip)      # 0xc630
leaq 0x7a63(%rip), %r15      # 0xc630
movb $0x4, 0x7a5c(%rip)      # 0xc630
leaq 0x17b05(%rip), %r13     # 0x1c6e0
movq (%r13), %rdx
pushq $0x4
popq %rsi
movq %r15, %rdi
callq 0x4c6e
movq (%r14), %rdi
callq 0x2150
pushq $0x1
popq %r12
movq (%r14), %rcx
movl $0x10000, %edx          # imm = 0x10000
movq %r15, %rdi
movq %r12, %rsi
callq 0x20e0
testq %rax, %rax
je 0x4c1f
movq (%r13), %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x4c6e
jmp 0x4bf6
movq 0x10(%rbx), %rdi
callq 0x2150
leaq 0x7a01(%rip), %r14      # 0xc630
pushq $0x1
popq %r15
leaq 0x17aa6(%rip), %r12     # 0x1c6e0
movq 0x10(%rbx), %rcx
movl $0x10000, %edx          # imm = 0x10000
movq %r14, %rdi
movq %r15, %rsi
callq 0x20e0
testq %rax, %rax
je 0x4c64
movq (%r12), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x4c6e
jmp 0x4c3a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/hcmiya[P]opuscomment/src/read-flac.c
// Function: put_base64_locale
static void *put_base64_locale(void *tagin_) {
	FILE *tagin = tagin_;
	iconv_t cd = iconv_open(nl_langinfo(CODESET), "us-ascii");
	size_t readlen;
	char buf[128];
	while (readlen = fread(buf, 1, 64, tagin)) {
		size_t asciileft = readlen, locleft = 128 - readlen;
		char *ascii = buf, *loc = buf + readlen;
		iconv(cd, &ascii, &asciileft, &loc, &locleft);
		// このiconv()はPCS範囲内でシフトも発生しないはずなのでバッファ持ち越しがない
		// asciiは元のlocの位置に移った
		write_buffer(ascii, loc - ascii, tag_output);
	}
	iconv_close(cd);
	fclose(tagin);
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
pushq $0xe
popq %rdi
callq 0x22f0
leaq 0x2db3(%rip), %rsi      # 0x80f3
movq %rax, %rdi
callq 0x24d0
movq %rax, %r14
leaq 0x20(%rsp), %r15
movq %rsp, %rbp
leaq 0x10(%rsp), %r13
leaq 0x17389(%rip), %r12     # 0x1c6e8
movq %r15, %rdi
pushq $0x1
popq %rsi
pushq $0x40
popq %rdx
movq %rbx, %rcx
callq 0x20e0
testq %rax, %rax
je 0x53c6
movq %rax, 0x18(%rsp)
movl $0x80, %ecx
subq %rax, %rcx
movq %rcx, 0x10(%rsp)
movq %r15, 0x8(%rsp)
addq %rsp, %rax
addq $0x20, %rax
movq %rax, (%rsp)
movq %r14, %rdi
leaq 0x8(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %rbp, %rcx
movq %r13, %r8
callq 0x20b0
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
subq %rdi, %rsi
movq (%r12), %rdx
callq 0x4c6e
jmp 0x535f
movq %r14, %rdi
callq 0x2370
movq %rbx, %rdi
callq 0x2120
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
movb $0x1, %al
testl %edx, %edx
je 0x542e
xorl %edx, %edx
cmpq %rdx, %rsi
je 0x5456
movb (%rdi,%rdx), %r10b
cmpb $0x3d, %r10b
je 0x5453
leal -0x20(%r10), %r11d
cmpb $0x5e, %r11b
setb %r9b
addb $-0x61, %r10b
cmpb $0x19, %r10b
ja 0x5426
movb %r11b, (%rdi,%rdx)
testq %r8, %r8
je 0x5426
movb $0x1, (%r8)
andb %r9b, %al
incq %rdx
jmp 0x53f4
xorl %edx, %edx
cmpq %rdx, %rsi
je 0x5456
movb (%rdi,%rdx), %r8b
cmpb $0x3d, %r8b
je 0x5453
addb $-0x20, %r8b
cmpb $0x5e, %r8b
setb %r8b
andb %r8b, %al
incq %rdx
jmp 0x5430
movb $0x0, (%rcx)
andb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x17248(%rip), %rax     # 0x1c6d4
movl (%rax), %ebp
movq %r14, %rdi
cmpl %ebp, %ebx
jne 0x54f0
callq 0x2040
testl %eax, %eax
je 0x54a8
pushq $0x5
popq %rdi
xorl %eax, %eax
callq 0x6639
leaq 0x1721d(%rip), %rax     # 0x1c6cc
cmpl $0x4, (%rax)
je 0x5573
movq %r14, %rdi
callq 0x2080
leaq 0x17209(%rip), %r15     # 0x1c6d0
movl (%r15), %ecx
cmpq %rcx, %rax
je 0x5573
movq %r14, %rdi
callq 0x2080
movl (%r15), %edx
pushq $0xa
popq %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x6639
jmp 0x5573
callq 0x2080
cmpl $0x1, %eax
je 0x553b
testl %eax, %eax
jne 0x5547
leaq 0x171d7(%rip), %rax     # 0x1c6dc
cmpb $0x1, (%rax)
jne 0x5514
pushq $0x5
popq %rdi
xorl %eax, %eax
callq 0x6639
movq %r14, %rdi
callq 0x2040
testl %eax, %eax
je 0x5569
movq %r14, %rdi
callq 0x24a0
testl %eax, %eax
jne 0x5569
movq %r14, %rdi
callq 0x22b0
testq %rax, %rax
jne 0x5569
jmp 0x5573
leaq 0x1719a(%rip), %rax     # 0x1c6dc
movb $0x1, (%rax)
jmp 0x555d
leaq 0x1718e(%rip), %rax     # 0x1c6dc
cmpb $0x0, (%rax)
jne 0x555d
pushq $0x5
popq %rdi
xorl %eax, %eax
callq 0x6639
movq %r14, %rdi
callq 0x2040
testl %eax, %eax
je 0x5573
pushq $0x5
popq %rdi
xorl %eax, %eax
callq 0x6639
cmpl %ebp, %ebx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
movq %r14, %rcx
callq 0x2460
cmpq 0x8(%rbx), %rax
je 0x55aa
callq 0x67b6
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rdx
pushq $0x1
popq %rsi
movq %r14, %rcx
callq 0x2460
cmpq 0x18(%rbx), %rax
jne 0x55cb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x67b6
// File: /workspace/github_c_makefile_star2_O2/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
movl (%rsi), %eax
movl %eax, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
callq 0x5a19
movl %eax, %r14d
leaq 0x14(%rsp), %rax
movl %r14d, (%rax)
leaq 0xf(%rsp), %rax
movb $0x1, (%rax)
movb $0x1, %bl
leaq 0x20(%rsp), %r13
testl %r14d, %r14d
je 0x5b69
movl %r14d, %ebp
movl $0x1000, %eax           # imm = 0x1000
cmpq %rax, %rbp
movl $0x1000, %r15d          # imm = 0x1000
cmovbq %rbp, %r15
movq %r13, %rdi
movq %r15, %rsi
movq 0x18(%rsp), %rdx
callq 0x59f5
testb $0x1, %bl
je 0x5ae4
cmpb $0x3d, 0x20(%rsp)
jne 0x5ac3
movq 0x67df(%rip), %rsi      # 0xc298
pushq $0xd
popq %rdi
xorl %eax, %eax
callq 0x6639
leaq 0x16bbe(%rip), %rax     # 0x1c688
cmpb $0x1, 0xe(%rax)
jne 0x5aec
movq %r13, %rdi
movq %rbp, %rsi
callq 0x60de
testb %al, %al
je 0x5aec
xorl %r12d, %r12d
jmp 0x5b5a
testb $0x1, %r12b
jne 0x5b00
jmp 0x5b5a
movl 0x10(%rsp), %edi
leaq 0x14(%rsp), %rsi
pushq $0x4
popq %rdx
callq 0x2100
movb $0x1, %r12b
cmpb $0x1, 0xf(%rsp)
jne 0x5b4b
leaq 0x16b7a(%rip), %rax     # 0x1c688
movzbl 0x16(%rax), %edx
movq %r13, %rdi
movq %r15, %rsi
leaq 0xf(%rsp), %rcx
leaq 0x16b34(%rip), %r8      # 0x1c658
callq 0x53ec
testb %al, %al
jne 0x5b4b
leaq 0x16b54(%rip), %rax     # 0x1c688
cmpb $0x1, 0x21(%rax)
jne 0x5b4b
movq 0x6757(%rip), %rsi      # 0xc298
pushq $0xd
popq %rdi
xorl %eax, %eax
callq 0x6639
movl 0x10(%rsp), %edi
movq %r13, %rsi
movq %r15, %rdx
callq 0x2100
subl %r15d, %r14d
movl %r14d, 0x14(%rsp)
xorl %ebx, %ebx
jmp 0x5a78
leaq 0x16b18(%rip), %rax     # 0x1c688
cmpb $0x1, 0x21(%rax)
jne 0x5b8e
cmpb $0x1, 0xf(%rsp)
jne 0x5b8e
movq 0x6714(%rip), %rsi      # 0xc298
pushq $0xd
popq %rdi
xorl %eax, %eax
callq 0x6639
incq 0x6703(%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_O2/hcmiya[P]opuscomment/src/retrieve-tags.c
// Function: rtcopy_write
static bool rtcopy_write(FILE *packet_input, void *fptag_) {
	FILE *fptag = fptag_;
	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) {
			first = false;
			
			switch (O.edit) {
			case EDIT_WRITE:
				copy = O.tag_ignore_picture && test_mbp(buf, len);
				break;
			case EDIT_APPEND:
				copy = true;
				break;
			}
			if (copy) {
				uint8_t chunk[4];
				*(uint32_t*)chunk = oi32(len);
				fwrite(chunk, 4, 1, fptag);
				check_tagpacket_length(4);
			}
		}
		if (copy) {
			if (O.tag_toupper && field) {
				for (uint8_t *p = buf, *endp = buf + rl; p < endp; p++) {
					if (*p >= 0x61 && *p <= 0x7a) {
						*p -= 32;
					}
					if (*p == 0x3d) {
						field = false;
						break;
					}
				}
			}
			fwrite(buf, 1, rl, fptag);
			check_tagpacket_length(rl);
		}
		len -= rl;
	}
	return copy;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1028, %rsp           # imm = 0x1028
movq %rsi, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
callq 0x5a19
movl %eax, %ebp
movb $0x1, %r15b
movb $0x1, %r14b
testl %ebp, %ebp
je 0x5f88
movl %ebp, %ebx
movl $0x1000, %eax           # imm = 0x1000
cmpq %rax, %rbx
movl $0x1000, %r12d          # imm = 0x1000
cmovbq %rbx, %r12
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
movq 0x18(%rsp), %rdx
callq 0x59f5
testb $0x1, %r14b
je 0x5f12
leaq 0x167d9(%rip), %rax     # 0x1c688
movl (%rax), %eax
cmpl $0x3, %eax
je 0x5ee4
cmpl $0x2, %eax
jne 0x5edc
leaq 0x167c6(%rip), %rax     # 0x1c688
cmpb $0x1, 0xe(%rax)
jne 0x5f83
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x60de
movl %eax, %r13d
testb $0x1, %r13b
jne 0x5ee7
jmp 0x5f12
movb $0x1, %r13b
movl %ebp, %edi
callq 0x651b
movl %eax, 0xc(%rsp)
leaq 0xc(%rsp), %rdi
pushq $0x4
popq %rbx
movq %rbx, %rsi
pushq $0x1
popq %rdx
movq 0x10(%rsp), %rcx
callq 0x2460
movq %rbx, %rdi
callq 0x5600
testb $0x1, %r13b
je 0x5f78
leaq 0x16769(%rip), %rax     # 0x1c688
movb 0x16(%rax), %al
andb %r15b, %al
cmpb $0x1, %al
jne 0x5f5b
leaq (%rsp,%r12), %rax
addq $0x20, %rax
leaq 0x20(%rsp), %rcx
cmpq %rax, %rcx
setae %r15b
jae 0x5f5b
movb (%rcx), %dl
leal -0x61(%rdx), %esi
cmpb $0x19, %sil
ja 0x5f51
addb $-0x20, %dl
movb %dl, (%rcx)
jmp 0x5f56
cmpb $0x3d, %dl
je 0x5f5b
incq %rcx
jmp 0x5f36
leaq 0x20(%rsp), %rdi
pushq $0x1
popq %rsi
movq %r12, %rdx
movq 0x10(%rsp), %rcx
callq 0x2460
movq %r12, %rdi
callq 0x5600
subl %r12d, %ebp
xorl %r14d, %r14d
jmp 0x5e74
xorl %r13d, %r13d
jmp 0x5f78
andb $0x1, %r13b
movl %r13d, %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_O2/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 0x6058
movq %rsi, %rbx
movq %rdi, %r14
movq 0x16695(%rip), %rax     # 0x1c650
testq %rax, %rax
jne 0x5fc5
callq 0x2230
movq %rax, 0x16684(%rip)     # 0x1c650
movq 0x1666d(%rip), %rax     # 0x1c640
testq %rax, %rax
jne 0x5fdd
callq 0x2230
addl %ebx, 0x16679(%rip)     # 0x1c65c
movq %rax, 0x16656(%rip)     # 0x1c640
cmpb $0x1, 0x629f(%rip)      # 0xc290
jne 0x603c
leaq 0x6296(%rip), %rcx      # 0xc290
leaq 0x16657(%rip), %r8      # 0x1c658
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x53ec
testb %al, %al
jne 0x603c
leaq 0x16666(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x20dc(%rip), %rcx      # 0x8100
pushq $0x7
popq %rsi
pushq $0x3
popq %rdx
callq 0x2440
pushq $0x64
popq %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x68cf
movq 0x165fd(%rip), %rcx     # 0x1c640
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2460
movl 0x165fe(%rip), %edi     # 0x1c65c
testl %edi, %edi
jne 0x6091
leaq 0x16617(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x208d(%rip), %rcx      # 0x8100
pushq $0x7
popq %rsi
pushq $0x3
popq %rdx
callq 0x2440
pushq $0x64
popq %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x68cf
movl 0x165cb(%rip), %edi     # 0x1c65c
callq 0x651b
movl %eax, 0x165c0(%rip)     # 0x1c65c
leaq 0x165b9(%rip), %rdi     # 0x1c65c
movq 0x165a6(%rip), %rcx     # 0x1c650
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
callq 0x2460
movzbl 0x61d4(%rip), %edi      # 0xc290
movq 0x1658d(%rip), %rsi     # 0x1c650
callq 0x21f0
andl $0x0, 0x1658d(%rip)     # 0x1c65c
movb $0x1, 0x61ba(%rip)      # 0xc290
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/hcmiya[P]opuscomment/src/retrieve-tags.c
// Function: test_mbp
static bool test_mbp(uint8_t *buf, size_t len) {
	uint8_t const *mbp = MBPeq;
	size_t const mbplen = 23;
	if (len < mbplen) {
		return false;
	}
	while (*mbp) {
		uint8_t c = *buf++;
		if (c >= 0x61 && c <= 0x7a) { // a-z in ASCII
			c -= 32;
		}
		if (*mbp != c) {
			break;
		}
		mbp++;
	}
	return !*mbp;
}

// Assembly:
cmpq $0x17, %rsi
jae 0x60e7
xorl %eax, %eax
retq
leaq 0x5caa(%rip), %rax      # 0xbd98
movq (%rax), %rcx
xorl %edx, %edx
movb (%rcx,%rdx), %sil
testb %sil, %sil
sete %al
je 0x6120
movzbl (%rdi,%rdx), %r8d
leal -0x61(%r8), %r9d
leal -0x20(%r8), %r10d
cmpb $0x1a, %r9b
movzbl %r10b, %r9d
cmovael %r8d, %r9d
incq %rdx
cmpb %r9b, %sil
je 0x60f3
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x164de(%rip), %r14     # 0x1c660
testq %r14, %r14
jne 0x61b3
leaq 0x2349(%rip), %rsi      # 0x84d7
pushq $0x6
popq %rdi
xorl %edx, %edx
callq 0x2160
movq %rax, %r14
movq %rax, 0x164be(%rip)     # 0x1c660
testq %rax, %rax
jne 0x61b3
callq 0x67b6
movq 0x164ad(%rip), %r14     # 0x1c660
leaq 0x60f6(%rip), %r12      # 0xc2b0
leaq 0x164af(%rip), %r13     # 0x1c670
movq %r12, (%r13)
movq 0x10(%r12), %r15
testq %r15, %r15
je 0x61e5
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2330
addq $0x40, %r12
testl %eax, %eax
jne 0x61c1
testq %r15, %r15
setne %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6210
pushq $0xc
popq %rdi
xorl %eax, %eax
callq 0x6639
movq 0x10(%rbx), %rax
cmpb $0x10, 0x8(%rax)
jb 0x6224
pushq $0x6
popq %rdi
xorl %eax, %eax
callq 0x6639
leaq 0x1645d(%rip), %r15     # 0x1c688
cmpb $0x1, 0xd(%r15)
je 0x62de
cmpb $0x1, 0x4(%r15)
jne 0x62b0
cmpb $0x1, 0x5(%r15)
jne 0x6272
movq 0x10(%rbx), %rax
movzwl 0x10(%rax), %edi
callq 0x6518
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 0x6276
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 0x6518
movq 0x10(%rbx), %rcx
movw %ax, 0x10(%rcx)
movq %rbx, %rdi
callq 0x2110
cmpb $0x1, 0xd(%r15)
je 0x6318
cmpb $0x1, 0xd(%r15)
jne 0x62d3
movq 0x5d3a(%rip), %rax      # 0xbff8
movq (%rax), %rsi
pushq $0xa
popq %rdi
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 0x5d0f(%rip), %rax      # 0xbff8
movq (%rax), %r14
movq 0x10(%rbx), %rax
movzwl 0x10(%rax), %edi
callq 0x6518
cmpb $0x1, %bpl
jne 0x633f
movswl %ax, %edx
leaq 0x1f15(%rip), %rsi      # 0x821e
movq %r14, %rdi
xorl %eax, %eax
callq 0x2260
jmp 0x6236
movq 0x5cd9(%rip), %rax      # 0xbff8
movq (%rax), %rdi
cmpb $0x1, 0x7(%r15)
jne 0x6362
movswl %bp, %edx
leaq 0x1eea(%rip), %rsi      # 0x821d
xorl %eax, %eax
callq 0x2260
jmp 0x62b0
cwtl
cvtsi2sd %eax, %xmm0
mulsd 0x1dcc(%rip), %xmm0     # 0x8118
leaq 0x1ecf(%rip), %rsi      # 0x8222
movq %r14, %rdi
movb $0x1, %al
callq 0x2260
jmp 0x6236
movswl %bp, %eax
cvtsi2sd %eax, %xmm0
mulsd 0x1da7(%rip), %xmm0     # 0x8118
leaq 0x1ea9(%rip), %rsi      # 0x8221
movb $0x1, %al
callq 0x2260
jmp 0x62b0
// File: /workspace/github_c_makefile_star2_O2/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 0x6399
pushq $0xc
popq %rdi
xorl %eax, %eax
callq 0x6639
movq 0x10(%rbx), %rax
cmpb $0x3, 0x7(%rax)
jne 0x63ab
cmpb $0x2, 0x8(%rax)
jne 0x63ab
popq %rbx
retq
pushq $0x6
popq %rdi
xorl %eax, %eax
popq %rbx
jmp 0x6639
// File: /workspace/github_c_makefile_star2_O2/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 0x63cb
pushq $0xc
popq %rdi
xorl %eax, %eax
callq 0x6639
movq 0x10(%rbx), %rax
movl 0x7(%rax), %edi
callq 0x651b
testl %eax, %eax
je 0x63e5
pushq $0x6
popq %rdi
xorl %eax, %eax
callq 0x6639
movq 0x10(%rbx), %rax
cmpb $0x0, 0xb(%rax)
jne 0x63fd
pushq $0xc
popq %rdi
xorl %eax, %eax
callq 0x6639
movq 0x10(%rbx), %rax
movl 0xc(%rax), %edi
callq 0x651b
testl %eax, %eax
jne 0x6413
pushq $0xc
popq %rdi
xorl %eax, %eax
callq 0x6639
movq 0x10(%rbx), %rax
cmpb $0x0, 0x1d(%rax)
je 0x641f
popq %rbx
retq
pushq $0xc
popq %rdi
xorl %eax, %eax
popq %rbx
jmp 0x6639
// File: /workspace/github_c_makefile_star2_O2/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 0x64db
movq 0x10(%rbx), %rax
cmpb $0x1, 0x5(%rax)
je 0x64e9
pushq $0xc
popq %rdi
xorl %eax, %eax
callq 0x6639
movq 0x10(%rbx), %rax
cmpb $0x1, 0x6(%rax)
je 0x64f9
pushq $0x6
popq %rdi
xorl %eax, %eax
callq 0x6639
movq 0x10(%rbx), %rax
cmpb $0x0, 0x7(%rax)
jne 0x650a
cmpq $0x1a, 0x18(%rbx)
jne 0x650c
popq %rbx
retq
pushq $0xc
popq %rdi
xorl %eax, %eax
popq %rbx
jmp 0x6639
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x65c7
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 0x6524
movq 0x5a05(%rip), %r12      # 0xbff8
movq (%r12), %r15
leaq 0x16082(%rip), %rax     # 0x1c680
movq (%rax), %rdi
movslq %ebx, %rdx
leaq 0x5615(%rip), %rax      # 0xbc20
movq (%rax,%rdx,8), %rcx
pushq $0x2
popq %rsi
callq 0x2440
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x2400
movq (%r12), %rsi
pushq $0xa
popq %rdi
callq 0x21f0
pushq $0x1
popq %rdi
callq 0x2450
// File: /workspace/github_c_makefile_star2_O2/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 0x669d
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 0x6524
movslq %ebx, %rax
shlq $0x4, %rax
leaq 0x55d0(%rip), %rcx      # 0xbca0
leaq (%rcx,%rax), %r15
cmpb $0x1, (%rax,%rcx)
jne 0x66ea
leaq 0x15f8f(%rip), %r12     # 0x1c670
movq (%r12), %rax
cmpl $0x2, (%rax)
jne 0x672d
movq 0x5907(%rip), %rax      # 0xbff8
movq (%rax), %r14
leaq 0x15f85(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x1def(%rip), %rcx      # 0x84f4
pushq $0x1
popq %rsi
pushq $0x8
popq %rdx
callq 0x2440
leaq 0x15f59(%rip), %rcx     # 0x1c670
movq (%rcx), %rcx
movq 0x10(%rcx), %rdx
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x2260
jmp 0x6771
movq 0x58c4(%rip), %rax      # 0xbff8
movq (%rax), %r14
leaq 0x15f42(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x1d91(%rip), %rcx      # 0x84d9
pushq $0x1
popq %rsi
pushq $0x4
popq %rdx
callq 0x2440
movq (%r12), %rcx
movq 0x10(%rcx), %rdx
leaq 0x15f6e(%rip), %rcx     # 0x1c6d0
movl (%rcx), %ecx
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x2260
movq 0x5880(%rip), %r12      # 0xbff8
movq (%r12), %r14
leaq 0x15efd(%rip), %rax     # 0x1c680
movq (%rax), %rdi
movq 0x8(%r15), %rcx
pushq $0x3
popq %rsi
movl %ebx, %edx
callq 0x2440
movq %rsp, %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x2400
movq (%r12), %rsi
pushq $0xa
popq %rdi
callq 0x21f0
pushq $0x2
popq %rdi
callq 0x2450
// File: /workspace/github_c_makefile_star2_O2/hcmiya[P]opuscomment/src/error.c
// Function: oserror_fmt
noreturn void oserror_fmt(char const *e, ...) {
	va_list ap;
	va_start(ap, e);
	errorprefix();
	vfprintf(stderr, e, ap);
	fputc('\n', stderr);
	exit(3);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
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 0x6831
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 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
callq 0x6524
movq 0x579b(%rip), %r15      # 0xbff8
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2400
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x21f0
pushq $0x3
popq %rdi
callq 0x2450
// File: /workspace/github_c_makefile_star2_O2/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 0x6524
movq 0x5767(%rip), %rax      # 0xbff8
movq (%rax), %r14
leaq 0x15de5(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x1982(%rip), %rcx      # 0x8227
pushq $0x1
popq %rsi
pushq $0x5
popq %rdx
callq 0x2440
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2260
xorl %edi, %edi
callq 0x23d0
pushq $0x3
popq %rdi
callq 0x2450
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0xd8, %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 0x6935
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 0x110(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r14)
callq 0x6524
movq 0x5697(%rip), %r13      # 0xbff8
movq (%r13), %r12
leaq 0x15d14(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x1b90(%rip), %rcx      # 0x8506
pushq $0x1
popq %r15
pushq $0x7
popq %rdx
movl %r15d, %esi
callq 0x2440
movq %r12, %rdi
movq %rax, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x2260
movq (%r13), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2400
movq (%r13), %rsi
pushq $0xa
popq %rdi
callq 0x21f0
movl %r15d, %edi
callq 0x2450
// File: /workspace/github_c_makefile_star2_O2/begriffs[P]pthread-test/thread_error.c
// Function: main
int main(void)
{
	pthread_t weirdo;
	/* join with an uninitialized value */
	int status = pthread_join(weirdo, NULL);

	if (status != 0)
		fprintf(stderr, "Error %d: %s\n", status, strerror(status));
	else
		fprintf(stderr, "Weird, no error\n");
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
xorl %esi, %esi
callq 0x1050
movl %eax, %ebp
movq 0x2e79(%rip), %rax      # 0x3ff8
movq (%rax), %rbx
testl %ebp, %ebp
jne 0x119d
leaq 0xe85(%rip), %rdi       # 0x2012
pushq $0x10
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x1040
jmp 0x11ba
movl %ebp, %edi
callq 0x1060
leaq 0xe59(%rip), %rsi       # 0x2004
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/codeniko[P]CS214-Malloc-Free/Test4.c
// Function: main
void main()
{
    int i;
    int* p = malloc(5 * sizeof(int));
    for(i = 0; i < 5; i++){
        p[i] = i;
    }
    for(i = 0; i < 5; i++){
        printf("address: %p, value: %d\n", p + i, p[i]);
     }
    free(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0xea7(%rip), %rsi       # 0x2004
pushq $0x14
popq %rdi
pushq $0x7
popq %rdx
callq 0x11c0
movq %rax, %rbx
xorl %eax, %eax
cmpq $0x5, %rax
je 0x117b
movl %eax, (%rbx,%rax,4)
incq %rax
jmp 0x116d
leaq 0xe8a(%rip), %r14       # 0x200c
xorl %r15d, %r15d
cmpq $0x14, %r15
je 0x11a3
leaq (%rbx,%r15), %rsi
movl (%rbx,%r15), %edx
movq %r14, %rdi
xorl %eax, %eax
callq 0x1030
addq $0x4, %r15
jmp 0x1185
leaq 0xe5a(%rip), %rsi       # 0x2004
pushq $0xe
popq %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x12f9
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xea11
leaq 0x2647(%rip), %rax      # 0x11040
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movb $0x0, 0x13a7c(%rip)     # 0x22485
retq
movb $0x1, 0x13a71(%rip)     # 0x22482
retq
movb $0x1, 0x13a6b(%rip)     # 0x22484
retq
movb $0x1, 0x13a62(%rip)     # 0x22483
retq