LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x2dfd10
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x2dfc11
movq 0x30(%rbx), %rdi
callq 0x8a4fd
andq $0x0, 0x30(%rbx)
movq 0x28(%rbx), %rdi
callq 0xad1fa
movq %rax, %r12
movq 0x20(%rbx), %rdi
callq 0xad1fa
movq 0x18(%rbx), %rcx
leaq 0xaa84d(%rip), %rdi     # 0x38a4d1
pushq $0x4
popq %r8
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x92a82
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2dfd3a
leaq 0xaa7e3(%rip), %r12     # 0x38a48b
pushq $0x47
popq %rdx
movq %r12, %rsi
callq 0x936f9
movq 0x28(%rbx), %rdi
callq 0xad1fa
andq $0x0, (%rsp)
pushq $0x48
popq %rsi
pushq $0x1
popq %r9
movq %r15, %rdi
movq %r12, %rdx
xorl %ecx, %ecx
movq %rax, %r8
callq 0x2b613a
cmpq %r14, 0x18(%rbx)
jne 0x2dfd64
movq 0x20(%rbx), %r14
movq 0x28(%rbx), %rdi
callq 0xae103
leaq 0xaa795(%rip), %rsi     # 0x38a48b
pushq $0x4c
popq %rdx
movq %rbx, %rdi
callq 0x936f9
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x158251(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x52f2(%rip), %rsi      # 0x2e5013
leaq 0xaa780(%rip), %rdx     # 0x38a4a8
leaq 0xaa787(%rip), %rcx     # 0x38a4b6
leaq 0xaa755(%rip), %r8      # 0x38a48b
pushq $0x3e
jmp 0x2dfd8c
movq 0x158227(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x52c8(%rip), %rsi      # 0x2e5013
leaq 0xaa7aa(%rip), %rdx     # 0x38a4fc
leaq 0xaa75d(%rip), %rcx     # 0x38a4b6
leaq 0xaa72b(%rip), %r8      # 0x38a48b
pushq $0x46
jmp 0x2dfd8c
movq 0x1581fd(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x529e(%rip), %rsi      # 0x2e5013
leaq 0xaa79d(%rip), %rdx     # 0x38a519
leaq 0xaa733(%rip), %rcx     # 0x38a4b6
leaq 0xaa701(%rip), %r8      # 0x38a48b
pushq $0x49
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/lacework-dev[P]strace_lab_PUBLIC/./src/example_4.c
// Function: main
int main(int argc, char *argv[])
{

	int fd = open("/tmp/follow_twitter_lacework_labs", O_CREAT|O_WRONLY, 0777);

	// ptrace reference: https://stackoverflow.com/questions/33646089/using-ptrace-to-detect-debugger
	if (ptrace(PTRACE_TRACEME, 0,1,0) == -1) 
	{
		printf("[!] Oh no! Error!");
		return 1;
	} 

	if (fd == 31337){
		printf("[*] Achievement unlocked!\n");
	} else {
		printf("[!] Achievement still locked!\n");
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0xe8a(%rip), %rdi       # 0x2004
pushq $0x41
popq %rsi
movl $0x1ff, %edx            # imm = 0x1FF
xorl %eax, %eax
callq 0x1060
movl %eax, %r14d
pushq $0x1
popq %rbx
xorl %edi, %edi
xorl %esi, %esi
movl %ebx, %edx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1050
cmpq $-0x1, %rax
je 0x11b6
cmpl $0x7a69, %r14d          # imm = 0x7A69
jne 0x11c6
leaq 0xea2(%rip), %rdi       # 0x2056
jmp 0x11cd
leaq 0xe69(%rip), %rdi       # 0x2026
xorl %eax, %eax
callq 0x1040
jmp 0x11d4
leaq 0xe6b(%rip), %rdi       # 0x2038
callq 0x1030
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc9cd
cmpb $0x1, 0x47a45(%rip)     # 0x543f0
jne 0xca1e
cmpl $0x0, 0x3f8ec(%rip)     # 0x4c2a0
jne 0xca1e
movl $0x22, 0x4(%rsp)
movl $0x2e, (%rsp)
pushq $0x22
popq %rdi
pushq $0x2e
popq %rsi
jmp 0xca24
cmpl $0x20, %edi
jl 0xca24
leal -0x40(%rsi), %ecx
cmpl $0xbc, %ecx
ja 0xca2e
leal -0xf0(%rdi), %eax
cmpl $0x9, %eax
ja 0xca2e
testb $0x1, 0x3f9bd(%rip)     # 0x4c3ac
jne 0xca2e
xorl %eax, %eax
cmpl $0x7f, %esi
je 0xca2c
imull $0xbc, %edi, %eax
addl %ecx, %eax
cmpl $0x7f, %esi
adcl $-0x1, %eax
addl $0x2fc0, %eax           # imm = 0x2FC0
andl $0x0, 0x4(%rsp)
orl $0x1000000, %eax        # imm = 0x1000000
movl %eax, (%rsp)
xorl %edi, %edi
movl %eax, %esi
jmp 0xca24
andl $0x7f, %esi
movl %esi, (%rsp)
callq *0x3f87e(%rip)          # 0x4c2a8
xorl %eax, %eax
popq %rcx
retq
leaq 0x4(%rsp), %rdx
movq %rsp, %rcx
callq 0x10ea6
testl %eax, %eax
je 0xca44
pushq $0x1
popq %rax
jmp 0xca2c
movl 0x4(%rsp), %edi
movl (%rsp), %esi
jmp 0xca24
// File: /workspace/github_c_makefile_star2_O2/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, 0x47643(%rip)     # 0x54520
jne 0xcf01
movb $0x0, 0x4763a(%rip)     # 0x54520
pushq $-0x11
popq %rdi
callq *0x3f3c9(%rip)          # 0x4c2b8
pushq $-0x45
popq %rdi
callq *0x3f3c0(%rip)          # 0x4c2b8
pushq $-0x41
popq %rdi
callq *0x3f3b7(%rip)          # 0x4c2b8
cmpl $-0x1, %ebp
je 0xd023
testl %ebp, %ebp
jne 0xcf51
movl %r14d, %eax
andl $0xff000000, %eax       # imm = 0xFF000000
cmpl $0x1000000, %eax        # imm = 0x1000000
jne 0xd020
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 0x118b8
movl (%rbx), %edi
jmp 0xcfec
movl %ebp, %edi
movl %r14d, %esi
callq 0x11a77
testl %eax, %eax
je 0xd015
movl %eax, %ebx
movl %eax, %edi
movl %ebp, %esi
movl %r14d, %edx
callq 0x11c39
testl %eax, %eax
je 0xcfc8
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 0x118b8
movl (%r14), %edi
callq *0x3f319(%rip)          # 0x4c2b8
movl (%r15), %edi
testl %edi, %edi
je 0xcfac
callq *0x3f30c(%rip)          # 0x4c2b8
movl 0xc(%rsp), %edi
testl %edi, %edi
je 0xcfba
callq *0x3f2fe(%rip)          # 0x4c2b8
movl 0x8(%rsp), %edi
testl %edi, %edi
je 0xcfc8
callq *0x3f2f0(%rip)          # 0x4c2b8
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 0x118b8
movl (%r14), %edi
callq *0x3f2c6(%rip)          # 0x4c2b8
movl (%r15), %edi
testl %edi, %edi
je 0xcfff
callq *0x3f2b9(%rip)          # 0x4c2b8
movl 0xc(%rsp), %edi
testl %edi, %edi
je 0xd00d
callq *0x3f2ab(%rip)          # 0x4c2b8
movl 0x8(%rsp), %ebp
testl %ebp, %ebp
jne 0xd023
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 *0x3f283(%rip)          # 0x4c2b8
// File: /workspace/github_c_makefile_star2_O2/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, 0x4726c(%rip)     # 0x54520
jne 0xd30a
movb $0x0, 0x47263(%rip)     # 0x54520
xorl %eax, %eax
cmpb $0x0, 0x4725e(%rip)     # 0x54524
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 *0x3efc8(%rip)          # 0x4c2b8
movl %r12d, %edi
callq *0x3efbf(%rip)          # 0x4c2b8
movl %r15d, %edi
callq *0x3efb6(%rip)          # 0x4c2b8
movl %ebx, %edi
callq *0x3efae(%rip)          # 0x4c2b8
cmpl $0x1, %r14d
je 0xd320
testl %r14d, %r14d
je 0xd326
cmpl $-0x1, %r14d
jne 0xd396
pushq $-0x1
popq %rdi
jmp 0xd388
orl $0x80, %ebp
movl %ebp, %ebx
movq 0x3ef89(%rip), %rax     # 0x4c2b8
cmpb $0x1, 0x471ee(%rip)     # 0x54524
jne 0xd361
movl $0xff, %ebp
movl %ebx, %edi
andl %ebp, %edi
callq *%rax
movl %ebx, %edi
shrl $0x8, %edi
andl %ebp, %edi
callq *0x3ef68(%rip)          # 0x4c2b8
shrl $0x10, %ebx
andl %ebp, %ebx
movl %ebx, %edi
callq *0x3ef5b(%rip)          # 0x4c2b8
xorl %edi, %edi
jmp 0xd388
xorl %edi, %edi
callq *%rax
movl %ebx, %edi
shrl $0x10, %edi
movl $0xff, %ebp
andl %ebp, %edi
callq *0x3ef41(%rip)          # 0x4c2b8
movl %ebx, %edi
shrl $0x8, %edi
andl %ebp, %edi
callq *0x3ef34(%rip)          # 0x4c2b8
andl %ebp, %ebx
movl %ebx, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *0x3ef22(%rip)          # 0x4c2b8
movl %r14d, %edi
movl %ebp, %esi
callq 0x11a77
testl %eax, %eax
je 0xd3e9
movl %eax, %ebx
movl %eax, %edi
movl %r14d, %esi
movl %ebp, %edx
callq 0x11c39
testl %eax, %eax
je 0xd328
movl %eax, %ebp
movq 0x3eef5(%rip), %rax     # 0x4c2b8
cmpb $0x1, 0x4715a(%rip)     # 0x54524
jne 0xd3f2
movzbl %bpl, %edi
callq *%rax
shrl $0x8, %ebp
movl %ebp, %edi
callq *0x3eedb(%rip)          # 0x4c2b8
xorl %edi, %edi
callq *0x3eed3(%rip)          # 0x4c2b8
xorl %edi, %edi
jmp 0xd40d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
callq *%rax
xorl %edi, %edi
callq *0x3eeba(%rip)          # 0x4c2b8
movl %ebp, %edi
shrl $0x8, %edi
callq *0x3eeaf(%rip)          # 0x4c2b8
movzbl %bpl, %edi
callq *0x3eea5(%rip)          # 0x4c2b8
jmp 0xd328
// File: /workspace/github_c_makefile_star2_O2/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 0xd4ee
movq %rdi, %rbx
leaq 0x8c13(%rip), %rcx      # 0x16044
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x7f, %esi
jg 0xd4ee
cmpl $0x0, 0x46fce(%rip)     # 0x54418
je 0xd4ee
movabsq $0x8000000000, %rax     # imm = 0x8000000000
movq %rax, 0x8(%rbx)
jmp 0xd485
leal -0xa1(%rsi), %eax
cmpl $0x5d, %eax
ja 0xd496
movslq 0x10(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x10(%rbx)
movl %esi, 0x14(%rbx,%rax,4)
movq %rbx, %rdi
callq 0x11c8e
andl $0x0, 0x8(%rbx)
andl $0x0, 0x10(%rbx)
jmp 0xd4ee
leal -0xa1(%rsi), %eax
cmpl $0x5d, %eax
jbe 0xd4d9
movq %rbx, %rdi
popq %rbx
jmp 0x11d36
cmpl $0x80, %esi
setl %al
movl %esi, %ecx
andl $0x7f000000, %ecx       # imm = 0x7F000000
cmpl $0x1000000, %ecx        # imm = 0x1000000
sete %cl
orb %al, %cl
jne 0xd4ee
cmpl $0x8e, %esi
sete %al
leal -0xa1(%rsi), %ecx
cmpl $0x5e, %ecx
setb %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xd4f0
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 0xd496
movl $0x2, 0x8(%rbx)
movslq 0x10(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x10(%rbx)
movl $0x8f, 0x14(%rbx,%rax,4)
jmp 0xd4ee
// File: /workspace/github_c_makefile_star2_O2/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 0xd85c
movq %rdi, %rbx
leaq 0x8958(%rip), %rcx      # 0x16068
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl %esi, %eax
andl $-0x40, %eax
cmpl $0x80, %eax
jne 0xd863
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 0xd85c
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 0xd822
movl 0x1c(%rbx), %ebp
movl $0xef, %edi
movl $0xbb, %esi
movl %ebp, %edx
callq 0x11169
cmpl $0xbf, %ebp
jne 0xd82a
jmp 0xd832
movl %esi, %eax
andl $-0x40, %eax
cmpl $0x80, %eax
jne 0xd863
movslq 0x10(%rbx), %rax
cmpq $0x2, %rax
jg 0xd832
jmp 0xd852
cmpl $0x7f, %esi
jg 0xd85c
cmpl $0x0, 0x46c58(%rip)     # 0x54418
je 0xd85c
movabsq $0x8000000000, %rax     # imm = 0x8000000000
movq %rax, 0x8(%rbx)
jmp 0xd836
cmpl $0x80, %esi
setl %al
movl %esi, %ecx
andl $0x7f000000, %ecx       # imm = 0x7F000000
cmpl $0x1000000, %ecx        # imm = 0x1000000
sete %cl
orb %al, %cl
jne 0xd85c
movl %esi, %eax
andl $0x7fffffe0, %eax       # imm = 0x7FFFFFE0
cmpl $0xc0, %eax
jne 0xd80b
movl $0x1, 0x8(%rbx)
jmp 0xd84e
movl %esi, %eax
andl $0x7ffffff0, %eax       # imm = 0x7FFFFFF0
cmpl $0xe0, %eax
jne 0xd83c
movl $0x2, 0x8(%rbx)
jmp 0xd84e
movl 0x1c(%rbx), %edx
callq 0x11169
movq %rbx, %rdi
callq 0x11c8e
andl $0x0, 0x8(%rbx)
andl $0x0, 0x10(%rbx)
jmp 0xd85c
leal -0xf0(%rsi), %eax
cmpl $0x4, %eax
ja 0xd863
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 0x11d36
// File: /workspace/github_c_makefile_star2_O2/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 %rax
movq 0x45580(%rip), %rcx     # 0x54528
testq %rcx, %rcx
je 0xefc9
movq (%rcx), %rax
andq $0x0, 0x8(%rax)
movq 0x10(%rcx), %rax
andq $0x0, 0x8(%rax)
movq 0x20(%rcx), %rax
andq $0x0, 0x8(%rax)
jmp 0xf012
pushq $0x28
popq %rdi
callq 0x10d32
movq %rax, 0x45550(%rip)     # 0x54528
movl $0x100, %edi            # imm = 0x100
callq 0x11d60
movq 0x4553f(%rip), %rcx     # 0x54528
movq %rax, (%rcx)
pushq $0x3
popq %rdi
callq 0x11d60
movq 0x4552d(%rip), %rcx     # 0x54528
movq %rax, 0x10(%rcx)
pushq $0x9
popq %rdi
callq 0x11d60
movq 0x4551a(%rip), %rcx     # 0x54528
movq %rax, 0x20(%rcx)
andl $0x0, 0x8(%rcx)
andl $0x0, 0x18(%rcx)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x45399(%rip)     # 0x543c0
jne 0xf034
callq 0x1239c
jmp 0xf034
movl %eax, %edi
callq *%rcx
movq %rbx, %rdi
callq *0x3d2db(%rip)          # 0x4c318
movq 0x3d274(%rip), %rcx     # 0x4c2b8
cmpl $-0x1, %eax
jne 0xf030
pushq $-0x1
popq %rdi
popq %rbx
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O2/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 0x10e25
movl %edi, %eax
andl $0x7f, %eax
cmpb $0x1, 0x3b633(%rip)     # 0x4c3ac
jne 0x10dd4
cmpl $0x2f, %eax
ja 0x10d8f
leaq 0x6a89(%rip), %r8       # 0x17810
movsbl -0x20(%rax,%r8), %r8d
jmp 0x10d9e
leal -0x6e(%rax), %r9d
xorl %r8d, %r8d
cmpl $0x11, %r9d
setb %r8b
testl %r8d, %r8d
je 0x10dd4
leal -0x21(%rax), %r8d
cmpl $0xe, %r8d
ja 0x10e81
testq %rdx, %rdx
je 0x10e60
leal -0x1(%rax), %r8d
shrl %r8d
shrl $0x3, %eax
imull $-0x3, %eax, %eax
addl %r8d, %eax
addl $0xec, %eax
jmp 0x10e5e
cmpl $0x21, %eax
setb %r8b
cmpl $0x7f, %eax
sete %r9b
orb %r8b, %r9b
jne 0x10e25
leal -0x21(%rax), %r8d
leaq 0x39cbe(%rip), %r9      # 0x4aab0
movq (%r9,%r8,8), %r8
testq %r8, %r8
je 0x10e2e
movl %esi, %r9d
andl $0x7f, %r9d
movzwl -0x42(%r8,%r9,2), %r8d
testl %r8d, %r8d
je 0x10e2e
testq %rdx, %rdx
je 0x10e1a
movl %r8d, %eax
shrl $0x8, %eax
movl %eax, (%rdx)
testq %rcx, %rcx
je 0x10e7e
movzbl %r8b, %eax
jmp 0x10e7c
cmpl $0x7f, %edi
jle 0x10e40
pushq $0x1
popq %rax
retq
cmpl $0x75, %eax
setae %al
cmpl $0x7f, %edi
setg %r8b
orb %al, %r8b
jne 0x10e2a
testq %rdx, %rdx
je 0x10e60
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 0x10e7e
xorl %edx, %edx
cmpl $0x60, %esi
setge %dl
addl $0x1f, %edx
testb $0x1, %dil
pushq $0x7e
popq %rax
cmovnel %edx, %eax
addl %esi, %eax
movl %eax, (%rcx)
xorl %eax, %eax
retq
cmpl $0x6e, %eax
setb %r8b
cmpl $0x7f, %eax
sete %r9b
orb %r8b, %r9b
jne 0x10e2a
testq %rdx, %rdx
je 0x10e60
decl %eax
shrl %eax
addl $0xbe, %eax
movl %eax, (%rdx)
jmp 0x10e60
// File: /workspace/github_c_makefile_star2_O2/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 0x110d8
movl %edi, %eax
retq
pushq $-0x1
popq %rax
cmpl $0xc2, %edi
jae 0x110e4
retq
cmpl $0xdf, %edi
ja 0x110fa
andl $0x1f, %edi
shll $0x6, %edi
andl $0x3f, %esi
orl %edi, %esi
movl %esi, %eax
retq
cmpl $0xef, %edi
ja 0x11118
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 0x110e3
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_O2/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 0x111d1
leal -0xc0(%r14), %eax
xorl %r12d, %r12d
cmpl $0x2f, %eax
ja 0x111dc
movl %edx, %ebp
movl %esi, %r15d
movl %r14d, %edi
movq %r13, %rcx
movq %rbx, %r8
callq 0x111f3
testl %eax, %eax
jle 0x111ee
testq %r13, %r13
je 0x111b1
andl $0x0, (%r13)
testq %rbx, %rbx
je 0x111dc
movl %r14d, %edi
movl %r15d, %esi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x110cd
movl %eax, %r14d
orl $0x1000000, %r14d       # imm = 0x1000000
jmp 0x111d6
andl $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 0x111dc
// File: /workspace/github_c_makefile_star2_O2/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:
pushq $0x1
popq %rax
testq %rdx, %rdx
je 0x116b6
leal -0x80(%rdi), %r10d
cmpl $0x7f, %edi
setg %dil
cmpl %ecx, %r10d
setl %cl
andb %dil, %cl
cmpb $0x1, %cl
jne 0x116b6
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 0x116b6
movl %esi, %edx
movzwl -0x100(%rcx,%rdx,2), %ecx
testl %ecx, %ecx
je 0x116b6
cmpb $0x1, 0x42da9(%rip)     # 0x54408
jne 0x11680
movl %ecx, %edx
andl $0xff00, %edx           # imm = 0xFF00
cmpl $0x2d00, %edx           # imm = 0x2D00
sete %dl
cmpw $0xf301, %cx            # imm = 0xF301
setae %sil
orb %dl, %sil
jne 0x116b6
testq %r8, %r8
je 0x116a9
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 0x116b6
movzbl %cl, %ecx
movl %ecx, (%r9)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x116e1
andl $0x0, (%r14)
jmp 0x117a9
cmpl $0xffff, %ebp           # imm = 0xFFFF
ja 0x1172c
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 0x118b8
movl (%r15), %edi
movl (%r12), %esi
movl (%r13), %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0x111f3
testl %eax, %eax
jg 0x1179f
jmp 0x117ad
cmpb $0x1, 0x3ac79(%rip)     # 0x4c3ac
jne 0x1179f
movl %ebp, %eax
shrl $0xa, %eax
addl $0xd7c0, %eax           # imm = 0xD7C0
andl $0x3ff, %edi            # imm = 0x3FF
orl $0xdc00, %edi           # imm = 0xDC00
pushq $0x4
popq %rcx
leaq 0xf8bb(%rip), %rdx      # 0x21010
cmpq $0xa0, %rcx
je 0x11775
movzwl -0x2(%rdx,%rcx), %esi
cmpl %esi, %eax
jne 0x1176f
movzwl (%rdx,%rcx), %esi
cmpl %esi, %edi
je 0x117bc
addq $0x6, %rcx
jmp 0x11755
pushq $0x4
popq %rcx
leaq 0xf931(%rip), %rdx      # 0x210b0
cmpq $0x682, %rcx            # imm = 0x682
je 0x1179f
movzwl -0x2(%rdx,%rcx), %esi
cmpl %esi, %eax
jne 0x11799
movzwl (%rdx,%rcx), %esi
cmpl %esi, %edi
je 0x117c9
addq $0x6, %rcx
jmp 0x1177f
andl $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 0x117d9
movzwl -0x4(%rdx,%rcx), %eax
movzbl %al, %ebp
shrl $0x8, %eax
orl $0x8f00, %eax           # imm = 0x8F00
movl %eax, (%r14)
jmp 0x117a9
// File: /workspace/github_c_makefile_star2_O2/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, 0x42c28(%rip)     # 0x5440c
je 0x118b7
pushq %rbx
movl %edi, %ebx
cmpl $0x1233, %edi           # imm = 0x1233
je 0x1188c
cmpl $0x1159, %ebx           # imm = 0x1159
je 0x11833
cmpl $0x1168, %ebx           # imm = 0x1168
je 0x11871
cmpl $0x1229, %ebx           # imm = 0x1229
je 0x11852
cmpl $0x1013, %ebx           # imm = 0x1013
jne 0x118b0
pushq $0x1b
popq %rdi
callq *0x3aa92(%rip)          # 0x4c2b8
pushq $0x28
popq %rdi
callq *0x3aa89(%rip)          # 0x4c2b8
pushq $0x49
jmp 0x118a9
pushq $0x1b
popq %rdi
callq *0x3aa7c(%rip)          # 0x4c2b8
pushq $0x24
popq %rdi
callq *0x3aa73(%rip)          # 0x4c2b8
pushq $0x28
popq %rdi
callq *0x3aa6a(%rip)          # 0x4c2b8
pushq $0x44
jmp 0x118a9
pushq $0x1b
popq %rdi
callq *0x3aa5d(%rip)          # 0x4c2b8
pushq $0x24
popq %rdi
callq *0x3aa54(%rip)          # 0x4c2b8
pushq $0x28
popq %rdi
callq *0x3aa4b(%rip)          # 0x4c2b8
pushq $0x50
jmp 0x118a9
pushq $0x1b
popq %rdi
callq *0x3aa3e(%rip)          # 0x4c2b8
pushq $0x24
popq %rdi
callq *0x3aa35(%rip)          # 0x4c2b8
movzbl 0x3aa37(%rip), %edi     # 0x4c2c1
jmp 0x118aa
pushq $0x1b
popq %rdi
callq *0x3aa23(%rip)          # 0x4c2b8
pushq $0x24
popq %rdi
callq *0x3aa1a(%rip)          # 0x4c2b8
pushq $0x28
popq %rdi
callq *0x3aa11(%rip)          # 0x4c2b8
pushq $0x51
popq %rdi
callq *0x3aa08(%rip)          # 0x4c2b8
movl %ebx, 0x42b56(%rip)     # 0x5440c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x118cb
movl %eax, (%rsi)
andl $0x0, (%rdx)
jmp 0x118e7
cmpl $0x7ff, %eax            # imm = 0x7FF
ja 0x118f0
shrl $0x6, %eax
orl $0xc0, %eax
movl %eax, (%rsi)
andl $0x3f, %edi
orl $0x80, %edi
movl %edi, (%rdx)
andl $0x0, (%rcx)
xorl %edi, %edi
movl %edi, (%r8)
retq
cmpl $0xffff, %eax           # imm = 0xFFFF
ja 0x1191b
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)
jmp 0x118ea
cmpl $0x10ffff, %eax         # imm = 0x10FFFF
ja 0x11950
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 0x118ec
andl $0x0, (%rsi)
jmp 0x118c6
// File: /workspace/github_c_makefile_star2_O2/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 0xf31a(%rip), %rcx      # 0x20f5c
xorl %r8d, %r8d
cmpq $0x5, %r8
je 0x11c8d
movzwl (%rcx,%r8,2), %r9d
incq %r8
cmpl %edi, %r9d
jne 0x11c45
andl $0x7f, %esi
shll $0x8, %esi
andl $0x7f, %edx
orl %esi, %edx
xorl %eax, %eax
leaq 0xf304(%rip), %rcx      # 0x20f70
xorl %edi, %edi
leaq 0x6(%rdi), %rsi
cmpq $0x9c, %rsi
je 0x11c8d
movzwl (%rcx,%rdi), %r8d
movq %rsi, %rdi
cmpl %r8d, %edx
jne 0x11c6e
movzwl -0x4(%rcx,%rsi), %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x11ccb
cmpl $0x8e, %ebp
je 0x11cd2
movl 0x18(%rbx), %esi
cmpl $0x8f, %ebp
jne 0x11cd6
movl %esi, %eax
andl $0x70, %eax
cmpl $0x20, %eax
je 0x11d06
cmpl $0x70, %eax
je 0x11cfd
cmpl $0x60, %eax
jne 0x11d0f
leaq 0x46f7(%rip), %rax      # 0x163c0
jmp 0x11d1c
movl $0x100, %eax            # imm = 0x100
jmp 0x11d2c
pushq $0x2
jmp 0x11d2b
movl %ebp, %edi
callq 0x11a77
testl %eax, %eax
je 0x11cf9
movl %ebp, %eax
andl $0x70, %eax
cmpl $0x20, %eax
je 0x11d13
cmpl $0x70, %eax
jne 0x11d24
leaq 0x4789(%rip), %rax      # 0x16480
jmp 0x11d1a
pushq $0x40
jmp 0x11d2b
leaq 0x46fc(%rip), %rax      # 0x16400
jmp 0x11d1c
leaq 0x4673(%rip), %rax      # 0x16380
jmp 0x11d1c
pushq $0x10
jmp 0x11d2b
leaq 0x4726(%rip), %rax      # 0x16440
movl %ebp, %esi
andl $0xf, %esi
movl (%rax,%rsi,4), %eax
jmp 0x11d2c
cmpl $0x4f, %eax
jbe 0x11d2f
pushq $0x1
popq %rax
orl %eax, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
orl $-0x1, 0x8(%rdi)
orl $-0x1, 0x14(%rdi)
callq 0x11c8e
movq 0x3a57a(%rip), %rax     # 0x4c2c8
cmpq 0x28(%rbx), %rax
je 0x11d56
popq %rbx
retq
xorl %edi, %edi
xorl %esi, %esi
popq %rbx
jmp 0x11962
// File: /workspace/github_c_makefile_star2_O2/nurse[P]nkf/nkf.c
// Function: nkf_buf_new
static nkf_buf_t *
nkf_buf_new(int length)
{
    nkf_buf_t *buf = nkf_xmalloc(sizeof(nkf_buf_t));
    buf->ptr = nkf_xmalloc(sizeof(nkf_char) * length);
    buf->capa = length;
    buf->len = 0;
    return buf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
pushq $0x18
popq %rdi
callq 0x10d32
movq %rax, %r14
movl %ebx, %ebx
leaq (,%rbx,4), %rdi
callq 0x10d32
movq %rax, 0x10(%r14)
movq %rbx, (%r14)
andq $0x0, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x11e5e
xorl %eax, %eax
cmpb $0x2d, 0x1(%rdi)
sete %al
leaq (%rdi,%rax,2), %rdi
xorl %eax, %eax
leaq 0x34089(%rip), %rcx     # 0x45ef0
xorl %edx, %edx
cmpq $0x33, %rdx
je 0x11ef6
movq %rdx, %rsi
shlq $0x4, %rsi
addq %rcx, %rsi
movq (%rsi), %r8
xorl %r9d, %r9d
movsbl (%r8,%r9), %r11d
movsbl (%rdi,%r9), %r10d
testl %r11d, %r11d
je 0x11ec8
testb %r10b, %r10b
je 0x11ecd
leal -0x61(%r11), %ebx
leal -0x20(%r11), %ebp
cmpb $0x1a, %bl
movzbl %bpl, %ebx
cmovael %r11d, %ebx
leal -0x61(%r10), %r11d
leal -0x20(%r10), %ebp
cmpb $0x1a, %r11b
movzbl %bpl, %r11d
cmovael %r10d, %r11d
incq %r9
cmpl %r11d, %ebx
je 0x11e83
jmp 0x11ecd
testb %r10b, %r10b
je 0x11ed2
incq %rdx
jmp 0x11e69
movslq 0x8(%rsi), %rcx
testq %rcx, %rcx
js 0x11ef4
imulq $0x18, %rcx, %rax
leaq 0x3394a(%rip), %rdx     # 0x45830
addq %rax, %rdx
xorl %eax, %eax
cmpl $0x24, %ecx
cmovbq %rdx, %rax
jmp 0x11ef6
xorl %eax, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
pushq $0x26
popq %rsi
xorl %edi, %edi
callq *0x3a39f(%rip)          # 0x4c2a8
pushq $0x23
popq %rsi
xorl %edi, %edi
callq *0x3a394(%rip)          # 0x4c2a8
andl $0xffffff, %ebx         # imm = 0xFFFFFF
pushq $0xa
popq %rbp
cmpl $0xf4240, %ebx          # imm = 0xF4240
jb 0x11f49
movl $0xf4240, %ecx          # imm = 0xF4240
movl %ebx, %eax
xorl %edx, %edx
divl %ecx
leal -0xa(%rax), %esi
cmpl $0x989680, %ebx         # imm = 0x989680
cmovbl %eax, %esi
orl $0x30, %esi
xorl %edi, %edi
callq *0x3a361(%rip)          # 0x4c2a8
jmp 0x11f55
cmpl $0x186a0, %ebx          # imm = 0x186A0
jb 0x12013
movl $0x186a0, %ecx          # imm = 0x186A0
movl %ebx, %eax
xorl %edx, %edx
divl %ecx
movzbl %al, %eax
movb $0xa, %cl
divb %cl
movzbl %ah, %eax
orb $0x30, %al
movzbl %al, %esi
xorl %edi, %edi
callq *0x3a331(%rip)          # 0x4c2a8
movl $0x2710, %ecx           # imm = 0x2710
movl %ebx, %eax
xorl %edx, %edx
divl %ecx
movw $0xa, %cx
xorl %edx, %edx
divw %cx
orl $0x30, %edx
movzwl %dx, %esi
xorl %edi, %edi
callq *0x3a30f(%rip)          # 0x4c2a8
movl $0x3e8, %ecx            # imm = 0x3E8
movl %ebx, %eax
xorl %edx, %edx
divl %ecx
movw $0xa, %cx
xorl %edx, %edx
divw %cx
orl $0x30, %edx
movzwl %dx, %esi
xorl %edi, %edi
callq *0x3a2ed(%rip)          # 0x4c2a8
pushq $0x64
popq %rcx
movl %ebx, %eax
xorl %edx, %edx
divl %ecx
xorl %edx, %edx
divl %ebp
orl $0x30, %edx
xorl %edi, %edi
movl %edx, %esi
callq *0x3a2d3(%rip)          # 0x4c2a8
movl %ebx, %eax
xorl %edx, %edx
divl %ebp
xorl %edx, %edx
divl %ebp
orl $0x30, %edx
xorl %edi, %edi
movl %edx, %esi
callq *0x3a2bc(%rip)          # 0x4c2a8
movl %ebx, %eax
xorl %edx, %edx
divl %ebp
orl $0x30, %edx
xorl %edi, %edi
movl %edx, %esi
callq *0x3a2a9(%rip)          # 0x4c2a8
movq 0x3a2a2(%rip), %rax     # 0x4c2a8
pushq $0x3b
popq %rsi
xorl %edi, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rax
cmpl $0x2710, %ebx           # imm = 0x2710
jae 0x11f77
cmpl $0x3e8, %ebx            # imm = 0x3E8
jae 0x11f99
cmpl $0x64, %ebx
jae 0x11fbb
cmpl $0xa, %ebx
jae 0x11fd5
jmp 0x11fec
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movl %edi, %ebx
pushq $0x26
popq %rsi
xorl %edi, %edi
callq *0x3a263(%rip)          # 0x4c2a8
pushq $0x23
popq %rsi
xorl %edi, %edi
callq *0x3a258(%rip)          # 0x4c2a8
pushq $0x78
popq %rsi
xorl %edi, %edi
callq *0x3a24d(%rip)          # 0x4c2a8
movq 0x3a246(%rip), %rdi     # 0x4c2a8
movl %ebx, %esi
callq 0x12290
movq 0x3a238(%rip), %rax     # 0x4c2a8
pushq $0x3b
popq %rsi
xorl %edi, %edi
popq %rbx
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebx
pushq $0x5c
popq %rsi
xorl %edi, %edi
callq *0x3a21b(%rip)          # 0x4c2a8
movl %ebx, %r14d
andl $0xffffff, %r14d        # imm = 0xFFFFFF
cmpl $0x10000, %r14d         # imm = 0x10000
jae 0x120d3
pushq $0x75
popq %rsi
xorl %edi, %edi
callq *0x3a1fd(%rip)          # 0x4c2a8
movl %ebx, %eax
shrl $0xc, %eax
andl $0xf, %eax
leaq 0x53da(%rip), %rcx      # 0x17494
movsbl (%rax,%rcx), %esi
xorl %edi, %edi
callq *0x3a1e2(%rip)          # 0x4c2a8
movl %ebx, %eax
shrl $0x8, %eax
andl $0xf, %eax
jmp 0x1216f
shrl $0xa, %r14d
leal 0xd7c0(%r14), %r15d
pushq $0x75
popq %rbp
xorl %edi, %edi
movl %ebp, %esi
callq *0x3a1bd(%rip)          # 0x4c2a8
movl %r15d, %eax
shrl $0xc, %eax
andl $0xf, %eax
leaq 0x5399(%rip), %r12      # 0x17494
movsbl (%rax,%r12), %esi
xorl %edi, %edi
callq *0x3a1a0(%rip)          # 0x4c2a8
movl %r15d, %eax
shrl $0x8, %eax
andl $0xf, %eax
movsbl (%rax,%r12), %esi
xorl %edi, %edi
callq *0x3a18a(%rip)          # 0x4c2a8
shrl $0x4, %r15d
andl $0xf, %r15d
movsbl (%r15,%r12), %esi
xorl %edi, %edi
callq *0x3a175(%rip)          # 0x4c2a8
andl $0xf, %r14d
movsbl (%r14,%r12), %esi
xorl %edi, %edi
callq *0x3a164(%rip)          # 0x4c2a8
pushq $0x5c
popq %rsi
xorl %edi, %edi
callq *0x3a159(%rip)          # 0x4c2a8
xorl %edi, %edi
movl %ebp, %esi
callq *0x3a14f(%rip)          # 0x4c2a8
pushq $0x44
popq %rsi
xorl %edi, %edi
callq *0x3a144(%rip)          # 0x4c2a8
movl %ebx, %eax
shrl $0x8, %eax
andl $0x3, %eax
orl $0xc, %eax
movl %eax, %eax
leaq 0x531c(%rip), %r14      # 0x17494
movsbl (%rax,%r14), %esi
xorl %edi, %edi
callq *0x3a123(%rip)          # 0x4c2a8
movl %ebx, %eax
shrl $0x4, %eax
andl $0xf, %eax
movsbl (%rax,%r14), %esi
xorl %edi, %edi
callq *0x3a10e(%rip)          # 0x4c2a8
movq 0x3a107(%rip), %rax     # 0x4c2a8
andl $0xf, %ebx
movsbl (%rbx,%r14), %esi
xorl %edi, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movl %edi, %ebx
pushq $0x5c
popq %rsi
xorl %edi, %edi
callq *0x3a0e5(%rip)          # 0x4c2a8
pushq $0x78
popq %rsi
xorl %edi, %edi
callq *0x3a0da(%rip)          # 0x4c2a8
pushq $0x7b
popq %rsi
xorl %edi, %edi
callq *0x3a0cf(%rip)          # 0x4c2a8
movq 0x3a0c8(%rip), %rdi     # 0x4c2a8
movl %ebx, %esi
callq 0x12290
movq 0x3a0ba(%rip), %rax     # 0x4c2a8
pushq $0x7d
popq %rsi
xorl %edi, %edi
popq %rbx
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/nurse[P]nkf/nkf.c
// Function: nkf_each_char_to_hex
static void
nkf_each_char_to_hex(void (*f)(nkf_char c2,nkf_char c1), nkf_char c)
{
    int shift = 20;
    c &= VALUE_MASK;
    while(shift >= 0){
	if(c >= NKF_INT32_C(1)<<shift){
	    while(shift >= 0){
		(*f)(0, bin2hex(c>>shift));
		shift -= 4;
	    }
	}else{
	    shift -= 4;
	}
    }
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
andl $0xffffff, %ebx         # imm = 0xFFFFFF
pushq $0x14
popq %rbp
pushq $0x1
popq %r15
leaq 0x51e3(%rip), %r12      # 0x17494
testl %ebp, %ebp
js 0x122e1
movl %r15d, %eax
movl %ebp, %ecx
shll %cl, %eax
cmpl %eax, %ebx
jge 0x122db
addl $-0x4, %ebp
jmp 0x122b1
movl %ebx, %eax
movl %ebp, %ecx
shrl %cl, %eax
andl $0xf, %eax
movsbl (%rax,%r12), %esi
xorl %edi, %edi
callq *%r14
addl $-0x4, %ebp
testl %ebp, %ebp
jns 0x122c5
jmp 0x122b1
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/nurse[P]nkf/nkf.c
// Function: nkf_default_encoding
static nkf_encoding*
nkf_default_encoding(void)
{
    nkf_encoding *enc = 0;
#ifdef DEFAULT_CODE_LOCALE
    enc = nkf_locale_encoding();
#elif defined(DEFAULT_ENCIDX)
    enc = nkf_enc_from_index(DEFAULT_ENCIDX);
#endif
    if (!enc) enc = nkf_utf8_encoding();
    return enc;
}

// Assembly:
pushq %rax
pushq $0xe
popq %rdi
callq 0xc190
testq %rax, %rax
je 0x12305
movq %rax, %rdi
callq 0x11e4a
testq %rax, %rax
jne 0x1230c
leaq 0x3371c(%rip), %rax     # 0x45a28
popq %rcx
retq