LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/obo_stanza.c
// Function: gt_obo_stanza_get_value
const char* gt_obo_stanza_get_value(const GtOBOStanza *obo_stanza,
                                    const char *stanza_key,
                                    GtUword num)
{
  GtStrArray *sa;
  gt_assert(obo_stanza);
  if ((sa = gt_hashmap_get(obo_stanza->content, stanza_key)))
    return gt_str_array_get(sa, num);
  return NULL;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x340793
movq %rdx, %rbx
movq 0x8(%rdi), %rdi
callq 0x100add
testq %rax, %rax
je 0x34078f
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x11bfb3
xorl %eax, %eax
popq %rbx
retq
callq 0x9751c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/obo_stanza.c
// Function: gt_obo_stanza_size
GtUword gt_obo_stanza_size(const GtOBOStanza *obo_stanza,
                                 const char *stanza_key)
{
  GtStrArray *sa;
  gt_assert(obo_stanza);
  if ((sa = gt_hashmap_get(obo_stanza->content, stanza_key)))
    return gt_str_array_size(sa);
  return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x3407b9
movq 0x8(%rdi), %rdi
callq 0x100add
testq %rax, %rax
je 0x3407b5
movq %rax, %rdi
popq %rax
jmp 0x11c131
xorl %eax, %eax
popq %rcx
retq
callq 0x97553
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/firstcodes-psbuf.c
// Function: gt_leftborderbuffer_new
GtLeftborderOutbuffer *gt_leftborderbuffer_new(const char *name,
                                               GtFirstcodesspacelog *fcsl)
{
  GtLeftborderOutbuffer *lbbuf = gt_malloc(sizeof (*lbbuf));

  lbbuf->totalwrite = 0;
  lbbuf->outfilename = gt_str_new();
  lbbuf->fp = gt_xtmpfp(lbbuf->outfilename);
  lbbuf->nextfree = 0;
  lbbuf->allocated = 1024UL;
  lbbuf->name = gt_str_new_cstr(name);
  lbbuf->spaceuint32_t = gt_malloc(sizeof (*lbbuf->spaceuint32_t) *
                                   lbbuf->allocated);
  GT_FCI_ADDWORKSPACE(fcsl,name,
                      sizeof (*lbbuf->spaceuint32_t) * lbbuf->allocated);
  return lbbuf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa9a0d(%rip), %r15     # 0x3ea20b
movl $0x38, %edi
movq %r15, %rsi
movl $0x1f, %edx
callq 0x104226
movq %rax, %r12
xorl %r13d, %r13d
movq %r13, 0x18(%rax)
callq 0x11ac6c
movq %rax, 0x20(%r12)
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
movl $0x23, %ecx
callq 0xfd35a
movq %rax, 0x30(%r12)
movq %r13, 0x8(%r12)
movq $0x400, 0x10(%r12)      # imm = 0x400
movq %rbx, %rdi
callq 0x11acc9
movq %rax, 0x28(%r12)
movq 0x10(%r12), %rdi
shlq $0x2, %rdi
movq %r15, %rsi
movl $0x28, %edx
callq 0x104226
movq %rax, (%r12)
movq 0x10(%r12), %rax
shlq $0x2, %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl $0x2a, %esi
movq %r15, %rdx
movl $0x1, %ecx
movq %rbx, %r8
movl $0x1, %r9d
callq 0x316945
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/firstcodes-psbuf.c
// Function: gt_leftborderbuffer_flush
void gt_leftborderbuffer_flush(GtLeftborderOutbuffer *leftborderbuffer)
{
  gt_xfwrite(leftborderbuffer->spaceuint32_t,
             sizeof (*leftborderbuffer->spaceuint32_t),
             (size_t) leftborderbuffer->nextfree,
             leftborderbuffer->fp);
  leftborderbuffer->totalwrite += leftborderbuffer->nextfree;
  leftborderbuffer->nextfree = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rdx
movq 0x30(%rbx), %rcx
movl $0x4, %esi
callq 0x11f89c
movq 0x8(%rbx), %rax
addq %rax, 0x18(%rbx)
movq $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/firstcodes-psbuf.c
// Function: gt_leftborderbuffer_delete
GtStr *gt_leftborderbuffer_delete(GtLeftborderOutbuffer *lbbuf,
                                  GtFirstcodesspacelog *fcsl,
                                  GT_UNUSED GtUword expectedwritten)
{
  GtStr *outfilename;

  gt_assert(lbbuf != NULL);
  gt_leftborderbuffer_flush(lbbuf);
  gt_fa_fclose(lbbuf->fp);
  lbbuf->fp = NULL;
  gt_log_log("write %s to file %s ("GT_WU" units of size %u)",
             gt_str_get(lbbuf->name),
             gt_str_get(lbbuf->outfilename),
             lbbuf->totalwrite,(unsigned int) sizeof (*lbbuf->spaceuint32_t));
  gt_assert(lbbuf->spaceuint32_t != NULL);
  gt_free(lbbuf->spaceuint32_t);
  GT_FCI_SUBTRACTWORKSPACE(fcsl,gt_str_get(lbbuf->name));
  gt_assert(lbbuf->totalwrite == expectedwritten);
  outfilename = lbbuf->outfilename;
  gt_str_delete(lbbuf->name);
  gt_free(lbbuf);
  return outfilename;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3409d3
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rdx
movq 0x30(%rbx), %rcx
movl $0x4, %esi
callq 0x11f89c
movq 0x8(%rbx), %rax
movq 0x30(%rbx), %rdi
addq %rax, 0x18(%rbx)
xorl %r12d, %r12d
movq %r12, 0x8(%rbx)
callq 0xfd018
movq %r12, 0x30(%rbx)
movq 0x28(%rbx), %rdi
callq 0x11b0a1
movq %rax, %r12
movq 0x20(%rbx), %rdi
callq 0x11b0a1
movq 0x18(%rbx), %rcx
leaq 0xa990f(%rip), %rdi     # 0x3ea251
movq %r12, %rsi
movq %rax, %rdx
movl $0x4, %r8d
xorl %eax, %eax
callq 0x103d72
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3409d8
leaq 0xa98a7(%rip), %r12     # 0x3ea20b
movq %r12, %rsi
movl $0x47, %edx
callq 0x1045eb
movq 0x28(%rbx), %rdi
callq 0x11b0a1
movq $0x0, (%rsp)
movq %r15, %rdi
movl $0x48, %esi
movq %r12, %rdx
xorl %ecx, %ecx
movq %rax, %r8
movl $0x1, %r9d
callq 0x316945
cmpq %r14, 0x18(%rbx)
jne 0x3409dd
movq 0x20(%rbx), %r14
movq 0x28(%rbx), %rdi
callq 0x11bdbf
leaq 0xa9854(%rip), %rsi     # 0x3ea20b
movq %rbx, %rdi
movl $0x4c, %edx
callq 0x1045eb
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x97666
callq 0x9762f
callq 0x975f8
nop
// File: /workspace/github_c_makefile_star2_O3/nurse[P]nkf/nkf.c
// Function: s_iconv
static nkf_char
s_iconv(ARG_UNUSED nkf_char c2, nkf_char c1, ARG_UNUSED nkf_char c0)
{
    if (c2 == JIS_X_0201_1976_K || (0xA1 <= c2 && c2 <= 0xDF)) {
	if (iso2022jp_f && !x0201_f) {
	    c2 = GETA1; c1 = GETA2;
	} else {
	    c1 &= 0x7f;
	}
    } else if ((c2 == EOF) || (c2 == 0) || c2 < SP) {
	/* NOP */
    } else if (!x0213_f && 0xF0 <= c2 && c2 <= 0xF9 && 0x40 <= c1 && c1 <= 0xFC) {
	/* CP932 UDC */
	if(c1 == 0x7F) return 0;
	c1 = nkf_char_unicode_new((c2 - 0xF0) * 188 + (c1 - 0x40 - (0x7E < c1)) + 0xE000);
	c2 = 0;
    } else {
	nkf_char ret = s2e_conv(c2, c1, &c2, &c1);
	if (ret) return ret;
    }
    (*oconv)(c2, c1);
    return 0;
}

// Assembly:
pushq %rax
movl %edi, 0x4(%rsp)
movl %esi, (%rsp)
cmpl $0x1013, %edi           # imm = 0x1013
setne %al
leal -0xa1(%rdi), %ecx
cmpl $0x3f, %ecx
setae %cl
testb %cl, %al
jne 0xcbd5
cmpb $0x1, 0x48851(%rip)     # 0x55400
jne 0xcc29
cmpl $0x0, 0x406f8(%rip)     # 0x4d2b0
jne 0xcc29
movl $0x22, 0x4(%rsp)
movl $0x2e, (%rsp)
movl $0x22, %edi
movl $0x2e, %esi
jmp 0xcc2f
cmpl $0x20, %edi
jl 0xcc2f
leal -0x40(%rsi), %ecx
cmpl $0xbc, %ecx
ja 0xcc39
leal -0xf0(%rdi), %eax
cmpl $0x9, %eax
ja 0xcc39
testb $0x1, 0x407c5(%rip)     # 0x4d3bc
jne 0xcc39
xorl %eax, %eax
cmpl $0x7f, %esi
je 0xcc37
imull $0xbc, %edi, %eax
addl %ecx, %eax
cmpl $0x7f, %esi
adcl $-0x1, %eax
addl $0x2fc0, %eax           # imm = 0x2FC0
orl $0x1000000, %eax        # imm = 0x1000000
movl %eax, (%rsp)
movl $0x0, 0x4(%rsp)
xorl %edi, %edi
movl %eax, %esi
jmp 0xcc2f
andl $0x7f, %esi
movl %esi, (%rsp)
callq *0x40683(%rip)          # 0x4d2b8
xorl %eax, %eax
popq %rcx
retq
leaq 0x4(%rsp), %rdx
movq %rsp, %rcx
callq 0x1108d
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0xcc37
movl 0x4(%rsp), %edi
movl (%rsp), %esi
jmp 0xcc2f
// File: /workspace/github_c_makefile_star2_O3/nurse[P]nkf/nkf.c
// Function: w_oconv
static void
w_oconv(nkf_char c2, nkf_char c1)
{
    nkf_char c3, c4;
    nkf_char val, val2;

    if (output_bom_f) {
	output_bom_f = FALSE;
	(*o_putc)('\357');
	(*o_putc)('\273');
	(*o_putc)('\277');
    }

    if (c2 == EOF) {
	(*o_putc)(EOF);
	return;
    }

    if (c2 == 0 && nkf_char_unicode_p(c1)){
	val = c1 & VALUE_MASK;
	OUTPUT_UTF8(val);
	return;
    }

    if (c2 == 0) {
	(*o_putc)(c1);
    } else {
	val = e2w_conv(c2, c1);
	if (val){
	    val2 = e2w_combining(val, c2, c1);
	    if (val2)
		OUTPUT_UTF8(val2);
	    OUTPUT_UTF8(val);
	}
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %r14d
movl %edi, %ebp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
cmpb $0x1, 0x48412(%rip)     # 0x55530
jne 0xd148
movb $0x0, 0x48409(%rip)     # 0x55530
movl $0xffffffef, %edi       # imm = 0xFFFFFFEF
callq *0x40196(%rip)          # 0x4d2c8
movl $0xffffffbb, %edi       # imm = 0xFFFFFFBB
callq *0x4018b(%rip)          # 0x4d2c8
movl $0xffffffbf, %edi       # imm = 0xFFFFFFBF
callq *0x40180(%rip)          # 0x4d2c8
cmpl $-0x1, %ebp
je 0xd26a
testl %ebp, %ebp
jne 0xd198
movl %r14d, %eax
andl $0xff000000, %eax       # imm = 0xFF000000
cmpl $0x1000000, %eax        # imm = 0x1000000
jne 0xd267
andl $0xffffff, %r14d        # imm = 0xFFFFFF
leaq 0x10(%rsp), %rbx
leaq 0x14(%rsp), %r15
leaq 0xc(%rsp), %rcx
leaq 0x8(%rsp), %r8
movl %r14d, %edi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x11b58
movl (%rbx), %edi
jmp 0xd233
movl %ebp, %edi
movl %r14d, %esi
callq 0x11d0f
testl %eax, %eax
je 0xd25c
movl %eax, %ebx
movl %eax, %edi
movl %ebp, %esi
movl %r14d, %edx
callq 0x11ef5
testl %eax, %eax
je 0xd20f
leaq 0x10(%rsp), %r14
leaq 0x14(%rsp), %r15
leaq 0xc(%rsp), %rcx
leaq 0x8(%rsp), %r8
movl %eax, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x11b58
movl (%r14), %edi
callq *0x400e2(%rip)          # 0x4d2c8
movl (%r15), %edi
testl %edi, %edi
je 0xd1f3
callq *0x400d5(%rip)          # 0x4d2c8
movl 0xc(%rsp), %edi
testl %edi, %edi
je 0xd201
callq *0x400c7(%rip)          # 0x4d2c8
movl 0x8(%rsp), %edi
testl %edi, %edi
je 0xd20f
callq *0x400b9(%rip)          # 0x4d2c8
leaq 0x10(%rsp), %r14
leaq 0x14(%rsp), %r15
leaq 0xc(%rsp), %rcx
leaq 0x8(%rsp), %r8
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x11b58
movl (%r14), %edi
callq *0x4008f(%rip)          # 0x4d2c8
movl (%r15), %edi
testl %edi, %edi
je 0xd246
callq *0x40082(%rip)          # 0x4d2c8
movl 0xc(%rsp), %edi
testl %edi, %edi
je 0xd254
callq *0x40074(%rip)          # 0x4d2c8
movl 0x8(%rsp), %ebp
testl %ebp, %ebp
jne 0xd26a
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %r14d, %ebp
movl %ebp, %edi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *0x4004c(%rip)          # 0x4d2c8
// File: /workspace/github_c_makefile_star2_O3/nurse[P]nkf/nkf.c
// Function: w_oconv32
static void
w_oconv32(nkf_char c2, nkf_char c1)
{
    if (output_bom_f) {
	output_bom_f = FALSE;
	if (output_endian == ENDIAN_LITTLE){
	    (*o_putc)(0xFF);
	    (*o_putc)(0xFE);
	    (*o_putc)(0);
	    (*o_putc)(0);
	}else{
	    (*o_putc)(0);
	    (*o_putc)(0);
	    (*o_putc)(0xFE);
	    (*o_putc)(0xFF);
	}
    }

    if (c2 == EOF) {
	(*o_putc)(EOF);
	return;
    }

    if (c2 == ISO_8859_1) {
	c1 |= 0x80;
    } else if (c2 == 0 && nkf_char_unicode_p(c1)) {
	c1 &= VALUE_MASK;
    } else if (c2) {
	nkf_char val, val2;
	val = e2w_conv(c2, c1);
	if (!val) return;
	val2 = e2w_combining(val, c2, c1);
	if (val2)
	    OUTPUT_UTF32(val2);
	c1 = val;
    }
    OUTPUT_UTF32(c1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movl %edi, %r14d
cmpb $0x1, 0x4802f(%rip)     # 0x55530
jne 0xd557
movb $0x0, 0x48026(%rip)     # 0x55530
xorl %eax, %eax
cmpb $0x0, 0x48021(%rip)     # 0x55534
movl $0xff, %ebx
movl $0x0, %edi
cmovnel %ebx, %edi
movl $0xfe, %r15d
movl $0x0, %r12d
cmovnel %r15d, %r12d
cmovnel %eax, %r15d
cmovnel %eax, %ebx
callq *0x3fd8b(%rip)          # 0x4d2c8
movl %r12d, %edi
callq *0x3fd82(%rip)          # 0x4d2c8
movl %r15d, %edi
callq *0x3fd79(%rip)          # 0x4d2c8
movl %ebx, %edi
callq *0x3fd71(%rip)          # 0x4d2c8
cmpl $0x1, %r14d
je 0xd56f
testl %r14d, %r14d
je 0xd575
cmpl $-0x1, %r14d
jne 0xd5e5
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
jmp 0xd5d7
orl $0x80, %ebp
movl %ebp, %ebx
movq 0x3fd4a(%rip), %rax     # 0x4d2c8
cmpb $0x1, 0x47faf(%rip)     # 0x55534
jne 0xd5b0
movl $0xff, %ebp
movl %ebx, %edi
andl %ebp, %edi
callq *%rax
movl %ebx, %edi
shrl $0x8, %edi
andl %ebp, %edi
callq *0x3fd29(%rip)          # 0x4d2c8
shrl $0x10, %ebx
andl %ebp, %ebx
movl %ebx, %edi
callq *0x3fd1c(%rip)          # 0x4d2c8
xorl %edi, %edi
jmp 0xd5d7
xorl %edi, %edi
callq *%rax
movl %ebx, %edi
shrl $0x10, %edi
movl $0xff, %ebp
andl %ebp, %edi
callq *0x3fd02(%rip)          # 0x4d2c8
movl %ebx, %edi
shrl $0x8, %edi
andl %ebp, %edi
callq *0x3fcf5(%rip)          # 0x4d2c8
andl %ebp, %ebx
movl %ebx, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *0x3fce3(%rip)          # 0x4d2c8
movl %r14d, %edi
movl %ebp, %esi
callq 0x11d0f
testl %eax, %eax
je 0xd638
movl %eax, %ebx
movl %eax, %edi
movl %r14d, %esi
movl %ebp, %edx
callq 0x11ef5
testl %eax, %eax
je 0xd577
movl %eax, %ebp
movq 0x3fcb6(%rip), %rax     # 0x4d2c8
cmpb $0x1, 0x47f1b(%rip)     # 0x55534
jne 0xd641
movzbl %bpl, %edi
callq *%rax
shrl $0x8, %ebp
movl %ebp, %edi
callq *0x3fc9c(%rip)          # 0x4d2c8
xorl %edi, %edi
callq *0x3fc94(%rip)          # 0x4d2c8
xorl %edi, %edi
jmp 0xd65c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
callq *%rax
xorl %edi, %edi
callq *0x3fc7b(%rip)          # 0x4d2c8
movl %ebp, %edi
shrl $0x8, %edi
callq *0x3fc70(%rip)          # 0x4d2c8
movzbl %bpl, %edi
callq *0x3fc66(%rip)          # 0x4d2c8
jmp 0xd577
// File: /workspace/github_c_makefile_star2_O3/nurse[P]nkf/nkf.c
// Function: e_status
static void
e_status(struct input_code *ptr, nkf_char c)
{
    switch (ptr->stat){
    case -1:
	status_check(ptr, c);
	break;
    case 0:
	if (c <= DEL){
	    break;
	}else if (nkf_char_unicode_p(c)){
	    break;
	}else if (SS2 == c || (0xa1 <= c && c <= 0xfe)){
	    ptr->stat = 1;
	    status_push_ch(ptr, c);
#ifdef X0212_ENABLE
	}else if (0x8f == c){
	    ptr->stat = 2;
	    status_push_ch(ptr, c);
#endif /* X0212_ENABLE */
	}else{
	    status_disable(ptr);
	}
	break;
    case 1:
	if (0xa1 <= c && c <= 0xfe){
	    status_push_ch(ptr, c);
	    code_score(ptr);
	    status_clear(ptr);
	}else{
	    status_disable(ptr);
	}
	break;
#ifdef X0212_ENABLE
    case 2:
	if (0xa1 <= c && c <= 0xfe){
	    ptr->stat = 1;
	    status_push_ch(ptr, c);
	}else{
	    status_disable(ptr);
	}
#endif /* X0212_ENABLE */
    }
}

// Assembly:
pushq %rbx
movl 0x8(%rdi), %eax
incl %eax
cmpl $0x3, %eax
ja 0xd747
movq %rdi, %rbx
leaq 0x99c4(%rip), %rcx      # 0x17044
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x7f, %esi
jg 0xd747
cmpl $0x0, 0x47d8f(%rip)     # 0x55428
je 0xd747
movabsq $0x8000000000, %rax     # imm = 0x8000000000
movq %rax, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
jmp 0xd747
leal -0xa1(%rsi), %eax
cmpl $0x5d, %eax
ja 0xd6ef
movslq 0x10(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x10(%rbx)
movl %esi, 0x14(%rbx,%rax,4)
movq %rbx, %rdi
callq 0x11f47
xorl %eax, %eax
movl %eax, 0x8(%rbx)
movl %eax, 0x10(%rbx)
jmp 0xd747
leal -0xa1(%rsi), %eax
cmpl $0x5d, %eax
jbe 0xd732
movq %rbx, %rdi
popq %rbx
jmp 0x11ff8
cmpl $0x80, %esi
setl %al
movl %esi, %ecx
andl $0x7f000000, %ecx       # imm = 0x7F000000
cmpl $0x1000000, %ecx        # imm = 0x1000000
sete %cl
orb %al, %cl
jne 0xd747
cmpl $0x8e, %esi
sete %al
leal -0xa1(%rsi), %ecx
cmpl $0x5e, %ecx
setb %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xd749
movl $0x1, 0x8(%rbx)
movslq 0x10(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x10(%rbx)
movl %esi, 0x14(%rbx,%rax,4)
popq %rbx
retq
cmpl $0x8f, %esi
jne 0xd6ef
movl $0x2, 0x8(%rbx)
movslq 0x10(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x10(%rbx)
movl $0x8f, 0x14(%rbx,%rax,4)
jmp 0xd747
// File: /workspace/github_c_makefile_star2_O3/nurse[P]nkf/nkf.c
// Function: w_status
static void
w_status(struct input_code *ptr, nkf_char c)
{
    switch (ptr->stat){
    case -1:
	status_check(ptr, c);
	break;
    case 0:
	if (c <= DEL){
	    break;
	}else if (nkf_char_unicode_p(c)){
	    break;
	}else if (0xc0 <= c && c <= 0xdf){
	    ptr->stat = 1;
	    status_push_ch(ptr, c);
	}else if (0xe0 <= c && c <= 0xef){
	    ptr->stat = 2;
	    status_push_ch(ptr, c);
	}else if (0xf0 <= c && c <= 0xf4){
	    ptr->stat = 3;
	    status_push_ch(ptr, c);
	}else{
	    status_disable(ptr);
	}
	break;
    case 1:
    case 2:
	if (0x80 <= c && c <= 0xbf){
	    status_push_ch(ptr, c);
	    if (ptr->index > ptr->stat){
		int bom = (ptr->buf[0] == 0xef && ptr->buf[1] == 0xbb
			   && ptr->buf[2] == 0xbf);
		w2e_conv(ptr->buf[0], ptr->buf[1], ptr->buf[2],
			 &ptr->buf[0], &ptr->buf[1]);
		if (!bom){
		    code_score(ptr);
		}
		status_clear(ptr);
	    }
	}else{
	    status_disable(ptr);
	}
	break;
    case 3:
	if (0x80 <= c && c <= 0xbf){
	    if (ptr->index < ptr->stat){
		status_push_ch(ptr, c);
	    } else {
		status_clear(ptr);
	    }
	}else{
	    status_disable(ptr);
	}
	break;
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
incl %eax
cmpl $0x4, %eax
ja 0xdac6
movq %rdi, %rbx
leaq 0x96f8(%rip), %rcx      # 0x17068
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl %esi, %eax
andl $-0x40, %eax
cmpl $0x80, %eax
jne 0xdacd
movslq 0x10(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x10(%rbx)
movl %esi, 0x14(%rbx,%rax,4)
movl 0x10(%rbx), %eax
cmpl 0x8(%rbx), %eax
jle 0xdac6
leaq 0x14(%rbx), %rcx
movl 0x14(%rbx), %edi
movl 0x18(%rbx), %esi
movl %edi, %eax
xorl $0xef, %eax
leaq 0x18(%rbx), %r8
movl %esi, %edx
xorl $0xbb, %edx
orl %eax, %edx
jne 0xda8c
movl 0x1c(%rbx), %ebp
movl $0xef, %edi
movl $0xbb, %esi
movl %ebp, %edx
callq 0x11357
cmpl $0xbf, %ebp
jne 0xda94
jmp 0xda9c
movl %esi, %eax
andl $-0x40, %eax
cmpl $0x80, %eax
jne 0xdacd
movslq 0x10(%rbx), %rax
cmpq $0x2, %rax
jg 0xda9c
jmp 0xdabc
cmpl $0x7f, %esi
jg 0xdac6
cmpl $0x0, 0x47a08(%rip)     # 0x55428
je 0xdac6
movabsq $0x8000000000, %rax     # imm = 0x8000000000
movq %rax, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
jmp 0xdac6
cmpl $0x80, %esi
setl %al
movl %esi, %ecx
andl $0x7f000000, %ecx       # imm = 0x7F000000
cmpl $0x1000000, %ecx        # imm = 0x1000000
sete %cl
orb %al, %cl
jne 0xdac6
movl %esi, %eax
andl $0x7fffffe0, %eax       # imm = 0x7FFFFFE0
cmpl $0xc0, %eax
jne 0xda75
movl $0x1, 0x8(%rbx)
jmp 0xdab8
movl %esi, %eax
andl $0x7ffffff0, %eax       # imm = 0x7FFFFFF0
cmpl $0xe0, %eax
jne 0xdaa6
movl $0x2, 0x8(%rbx)
jmp 0xdab8
movl 0x1c(%rbx), %edx
callq 0x11357
movq %rbx, %rdi
callq 0x11f47
xorl %eax, %eax
movl %eax, 0x8(%rbx)
movl %eax, 0x10(%rbx)
jmp 0xdac6
leal -0xf0(%rsi), %eax
cmpl $0x4, %eax
ja 0xdacd
movl $0x3, 0x8(%rbx)
movslq 0x10(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x10(%rbx)
movl %esi, 0x14(%rbx,%rax,4)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x11ff8
// File: /workspace/github_c_makefile_star2_O3/nurse[P]nkf/nkf.c
// Function: nkf_state_init
static void
nkf_state_init(void)
{
    if (nkf_state) {
	nkf_buf_clear(nkf_state->std_gc_buf);
	nkf_buf_clear(nkf_state->broken_buf);
	nkf_buf_clear(nkf_state->nfc_buf);
    }
    else {
	nkf_state = nkf_xmalloc(sizeof(nkf_state_t));
	nkf_state->std_gc_buf = nkf_buf_new(STD_GC_BUFSIZE);
	nkf_state->broken_buf = nkf_buf_new(3);
	nkf_state->nfc_buf = nkf_buf_new(9);
    }
    nkf_state->broken_state = 0;
    nkf_state->mimeout_state = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x462c0(%rip), %rax     # 0x55538
testq %rax, %rax
je 0xf29b
movq (%rax), %rcx
xorl %edx, %edx
movq %rdx, 0x8(%rcx)
movq 0x10(%rax), %rcx
movq %rdx, 0x8(%rcx)
movq 0x20(%rax), %rcx
movq %rdx, 0x8(%rcx)
jmp 0xf341
movl $0x28, %edi
callq 0x10f16
movq %rax, 0x4628c(%rip)     # 0x55538
movl $0x18, %edi
callq 0x10f16
movq %rax, %rbx
movl $0x400, %edi            # imm = 0x400
callq 0x10f16
movq %rax, 0x10(%rbx)
movq $0x100, (%rbx)          # imm = 0x100
xorl %r14d, %r14d
movq %r14, 0x8(%rbx)
movq 0x4625c(%rip), %rax     # 0x55538
movq %rbx, (%rax)
movl $0x18, %edi
callq 0x10f16
movq %rax, %rbx
movl $0xc, %edi
callq 0x10f16
movq %rax, 0x10(%rbx)
movq $0x3, (%rbx)
movq %r14, 0x8(%rbx)
movq 0x4622c(%rip), %rax     # 0x55538
movq %rbx, 0x10(%rax)
movl $0x18, %edi
callq 0x10f16
movq %rax, %rbx
movl $0x24, %edi
callq 0x10f16
movq %rax, 0x10(%rbx)
movq $0x9, (%rbx)
movq %r14, 0x8(%rbx)
movq 0x461fb(%rip), %rax     # 0x55538
movq %rbx, 0x20(%rax)
xorl %ecx, %ecx
movl %ecx, 0x8(%rax)
movl %ecx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/nurse[P]nkf/nkf.c
// Function: noconvert
static nkf_char
noconvert(FILE *f)
{
    nkf_char    c;

    if (nop_f == 2)
	module_connection();
    while ((c = (*i_getc)(f)) != EOF)
	(*o_putc)(c);
    (*o_putc)(EOF);
    return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x2, 0x46074(%rip)     # 0x553d0
jne 0xf36d
callq 0x126f7
jmp 0xf36d
movl %eax, %edi
callq *0x3df5b(%rip)          # 0x4d2c8
movq %rbx, %rdi
callq *0x3dfb2(%rip)          # 0x4d328
cmpl $-0x1, %eax
jne 0xf365
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
popq %rbx
jmpq *0x3df41(%rip)          # 0x4d2c8
// File: /workspace/github_c_makefile_star2_O3/nurse[P]nkf/nkf.c
// Function: e2s_conv
static nkf_char
e2s_conv(nkf_char c2, nkf_char c1, nkf_char *p2, nkf_char *p1)
{
    nkf_char ndx;
    if (is_eucg3(c2)){
	ndx = c2 & 0x7f;
	if (x0213_f && is_x0213_2_in_x0212(ndx)){
	    if((0x21 <= ndx && ndx <= 0x2F)){
		if (p2) *p2 = ((ndx - 1) >> 1) + 0xec - ndx / 8 * 3;
		if (p1) *p1 = c1 + ((ndx & 1) ? ((c1 < 0x60) ? 0x1f : 0x20) : 0x7e);
		return 0;
	    }else if(0x6E <= ndx && ndx <= 0x7E){
		if (p2) *p2 = ((ndx - 1) >> 1) + 0xbe;
		if (p1) *p1 = c1 + ((ndx & 1) ? ((c1 < 0x60) ? 0x1f : 0x20) : 0x7e);
		return 0;
	    }
	    return 1;
	}
#ifdef X0212_ENABLE
	else if(nkf_isgraph(ndx)){
	    nkf_char val = 0;
	    const unsigned short *ptr;
	    ptr = x0212_shiftjis[ndx - 0x21];
	    if (ptr){
		val = ptr[(c1 & 0x7f) - 0x21];
	    }
	    if (val){
		c2 = val >> 8;
		c1 = val & 0xff;
		if (p2) *p2 = c2;
		if (p1) *p1 = c1;
		return 0;
	    }
	    c2 = x0212_shift(c2);
	}
#endif /* X0212_ENABLE */
    }
    if(0x7F < c2) return 1;
    if (p2) *p2 = ((c2 - 1) >> 1) + ((c2 <= 0x5e) ? 0x71 : 0xb1);
    if (p1) *p1 = c1 + ((c2 & 1) ? ((c1 < 0x60) ? 0x1f : 0x20) : 0x7e);
    return 0;
}

// Assembly:
movl %edi, %eax
andl $0xff00, %eax           # imm = 0xFF00
cmpl $0x8f00, %eax           # imm = 0x8F00
jne 0x10ff5
movl %edi, %r8d
andl $0x7f, %r8d
cmpb $0x1, 0x3c46c(%rip)     # 0x4d3bc
jne 0x10fa6
cmpl $0x2f, %r8d
ja 0x10f67
leaq 0x78b1(%rip), %rax      # 0x18810
movsbl -0x20(%r8,%rax), %eax
jmp 0x10f74
leal -0x6e(%r8), %r9d
xorl %eax, %eax
cmpl $0x11, %r9d
setb %al
testl %eax, %eax
je 0x10fa6
leal -0x21(%r8), %eax
cmpl $0xe, %eax
ja 0x1105c
testq %rdx, %rdx
je 0x1101f
leal -0x1(%r8), %eax
shrl %eax
shrl $0x3, %r8d
leal (%r8,%r8,2), %r8d
subl %r8d, %eax
addl $0xec, %eax
jmp 0x1101d
cmpl $0x21, %r8d
setb %al
cmpl $0x7f, %r8d
sete %r9b
orb %al, %r9b
jne 0x10ff5
leal -0x21(%r8), %eax
leaq 0x3aadb(%rip), %r9      # 0x4baa0
movq (%r9,%rax,8), %rax
testq %rax, %rax
je 0x11042
movl %esi, %r9d
andl $0x7f, %r9d
movzwl -0x42(%rax,%r9,2), %eax
testl %eax, %eax
je 0x11042
testq %rdx, %rdx
je 0x10feb
movl %eax, %esi
shrl $0x8, %esi
movl %esi, (%rdx)
testq %rcx, %rcx
je 0x1103f
movzbl %al, %eax
jmp 0x1103d
movl $0x1, %eax
cmpl $0x7f, %edi
jg 0x11041
testq %rdx, %rdx
je 0x1101f
leal -0x1(%rdi), %eax
sarl %eax
xorl %r8d, %r8d
cmpl $0x5f, %edi
setge %r8b
shll $0x6, %r8d
addl %r8d, %eax
addl $0x71, %eax
movl %eax, (%rdx)
testq %rcx, %rcx
je 0x1103f
xorl %edx, %edx
cmpl $0x60, %esi
setge %dl
addl $0x1f, %edx
testb $0x1, %dil
movl $0x7e, %eax
cmovnel %edx, %eax
addl %esi, %eax
movl %eax, (%rcx)
xorl %eax, %eax
retq
cmpl $0x75, %r8d
setae %al
cmpl $0x7f, %edi
setg %r8b
orb %al, %r8b
movl $0x1, %eax
je 0x10fff
jmp 0x11041
cmpl $0x6e, %r8d
setb %r9b
cmpl $0x7f, %r8d
sete %r10b
movl $0x1, %eax
orb %r9b, %r10b
jne 0x11041
testq %rdx, %rdx
je 0x1101f
decl %r8d
shrl %r8d
addl $0xbe, %r8d
movl %r8d, (%rdx)
jmp 0x1101f
// File: /workspace/github_c_makefile_star2_O3/nurse[P]nkf/nkf.c
// Function: nkf_utf8_to_unicode
static nkf_char
nkf_utf8_to_unicode(nkf_char c1, nkf_char c2, nkf_char c3, nkf_char c4)
{
    nkf_char wc;
    if (c1 <= 0x7F) {
	/* single byte */
	wc = c1;
    }
    else if (c1 <= 0xC1) {
	/* trail byte or invalid */
	return -1;
    }
    else if (c1 <= 0xDF) {
	/* 2 bytes */
	wc  = (c1 & 0x1F) << 6;
	wc |= (c2 & 0x3F);
    }
    else if (c1 <= 0xEF) {
	/* 3 bytes */
	wc  = (c1 & 0x0F) << 12;
	wc |= (c2 & 0x3F) << 6;
	wc |= (c3 & 0x3F);
    }
    else if (c2 <= 0xF4) {
	/* 4 bytes */
	wc  = (c1 & 0x0F) << 18;
	wc |= (c2 & 0x3F) << 12;
	wc |= (c3 & 0x3F) << 6;
	wc |= (c4 & 0x3F);
    }
    else {
	return -1;
    }
    return wc;
}

// Assembly:
cmpl $0x80, %edi
jge 0x112ef
movl %edi, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0xc2, %edi
jae 0x112fd
retq
cmpl $0xdf, %edi
ja 0x11313
andl $0x1f, %edi
shll $0x6, %edi
andl $0x3f, %esi
orl %edi, %esi
movl %esi, %eax
retq
cmpl $0xef, %edi
ja 0x11331
shll $0xc, %edi
movzwl %di, %eax
andl $0x3f, %esi
shll $0x6, %esi
orl %eax, %esi
andl $0x3f, %edx
orl %esi, %edx
movl %edx, %eax
retq
cmpl $0xf4, %esi
jg 0x112fc
andl $0xf, %edi
shll $0x12, %edi
andl $0x3f, %esi
shll $0xc, %esi
orl %edi, %esi
andl $0x3f, %edx
shll $0x6, %edx
orl %esi, %edx
andl $0x3f, %ecx
orl %edx, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/nurse[P]nkf/nkf.c
// Function: w2e_conv
static nkf_char
w2e_conv(nkf_char c2, nkf_char c1, nkf_char c0, nkf_char *p2, nkf_char *p1)
{
    nkf_char ret = 0;

    if (!c1){
	*p2 = 0;
	*p1 = c2;
    }else if (0xc0 <= c2 && c2 <= 0xef) {
	ret =  unicode_to_jis_common(c2, c1, c0, p2, p1);
#ifdef NUMCHAR_OPTION
	if (ret > 0){
	    if (p2) *p2 = 0;
	    if (p1) *p1 = nkf_char_unicode_new(nkf_utf8_to_unicode(c2, c1, c0, 0));
	    ret = 0;
	}
#endif
    }
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r13
movl %edi, %r14d
testl %esi, %esi
je 0x113c2
leal -0xc0(%r14), %eax
xorl %r12d, %r12d
cmpl $0x2f, %eax
ja 0x113d0
movl %edx, %ebp
movl %esi, %r15d
movl %r14d, %edi
movq %r13, %rcx
movq %rbx, %r8
callq 0x113e7
testl %eax, %eax
jle 0x113e2
testq %r13, %r13
je 0x113a2
movl $0x0, (%r13)
testq %rbx, %rbx
je 0x113d0
movl %r14d, %edi
movl %r15d, %esi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x112e4
movl %eax, %r14d
orl $0x1000000, %r14d       # imm = 0x1000000
jmp 0x113ca
movl $0x0, (%r13)
movl %r14d, (%rbx)
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r12d
jmp 0x113d0
// File: /workspace/github_c_makefile_star2_O3/nurse[P]nkf/nkf.c
// Function: unicode_to_jis_common2
static int
unicode_to_jis_common2(nkf_char c1, nkf_char c0,
		       const unsigned short *const *pp, nkf_char psize,
		       nkf_char *p2, nkf_char *p1)
{
    nkf_char c2;
    const unsigned short *p;
    unsigned short val;

    if (pp == 0) return 1;

    c1 -= 0x80;
    if (c1 < 0 || psize <= c1) return 1;
    p = pp[c1];
    if (p == 0)  return 1;

    c0 -= 0x80;
    if (c0 < 0 || sizeof_utf8_to_euc_C2 <= c0) return 1;
    val = p[c0];
    if (val == 0) return 1;
    if (no_cp932ext_f && (
			  (val>>8) == 0x2D || /* NEC special characters */
			  val > NKF_INT32_C(0xF300) /* IBM extended characters */
			 )) return 1;

    c2 = val >> 8;
    if (val > 0x7FFF){
	c2 &= 0x7f;
	c2 |= PREFIX_EUCG3;
    }
    if (c2 == SO) c2 = JIS_X_0201_1976_K;
    c1 = val & 0xFF;
    if (p2) *p2 = c2;
    if (p1) *p1 = c1;
    return 0;
}

// Assembly:
movl $0x1, %eax
testq %rdx, %rdx
je 0x1191c
leal -0x80(%rdi), %r10d
cmpl $0x7f, %edi
setg %dil
cmpl %ecx, %r10d
setl %cl
andb %dil, %cl
cmpb $0x1, %cl
jne 0x1191c
movl %r10d, %ecx
movq (%rdx,%rcx,8), %rcx
testq %rcx, %rcx
sete %dl
leal -0xc0(%rsi), %edi
cmpl $-0x40, %edi
setb %dil
orb %dl, %dil
jne 0x1191c
movl %esi, %edx
movzwl -0x100(%rcx,%rdx,2), %ecx
testl %ecx, %ecx
je 0x1191c
cmpb $0x1, 0x43b54(%rip)     # 0x55418
jne 0x118e6
movl %ecx, %edx
andl $0xff00, %edx           # imm = 0xFF00
cmpl $0x2d00, %edx           # imm = 0x2D00
sete %dl
cmpl $0xf301, %ecx           # imm = 0xF301
setae %sil
orb %dl, %sil
jne 0x1191c
testq %r8, %r8
je 0x1190f
movl %ecx, %eax
shrl $0x8, %eax
movl %eax, %edx
andl $0x7f, %edx
orl $0x8f00, %edx           # imm = 0x8F00
testw %cx, %cx
cmovnsl %eax, %edx
cmpl $0xe, %edx
movl $0x1013, %eax           # imm = 0x1013
cmovnel %edx, %eax
movl %eax, (%r8)
xorl %eax, %eax
testq %r9, %r9
je 0x1191c
movzbl %cl, %ecx
movl %ecx, (%r9)
retq
// File: /workspace/github_c_makefile_star2_O3/nurse[P]nkf/nkf.c
// Function: w16e_conv
static nkf_char
w16e_conv(nkf_char val, nkf_char *p2, nkf_char *p1)
{
    nkf_char c1, c2, c3, c4;
    nkf_char ret = 0;
    val &= VALUE_MASK;
    if (val < 0x80) {
	*p2 = 0;
	*p1 = val;
    }
    else if (nkf_char_unicode_bmp_p(val)){
	nkf_unicode_to_utf8(val, &c1, &c2, &c3, &c4);
	ret =  unicode_to_jis_common(c1, c2, c3, p2, p1);
	if (ret > 0){
	    *p2 = 0;
	    *p1 = nkf_char_unicode_new(val);
	    ret = 0;
	}
    }
    else {
	int i;
	if (x0213_f) {
	    c1 = (val >> 10) + NKF_INT32_C(0xD7C0);   /* high surrogate */
	    c2 = (val & 0x3FF) + NKF_INT32_C(0xDC00); /* low surrogate */
	    for (i = 0; i < sizeof_x0213_1_surrogate_table; i++)
		if (x0213_1_surrogate_table[i][1] == c1 && x0213_1_surrogate_table[i][2] == c2) {
		    val = x0213_1_surrogate_table[i][0];
		    *p2 = val >> 8;
		    *p1 = val & 0xFF;
		    return 0;
		}
	    for (i = 0; i < sizeof_x0213_2_surrogate_table; i++)
		if (x0213_2_surrogate_table[i][1] == c1 && x0213_2_surrogate_table[i][2] == c2) {
		    val = x0213_2_surrogate_table[i][0];
		    *p2 = PREFIX_EUCG3 | (val >> 8);
		    *p1 = val & 0xFF;
		    return 0;
		}
	}
	*p2 = 0;
	*p1 = nkf_char_unicode_new(val);
    }
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
andl $0xffffff, %ebp         # imm = 0xFFFFFF
cmpl $0x7f, %ebp
ja 0x1194a
movl $0x0, (%r14)
jmp 0x11a15
cmpl $0xffff, %ebp           # imm = 0xFFFF
ja 0x11995
leaq 0x14(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0xc(%rsp), %r13
leaq 0x8(%rsp), %r8
movl %ebp, %edi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x11b58
movl (%r15), %edi
movl (%r12), %esi
movl (%r13), %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0x113e7
testl %eax, %eax
jg 0x11a08
jmp 0x11a19
cmpb $0x1, 0x3ba20(%rip)     # 0x4d3bc
jne 0x11a08
movl %ebp, %eax
shrl $0xa, %eax
addl $0xd7c0, %eax           # imm = 0xD7C0
andl $0x3ff, %edi            # imm = 0x3FF
orl $0xdc00, %edi           # imm = 0xDC00
movl $0x4, %ecx
leaq 0x10650(%rip), %rdx     # 0x22010
movzwl -0x2(%rdx,%rcx), %esi
cmpl %esi, %eax
jne 0x119d1
movzwl (%rdx,%rcx), %esi
cmpl %esi, %edi
je 0x11a28
addq $0x6, %rcx
cmpq $0xa0, %rcx
jne 0x119c0
movl $0x4, %ecx
leaq 0x106c6(%rip), %rdx     # 0x220b0
movzwl -0x2(%rdx,%rcx), %esi
cmpl %esi, %eax
jne 0x119fb
movzwl (%rdx,%rcx), %esi
cmpl %esi, %edi
je 0x11a35
addq $0x6, %rcx
cmpq $0x682, %rcx            # imm = 0x682
jne 0x119ea
movl $0x0, (%r14)
orl $0x1000000, %ebp        # imm = 0x1000000
movl %ebp, (%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzwl -0x4(%rdx,%rcx), %eax
movzbl %al, %ebp
shrl $0x8, %eax
jmp 0x11a45
movzwl -0x4(%rdx,%rcx), %eax
movzbl %al, %ebp
shrl $0x8, %eax
orl $0x8f00, %eax           # imm = 0x8F00
movl %eax, (%r14)
jmp 0x11a15
// File: /workspace/github_c_makefile_star2_O3/nurse[P]nkf/nkf.c
// Function: output_escape_sequence
static void
output_escape_sequence(int mode)
{
    if (output_mode == mode)
	return;
    switch(mode) {
    case ISO_8859_1:
	(*o_putc)(ESC);
	(*o_putc)('.');
	(*o_putc)('A');
	break;
    case JIS_X_0201_1976_K:
	(*o_putc)(ESC);
	(*o_putc)('(');
	(*o_putc)('I');
	break;
    case JIS_X_0208:
	(*o_putc)(ESC);
	(*o_putc)('$');
	(*o_putc)(kanji_intro);
	break;
    case JIS_X_0212:
	(*o_putc)(ESC);
	(*o_putc)('$');
	(*o_putc)('(');
	(*o_putc)('D');
	break;
    case JIS_X_0213_1:
	(*o_putc)(ESC);
	(*o_putc)('$');
	(*o_putc)('(');
	(*o_putc)('Q');
	break;
    case JIS_X_0213_2:
	(*o_putc)(ESC);
	(*o_putc)('$');
	(*o_putc)('(');
	(*o_putc)('P');
	break;
    }
    output_mode = mode;
}

// Assembly:
cmpl %edi, 0x439cc(%rip)     # 0x5541c
je 0x11b57
pushq %rbx
movl %edi, %ebx
cmpl $0x1167, %edi           # imm = 0x1167
jle 0x11aac
cmpl $0x1168, %ebx           # imm = 0x1168
je 0x11ae8
cmpl $0x1229, %ebx           # imm = 0x1229
je 0x11b07
cmpl $0x1233, %ebx           # imm = 0x1233
jne 0x11b50
movl $0x1b, %edi
callq *0x3b83c(%rip)          # 0x4d2c8
movl $0x24, %edi
callq *0x3b831(%rip)          # 0x4d2c8
movl $0x28, %edi
callq *0x3b826(%rip)          # 0x4d2c8
movl $0x51, %edi
jmp 0x11b4a
cmpl $0x1013, %ebx           # imm = 0x1013
je 0x11b2f
cmpl $0x1159, %ebx           # imm = 0x1159
jne 0x11b50
movl $0x1b, %edi
callq *0x3b7fd(%rip)          # 0x4d2c8
movl $0x24, %edi
callq *0x3b7f2(%rip)          # 0x4d2c8
movl $0x28, %edi
callq *0x3b7e7(%rip)          # 0x4d2c8
movl $0x44, %edi
jmp 0x11b4a
movl $0x1b, %edi
callq *0x3b7d5(%rip)          # 0x4d2c8
movl $0x24, %edi
callq *0x3b7ca(%rip)          # 0x4d2c8
movzbl 0x3b7cc(%rip), %edi     # 0x4d2d1
jmp 0x11b4a
movl $0x1b, %edi
callq *0x3b7b6(%rip)          # 0x4d2c8
movl $0x24, %edi
callq *0x3b7ab(%rip)          # 0x4d2c8
movl $0x28, %edi
callq *0x3b7a0(%rip)          # 0x4d2c8
movl $0x50, %edi
jmp 0x11b4a
movl $0x1b, %edi
callq *0x3b78e(%rip)          # 0x4d2c8
movl $0x28, %edi
callq *0x3b783(%rip)          # 0x4d2c8
movl $0x49, %edi
callq *0x3b778(%rip)          # 0x4d2c8
movl %ebx, 0x438c6(%rip)     # 0x5541c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/nurse[P]nkf/nkf.c
// Function: nkf_unicode_to_utf8
static void
nkf_unicode_to_utf8(nkf_char val, nkf_char *p1, nkf_char *p2, nkf_char *p3, nkf_char *p4)
{
    val &= VALUE_MASK;
    if (val < 0x80){
	*p1 = val;
	*p2 = 0;
	*p3 = 0;
	*p4 = 0;
    }else if (val < 0x800){
	*p1 = 0xc0 | (val >> 6);
	*p2 = 0x80 | (val & 0x3f);
	*p3 = 0;
	*p4 = 0;
    } else if (nkf_char_unicode_bmp_p(val)) {
	*p1 = 0xe0 |  (val >> 12);
	*p2 = 0x80 | ((val >>  6) & 0x3f);
	*p3 = 0x80 | ( val        & 0x3f);
	*p4 = 0;
    } else if (nkf_char_unicode_value_p(val)) {
	*p1 = 0xf0 |  (val >> 18);
	*p2 = 0x80 | ((val >> 12) & 0x3f);
	*p3 = 0x80 | ((val >>  6) & 0x3f);
	*p4 = 0x80 | ( val        & 0x3f);
    } else {
	*p1 = 0;
	*p2 = 0;
	*p3 = 0;
	*p4 = 0;
    }
}

// Assembly:
movl %edi, %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
cmpl $0x7f, %eax
ja 0x11b6e
movl %eax, (%rsi)
xorl %edi, %edi
movl %edi, (%rdx)
movl %edi, (%rcx)
jmp 0x11bbd
cmpl $0x7ff, %eax            # imm = 0x7FF
ja 0x11b92
shrl $0x6, %eax
orl $0xc0, %eax
movl %eax, (%rsi)
andl $0x3f, %edi
orl $0x80, %edi
movl %edi, (%rdx)
movl $0x0, (%rcx)
jmp 0x11bbb
cmpl $0xffff, %eax           # imm = 0xFFFF
ja 0x11bc1
shrl $0xc, %eax
orl $0xe0, %eax
movl %eax, (%rsi)
movl %edi, %eax
shrl $0x6, %eax
andl $0x3f, %eax
movl $0x80, %esi
orl %esi, %eax
movl %eax, (%rdx)
andl $0x3f, %edi
orl %esi, %edi
movl %edi, (%rcx)
xorl %edi, %edi
movl %edi, (%r8)
retq
cmpl $0x10ffff, %eax         # imm = 0x10FFFF
ja 0x11bf6
shrl $0x12, %eax
orl $0xf0, %eax
movl %eax, (%rsi)
movl %edi, %eax
shrl $0xc, %eax
andl $0x3f, %eax
movl $0x80, %esi
orl %esi, %eax
movl %eax, (%rdx)
movl %edi, %eax
shrl $0x6, %eax
andl $0x3f, %eax
orl %esi, %eax
movl %eax, (%rcx)
andl $0x3f, %edi
orl %esi, %edi
jmp 0x11bbd
xorl %edi, %edi
movl %edi, (%rsi)
jmp 0x11b68
// File: /workspace/github_c_makefile_star2_O3/nurse[P]nkf/nkf.c
// Function: e2w_combining
static nkf_char
e2w_combining(nkf_char comb, nkf_char c2, nkf_char c1)
{
    nkf_char euc;
    int i;
    for (i = 0; i < sizeof_x0213_combining_chars; i++)
	if (x0213_combining_chars[i] == comb)
	    break;
    if (i >= sizeof_x0213_combining_chars)
	return 0;
    euc = (c2&0x7f)<<8 | (c1&0x7f);
    for (i = 0; i < sizeof_x0213_combining_table; i++)
	if (x0213_combining_table[i][0] == euc)
	    return x0213_combining_table[i][1];
    return 0;
}

// Assembly:
xorl %eax, %eax
leaq 0x1005e(%rip), %rcx     # 0x21f5c
movzwl (%rcx,%rax,2), %r8d
cmpl %edi, %r8d
je 0x11f13
incq %rax
cmpq $0x5, %rax
jne 0x11efe
jmp 0x11f3f
andl $0x7f, %esi
shll $0x8, %esi
andl $0x7f, %edx
orl %esi, %edx
movl $0x2, %eax
leaq 0x10046(%rip), %rcx     # 0x21f70
movzwl -0x2(%rcx,%rax), %esi
cmpl %esi, %edx
je 0x11f42
addq $0x6, %rax
cmpq $0x98, %rax
jne 0x11f2a
xorl %eax, %eax
retq
movzwl (%rcx,%rax), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/nurse[P]nkf/nkf.c
// Function: code_score
static void
code_score(struct input_code *ptr)
{
    nkf_char c2 = ptr->buf[0];
    nkf_char c1 = ptr->buf[1];
    if (c2 < 0){
	set_code_score(ptr, SCORE_ERROR);
    }else if (c2 == SS2){
	set_code_score(ptr, SCORE_KANA);
    }else if (c2 == 0x8f){
	if ((c1 & 0x70) == 0x20){
	    set_code_score(ptr, score_table_8FA0[c1 & 0x0f]);
	}else if ((c1 & 0x70) == 0x60){
	    set_code_score(ptr, score_table_8FE0[c1 & 0x0f]);
	}else if ((c1 & 0x70) == 0x70){
	    set_code_score(ptr, score_table_8FF0[c1 & 0x0f]);
	}else{
	    set_code_score(ptr, SCORE_X0212);
	}
#ifdef UTF8_OUTPUT_ENABLE
    }else if (!e2w_conv(c2, c1)){
	set_code_score(ptr, SCORE_NO_EXIST);
#endif
    }else if ((c2 & 0x70) == 0x20){
	set_code_score(ptr, score_table_A0[c2 & 0x0f]);
    }else if ((c2 & 0x70) == 0x70){
	set_code_score(ptr, score_table_F0[c2 & 0x0f]);
    }else if ((c2 & 0x70) >= 0x50){
	set_code_score(ptr, SCORE_L2);
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x14(%rdi), %ebp
testl %ebp, %ebp
js 0x11f89
cmpl $0x8e, %ebp
je 0x11f90
movl 0x18(%rbx), %esi
cmpl $0x8f, %ebp
jne 0x11f97
movl %esi, %ecx
andl $0x70, %ecx
cmpl $0x20, %ecx
je 0x11fca
cmpl $0x70, %ecx
je 0x11fc1
movl $0x10, %eax
cmpl $0x60, %ecx
jne 0x11fe2
leaq 0x5439(%rip), %rax      # 0x173c0
jmp 0x11fdc
movl $0x100, %eax            # imm = 0x100
jmp 0x11fe2
movl $0x2, %eax
jmp 0x11fe2
movl %ebp, %edi
callq 0x11d0f
testl %eax, %eax
je 0x11fba
movl %ebp, %ecx
andl $0x70, %ecx
cmpl $0x20, %ecx
je 0x11fd3
cmpl $0x70, %ecx
jne 0x11fec
leaq 0x54c8(%rip), %rax      # 0x17480
jmp 0x11fda
movl $0x40, %eax
jmp 0x11fe2
leaq 0x5438(%rip), %rax      # 0x17400
jmp 0x11fdc
leaq 0x53af(%rip), %rax      # 0x17380
jmp 0x11fdc
leaq 0x5466(%rip), %rax      # 0x17440
movl %ebp, %esi
andl $0xf, %esi
movl (%rax,%rsi,4), %eax
orl %eax, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x1, %eax
cmpl $0x4f, %ecx
ja 0x11fe2
jmp 0x11fe5
// File: /workspace/github_c_makefile_star2_O3/nurse[P]nkf/nkf.c
// Function: status_disable
static void
status_disable(struct input_code *ptr)
{
    ptr->stat = -1;
    ptr->buf[0] = -1;
    code_score(ptr);
    if (iconv == ptr->iconv_func) set_iconv(FALSE, 0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x8(%rdi)
movl %eax, 0x14(%rdi)
callq 0x11f47
movq 0x3b2c5(%rip), %rax     # 0x4d2d8
cmpq 0x28(%rbx), %rax
je 0x1201b
popq %rbx
retq
xorl %edi, %edi
xorl %esi, %esi
popq %rbx
jmp 0x11c09
// File: /workspace/github_c_makefile_star2_O3/nurse[P]nkf/nkf.c
// Function: nkf_enc_find
static int
nkf_enc_find_index(const char *name)
{
    int i;
    if (name[0] == 'X' && *(name+1) == '-') name += 2;
    for (i = 0; encoding_name_to_id_table[i].id >= 0; i++) {
	if (nkf_str_caseeql(encoding_name_to_id_table[i].name, name)) {
	    return encoding_name_to_id_table[i].id;
	}
    }
    return -1;
}

// Assembly:
pushq %rbp
pushq %rbx
cmpb $0x58, (%rdi)
jne 0x12102
xorl %eax, %eax
cmpb $0x2d, 0x1(%rdi)
sete %al
leaq (%rdi,%rax,2), %rdi
leaq 0x34dd7(%rip), %rcx     # 0x46ee0
xorl %eax, %eax
xorl %edx, %edx
xorl %esi, %esi
movq %rcx, %r8
movq (%r8), %r8
movb (%r8), %r10b
xorl %r9d, %r9d
testb %r10b, %r10b
je 0x12163
movsbl (%rdi,%r9), %r11d
testl %r11d, %r11d
je 0x1216a
leal -0x61(%r10), %ebx
leal -0x20(%r10), %ebp
cmpb $0x1a, %bl
movzbl %bpl, %ebx
movsbl %r10b, %r10d
cmovbl %ebx, %r10d
leal -0x61(%r11), %ebx
leal -0x20(%r11), %ebp
cmpb $0x1a, %bl
movzbl %bpl, %ebx
cmovael %r11d, %ebx
cmpl %ebx, %r10d
jne 0x1216a
movb 0x1(%r8,%r9), %r10b
incq %r9
jmp 0x1211b
cmpb $0x0, (%rdi,%r9)
je 0x12184
incq %rdx
movq %rdx, %rsi
shlq $0x4, %rsi
leaq (%rcx,%rsi), %r8
movl 0x8(%rsi,%rcx), %esi
cmpq $0x33, %rdx
jne 0x12112
jmp 0x121a2
xorl %eax, %eax
testl %esi, %esi
js 0x121a2
cmpl $0x24, %esi
movl %esi, %ecx
leaq (%rcx,%rcx,2), %rcx
leaq 0x34686(%rip), %rdx     # 0x46820
leaq (%rdx,%rcx,8), %rcx
cmovbq %rcx, %rax
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/nurse[P]nkf/nkf.c
// Function: encode_fallback_html
static void
encode_fallback_html(nkf_char c)
{
    (*oconv)(0, '&');
    (*oconv)(0, '#');
    c &= VALUE_MASK;
    if(c >= NKF_INT32_C(1000000))
	(*oconv)(0, 0x30+(c/NKF_INT32_C(1000000))%10);
    if(c >= NKF_INT32_C(100000))
	(*oconv)(0, 0x30+(c/NKF_INT32_C(100000) )%10);
    if(c >= 10000)
	(*oconv)(0, 0x30+(c/10000  )%10);
    if(c >= 1000)
	(*oconv)(0, 0x30+(c/1000   )%10);
    if(c >= 100)
	(*oconv)(0, 0x30+(c/100    )%10);
    if(c >= 10)
	(*oconv)(0, 0x30+(c/10     )%10);
    if(c >= 0)
	(*oconv)(0, 0x30+ c         %10);
    (*oconv)(0, ';');
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %edi, %edi
movl $0x26, %esi
callq *0x3b100(%rip)          # 0x4d2b8
xorl %edi, %edi
movl $0x23, %esi
callq *0x3b0f3(%rip)          # 0x4d2b8
andl $0xffffff, %ebx         # imm = 0xFFFFFF
movl %ebx, %r14d
cmpl $0xf4240, %ebx          # imm = 0xF4240
jb 0x121fa
imulq $0x10c6f7b, %r14, %rax  # imm = 0x10C6F7B
shrq $0x2c, %rax
leal -0xa(%rax), %esi
cmpl $0x989680, %ebx         # imm = 0x989680
cmovbl %eax, %esi
orl $0x30, %esi
xorl %edi, %edi
callq *0x3b0c0(%rip)          # 0x4d2b8
jmp 0x12206
cmpl $0x186a0, %ebx          # imm = 0x186A0
jb 0x1230a
imulq $0x14f8b59, %r14, %rax  # imm = 0x14F8B59
shrq $0x29, %rax
imull $0xcd, %eax, %ecx
shrl $0xa, %ecx
andl $0x3e, %ecx
leal (%rcx,%rcx,4), %ecx
subb %cl, %al
orb $0x30, %al
movzbl %al, %esi
xorl %edi, %edi
callq *0x3b089(%rip)          # 0x4d2b8
imulq $0x1a36e3, %r14, %rax   # imm = 0x1A36E3
shrq $0x22, %rax
imull $0x199a, %eax, %ecx     # imm = 0x199A
shrl $0xf, %ecx
andl $-0x2, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
orl $0x30, %eax
movzwl %ax, %esi
xorl %edi, %edi
callq *0x3b05f(%rip)          # 0x4d2b8
imulq $0x83126f, %r14, %rax   # imm = 0x83126F
shrq $0x21, %rax
imull $0x6667, %eax, %ecx     # imm = 0x6667
shrl $0x11, %ecx
andl $-0x2, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
orl $0x30, %eax
movzwl %ax, %esi
xorl %edi, %edi
callq *0x3b035(%rip)          # 0x4d2b8
imulq $0x28f5c29, %r14, %rsi  # imm = 0x28F5C29
shrq $0x20, %rsi
imulq $0x1999999a, %rsi, %rax # imm = 0x1999999A
shrq $0x20, %rax
addl %eax, %eax
leal (%rax,%rax,4), %eax
subl %eax, %esi
orl $0x30, %esi
xorl %edi, %edi
callq *0x3b00d(%rip)          # 0x4d2b8
imulq $0x1999999a, %r14, %rsi # imm = 0x1999999A
shrq $0x20, %rsi
imulq $0x1999999a, %rsi, %rax # imm = 0x1999999A
shrq $0x20, %rax
addl %eax, %eax
leal (%rax,%rax,4), %eax
subl %eax, %esi
orl $0x30, %esi
xorl %edi, %edi
callq *0x3afe5(%rip)          # 0x4d2b8
imulq $0x1999999a, %r14, %rax # imm = 0x1999999A
shrq $0x20, %rax
addl %eax, %eax
leal (%rax,%rax,4), %eax
negl %eax
leal (%rbx,%rax), %esi
addl $0x30, %esi
xorl %edi, %edi
callq *0x3afc5(%rip)          # 0x4d2b8
movq 0x3afbe(%rip), %rax     # 0x4d2b8
xorl %edi, %edi
movl $0x3b, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
cmpl $0x2710, %ebx           # imm = 0x2710
jae 0x1222f
cmpl $0x3e8, %ebx            # imm = 0x3E8
jae 0x12259
cmpl $0x64, %ebx
jae 0x12283
cmpl $0xa, %ebx
jae 0x122ab
jmp 0x122d3
// File: /workspace/github_c_makefile_star2_O3/nurse[P]nkf/nkf.c
// Function: encode_fallback_xml
static void
encode_fallback_xml(nkf_char c)
{
    (*oconv)(0, '&');
    (*oconv)(0, '#');
    (*oconv)(0, 'x');
    nkf_each_char_to_hex(oconv, c);
    (*oconv)(0, ';');
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %edi, %edi
movl $0x26, %esi
callq *0x3af6c(%rip)          # 0x4d2b8
xorl %edi, %edi
movl $0x23, %esi
callq *0x3af5f(%rip)          # 0x4d2b8
xorl %edi, %edi
movl $0x78, %esi
callq *0x3af52(%rip)          # 0x4d2b8
movq 0x3af4b(%rip), %rdx     # 0x4d2b8
andl $0xffffff, %ebx         # imm = 0xFFFFFF
movl $0x14, %ebp
movl %ebx, %eax
movl %ebp, %ecx
shrl %cl, %eax
testl %eax, %eax
jne 0x1238c
addl $-0x4, %ebp
cmpl $-0x4, %ebp
jne 0x12378
jmp 0x123ba
leaq 0x6101(%rip), %r14      # 0x18494
movl %ebx, %eax
movl %ebp, %ecx
shrl %cl, %eax
andl $0xf, %eax
movsbl (%rax,%r14), %esi
xorl %edi, %edi
movq %rdx, %r15
callq *%rdx
movq %r15, %rdx
addl $-0x4, %ebp
cmpl $-0x4, %ebp
jne 0x12393
movq 0x3aefe(%rip), %rdx     # 0x4d2b8
xorl %edi, %edi
movl $0x3b, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rdx
// File: /workspace/github_c_makefile_star2_O3/nurse[P]nkf/nkf.c
// Function: encode_fallback_java
static void
encode_fallback_java(nkf_char c)
{
    (*oconv)(0, '\\');
    c &= VALUE_MASK;
    if(!nkf_char_unicode_bmp_p(c)){
        int high = (c >> 10) + NKF_INT32_C(0xD7C0);   /* high surrogate */
        int low = (c & 0x3FF) + NKF_INT32_C(0xDC00); /* low surrogate */
	(*oconv)(0, 'u');
	(*oconv)(0, bin2hex(high>>12));
	(*oconv)(0, bin2hex(high>> 8));
	(*oconv)(0, bin2hex(high>> 4));
	(*oconv)(0, bin2hex(high    ));
	(*oconv)(0, '\\');
	(*oconv)(0, 'u');
	(*oconv)(0, bin2hex(low>>12));
	(*oconv)(0, bin2hex(low>> 8));
	(*oconv)(0, bin2hex(low>> 4));
	(*oconv)(0, bin2hex(low    ));
    }else{
	(*oconv)(0, 'u');
	(*oconv)(0, bin2hex(c>>12));
	(*oconv)(0, bin2hex(c>> 8));
	(*oconv)(0, bin2hex(c>> 4));
	(*oconv)(0, bin2hex(c    ));
    }
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %edi, %edi
movl $0x5c, %esi
callq *0x3aed4(%rip)          # 0x4d2b8
movl %ebx, %r14d
andl $0xffffff, %r14d        # imm = 0xFFFFFF
cmpl $0x10000, %r14d         # imm = 0x10000
jae 0x1242c
xorl %edi, %edi
movl $0x75, %esi
callq *0x3aeb4(%rip)          # 0x4d2b8
movl %ebx, %eax
shrl $0xc, %eax
andl $0xf, %eax
leaq 0x6081(%rip), %rcx      # 0x18494
movsbl (%rax,%rcx), %esi
xorl %edi, %edi
callq *0x3ae99(%rip)          # 0x4d2b8
movl %ebx, %eax
shrl $0x8, %eax
andl $0xf, %eax
jmp 0x124cf
shrl $0xa, %r14d
leal 0xd7c0(%r14), %r15d
xorl %edi, %edi
movl $0x75, %esi
callq *0x3ae74(%rip)          # 0x4d2b8
movl %r15d, %eax
shrl $0xc, %eax
andl $0xf, %eax
leaq 0x6040(%rip), %r12      # 0x18494
movsbl (%rax,%r12), %esi
xorl %edi, %edi
callq *0x3ae57(%rip)          # 0x4d2b8
movl %r15d, %eax
shrl $0x8, %eax
andl $0xf, %eax
movsbl (%rax,%r12), %esi
xorl %edi, %edi
callq *0x3ae41(%rip)          # 0x4d2b8
shrl $0x4, %r15d
andl $0xf, %r15d
movsbl (%r15,%r12), %esi
xorl %edi, %edi
callq *0x3ae2c(%rip)          # 0x4d2b8
andl $0xf, %r14d
movsbl (%r14,%r12), %esi
xorl %edi, %edi
callq *0x3ae1b(%rip)          # 0x4d2b8
xorl %edi, %edi
movl $0x5c, %esi
callq *0x3ae0e(%rip)          # 0x4d2b8
xorl %edi, %edi
movl $0x75, %esi
callq *0x3ae01(%rip)          # 0x4d2b8
xorl %edi, %edi
movl $0x44, %esi
callq *0x3adf4(%rip)          # 0x4d2b8
movl %ebx, %eax
shrl $0x8, %eax
andl $0x3, %eax
orl $0xc, %eax
movl %eax, %eax
leaq 0x5fbc(%rip), %r14      # 0x18494
movsbl (%rax,%r14), %esi
xorl %edi, %edi
callq *0x3add3(%rip)          # 0x4d2b8
movl %ebx, %eax
shrl $0x4, %eax
andl $0xf, %eax
movsbl (%rax,%r14), %esi
xorl %edi, %edi
callq *0x3adbe(%rip)          # 0x4d2b8
movq 0x3adb7(%rip), %rax     # 0x4d2b8
andl $0xf, %ebx
movsbl (%rbx,%r14), %esi
xorl %edi, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/nurse[P]nkf/nkf.c
// Function: encode_fallback_perl
static void
encode_fallback_perl(nkf_char c)
{
    (*oconv)(0, '\\');
    (*oconv)(0, 'x');
    (*oconv)(0, '{');
    nkf_each_char_to_hex(oconv, c);
    (*oconv)(0, '}');
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %edi, %edi
movl $0x5c, %esi
callq *0x3ad8a(%rip)          # 0x4d2b8
xorl %edi, %edi
movl $0x78, %esi
callq *0x3ad7d(%rip)          # 0x4d2b8
xorl %edi, %edi
movl $0x7b, %esi
callq *0x3ad70(%rip)          # 0x4d2b8
movq 0x3ad69(%rip), %rdx     # 0x4d2b8
andl $0xffffff, %ebx         # imm = 0xFFFFFF
movl $0x14, %ebp
movl %ebx, %eax
movl %ebp, %ecx
shrl %cl, %eax
testl %eax, %eax
jne 0x1256e
addl $-0x4, %ebp
cmpl $-0x4, %ebp
jne 0x1255a
jmp 0x1259c
leaq 0x5f1f(%rip), %r14      # 0x18494
movl %ebx, %eax
movl %ebp, %ecx
shrl %cl, %eax
andl $0xf, %eax
movsbl (%rax,%r14), %esi
xorl %edi, %edi
movq %rdx, %r15
callq *%rdx
movq %r15, %rdx
addl $-0x4, %ebp
cmpl $-0x4, %ebp
jne 0x12575
movq 0x3ad1c(%rip), %rdx     # 0x4d2b8
xorl %edi, %edi
movl $0x7d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rdx