LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__hdr_info(stbi__context*, int*, int*, int*)
static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)
{
   char buffer[STBI__HDR_BUFLEN];
   char *token;
   int valid = 0;

   if (strcmp(stbi__hdr_gettoken(s,buffer), "#?RADIANCE") != 0) {
       stbi__rewind( s );
       return 0;
   }

   for(;;) {
      token = stbi__hdr_gettoken(s,buffer);
      if (token[0] == 0) break;
      if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
   }

   if (!valid) {
       stbi__rewind( s );
       return 0;
   }
   token = stbi__hdr_gettoken(s,buffer);
   if (strncmp(token, "-Y ", 3)) {
       stbi__rewind( s );
       return 0;
   }
   token += 3;
   *y = (int) strtol(token, &token, 10);
   while (*token == ' ') ++token;
   if (strncmp(token, "+X ", 3)) {
       stbi__rewind( s );
       return 0;
   }
   token += 3;
   *x = (int) strtol(token, NULL, 10);
   *comp = 3;
   return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp            # imm = 0x418
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsp), %r13
movq %r13, %rsi
callq 0x1f013
movabsq $0x4e41494441523f23, %rax # imm = 0x4E41494441523F23
xorq (%r13), %rax
movabsq $0x45434e41494441, %rcx # imm = 0x45434E41494441
xorq 0x3(%r13), %rcx
orq %rax, %rcx
je 0x1fe47
movq 0xc8(%r15), %rax
movq %rax, 0xb8(%r15)
xorl %eax, %eax
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x1f013
cmpb $0x0, (%r13)
je 0x1ff66
movq %rbx, 0x8(%rsp)
xorl %ebp, %ebp
movl $0x1, %ebx
leaq 0x10(%rsp), %r13
movdqu 0x17(%rsp), %xmm0
pcmpeqb 0x1b2f(%rip), %xmm0     # 0x219b0
movdqa 0x10(%rsp), %xmm1
pcmpeqb 0x1b31(%rip), %xmm1     # 0x219c0
pand %xmm0, %xmm1
pmovmskb %xmm1, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
cmovel %ebx, %ebp
movq %r15, %rdi
movq %r13, %rsi
callq 0x1f013
cmpb $0x0, 0x10(%rsp)
jne 0x1fe73
movq %r13, (%rsp)
testl %ebp, %ebp
je 0x1fe25
movq %r15, %rdi
movq %r13, %rsi
callq 0x1f013
movl $0x592d, %eax           # imm = 0x592D
xorl 0x10(%rsp), %eax
movq %r13, (%rsp)
movzbl 0x12(%rsp), %ecx
xorl $0x20, %ecx
orw %ax, %cx
jne 0x1fe25
leaq 0x13(%rsp), %rdi
movq %rsp, %r13
movq %rdi, (%r13)
movq %r13, %rsi
movl $0xa, %edx
callq 0x8470
movl %eax, (%r12)
movq (%r13), %r12
decq %r12
cmpb $0x20, 0x1(%r12)
leaq 0x1(%r12), %r12
je 0x1ff0a
movq %r12, (%rsp)
leaq 0x26f2(%rip), %rsi      # 0x22614
movl $0x3, %edx
movq %r12, %rdi
callq 0x8180
testl %eax, %eax
movq 0x8(%rsp), %rbx
jne 0x1fe25
addq $0x3, %r12
movq %r12, (%rsp)
movq %r12, %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x8470
movl %eax, (%r14)
movl $0x3, (%rbx)
movl $0x1, %eax
jmp 0x1fe35
movq %r13, (%rsp)
jmp 0x1fe25
// File: /workspace/github_c_makefile_star2_O1/hcmiya[P]opuscomment/src/put-tags.c
// Function: tag_output_close
void tag_output_close(void) {
	if (O.tag_deferred) {
		FILE *deferred = tag_output;
		tag_output = stdout;
		rewind(deferred);
		size_t readlen;
		uint8_t buf[STACK_BUF_LEN];
		while(readlen = fread(buf, 1, STACK_BUF_LEN, deferred)) {
			put_bin(buf, readlen);
		}
		fclose(deferred);
	}
	
	if (fclose(stdout) == EOF) {
		puterror();
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
leaq 0x1a05b(%rip), %rax     # 0x1c688
cmpb $0x1, 0x20(%rax)
jne 0x269c
leaq 0x1a0ae(%rip), %rax     # 0x1c6e8
movq (%rax), %rbx
movq 0x997c(%rip), %rcx      # 0xbfc0
movq (%rcx), %rcx
movq %rcx, (%rax)
movq %rbx, %rdi
callq 0x2150
movq %rsp, %rdi
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
movq %rbx, %rcx
callq 0x20e0
testq %rax, %rax
je 0x2694
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x26c0
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
movq %r14, %rdi
movq %rbx, %rcx
callq 0x20e0
testq %rax, %rax
jne 0x266f
movq %rbx, %rdi
callq 0x2120
movq 0x991d(%rip), %rax      # 0xbfc0
movq (%rax), %rdi
callq 0x2120
addq $0x1008, %rsp           # imm = 0x1008
cmpl $-0x1, %eax
je 0x26bb
popq %rbx
popq %r14
retq
popq %rbx
popq %r14
jmp 0x26e5
// File: /workspace/github_c_makefile_star2_O1/hcmiya[P]opuscomment/src/put-tags.c
// Function: iconv_new
iconv_t iconv_new(char const *to, char const *from) {
#if defined __GLIBC__ || defined _LIBICONV_VERSION
	char to2[64];
	strcat(strcpy(to2, to), "//TRANSLIT");
#else
	char const *to2 = to;
#endif
	iconv_t cd = iconv_open(to2, from);
	if (cd == (iconv_t)-1) {
		if (errno == EINVAL) {
			oserror_fmt(catgets(catd, 4, 3, "iconv doesn't support converting %s -> %s"), from, to);
		}
		else {
			oserror();
		}
	}
	return cd;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2090
movq %r15, %rdi
callq 0x2130
movabsq $0x4c534e4152542f2f, %rcx # imm = 0x4C534E4152542F2F
movq %rcx, (%rsp,%rax)
movl $0x54494c, 0x7(%rsp,%rax) # imm = 0x54494C
movq %r15, %rdi
movq %r14, %rsi
callq 0x24d0
movq %rax, %r15
cmpq $-0x1, %rax
jne 0x2a09
callq 0x2050
cmpl $0x16, (%rax)
jne 0x2a04
leaq 0x19ca7(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x5632(%rip), %rcx      # 0x8015
movl $0x4, %esi
movl $0x3, %edx
callq 0x2440
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x6fb5
jmp 0x2a09
callq 0x6f9b
movq %r15, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hcmiya[P]opuscomment/src/put-tags.c
// Function: conv_ls
static size_t conv_ls(iconv_t cd, uint8_t *buf, size_t tagleft) {
	uint8_t *u8 = buf;
	char *ls = buf + tagleft;
	size_t remain = 0;
	for (;;) {
		char *lsend = ls;
		size_t bufleft = STACK_BUF_LEN - ((uint8_t*)ls - buf) - 1;
		size_t iconvret = iconv(cd, (char**)&u8, &tagleft, &lsend, &bufleft);
		int ie = errno;
		errno = 0;
		if (iconvret == (size_t)-1 && ie == EILSEQ) {
			u8error();
		}
		*lsend = '\0';
		// WONTFIX
		// ロケール文字列に \0 が含まれていてもそのままそこで途切れさせる
		put_ls(ls);
		if (iconvret != (size_t)-1 || ie == EINVAL) {
			remain = tagleft;
			if (remain) {
				memcpy(buf, u8, remain);
			}
			break;
		}
	}
	return remain;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x10(%rsp), %rax
movq %rdx, (%rax)
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rsi, 0x18(%rsp)
leaq (%rsi,%rdx), %r13
movl $0xfff, %ebp            # imm = 0xFFF
subq %rdx, %rbp
xorl %r15d, %r15d
movq %r13, (%rsp)
movq %rbp, 0x20(%rsp)
movq %r14, %rdi
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rsp, %rcx
leaq 0x20(%rsp), %r8
callq 0x20b0
movq %rax, %r12
callq 0x2050
movl (%rax), %ebx
movl $0x0, (%rax)
cmpq $-0x1, %r12
sete %al
cmpl $0x54, %ebx
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2ab4
movl 0x97d8(%rip), %esi      # 0xc280
movl $0x8, %edi
xorl %eax, %eax
callq 0x6e10
movq (%rsp), %rax
movb $0x0, (%rax)
movq %r13, %rdi
callq 0x2130
movq %r13, %rdi
movq %rax, %rsi
callq 0x26c0
cmpq $-0x1, %r12
sete %al
cmpl $0x16, %ebx
setne %bl
andb %al, %bl
jne 0x2afb
movq 0x10(%rsp), %r15
testq %r15, %r15
je 0x2afb
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
movq %r15, %rdx
callq 0x22a0
testb %bl, %bl
jne 0x2a5b
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hcmiya[P]opuscomment/src/put-tags.c
// Function: esc_oc
static uint8_t *esc_oc(uint8_t *src, uint8_t *dest, size_t len) {
	uint8_t *end = src + len;
	while(src < end) {
		*dest++ = *src++;
		if (src[-1] == 0xa) *dest++ = O.tag_escape_tilde ? 0x7e : 0x9;
	}
	return dest;
}

// Assembly:
movq %rsi, %rax
testq %rdx, %rdx
jle 0x2b57
addq %rdi, %rdx
leaq 0x19b61(%rip), %rcx     # 0x1c688
movb (%rdi), %sil
movb %sil, (%rax)
cmpb $0xa, (%rdi)
jne 0x2b4c
cmpb $0x0, 0x14(%rcx)
movl $0x7e, %esi
jne 0x2b42
movl $0x9, %esi
movb %sil, 0x1(%rax)
addq $0x2, %rax
jmp 0x2b4f
incq %rax
incq %rdi
cmpq %rdx, %rdi
jb 0x2b27
retq
// File: /workspace/github_c_makefile_star2_O1/hcmiya[P]opuscomment/src/put-tags.c
// Function: esc_vc
static uint8_t *esc_vc(uint8_t *src, uint8_t *dest, size_t len) {
	uint8_t *end = src + len;
	for (; src < end; src++) {
		switch (*src) {
		case 0x00:
			*dest++ = 0x5c;
			*dest++ = 0x30;
			break;
			
		case 0x0a:
			*dest++ = 0x5c;
			*dest++ = 0x6e;
			break;
		case 0x0d:
			*dest++ = 0x5c;
			*dest++ = 0x72;
			break;
			
		case 0x5c:
			*dest++ = 0x5c;
			*dest++ = 0x5c;
			break;
			
		default:
			*dest++ = *src;
			break;
		}
	}
	return dest;
}

// Assembly:
movq %rsi, %rax
testq %rdx, %rdx
jle 0x2bad
addq %rdi, %rdx
movb (%rdi), %cl
movzbl %cl, %esi
cmpl $0xc, %esi
jg 0x2b7d
testl %esi, %esi
je 0x2b95
cmpl $0xa, %esi
jne 0x2b8e
movw $0x6e5c, (%rax)         # imm = 0x6E5C
jmp 0x2ba1
cmpl $0xd, %esi
je 0x2b9c
cmpl $0x5c, %esi
jne 0x2b8e
movw $0x5c5c, (%rax)         # imm = 0x5C5C
jmp 0x2ba1
movb %cl, (%rax)
incq %rax
jmp 0x2ba5
movw $0x305c, (%rax)         # imm = 0x305C
jmp 0x2ba1
movw $0x725c, (%rax)         # imm = 0x725C
addq $0x2, %rax
incq %rdi
cmpq %rdx, %rdi
jb 0x2b63
retq
// File: /workspace/github_c_makefile_star2_O1/hcmiya[P]opuscomment/src/parse-tags.c
// Function: split_text
void *split_text(void *fp_) {
	FILE *fp = fp_;
	prepare_record();
	void (*line)(uint8_t *, size_t, bool) = O.tag_escape ? line_vc : line_oc;
	
	uint8_t tagbuf[STACK_BUF_LEN];
	size_t readlen;
	while ((readlen = fread(tagbuf, 1, STACK_BUF_LEN, fp)) != 0) {
		uint8_t *p1, *p2;
		if (memchr(tagbuf, 0, readlen) != NULL) {
			err_bin();
		}
		p1 = tagbuf;
		while ((p2 = memchr(p1, 0x0a, readlen - (p1 - tagbuf))) != NULL) {
			p2++;
			line(p1, p2 - p1, true);
			p1 = p2;
		}
		size_t left = readlen - (p1 - tagbuf);
		if (left) line(p1, left, false);
	}
	fclose(fp);
	line(NULL, 0, false);
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rdi, %rbx
callq 0x2bd4
leaq 0x19a36(%rip), %rax     # 0x1c688
cmpl $0x0, 0x10(%rax)
leaq 0x32c(%rip), %rax       # 0x2f89
leaq 0x114(%rip), %rbp       # 0x2d78
cmoveq %rax, %rbp
movq %rsp, %r14
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
movq %r14, %rdi
movq %rbx, %rcx
callq 0x20e0
testq %rax, %rax
je 0x2d2c
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x2200
testq %rax, %rax
jne 0x2d50
movq %r14, %rdi
movl $0xa, %esi
movq %r15, %rdx
callq 0x2200
testq %rax, %rax
je 0x2cf6
movq %r14, %rcx
movq %r14, %rdi
movq %rax, %r12
incq %r12
movq %r12, %rsi
subq %rcx, %rsi
movl $0x1, %edx
callq *%rbp
movq %r14, %r13
subq %r12, %r13
addq %r15, %r13
movq %r12, %rdi
movl $0xa, %esi
movq %r13, %rdx
callq 0x2200
movq %r12, %rcx
movq %r12, %rdi
testq %rax, %rax
jne 0x2cbd
jmp 0x2cfc
movq %r14, %r12
movq %r15, %r13
testq %r13, %r13
je 0x2d0b
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq *%rbp
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
movq %r14, %rdi
movq %rbx, %rcx
callq 0x20e0
movq %rax, %r15
testq %rax, %rax
jne 0x2c8c
movq %rbx, %rdi
callq 0x2120
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq *%rbp
xorl %eax, %eax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19929(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x535c(%rip), %rcx      # 0x80bd
movl $0x5, %esi
movl $0x4, %edx
callq 0x2440
movq %rax, %rdi
callq 0x3e34
// File: /workspace/github_c_makefile_star2_O1/hcmiya[P]opuscomment/src/parse-tags.c
// Function: line_oc
static void line_oc(uint8_t *line, size_t n, bool lf) {
	static bool afterlf = false;
	
	if (!line) {
		if (!first_call) {
			if (O.tag_check_line_term && !afterlf) {
				err_noterm();
			}
			if (!keep_blank) {
				if (on_field) err_nosep();
				finalize_record();
			}
			first_call = true;
			afterlf = false;
		}
		return;
	}
	
	if (afterlf) {
		if (*line == 0x9 || *line == 0x7e) {
			*line = 0x0a;
			if (lf) n--;
			append_buffer(line, n);
			afterlf = lf;
			return;
		}
		else {
			finalize_record();
		}
	}
	if (test_blank(line, n, lf)) return;
	
	if (lf) n--;
	if (on_field) {
		if(!test_tag_field(line, n, true, &on_field, NULL)) err_name();
		if (on_field && lf) err_name();
		test_mbp(&line, &n);
	}
	else {
		append_buffer(line, n);
	}
	afterlf = lf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
testq %rdi, %rdi
je 0x2fdb
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
cmpb $0x1, 0x961c(%rip)      # 0xc5cb
jne 0x3035
movzbl (%r14), %eax
cmpl $0x7e, %eax
je 0x2fc3
cmpl $0x9, %eax
jne 0x3030
movb $0xa, (%r14)
testb %bl, %bl
je 0x2fd2
decq %r15
movq %r15, (%rsp)
movq (%rsp), %rsi
jmp 0x3095
cmpb $0x1, 0x958f(%rip)      # 0xc571
jne 0x30a3
leaq 0x19699(%rip), %rax     # 0x1c688
cmpb $0x1, 0x22(%rax)
jne 0x300a
cmpb $0x0, 0x95cf(%rip)      # 0xc5cb
jne 0x300a
movl $0xd, %edi
xorl %eax, %eax
callq 0x6d34
cmpb $0x0, 0x9561(%rip)      # 0xc572
jne 0x3025
cmpb $0x1, 0x9559(%rip)      # 0xc573
je 0x30ca
callq 0x378f
movb $0x0, 0x9545(%rip)      # 0xc571
xorl %ebx, %ebx
jmp 0x309d
callq 0x378f
movzbl %bl, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3871
testb %al, %al
jne 0x30a3
testb %bl, %bl
je 0x3052
decq %r15
movq %r15, (%rsp)
movq (%rsp), %rsi
cmpb $0x1, 0x9516(%rip)      # 0xc573
jne 0x3095
leaq 0x950d(%rip), %rcx      # 0xc573
movq %r14, %rdi
movl $0x1, %edx
xorl %r8d, %r8d
callq 0x5988
testb %al, %al
je 0x30ad
movb 0x94f3(%rip), %al       # 0xc573
andb %bl, %al
cmpb $0x1, %al
je 0x30ad
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x3ac4
jmp 0x309d
movq %r14, %rdi
callq 0x3c4b
movb %bl, 0x9528(%rip)       # 0xc5cb
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x195cc(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x4fec(%rip), %rcx      # 0x80aa
movl $0x5, %esi
movl $0x2, %edx
jmp 0x30e5
leaq 0x195af(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x4f93(%rip), %rcx      # 0x806e
movl $0x5, %esi
movl $0x1, %edx
callq 0x2440
movq %rax, %rdi
callq 0x3e34
// File: /workspace/github_c_makefile_star2_O1/hcmiya[P]opuscomment/src/parse-tags.c
// Function: split_binary
void *split_binary(void *fp_) {
	FILE *fp = fp_;
	prepare_record();
	
	uint8_t tagbuf[STACK_BUF_LEN];
	size_t readlen;
	while ((readlen = fread(tagbuf, 1, STACK_BUF_LEN, fp)) != 0) {
		uint8_t *p1, *p2;
		p1 = tagbuf;
		while ((p2 = memchr(p1, 0, readlen - (p1 - tagbuf))) != NULL) {
			line_nul(p1, p2 - p1, true);
			p1 = p2 + 1;
		}
		size_t left = readlen - (p1 - tagbuf);
		if (left) line_nul(p1, left, false);
	}
	fclose(fp);
	line_nul(NULL, 0, false);
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rdi, %rbx
callq 0x2bd4
movq %rsp, %r14
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
movq %r14, %rdi
movq %rbx, %rcx
callq 0x20e0
testq %rax, %rax
je 0x31b9
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x2200
testq %rax, %rax
je 0x3180
movq %rax, %r13
movq %r14, %r12
movq %r13, %rsi
subq %r12, %rsi
movq %r12, %rdi
movl $0x1, %edx
callq 0x31e0
movq %r13, %r12
incq %r12
movq %r14, %rbp
subq %r12, %rbp
addq %r15, %rbp
movq %r12, %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x2200
movq %rax, %r13
testq %rax, %rax
jne 0x3147
jmp 0x3186
movq %r14, %r12
movq %r15, %rbp
testq %rbp, %rbp
je 0x3198
movq %r12, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x31e0
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
movq %r14, %rdi
movq %rbx, %rcx
callq 0x20e0
movq %rax, %r15
testq %rax, %rax
jne 0x312f
movq %rbx, %rdi
callq 0x2120
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x31e0
xorl %eax, %eax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hcmiya[P]opuscomment/src/parse-tags.c
// Function: line_nul
static void line_nul(uint8_t *line, size_t n, bool term) {
	if (!line) {
		if (!first_call) {
			if (!keep_blank) {
				if (on_field) err_nosep();
				finalize_record();
			}
			first_call = true;
		}
		return;
	}
	
	if(test_blank(line, n, term)) return;
	
	if (on_field) {
		if(!test_tag_field(line, n, true, &on_field, NULL)) err_name();
		if (on_field && term) err_nosep();
		test_mbp(&line, &n);
	}
	else {
		append_buffer(line, n);
	}
	
	if (term) finalize_record();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
testq %rdi, %rdi
je 0x3255
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movzbl %bl, %edx
callq 0x3871
testb %al, %al
jne 0x329b
cmpb $0x1, 0x935d(%rip)      # 0xc573
jne 0x327e
leaq 0x9354(%rip), %rcx      # 0xc573
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
xorl %r8d, %r8d
callq 0x5988
testb %al, %al
je 0x32c2
movb 0x9333(%rip), %al       # 0xc573
andb %bl, %al
cmpb $0x1, %al
je 0x32a5
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x3ac4
jmp 0x3289
cmpb $0x1, 0x9315(%rip)      # 0xc571
jne 0x329b
cmpb $0x0, 0x930d(%rip)      # 0xc572
jne 0x3275
cmpb $0x1, 0x9305(%rip)      # 0xc573
je 0x32a5
callq 0x378f
movb $0x0, 0x92f5(%rip)      # 0xc571
jmp 0x329b
movq %r15, %rdi
movq %r14, %rsi
callq 0x3c4b
testb %bl, %bl
je 0x329b
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x378f
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x193d4(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x4db8(%rip), %rcx      # 0x806e
movl $0x5, %esi
movl $0x1, %edx
jmp 0x32dd
leaq 0x193b7(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x4dd7(%rip), %rcx      # 0x80aa
movl $0x5, %esi
movl $0x2, %edx
callq 0x2440
movq %rax, %rdi
callq 0x3e34
// File: /workspace/github_c_makefile_star2_O1/hcmiya[P]opuscomment/src/parse-tags.c
// Function: parse_opt_tag
void parse_opt_tag(int opt, char const *arg) {
	char *ls = (char*)arg;
	size_t l = strlen(ls);
	
	if (optcd == (iconv_t)-1) {
		optcd = iconv_new("UTF-8", nl_langinfo(CODESET));
	}
	void (*addbuf)(uint8_t *, size_t, bool);
	switch (opt) {
	case 't':
		prepare_record();
		addbuf = line_nul;
		break;
	case 'd':
		addbuf = rt_del_args;
		break;
	}
	char u8buf[STACK_BUF_LEN];
	size_t u8left;
	char *u8;
	while (l) {
		u8left = STACK_BUF_LEN;
		u8 = u8buf;
		size_t ret = iconv(optcd, &ls, &l, &u8, &u8left);
		
		if (ret == (size_t)-1) {
			// 引数処理なのでEINVAL時のバッファ持ち越しは考慮しない
			if (errno != E2BIG) {
				oserror();
			}
		}
		addbuf(u8buf, u8 - u8buf, false);
	}
	u8 = u8buf;
	u8left = STACK_BUF_LEN;
	if (iconv(optcd, NULL, NULL, &u8, &u8left) == (size_t)-1) {
		oserror();
	}
	addbuf(u8buf, u8 - u8buf, true);
	addbuf(NULL, 0, false);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1028, %rsp           # imm = 0x1028
movl %edi, %ebx
movq %rsi, 0x18(%rsp)
movq %rsi, %rdi
callq 0x2130
movq %rax, 0x8(%rsp)
cmpq $-0x1, 0x8c0d(%rip)     # 0xc288
jne 0x369d
movl $0xe, %edi
callq 0x22f0
leaq 0x4976(%rip), %rdi      # 0x8004
movq %rax, %rsi
callq 0x2979
movq %rax, 0x8beb(%rip)      # 0xc288
cmpl $0x74, %ebx
jne 0x36b0
callq 0x2bd4
leaq -0x4ce(%rip), %rbp      # 0x31e0
jmp 0x36b7
leaq 0x30b7(%rip), %rbp      # 0x676e
cmpq $0x0, 0x8(%rsp)
je 0x3726
leaq 0x20(%rsp), %rbx
leaq 0x18(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rsp, %r12
leaq 0x10(%rsp), %r13
movq $0x1000, 0x10(%rsp)     # imm = 0x1000
movq %rbx, (%rsp)
movq 0x8b9e(%rip), %rdi      # 0xc288
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %r13, %r8
callq 0x20b0
cmpq $-0x1, %rax
jne 0x3710
callq 0x2050
cmpl $0x7, (%rax)
je 0x3710
callq 0x6f9b
movq (%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq *%rbp
cmpq $0x0, 0x8(%rsp)
jne 0x36d6
leaq 0x20(%rsp), %rbx
movq %rsp, %rcx
movq %rbx, (%rcx)
leaq 0x10(%rsp), %r8
movq $0x1000, (%r8)          # imm = 0x1000
movq 0x8b44(%rip), %rdi      # 0xc288
xorl %esi, %esi
xorl %edx, %edx
callq 0x20b0
cmpq $-0x1, %rax
jne 0x3758
callq 0x6f9b
movq (%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq *%rbp
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq *%rbp
addq $0x1028, %rsp           # imm = 0x1028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hcmiya[P]opuscomment/src/parse-tags.c
// Function: finalize_record
static void finalize_record(void) {
	if (store_picture) {
		if (b64pos != 0) err_base64();
		long picend = ftell(flacpict);
		uint32_t piclength = picend - picture_top - 4;
		piclength = ntohl(0x06000000 | piclength);
		fseek(flacpict, picture_top, SEEK_SET);
		fwrite(&piclength, 4, 1, flacpict);
		fseek(flacpict, 0, SEEK_END);
		picture_top = picend;
	}
	else {
		fwrite(&recordlen, 4, 1, strcount);
		tagnum++;
	}
	first_call = true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x8dda(%rip)      # 0xc574
jne 0x3816
cmpb $0x0, 0x8dd2(%rip)      # 0xc575
jne 0x3849
movq 0x8da0(%rip), %rdi      # 0xc550
callq 0x2280
movq %rax, %rbx
movq 0x8db9(%rip), %rsi      # 0xc578
subl %esi, %eax
addl $-0x4, %eax
orl $0x6000000, %eax        # imm = 0x6000000
bswapl %eax
leaq 0x4(%rsp), %r14
movl %eax, (%r14)
movq 0x8d76(%rip), %rdi      # 0xc550
xorl %edx, %edx
callq 0x2320
movq 0x8d68(%rip), %rcx      # 0xc550
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rdi
callq 0x2460
movq 0x8d4f(%rip), %rdi      # 0xc550
xorl %esi, %esi
movl $0x2, %edx
callq 0x2320
movq %rbx, 0x8d64(%rip)      # 0xc578
jmp 0x383a
movq 0x8d2b(%rip), %rcx      # 0xc548
leaq 0x8d5c(%rip), %rdi      # 0xc580
movl $0x4, %esi
movl $0x1, %edx
callq 0x2460
incq 0x8d1e(%rip)            # 0xc558
movb $0x0, 0x8d30(%rip)      # 0xc571
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x18e30(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x4827(%rip), %rcx      # 0x8081
movl $0x5, %esi
movl $0x7, %edx
callq 0x2440
movq %rax, %rdi
callq 0x3e34
// File: /workspace/github_c_makefile_star2_O1/hcmiya[P]opuscomment/src/parse-tags.c
// Function: esctab
static int esctab(int c) {
	switch (c) {
	case 0x30: // '0'
		c = '\0';
		break;
	case 0x5c: // '\'
		c = 0x5c;
		break;
	case 0x6e: // 'n'
		c = 0x0a;
		break;
	case 0x72: // 'r'
		c = 0x0d;
		break;
	default:
		err_esc();
		break;
	}
	return c;
}

// Assembly:
cmpl $0x6d, %edi
jg 0x3a85
xorl %eax, %eax
cmpl $0x30, %edi
je 0x3a9a
cmpl $0x5c, %edi
jne 0x3a9b
movl $0x5c, %eax
retq
cmpl $0x6e, %edi
je 0x3a95
cmpl $0x72, %edi
jne 0x3a9b
movl $0xd, %eax
retq
movl $0xa, %eax
retq
pushq %rax
leaq 0x18bdd(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x4594(%rip), %rcx      # 0x8041
movl $0x5, %esi
movl $0x5, %edx
callq 0x2440
movq %rax, %rdi
callq 0x3e34
// File: /workspace/github_c_makefile_star2_O1/hcmiya[P]opuscomment/src/parse-tags.c
// Function: test_mbp
static void test_mbp(uint8_t **line, size_t *n) {
	if (fieldlen > 22) {
		append_buffer(*line, *n);
	}
	else {
		bool filled;
		size_t before = fieldlen;
		filled = count_field_len(*line, *n);
		size_t add = fieldlen - before;
		if (filled) {
			size_t w;
			// M_B_Pを比較する分のバッファが埋まったか項目名が決まった場合
			if (fieldlen > 22) {
				if (add + before > 22) {
					add = 22 - before;
				}
				w = 22;
			}
			else if (fieldlen == 22 && !on_field) {
				if (codec->type == CODEC_FLAC &&
					memcmp(field_pending, MBPeq, 22) == 0) {
					store_picture = true;
					fwrite((uint32_t[]){0}, 4, 1, flacpict);
					editlen -= 4;
					uint8_t *databegin = strchr(*line, 0x3d) + 1;
					append_buffer(databegin, *n - (databegin - *line));
					return;
				}
				else {
					w = 22;
				}
			}
			else {
				w = fieldlen;
			}
			append_buffer(field_pending, w);
			*line += add;
			*n -= add;
			append_buffer(*line, *n);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8ab2(%rip), %r12      # 0xc588
movq (%rdi), %r15
movq (%rsi), %rdx
cmpq $0x17, %r12
jb 0x3aed
movq %r15, %rdi
movq %rdx, %rsi
jmp 0x3bec
movq %rsi, %rbx
movq %rdi, %r14
movb 0x8a79(%rip), %bpl      # 0xc573
cmpb $0x1, %bpl
jne 0x3b05
subq %r12, %rdx
jmp 0x3b18
movq %r15, %rdi
movl $0x3d, %esi
callq 0x2200
movq %rax, %rdx
subq %r15, %rdx
leaq (%rdx,%r12), %r13
leaq 0x8a8d(%rip), %rdi      # 0xc5b0
addq %r12, %rdi
cmpq $0x16, %r13
ja 0x3b4f
movq %r15, %rsi
callq 0x22a0
movq %r13, 0x8a4d(%rip)      # 0xc588
testb %bpl, %bpl
je 0x3b66
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x16, %edx
subq %r12, %rdx
movq %r15, %rsi
callq 0x22a0
movq %r13, 0x8a22(%rip)      # 0xc588
movl $0x16, %esi
cmpq $0x16, %r13
jbe 0x3b79
movl $0x16, %r13d
jmp 0x3bcb
setne %al
orb %bpl, %al
je 0x3b86
movq %r13, %rsi
jmp 0x3bcb
leaq 0x18ae3(%rip), %rax     # 0x1c670
movq (%rax), %rax
cmpl $0x2, (%rax)
jne 0x3bcb
leaq 0x81fc(%rip), %rax      # 0xbd98
movq (%rax), %rax
movdqu 0x8a0f(%rip), %xmm0     # 0xc5b6
movdqu (%rax), %xmm1
movdqu 0x6(%rax), %xmm2
pcmpeqb 0x89f8(%rip), %xmm1     # 0xc5b0
pcmpeqb %xmm0, %xmm2
pand %xmm2, %xmm1
pmovmskb %xmm1, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x3bfc
subq %r12, %r13
leaq 0x89db(%rip), %rdi      # 0xc5b0
callq 0x3c4b
movq (%r14), %rdi
addq %r13, %rdi
movq %rdi, (%r14)
movq (%rbx), %rsi
subq %r13, %rsi
movq %rsi, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3c4b
movb $0x1, 0x8971(%rip)      # 0xc574
leaq 0x4(%rsp), %rdi
movl $0x0, (%rdi)
movq 0x893b(%rip), %rcx      # 0xc550
movl $0x4, %esi
movl $0x1, %edx
callq 0x2460
addq $-0x4, 0x8974(%rip)     # 0xc5a0
movq (%r14), %r14
movq %r14, %rdi
movl $0x3d, %esi
callq 0x2140
addq (%rbx), %r14
leaq 0x1(%rax), %rdi
subq %rdi, %r14
movq %r14, %rsi
jmp 0x3bec
// File: /workspace/github_c_makefile_star2_O1/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, 0x8911(%rip)      # 0xc574
jne 0x3dc3
testq %rbx, %rbx
jle 0x3db4
addq %r14, %rbx
leaq 0x8124(%rip), %rax      # 0xbda0
movq (%rax), %r15
movb $0x1, %bpl
leaq 0x893e(%rip), %r13      # 0xc5c7
leaq 0x5(%rsp), %r12
movzbl (%r14), %esi
movq %r15, %rdi
callq 0x2140
testq %rax, %rax
je 0x3e0c
movb 0x88cc(%rip), %cl       # 0xc575
testb %cl, %cl
sete %dl
andb 0x88e4(%rip), %dl       # 0xc598
cmpb $0x1, %dl
je 0x3e0c
subq %r15, %rax
movsbq %cl, %rdx
movzbl %al, %esi
cmpq $0x40, %rsi
sete %dil
cmpb $0x2, %dl
setl %r8b
andb %dil, %r8b
cmpb $0x1, %r8b
je 0x3e0c
cmpl $0x40, %esi
setne %sil
cmpb $0x2, %cl
setne %dil
orb %sil, %dil
jne 0x3d06
movb %bpl, 0x889b(%rip)      # 0xc598
movb %bpl, 0x88c2(%rip)      # 0xc5c6
xorl %eax, %eax
cmpb $0x3, %cl
jne 0x3d3a
cmpb $0x1, 0x8886(%rip)      # 0xc598
jne 0x3d20
cmpb $0x40, %al
jne 0x3e0c
xorl %eax, %eax
jmp 0x3d3a
movb $0x3, %sil
cmpb $0x40, %al
jne 0x3d33
movb $0x1, 0x886a(%rip)      # 0xc598
movb $0x2, %sil
xorl %eax, %eax
movb %sil, 0x888c(%rip)      # 0xc5c6
incb %cl
movb %cl, 0x8833(%rip)       # 0xc575
movb %al, (%rdx,%r13)
cmpb $0x4, %cl
jne 0x3da8
movb 0x8876(%rip), %al       # 0xc5c7
shlb $0x2, %al
movb 0x886e(%rip), %cl       # 0xc5c8
movl %ecx, %edx
shrb $0x4, %dl
orb %al, %dl
movb %dl, 0x5(%rsp)
shlb $0x4, %cl
movb 0x885b(%rip), %al       # 0xc5c9
movl %eax, %edx
shrb $0x2, %dl
orb %cl, %dl
shlb $0x6, %al
orb 0x884c(%rip), %al       # 0xc5ca
movb %dl, 0x6(%rsp)
movb %al, 0x7(%rsp)
movzbl 0x8839(%rip), %edx      # 0xc5c6
movq 0x87bc(%rip), %rcx      # 0xc550
movl $0x1, %esi
movq %r12, %rdi
callq 0x2460
movb $0x0, 0x87cd(%rip)      # 0xc575
incq %r14
cmpq %rbx, %r14
jb 0x3c8e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x87d6(%rip), %rax      # 0xc5a0
addq %rbx, %rax
movq %rax, 0x87cc(%rip)      # 0xc5a0
cmpq $0x2800001, %rax        # imm = 0x2800001
jb 0x3de1
callq 0x71aa
addl %ebx, 0x8799(%rip)      # 0xc580
movq 0x8752(%rip), %rcx      # 0xc540
movl $0x1, %esi
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2460
leaq 0x1886d(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x4264(%rip), %rcx      # 0x8081
movl $0x5, %esi
movl $0x7, %edx
callq 0x2440
movq %rax, %rdi
callq 0x3e34
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
callq 0x24f0
movq 0x81b0(%rip), %r15      # 0xbff8
movq (%r15), %r14
leaq 0x1882e(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x41fd(%rip), %rcx      # 0x8059
movl $0x1, %esi
movl $0x6, %edx
callq 0x2440
movq 0x86e6(%rip), %rdx      # 0xc558
incq %rdx
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x2260
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x2180
movq (%r15), %rsi
movl $0xa, %edi
callq 0x21f0
movl $0x1, %edi
callq 0x2450
// File: /workspace/github_c_makefile_star2_O1/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 0x1880d(%rip), %rax     # 0x1c6e0
movq (%rax), %rdi
callq 0x2120
cmpl $-0x1, %eax
jne 0x3efc
leaq 0x187a1(%rip), %rax     # 0x1c688
movq 0x30(%rax), %rdi
testq %rdi, %rdi
jne 0x3ef7
movq 0x86d9(%rip), %rdi      # 0xc5d0
callq 0x7069
leaq 0x18785(%rip), %rbx     # 0x1c688
cmpq $0x0, 0x30(%rbx)
jne 0x3f60
leaq 0x187b7(%rip), %rax     # 0x1c6c8
cmpb $0x1, (%rax)
jne 0x3f60
leaq 0x187a3(%rip), %rax     # 0x1c6c0
movq (%rax), %rdi
callq 0x22d0
movq %rsp, %rsi
movl %eax, %edi
callq 0x24b0
movq 0x869a(%rip), %rdi      # 0xc5d0
movq 0x28(%rbx), %rsi
callq 0x23e0
testl %eax, %eax
jne 0x3f5b
movb $0x0, 0x868e(%rip)      # 0xc5d8
movq 0x28(%rbx), %rdi
movl 0x18(%rsp), %esi
callq 0x2380
testl %eax, %eax
je 0x3f60
callq 0x6f9b
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rdi, %rbx
leaq 0x18235(%rip), %r15     # 0x1c6c0
movq (%r15), %rdi
callq 0x2290
movq (%r15), %rdi
movq 0x815b(%rip), %rsi      # 0xc5f8
subq %rbx, %rsi
xorl %edx, %edx
callq 0x2320
testl %eax, %eax
je 0x44b0
callq 0x6f9b
movq (%r15), %rcx
movq %rsp, %rdi
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x20e0
testq %rax, %rax
je 0x4512
movq %rax, %r14
leaq 0x1820c(%rip), %r12     # 0x1c6e0
movq %rsp, %rbx
movq (%r12), %rcx
movl $0x1, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2460
cmpq %r14, %rax
je 0x44f5
callq 0x6f9b
movq (%r15), %rcx
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
movq %rbx, %rdi
callq 0x20e0
movq %rax, %r14
testq %rax, %rax
jne 0x44d7
movq (%r15), %rdi
callq 0x20c0
testl %eax, %eax
je 0x4523
callq 0x6f9b
callq 0x3ec4
xorl %edi, %edi
callq 0x2450
// File: /workspace/github_c_makefile_star2_O1/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 0x17bba(%rip), %r14     # 0x1c6d8
addl (%r14), %eax
movq %rbx, %rdi
movl %eax, %esi
callq 0x5b93
movq %rbx, %rdi
callq 0x2110
leaq 0x17ba6(%rip), %rax     # 0x1c6e0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x5b3b
movq %rbx, %rdi
callq 0x24a0
testl %eax, %eax
je 0x4b64
leaq 0x17b70(%rip), %rax     # 0x1c6c8
cmpb $0x1, (%rax)
je 0x4b6e
movl $0x0, (%r14)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %edi, %edi
callq 0x4473
// File: /workspace/github_c_makefile_star2_O1/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 0x4b9d
movl $0x5, %edi
xorl %eax, %eax
callq 0x6e10
jmp 0x4bb5
leaq 0x17b2c(%rip), %rax     # 0x1c6d0
cmpl $0x2, (%rax)
jb 0x4bb5
movq %rbx, %rdi
callq 0x2470
testl %eax, %eax
je 0x4b8f
leaq 0x17b14(%rip), %rax     # 0x1c6d0
incl (%rax)
movq (%rbx), %rax
movb 0x1a(%rax), %r12b
testb %r12b, %r12b
je 0x4ce6
movq 0x10(%rbx), %r14
cmpb $0x1, %r12b
jne 0x4be6
movl $0x1b, %r13d
movb $0x1, %r15b
jmp 0x4c89
movq (%rbx), %rax
cmpb $-0x1, 0x1b(%rax)
je 0x4bf6
xorl %eax, %eax
jmp 0x4c7e
leal -0x1(%r12), %eax
movl %eax, 0x14(%rsp)
leal -0x2(%r12), %eax
movzbl %al, %r13d
xorl %ebp, %ebp
movq %r14, %r15
cmpl $0x7800001, 0x7a09(%rip) # imm = 0x7800001
jb 0x4c2a
movl $0x9, %edi
movl $0x78, %esi
xorl %eax, %eax
callq 0x6e10
movl 0x79e0(%rip), %edi      # 0xc610
movl $0xff, %edx
movq %r15, %rsi
callq 0x2100
addl $0xff, 0x79d9(%rip)     # 0xc620
cmpq %rbp, %r13
je 0x4c70
leaq 0xff(%r15), %r14
leaq 0x1(%rbp), %rax
movq (%rbx), %rcx
cmpb $-0x1, 0x1c(%rcx,%rbp)
movq %rax, %rbp
je 0x4c0a
addq $0xff, %r15
movq %r15, %r14
jmp 0x4c7e
addq $0xff, %r15
movq %r15, %r14
movl 0x14(%rsp), %eax
movzbl %al, %r15d
leaq 0x1b(%r15), %r13
incb %r15b
movq (%rbx), %rax
movzbl (%rax,%r13), %eax
addl 0x7989(%rip), %eax      # 0xc620
movl %eax, 0x7983(%rip)      # 0xc620
cmpl $0x7800001, %eax        # imm = 0x7800001
jb 0x4cb5
movl $0x9, %edi
movl $0x78, %esi
xorl %eax, %eax
callq 0x6e10
movl 0x7955(%rip), %edi      # 0xc610
movq (%rbx), %rax
movzbl (%rax,%r13), %edx
movq %r14, %rsi
callq 0x2100
cmpb %r12b, %r15b
setne %bpl
jne 0x4ce2
movzbl %r15b, %eax
movq (%rbx), %rcx
cmpb $-0x1, 0x1a(%rcx,%rax)
je 0x4ce6
movb $0x1, %al
jmp 0x4ce8
xorl %eax, %eax
testb %al, %al
je 0x4d64
movl 0x791e(%rip), %edi      # 0xc610
callq 0x21c0
movq 0x791a(%rip), %rdi      # 0xc618
leaq 0x8(%rsp), %rsi
callq 0x2490
leaq 0x17979(%rip), %r14     # 0x1c688
cmpl $0x1, (%r14)
je 0x4d27
leaq 0x179dc(%rip), %rax     # 0x1c6f8
movq (%rax), %rdi
movq %rsp, %rsi
callq 0x2490
cmpl $0x3, (%r14)
jne 0x4d39
movq 0x8(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x4d75
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
movzbl %bpl, %ecx
andl $0x1, %ecx
movq %rbx, %rdi
callq 0x3f69
movq 0x8(%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
movq (%rsp), %rcx
cmpq $0x0, 0x18(%rcx)
jne 0x4d39
cmpq $0x0, 0x30(%r14)
jne 0x4d39
cmpb $0x0, 0x4(%r14)
jne 0x4d39
cmpb $0x0, 0x28(%rax)
jne 0x4d39
xorl %edi, %edi
callq 0x2450
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %rsi
callq 0x2360
testl %eax, %eax
je 0x4ea2
leaq 0x1790b(%rip), %r15     # 0x1c6cc
movq %rsp, %r14
leaq 0x17915(%rip), %r12     # 0x1c6e0
testl %eax, %eax
jle 0x4e13
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rax, 0x781d(%rip)      # 0xc5f8
cmpl $0x0, (%r15)
je 0x4e1e
movq %r14, %rdi
callq 0x5a26
movl %eax, %ebp
testb %al, %al
je 0x4e28
movl (%r15), %eax
cmpl $0x4, %eax
je 0x4e98
cmpl $0x2, %eax
je 0x4e8e
cmpl $0x1, %eax
jne 0x4e28
movq %r14, %rdi
callq 0x4978
jmp 0x4e28
negl %eax
addq %rax, 0x77dc(%rip)      # 0xc5f8
jmp 0x4e79
movq %r14, %rdi
callq 0x47ac
movl %eax, %ebp
testb %bpl, %bpl
je 0x4e4b
cmpl $0x3, (%r15)
ja 0x4e4b
movq %r14, %rdi
callq 0x24a0
testl %eax, %eax
je 0x4e4b
movl $0x5, %edi
xorl %eax, %eax
callq 0x6e10
testb %bpl, %bpl
jne 0x4e79
movq %r14, %rdi
callq 0x2080
movq 0x7781(%rip), %rsi      # 0xc5e0
testq %rsi, %rsi
movq (%r12), %rcx
cmoveq %rcx, %rsi
testq %rax, %rax
cmoveq %rcx, %rsi
movq %r14, %rdi
callq 0x5b3b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2360
testl %eax, %eax
jne 0x4dcb
jmp 0x4ea2
movq %r14, %rdi
callq 0x4b75
jmp 0x4e28
movq %r14, %rdi
callq 0x4b0b
jmp 0x4e28
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq 0x771e(%rip), %rdi      # 0xc5e0
callq 0x2150
movq 0x7712(%rip), %rcx      # 0xc5e0
movq %rsp, %rdi
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x20e0
testq %rax, %rax
je 0x4f30
movq %rax, %r14
leaq 0x177f1(%rip), %r15     # 0x1c6e0
movq %rsp, %rbx
movq (%r15), %rcx
movl $0x1, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2460
cmpq %r14, %rax
je 0x4f0f
callq 0x6f9b
movq 0x76ca(%rip), %rcx      # 0xc5e0
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
movq %rbx, %rdi
callq 0x20e0
movq %rax, %r14
testq %rax, %rax
jne 0x4ef2
movq 0x76a9(%rip), %rdi      # 0xc5e0
callq 0x2120
movq $0x0, 0x7699(%rip) # 0xc5e0
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1775b(%rip), %rax     # 0x1c6c0
movq (%rax), %rcx
leaq 0x76c1(%rip), %rdi      # 0xc630
movl $0x1, %esi
movl $0x4, %edx
callq 0x20e0
cmpq $0x4, %rax
je 0x4f9b
cmpq $-0x1, %rax
jne 0x4f8f
callq 0x6f9b
movl $0xf, %edi
xorl %eax, %eax
callq 0x6e10
movb 0x768f(%rip), %al       # 0xc630
movl %eax, %ecx
andb $0x7f, %cl
movb %cl, (%rbx)
movb $0x0, 0x7681(%rip)      # 0xc630
movl 0x767b(%rip), %ecx      # 0xc630
bswapl %ecx
movq %rcx, (%r14)
movb (%rbx), %cl
movb %cl, 0x766e(%rip)       # 0xc630
shrb $0x7, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x50a2
movq %rdi, %r14
xorl %edi, %edi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x3f69
movq (%r14), %rdi
callq 0x2280
bswapl %eax
movl %eax, 0x762c(%rip)      # 0xc630
leaq 0x7625(%rip), %rdi      # 0xc630
movb $0x4, 0x761e(%rip)      # 0xc630
leaq 0x176c7(%rip), %r13     # 0x1c6e0
movq (%r13), %rcx
movl $0x1, %esi
movl $0x4, %edx
callq 0x2460
cmpq $0x4, %rax
je 0x5037
callq 0x6f9b
movq (%r14), %rdi
callq 0x2150
movq (%r14), %rcx
leaq 0x75e7(%rip), %rdi      # 0xc630
movl $0x1, %esi
movl $0x10000, %edx          # imm = 0x10000
callq 0x20e0
testq %rax, %rax
je 0x50a2
movq %rax, %r12
leaq 0x75c9(%rip), %r15      # 0xc630
movq (%r13), %rcx
movl $0x1, %esi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2460
cmpq %r12, %rax
je 0x5085
callq 0x6f9b
movq (%r14), %rcx
movl $0x1, %esi
movl $0x10000, %edx          # imm = 0x10000
movq %r15, %rdi
callq 0x20e0
movq %rax, %r12
testq %rax, %rax
jne 0x5067
movq 0x10(%rbx), %rdi
callq 0x2150
movq 0x10(%rbx), %rcx
leaq 0x757a(%rip), %rdi      # 0xc630
movl $0x1, %esi
movl $0x10000, %edx          # imm = 0x10000
callq 0x20e0
testq %rax, %rax
je 0x5117
movq %rax, %r15
leaq 0x1760c(%rip), %r12     # 0x1c6e0
leaq 0x7555(%rip), %r14      # 0xc630
movq (%r12), %rcx
movl $0x1, %esi
movq %r14, %rdi
movq %r15, %rdx
callq 0x2460
cmpq %r15, %rax
je 0x50f9
callq 0x6f9b
movq 0x10(%rbx), %rcx
movl $0x1, %esi
movl $0x10000, %edx          # imm = 0x10000
movq %r14, %rdi
callq 0x20e0
movq %rax, %r15
testq %rax, %rax
jne 0x50db
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0xe, %edi
callq 0x22f0
leaq 0x2849(%rip), %rsi      # 0x80f5
movq %rax, %rdi
callq 0x24d0
movq %rax, %r14
leaq 0x20(%rsp), %r15
movl $0x1, %esi
movl $0x40, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x20e0
testq %rax, %rax
je 0x5961
leaq 0x10(%rsp), %r12
leaq 0x16e02(%rip), %rbp     # 0x1c6e8
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 %rsp, %rcx
movq %r12, %r8
callq 0x20b0
movq 0x8(%rsp), %rdi
movq (%rsp), %r13
subq %rdi, %r13
movq (%rbp), %rcx
movl $0x1, %esi
movq %r13, %rdx
callq 0x2460
cmpq %r13, %rax
je 0x5947
callq 0x6f9b
movl $0x1, %esi
movl $0x40, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x20e0
testq %rax, %rax
jne 0x58e6
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
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x59d1
testq %rsi, %rsi
je 0x59ff
movb $0x1, %al
xorl %edx, %edx
xorl %r9d, %r9d
movb (%rdi,%r9), %r10b
cmpb $0x3d, %r10b
je 0x5a03
leal -0x20(%r10), %r11d
cmpb $0x5e, %r11b
movzbl %al, %eax
cmovael %edx, %eax
addb $-0x61, %r10b
cmpb $0x19, %r10b
ja 0x59c7
movb %r11b, (%rdi,%r9)
testq %r8, %r8
je 0x59c7
movb $0x1, (%r8)
incq %r9
cmpq %r9, %rsi
jne 0x5998
jmp 0x5a06
testq %rsi, %rsi
je 0x59ff
movb $0x1, %al
xorl %edx, %edx
xorl %r8d, %r8d
movb (%rdi,%r8), %r9b
cmpb $0x3d, %r9b
je 0x5a03
addb $-0x20, %r9b
cmpb $0x5e, %r9b
movzbl %al, %eax
cmovael %edx, %eax
incq %r8
cmpq %r8, %rsi
jne 0x59dd
jmp 0x5a06
movb $0x1, %al
jmp 0x5a06
movb $0x0, (%rcx)
andb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x16c96(%rip), %rax     # 0x1c6d4
movl (%rax), %ebp
movq %r14, %rdi
cmpl %ebp, %ebx
jne 0x5aa6
callq 0x2040
testl %eax, %eax
je 0x5a5c
movl $0x5, %edi
xorl %eax, %eax
callq 0x6e10
leaq 0x16c69(%rip), %rax     # 0x1c6cc
cmpl $0x4, (%rax)
je 0x5b2b
movq %r14, %rdi
callq 0x2080
leaq 0x16c55(%rip), %r15     # 0x1c6d0
movl (%r15), %ecx
cmpq %rcx, %rax
je 0x5b2b
movq %r14, %rdi
callq 0x2080
movl (%r15), %edx
movl $0xa, %edi
movq %rax, %rsi
xorl %eax, %eax
callq 0x6e10
jmp 0x5b2b
callq 0x2080
movq %rax, %r15
leaq 0x16c27(%rip), %rax     # 0x1c6dc
cmpl $0x1, %r15d
je 0x5af8
testl %r15d, %r15d
jne 0x5afd
cmpb $0x1, (%rax)
jne 0x5ad1
movl $0x5, %edi
xorl %eax, %eax
callq 0x6e10
movq %r14, %rdi
callq 0x2040
testl %eax, %eax
je 0x5b02
movq %r14, %rdi
callq 0x24a0
testl %eax, %eax
jne 0x5b02
movq %r14, %rdi
callq 0x22b0
testq %rax, %rax
jne 0x5b02
jmp 0x5b0e
movb $0x1, (%rax)
jmp 0x5b0e
cmpb $0x0, (%rax)
jne 0x5b0e
movl $0x5, %edi
xorl %eax, %eax
callq 0x6e10
testl %r15d, %r15d
je 0x5b2b
movq %r14, %rdi
callq 0x2040
testl %eax, %eax
je 0x5b2b
movl $0x5, %edi
xorl %eax, %eax
callq 0x6e10
cmpl %ebp, %ebx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5b64
callq 0x6f9b
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rdx
movl $0x1, %esi
movq %r14, %rcx
callq 0x2460
cmpq 0x18(%rbx), %rax
jne 0x5b87
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6f9b