LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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, 0x48449(%rip)     # 0x55530
jne 0xd111
movb $0x0, 0x48440(%rip)     # 0x55530
movl $0xffffffef, %edi       # imm = 0xFFFFFFEF
callq *0x401cd(%rip)          # 0x4d2c8
movl $0xffffffbb, %edi       # imm = 0xFFFFFFBB
callq *0x401c2(%rip)          # 0x4d2c8
movl $0xffffffbf, %edi       # imm = 0xFFFFFFBF
callq *0x401b7(%rip)          # 0x4d2c8
cmpl $-0x1, %ebp
je 0xd229
testl %ebp, %ebp
jne 0xd165
movl %r14d, %eax
andl $0xff000000, %eax       # imm = 0xFF000000
cmpl $0x1000000, %eax        # imm = 0x1000000
jne 0xd15d
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 0x11afc
movl (%rbx), %edi
jmp 0xd200
testl %ebp, %ebp
je 0xd246
movl %ebp, %edi
movl %r14d, %esi
callq 0x11ca5
testl %eax, %eax
je 0xd23b
movl %eax, %ebx
movl %eax, %edi
movl %ebp, %esi
movl %r14d, %edx
callq 0x11e7b
testl %eax, %eax
je 0xd1dc
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 0x11afc
movl (%r14), %edi
callq *0x40115(%rip)          # 0x4d2c8
movl (%r15), %edi
testl %edi, %edi
je 0xd1c0
callq *0x40108(%rip)          # 0x4d2c8
movl 0xc(%rsp), %edi
testl %edi, %edi
je 0xd1ce
callq *0x400fa(%rip)          # 0x4d2c8
movl 0x8(%rsp), %edi
testl %edi, %edi
je 0xd1dc
callq *0x400ec(%rip)          # 0x4d2c8
leaq 0x10(%rsp), %r14
leaq 0x14(%rsp), %r15
leaq 0xc(%rsp), %rcx
leaq 0x8(%rsp), %r8
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x11afc
movl (%r14), %edi
callq *0x400c2(%rip)          # 0x4d2c8
movl (%r15), %edi
testl %edi, %edi
je 0xd213
callq *0x400b5(%rip)          # 0x4d2c8
movl 0xc(%rsp), %edi
testl %edi, %edi
je 0xd221
callq *0x400a7(%rip)          # 0x4d2c8
movl 0x8(%rsp), %ebp
testl %ebp, %ebp
je 0xd23b
movl %ebp, %edi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *0x4008d(%rip)          # 0x4d2c8
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %r14d, %ebp
jmp 0xd229
// File: /workspace/github_c_makefile_star2_O1/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, %ebx
movl %edi, %r14d
cmpb $0x1, 0x4805e(%rip)     # 0x55530
jne 0xd528
movb $0x0, 0x48055(%rip)     # 0x55530
xorl %eax, %eax
cmpb $0x0, 0x48050(%rip)     # 0x55534
movl $0xff, %ebp
movl $0x0, %edi
cmovnel %ebp, %edi
movl $0xfe, %r15d
movl $0x0, %r12d
cmovnel %r15d, %r12d
cmovnel %eax, %r15d
cmovnel %eax, %ebp
callq *0x3fdba(%rip)          # 0x4d2c8
movl %r12d, %edi
callq *0x3fdb1(%rip)          # 0x4d2c8
movl %r15d, %edi
callq *0x3fda8(%rip)          # 0x4d2c8
movl %ebp, %edi
callq *0x3fda0(%rip)          # 0x4d2c8
cmpl $0x1, %r14d
je 0xd5aa
testl %r14d, %r14d
je 0xd543
cmpl $-0x1, %r14d
jne 0xd55c
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
jmp 0xd638
movl %ebx, %eax
andl $0xff000000, %eax       # imm = 0xFF000000
cmpl $0x1000000, %eax        # imm = 0x1000000
sete %al
testl %r14d, %r14d
sete %cl
orb %al, %cl
jne 0xd5d8
movl %r14d, %edi
movl %ebx, %esi
callq 0x11ca5
movl %eax, %ebp
testl %eax, %eax
je 0xd5d4
movl %ebp, %edi
movl %r14d, %esi
movl %ebx, %edx
callq 0x11e7b
testl %eax, %eax
je 0xd5d2
movl %eax, %ebx
movq 0x3fd43(%rip), %rax     # 0x4d2c8
cmpb $0x1, 0x47fa8(%rip)     # 0x55534
jne 0xd5b2
movzbl %bl, %edi
callq *%rax
shrl $0x8, %ebx
movl %ebx, %edi
callq *0x3fd2a(%rip)          # 0x4d2c8
xorl %edi, %edi
callq *0x3fd22(%rip)          # 0x4d2c8
xorl %edi, %edi
jmp 0xd5cc
orl $0x80, %ebx
jmp 0xd5d8
xorl %edi, %edi
callq *%rax
xorl %edi, %edi
callq *0x3fd0a(%rip)          # 0x4d2c8
movl %ebx, %edi
shrl $0x8, %edi
callq *0x3fcff(%rip)          # 0x4d2c8
movzbl %bl, %edi
callq *0x3fcf6(%rip)          # 0x4d2c8
movl %ebp, %ebx
testl %ebp, %ebp
je 0xd646
movq 0x3fce9(%rip), %rax     # 0x4d2c8
cmpb $0x1, 0x47f4e(%rip)     # 0x55534
jne 0xd611
movl $0xff, %ebp
movl %ebx, %edi
andl %ebp, %edi
callq *%rax
movl %ebx, %edi
shrl $0x8, %edi
andl %ebp, %edi
callq *0x3fcc8(%rip)          # 0x4d2c8
shrl $0x10, %ebx
andl %ebp, %ebx
movl %ebx, %edi
callq *0x3fcbb(%rip)          # 0x4d2c8
xorl %edi, %edi
jmp 0xd638
xorl %edi, %edi
callq *%rax
movl %ebx, %edi
shrl $0x10, %edi
movl $0xff, %ebp
andl %ebp, %edi
callq *0x3fca1(%rip)          # 0x4d2c8
movl %ebx, %edi
shrl $0x8, %edi
andl %ebp, %edi
callq *0x3fc94(%rip)          # 0x4d2c8
andl %ebp, %ebx
movl %ebx, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *0x3fc82(%rip)          # 0x4d2c8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd72f
movq %rdi, %rbx
leaq 0x99dc(%rip), %rcx      # 0x17044
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x7f, %esi
jg 0xd72f
cmpl $0x0, 0x47da7(%rip)     # 0x55428
je 0xd72f
movabsq $0x8000000000, %rax     # imm = 0x8000000000
movq %rax, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
jmp 0xd72f
leal -0xa1(%rsi), %eax
cmpl $0x5d, %eax
ja 0xd6d7
movslq 0x10(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x10(%rbx)
movl %esi, 0x14(%rbx,%rax,4)
movq %rbx, %rdi
callq 0x11ed6
xorl %eax, %eax
movl %eax, 0x8(%rbx)
movl %eax, 0x10(%rbx)
jmp 0xd72f
leal -0xa1(%rsi), %eax
cmpl $0x5d, %eax
jbe 0xd71a
movq %rbx, %rdi
popq %rbx
jmp 0x11fbc
cmpl $0x80, %esi
setl %al
movl %esi, %ecx
andl $0x7f000000, %ecx       # imm = 0x7F000000
cmpl $0x1000000, %ecx        # imm = 0x1000000
sete %cl
orb %al, %cl
jne 0xd72f
cmpl $0x8e, %esi
sete %al
leal -0xa1(%rsi), %ecx
cmpl $0x5e, %ecx
setb %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xd731
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 0xd6d7
movl $0x2, 0x8(%rbx)
movslq 0x10(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x10(%rbx)
movl $0x8f, 0x14(%rbx,%rax,4)
jmp 0xd72f
// File: /workspace/github_c_makefile_star2_O1/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 0xdab0
movq %rdi, %rbx
leaq 0x970b(%rip), %rcx      # 0x17068
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl %esi, %eax
andl $-0x40, %eax
cmpl $0x80, %eax
jne 0xdab7
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 0xdab0
leaq 0x14(%rbx), %rcx
movl (%rcx), %edi
cmpl $0xef, %edi
jne 0xda58
movl 0x18(%rbx), %esi
cmpl $0xbb, %esi
jne 0xda58
leaq 0x18(%rbx), %r8
movl 0x1c(%rbx), %ebp
movl %ebp, %edx
callq 0x11376
cmpl $0xbf, %ebp
jne 0xda67
jmp 0xda6f
movl %esi, %eax
andl $-0x40, %eax
cmpl $0x80, %eax
jne 0xdab7
movslq 0x10(%rbx), %rax
cmpq $0x2, %rax
jg 0xda6f
jmp 0xdaa6
cmpl $0x7f, %esi
jg 0xdab0
cmpl $0x0, 0x47a25(%rip)     # 0x55428
je 0xdab0
movabsq $0x8000000000, %rax     # imm = 0x8000000000
movq %rax, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
jmp 0xdab0
cmpl $0x80, %esi
setl %al
movl %esi, %ecx
andl $0x7f000000, %ecx       # imm = 0x7F000000
cmpl $0x1000000, %ecx        # imm = 0x1000000
sete %cl
orb %al, %cl
jne 0xdab0
movl %esi, %eax
andl $0x7fffffe0, %eax       # imm = 0x7FFFFFE0
cmpl $0xc0, %eax
jne 0xda79
movl $0x1, 0x8(%rbx)
jmp 0xdaa2
leaq 0x18(%rbx), %r8
movl 0x18(%rbx), %esi
movl 0x1c(%rbx), %edx
callq 0x11376
movq %rbx, %rdi
callq 0x11ed6
xorl %eax, %eax
movl %eax, 0x8(%rbx)
movl %eax, 0x10(%rbx)
jmp 0xdab0
movl %esi, %eax
andl $0x7ffffff0, %eax       # imm = 0x7FFFFFF0
cmpl $0xe0, %eax
jne 0xda90
movl $0x2, 0x8(%rbx)
jmp 0xdaa2
leal -0xf0(%rsi), %eax
cmpl $0x4, %eax
ja 0xdab7
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 0x11fbc
// File: /workspace/github_c_makefile_star2_O1/nurse[P]nkf/nkf.c
// Function: nkf_state_init
static void
nkf_state_init(void)
{
    if (nkf_state) {
	nkf_buf_clear(nkf_state->std_gc_buf);
	nkf_buf_clear(nkf_state->broken_buf);
	nkf_buf_clear(nkf_state->nfc_buf);
    }
    else {
	nkf_state = nkf_xmalloc(sizeof(nkf_state_t));
	nkf_state->std_gc_buf = nkf_buf_new(STD_GC_BUFSIZE);
	nkf_state->broken_buf = nkf_buf_new(3);
	nkf_state->nfc_buf = nkf_buf_new(9);
    }
    nkf_state->broken_state = 0;
    nkf_state->mimeout_state = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x4630f(%rip), %rax     # 0x55538
testq %rax, %rax
je 0xf24c
movq (%rax), %rcx
xorl %edx, %edx
movq %rdx, 0x8(%rcx)
movq 0x10(%rax), %rcx
movq %rdx, 0x8(%rcx)
movq 0x20(%rax), %rax
movq %rdx, 0x8(%rax)
jmp 0xf2f2
movl $0x28, %edi
callq 0x10f26
movq %rax, 0x462db(%rip)     # 0x55538
movl $0x18, %edi
callq 0x10f26
movq %rax, %rbx
movl $0x400, %edi            # imm = 0x400
callq 0x10f26
movq %rax, 0x10(%rbx)
movq $0x100, (%rbx)          # imm = 0x100
xorl %r14d, %r14d
movq %r14, 0x8(%rbx)
movq 0x462ab(%rip), %rax     # 0x55538
movq %rbx, (%rax)
movl $0x18, %edi
callq 0x10f26
movq %rax, %rbx
movl $0xc, %edi
callq 0x10f26
movq %rax, 0x10(%rbx)
movq $0x3, (%rbx)
movq %r14, 0x8(%rbx)
movq 0x4627b(%rip), %rax     # 0x55538
movq %rbx, 0x10(%rax)
movl $0x18, %edi
callq 0x10f26
movq %rax, %rbx
movl $0x24, %edi
callq 0x10f26
movq %rax, 0x10(%rbx)
movq $0x9, (%rbx)
movq %r14, 0x8(%rbx)
movq 0x4624a(%rip), %rax     # 0x55538
movq %rbx, 0x20(%rax)
movq 0x4623f(%rip), %rax     # 0x55538
xorl %ecx, %ecx
movl %ecx, 0x8(%rax)
movl %ecx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x460bc(%rip)     # 0x553d0
jne 0xf325
callq 0x126df
jmp 0xf325
movl %eax, %edi
callq *0x3dfa3(%rip)          # 0x4d2c8
movq %rbx, %rdi
callq *0x3dffa(%rip)          # 0x4d328
cmpl $-0x1, %eax
jne 0xf31d
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
popq %rbx
jmpq *0x3df89(%rip)          # 0x4d2c8
// File: /workspace/github_c_makefile_star2_O1/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 0x11056
movl %edi, %r8d
andl $0x7f, %r8d
cmpb $0x1, 0x3c45c(%rip)     # 0x4d3bc
jne 0x10fb5
cmpl $0x2f, %r8d
ja 0x10f77
leaq 0x7891(%rip), %rax      # 0x18800
movsbl -0x20(%r8,%rax), %eax
jmp 0x10f84
leal -0x6e(%r8), %r9d
xorl %eax, %eax
cmpl $0x11, %r9d
setb %al
testl %eax, %eax
je 0x10fb5
leal -0x21(%r8), %eax
cmpl $0xe, %eax
ja 0x10ff0
testq %rdx, %rdx
je 0x11080
leal -0x1(%r8), %eax
shrl %eax
shrl $0x3, %r8d
leal (%r8,%r8,2), %r8d
subl %r8d, %eax
addl $0xec, %eax
jmp 0x1107e
cmpl $0x21, %r8d
setb %al
cmpl $0x7f, %r8d
sete %r9b
orb %al, %r9b
jne 0x11056
leal -0x21(%r8), %eax
leaq 0x3aac8(%rip), %r9      # 0x4baa0
movq (%r9,%rax,8), %rax
testq %rax, %rax
je 0x11025
movl %esi, %r9d
andl $0x7f, %r9d
movzwl -0x42(%rax,%r9,2), %eax
jmp 0x11027
cmpl $0x6e, %r8d
setb %r9b
cmpl $0x7f, %r8d
sete %r10b
movl $0x1, %eax
orb %r9b, %r10b
jne 0x110a2
testq %rdx, %rdx
je 0x11080
decl %r8d
shrl %r8d
addl $0xbe, %r8d
movl %r8d, (%rdx)
jmp 0x11080
xorl %eax, %eax
testl %eax, %eax
je 0x11043
movl %eax, %edi
shrl $0x8, %edi
testq %rdx, %rdx
je 0x11037
movl %edi, (%rdx)
movzbl %al, %esi
testq %rcx, %rcx
je 0x11052
movl %esi, (%rcx)
jmp 0x11052
leal 0x94(%r8), %r9d
cmpl $0x75, %r8d
cmovael %r9d, %edi
testl %eax, %eax
jne 0x110a0
movl $0x1, %eax
cmpl $0x7f, %edi
jg 0x110a2
testq %rdx, %rdx
je 0x11080
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 0x110a0
xorl %eax, %eax
cmpl $0x60, %esi
setge %al
addl $0x1f, %eax
testb $0x1, %dil
movl $0x7e, %edx
cmovnel %eax, %edx
addl %esi, %edx
movl %edx, (%rcx)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1130e
movl %edi, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0xc2, %edi
jge 0x1131c
retq
cmpl $0xdf, %edi
jg 0x11332
andl $0x1f, %edi
shll $0x6, %edi
andl $0x3f, %esi
orl %edi, %esi
movl %esi, %eax
retq
cmpl $0xef, %edi
jg 0x11350
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 0x1131b
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_O1/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 0x113e1
leal -0xc0(%r14), %eax
xorl %r12d, %r12d
cmpl $0x2f, %eax
ja 0x113ef
movl %edx, %ebp
movl %esi, %r15d
movl %r14d, %edi
movq %r13, %rcx
movq %rbx, %r8
callq 0x11406
testl %eax, %eax
jle 0x11401
testq %r13, %r13
je 0x113c1
movl $0x0, (%r13)
testq %rbx, %rbx
je 0x113ef
movl %r14d, %edi
movl %r15d, %esi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x11303
movl %eax, %r14d
orl $0x1000000, %r14d       # imm = 0x1000000
jmp 0x113e9
movl $0x0, (%r13)
movl %r14d, (%rbx)
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r12d
jmp 0x113ef
// File: /workspace/github_c_makefile_star2_O1/nurse[P]nkf/nkf.c
// Function: unicode_to_jis_common2
static int
unicode_to_jis_common2(nkf_char c1, nkf_char c0,
		       const unsigned short *const *pp, nkf_char psize,
		       nkf_char *p2, nkf_char *p1)
{
    nkf_char c2;
    const unsigned short *p;
    unsigned short val;

    if (pp == 0) return 1;

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

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

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

// Assembly:
movl $0x1, %eax
testq %rdx, %rdx
je 0x118b4
leal -0x80(%rdi), %r10d
cmpl $0x7f, %edi
setg %dil
cmpl %ecx, %r10d
setl %cl
andb %dil, %cl
cmpb $0x1, %cl
jne 0x118b4
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 0x118b4
movl %esi, %edx
movzwl -0x100(%rcx,%rdx,2), %ecx
testl %ecx, %ecx
je 0x118b4
cmpb $0x1, 0x43bbc(%rip)     # 0x55418
jne 0x1187e
movl %ecx, %edx
andl $0xff00, %edx           # imm = 0xFF00
cmpl $0x2d00, %edx           # imm = 0x2D00
sete %dl
cmpl $0xf301, %ecx           # imm = 0xF301
setae %sil
orb %dl, %sil
jne 0x118b4
testq %r8, %r8
je 0x118a7
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 0x118b4
movzbl %cl, %ecx
movl %ecx, (%r9)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x118e2
movl $0x0, (%r14)
jmp 0x119b9
cmpl $0xffff, %ebp           # imm = 0xFFFF
ja 0x11931
leaq 0xc(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x14(%rsp), %r13
leaq 0x10(%rsp), %r8
movl %ebp, %edi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x11afc
movl (%r15), %edi
movl (%r12), %esi
movl (%r13), %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0x11406
testl %eax, %eax
jg 0x119ac
jmp 0x119bd
cmpb $0x1, 0x3ba84(%rip)     # 0x4d3bc
jne 0x119ac
movl %ebp, %eax
shrl $0xa, %eax
addl $0xd7c0, %eax           # imm = 0xD7C0
movl %eax, 0xc(%rsp)
andl $0x3ff, %edi            # imm = 0x3FF
orl $0xdc00, %edi           # imm = 0xDC00
movl %edi, 0x8(%rsp)
movl $0x4, %ecx
leaq 0x1069c(%rip), %rdx     # 0x22000
movzwl -0x2(%rdx,%rcx), %esi
cmpl %esi, %eax
jne 0x11975
movzwl (%rdx,%rcx), %esi
cmpl %esi, %edi
je 0x119cc
addq $0x6, %rcx
cmpq $0xa0, %rcx
jne 0x11964
movl $0x4, %ecx
leaq 0x10712(%rip), %rdx     # 0x220a0
movzwl -0x2(%rdx,%rcx), %esi
cmpl %esi, %eax
jne 0x1199f
movzwl (%rdx,%rcx), %esi
cmpl %esi, %edi
je 0x119d9
addq $0x6, %rcx
cmpq $0x682, %rcx            # imm = 0x682
jne 0x1198e
movl $0x0, (%r14)
orl $0x1000000, %ebp        # imm = 0x1000000
movl %ebp, (%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzwl -0x4(%rdx,%rcx), %eax
movzbl %al, %ebp
shrl $0x8, %eax
jmp 0x119e9
movzwl -0x4(%rdx,%rcx), %eax
movzbl %al, %ebp
shrl $0x8, %eax
orl $0x8f00, %eax           # imm = 0x8F00
movl %eax, (%r14)
jmp 0x119b9
// File: /workspace/github_c_makefile_star2_O1/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, 0x43a28(%rip)     # 0x5541c
je 0x11afb
pushq %rbx
movl %edi, %ebx
cmpl $0x1167, %edi           # imm = 0x1167
jle 0x11a50
cmpl $0x1168, %ebx           # imm = 0x1168
je 0x11a8c
cmpl $0x1229, %ebx           # imm = 0x1229
je 0x11aab
cmpl $0x1233, %ebx           # imm = 0x1233
jne 0x11af4
movl $0x1b, %edi
callq *0x3b898(%rip)          # 0x4d2c8
movl $0x24, %edi
callq *0x3b88d(%rip)          # 0x4d2c8
movl $0x28, %edi
callq *0x3b882(%rip)          # 0x4d2c8
movl $0x51, %edi
jmp 0x11aee
cmpl $0x1013, %ebx           # imm = 0x1013
je 0x11ad3
cmpl $0x1159, %ebx           # imm = 0x1159
jne 0x11af4
movl $0x1b, %edi
callq *0x3b859(%rip)          # 0x4d2c8
movl $0x24, %edi
callq *0x3b84e(%rip)          # 0x4d2c8
movl $0x28, %edi
callq *0x3b843(%rip)          # 0x4d2c8
movl $0x44, %edi
jmp 0x11aee
movl $0x1b, %edi
callq *0x3b831(%rip)          # 0x4d2c8
movl $0x24, %edi
callq *0x3b826(%rip)          # 0x4d2c8
movzbl 0x3b828(%rip), %edi     # 0x4d2d1
jmp 0x11aee
movl $0x1b, %edi
callq *0x3b812(%rip)          # 0x4d2c8
movl $0x24, %edi
callq *0x3b807(%rip)          # 0x4d2c8
movl $0x28, %edi
callq *0x3b7fc(%rip)          # 0x4d2c8
movl $0x50, %edi
jmp 0x11aee
movl $0x1b, %edi
callq *0x3b7ea(%rip)          # 0x4d2c8
movl $0x28, %edi
callq *0x3b7df(%rip)          # 0x4d2c8
movl $0x49, %edi
callq *0x3b7d4(%rip)          # 0x4d2c8
movl %ebx, 0x43922(%rip)     # 0x5541c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x11b12
movl %eax, (%rsi)
xorl %edi, %edi
movl %edi, (%rdx)
movl %edi, (%rcx)
jmp 0x11b61
cmpl $0x7ff, %eax            # imm = 0x7FF
ja 0x11b36
shrl $0x6, %eax
orl $0xc0, %eax
movl %eax, (%rsi)
andl $0x3f, %edi
orl $0x80, %edi
movl %edi, (%rdx)
movl $0x0, (%rcx)
jmp 0x11b5f
cmpl $0xffff, %eax           # imm = 0xFFFF
ja 0x11b65
shrl $0xc, %eax
orl $0xe0, %eax
movl %eax, (%rsi)
movl %edi, %eax
shrl $0x6, %eax
andl $0x3f, %eax
movl $0x80, %esi
orl %esi, %eax
movl %eax, (%rdx)
andl $0x3f, %edi
orl %esi, %edi
movl %edi, (%rcx)
xorl %edi, %edi
movl %edi, (%r8)
retq
cmpl $0x10ffff, %eax         # imm = 0x10FFFF
ja 0x11b9a
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 0x11b61
xorl %edi, %edi
movl %edi, (%rsi)
jmp 0x11b0c
// File: /workspace/github_c_makefile_star2_O1/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 %ecx, %ecx
leaq 0x100c8(%rip), %rax     # 0x21f4c
movzwl (%rax,%rcx,2), %r8d
cmpl %edi, %r8d
je 0x11e9c
incq %rcx
cmpq $0x5, %rcx
jne 0x11e84
movl $0x5, %ecx
xorl %eax, %eax
cmpl $0x4, %ecx
ja 0x11ed0
andl $0x7f, %esi
shll $0x8, %esi
andl $0x7f, %edx
orl %esi, %edx
movl $0x2, %ecx
leaq 0x100a6(%rip), %rsi     # 0x21f60
movzwl -0x2(%rsi,%rcx), %edi
cmpl %edi, %edx
je 0x11ed1
addq $0x6, %rcx
cmpq $0x98, %rcx
jne 0x11eba
retq
movzwl (%rsi,%rcx), %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x11efd
movl 0x18(%rbx), %esi
cmpl $0x8f, %ebp
je 0x11f10
cmpl $0x8e, %ebp
jne 0x11f32
movl $0x2, %eax
jmp 0x11f02
movl $0x100, %eax            # imm = 0x100
testq %rbx, %rbx
jne 0x11f9b
jmp 0x11f9e
movl %esi, %eax
andl $0x70, %eax
cmpl $0x70, %eax
je 0x11f6f
cmpl $0x60, %eax
je 0x11f61
cmpl $0x20, %eax
jne 0x11f7d
testq %rbx, %rbx
je 0x11f9e
leaq 0x5440(%rip), %rax      # 0x17370
jmp 0x11f95
movl %ebp, %edi
callq 0x11ca5
testl %eax, %eax
je 0x11f5a
movl %ebp, %eax
andl $0x70, %eax
cmpl $0x70, %eax
je 0x11f87
cmpl $0x20, %eax
jne 0x11fa5
testq %rbx, %rbx
je 0x11f9e
leaq 0x54d8(%rip), %rax      # 0x17430
jmp 0x11f93
movl $0x40, %eax
jmp 0x11f02
testq %rbx, %rbx
je 0x11f9e
leaq 0x5443(%rip), %rax      # 0x173b0
jmp 0x11f95
testq %rbx, %rbx
je 0x11f9e
leaq 0x5475(%rip), %rax      # 0x173f0
jmp 0x11f95
movl $0x10, %eax
jmp 0x11f02
testq %rbx, %rbx
je 0x11f9e
leaq 0x54dd(%rip), %rax      # 0x17470
movl %ebp, %esi
andl $0xf, %esi
movl (%rax,%rsi,4), %eax
orl %eax, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpl $0x50, %eax
setb %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
movl $0x1, %eax
je 0x11f9b
jmp 0x11f9e
// File: /workspace/github_c_makefile_star2_O1/nurse[P]nkf/nkf.c
// Function: status_disable
static void
status_disable(struct input_code *ptr)
{
    ptr->stat = -1;
    ptr->buf[0] = -1;
    code_score(ptr);
    if (iconv == ptr->iconv_func) set_iconv(FALSE, 0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x8(%rdi)
movl %eax, 0x14(%rdi)
callq 0x11ed6
movq 0x3b301(%rip), %rax     # 0x4d2d8
cmpq 0x28(%rbx), %rax
je 0x11fdf
popq %rbx
retq
xorl %edi, %edi
xorl %esi, %esi
popq %rbx
jmp 0x11bad
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
cmpb $0x58, (%rdi)
jne 0x120c5
xorl %eax, %eax
cmpb $0x2d, 0x1(%rdi)
sete %al
leaq (%rdi,%rax,2), %rdi
leaq 0x34e14(%rip), %rax     # 0x46ee0
xorl %ecx, %ecx
xorl %edx, %edx
movq %rax, %rsi
movq (%rsi), %rsi
movb (%rsi), %r10b
testb %r10b, %r10b
je 0x12138
movb (%rdi), %r9b
testb %r9b, %r9b
je 0x12142
movl $0x1, %r8d
leal -0x61(%r10), %r11d
leal -0x20(%r10), %ebx
cmpb $0x1a, %r11b
movzbl %bl, %r11d
movsbl %r10b, %r10d
cmovbl %r11d, %r10d
leal -0x61(%r9), %r11d
leal -0x20(%r9), %ebx
cmpb $0x1a, %r11b
movzbl %bl, %r11d
movsbl %r9b, %r9d
cmovbl %r11d, %r9d
cmpl %r9d, %r10d
jne 0x12142
movb (%rsi,%r8), %r10b
testb %r10b, %r10b
je 0x1213b
movb (%rdi,%r8), %r9b
incq %r8
testb %r9b, %r9b
jne 0x120ec
jmp 0x12142
xorl %r8d, %r8d
cmpb $0x0, (%rdi,%r8)
je 0x12163
incq %rcx
movq %rcx, %rdx
shlq $0x4, %rdx
leaq (%rax,%rdx), %rsi
movl 0x8(%rdx,%rax), %edx
cmpq $0x33, %rcx
jne 0x120d3
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %eax, %eax
cmpl $0x24, %edx
movl %edx, %ecx
leaq (%rcx,%rcx,2), %rcx
leaq 0x346ab(%rip), %rdx     # 0x46820
leaq (%rdx,%rcx,8), %rcx
cmovbq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/nurse[P]nkf/nkf.c
// Function: encode_fallback_html
static void
encode_fallback_html(nkf_char c)
{
    (*oconv)(0, '&');
    (*oconv)(0, '#');
    c &= VALUE_MASK;
    if(c >= NKF_INT32_C(1000000))
	(*oconv)(0, 0x30+(c/NKF_INT32_C(1000000))%10);
    if(c >= NKF_INT32_C(100000))
	(*oconv)(0, 0x30+(c/NKF_INT32_C(100000) )%10);
    if(c >= 10000)
	(*oconv)(0, 0x30+(c/10000  )%10);
    if(c >= 1000)
	(*oconv)(0, 0x30+(c/1000   )%10);
    if(c >= 100)
	(*oconv)(0, 0x30+(c/100    )%10);
    if(c >= 10)
	(*oconv)(0, 0x30+(c/10     )%10);
    if(c >= 0)
	(*oconv)(0, 0x30+ c         %10);
    (*oconv)(0, ';');
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %edi, %edi
movl $0x26, %esi
callq *0x3b126(%rip)          # 0x4d2b8
xorl %edi, %edi
movl $0x23, %esi
callq *0x3b119(%rip)          # 0x4d2b8
andl $0xffffff, %ebx         # imm = 0xFFFFFF
movl %ebx, %r14d
cmpl $0xf4240, %ebx          # imm = 0xF4240
jb 0x121d8
imulq $0x10c6f7b, %r14, %rsi  # imm = 0x10C6F7B
shrq $0x2c, %rsi
imulq $0x1999999a, %rsi, %rax # imm = 0x1999999A
shrq $0x20, %rax
addl %eax, %eax
leal (%rax,%rax,4), %eax
subl %eax, %esi
orl $0x30, %esi
xorl %edi, %edi
callq *0x3b0e0(%rip)          # 0x4d2b8
cmpl $0x186a0, %ebx          # imm = 0x186A0
jb 0x12208
imulq $0x14f8b59, %r14, %rsi  # imm = 0x14F8B59
shrq $0x29, %rsi
imulq $0x1999999a, %rsi, %rax # imm = 0x1999999A
shrq $0x20, %rax
addl %eax, %eax
leal (%rax,%rax,4), %eax
subl %eax, %esi
orl $0x30, %esi
xorl %edi, %edi
callq *0x3b0b0(%rip)          # 0x4d2b8
cmpl $0x2710, %ebx           # imm = 0x2710
jb 0x12238
imulq $0x1a36e3, %r14, %rsi   # imm = 0x1A36E3
shrq $0x22, %rsi
imulq $0x1999999a, %rsi, %rax # imm = 0x1999999A
shrq $0x20, %rax
addl %eax, %eax
leal (%rax,%rax,4), %eax
subl %eax, %esi
orl $0x30, %esi
xorl %edi, %edi
callq *0x3b080(%rip)          # 0x4d2b8
cmpl $0x3e8, %ebx            # imm = 0x3E8
jb 0x12268
imulq $0x83126f, %r14, %rsi   # imm = 0x83126F
shrq $0x21, %rsi
imulq $0x1999999a, %rsi, %rax # imm = 0x1999999A
shrq $0x20, %rax
addl %eax, %eax
leal (%rax,%rax,4), %eax
subl %eax, %esi
orl $0x30, %esi
xorl %edi, %edi
callq *0x3b050(%rip)          # 0x4d2b8
cmpl $0x64, %ebx
jb 0x12295
imulq $0x28f5c29, %r14, %rsi  # imm = 0x28F5C29
shrq $0x20, %rsi
imulq $0x1999999a, %rsi, %rax # imm = 0x1999999A
shrq $0x20, %rax
addl %eax, %eax
leal (%rax,%rax,4), %eax
subl %eax, %esi
orl $0x30, %esi
xorl %edi, %edi
callq *0x3b023(%rip)          # 0x4d2b8
cmpl $0xa, %ebx
jb 0x122c2
imulq $0x1999999a, %r14, %rsi # imm = 0x1999999A
shrq $0x20, %rsi
imulq $0x1999999a, %rsi, %rax # imm = 0x1999999A
shrq $0x20, %rax
addl %eax, %eax
leal (%rax,%rax,4), %eax
subl %eax, %esi
orl $0x30, %esi
xorl %edi, %edi
callq *0x3aff6(%rip)          # 0x4d2b8
imulq $0x1999999a, %r14, %rax # imm = 0x1999999A
shrq $0x20, %rax
addl %eax, %eax
leal (%rax,%rax,4), %eax
negl %eax
leal (%rbx,%rax), %esi
addl $0x30, %esi
xorl %edi, %edi
callq *0x3afd6(%rip)          # 0x4d2b8
movq 0x3afcf(%rip), %rax     # 0x4d2b8
xorl %edi, %edi
movl $0x3b, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %edi, %edi
movl $0x26, %esi
callq *0x3afa8(%rip)          # 0x4d2b8
xorl %edi, %edi
movl $0x23, %esi
callq *0x3af9b(%rip)          # 0x4d2b8
xorl %edi, %edi
movl $0x78, %esi
callq *0x3af8e(%rip)          # 0x4d2b8
movq 0x3af87(%rip), %r15     # 0x4d2b8
andl $0xffffff, %ebx         # imm = 0xFFFFFF
movl $0x14, %r14d
leaq 0x6140(%rip), %r12      # 0x18484
movl $0x1, %eax
movl %r14d, %ecx
shll %cl, %eax
cmpl %eax, %ebx
jge 0x1235b
addl $-0x4, %r14d
movl %r14d, %eax
jmp 0x1237c
movl %ebx, %eax
movl %r14d, %ecx
shrl %cl, %eax
andl $0xf, %eax
movsbl (%rax,%r12), %esi
xorl %edi, %edi
callq *%r15
leal -0x4(%r14), %eax
cmpl $0x3, %r14d
movl %eax, %r14d
jg 0x1235b
movl %eax, %r14d
testl %eax, %eax
jns 0x12344
movq 0x3af2e(%rip), %rax     # 0x4d2b8
xorl %edi, %edi
movl $0x3b, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nurse[P]nkf/nkf.c
// Function: encode_fallback_java
static void
encode_fallback_java(nkf_char c)
{
    (*oconv)(0, '\\');
    c &= VALUE_MASK;
    if(!nkf_char_unicode_bmp_p(c)){
        int high = (c >> 10) + NKF_INT32_C(0xD7C0);   /* high surrogate */
        int low = (c & 0x3FF) + NKF_INT32_C(0xDC00); /* low surrogate */
	(*oconv)(0, 'u');
	(*oconv)(0, bin2hex(high>>12));
	(*oconv)(0, bin2hex(high>> 8));
	(*oconv)(0, bin2hex(high>> 4));
	(*oconv)(0, bin2hex(high    ));
	(*oconv)(0, '\\');
	(*oconv)(0, 'u');
	(*oconv)(0, bin2hex(low>>12));
	(*oconv)(0, bin2hex(low>> 8));
	(*oconv)(0, bin2hex(low>> 4));
	(*oconv)(0, bin2hex(low    ));
    }else{
	(*oconv)(0, 'u');
	(*oconv)(0, bin2hex(c>>12));
	(*oconv)(0, bin2hex(c>> 8));
	(*oconv)(0, bin2hex(c>> 4));
	(*oconv)(0, bin2hex(c    ));
    }
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %edi, %edi
movl $0x5c, %esi
callq *0x3af03(%rip)          # 0x4d2b8
movl %ebx, %r14d
andl $0xffffff, %r14d        # imm = 0xFFFFFF
cmpl $0x10000, %r14d         # imm = 0x10000
jae 0x123fd
xorl %edi, %edi
movl $0x75, %esi
callq *0x3aee3(%rip)          # 0x4d2b8
movl %ebx, %eax
shrl $0xc, %eax
andl $0xf, %eax
leaq 0x60a0(%rip), %rcx      # 0x18484
movsbl (%rax,%rcx), %esi
xorl %edi, %edi
callq *0x3aec8(%rip)          # 0x4d2b8
movl %ebx, %eax
shrl $0x8, %eax
andl $0xf, %eax
jmp 0x124a0
shrl $0xa, %r14d
leal 0xd7c0(%r14), %r15d
xorl %edi, %edi
movl $0x75, %esi
callq *0x3aea3(%rip)          # 0x4d2b8
movl %r15d, %eax
shrl $0xc, %eax
andl $0xf, %eax
leaq 0x605f(%rip), %r12      # 0x18484
movsbl (%rax,%r12), %esi
xorl %edi, %edi
callq *0x3ae86(%rip)          # 0x4d2b8
movl %r15d, %eax
shrl $0x8, %eax
andl $0xf, %eax
movsbl (%rax,%r12), %esi
xorl %edi, %edi
callq *0x3ae70(%rip)          # 0x4d2b8
shrl $0x4, %r15d
andl $0xf, %r15d
movsbl (%r15,%r12), %esi
xorl %edi, %edi
callq *0x3ae5b(%rip)          # 0x4d2b8
andl $0xf, %r14d
movsbl (%r14,%r12), %esi
xorl %edi, %edi
callq *0x3ae4a(%rip)          # 0x4d2b8
xorl %edi, %edi
movl $0x5c, %esi
callq *0x3ae3d(%rip)          # 0x4d2b8
xorl %edi, %edi
movl $0x75, %esi
callq *0x3ae30(%rip)          # 0x4d2b8
xorl %edi, %edi
movl $0x44, %esi
callq *0x3ae23(%rip)          # 0x4d2b8
movl %ebx, %eax
shrl $0x8, %eax
andl $0x3, %eax
orl $0xc, %eax
movl %eax, %eax
leaq 0x5fdb(%rip), %r14      # 0x18484
movsbl (%rax,%r14), %esi
xorl %edi, %edi
callq *0x3ae02(%rip)          # 0x4d2b8
movl %ebx, %eax
shrl $0x4, %eax
andl $0xf, %eax
movsbl (%rax,%r14), %esi
xorl %edi, %edi
callq *0x3aded(%rip)          # 0x4d2b8
movq 0x3ade6(%rip), %rax     # 0x4d2b8
andl $0xf, %ebx
movsbl (%rbx,%r14), %esi
xorl %edi, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %edi, %edi
movl $0x5c, %esi
callq *0x3adb8(%rip)          # 0x4d2b8
xorl %edi, %edi
movl $0x78, %esi
callq *0x3adab(%rip)          # 0x4d2b8
xorl %edi, %edi
movl $0x7b, %esi
callq *0x3ad9e(%rip)          # 0x4d2b8
movq 0x3ad97(%rip), %r15     # 0x4d2b8
andl $0xffffff, %ebx         # imm = 0xFFFFFF
movl $0x14, %r14d
leaq 0x5f50(%rip), %r12      # 0x18484
movl $0x1, %eax
movl %r14d, %ecx
shll %cl, %eax
cmpl %eax, %ebx
jge 0x1254b
addl $-0x4, %r14d
movl %r14d, %eax
jmp 0x1256c
movl %ebx, %eax
movl %r14d, %ecx
shrl %cl, %eax
andl $0xf, %eax
movsbl (%rax,%r12), %esi
xorl %edi, %edi
callq *%r15
leal -0x4(%r14), %eax
cmpl $0x3, %r14d
movl %eax, %r14d
jg 0x1254b
movl %eax, %r14d
testl %eax, %eax
jns 0x12534
movq 0x3ad3e(%rip), %rax     # 0x4d2b8
xorl %edi, %edi
movl $0x7d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/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
movl $0xe, %edi
callq 0xc1a0
testq %rax, %rax
je 0x12646
movq %rax, %rdi
callq 0x120b2
jmp 0x12648
xorl %eax, %eax
testq %rax, %rax
leaq 0x343c6(%rip), %rcx     # 0x46a18
cmovneq %rax, %rcx
movq %rcx, %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/nurse[P]nkf/nkf.c
// Function: eol_conv
static void
eol_conv(nkf_char c2, nkf_char c1)
{
    if (guess_f && input_eol != EOF) {
	if (c2 == 0 && c1 == LF) {
	    if (!input_eol) input_eol = prev_cr ? CRLF : LF;
	    else if (input_eol != (prev_cr ? CRLF : LF)) input_eol = EOF;
	} else if (c2 == 0 && c1 == CR && input_eol == LF) input_eol = EOF;
	else if (!prev_cr);
	else if (!input_eol) input_eol = CR;
	else if (input_eol != CR) input_eol = EOF;
    }
    if (prev_cr || (c2 == 0 && c1 == LF)) {
	prev_cr = 0;
	if (eolmode_f != LF) (*o_eol_conv)(0, CR);
	if (eolmode_f != CR) (*o_eol_conv)(0, LF);
    }
    if (c2 == 0 && c1 == CR) prev_cr = CR;
    else if (c2 != 0 || c1 != LF) (*o_eol_conv)(c2, c1);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
cmpl $0x0, 0x39b6e(%rip)     # 0x4d3b0
setne %cl
movl 0x41b95(%rip), %eax     # 0x553e0
cmpl $-0x1, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x138a3
movl %ebx, %ecx
xorl $0xa, %ecx
orl %ebp, %ecx
jne 0x13884
cmpb $0x0, 0x41d94(%rip)     # 0x555fc
movl $0xd0a, %edx            # imm = 0xD0A
movl $0xa, %ecx
cmovnel %edx, %ecx
testl %eax, %eax
je 0x1389d
cmpl %ecx, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
jne 0x1389d
jmp 0x138a3
movl %ebx, %edx
xorl $0xd, %edx
orl %ebp, %edx
movl %eax, %esi
xorl $0xa, %esi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
orl %edx, %esi
jne 0x1391d
movl %ecx, 0x41b3d(%rip)     # 0x553e0
cmpb $0x0, 0x41d52(%rip)     # 0x555fc
jne 0x138b5
movl %ebx, %eax
xorl $0xa, %eax
orl %ebp, %eax
jne 0x138e8
movb $0x0, 0x41d40(%rip)     # 0x555fc
cmpl $0xa, 0x41cd1(%rip)     # 0x55594
je 0x138d2
xorl %edi, %edi
movl $0xd, %esi
callq *0x39a2e(%rip)          # 0x4d300
cmpl $0xd, 0x41cbb(%rip)     # 0x55594
je 0x138e8
xorl %edi, %edi
movl $0xa, %esi
callq *0x39a18(%rip)          # 0x4d300
movl %ebx, %eax
xorl $0xd, %eax
orl %ebp, %eax
jne 0x138fa
movb $0x1, 0x41d04(%rip)     # 0x555fc
jmp 0x13916
movl %ebx, %eax
xorl $0xa, %eax
orl %ebp, %eax
je 0x13916
movq 0x399f6(%rip), %rax     # 0x4d300
movl %ebp, %edi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpb $0x1, 0x41cd8(%rip)     # 0x555fc
jne 0x138a3
testl %eax, %eax
je 0x1393c
cmpl $0xd, %eax
je 0x138a3
jmp 0x1389d
movl $0xd, %ecx
jmp 0x1389d
// File: /workspace/github_c_makefile_star2_O1/nurse[P]nkf/nkf.c
// Function: rot_conv
static void
rot_conv(nkf_char c2, nkf_char c1)
{
    if (c2 == 0 || c2 == JIS_X_0201_1976_K || c2 == ISO_8859_1) {
	c1 = rot13(c1);
    } else if (c2) {
	c1 = rot47(c1);
	c2 = rot47(c2);
    }
    (*o_rot_conv)(c2,c1);
}

// Assembly:
cmpl $0x2, %edi
jb 0x13953
cmpl $0x1013, %edi           # imm = 0x1013
jne 0x13962
cmpl $0x41, %esi
jl 0x139b7
cmpl $0x4d, %esi
jg 0x13971
addl $0xd, %esi
jmp 0x139b7
cmpl $0x21, %esi
jl 0x1399d
cmpl $0x4f, %esi
jg 0x13992
addl $0x2f, %esi
jmp 0x1399d
cmpl $0x5a, %esi
jg 0x1397b
addl $-0xd, %esi
jmp 0x139b7
cmpl $0x61, %esi
jl 0x139b7
cmpl $0x6d, %esi
jle 0x1395d
leal -0xd(%rsi), %eax
cmpl $0x7b, %esi
cmovgel %esi, %eax
movl %eax, %esi
jmp 0x139b7
leal -0x2f(%rsi), %eax
cmpl $0x7f, %esi
cmovgel %esi, %eax
movl %eax, %esi
cmpl $0x21, %edi
jl 0x139b7
cmpl $0x4f, %edi
jg 0x139ac
addl $0x2f, %edi
jmp 0x139b7
leal -0x2f(%rdi), %eax
cmpl $0x7f, %edi
cmovgel %edi, %eax
movl %eax, %edi
movq 0x3994a(%rip), %rax     # 0x4d308
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/nurse[P]nkf/nkf.c
// Function: hira_conv
static void
hira_conv(nkf_char c2, nkf_char c1)
{
    if (hira_f & 1) {
	if (c2 == 0x25) {
	    if (0x20 < c1 && c1 < 0x74) {
		c2 = 0x24;
		(*o_hira_conv)(c2,c1);
		return;
	    } else if (c1 == 0x74 && nkf_enc_unicode_p(output_encoding)) {
		c2 = 0;
		c1 = nkf_char_unicode_new(0x3094);
		(*o_hira_conv)(c2,c1);
		return;
	    }
	} else if (c2 == 0x21 && (c1 == 0x33 || c1 == 0x34)) {
	    c1 += 2;
	    (*o_hira_conv)(c2,c1);
	    return;
	}
    }
    if (hira_f & 2) {
	if (c2 == 0 && c1 == nkf_char_unicode_new(0x3094)) {
	    c2 = 0x25;
	    c1 = 0x74;
	} else if (c2 == 0x24 && 0x20 < c1 && c1 < 0x74) {
	    c2 = 0x25;
	} else if (c2 == 0x21 && (c1 == 0x35 || c1 == 0x36)) {
	    c1 -= 2;
	}
    }
    (*o_hira_conv)(c2,c1);
}

// Assembly:
movl 0x41b23(%rip), %eax     # 0x55568
testb $0x1, %al
je 0x13ab6
cmpl $0x21, %edi
je 0x13a69
cmpl $0x25, %edi
jne 0x13ab6
leal -0x21(%rsi), %ecx
cmpl $0x52, %ecx
ja 0x13a82
movq 0x398ae(%rip), %rax     # 0x4d310
movl $0x24, %edi
jmpq *%rax
leal -0x33(%rsi), %ecx
cmpl $0x1, %ecx
ja 0x13ab6
addl $0x2, %esi
movq 0x39895(%rip), %rax     # 0x4d310
movl $0x21, %edi
jmpq *%rax
cmpl $0x74, %esi
jne 0x13ab6
movq 0x41aba(%rip), %rcx     # 0x55548
movq 0x10(%rcx), %rcx
leaq 0x32d67(%rip), %rdx     # 0x46800
cmpq %rdx, %rcx
je 0x13b0c
leaq 0x32d2b(%rip), %rdx     # 0x467d0
cmpq %rdx, %rcx
je 0x13b0c
leaq 0x32d37(%rip), %rdx     # 0x467e8
cmpq %rdx, %rcx
je 0x13b0c
testb $0x2, %al
je 0x13b03
movl %esi, %eax
xorl $0x1003094, %eax        # imm = 0x1003094
orl %edi, %eax
jne 0x13ad1
movl $0x25, %edi
movl $0x74, %esi
jmp 0x13b03
cmpl $0x24, %edi
sete %al
leal -0x21(%rsi), %ecx
cmpl $0x53, %ecx
setb %cl
testb %cl, %al
je 0x13aeb
movl $0x25, %edi
jmp 0x13b03
cmpl $0x21, %edi
jne 0x13b03
leal -0x35(%rsi), %eax
leal -0x2(%rsi), %ecx
cmpl $0x2, %eax
cmovael %esi, %ecx
movl $0x21, %edi
movl %ecx, %esi
movq 0x39806(%rip), %rax     # 0x4d310
jmpq *%rax
movq 0x397fd(%rip), %rax     # 0x4d310
xorl %edi, %edi
movl $0x1003094, %esi        # imm = 0x1003094
jmpq *%rax