LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__parse_zlib(stbi__zbuf*, int)
static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)
{
   int final, type;
   if (parse_header)
      if (!stbi__parse_zlib_header(a)) return 0;
   a->num_bits = 0;
   a->code_buffer = 0;
   do {
      final = stbi__zreceive(a,1);
      type = stbi__zreceive(a,2);
      if (type == 0) {
         if (!stbi__parse_uncomperssed_block(a)) return 0;
      } else if (type == 3) {
         return 0;
      } else {
         if (type == 1) {
            // use fixed code lengths
            if (!stbi__zdefault_distance[31]) stbi__init_zdefaults();
            if (!stbi__zbuild_huffman(&a->z_length  , stbi__zdefault_length  , 288)) return 0;
            if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance,  32)) return 0;
         } else {
            if (!stbi__compute_huffman_codes(a)) return 0;
         }
         if (!stbi__parse_huffman_block(a)) return 0;
      }
   } while (!final);
   return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x2ac12
movq 0x18(%rsp), %rdi
callq 0x2ad60
cmpl $0x0, %eax
jne 0x2ac10
movl $0x0, 0x24(%rsp)
jmp 0x2ad4f
jmp 0x2ac12
movq 0x18(%rsp), %rax
movl $0x0, 0x10(%rax)
movq 0x18(%rsp), %rax
movl $0x0, 0x14(%rax)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x2ae10
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x2ae10
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x2ac78
movq 0x18(%rsp), %rdi
callq 0x2ae80
cmpl $0x0, %eax
jne 0x2ac73
movl $0x0, 0x24(%rsp)
jmp 0x2ad4f
jmp 0x2ad33
cmpl $0x3, 0xc(%rsp)
jne 0x2ac8c
movl $0x0, 0x24(%rsp)
jmp 0x2ad4f
cmpl $0x1, 0xc(%rsp)
jne 0x2acfb
cmpb $0x0, 0xbb45(%rip)      # 0x367df
jne 0x2aca1
callq 0x2b070
movq 0x18(%rsp), %rdi
addq $0x34, %rdi
leaq 0xbb2f(%rip), %rsi      # 0x367e0
movl $0x120, %edx            # imm = 0x120
callq 0x2b150
cmpl $0x0, %eax
jne 0x2accd
movl $0x0, 0x24(%rsp)
jmp 0x2ad4f
movq 0x18(%rsp), %rdi
addq $0x818, %rdi            # imm = 0x818
leaq 0xbae0(%rip), %rsi      # 0x367c0
movl $0x20, %edx
callq 0x2b150
cmpl $0x0, %eax
jne 0x2acf9
movl $0x0, 0x24(%rsp)
jmp 0x2ad4f
jmp 0x2ad16
movq 0x18(%rsp), %rdi
callq 0x2b510
cmpl $0x0, %eax
jne 0x2ad14
movl $0x0, 0x24(%rsp)
jmp 0x2ad4f
jmp 0x2ad16
movq 0x18(%rsp), %rdi
callq 0x2b830
cmpl $0x0, %eax
jne 0x2ad2f
movl $0x0, 0x24(%rsp)
jmp 0x2ad4f
jmp 0x2ad31
jmp 0x2ad33
jmp 0x2ad35
cmpl $0x0, 0x10(%rsp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2ac2a
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__init_zdefaults()
static void stbi__init_zdefaults(void)
{
   int i;   // use <= to match clearly with spec
   for (i=0; i <= 143; ++i)     stbi__zdefault_length[i]   = 8;
   for (   ; i <= 255; ++i)     stbi__zdefault_length[i]   = 9;
   for (   ; i <= 279; ++i)     stbi__zdefault_length[i]   = 7;
   for (   ; i <= 287; ++i)     stbi__zdefault_length[i]   = 8;

   for (i=0; i <=  31; ++i)     stbi__zdefault_distance[i] = 5;
}

// Assembly:
movl $0x0, -0x4(%rsp)
cmpl $0x8f, -0x4(%rsp)
jg 0x2b09f
movslq -0x4(%rsp), %rcx
leaq 0xb752(%rip), %rax      # 0x367e0
movb $0x8, (%rax,%rcx)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x2b078
jmp 0x2b0a1
cmpl $0xff, -0x4(%rsp)
jg 0x2b0c8
movslq -0x4(%rsp), %rcx
leaq 0xb729(%rip), %rax      # 0x367e0
movb $0x9, (%rax,%rcx)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x2b0a1
jmp 0x2b0ca
cmpl $0x117, -0x4(%rsp)      # imm = 0x117
jg 0x2b0f1
movslq -0x4(%rsp), %rcx
leaq 0xb700(%rip), %rax      # 0x367e0
movb $0x7, (%rax,%rcx)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x2b0ca
jmp 0x2b0f3
cmpl $0x11f, -0x4(%rsp)      # imm = 0x11F
jg 0x2b11a
movslq -0x4(%rsp), %rcx
leaq 0xb6d7(%rip), %rax      # 0x367e0
movb $0x8, (%rax,%rcx)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x2b0f3
movl $0x0, -0x4(%rsp)
cmpl $0x1f, -0x4(%rsp)
jg 0x2b146
movslq -0x4(%rsp), %rcx
leaq 0xb68b(%rip), %rax      # 0x367c0
movb $0x5, (%rax,%rcx)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x2b122
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, (%rsp)
movq (%rsp), %rax
movl 0x14(%rax), %eax
movq (%rsp), %rcx
movl 0x10(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
cmpl %ecx, %eax
jae 0x2bb72
jmp 0x2bb91
leaq 0x26a6(%rip), %rdi      # 0x2e21f
leaq 0x2093(%rip), %rsi      # 0x2dc13
movl $0xdd8, %edx            # imm = 0xDD8
leaq 0x26b8(%rip), %rcx      # 0x2e244
callq 0xd270
movq (%rsp), %rdi
callq 0x2bb10
movzbl %al, %eax
movq (%rsp), %rcx
movl 0x10(%rcx), %ecx
shll %cl, %eax
movl %eax, %ecx
movq (%rsp), %rax
orl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
movq (%rsp), %rax
movl 0x10(%rax), %ecx
addl $0x8, %ecx
movl %ecx, 0x10(%rax)
movq (%rsp), %rax
cmpl $0x18, 0x10(%rax)
jle 0x2bb55
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x28(%rsp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x2bc10
leaq 0x26c5(%rip), %rdi      # 0x2e2c7
callq 0x1a190
movl %eax, 0x34(%rsp)
jmp 0x2bcd0
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rsp), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x28(%rsp), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %eax
addl 0x1c(%rsp), %eax
cmpl 0x8(%rsp), %eax
jle 0x2bc5c
movl 0x8(%rsp), %eax
shll %eax
movl %eax, 0x8(%rsp)
jmp 0x2bc42
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rdi
movslq 0x8(%rsp), %rsi
callq 0xd6e0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2bc8e
leaq 0x1ec0(%rip), %rdi      # 0x2db43
callq 0x1a190
movl %eax, 0x34(%rsp)
jmp 0x2bcd0
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rcx
movslq 0xc(%rsp), %rax
addq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rcx
movslq 0x8(%rsp), %rax
addq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x28(%rax)
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__hdr_test_core(stbi__context*)
static int stbi__hdr_test_core(stbi__context *s)
{
   const char *signature = "#?RADIANCE\n";
   int i;
   for (i=0; signature[i]; ++i)
      if (stbi__get8(s) != signature[i])
         return 0;
   return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
leaq 0x2412(%rip), %rax      # 0x2e3b2
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x2bff5
movq 0x18(%rsp), %rdi
callq 0x21530
movzbl %al, %eax
movq 0x10(%rsp), %rcx
movslq 0xc(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x2bfe6
movl $0x0, 0x24(%rsp)
jmp 0x2bffd
jmp 0x2bfe8
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2bfad
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__bmp_info(stbi__context*, int*, int*, int*)
static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)
{
   int hsz;
   if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') {
       stbi__rewind( s );
       return 0;
   }
   stbi__skip(s,12);
   hsz = stbi__get32le(s);
   if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) {
       stbi__rewind( s );
       return 0;
   }
   if (hsz == 12) {
      *x = stbi__get16le(s);
      *y = stbi__get16le(s);
   } else {
      *x = stbi__get32le(s);
      *y = stbi__get32le(s);
   }
   if (stbi__get16le(s) != 1) {
       stbi__rewind( s );
       return 0;
   }
   *comp = stbi__get16le(s) / 8;
   return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x21530
movzbl %al, %eax
cmpl $0x42, %eax
jne 0x2c12c
movq 0x28(%rsp), %rdi
callq 0x21530
movzbl %al, %eax
cmpl $0x4d, %eax
je 0x2c143
movq 0x28(%rsp), %rdi
callq 0x1fab0
movl $0x0, 0x34(%rsp)
jmp 0x2c235
movq 0x28(%rsp), %rdi
movl $0xc, %esi
callq 0x21ab0
movq 0x28(%rsp), %rdi
callq 0x28920
movl %eax, 0xc(%rsp)
cmpl $0xc, 0xc(%rsp)
je 0x2c19a
cmpl $0x28, 0xc(%rsp)
je 0x2c19a
cmpl $0x38, 0xc(%rsp)
je 0x2c19a
cmpl $0x6c, 0xc(%rsp)
je 0x2c19a
cmpl $0x7c, 0xc(%rsp)
je 0x2c19a
movq 0x28(%rsp), %rdi
callq 0x1fab0
movl $0x0, 0x34(%rsp)
jmp 0x2c235
cmpl $0xc, 0xc(%rsp)
jne 0x2c1c9
movq 0x28(%rsp), %rdi
callq 0x28960
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x28(%rsp), %rdi
callq 0x28960
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
jmp 0x2c1ef
movq 0x28(%rsp), %rdi
callq 0x28920
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x28(%rsp), %rdi
callq 0x28920
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x28(%rsp), %rdi
callq 0x28960
cmpl $0x1, %eax
je 0x2c212
movq 0x28(%rsp), %rdi
callq 0x1fab0
movl $0x0, 0x34(%rsp)
jmp 0x2c235
movq 0x28(%rsp), %rdi
callq 0x28960
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x261d0
cmpl $0x38425053, %eax       # imm = 0x38425053
je 0x2c280
movq 0x28(%rsp), %rdi
callq 0x1fab0
movl $0x0, 0x34(%rsp)
jmp 0x2c364
movq 0x28(%rsp), %rdi
callq 0x21680
cmpl $0x1, %eax
je 0x2c2a6
movq 0x28(%rsp), %rdi
callq 0x1fab0
movl $0x0, 0x34(%rsp)
jmp 0x2c364
movq 0x28(%rsp), %rdi
movl $0x6, %esi
callq 0x21ab0
movq 0x28(%rsp), %rdi
callq 0x21680
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jl 0x2c2d1
cmpl $0x10, 0xc(%rsp)
jle 0x2c2e5
movq 0x28(%rsp), %rdi
callq 0x1fab0
movl $0x0, 0x34(%rsp)
jmp 0x2c364
movq 0x28(%rsp), %rdi
callq 0x261d0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x28(%rsp), %rdi
callq 0x261d0
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x28(%rsp), %rdi
callq 0x21680
cmpl $0x8, %eax
je 0x2c32e
movq 0x28(%rsp), %rdi
callq 0x1fab0
movl $0x0, 0x34(%rsp)
jmp 0x2c364
movq 0x28(%rsp), %rdi
callq 0x21680
cmpl $0x3, %eax
je 0x2c351
movq 0x28(%rsp), %rdi
callq 0x1fab0
movl $0x0, 0x34(%rsp)
jmp 0x2c364
movq 0x10(%rsp), %rax
movl $0x4, (%rax)
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__pic_info(stbi__context*, int*, int*, int*)
static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp)
{
   int act_comp=0,num_packets=0,chained;
   stbi__pic_packet packets[10];

   stbi__skip(s, 92);

   *x = stbi__get16be(s);
   *y = stbi__get16be(s);
   if (stbi__at_eof(s))  return 0;
   if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) {
       stbi__rewind( s );
       return 0;
   }

   stbi__skip(s, 8);

   do {
      stbi__pic_packet *packet;

      if (num_packets==sizeof(packets)/sizeof(packets[0]))
         return 0;

      packet = &packets[num_packets++];
      chained = stbi__get8(s);
      packet->size    = stbi__get8(s);
      packet->type    = stbi__get8(s);
      packet->channel = stbi__get8(s);
      act_comp |= packet->channel;

      if (stbi__at_eof(s)) {
          stbi__rewind( s );
          return 0;
      }
      if (packet->size != 8) {
          stbi__rewind( s );
          return 0;
      }
   } while (chained);

   *comp = (act_comp & 0x10 ? 4 : 3);

   return 1;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movl $0x0, 0x38(%rsp)
movq 0x58(%rsp), %rdi
movl $0x5c, %esi
callq 0x21ab0
movq 0x58(%rsp), %rdi
callq 0x21680
movl %eax, %ecx
movq 0x50(%rsp), %rax
movl %ecx, (%rax)
movq 0x58(%rsp), %rdi
callq 0x21680
movl %eax, %ecx
movq 0x48(%rsp), %rax
movl %ecx, (%rax)
movq 0x58(%rsp), %rdi
callq 0x20b60
cmpl $0x0, %eax
je 0x2c3e9
movl $0x0, 0x64(%rsp)
jmp 0x2c53c
movq 0x50(%rsp), %rax
cmpl $0x0, (%rax)
je 0x2c420
movq 0x50(%rsp), %rcx
movl $0x10000000, %eax       # imm = 0x10000000
cltd
idivl (%rcx)
movq 0x48(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x2c420
movq 0x58(%rsp), %rdi
callq 0x1fab0
movl $0x0, 0x64(%rsp)
jmp 0x2c53c
movq 0x58(%rsp), %rdi
movl $0x8, %esi
callq 0x21ab0
movslq 0x38(%rsp), %rax
cmpq $0xa, %rax
jne 0x2c447
movl $0x0, 0x64(%rsp)
jmp 0x2c53c
movl 0x38(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%rsp)
movslq %eax, %rcx
leaq 0x10(%rsp), %rax
imulq $0x3, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
callq 0x21530
movzbl %al, %eax
movl %eax, 0x34(%rsp)
movq 0x58(%rsp), %rdi
callq 0x21530
movb %al, %cl
movq 0x8(%rsp), %rax
movb %cl, (%rax)
movq 0x58(%rsp), %rdi
callq 0x21530
movb %al, %cl
movq 0x8(%rsp), %rax
movb %cl, 0x1(%rax)
movq 0x58(%rsp), %rdi
callq 0x21530
movb %al, %cl
movq 0x8(%rsp), %rax
movb %cl, 0x2(%rax)
movq 0x8(%rsp), %rax
movzbl 0x2(%rax), %eax
orl 0x3c(%rsp), %eax
movl %eax, 0x3c(%rsp)
movq 0x58(%rsp), %rdi
callq 0x20b60
cmpl $0x0, %eax
je 0x2c4e8
movq 0x58(%rsp), %rdi
callq 0x1fab0
movl $0x0, 0x64(%rsp)
jmp 0x2c53c
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x8, %eax
je 0x2c509
movq 0x58(%rsp), %rdi
callq 0x1fab0
movl $0x0, 0x64(%rsp)
jmp 0x2c53c
jmp 0x2c50b
cmpl $0x0, 0x34(%rsp)
jne 0x2c42f
movl 0x3c(%rsp), %edx
andl $0x10, %edx
movl $0x3, %ecx
movl $0x4, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq 0x40(%rsp), %rax
movl %ecx, (%rax)
movl $0x1, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x438, %rsp            # imm = 0x438
movq %rdi, 0x428(%rsp)
movq %rsi, 0x420(%rsp)
movq %rdx, 0x418(%rsp)
movq %rcx, 0x410(%rsp)
movl $0x0, 0x4(%rsp)
movq 0x428(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2a620
movq %rax, %rdi
leaq 0x1bdc(%rip), %rsi      # 0x2e177
callq 0xd5c0
cmpl $0x0, %eax
je 0x2c5c2
movq 0x428(%rsp), %rdi
callq 0x1fab0
movl $0x0, 0x434(%rsp)
jmp 0x2c743
jmp 0x2c5c4
movq 0x428(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2a620
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x2c5ea
jmp 0x2c60a
movq 0x8(%rsp), %rdi
leaq 0x1b94(%rip), %rsi      # 0x2e18a
callq 0xd5c0
cmpl $0x0, %eax
jne 0x2c608
movl $0x1, 0x4(%rsp)
jmp 0x2c5c4
cmpl $0x0, 0x4(%rsp)
jne 0x2c62e
movq 0x428(%rsp), %rdi
callq 0x1fab0
movl $0x0, 0x434(%rsp)
jmp 0x2c743
movq 0x428(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2a620
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x1b63(%rip), %rsi      # 0x2e1b4
movl $0x3, %edx
callq 0xd1d0
cmpl $0x0, %eax
je 0x2c67d
movq 0x428(%rsp), %rdi
callq 0x1fab0
movl $0x0, 0x434(%rsp)
jmp 0x2c743
movq 0x8(%rsp), %rax
addq $0x3, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0xa, %edx
callq 0xd5d0
movl %eax, %ecx
movq 0x418(%rsp), %rax
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x2c6c8
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2c6ab
movq 0x8(%rsp), %rdi
leaq 0x1afc(%rip), %rsi      # 0x2e1d0
movl $0x3, %edx
callq 0xd1d0
cmpl $0x0, %eax
je 0x2c6fd
movq 0x428(%rsp), %rdi
callq 0x1fab0
movl $0x0, 0x434(%rsp)
jmp 0x2c743
movq 0x8(%rsp), %rax
addq $0x3, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0xd5d0
movl %eax, %ecx
movq 0x420(%rsp), %rax
movl %ecx, (%rax)
movq 0x410(%rsp), %rax
movl $0x3, (%rax)
movl $0x1, 0x434(%rsp)
movl 0x434(%rsp), %eax
addq $0x438, %rsp            # imm = 0x438
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__tga_info(stbi__context*, int*, int*, int*)
static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp)
{
    int tga_w, tga_h, tga_comp;
    int sz;
    stbi__get8(s);                   // discard Offset
    sz = stbi__get8(s);              // color type
    if( sz > 1 ) {
        stbi__rewind(s);
        return 0;      // only RGB or indexed allowed
    }
    sz = stbi__get8(s);              // image type
    // only RGB or grey allowed, +/- RLE
    if ((sz != 1) && (sz != 2) && (sz != 3) && (sz != 9) && (sz != 10) && (sz != 11)) return 0;
    stbi__skip(s,9);
    tga_w = stbi__get16le(s);
    if( tga_w < 1 ) {
        stbi__rewind(s);
        return 0;   // test width
    }
    tga_h = stbi__get16le(s);
    if( tga_h < 1 ) {
        stbi__rewind(s);
        return 0;   // test height
    }
    sz = stbi__get8(s);               // bits per pixel
    // only RGB or RGBA or grey allowed
    if ((sz != 8) && (sz != 16) && (sz != 24) && (sz != 32)) {
        stbi__rewind(s);
        return 0;
    }
    tga_comp = sz;
    if (x) *x = tga_w;
    if (y) *y = tga_h;
    if (comp) *comp = tga_comp / 8;
    return 1;                   // seems to have passed everything
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x21530
movq 0x28(%rsp), %rdi
callq 0x21530
movzbl %al, %eax
movl %eax, (%rsp)
cmpl $0x1, (%rsp)
jle 0x2c7af
movq 0x28(%rsp), %rdi
callq 0x1fab0
movl $0x0, 0x34(%rsp)
jmp 0x2c8e5
movq 0x28(%rsp), %rdi
callq 0x21530
movzbl %al, %eax
movl %eax, (%rsp)
cmpl $0x1, (%rsp)
je 0x2c7f0
cmpl $0x2, (%rsp)
je 0x2c7f0
cmpl $0x3, (%rsp)
je 0x2c7f0
cmpl $0x9, (%rsp)
je 0x2c7f0
cmpl $0xa, (%rsp)
je 0x2c7f0
cmpl $0xb, (%rsp)
je 0x2c7f0
movl $0x0, 0x34(%rsp)
jmp 0x2c8e5
movq 0x28(%rsp), %rdi
movl $0x9, %esi
callq 0x21ab0
movq 0x28(%rsp), %rdi
callq 0x28960
movl %eax, 0xc(%rsp)
cmpl $0x1, 0xc(%rsp)
jge 0x2c82b
movq 0x28(%rsp), %rdi
callq 0x1fab0
movl $0x0, 0x34(%rsp)
jmp 0x2c8e5
movq 0x28(%rsp), %rdi
callq 0x28960
movl %eax, 0x8(%rsp)
cmpl $0x1, 0x8(%rsp)
jge 0x2c857
movq 0x28(%rsp), %rdi
callq 0x1fab0
movl $0x0, 0x34(%rsp)
jmp 0x2c8e5
movq 0x28(%rsp), %rdi
callq 0x21530
movzbl %al, %eax
movl %eax, (%rsp)
cmpl $0x8, (%rsp)
je 0x2c893
cmpl $0x10, (%rsp)
je 0x2c893
cmpl $0x18, (%rsp)
je 0x2c893
cmpl $0x20, (%rsp)
je 0x2c893
movq 0x28(%rsp), %rdi
callq 0x1fab0
movl $0x0, 0x34(%rsp)
jmp 0x2c8e5
movl (%rsp), %eax
movl %eax, 0x4(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x2c8ad
movl 0xc(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
cmpq $0x0, 0x18(%rsp)
je 0x2c8c0
movl 0x8(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
cmpq $0x0, 0x10(%rsp)
je 0x2c8dd
movl 0x4(%rsp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__jpeg_info_raw(stbi__jpeg*, int*, int*, int*)
static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp)
{
   if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) {
      stbi__rewind( j->s );
      return 0;
   }
   if (x) *x = j->s->img_x;
   if (y) *y = j->s->img_y;
   if (comp) *comp = j->s->img_n;
   return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x1f940
cmpl $0x0, %eax
jne 0x2c932
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x1fab0
movl $0x0, 0x24(%rsp)
jmp 0x2c985
cmpq $0x0, 0x10(%rsp)
je 0x2c94b
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl (%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
cmpq $0x0, 0x8(%rsp)
je 0x2c965
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl 0x4(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
cmpq $0x0, (%rsp)
je 0x2c97d
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl 0x8(%rax), %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/patriciogonzalezvivo[P]tprint/include/std/stb_image.h
// Function: stbi__gif_info_raw(stbi__context*, int*, int*, int*)
static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp)
{
   stbi__gif g;
   if (!stbi__gif_header(s, &g, comp, 1)) {
      stbi__rewind( s );
      return 0;
   }
   if (x) *x = g.w;
   if (y) *y = g.h;
   return 1;
}

// Assembly:
subq $0x4888, %rsp           # imm = 0x4888
movq %rdi, 0x4878(%rsp)
movq %rsi, 0x4870(%rsp)
movq %rdx, 0x4868(%rsp)
movq %rcx, 0x4860(%rsp)
movq 0x4878(%rsp), %rdi
movq 0x4860(%rsp), %rdx
leaq 0x8(%rsp), %rsi
movl $0x1, %ecx
callq 0x29210
cmpl $0x0, %eax
jne 0x2ca95
movq 0x4878(%rsp), %rdi
callq 0x1fab0
movl $0x0, 0x4884(%rsp)
jmp 0x2cad2
cmpq $0x0, 0x4870(%rsp)
je 0x2caae
movl 0x8(%rsp), %ecx
movq 0x4870(%rsp), %rax
movl %ecx, (%rax)
cmpq $0x0, 0x4868(%rsp)
je 0x2cac7
movl 0xc(%rsp), %ecx
movq 0x4868(%rsp), %rax
movl %ecx, (%rax)
movl $0x1, 0x4884(%rsp)
movl 0x4884(%rsp), %eax
addq $0x4888, %rsp           # imm = 0x4888
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x1010, %rsp           # imm = 0x1010
leaq 0x1b096(%rip), %rax     # 0x1d6c8
testb $0x1, 0x20(%rax)
je 0x26a2
leaq 0x1b0e9(%rip), %rax     # 0x1d728
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq 0xa973(%rip), %rax      # 0xcfc0
movq (%rax), %rcx
leaq 0x1b0d1(%rip), %rax     # 0x1d728
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x2160
leaq -0x1010(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x20e0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x2699
leaq -0x1010(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x26d0
jmp 0x2663
movq -0x8(%rbp), %rdi
callq 0x2120
movq 0xa917(%rip), %rax      # 0xcfc0
movq (%rax), %rdi
callq 0x2120
cmpl $-0x1, %eax
jne 0x26bb
callq 0x2720
addq $0x1010, %rsp           # imm = 0x1010
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hcmiya[P]opuscomment/src/put-tags.c
// Function: puterror
static void puterror(void) {
	if (tag_output_to_file) {
		fileerror(O.tag_filename);
	}
	else {
		oserror();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1b005(%rip), %rax     # 0x1d730
testb $0x1, (%rax)
je 0x2742
leaq 0x1af91(%rip), %rax     # 0x1d6c8
movq 0x18(%rax), %rdi
callq 0x8960
jmp 0x2747
callq 0x8880
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x50(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2090
movq %rax, %rdi
leaq 0x7593(%rip), %rsi      # 0xa00a
callq 0x2470
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2510
movq %rax, -0x58(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x58(%rbp)
jne 0x2adf
callq 0x2050
cmpl $0x16, (%rax)
jne 0x2ad8
leaq 0x1ac15(%rip), %rax     # 0x1d6c0
movq (%rax), %rdi
movl $0x4, %esi
movl $0x3, %edx
leaq 0x7556(%rip), %rcx      # 0xa015
callq 0x2460
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
movb $0x0, %al
callq 0x88a0
jmp 0x2add
callq 0x8880
jmp 0x2adf
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
subq %rax, %rcx
movl $0x1000, %eax           # imm = 0x1000
subq %rcx, %rax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq 0x20b0
movq %rax, -0x48(%rbp)
callq 0x2050
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
callq 0x2050
movl $0x0, (%rax)
cmpq $-0x1, -0x48(%rbp)
jne 0x2bb7
cmpl $0x54, -0x4c(%rbp)
jne 0x2bb7
callq 0x2c10
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x28(%rbp), %rdi
callq 0x2c30
cmpq $-0x1, -0x48(%rbp)
jne 0x2bd4
cmpl $0x16, -0x4c(%rbp)
jne 0x2bf6
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x2bf4
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x22d0
jmp 0x2bfb
jmp 0x2b50
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x2ce4
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movzbl -0x1(%rax), %eax
cmpl $0xa, %eax
jne 0x2ce2
leaq 0x1aa0c(%rip), %rax     # 0x1d6c8
movb 0x14(%rax), %dl
movl $0x9, %eax
movl $0x7e, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0x2c7c
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x2e10
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x2d4b
jmp 0x2d2a
movl -0x24(%rbp), %eax
subl $0xa, %eax
je 0x2d74
jmp 0x2d34
movl -0x24(%rbp), %eax
subl $0xd, %eax
je 0x2d9a
jmp 0x2d3e
movl -0x24(%rbp), %eax
subl $0x5c, %eax
je 0x2dc0
jmp 0x2de6
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x5c, (%rax)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x30, (%rax)
jmp 0x2dfd
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x5c, (%rax)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x6e, (%rax)
jmp 0x2dfd
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x5c, (%rax)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x72, (%rax)
jmp 0x2dfd
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x5c, (%rax)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x5c, (%rax)
jmp 0x2dfd
movq -0x8(%rbp), %rax
movb (%rax), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0x2dff
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x2d0c
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x1040, %rsp           # imm = 0x1040
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x2e60
leaq 0x1a795(%rip), %rax     # 0x1d6c8
movl 0x10(%rax), %edx
leaq 0x373(%rip), %rax       # 0x32b0
leaq 0x14c(%rip), %rcx       # 0x3090
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x18(%rbp)
leaq -0x1020(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x20e0
movq %rax, -0x1028(%rbp)
cmpq $0x0, %rax
je 0x306d
leaq -0x1020(%rbp), %rdi
movq -0x1028(%rbp), %rdx
xorl %esi, %esi
callq 0x2220
cmpq $0x0, %rax
je 0x2f9a
callq 0x3420
leaq -0x1020(%rbp), %rax
movq %rax, -0x1030(%rbp)
movq -0x1030(%rbp), %rdi
movq -0x1028(%rbp), %rdx
movq -0x1030(%rbp), %rax
leaq -0x1020(%rbp), %rcx
subq %rcx, %rax
subq %rax, %rdx
movl $0xa, %esi
callq 0x2220
movq %rax, -0x1038(%rbp)
cmpq $0x0, %rax
je 0x3026
movq -0x1038(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x1038(%rbp)
movq -0x18(%rbp), %rax
movq -0x1030(%rbp), %rdi
movq -0x1038(%rbp), %rsi
movq -0x1030(%rbp), %rcx
subq %rcx, %rsi
movl $0x1, %edx
callq *%rax
movq -0x1038(%rbp), %rax
movq %rax, -0x1030(%rbp)
jmp 0x2fa8
movq -0x1028(%rbp), %rax
movq -0x1030(%rbp), %rcx
leaq -0x1020(%rbp), %rdx
subq %rdx, %rcx
subq %rcx, %rax
movq %rax, -0x1040(%rbp)
cmpq $0x0, -0x1040(%rbp)
je 0x3068
movq -0x18(%rbp), %rax
movq -0x1030(%rbp), %rdi
movq -0x1040(%rbp), %rsi
xorl %edx, %edx
callq *%rax
jmp 0x2f4f
movq -0x10(%rbp), %rdi
callq 0x2120
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
movq %rsi, %rdi
callq *-0x18(%rbp)
xorl %eax, %eax
addq $0x1040, %rsp           # imm = 0x1040
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3321
testb $0x1, 0x9ff3(%rip)      # 0xd2c8
jne 0x331c
leaq 0x1a3ea(%rip), %rax     # 0x1d6c8
testb $0x1, 0x22(%rax)
je 0x32f2
testb $0x1, 0xa320(%rip)      # 0xd60b
jne 0x32f2
callq 0x3ce0
testb $0x1, 0xa2b8(%rip)      # 0xd5b1
jne 0x330e
testb $0x1, 0xa2b0(%rip)      # 0xd5b2
je 0x3309
callq 0x3d30
callq 0x3d60
movb $0x1, 0x9fb3(%rip)      # 0xd2c8
movb $0x0, 0xa2ef(%rip)      # 0xd60b
jmp 0x3419
testb $0x1, 0xa2e3(%rip)      # 0xd60b
je 0x337f
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x9, %eax
je 0x3342
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x7e, %eax
jne 0x3378
movq -0x8(%rbp), %rax
movb $0xa, (%rax)
testb $0x1, -0x11(%rbp)
je 0x335b
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4310
movb -0x11(%rbp), %al
andb $0x1, %al
movb %al, 0xa298(%rip)       # 0xd60b
jmp 0x3419
callq 0x3d60
jmp 0x337f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x3e50
testb $0x1, %al
jne 0x339a
jmp 0x339c
jmp 0x3419
testb $0x1, -0x11(%rbp)
je 0x33ae
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0xa1fd(%rip)      # 0xd5b2
je 0x3401
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
leaq 0xa1e7(%rip), %rcx      # 0xd5b2
xorl %eax, %eax
movl %eax, %r8d
callq 0x6880
testb $0x1, %al
jne 0x33de
callq 0x4110
testb $0x1, 0xa1cd(%rip)      # 0xd5b2
je 0x33f2
testb $0x1, -0x11(%rbp)
je 0x33f2
callq 0x4110
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x4140
jmp 0x340e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4310
movb -0x11(%rbp), %al
andb $0x1, %al
movb %al, 0xa1f2(%rip)       # 0xd60b
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x2e60
leaq -0x1010(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x20e0
movq %rax, -0x1018(%rbp)
cmpq $0x0, %rax
je 0x3557
leaq -0x1010(%rbp), %rax
movq %rax, -0x1020(%rbp)
movq -0x1020(%rbp), %rdi
movq -0x1018(%rbp), %rdx
movq -0x1020(%rbp), %rax
leaq -0x1010(%rbp), %rcx
subq %rcx, %rax
subq %rax, %rdx
xorl %esi, %esi
callq 0x2220
movq %rax, -0x1028(%rbp)
cmpq $0x0, %rax
je 0x3511
movq -0x1020(%rbp), %rdi
movq -0x1028(%rbp), %rsi
movq -0x1020(%rbp), %rax
subq %rax, %rsi
movl $0x1, %edx
callq 0x3580
movq -0x1028(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x1020(%rbp)
jmp 0x34a5
movq -0x1018(%rbp), %rax
movq -0x1020(%rbp), %rcx
leaq -0x1010(%rbp), %rdx
subq %rdx, %rcx
subq %rcx, %rax
movq %rax, -0x1030(%rbp)
cmpq $0x0, -0x1030(%rbp)
je 0x3552
movq -0x1020(%rbp), %rdi
movq -0x1030(%rbp), %rsi
xorl %edx, %edx
callq 0x3580
jmp 0x346c
movq -0x10(%rbp), %rdi
callq 0x2120
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
movq %rsi, %rdi
callq 0x3580
xorl %eax, %eax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x35cf
testb $0x1, 0x9d23(%rip)      # 0xd2c8
jne 0x35ca
testb $0x1, 0xa003(%rip)      # 0xd5b1
jne 0x35c3
testb $0x1, 0x9ffb(%rip)      # 0xd5b2
je 0x35be
callq 0x3d30
callq 0x3d60
movb $0x1, 0x9cfe(%rip)      # 0xd2c8
jmp 0x3657
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x3e50
testb $0x1, %al
jne 0x35ea
jmp 0x35ec
jmp 0x3657
testb $0x1, 0x9fbf(%rip)      # 0xd5b2
je 0x363f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
leaq 0x9fa9(%rip), %rcx      # 0xd5b2
xorl %eax, %eax
movl %eax, %r8d
callq 0x6880
testb $0x1, %al
jne 0x361c
callq 0x4110
testb $0x1, 0x9f8f(%rip)      # 0xd5b2
je 0x3630
testb $0x1, -0x11(%rbp)
je 0x3630
callq 0x3d30
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x4140
jmp 0x364c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4310
testb $0x1, -0x11(%rbp)
je 0x3657
callq 0x3d60
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hcmiya[P]opuscomment/src/parse-tags.c
// Function: parse_tags
void *parse_tags(void* nouse_) {
	bool do_read = true;
	if (tagnum) {
		// -tでタグを追加した場合、-cが無ければstdinを使わない
		if (!O.tag_filename) {
			do_read = false;
		}
	}
	if (O.tag_filename && strcmp(O.tag_filename, "-") != 0) {
		from_file = true;
		edit_input = fopen(O.tag_filename, "r");
		if (!edit_input) {
			fileerror(O.tag_filename);
		}
	}
	else {
		edit_input = stdin;
	}
	
	if (do_read) {
		// UTF-8化された文字列をチャンク化する処理をスレッド化(化が多い)
		int pfd[2];
		pipe(pfd);
		FILE *fpu8 = fdopen(pfd[0], "r");
		pthread_t split_thread;
		void *(*split)(void*) = O.tag_escape == TAG_ESCAPE_NUL ? split_binary : split_text;
		pthread_create(&split_thread, NULL, split, fpu8);
		
		// 本スレッドはstdinをUTF-8化する
		toutf8(pfd[1]);
		pthread_join(split_thread, NULL);
	}
	
	struct edit_st *rtn = calloc(1, sizeof(*rtn));
	rtn->str = strstore;
	rtn->len = strcount;
	rtn->pict = flacpict;
	rtn->num = tagnum;
	return rtn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movb $0x1, -0x9(%rbp)
cmpq $0x0, 0x9f20(%rip)      # 0xd598
je 0x368e
leaq 0x1a047(%rip), %rax     # 0x1d6c8
cmpq $0x0, 0x18(%rax)
jne 0x368c
movb $0x0, -0x9(%rbp)
jmp 0x368e
leaq 0x1a033(%rip), %rax     # 0x1d6c8
cmpq $0x0, 0x18(%rax)
je 0x36f9
leaq 0x1a025(%rip), %rax     # 0x1d6c8
movq 0x18(%rax), %rdi
leaq 0x6991(%rip), %rsi      # 0xa03f
callq 0x2270
cmpl $0x0, %eax
je 0x36f9
movb $0x1, 0x9ee1(%rip)      # 0xd5a0
leaq 0x1a002(%rip), %rax     # 0x1d6c8
movq 0x18(%rax), %rdi
leaq 0x69ae(%rip), %rsi      # 0xa07f
callq 0x23e0
movq %rax, 0x9ecb(%rip)      # 0xd5a8
cmpq $0x0, 0x9ec3(%rip)      # 0xd5a8
jne 0x36f7
leaq 0x19fda(%rip), %rax     # 0x1d6c8
movq 0x18(%rax), %rdi
callq 0x8960
jmp 0x370a
movq 0x98c8(%rip), %rax      # 0xcfc8
movq (%rax), %rax
movq %rax, 0x9e9e(%rip)      # 0xd5a8
testb $0x1, -0x9(%rbp)
je 0x3779
leaq -0x14(%rbp), %rdi
callq 0x2200
movl -0x14(%rbp), %edi
leaq 0x695c(%rip), %rsi      # 0xa07f
callq 0x2360
movq %rax, -0x20(%rbp)
leaq 0x19f95(%rip), %rax     # 0x1d6c8
movl 0x10(%rax), %edx
leaq -0x82d(%rip), %rax      # 0x2f10
leaq -0x2f4(%rip), %rcx      # 0x3450
cmpl $0x2, %edx
cmoveq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x23b0
movl -0x10(%rbp), %edi
callq 0x37e0
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x24c0
movl $0x1, %edi
movl $0x20, %esi
callq 0x2250
movq %rax, -0x38(%rbp)
movq 0x9ded(%rip), %rcx      # 0xd580
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq 0x9de7(%rip), %rcx      # 0xd588
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x9de0(%rip), %rcx      # 0xd590
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0x9dd9(%rip), %rcx      # 0xd598
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x1050, %rsp           # imm = 0x1050
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2130
movq %rax, -0x20(%rbp)
movq $-0x1, %rax
cmpq %rax, 0x976b(%rip)      # 0xd2c0
jne 0x3b77
movl $0xe, %edi
callq 0x2320
movq %rax, %rsi
leaq 0x6499(%rip), %rdi      # 0xa004
callq 0x2a50
movq %rax, 0x9749(%rip)      # 0xd2c0
movl -0x4(%rbp), %eax
movl %eax, -0x104c(%rbp)
subl $0x64, %eax
je 0x3ba6
jmp 0x3b87
movl -0x104c(%rbp), %eax
subl $0x74, %eax
jne 0x3bb1
jmp 0x3b94
callq 0x2e60
leaq -0x620(%rip), %rax      # 0x3580
movq %rax, -0x28(%rbp)
jmp 0x3bb1
leaq 0x4033(%rip), %rax      # 0x7be0
movq %rax, -0x28(%rbp)
jmp 0x3bb3
cmpq $0x0, -0x20(%rbp)
je 0x3c40
movq $0x1000, -0x1038(%rbp) # imm = 0x1000
leaq -0x1030(%rbp), %rax
movq %rax, -0x1040(%rbp)
movq 0x96e2(%rip), %rdi      # 0xd2c0
leaq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x1040(%rbp), %rcx
leaq -0x1038(%rbp), %r8
callq 0x20b0
movq %rax, -0x1048(%rbp)
cmpq $-0x1, -0x1048(%rbp)
jne 0x3c1b
callq 0x2050
cmpl $0x7, (%rax)
je 0x3c19
callq 0x8880
jmp 0x3c1b
movq -0x28(%rbp), %rax
leaq -0x1030(%rbp), %rdi
movq -0x1040(%rbp), %rsi
leaq -0x1030(%rbp), %rcx
subq %rcx, %rsi
xorl %edx, %edx
callq *%rax
jmp 0x3bb3
leaq -0x1030(%rbp), %rax
movq %rax, -0x1040(%rbp)
movq $0x1000, -0x1038(%rbp) # imm = 0x1000
movq 0x9660(%rip), %rdi      # 0xd2c0
xorl %eax, %eax
movl %eax, %edx
leaq -0x1040(%rbp), %rcx
leaq -0x1038(%rbp), %r8
movq %rdx, %rsi
callq 0x20b0
cmpq $-0x1, %rax
jne 0x3c85
callq 0x8880
movq -0x28(%rbp), %rax
leaq -0x1030(%rbp), %rdi
movq -0x1040(%rbp), %rsi
leaq -0x1030(%rbp), %rcx
subq %rcx, %rsi
movl $0x1, %edx
callq *%rax
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
movq %rsi, %rdi
callq *-0x28(%rbp)
addq $0x1050, %rsp           # imm = 0x1050
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testb $0x1, 0x9844(%rip)      # 0xd5b3
je 0x3e0a
movsbl 0x9838(%rip), %eax      # 0xd5b4
cmpl $0x0, %eax
je 0x3d86
callq 0x4420
movq 0x9803(%rip), %rdi      # 0xd590
callq 0x22b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
subq 0x9817(%rip), %rax      # 0xd5b8
subq $0x4, %rax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
orl $0x6000000, %edi        # imm = 0x6000000
callq 0x24d0
movl %eax, -0xc(%rbp)
movq 0x97d0(%rip), %rdi      # 0xd590
movq 0x97f1(%rip), %rsi      # 0xd5b8
xorl %edx, %edx
callq 0x2340
movq 0x97bb(%rip), %rcx      # 0xd590
leaq -0xc(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x2490
movq 0x97a1(%rip), %rdi      # 0xd590
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x2340
movq -0x8(%rbp), %rax
movq %rax, 0x97b0(%rip)      # 0xd5b8
jmp 0x3e39
movq 0x9777(%rip), %rcx      # 0xd588
leaq 0x97a8(%rip), %rdi      # 0xd5c0
movl $0x4, %esi
movl $0x1, %edx
callq 0x2490
movq 0x976a(%rip), %rax      # 0xd598
addq $0x1, %rax
movq %rax, 0x975f(%rip)      # 0xd598
movb $0x1, 0x9488(%rip)      # 0xd2c8
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)