LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/obo_parse_tree.c
// Function: validate_value
static int validate_value(const GtOBOStanza *obo_stanza, const char *value,
                          GtError *err)
{
  gt_error_check(err);
  gt_assert(obo_stanza && value);
  if (!gt_obo_stanza_get_value(obo_stanza, value, 0)) {
    gt_error_set(err, "%s stanza starting on line "GT_WU" in file \"%s\" lacks "
                 "required \"%s\" tag", gt_obo_stanza_get_type(obo_stanza),
                 gt_obo_stanza_line(obo_stanza),
                 gt_obo_stanza_filename(obo_stanza), value);
    return -1;
  }
  return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x50cbb3
movq 0x18(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x50cb7b
jmp 0x50cbb3
movq 0x12f41e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x9487(%rip), %rsi      # 0x516013
leaq 0x962c(%rip), %rdx      # 0x5161bf
leaq 0xb7619(%rip), %rcx     # 0x5c41b3
leaq 0xb73b5(%rip), %r8      # 0x5c3f56
movl $0x75, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x50cbb5
jmp 0x50cbb7
cmpq $0x0, 0x28(%rsp)
je 0x50cbc7
cmpq $0x0, 0x20(%rsp)
jne 0x50cbff
movq 0x12f3d2(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x943b(%rip), %rsi      # 0x516013
leaq 0xb75e3(%rip), %rdx     # 0x5c41c2
leaq 0xb75cd(%rip), %rcx     # 0x5c41b3
leaq 0xb7369(%rip), %r8      # 0x5c3f56
movl $0x76, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x50cc01
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x50cec0
cmpq $0x0, %rax
jne 0x50cc79
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0x50ce70
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x50d060
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x50d000
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %rax, %r8
movq 0x20(%rsp), %r9
leaq 0xb756e(%rip), %rsi     # 0x5c41d6
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x50cc81
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/obo_stanza.c
// Function: gt_obo_stanza_new
GtOBOStanza* gt_obo_stanza_new(const char *type, GtUword line,
                               GtStr *filename)
{
  GtOBOStanza *obo_stanza = gt_malloc(sizeof *obo_stanza);
  obo_stanza->type = gt_cstr_dup(type);
  obo_stanza->content = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
                                       (GtFree) gt_str_array_delete);
  obo_stanza->line = line;
  obo_stanza->filename = gt_str_ref(filename);
  return obo_stanza;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x20, %edi
leaq 0xb756b(%rip), %rsi     # 0x5c421a
movl $0x23, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0xa2db0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movl $0x1, %edi
leaq -0x4242af(%rip), %rsi   # 0xe8a30
leaq -0x3ecfc6(%rip), %rdx   # 0x11fd20
callq 0xe0c40
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rdi
callq 0x11e360
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/obo_stanza.c
// Function: gt_obo_stanza_delete
void gt_obo_stanza_delete(GtOBOStanza *obo_stanza)
{
  if (!obo_stanza) return;
  gt_str_delete(obo_stanza->filename);
  gt_hashmap_delete(obo_stanza->content);
  gt_free(obo_stanza->type);
  gt_free(obo_stanza);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x50cd3e
jmp 0x50cd85
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11f560
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xe1770
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0xb74b4(%rip), %rsi     # 0x5c421a
movl $0x31, %edx
callq 0xe88c0
movq (%rsp), %rdi
leaq 0xb749f(%rip), %rsi     # 0x5c421a
movl $0x32, %edx
callq 0xe88c0
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/obo_stanza.c
// Function: gt_obo_stanza_add
void gt_obo_stanza_add(GtOBOStanza *obo_stanza, const char *tag,
                       const char *value)
{
  GtStrArray *sa;
  gt_assert(obo_stanza && tag && value);
  if (!(sa = gt_hashmap_get(obo_stanza->content, tag))) {
    sa = gt_str_array_new();
    gt_str_array_add_cstr(sa, value);
    gt_hashmap_add(obo_stanza->content, gt_cstr_dup(tag), sa);
  }
  else
    gt_str_array_add_cstr(sa, value);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x50cdbb
cmpq $0x0, 0x18(%rsp)
je 0x50cdbb
cmpq $0x0, 0x10(%rsp)
jne 0x50cdf3
movq 0x12f1de(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x9247(%rip), %rsi      # 0x516013
leaq 0xb7461(%rip), %rdx     # 0x5c4234
leaq 0xb7475(%rip), %rcx     # 0x5c424f
leaq 0xb7439(%rip), %r8      # 0x5c421a
movl $0x39, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x50cdf5
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0xe0f20
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x50ce56
callq 0x11f5c0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11f720
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0xa2db0
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x8(%rsp), %rdx
callq 0xe0fc0
jmp 0x50ce65
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x11f720
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x50cf13
movq 0x12f0be(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x9127(%rip), %rsi      # 0x516013
leaq 0xb7258(%rip), %rdx     # 0x5c414b
leaq 0xb737e(%rip), %rcx     # 0x5c4278
leaq 0xb7319(%rip), %r8      # 0x5c421a
movl $0x4e, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x50cf15
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0xe0f20
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x50cf47
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x11f8c0
movq %rax, 0x20(%rsp)
jmp 0x50cf50
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x50cfae
movq 0x12f023(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x908c(%rip), %rsi      # 0x516013
leaq 0xb71bd(%rip), %rdx     # 0x5c414b
leaq 0xb72fb(%rip), %rcx     # 0x5c4290
leaq 0xb727e(%rip), %r8      # 0x5c421a
movl $0x58, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x50cfb0
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0xe0f20
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x50cfdf
movq 0x8(%rsp), %rdi
callq 0x11fcc0
movq %rax, 0x20(%rsp)
jmp 0x50cfe8
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x38, %edi
leaq 0xb7203(%rip), %rsi     # 0x5c42cd
movl $0x1f, %edx
callq 0xe80f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
xorl %esi, %esi
leaq 0xb71c4(%rip), %rdx     # 0x5c42cd
movl $0x23, %ecx
callq 0xd9e50
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x10(%rsp), %rax
movq $0x400, 0x10(%rax)      # imm = 0x400
movq 0x20(%rsp), %rdi
callq 0x11d510
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
shlq $0x2, %rdi
leaq 0xb716a(%rip), %rsi     # 0x5c42cd
movl $0x28, %edx
callq 0xe80f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %r8
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
shlq $0x2, %rax
movl $0x2a, %esi
leaq 0xb7132(%rip), %rdx     # 0x5c42cd
movl $0x1, %r9d
movl %r9d, %ecx
movq %rax, (%rsp)
callq 0x4bea60
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq (%rax), %rdi
movq (%rsp), %rax
movq 0x8(%rax), %rdx
movq (%rsp), %rax
movq 0x30(%rax), %rcx
movl $0x4, %esi
callq 0x126d30
movq (%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xe87(%rip), %rdi       # 0x2004
movl $0x41, %esi
movl $0x1ff, %edx            # imm = 0x1FF
movb $0x0, %al
callq 0x1050
movl %eax, -0x14(%rbp)
xorl %ecx, %ecx
movl $0x1, %edx
movl %ecx, %edi
movl %ecx, %esi
movb $0x0, %al
callq 0x1040
cmpq $-0x1, %rax
jne 0x11c0
leaq 0xe76(%rip), %rdi       # 0x2026
movb $0x0, %al
callq 0x1030
movl $0x1, -0x4(%rbp)
jmp 0x11ee
cmpl $0x7a69, -0x14(%rbp)    # imm = 0x7A69
jne 0x11d9
leaq 0xe68(%rip), %rdi       # 0x2038
movb $0x0, %al
callq 0x1030
jmp 0x11e7
leaq 0xe73(%rip), %rdi       # 0x2053
movb $0x0, %al
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x1013, -0x8(%rbp)     # imm = 0x1013
je 0xcc1d
movl $0xa1, %eax
cmpl -0x8(%rbp), %eax
jg 0xcc4d
cmpl $0xdf, -0x8(%rbp)
jg 0xcc4d
cmpl $0x0, 0x4d83c(%rip)     # 0x5a460
je 0xcc3f
cmpl $0x0, 0x45663(%rip)     # 0x52290
jne 0xcc3f
movl $0x22, -0x8(%rbp)
movl $0x2e, -0xc(%rbp)
jmp 0xcc48
movl -0xc(%rbp), %eax
andl $0x7f, %eax
movl %eax, -0xc(%rbp)
jmp 0xcd0b
cmpl $-0x1, -0x8(%rbp)
je 0xcc5f
cmpl $0x0, -0x8(%rbp)
je 0xcc5f
cmpl $0x20, -0x8(%rbp)
jge 0xcc64
jmp 0xcd09
cmpl $0x0, 0x457b1(%rip)     # 0x5241c
jne 0xcce1
movl $0xf0, %eax
cmpl -0x8(%rbp), %eax
jg 0xcce1
cmpl $0xf9, -0x8(%rbp)
jg 0xcce1
movl $0x40, %eax
cmpl -0xc(%rbp), %eax
jg 0xcce1
cmpl $0xfc, -0xc(%rbp)
jg 0xcce1
cmpl $0x7f, -0xc(%rbp)
jne 0xcca2
movl $0x0, -0x4(%rbp)
jmp 0xcd21
movl -0x8(%rbp), %eax
subl $0xf0, %eax
imull $0xbc, %eax, %eax
movl -0xc(%rbp), %ecx
subl $0x40, %ecx
movl $0x7e, %edx
cmpl -0xc(%rbp), %edx
setl %dl
andb $0x1, %dl
movzbl %dl, %edx
subl %edx, %ecx
addl %ecx, %eax
addl $0xe000, %eax           # imm = 0xE000
orl $0x1000000, %eax        # imm = 0x1000000
movl %eax, -0xc(%rbp)
movl $0x0, -0x8(%rbp)
jmp 0xcd07
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
leaq -0x8(%rbp), %rdx
leaq -0xc(%rbp), %rcx
callq 0x121e0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xcd05
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcd21
jmp 0xcd07
jmp 0xcd09
jmp 0xcd0b
movq 0x45586(%rip), %rax     # 0x52298
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq *%rax
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
incl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0xdeaa
movq -0x18(%rbp), %rax
leaq 0xe2d6(%rip), %rcx      # 0x1c068
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x13b70
jmp 0xdeaa
cmpl $0x7f, -0xc(%rbp)
jg 0xddb7
jmp 0xdeaa
movl -0xc(%rbp), %eax
andl $0xff000000, %eax       # imm = 0xFF000000
cmpl $0x1000000, %eax        # imm = 0x1000000
jne 0xddcb
jmp 0xdeaa
movl $0x8e, %eax
cmpl -0xc(%rbp), %eax
je 0xdde8
movl $0xa1, %eax
cmpl -0xc(%rbp), %eax
jg 0xde01
cmpl $0xfe, -0xc(%rbp)
jg 0xde01
movq -0x8(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x13ba0
jmp 0xde2f
movl $0x8f, %eax
cmpl -0xc(%rbp), %eax
jne 0xde24
movq -0x8(%rbp), %rax
movl $0x2, 0x8(%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x13ba0
jmp 0xde2d
movq -0x8(%rbp), %rdi
callq 0x13d90
jmp 0xde2f
jmp 0xde31
jmp 0xde33
jmp 0xdeaa
movl $0xa1, %eax
cmpl -0xc(%rbp), %eax
jg 0xde68
cmpl $0xfe, -0xc(%rbp)
jg 0xde68
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x13ba0
movq -0x8(%rbp), %rdi
callq 0x13bd0
movq -0x8(%rbp), %rdi
callq 0x13d70
jmp 0xde71
movq -0x8(%rbp), %rdi
callq 0x13d90
jmp 0xdeaa
movl $0xa1, %eax
cmpl -0xc(%rbp), %eax
jg 0xde9f
cmpl $0xfe, -0xc(%rbp)
jg 0xde9f
movq -0x8(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x13ba0
jmp 0xdea8
movq -0x8(%rbp), %rdi
callq 0x13d90
jmp 0xdeaa
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
cmpq $0x0, 0x4bbac(%rip)     # 0x5a598
je 0xea1f
movq 0x4bba3(%rip), %rax     # 0x5a598
movq (%rax), %rdi
callq 0x13e40
movq 0x4bb94(%rip), %rax     # 0x5a598
movq 0x10(%rax), %rdi
callq 0x13e40
movq 0x4bb84(%rip), %rax     # 0x5a598
movq 0x20(%rax), %rdi
callq 0x13e40
jmp 0xea77
movl $0x28, %edi
callq 0x11d50
movq %rax, 0x4bb68(%rip)     # 0x5a598
movl $0x100, %edi            # imm = 0x100
callq 0x13e60
movq %rax, %rcx
movq 0x4bb54(%rip), %rax     # 0x5a598
movq %rcx, (%rax)
movl $0x3, %edi
callq 0x13e60
movq %rax, %rcx
movq 0x4bb3d(%rip), %rax     # 0x5a598
movq %rcx, 0x10(%rax)
movl $0x9, %edi
callq 0x13e60
movq %rax, %rcx
movq 0x4bb25(%rip), %rax     # 0x5a598
movq %rcx, 0x20(%rax)
movq 0x4bb1a(%rip), %rax     # 0x5a598
movl $0x0, 0x8(%rax)
movq 0x4bb0c(%rip), %rax     # 0x5a598
movl $0x0, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x2, 0x49c0d(%rip)     # 0x5a430
jne 0x1082a
callq 0x14a10
jmp 0x1082c
movq 0x41ad5(%rip), %rax     # 0x52308
movq -0x8(%rbp), %rdi
callq *%rax
movl %eax, -0xc(%rbp)
cmpl $-0x1, %eax
je 0x1084f
movq 0x41a60(%rip), %rax     # 0x522a8
movl -0xc(%rbp), %edi
callq *%rax
jmp 0x1082c
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq *0x41a4e(%rip)          # 0x522a8
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nurse[P]nkf/nkf.c
// Function: print_guessed_code
static void
print_guessed_code(char *filename)
{
    if (filename != NULL) printf("%s: ", filename);
    if (input_codename && !*input_codename) {
	printf("BINARY\n");
    } else {
	input_codename = get_guessed_code();
	if (guess_f == 1) {
	    printf("%s\n", input_codename);
	} else {
	    printf("%s%s%s%s\n",
		   input_codename,
		   iconv != w_iconv16 && iconv != w_iconv32 ? "" :
		   input_endian == ENDIAN_LITTLE ? " LE" :
		   input_endian == ENDIAN_BIG ? " BE" :
		   "[BUG]",
		   input_bom_f ? " (BOM)" : "",
		   input_eol == CR   ? " (CR)" :
		   input_eol == LF   ? " (LF)" :
		   input_eol == CRLF ? " (CRLF)" :
		   input_eol == EOF  ? " (MIXED NL)" :
		   "");
	}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x11bb5
movq -0x8(%rbp), %rsi
leaq 0xc020(%rip), %rdi      # 0x1dbce
movb $0x0, %al
callq 0xc0c0
cmpq $0x0, 0x4887b(%rip)     # 0x5a438
je 0x11bde
movq 0x48872(%rip), %rax     # 0x5a438
cmpb $0x0, (%rax)
jne 0x11bde
leaq 0xc001(%rip), %rdi      # 0x1dbd3
movb $0x0, %al
callq 0xc0c0
jmp 0x11d3d
callq 0x1af50
movq %rax, 0x4884e(%rip)     # 0x5a438
cmpl $0x1, 0x4081f(%rip)     # 0x52410
jne 0x11c0d
movq 0x4883e(%rip), %rsi     # 0x5a438
leaq 0xb380(%rip), %rdi      # 0x1cf81
movb $0x0, %al
callq 0xc0c0
jmp 0x11d3b
movq 0x48824(%rip), %rax     # 0x5a438
movq %rax, -0x10(%rbp)
leaq -0x46af(%rip), %rax     # 0xd570
cmpq %rax, 0x40692(%rip)     # 0x522b8
je 0x11c45
leaq -0x414f(%rip), %rax     # 0xdae0
cmpq %rax, 0x40682(%rip)     # 0x522b8
je 0x11c45
leaq 0xb8f3(%rip), %rax      # 0x1d532
movq %rax, -0x18(%rbp)
jmp 0x11c82
cmpl $0x2, 0x4067c(%rip)     # 0x522c8
jne 0x11c5b
leaq 0xbf90(%rip), %rax      # 0x1dbe5
movq %rax, -0x20(%rbp)
jmp 0x11c7a
movl 0x40667(%rip), %edx     # 0x522c8
leaq 0xbf85(%rip), %rax      # 0x1dbed
leaq 0xbf7a(%rip), %rcx      # 0x1dbe9
cmpl $0x1, %edx
cmoveq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl 0x48df0(%rip), %edx     # 0x5aa80
leaq 0xb89b(%rip), %rax      # 0x1d532
leaq 0xbf55(%rip), %rcx      # 0x1dbf3
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x28(%rbp)
cmpl $0xd, 0x48790(%rip)     # 0x5a440
jne 0x11cbf
leaq 0xbf41(%rip), %rax      # 0x1dbfa
movq %rax, -0x38(%rbp)
jmp 0x11d1d
cmpl $0xa, 0x4877a(%rip)     # 0x5a440
jne 0x11cd5
leaq 0xbf31(%rip), %rax      # 0x1dc00
movq %rax, -0x40(%rbp)
jmp 0x11d15
cmpl $0xd0a, 0x48761(%rip)   # imm = 0xD0A
jne 0x11cee
leaq 0xbf1e(%rip), %rax      # 0x1dc06
movq %rax, -0x48(%rbp)
jmp 0x11d0d
movl 0x4874c(%rip), %edx     # 0x5a440
leaq 0xb837(%rip), %rax      # 0x1d532
leaq 0xbf0c(%rip), %rcx      # 0x1dc0e
cmpl $-0x1, %edx
cmoveq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %r8
leaq 0xbea7(%rip), %rdi      # 0x1dbdb
movb $0x0, %al
callq 0xc0c0
jmp 0x11d3d
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nurse[P]nkf/nkf.c
// Function: nkf_xmalloc
static void *
nkf_xmalloc(size_t size)
{
    void *ptr;

    if (size == 0) size = 1;

    ptr = malloc(size);
    if (ptr == NULL) {
	perror("can't malloc");
	exit(EXIT_FAILURE);
    }

    return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x11d6b
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc160
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x11d95
leaq 0xbe94(%rip), %rdi      # 0x1dc1a
callq 0xc1f0
movl $0x1, %edi
callq 0xc220
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nurse[P]nkf/nkf.c
// Function: get_backup_filename
static char*
get_backup_filename(const char *suffix, const char *filename)
{
    char *backup_filename;
    int asterisk_count = 0;
    int i, j;
    int filename_length = strlen(filename);

    for(i = 0; suffix[i]; i++){
	if(suffix[i] == '*') asterisk_count++;
    }

    if(asterisk_count){
	backup_filename = nkf_xmalloc(strlen(suffix) + (asterisk_count * (filename_length - 1)) + 1);
	for(i = 0, j = 0; suffix[i];){
	    if(suffix[i] == '*'){
		backup_filename[j] = '\0';
		strncat(backup_filename, filename, filename_length);
		i++;
		j += filename_length;
	    }else{
		backup_filename[j++] = suffix[i++];
	    }
	}
	backup_filename[j] = '\0';
    }else{
	j = filename_length + strlen(suffix);
	backup_filename = nkf_xmalloc(j + 1);
	strcpy(backup_filename, filename);
	strcat(backup_filename, suffix);
	backup_filename[j] = '\0';
    }
    return backup_filename;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc090
movl %eax, -0x28(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x11dff
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2a, %eax
jne 0x11df2
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x11df4
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x11dca
cmpl $0x0, -0x1c(%rbp)
je 0x11ecb
movq -0x8(%rbp), %rdi
callq 0xc090
movq %rax, %rdi
movl -0x1c(%rbp), %eax
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
imull %ecx, %eax
cltq
addq %rax, %rdi
addq $0x1, %rdi
callq 0x11d50
movq %rax, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x11ebd
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2a, %eax
jne 0x11e91
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x28(%rbp), %rdx
callq 0xc100
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x28(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x11ebb
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x20(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x24(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x11e41
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x11f21
movslq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc090
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x11d50
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc070
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xc210
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nurse[P]nkf/nkf.c
// Function: is_x0213_2_in_x0212
static int
is_x0213_2_in_x0212(nkf_char c1)
{
    static const char x0213_2_table[] =
	{0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1};
    int ku = c1 - 0x20;
    if (ku <= 15)
	return x0213_2_table[ku]; /* 1, 3-5, 8, 12-15 */
    if (78 <= ku && ku <= 94)
	return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
subl $0x20, %eax
movl %eax, -0xc(%rbp)
cmpl $0xf, -0xc(%rbp)
jg 0x1251a
movslq -0xc(%rbp), %rcx
leaq 0xa09f(%rip), %rax      # 0x1c5b0
movsbl (%rax,%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x1253a
movl $0x4e, %eax
cmpl -0xc(%rbp), %eax
jg 0x12533
cmpl $0x5e, -0xc(%rbp)
jg 0x12533
movl $0x1, -0x4(%rbp)
jmp 0x1253a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nurse[P]nkf/nkf.c
// Function: x0212_shift
static nkf_char
x0212_shift(nkf_char c)
{
    nkf_char ret = c;
    c &= 0x7f;
    if (is_eucg3(ret)){
	if (0x75 <= c && c <= 0x7f){
	    ret = c + (0x109 - 0x75);
	}
    }else{
	if (0x75 <= c && c <= 0x7f){
	    ret = c + (0x113 - 0x75);
	}
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl $0x7f, %eax
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
movzwl %ax, %eax
sarl $0x8, %eax
cmpl $0x8f, %eax
jne 0x12583
movl $0x75, %eax
cmpl -0x4(%rbp), %eax
jg 0x12581
cmpl $0x7f, -0x4(%rbp)
jg 0x12581
movl -0x4(%rbp), %eax
addl $0x94, %eax
movl %eax, -0x8(%rbp)
jmp 0x125a0
movl $0x75, %eax
cmpl -0x4(%rbp), %eax
jg 0x1259e
cmpl $0x7f, -0x4(%rbp)
jg 0x1259e
movl -0x4(%rbp), %eax
addl $0x9e, %eax
movl %eax, -0x8(%rbp)
jmp 0x125a0
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nurse[P]nkf/nkf.c
// Function: x0212_unshift
static nkf_char
x0212_unshift(nkf_char c)
{
    nkf_char ret = c;
    if (0x7f <= c && c <= 0x88){
	ret = c + (0x75 - 0x7f);
    }else if (0x89 <= c && c <= 0x92){
	ret = PREFIX_EUCG3 | 0x80 | (c + (0x75 - 0x89));
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl $0x7f, %eax
cmpl -0x4(%rbp), %eax
jg 0x125db
cmpl $0x88, -0x4(%rbp)
jg 0x125db
movl -0x4(%rbp), %eax
addl $-0xa, %eax
movl %eax, -0x8(%rbp)
jmp 0x125fe
movl $0x89, %eax
cmpl -0x4(%rbp), %eax
jg 0x125fc
cmpl $0x92, -0x4(%rbp)
jg 0x125fc
movl -0x4(%rbp), %eax
addl $-0x14, %eax
orl $0x8f80, %eax           # imm = 0x8F80
movl %eax, -0x8(%rbp)
jmp 0x125fe
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpl $0x7f, -0x8(%rbp)
jg 0x126a1
movl -0x8(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x12760
cmpl $0xc1, -0x8(%rbp)
jg 0x126b6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12766
cmpl $0xdf, -0x8(%rbp)
jg 0x126dc
movl -0x8(%rbp), %eax
andl $0x1f, %eax
shll $0x6, %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
andl $0x3f, %eax
orl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x1275c
cmpl $0xef, -0x8(%rbp)
jg 0x1270e
movl -0x8(%rbp), %eax
andl $0xf, %eax
shll $0xc, %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
andl $0x3f, %eax
shll $0x6, %eax
orl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
andl $0x3f, %eax
orl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x1275a
cmpl $0xf4, -0xc(%rbp)
jg 0x1274f
movl -0x8(%rbp), %eax
andl $0xf, %eax
shll $0x12, %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
andl $0x3f, %eax
shll $0xc, %eax
orl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
andl $0x3f, %eax
shll $0x6, %eax
orl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
andl $0x3f, %eax
orl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x12758
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12766
jmp 0x1275a
jmp 0x1275c
jmp 0x1275e
jmp 0x12760
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nurse[P]nkf/nkf.c
// Function: x0213_wait_combining_p
static int
x0213_wait_combining_p(nkf_char wc)
{
    int i;
    for (i = 0; i < sizeof_x0213_combining_table; i++) {
	if (x0213_combining_table[i][1] == wc) {
	    return TRUE;
	}
    }
    return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x19, -0xc(%rbp)
jge 0x127b5
movslq -0xc(%rbp), %rcx
leaq 0x14b71(%rip), %rax     # 0x27300
imulq $0x6, %rcx, %rcx
addq %rcx, %rax
movzwl 0x2(%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x127a8
movl $0x1, -0x4(%rbp)
jmp 0x127bc
jmp 0x127aa
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1277e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x1280b
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x1287e
movl $0xc0, %eax
cmpl -0x4(%rbp), %eax
jg 0x1287c
cmpl $0xef, -0x4(%rbp)
jg 0x1287c
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0x12890
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x1287a
cmpq $0x0, -0x18(%rbp)
je 0x1284e
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x12873
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
xorl %ecx, %ecx
callq 0x12680
movl %eax, %ecx
orl $0x1000000, %ecx        # imm = 0x1000000
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x24(%rbp)
jmp 0x1287c
jmp 0x1287e
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x12eec
movl $0x1, -0x4(%rbp)
jmp 0x13012
movl -0x8(%rbp), %eax
subl $0x80, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x12f05
movl -0x1c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jg 0x12f11
movl $0x1, -0x4(%rbp)
jmp 0x13012
movq -0x18(%rbp), %rax
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x12f34
movl $0x1, -0x4(%rbp)
jmp 0x13012
movl -0xc(%rbp), %eax
subl $0x80, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x12f4f
movl $0x40, %eax
cmpl -0xc(%rbp), %eax
jg 0x12f5b
movl $0x1, -0x4(%rbp)
jmp 0x13012
movq -0x40(%rbp), %rax
movslq -0xc(%rbp), %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x42(%rbp)
movzwl -0x42(%rbp), %eax
cmpl $0x0, %eax
jne 0x12f80
movl $0x1, -0x4(%rbp)
jmp 0x13012
cmpl $0x0, 0x474f1(%rip)     # 0x5a478
je 0x12fa9
movzwl -0x42(%rbp), %eax
sarl $0x8, %eax
cmpl $0x2d, %eax
je 0x12fa0
movzwl -0x42(%rbp), %eax
cmpl $0xf300, %eax           # imm = 0xF300
jle 0x12fa9
movl $0x1, -0x4(%rbp)
jmp 0x13012
movzwl -0x42(%rbp), %eax
sarl $0x8, %eax
movl %eax, -0x34(%rbp)
movzwl -0x42(%rbp), %eax
cmpl $0x7fff, %eax           # imm = 0x7FFF
jle 0x12fd2
movl -0x34(%rbp), %eax
andl $0x7f, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
orl $0x8f00, %eax           # imm = 0x8F00
movl %eax, -0x34(%rbp)
cmpl $0xe, -0x34(%rbp)
jne 0x12fdf
movl $0x1013, -0x34(%rbp)    # imm = 0x1013
movzwl -0x42(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x8(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x12ffb
movl -0x34(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x1300b
movl -0x8(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0x4720b(%rip), %eax     # 0x5a47c
cmpl -0x4(%rbp), %eax
jne 0x1327b
jmp 0x133db
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $0x1, %eax
je 0x132d3
jmp 0x13288
movl -0x8(%rbp), %eax
subl $0x1013, %eax           # imm = 0x1013
je 0x132f9
jmp 0x13294
movl -0x8(%rbp), %eax
subl $0x1159, %eax           # imm = 0x1159
je 0x1334a
jmp 0x132a4
movl -0x8(%rbp), %eax
subl $0x1168, %eax           # imm = 0x1168
je 0x1331f
jmp 0x132b0
movl -0x8(%rbp), %eax
subl $0x1229, %eax           # imm = 0x1229
je 0x133a6
jmp 0x132c0
movl -0x8(%rbp), %eax
subl $0x1233, %eax           # imm = 0x1233
je 0x13378
jmp 0x133d2
movl $0x1b, %edi
callq *0x3efca(%rip)          # 0x522a8
movl $0x2e, %edi
callq *0x3efbf(%rip)          # 0x522a8
movl $0x41, %edi
callq *0x3efb4(%rip)          # 0x522a8
jmp 0x133d2
movl $0x1b, %edi
callq *0x3efa4(%rip)          # 0x522a8
movl $0x28, %edi
callq *0x3ef99(%rip)          # 0x522a8
movl $0x49, %edi
callq *0x3ef8e(%rip)          # 0x522a8
jmp 0x133d2
movl $0x1b, %edi
callq *0x3ef7e(%rip)          # 0x522a8
movl $0x24, %edi
callq *0x3ef73(%rip)          # 0x522a8
movq 0x3ef6c(%rip), %rax     # 0x522a8
movzbl 0x3ef6e(%rip), %edi     # 0x522b1
callq *%rax
jmp 0x133d2
movl $0x1b, %edi
callq *0x3ef53(%rip)          # 0x522a8
movl $0x24, %edi
callq *0x3ef48(%rip)          # 0x522a8
movl $0x28, %edi
callq *0x3ef3d(%rip)          # 0x522a8
movl $0x44, %edi
callq *0x3ef32(%rip)          # 0x522a8
jmp 0x133d2
movl $0x1b, %edi
callq *0x3ef25(%rip)          # 0x522a8
movl $0x24, %edi
callq *0x3ef1a(%rip)          # 0x522a8
movl $0x28, %edi
callq *0x3ef0f(%rip)          # 0x522a8
movl $0x51, %edi
callq *0x3ef04(%rip)          # 0x522a8
jmp 0x133d2
movl $0x1b, %edi
callq *0x3eef7(%rip)          # 0x522a8
movl $0x24, %edi
callq *0x3eeec(%rip)          # 0x522a8
movl $0x28, %edi
callq *0x3eee1(%rip)          # 0x522a8
movl $0x50, %edi
callq *0x3eed6(%rip)          # 0x522a8
movl -0x4(%rbp), %eax
movl %eax, 0x470a1(%rip)     # 0x5a47c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x4(%rbp), %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
movl %eax, -0x4(%rbp)
cmpl $0x80, -0x4(%rbp)
jge 0x13447
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
jmp 0x13571
cmpl $0x800, -0x4(%rbp)      # imm = 0x800
jge 0x1348d
movl -0x4(%rbp), %ecx
sarl $0x6, %ecx
orl $0xc0, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x4(%rbp), %ecx
andl $0x3f, %ecx
orl $0x80, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
jmp 0x1356f
movl -0x4(%rbp), %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
cmpl $0xffff, %eax           # imm = 0xFFFF
jg 0x134e4
movl -0x4(%rbp), %ecx
sarl $0xc, %ecx
orl $0xe0, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x4(%rbp), %ecx
sarl $0x6, %ecx
andl $0x3f, %ecx
orl $0x80, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x4(%rbp), %ecx
andl $0x3f, %ecx
orl $0x80, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
jmp 0x1356d
movl -0x4(%rbp), %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
cmpl $0x10ffff, %eax         # imm = 0x10FFFF
jg 0x13543
movl -0x4(%rbp), %ecx
sarl $0x12, %ecx
orl $0xf0, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x4(%rbp), %ecx
sarl $0xc, %ecx
andl $0x3f, %ecx
orl $0x80, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x4(%rbp), %ecx
sarl $0x6, %ecx
andl $0x3f, %ecx
orl $0x80, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x4(%rbp), %ecx
andl $0x3f, %ecx
orl $0x80, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
jmp 0x1356b
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
jmp 0x1356d
jmp 0x1356f
jmp 0x13571
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nurse[P]nkf/nkf.c
// Function: find_inputcode_byfunc
static struct input_code*
find_inputcode_byfunc(nkf_char (*iconv_func)(nkf_char c2,nkf_char c1,nkf_char c0))
{
    if (iconv_func){
	struct input_code *p = input_code_list;
	while (p->name){
	    if (iconv_func == p->iconv_func){
		return p;
	    }
	    p++;
	}
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x136ac
leaq 0x3eaba(%rip), %rax     # 0x52130
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x136aa
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jne 0x1369c
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x136b4
movq -0x18(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x18(%rbp)
jmp 0x1367a
jmp 0x136ac
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nurse[P]nkf/nkf.c
// Function: set_input_codename
static void
set_input_codename(const char *codename)
{
    if (!input_codename) {
	input_codename = codename;
    } else if (strcmp(codename, input_codename) != 0) {
	input_codename = "";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x46d64(%rip)     # 0x5a438
jne 0x136e3
movq -0x8(%rbp), %rax
movq %rax, 0x46d57(%rip)     # 0x5a438
jmp 0x13708
movq -0x8(%rbp), %rdi
movq 0x46d4a(%rip), %rsi     # 0x5a438
callq 0xc120
cmpl $0x0, %eax
je 0x13706
leaq 0x9e33(%rip), %rax      # 0x1d532
movq %rax, 0x46d32(%rip)     # 0x5a438
jmp 0x13708
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x5, -0x18(%rbp)
jge 0x13aed
movslq -0x18(%rbp), %rcx
leaq 0x13817(%rip), %rax     # 0x272ec
movzwl (%rax,%rcx,2), %eax
cmpl -0x8(%rbp), %eax
jne 0x13ae0
jmp 0x13aed
jmp 0x13ae2
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x13ac4
cmpl $0x5, -0x18(%rbp)
jl 0x13afc
movl $0x0, -0x4(%rbp)
jmp 0x13b66
movl -0xc(%rbp), %eax
andl $0x7f, %eax
shll $0x8, %eax
movl -0x10(%rbp), %ecx
andl $0x7f, %ecx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x19, -0x18(%rbp)
jge 0x13b5f
movslq -0x18(%rbp), %rcx
leaq 0x137d8(%rip), %rax     # 0x27300
imulq $0x6, %rcx, %rcx
addq %rcx, %rax
movzwl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x13b52
movslq -0x18(%rbp), %rcx
leaq 0x137be(%rip), %rax     # 0x27300
imulq $0x6, %rcx, %rcx
addq %rcx, %rax
movzwl 0x2(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x13b66
jmp 0x13b54
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x13b17
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x13c09
movq -0x8(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x13de0
jmp 0x13d5b
cmpl $0x8e, -0xc(%rbp)
jne 0x13c25
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x13de0
jmp 0x13d59
cmpl $0x8f, -0xc(%rbp)
jne 0x13cc4
movl -0x10(%rbp), %eax
andl $0x70, %eax
cmpl $0x20, %eax
jne 0x13c5b
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
andl $0xf, %eax
movslq %eax, %rcx
leaq 0x8abf(%rip), %rax      # 0x1c710
movl (%rax,%rcx,4), %esi
callq 0x13de0
jmp 0x13cbf
movl -0x10(%rbp), %eax
andl $0x70, %eax
cmpl $0x60, %eax
jne 0x13c84
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
andl $0xf, %eax
movslq %eax, %rcx
leaq 0x8ad6(%rip), %rax      # 0x1c750
movl (%rax,%rcx,4), %esi
callq 0x13de0
jmp 0x13cbd
movl -0x10(%rbp), %eax
andl $0x70, %eax
cmpl $0x70, %eax
jne 0x13cad
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
andl $0xf, %eax
movslq %eax, %rcx
leaq 0x8aed(%rip), %rax      # 0x1c790
movl (%rax,%rcx,4), %esi
callq 0x13de0
jmp 0x13cbb
movq -0x8(%rbp), %rdi
movl $0x10, %esi
callq 0x13de0
jmp 0x13cbd
jmp 0x13cbf
jmp 0x13d57
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x13770
cmpl $0x0, %eax
jne 0x13ce4
movq -0x8(%rbp), %rdi
movl $0x40, %esi
callq 0x13de0
jmp 0x13d55
movl -0xc(%rbp), %eax
andl $0x70, %eax
cmpl $0x20, %eax
jne 0x13d0d
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
andl $0xf, %eax
movslq %eax, %rcx
leaq 0x8acd(%rip), %rax      # 0x1c7d0
movl (%rax,%rcx,4), %esi
callq 0x13de0
jmp 0x13d53
movl -0xc(%rbp), %eax
andl $0x70, %eax
cmpl $0x70, %eax
jne 0x13d36
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
andl $0xf, %eax
movslq %eax, %rcx
leaq 0x8ae4(%rip), %rax      # 0x1c810
movl (%rax,%rcx,4), %esi
callq 0x13de0
jmp 0x13d51
movl -0xc(%rbp), %eax
andl $0x70, %eax
cmpl $0x50, %eax
jl 0x13d4f
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x13de0
jmp 0x13d51
jmp 0x13d53
jmp 0x13d55
jmp 0x13d57
jmp 0x13d59
jmp 0x13d5b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)