LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__out_gif_code(stbi__gif*, unsigned short)
static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)
{
   stbi_uc *p, *c;

   // recurse to decode the prefixes, since the linked-list is backwards,
   // and working backwards through an interleaved image would be nasty
   if (g->codes[code].prefix >= 0)
      stbi__out_gif_code(g, g->codes[code].prefix);

   if (g->cur_y >= g->max_y) return;

   p = &g->out[g->cur_x + g->cur_y];
   c = &g->color_table[g->codes[code].suffix * 4];

   if (c[3] >= 128) {
      p[0] = c[2];
      p[1] = c[1];
      p[2] = c[0];
      p[3] = c[3];
   }
   g->cur_x += 4;

   if (g->cur_x >= g->max_x) {
      g->cur_x = g->start_x;
      g->cur_y += g->step;

      while (g->cur_y >= g->max_y && g->parse > 0) {
         g->step = (1 << g->parse) * g->line_size;
         g->cur_y = g->start_y + (g->step >> 1);
         --g->parse;
      }
   }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %r14d
movzwl 0x824(%rdi,%r14,4), %eax
testw %ax, %ax
js 0x1dd57
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x1dd34
movslq 0x4850(%rbx), %rcx
cmpl 0x4848(%rbx), %ecx
jge 0x1de1e
movq 0x4828(%rbx), %rax
movzbl 0x827(%rbx,%r14,4), %edx
cmpb $0x0, 0x3(%rax,%rdx,4)
jns 0x1ddad
movq 0x8(%rbx), %rsi
movslq 0x484c(%rbx), %rdi
addq %rcx, %rdi
movb 0x2(%rax,%rdx,4), %cl
movb %cl, (%rsi,%rdi)
movb 0x1(%rax,%rdx,4), %cl
movb %cl, 0x1(%rsi,%rdi)
movb (%rax,%rdx,4), %cl
movb %cl, 0x2(%rsi,%rdi)
movb 0x3(%rax,%rdx,4), %al
movb %al, 0x3(%rsi,%rdi)
movl 0x484c(%rbx), %eax
addl $0x4, %eax
movl %eax, 0x484c(%rbx)
cmpl 0x4844(%rbx), %eax
jl 0x1de1e
movl 0x483c(%rbx), %ecx
movl 0x4848(%rbx), %eax
movl %ecx, 0x484c(%rbx)
movl 0x4850(%rbx), %ecx
addl 0x4834(%rbx), %ecx
movl %ecx, 0x4850(%rbx)
cmpl %eax, %ecx
jl 0x1de1e
movl 0x4830(%rbx), %ecx
testl %ecx, %ecx
jle 0x1de1e
movl 0x4854(%rbx), %edx
shll %cl, %edx
movl %edx, 0x4834(%rbx)
sarl %edx
addl 0x4840(%rbx), %edx
movl %edx, 0x4850(%rbx)
decl %ecx
movl %ecx, 0x4830(%rbx)
cmpl %eax, %edx
jge 0x1ddf2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__fill_bits(stbi__zbuf*)
static void stbi__fill_bits(stbi__zbuf *z)
{
   do {
      STBI_ASSERT(z->code_buffer < (1U << z->num_bits));
      z->code_buffer |= stbi__zget8(z) << z->num_bits;
      z->num_bits += 8;
   } while (z->num_bits <= 24);
}

// Assembly:
pushq %rax
movl 0x10(%rdi), %ecx
movl 0x14(%rdi), %eax
movl %eax, %edx
shrl %cl, %edx
testl %edx, %edx
jne 0x1ec21
movq (%rdi), %rsi
xorl %edx, %edx
cmpq 0x8(%rdi), %rsi
jae 0x1ec0b
leaq 0x1(%rsi), %rdx
movq %rdx, (%rdi)
movzbl (%rsi), %edx
shll %cl, %edx
orl %edx, %eax
movl %eax, 0x14(%rdi)
leal 0x8(%rcx), %edx
movl %edx, 0x10(%rdi)
cmpl $0x11, %ecx
movl %edx, %ecx
jl 0x1ebee
popq %rax
retq
leaq 0x2a47(%rip), %rdi      # 0x2166f
leaq 0x2438(%rip), %rsi      # 0x21067
leaq 0x2a5e(%rip), %rcx      # 0x21694
movl $0xdd8, %edx            # imm = 0xDD8
callq 0x8200
// File: /workspace/github_c_makefile_star2_O3/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__zexpand(stbi__zbuf*, char*, int)
static int stbi__zexpand(stbi__zbuf *z, char *zout, int n)  // need to make room for n bytes
{
   char *q;
   int cur, limit;
   z->zout = zout;
   if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG");
   cur   = (int) (z->zout     - z->zout_start);
   limit = (int) (z->zout_end - z->zout_start);
   while (cur + n > limit)
      limit *= 2;
   q = (char *) STBI_REALLOC(z->zout_start, limit);
   if (q == NULL) return stbi__err("outofmem", "Out of memory");
   z->zout_start = q;
   z->zout       = q + cur;
   z->zout_end   = q + limit;
   return 1;
}

// Assembly:
movq %rsi, 0x18(%rdi)
cmpl $0x0, 0x30(%rdi)
je 0x1ec99
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
subq %rdi, %r14
movl 0x28(%rbx), %eax
subl %edi, %eax
addl %r14d, %edx
movl %eax, %ecx
leal (%rcx,%rcx), %eax
cmpl %ecx, %edx
jg 0x1ec64
movslq %ecx, %r15
movq %r15, %rsi
callq 0x8580
testq %rax, %rax
je 0x1ecaa
movq %rax, 0x20(%rbx)
movslq %r14d, %rcx
addq %rax, %rcx
movq %rcx, 0x18(%rbx)
addq %rax, %r15
movq %r15, 0x28(%rbx)
movl $0x1, %eax
jmp 0x1ecba
leaq 0x2a77(%rip), %rax      # 0x21717
movq %rax, 0x8741(%rip)      # 0x273e8
xorl %eax, %eax
retq
leaq 0x22e6(%rip), %rax      # 0x20f97
movq %rax, 0x8730(%rip)      # 0x273e8
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__psd_info(stbi__context*, int*, int*, int*)
static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp)
{
   int channelCount;
   if (stbi__get32be(s) != 0x38425053) {
       stbi__rewind( s );
       return 0;
   }
   if (stbi__get16be(s) != 1) {
       stbi__rewind( s );
       return 0;
   }
   stbi__skip(s, 6);
   channelCount = stbi__get16be(s);
   if (channelCount < 0 || channelCount > 16) {
       stbi__rewind( s );
       return 0;
   }
   *y = stbi__get32be(s);
   *x = stbi__get32be(s);
   if (stbi__get16be(s) != 8) {
       stbi__rewind( s );
       return 0;
   }
   if (stbi__get16be(s) != 3) {
       stbi__rewind( s );
       return 0;
   }
   *comp = 4;
   return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
callq 0x1a2af
movl %eax, %ebp
shll $0x10, %ebp
movq %rbx, %rdi
callq 0x1a2af
orl %ebp, %eax
cmpl $0x38425053, %eax       # imm = 0x38425053
jne 0x1edb5
movq %rbx, %rdi
callq 0x1a2af
cmpl $0x1, %eax
jne 0x1edb5
cmpq $0x0, 0x10(%rbx)
je 0x1ed39
movq 0xb8(%rbx), %rax
movq 0xc0(%rbx), %rdx
movl %edx, %ecx
subl %eax, %ecx
cmpl $0x5, %ecx
jg 0x1ed40
movq %rdx, 0xb8(%rbx)
movq 0x28(%rbx), %rdi
movl $0x6, %esi
subl %ecx, %esi
callq *0x18(%rbx)
jmp 0x1ed4b
movq 0xb8(%rbx), %rax
addq $0x6, %rax
movq %rax, 0xb8(%rbx)
movq %rbx, %rdi
callq 0x1a2af
cmpl $0x11, %eax
jae 0x1edb5
movq %rbx, %rdi
callq 0x1a2af
movl %eax, %ebp
shll $0x10, %ebp
movq %rbx, %rdi
callq 0x1a2af
orl %ebp, %eax
movl %eax, (%r12)
movq %rbx, %rdi
callq 0x1a2af
movl %eax, %ebp
shll $0x10, %ebp
movq %rbx, %rdi
callq 0x1a2af
orl %ebp, %eax
movl %eax, (%r15)
movq %rbx, %rdi
callq 0x1a2af
cmpl $0x8, %eax
jne 0x1edb5
movq %rbx, %rdi
callq 0x1a2af
cmpl $0x3, %eax
jne 0x1edb5
movl $0x4, (%r14)
movl $0x1, %eax
jmp 0x1edc5
movq 0xc8(%rbx), %rax
movq %rax, 0xb8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1e3a0
movabsq $0x4e41494441523f23, %rax # imm = 0x4E41494441523F23
xorq (%r13), %rax
movabsq $0x45434e41494441, %rcx # imm = 0x45434E41494441
xorq 0x3(%r13), %rcx
orq %rax, %rcx
je 0x1f19c
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 0x1e3a0
cmpb $0x0, (%r13)
je 0x1f17a
movq %r14, (%rsp)
movq %rbx, %r14
xorl %ebp, %ebp
movl $0x1, %ebx
leaq 0x10(%rsp), %r13
movdqu 0x17(%rsp), %xmm0
pcmpeqb 0x17dc(%rip), %xmm0     # 0x209b0
movdqa 0x10(%rsp), %xmm1
pcmpeqb 0x17de(%rip), %xmm1     # 0x209c0
pand %xmm0, %xmm1
pmovmskb %xmm1, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
cmovel %ebx, %ebp
movq %r15, %rdi
movq %r13, %rsi
callq 0x1e3a0
cmpb $0x0, 0x10(%rsp)
jne 0x1f1c6
testl %ebp, %ebp
movq %r14, %rbx
movq (%rsp), %r14
je 0x1f17a
leaq 0x10(%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x1e3a0
movl $0x592d, %eax           # imm = 0x592D
xorl (%r13), %eax
movzbl 0x2(%r13), %ecx
xorl $0x20, %ecx
orw %ax, %cx
jne 0x1f17a
leaq 0x13(%rsp), %rdi
leaq 0x8(%rsp), %r13
movq %rdi, (%r13)
movq %r13, %rsi
movl $0xa, %edx
callq 0x8460
movl %eax, (%r12)
movq (%r13), %rdi
addq $0x2, %rdi
movzbl -0x2(%rdi), %eax
incq %rdi
cmpl $0x20, %eax
je 0x1f264
cmpl $0x2b, %eax
jne 0x1f17a
cmpb $0x58, -0x2(%rdi)
jne 0x1f17a
cmpb $0x20, -0x1(%rdi)
jne 0x1f17a
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0xa, %edx
callq 0x8460
movl %eax, (%r14)
movl $0x3, (%rbx)
movl $0x1, %eax
jmp 0x1f18a
// File: /workspace/github_c_makefile_star2_O3/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 0x2a0e
callq 0x2050
cmpl $0x16, (%rax)
jne 0x2a09
leaq 0x19ca2(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x562d(%rip), %rcx      # 0x8015
movl $0x4, %esi
movl $0x3, %edx
callq 0x2440
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x6f71
jmp 0x2a0e
callq 0x6f57
movq %r15, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r12d           # imm = 0xFFF
subq %rdx, %r12
leaq 0x20(%rsp), %rbx
movq %r13, (%rsp)
movq %r12, 0x20(%rsp)
movq %r14, %rdi
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rsp, %rcx
movq %rbx, %r8
callq 0x20b0
movq %rax, %r15
callq 0x2050
movl (%rax), %ebp
movl $0x0, (%rax)
cmpq $-0x1, %r15
sete %al
cmpl $0x54, %ebp
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2aba
movl 0x97d2(%rip), %esi      # 0xc280
movl $0x8, %edi
xorl %eax, %eax
callq 0x6dcc
movq (%rsp), %rax
movb $0x0, (%rax)
movq %r13, %rdi
callq 0x2130
movq %r13, %rdi
movq %rax, %rsi
callq 0x26c0
cmpq $-0x1, %r15
jne 0x2adf
cmpl $0x16, %ebp
jne 0x2a63
movq 0x10(%rsp), %rbx
testq %rbx, %rbx
je 0x2afb
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
movq %rbx, %rdx
callq 0x22a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2b50
addq %rdi, %rdx
leaq 0x19b69(%rip), %rcx     # 0x1c688
movb (%rdi), %sil
movb %sil, (%rax)
cmpb $0xa, %sil
jne 0x2b45
cmpb $0x0, 0x14(%rcx)
movl $0x7e, %esi
jne 0x2b3b
movl $0x9, %esi
movb %sil, 0x1(%rax)
addq $0x2, %rax
jmp 0x2b48
incq %rax
incq %rdi
cmpq %rdx, %rdi
jb 0x2b1f
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2ba6
addq %rdi, %rdx
movb (%rdi), %cl
movzbl %cl, %esi
cmpl $0xc, %esi
jg 0x2b76
testl %esi, %esi
je 0x2b8e
cmpl $0xa, %esi
jne 0x2b87
movw $0x6e5c, (%rax)         # imm = 0x6E5C
jmp 0x2b9a
cmpl $0xd, %esi
je 0x2b95
cmpl $0x5c, %esi
jne 0x2b87
movw $0x5c5c, (%rax)         # imm = 0x5C5C
jmp 0x2b9a
movb %cl, (%rax)
incq %rax
jmp 0x2b9e
movw $0x305c, (%rax)         # imm = 0x305C
jmp 0x2b9a
movw $0x725c, (%rax)         # imm = 0x725C
addq $0x2, %rax
incq %rdi
cmpq %rdx, %rdi
jb 0x2b5c
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2bcc
leaq 0x19a3e(%rip), %rax     # 0x1c688
cmpl $0x0, 0x10(%rax)
leaq 0x33a(%rip), %rax       # 0x2f8f
leaq 0x114(%rip), %rbp       # 0x2d70
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 0x2d24
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x2200
testq %rax, %rax
jne 0x2d48
movq %r14, %rdi
movl $0xa, %esi
movq %r15, %rdx
callq 0x2200
testq %rax, %rax
je 0x2cf3
movq %r14, %rcx
movq %r14, %r12
movq %r12, %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
testq %rax, %rax
jne 0x2cb5
testq %r13, %r13
jne 0x2cf9
jmp 0x2d03
movq %r15, %r13
movq %r14, %r12
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 0x2c84
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 0x19931(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x5362(%rip), %rcx      # 0x80bb
movl $0x5, %esi
movl $0x4, %edx
callq 0x2440
movq %rax, %rdi
callq 0x3e30
// File: /workspace/github_c_makefile_star2_O3/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 0x2fd4
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x1, 0x9616(%rip)      # 0xc5cb
jne 0x302e
movzbl (%r15), %eax
cmpl $0x7e, %eax
je 0x2fc5
cmpl $0x9, %eax
jne 0x3029
movb $0xa, (%r15)
movzbl %bl, %eax
subq %rax, %r14
jmp 0x308d
cmpb $0x1, 0x9596(%rip)      # 0xc571
jne 0x309e
leaq 0x196a0(%rip), %rax     # 0x1c688
cmpb $0x1, 0x22(%rax)
jne 0x3003
cmpb $0x0, 0x95d6(%rip)      # 0xc5cb
jne 0x3003
movl $0xd, %edi
xorl %eax, %eax
callq 0x6cf0
cmpb $0x0, 0x9568(%rip)      # 0xc572
jne 0x301e
cmpb $0x1, 0x9560(%rip)      # 0xc573
je 0x30c5
callq 0x3783
movb $0x0, 0x954c(%rip)      # 0xc571
xorl %ebx, %ebx
jmp 0x3098
callq 0x3783
movzbl %bl, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3865
testb %al, %al
jne 0x309e
testb %bl, %bl
je 0x304b
decq %r14
movq %r14, (%rsp)
cmpb $0x1, 0x9521(%rip)      # 0xc573
jne 0x308d
leaq 0x9518(%rip), %rcx      # 0xc573
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
xorl %r8d, %r8d
callq 0x5978
testb %al, %al
je 0x30a8
movb 0x94fb(%rip), %al       # 0xc573
andb %bl, %al
cmpb $0x1, %al
je 0x30a8
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x3a80
jmp 0x3098
movq %r15, %rdi
movq %r14, %rsi
callq 0x3c29
movb %bl, 0x952d(%rip)       # 0xc5cb
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x195d1(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x4fef(%rip), %rcx      # 0x80a8
movl $0x5, %esi
movl $0x2, %edx
jmp 0x30e0
leaq 0x195b4(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x4f96(%rip), %rcx      # 0x806c
movl $0x5, %esi
movl $0x1, %edx
callq 0x2440
movq %rax, %rdi
callq 0x3e30
// File: /workspace/github_c_makefile_star2_O3/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 0x2bcc
movq %rsp, %r14
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
movq %r14, %rdi
movq %rbx, %rcx
callq 0x20e0
testq %rax, %rax
je 0x31b4
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x2200
testq %rax, %rax
je 0x3180
movq %rax, %rbp
movq %r14, %r12
movq %rbp, %rsi
subq %r12, %rsi
movq %r12, %rdi
movl $0x1, %edx
callq 0x31db
movq %rbp, %r12
incq %r12
movq %r14, %r13
subq %r12, %r13
addq %r15, %r13
movq %r12, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x2200
movq %rax, %rbp
testq %rax, %rax
jne 0x3142
testq %r13, %r13
jne 0x3186
jmp 0x3193
movq %r15, %r13
movq %r14, %r12
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x31db
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
movq %r14, %rdi
movq %rbx, %rcx
callq 0x20e0
movq %rax, %r15
testq %rax, %rax
jne 0x312a
movq %rbx, %rdi
callq 0x2120
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x31db
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_O3/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 0x3250
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movzbl %bl, %edx
callq 0x3865
testb %al, %al
jne 0x3296
cmpb $0x1, 0x9362(%rip)      # 0xc573
jne 0x3279
leaq 0x9359(%rip), %rcx      # 0xc573
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
xorl %r8d, %r8d
callq 0x5978
testb %al, %al
je 0x32bd
movb 0x9338(%rip), %al       # 0xc573
andb %bl, %al
cmpb $0x1, %al
je 0x32a0
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x3a80
jmp 0x3284
cmpb $0x1, 0x931a(%rip)      # 0xc571
jne 0x3296
cmpb $0x0, 0x9312(%rip)      # 0xc572
jne 0x3270
cmpb $0x1, 0x930a(%rip)      # 0xc573
je 0x32a0
callq 0x3783
movb $0x0, 0x92fa(%rip)      # 0xc571
jmp 0x3296
movq %r15, %rdi
movq %r14, %rsi
callq 0x3c29
testb %bl, %bl
je 0x3296
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x3783
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x193d9(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x4dbb(%rip), %rcx      # 0x806c
movl $0x5, %esi
movl $0x1, %edx
jmp 0x32d8
leaq 0x193bc(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x4dda(%rip), %rcx      # 0x80a8
movl $0x5, %esi
movl $0x2, %edx
callq 0x2440
movq %rax, %rdi
callq 0x3e30
// File: /workspace/github_c_makefile_star2_O3/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, %ebp
movq %rsi, 0x18(%rsp)
movq %rsi, %rdi
callq 0x2130
movq %rax, %rbx
movq %rax, 0x10(%rsp)
cmpq $-0x1, 0x8c16(%rip)     # 0xc288
jne 0x3694
movl $0xe, %edi
callq 0x22f0
leaq 0x497f(%rip), %rdi      # 0x8004
movq %rax, %rsi
callq 0x297e
movq %rax, 0x8bf4(%rip)      # 0xc288
cmpl $0x74, %ebp
jne 0x36a7
callq 0x2bcc
leaq -0x4ca(%rip), %rbp      # 0x31db
jmp 0x36ae
leaq 0x309e(%rip), %rbp      # 0x674c
testq %rbx, %rbx
je 0x371a
leaq 0x20(%rsp), %rbx
leaq 0x18(%rsp), %r14
leaq 0x10(%rsp), %r15
movq %rsp, %r12
leaq 0x8(%rsp), %r13
movq $0x1000, 0x8(%rsp)      # imm = 0x1000
movq %rbx, (%rsp)
movq 0x8baa(%rip), %rdi      # 0xc288
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %r13, %r8
callq 0x20b0
cmpq $-0x1, %rax
jne 0x3704
callq 0x2050
cmpl $0x7, (%rax)
je 0x3704
callq 0x6f57
movq (%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq *%rbp
cmpq $0x0, 0x10(%rsp)
jne 0x36ca
leaq 0x20(%rsp), %rbx
movq %rsp, %rcx
movq %rbx, (%rcx)
leaq 0x8(%rsp), %r8
movq $0x1000, (%r8)          # imm = 0x1000
movq 0x8b50(%rip), %rdi      # 0xc288
xorl %esi, %esi
xorl %edx, %edx
callq 0x20b0
cmpq $-0x1, %rax
jne 0x374c
callq 0x6f57
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_O3/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, 0x8de6(%rip)      # 0xc574
jne 0x380a
cmpb $0x0, 0x8dde(%rip)      # 0xc575
jne 0x383d
movq 0x8dac(%rip), %rdi      # 0xc550
callq 0x2280
movq %rax, %rbx
movq 0x8dc5(%rip), %rsi      # 0xc578
subl %esi, %eax
addl $-0x4, %eax
orl $0x6000000, %eax        # imm = 0x6000000
bswapl %eax
leaq 0x4(%rsp), %r14
movl %eax, (%r14)
movq 0x8d82(%rip), %rdi      # 0xc550
xorl %edx, %edx
callq 0x2320
movq 0x8d74(%rip), %rcx      # 0xc550
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rdi
callq 0x2460
movq 0x8d5b(%rip), %rdi      # 0xc550
xorl %esi, %esi
movl $0x2, %edx
callq 0x2320
movq %rbx, 0x8d70(%rip)      # 0xc578
jmp 0x382e
movq 0x8d37(%rip), %rcx      # 0xc548
leaq 0x8d68(%rip), %rdi      # 0xc580
movl $0x4, %esi
movl $0x1, %edx
callq 0x2460
incq 0x8d2a(%rip)            # 0xc558
movb $0x0, 0x8d3c(%rip)      # 0xc571
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x18e3c(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x4831(%rip), %rcx      # 0x807f
movl $0x5, %esi
movl $0x7, %edx
callq 0x2440
movq %rax, %rdi
callq 0x3e30
// File: /workspace/github_c_makefile_star2_O3/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 0x3a41
xorl %eax, %eax
cmpl $0x30, %edi
je 0x3a56
cmpl $0x5c, %edi
jne 0x3a57
movl $0x5c, %eax
retq
cmpl $0x6e, %edi
je 0x3a51
cmpl $0x72, %edi
jne 0x3a57
movl $0xd, %eax
retq
movl $0xa, %eax
retq
pushq %rax
leaq 0x18c21(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x45d6(%rip), %rcx      # 0x803f
movl $0x5, %esi
movl $0x5, %edx
callq 0x2440
movq %rax, %rdi
callq 0x3e30
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq 0x8af4(%rip), %r13      # 0xc588
movq (%rdi), %r12
movq (%rsi), %r15
cmpq $0x17, %r13
jb 0x3aab
movq %r12, %rdi
movq %r15, %rsi
jmp 0x3c1a
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x8abb(%rip)      # 0xc573
jne 0x3af1
leaq 0x8aef(%rip), %rdi      # 0xc5b0
addq %r13, %rdi
cmpq $0x17, %r15
jae 0x3bd6
movq %r15, %rdx
subq %r13, %rdx
movq %r12, %rsi
callq 0x22a0
movq %r15, 0x8aa5(%rip)      # 0xc588
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
movl $0x3d, %esi
movq %r15, %rdx
callq 0x2200
subq %r12, %rax
leaq (%rax,%r13), %r15
leaq 0x8aa1(%rip), %rdi      # 0xc5b0
addq %r13, %rdi
cmpq $0x17, %r15
jae 0x3bd6
movq %r12, %rsi
movq %rax, %rdx
callq 0x22a0
movq %r15, 0x8a5a(%rip)      # 0xc588
cmpq $0x16, %r15
jne 0x3bf3
leaq 0x18b31(%rip), %rax     # 0x1c670
movq (%rax), %rax
movl $0x16, %r15d
cmpl $0x2, (%rax)
jne 0x3bf3
leaq 0x8240(%rip), %rax      # 0xbd98
movq (%rax), %rax
movdqu 0x8a53(%rip), %xmm0     # 0xc5b6
movdqu (%rax), %xmm1
movdqu 0x6(%rax), %xmm2
pcmpeqb 0x8a3c(%rip), %xmm1     # 0xc5b0
pcmpeqb %xmm0, %xmm2
pand %xmm2, %xmm1
pmovmskb %xmm1, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jne 0x3bf3
movb $0x1, 0x89e6(%rip)      # 0xc574
leaq 0xc(%rsp), %rdi
movl $0x0, (%rdi)
movq 0x89b0(%rip), %rcx      # 0xc550
movl $0x4, %esi
movl $0x1, %edx
callq 0x2460
addq $-0x4, 0x89e9(%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 0x3c1a
movl $0x16, %edx
subq %r13, %rdx
movq %r12, %rsi
callq 0x22a0
movq %r15, 0x899b(%rip)      # 0xc588
movl $0x16, %r15d
movq %r15, %r12
subq %r13, %r12
leaq 0x89b0(%rip), %rdi      # 0xc5b0
movq %r15, %rsi
callq 0x3c29
movq (%r14), %rdi
addq %r12, %rdi
movq %rdi, (%r14)
movq (%rbx), %rsi
subq %r12, %rsi
movq %rsi, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3c29
// File: /workspace/github_c_makefile_star2_O3/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, 0x8933(%rip)      # 0xc574
jne 0x3dbf
testq %rbx, %rbx
jle 0x3db0
addq %r14, %rbx
leaq 0x8146(%rip), %rax      # 0xbda0
movq (%rax), %r15
movb $0x1, %bpl
leaq 0x8960(%rip), %r13      # 0xc5c7
leaq 0x5(%rsp), %r12
movzbl (%r14), %esi
movq %r15, %rdi
callq 0x2140
testq %rax, %rax
je 0x3e08
movb 0x8910(%rip), %sil      # 0xc598
movb 0x88e7(%rip), %cl       # 0xc575
testb %cl, %cl
sete %dl
andb %sil, %dl
cmpb $0x1, %dl
je 0x3e08
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 0x3e08
cmpl $0x40, %edi
setne %dil
cmpb $0x2, %cl
setne %r8b
orb %dil, %r8b
jne 0x3cea
movb %bpl, 0x88b9(%rip)      # 0xc598
movb %bpl, 0x88e0(%rip)      # 0xc5c6
xorl %eax, %eax
jmp 0x3d05
cmpb $0x3, %cl
jne 0x3d05
testb %sil, %sil
je 0x3d16
cmpb $0x40, %al
jne 0x3e08
movzbl 0x88c3(%rip), %edx      # 0xc5c6
jmp 0x3d2d
incb %cl
movb %cl, 0x8868(%rip)       # 0xc575
movb %al, (%rdx,%r13)
jmp 0x3da4
cmpb $0x40, %al
jne 0x3d31
movb $0x1, 0x8877(%rip)      # 0xc598
movb $0x2, 0x889e(%rip)      # 0xc5c6
movl $0x2, %edx
xorl %eax, %eax
jmp 0x3d3d
movb $0x3, 0x888e(%rip)      # 0xc5c6
movl $0x3, %edx
movb $0x4, 0x8831(%rip)      # 0xc575
movb %al, 0x8880(%rip)       # 0xc5ca
movb 0x8877(%rip), %cl       # 0xc5c7
shlb $0x2, %cl
movb 0x886e(%rip), %sil      # 0xc5c8
movl %esi, %edi
shrb $0x4, %dil
orb %cl, %dil
movb %dil, 0x5(%rsp)
shlb $0x4, %sil
movb 0x8857(%rip), %cl       # 0xc5c9
movl %ecx, %edi
shrb $0x2, %dil
orb %sil, %dil
movb %dil, 0x6(%rsp)
shlb $0x6, %cl
orb %al, %cl
movb %cl, 0x7(%rsp)
movq 0x87c0(%rip), %rcx      # 0xc550
movl $0x1, %esi
movq %r12, %rdi
callq 0x2460
movb $0x0, 0x87d1(%rip)      # 0xc575
incq %r14
cmpq %rbx, %r14
jb 0x3c6c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x87da(%rip), %rax      # 0xc5a0
addq %rbx, %rax
movq %rax, 0x87d0(%rip)      # 0xc5a0
cmpq $0x2800001, %rax        # imm = 0x2800001
jb 0x3ddd
callq 0x7166
addl %ebx, 0x879d(%rip)      # 0xc580
movq 0x8756(%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 0x18871(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x4266(%rip), %rcx      # 0x807f
movl $0x5, %esi
movl $0x7, %edx
callq 0x2440
movq %rax, %rdi
callq 0x3e30
// File: /workspace/github_c_makefile_star2_O3/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 0x81b4(%rip), %r15      # 0xbff8
movq (%r15), %r14
leaq 0x18832(%rip), %rax     # 0x1c680
movq (%rax), %rdi
leaq 0x41ff(%rip), %rcx      # 0x8057
movl $0x1, %esi
movl $0x6, %edx
callq 0x2440
movq 0x86ea(%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_O3/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 0x18811(%rip), %rax     # 0x1c6e0
movq (%rax), %rdi
callq 0x2120
cmpl $-0x1, %eax
jne 0x3ef8
leaq 0x187a5(%rip), %rax     # 0x1c688
movq 0x30(%rax), %rdi
testq %rdi, %rdi
jne 0x3ef3
movq 0x86dd(%rip), %rdi      # 0xc5d0
callq 0x7025
leaq 0x18789(%rip), %rbx     # 0x1c688
cmpq $0x0, 0x30(%rbx)
jne 0x3f5c
leaq 0x187bb(%rip), %rax     # 0x1c6c8
cmpb $0x1, (%rax)
jne 0x3f5c
leaq 0x187a7(%rip), %rax     # 0x1c6c0
movq (%rax), %rdi
callq 0x22d0
movq %rsp, %rsi
movl %eax, %edi
callq 0x24b0
movq 0x869e(%rip), %rdi      # 0xc5d0
movq 0x28(%rbx), %rsi
callq 0x23e0
testl %eax, %eax
jne 0x3f57
movb $0x0, 0x8692(%rip)      # 0xc5d8
movq 0x28(%rbx), %rdi
movl 0x18(%rsp), %esi
callq 0x2380
testl %eax, %eax
je 0x3f5c
callq 0x6f57
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x18232(%rip), %r15     # 0x1c6c0
movq (%r15), %rdi
callq 0x2290
movq (%r15), %rdi
movq 0x8158(%rip), %rsi      # 0xc5f8
subq %rbx, %rsi
xorl %edx, %edx
callq 0x2320
testl %eax, %eax
je 0x44b3
callq 0x6f57
movq (%r15), %rcx
movq %rsp, %rdi
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x20e0
testq %rax, %rax
je 0x4515
movq %rax, %r14
leaq 0x18209(%rip), %r12     # 0x1c6e0
movq %rsp, %rbx
movq (%r12), %rcx
movl $0x1, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2460
cmpq %r14, %rax
je 0x44f8
callq 0x6f57
movq (%r15), %rcx
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
movq %rbx, %rdi
callq 0x20e0
movq %rax, %r14
testq %rax, %rax
jne 0x44da
movq (%r15), %rdi
callq 0x20c0
testl %eax, %eax
je 0x4526
callq 0x6f57
callq 0x3ec0
xorl %edi, %edi
callq 0x2450
// File: /workspace/github_c_makefile_star2_O3/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 0x17bbc(%rip), %r14     # 0x1c6d8
addl (%r14), %eax
movq %rbx, %rdi
movl %eax, %esi
callq 0x5b83
movq %rbx, %rdi
callq 0x2110
leaq 0x17ba8(%rip), %rax     # 0x1c6e0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x5b2b
movq %rbx, %rdi
callq 0x24a0
testl %eax, %eax
je 0x4b62
leaq 0x17b72(%rip), %rax     # 0x1c6c8
cmpb $0x1, (%rax)
je 0x4b6c
movl $0x0, (%r14)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %edi, %edi
callq 0x4476
// File: /workspace/github_c_makefile_star2_O3/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 0x4b9b
movl $0x5, %edi
xorl %eax, %eax
callq 0x6dcc
jmp 0x4bb3
leaq 0x17b2e(%rip), %rax     # 0x1c6d0
cmpl $0x2, (%rax)
jb 0x4bb3
movq %rbx, %rdi
callq 0x2470
testl %eax, %eax
je 0x4b8d
leaq 0x17b16(%rip), %rax     # 0x1c6d0
incl (%rax)
movq (%rbx), %rax
movzbl 0x1a(%rax), %r12d
testq %r12, %r12
je 0x4d80
movq 0x10(%rbx), %r14
cmpl $0x1, %r12d
jne 0x4be5
movl $0x1b, %r13d
movb $0x1, %r15b
jmp 0x4c95
cmpb $-0x1, 0x1b(%rax)
je 0x4bf2
xorl %ecx, %ecx
jmp 0x4c8a
leal -0x2(%r12), %eax
movzbl %al, %r13d
leal -0x1(%r12), %eax
movl %eax, 0xc(%rsp)
movl 0x7a16(%rip), %ecx      # 0xc620
xorl %ebp, %ebp
movq %r14, %r15
cmpl $0x7800001, %ecx        # imm = 0x7800001
jb 0x4c28
movl $0x9, %edi
movl $0x78, %esi
xorl %eax, %eax
callq 0x6dcc
movl 0x79e2(%rip), %edi      # 0xc610
movl $0xff, %edx
movq %r15, %rsi
callq 0x2100
movl 0x79df(%rip), %ecx      # 0xc620
movl $0xff, %eax
addl %eax, %ecx
movl %ecx, 0x79d2(%rip)      # 0xc620
cmpq %rbp, %r13
je 0x4c79
leaq 0xff(%r15), %r14
leaq 0x1(%rbp), %rdx
movq (%rbx), %rax
cmpb $-0x1, 0x1c(%rax,%rbp)
movq %rdx, %rbp
je 0x4c0c
addq $0xff, %r15
movq %r15, %r14
movl %edx, %ecx
jmp 0x4c8a
movq (%rbx), %rax
addq $0xff, %r15
movq %r15, %r14
movl 0xc(%rsp), %ecx
movzbl %cl, %r15d
leaq 0x1b(%r15), %r13
incb %r15b
movzbl (%rax,%r13), %eax
movl %eax, %ecx
addl 0x797e(%rip), %ecx      # 0xc620
movl %ecx, 0x7978(%rip)      # 0xc620
cmpl $0x7800001, %ecx        # imm = 0x7800001
jb 0x4cc8
movl $0x9, %edi
movl $0x78, %esi
xorl %eax, %eax
callq 0x6dcc
movq (%rbx), %rax
movb (%rax,%r13), %al
movl 0x7942(%rip), %edi      # 0xc610
movzbl %al, %edx
movq %r14, %rsi
callq 0x2100
cmpb %r12b, %r15b
jne 0x4ced
movq (%rbx), %rax
cmpb $-0x1, 0x1a(%rax,%r12)
je 0x4d80
movl 0x791d(%rip), %edi      # 0xc610
callq 0x21c0
movq 0x7919(%rip), %rdi      # 0xc618
leaq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0x2490
leaq 0x179e5(%rip), %rax     # 0x1c6f8
movq (%rax), %rdi
movq %rsp, %rsi
callq 0x2490
leaq 0x17963(%rip), %rax     # 0x1c688
cmpl $0x3, (%rax)
movq (%r14), %rsi
jne 0x4d59
cmpq $0x0, 0x20(%rsi)
movq (%rsp), %rdx
jne 0x4d5d
cmpq $0x0, 0x18(%rdx)
jne 0x4d5d
cmpq $0x0, 0x30(%rax)
jne 0x4d5d
cmpb $0x0, 0x4(%rax)
jne 0x4d5d
cmpb $0x0, 0x28(%rsi)
jne 0x4d5d
xorl %edi, %edi
callq 0x2450
movq (%rsp), %rdx
xorl %ecx, %ecx
cmpb %r12b, %r15b
setne %cl
movq %rbx, %rdi
callq 0x3f65
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_O3/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 0x4e9b
leaq 0x17915(%rip), %r15     # 0x1c6cc
movq %rsp, %r14
leaq 0x1791f(%rip), %r12     # 0x1c6e0
testl %eax, %eax
jle 0x4e0a
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rax, 0x7827(%rip)      # 0xc5f8
cmpl $0x0, (%r15)
je 0x4e15
movq %r14, %rdi
callq 0x5a12
testb %al, %al
je 0x4e49
movl (%r15), %eax
movb $0x1, %bpl
cmpl $0x4, %eax
je 0x4e91
cmpl $0x2, %eax
je 0x4e87
cmpl $0x1, %eax
jne 0x4e1f
movq %r14, %rdi
callq 0x4976
jmp 0x4e1f
negl %eax
addq %rax, 0x77e5(%rip)      # 0xc5f8
jmp 0x4e72
movq %r14, %rdi
callq 0x47a4
movl %eax, %ebp
testb %bpl, %bpl
je 0x4e44
cmpl $0x3, (%r15)
ja 0x4e44
movq %r14, %rdi
callq 0x24a0
testl %eax, %eax
je 0x4e44
movl $0x5, %edi
xorl %eax, %eax
callq 0x6dcc
jmp 0x4e72
testb %bpl, %bpl
jne 0x4e72
movq %r14, %rdi
callq 0x2080
movq 0x7788(%rip), %rsi      # 0xc5e0
testq %rsi, %rsi
movq (%r12), %rcx
cmoveq %rcx, %rsi
testq %rax, %rax
cmoveq %rcx, %rsi
movq %r14, %rdi
callq 0x5b2b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2360
testl %eax, %eax
jne 0x4dc1
jmp 0x4e9b
movq %r14, %rdi
callq 0x4b73
jmp 0x4e1f
movq %r14, %rdi
callq 0x4b09
jmp 0x4e1f
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7725(%rip), %rdi      # 0xc5e0
callq 0x2150
movq 0x7719(%rip), %rcx      # 0xc5e0
movq %rsp, %rdi
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x20e0
testq %rax, %rax
je 0x4f29
movq %rax, %r14
leaq 0x177f8(%rip), %r15     # 0x1c6e0
movq %rsp, %rbx
movq (%r15), %rcx
movl $0x1, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2460
cmpq %r14, %rax
je 0x4f08
callq 0x6f57
movq 0x76d1(%rip), %rcx      # 0xc5e0
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
movq %rbx, %rdi
callq 0x20e0
movq %rax, %r14
testq %rax, %rax
jne 0x4eeb
movq 0x76b0(%rip), %rdi      # 0xc5e0
callq 0x2120
movq $0x0, 0x76a0(%rip) # 0xc5e0
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x1775f(%rip), %rax     # 0x1c6c0
movq (%rax), %rcx
leaq 0x76c5(%rip), %rdi      # 0xc630
movl $0x1, %esi
movl $0x4, %edx
callq 0x20e0
cmpq $0x4, %rax
je 0x4f97
cmpq $-0x1, %rax
jne 0x4f8b
callq 0x6f57
movl $0xf, %edi
xorl %eax, %eax
callq 0x6dcc
movb 0x7693(%rip), %al       # 0xc630
movl %eax, %ecx
andb $0x7f, %cl
movb %cl, (%rbx)
movb $0x0, 0x7685(%rip)      # 0xc630
movl 0x767f(%rip), %ecx      # 0xc630
bswapl %ecx
movq %rcx, (%r14)
movb (%rbx), %cl
movb %cl, 0x7672(%rip)       # 0xc630
shrb $0x7, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x509e
movq %rdi, %r14
xorl %edi, %edi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x3f65
movq (%r14), %rdi
callq 0x2280
bswapl %eax
movl %eax, 0x7630(%rip)      # 0xc630
leaq 0x7629(%rip), %rdi      # 0xc630
movb $0x4, 0x7622(%rip)      # 0xc630
leaq 0x176cb(%rip), %r13     # 0x1c6e0
movq (%r13), %rcx
movl $0x1, %esi
movl $0x4, %edx
callq 0x2460
cmpq $0x4, %rax
je 0x5033
callq 0x6f57
movq (%r14), %rdi
callq 0x2150
movq (%r14), %rcx
leaq 0x75eb(%rip), %rdi      # 0xc630
movl $0x1, %esi
movl $0x10000, %edx          # imm = 0x10000
callq 0x20e0
testq %rax, %rax
je 0x509e
movq %rax, %r12
leaq 0x75cd(%rip), %r15      # 0xc630
movq (%r13), %rcx
movl $0x1, %esi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2460
cmpq %r12, %rax
je 0x5081
callq 0x6f57
movq (%r14), %rcx
movl $0x1, %esi
movl $0x10000, %edx          # imm = 0x10000
movq %r15, %rdi
callq 0x20e0
movq %rax, %r12
testq %rax, %rax
jne 0x5063
movq 0x10(%rbx), %rdi
callq 0x2150
movq 0x10(%rbx), %rcx
leaq 0x757e(%rip), %rdi      # 0xc630
movl $0x1, %esi
movl $0x10000, %edx          # imm = 0x10000
callq 0x20e0
testq %rax, %rax
je 0x5113
movq %rax, %r15
leaq 0x17610(%rip), %r12     # 0x1c6e0
leaq 0x7559(%rip), %r14      # 0xc630
movq (%r12), %rcx
movl $0x1, %esi
movq %r14, %rdi
movq %r15, %rdx
callq 0x2460
cmpq %r15, %rax
je 0x50f5
callq 0x6f57
movq 0x10(%rbx), %rcx
movl $0x1, %esi
movl $0x10000, %edx          # imm = 0x10000
movq %r14, %rdi
callq 0x20e0
movq %rax, %r15
testq %rax, %rax
jne 0x50d7
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2857(%rip), %rsi      # 0x80f3
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 0x5951
leaq 0x10(%rsp), %r12
leaq 0x16e12(%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 0x5937
callq 0x6f57
movl $0x1, %esi
movl $0x40, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x20e0
testq %rax, %rax
jne 0x58d6
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)