LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/euc.c
// Function: euc_jp_from_ucs
static unsigned long euc_jp_from_ucs(long int ucs)
{
    int r, c;
    if (ucs >= 0xFF61 && ucs <= 0xFF9F)
	return 0x20000000 | (ucs - (0xFF61 - 0xA1));
    else if (unicode_to_jisx0208(ucs, &r, &c))
	return 0x10000000 | ((r+0xA1) << 8) | (c+0xA1);
    else if (unicode_to_jisx0212(ucs, &r, &c))
	return 0x30000000 | ((r+0xA1) << 8) | (c+0xA1);
    else
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0xff61, -0x10(%rbp)    # imm = 0xFF61
jl 0x71c6
cmpq $0xff9f, -0x10(%rbp)    # imm = 0xFF9F
jg 0x71c6
movq -0x10(%rbp), %rax
subq $0xfec0, %rax           # imm = 0xFEC0
orq $0x20000000, %rax       # imm = 0x20000000
movq %rax, -0x8(%rbp)
jmp 0x7240
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0xa980
cmpl $0x0, %eax
je 0x71ff
movl -0x14(%rbp), %eax
addl $0xa1, %eax
shll $0x8, %eax
orl $0x10000000, %eax       # imm = 0x10000000
movl -0x18(%rbp), %ecx
addl $0xa1, %ecx
orl %ecx, %eax
cltq
movq %rax, -0x8(%rbp)
jmp 0x7240
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0xaaf0
cmpl $0x0, %eax
je 0x7238
movl -0x14(%rbp), %eax
addl $0xa1, %eax
shll $0x8, %eax
orl $0x30000000, %eax       # imm = 0x30000000
movl -0x18(%rbp), %ecx
addl $0xa1, %ecx
orl %ecx, %eax
cltq
movq %rax, -0x8(%rbp)
jmp 0x7240
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/euc.c
// Function: euc_tw_to_ucs
static long int euc_tw_to_ucs(unsigned long state)
{
    int plane;
    switch (state >> 28) {
      case 1: return cns11643_to_unicode(0, ((state >> 8) & 0xFF) - 0xA1,
					    ((state     ) & 0xFF) - 0xA1);
      case 2:
	plane = ((state >> 8) & 0xFF) - 0xA1;
	if (plane >= 7) return ERROR;
	return cns11643_to_unicode(plane, ((state >> 8) & 0xFF) - 0xA1,
					  ((state     ) & 0xFF) - 0xA1);
      default: return ERROR;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x1c, %rax
movq %rax, -0x20(%rbp)
subq $0x1, %rax
je 0x727f
jmp 0x7270
movq -0x20(%rbp), %rax
subq $0x2, %rax
je 0x72b4
jmp 0x7311
movq -0x10(%rbp), %rax
shrq $0x8, %rax
andq $0xff, %rax
subq $0xa1, %rax
movl %eax, %esi
movq -0x10(%rbp), %rax
andq $0xff, %rax
subq $0xa1, %rax
movl %eax, %edx
xorl %edi, %edi
callq 0x6860
movq %rax, -0x8(%rbp)
jmp 0x7319
movq -0x10(%rbp), %rax
shrq $0x8, %rax
andq $0xff, %rax
subq $0xa1, %rax
movl %eax, -0x14(%rbp)
cmpl $0x7, -0x14(%rbp)
jl 0x72db
movq $0xffff, -0x8(%rbp)     # imm = 0xFFFF
jmp 0x7319
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rax
shrq $0x8, %rax
andq $0xff, %rax
subq $0xa1, %rax
movl %eax, %esi
movq -0x10(%rbp), %rax
andq $0xff, %rax
subq $0xa1, %rax
movl %eax, %edx
callq 0x6860
movq %rax, -0x8(%rbp)
jmp 0x7319
movq $0xffff, -0x8(%rbp)     # imm = 0xFFFF
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/euc.c
// Function: euc_tw_from_ucs
static unsigned long euc_tw_from_ucs(long int ucs)
{
    int p, r, c;
    if (unicode_to_cns11643(ucs, &p, &r, &c)) {
	if (p == 0)
	    return 0x10000000 | ((r+0xA1) << 8) | (c+0xA1);
	else
	    return 0x20000000 |
		((p + 0xA1) << 16) | ((r+0xA1) << 8) | (c+0xA1);
    } else
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x1c(%rbp), %rcx
callq 0x6970
cmpl $0x0, %eax
je 0x73b0
cmpl $0x0, -0x14(%rbp)
jne 0x737f
movl -0x18(%rbp), %eax
addl $0xa1, %eax
shll $0x8, %eax
orl $0x10000000, %eax       # imm = 0x10000000
movl -0x1c(%rbp), %ecx
addl $0xa1, %ecx
orl %ecx, %eax
cltq
movq %rax, -0x8(%rbp)
jmp 0x73b8
movl -0x14(%rbp), %eax
addl $0xa1, %eax
shll $0x10, %eax
orl $0x20000000, %eax       # imm = 0x20000000
movl -0x18(%rbp), %ecx
addl $0xa1, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl -0x1c(%rbp), %ecx
addl $0xa1, %ecx
orl %ecx, %eax
cltq
movq %rax, -0x8(%rbp)
jmp 0x73b8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/gb2312.c
// Function: unicode_to_gb2312
int unicode_to_gb2312(long int unicode, int *r, int *c)
{
    int rr, cc;
    long int uu;
    int i, j, k;

    i = -1;
    j = lenof(gb2312_backward);
    while (j - i > 1) {
	k = (i + j) / 2;
	rr = gb2312_backward[k].r;
	cc = gb2312_backward[k].c;
	uu = gb2312_forward[rr][cc];
	if (unicode > uu)
	    i = k;
	else if (unicode < uu)
	    j = k;
	else {
	    *r = rr;
	    *c = cc;
	    return 1;
	}
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movl $0x1d15, -0x38(%rbp)    # imm = 0x1D15
movl -0x38(%rbp), %eax
subl -0x34(%rbp), %eax
cmpl $0x1, %eax
jle 0x752a
movl -0x34(%rbp), %eax
addl -0x38(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x3c(%rbp)
movslq -0x3c(%rbp), %rcx
leaq 0x53917(%rip), %rax     # 0x5adc0
movzbl (%rax,%rcx,2), %eax
movl %eax, -0x24(%rbp)
movslq -0x3c(%rbp), %rcx
leaq 0x53905(%rip), %rax     # 0x5adc0
movzbl 0x1(%rax,%rcx,2), %eax
movl %eax, -0x28(%rbp)
movslq -0x24(%rbp), %rcx
leaq 0x4f3e2(%rip), %rax     # 0x568b0
imulq $0xbc, %rcx, %rcx
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
jle 0x74f6
movl -0x3c(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x7525
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
jge 0x7508
movl -0x3c(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x7523
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x28(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x7531
jmp 0x7525
jmp 0x747e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/hz.c
// Function: write_hz
static int write_hz(charset_spec const *charset, long int input_chr,
		    charset_state *state,
		    void (*emit)(void *ctx, long int output), void *emitctx)
{
    int desired_state, r, c;

    UNUSEDARG(charset);

    /*
     * Analyse the input char.
     */
    if (input_chr < 0x80) {
	desired_state = 0;
	c = input_chr;
    } else if (unicode_to_gb2312(input_chr, &r, &c)) {
	desired_state = 1;
    } else {
	return FALSE;
    }

    if (state->s0 != (unsigned)desired_state) {
	emit(emitctx, '~');
	emit(emitctx, desired_state ? '{' : '}');
	state->s0 = desired_state;
    }

    if (input_chr < 0)
	return TRUE;		       /* special case: just reset state */

    if (state->s0) {
	/*
	 * GB mode.
	 */
	emit(emitctx, 0x21 + r);
	emit(emitctx, 0x21 + c);
    } else {
	emit(emitctx, c);
    }
    return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x80, -0x18(%rbp)
jge 0x774e
movl $0x0, -0x34(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0x3c(%rbp)
jmp 0x777b
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x3c(%rbp), %rdx
callq 0x7460
cmpl $0x0, %eax
je 0x776d
movl $0x1, -0x34(%rbp)
jmp 0x7779
movl $0x0, -0x4(%rbp)
jmp 0x781b
jmp 0x777b
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl -0x34(%rbp), %ecx
cmpq %rcx, %rax
je 0x77c4
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdi
movl $0x7e, %esi
callq *%rax
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
movl $0x7d, %ecx
movl $0x7b, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
movslq %ecx, %rsi
callq *%rax
movslq -0x34(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x18(%rbp)
jge 0x77d4
movl $0x1, -0x4(%rbp)
jmp 0x781b
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7806
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdi
movl -0x38(%rbp), %ecx
addl $0x21, %ecx
movslq %ecx, %rsi
callq *%rax
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdi
movl -0x3c(%rbp), %ecx
addl $0x21, %ecx
movslq %ecx, %rsi
callq *%rax
jmp 0x7814
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdi
movslq -0x3c(%rbp), %rsi
callq *%rax
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/iso2022.c
// Function: emacs_big5_1_to_unicode
static long int emacs_big5_1_to_unicode(int r, int c)
{
    unsigned long s;
    s = r * 94 + c;
    r = s / 157;
    c = s % 157;
    if (c >= 64) c += 34; /* Skip over the gap */
    return big5_to_unicode(r, c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
imull $0x5e, -0x4(%rbp), %eax
addl -0x8(%rbp), %eax
cltq
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x9d, %ecx
xorl %edx, %edx
divq %rcx
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
movl $0x9d, %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x8(%rbp)
cmpl $0x40, -0x8(%rbp)
jl 0x79ce
movl -0x8(%rbp), %eax
addl $0x22, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x66f0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/iso2022.c
// Function: unicode_to_emacs_big5
static int unicode_to_emacs_big5(long int unicode, int *p, int *r, int *c)
{
    int rr, cc, s;
    if (!unicode_to_big5(unicode, &rr, &cc))
	return 0;
    if (cc >= 64) {
	cc -= 34;
	assert(cc >= 64);
    }
    s = rr * 157 + cc;
    if (s >= 40*157) {
	*p = 2;
	s -= 40*157;
    } else {
	*p = 1;
    }
    *r = s / 94;
    *c = s % 94;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x6780
cmpl $0x0, %eax
jne 0x7a1a
movl $0x0, -0x4(%rbp)
jmp 0x7ab4
cmpl $0x40, -0x30(%rbp)
jl 0x7a52
movl -0x30(%rbp), %eax
subl $0x22, %eax
movl %eax, -0x30(%rbp)
cmpl $0x40, -0x30(%rbp)
jl 0x7a31
jmp 0x7a50
leaq 0x56fc0(%rip), %rdi     # 0x5e9f8
leaq 0x56fc2(%rip), %rsi     # 0x5ea01
movl $0xfa, %edx
leaq 0x56fc0(%rip), %rcx     # 0x5ea0b
callq 0x6050
jmp 0x7a52
imull $0x9d, -0x2c(%rbp), %eax
addl -0x30(%rbp), %eax
movl %eax, -0x34(%rbp)
cmpl $0x1888, -0x34(%rbp)    # imm = 0x1888
jl 0x7a7f
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movl -0x34(%rbp), %eax
subl $0x1888, %eax           # imm = 0x1888
movl %eax, -0x34(%rbp)
jmp 0x7a89
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movl -0x34(%rbp), %eax
movl $0x5e, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x34(%rbp), %eax
movl $0x5e, %ecx
cltd
idivl %ecx
movq -0x28(%rbp), %rax
movl %edx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/iso2022.c
// Function: emacs_big5_2_to_unicode
static long int emacs_big5_2_to_unicode(int r, int c)
{
    unsigned long s;
    s = r * 94 + c;
    r = s / 157 + 40;
    c = s % 157;
    if (c >= 64) c += 34; /* Skip over the gap */
    return big5_to_unicode(r, c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
imull $0x5e, -0x4(%rbp), %eax
addl -0x8(%rbp), %eax
cltq
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x9d, %ecx
xorl %edx, %edx
divq %rcx
addq $0x28, %rax
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
movl $0x9d, %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x8(%rbp)
cmpl $0x40, -0x8(%rbp)
jl 0x7b12
movl -0x8(%rbp), %eax
addl $0x22, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x66f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/iso2022.c
// Function: unicode_to_null_dbcs
static int unicode_to_null_dbcs(long int unicode, int *r, int *c)
{
    UNUSEDARG(unicode);
    UNUSEDARG(r);
    UNUSEDARG(c);
    return 0;			       /* failed to convert anything */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/iso2022.c
// Function: designate
static void designate(charset_state *state, int container,
		      int type, int ibyte, int fbyte)
{
    unsigned long i;

    assert(container >= 0 && container <= 3);
    assert(type == S4 || type == S6 || type == M4 || type == M6);

    for (i = 0; i < lenof(iso2022_subcharsets); i++) {
	if (iso2022_subcharsets[i].type == type &&
	    iso2022_subcharsets[i].i == ibyte &&
	    iso2022_subcharsets[i].f == fbyte) {
	    state->s1 &= ~(0x7fL << (container * 7));
	    state->s1 |= (i << (container * 7));
	    return;
	}
    }
    /*
     * If we don't find the charset, invoke the empty one, so we
     * output ERROR rather than garbage.
     */
    designate(state, container, type, 0, '~');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x8ec7
cmpl $0x3, -0xc(%rbp)
jg 0x8ec7
jmp 0x8ee6
leaq 0x55b72(%rip), %rdi     # 0x5ea40
leaq 0x55b2c(%rip), %rsi     # 0x5ea01
movl $0x149, %edx            # imm = 0x149
leaq 0x55b80(%rip), %rcx     # 0x5ea61
callq 0x6050
cmpl $0x0, -0x10(%rbp)
je 0x8efe
cmpl $0x1, -0x10(%rbp)
je 0x8efe
cmpl $0x2, -0x10(%rbp)
je 0x8efe
cmpl $0x3, -0x10(%rbp)
jne 0x8f00
jmp 0x8f1f
leaq 0x55b8e(%rip), %rdi     # 0x5ea95
leaq 0x55af3(%rip), %rsi     # 0x5ea01
movl $0x14a, %edx            # imm = 0x14A
leaq 0x55b47(%rip), %rcx     # 0x5ea61
callq 0x6050
movq $0x0, -0x20(%rbp)
cmpq $0x26, -0x20(%rbp)
jae 0x8fcd
leaq 0xa0357(%rip), %rax     # 0xa9290
imulq $0x28, -0x20(%rbp), %rcx
addq %rcx, %rax
movsbl (%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0x8fba
leaq 0xa0340(%rip), %rax     # 0xa9290
imulq $0x28, -0x20(%rbp), %rcx
addq %rcx, %rax
movsbl 0x1(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x8fba
leaq 0xa0328(%rip), %rax     # 0xa9290
imulq $0x28, -0x20(%rbp), %rcx
addq %rcx, %rax
movsbl 0x2(%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x8fba
imull $0x7, -0xc(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x7f, %eax
shlq %cl, %rax
movq %rax, %rcx
xorq $-0x1, %rcx
movq -0x8(%rbp), %rax
andq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
imull $0x7, -0xc(%rbp), %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
jmp 0x8fe4
jmp 0x8fbc
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x8f27
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
xorl %ecx, %ecx
movl $0x7e, %r8d
callq 0x8ea0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/iso2022.c
// Function: docs_utf8
static void docs_utf8(long int input_chr,
		      charset_state *state,
		      void (*emit)(void *ctx, long int output),
		      void *emitctx)
{
    int retstate;

    /*
     * Bits [25:0] of s0 are reserved for read_utf8().
     * Bits [27:26] are a tiny state machine to recognise ESC % @.
     */
    retstate = (state->s0 & 0x0c000000L) >> 26;
    if (retstate == 1 && input_chr == '%')
	retstate = 2;
    else if (retstate == 2 && input_chr == '@') {
	/* If we've got a partial UTF-8 sequence, complain. */
	if (state->s0 & 0x03ffffffL)
	    emit(emitctx, ERROR);
	state->s0 = 0;
	return;
    } else {
	if (retstate >= 1) do_utf8(ESC, state, emit, emitctx);
	if (retstate >= 2) do_utf8('%', state, emit, emitctx);
	retstate = 0;
	if (input_chr == ESC)
	    retstate = 1;
	else {
	    do_utf8(input_chr, state, emit, emitctx);
	}
    }
    state->s0 = (state->s0 & ~0x0c000000L) | (retstate << 26);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0xc000000, %rax        # imm = 0xC000000
shrq $0x1a, %rax
movl %eax, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
jne 0x9035
cmpq $0x25, -0x8(%rbp)
jne 0x9035
movl $0x2, -0x24(%rbp)
jmp 0x90dc
cmpl $0x2, -0x24(%rbp)
jne 0x9074
cmpq $0x40, -0x8(%rbp)
jne 0x9074
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x3ffffff, %rax        # imm = 0x3FFFFFF
cmpq $0x0, %rax
je 0x9064
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
movl $0xffff, %esi           # imm = 0xFFFF
callq *%rax
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
jmp 0x90fc
cmpl $0x1, -0x24(%rbp)
jl 0x9090
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x1b, %edi
callq 0x94a0
cmpl $0x2, -0x24(%rbp)
jl 0x90ac
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x25, %edi
callq 0x94a0
movl $0x0, -0x24(%rbp)
cmpq $0x1b, -0x8(%rbp)
jne 0x90c3
movl $0x1, -0x24(%rbp)
jmp 0x90d8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x94a0
jmp 0x90da
jmp 0x90dc
movq -0x10(%rbp), %rax
movq (%rax), %rcx
andq $-0xc000001, %rcx       # imm = 0xF3FFFFFF
movl -0x24(%rbp), %eax
shll $0x1a, %eax
cltq
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/iso2022.c
// Function: do_utf8
static void do_utf8(long int input_chr,
		    charset_state *state,
		    void (*emit)(void *ctx, long int output),
		    void *emitctx)
{
    charset_state ustate;

    ustate.s1 = 0;
    ustate.s0 = state->s0 & 0x03ffffffL;
    read_utf8(NULL, input_chr, &ustate, emit, emitctx);
    state->s0 = (state->s0 & ~0x03ffffffL) | (ustate.s0 & 0x03ffffffL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x3ffffff, %rax        # imm = 0x3FFFFFF
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
xorl %eax, %eax
movl %eax, %edi
leaq -0x30(%rbp), %rdx
callq 0xc150
movq -0x10(%rbp), %rax
movq (%rax), %rcx
andq $-0x4000000, %rcx       # imm = 0xFC000000
movq -0x30(%rbp), %rax
andq $0x3ffffff, %rax        # imm = 0x3FFFFFF
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/iso2022.c
// Function: oselect
static void oselect(charset_state *state, int i, int right,
		    void (*emit)(void *ctx, long int output),
		    void *emitctx)
{
    int shift = (right ? 31-7 : 31-7-7);
    struct iso2022_subcharset const *subcs = &iso2022_subcharsets[i];

    if (((state->s1 >> shift) & 0x7F) != (unsigned)i) {
	state->s1 &= ~(0x7FL << shift);
	state->s1 |= (i << shift);

	if (emit) {
	    emit(emitctx, ESC);
	    if (subcs->type == M4 || subcs->type == M6)
		emit(emitctx, '$');
	    if (subcs->type == S6 || subcs->type == M6) {
		assert(right);
		emit(emitctx, '-');
	    } else if (right) {
		emit(emitctx, ')');
	    } else {
		emit(emitctx, '(');
	    }
	    if (subcs->i)
		emit(emitctx, subcs->i);
	    emit(emitctx, subcs->f);
	}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl -0x10(%rbp), %edx
movl $0x11, %eax
movl $0x18, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x24(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0x9fd35(%rip), %rax     # 0xa9290
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x24(%rbp), %ecx
shrq %cl, %rax
andq $0x7f, %rax
movl -0xc(%rbp), %ecx
cmpq %rcx, %rax
je 0x96a6
movl -0x24(%rbp), %eax
movl %eax, %ecx
movl $0x7f, %eax
shlq %cl, %rax
movq %rax, %rcx
xorq $-0x1, %rcx
movq -0x8(%rbp), %rax
andq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %eax
movl -0x24(%rbp), %ecx
shll %cl, %eax
movslq %eax, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x96a4
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
movl $0x1b, %esi
callq *%rax
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2, %eax
je 0x95ed
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3, %eax
jne 0x95fc
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
movl $0x24, %esi
callq *%rax
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x1, %eax
je 0x9614
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3, %eax
jne 0x964c
cmpl $0x0, -0x10(%rbp)
je 0x961c
jmp 0x963b
leaq 0x555dd(%rip), %rdi     # 0x5ec00
leaq 0x553d7(%rip), %rsi     # 0x5ea01
movl $0x339, %edx            # imm = 0x339
leaq 0x555d0(%rip), %rcx     # 0x5ec06
callq 0x6050
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
movl $0x2d, %esi
callq *%rax
jmp 0x9674
cmpl $0x0, -0x10(%rbp)
je 0x9663
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
movl $0x29, %esi
callq *%rax
jmp 0x9672
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
movl $0x28, %esi
callq *%rax
jmp 0x9674
movq -0x30(%rbp), %rax
cmpb $0x0, 0x1(%rax)
je 0x9691
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rcx
movsbq 0x1(%rcx), %rsi
callq *%rax
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rcx
movsbq 0x2(%rcx), %rsi
callq *%rax
jmp 0x96a6
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/iso2022s.c
// Function: iso2022jp_to_ucs
static long int iso2022jp_to_ucs(int subcharset, unsigned long bytes)
{
    switch (subcharset) {
      case 1:			       /* JIS X 0201 bottom half */
	if (bytes == 0x5C)
	    return 0xA5;
	else if (bytes == 0x7E)
	    return 0x203E;
	/* else fall through to ASCII */
      case 0: return bytes;	       /* one-byte ASCII */
	/* (no break needed since all control paths have returned) */
      case 2: return jisx0208_to_unicode(((bytes >> 8) & 0xFF) - 0x21,
					 ((bytes     ) & 0xFF) - 0x21);
      default: return ERROR;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0xa6c5
jmp 0xa68b
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0xa69f
jmp 0xa695
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0xa6cf
jmp 0xa6fe
cmpq $0x5c, -0x18(%rbp)
jne 0xa6b0
movq $0xa5, -0x8(%rbp)
jmp 0xa706
cmpq $0x7e, -0x18(%rbp)
jne 0xa6c1
movq $0x203e, -0x8(%rbp)     # imm = 0x203E
jmp 0xa706
jmp 0xa6c3
jmp 0xa6c5
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa706
movq -0x18(%rbp), %rax
shrq $0x8, %rax
andq $0xff, %rax
subq $0x21, %rax
movl %eax, %edi
movq -0x18(%rbp), %rax
andq $0xff, %rax
subq $0x21, %rax
movl %eax, %esi
callq 0xa8f0
movq %rax, -0x8(%rbp)
jmp 0xa706
movq $0xffff, -0x8(%rbp)     # imm = 0xFFFF
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/iso2022s.c
// Function: iso2022jp_from_ucs
static int iso2022jp_from_ucs(long int ucs, int *subcharset,
			      unsigned long *bytes)
{
    int r, c;
    if (ucs < 0x80) {
	*subcharset = 0;
	*bytes = ucs;
	return 1;
    } else if (ucs == 0xA5 || ucs == 0x203E) {
	*subcharset = 1;
	*bytes = (ucs == 0xA5 ? 0x5C : 0x7E);
	return 1;
    } else if (unicode_to_jisx0208(ucs, &r, &c)) {
	*subcharset = 2;
	*bytes = ((r+0x21) << 8) | (c+0x21);
	return 1;
    } else {
	return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x80, -0x10(%rbp)
jge 0xa74f
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xa7e3
cmpq $0xa5, -0x10(%rbp)
je 0xa763
cmpq $0x203e, -0x10(%rbp)    # imm = 0x203E
jne 0xa798
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rdx
movl $0x7e, %eax
movl $0x5c, %ecx
cmpq $0xa5, %rdx
cmovel %ecx, %eax
movslq %eax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xa7e3
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xa980
cmpl $0x0, %eax
je 0xa7dc
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movl -0x24(%rbp), %eax
addl $0x21, %eax
shll $0x8, %eax
movl -0x28(%rbp), %ecx
addl $0x21, %ecx
orl %ecx, %eax
movslq %eax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xa7e3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/iso2022s.c
// Function: iso2022kr_to_ucs
static long int iso2022kr_to_ucs(int subcharset, unsigned long bytes)
{
    switch (subcharset) {
      case 0: return bytes;	       /* one-byte ASCII */
      case 1: return ksx1001_to_unicode(((bytes >> 8) & 0xFF) - 0x21,
					((bytes     ) & 0xFF) - 0x21);
      default: return ERROR;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0xa815
jmp 0xa80b
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0xa81f
jmp 0xa84e
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa856
movq -0x18(%rbp), %rax
shrq $0x8, %rax
andq $0xff, %rax
subq $0x21, %rax
movl %eax, %edi
movq -0x18(%rbp), %rax
andq $0xff, %rax
subq $0x21, %rax
movl %eax, %esi
callq 0xad50
movq %rax, -0x8(%rbp)
jmp 0xa856
movq $0xffff, -0x8(%rbp)     # imm = 0xFFFF
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/iso2022s.c
// Function: iso2022kr_from_ucs
static int iso2022kr_from_ucs(long int ucs, int *subcharset,
			      unsigned long *bytes)
{
    int r, c;
    if (ucs < 0x80) {
	*subcharset = 0;
	*bytes = ucs;
	return 1;
    } else if (unicode_to_ksx1001(ucs, &r, &c)) {
	*subcharset = 1;
	*bytes = ((r+0x21) << 8) | (c+0x21);
	return 1;
    } else {
	return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x80, -0x10(%rbp)
jge 0xa89c
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xa8e7
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xadf0
cmpl $0x0, %eax
je 0xa8e0
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movl -0x24(%rbp), %eax
addl $0x21, %eax
shll $0x8, %eax
movl -0x28(%rbp), %ecx
addl $0x21, %ecx
orl %ecx, %eax
movslq %eax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xa8e7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/jisx0208.c
// Function: unicode_to_jisx0208
int unicode_to_jisx0208(long int unicode, int *r, int *c)
{
    int rr, cc;
    long int uu;
    int i, j, k;

    i = -1;
    j = lenof(jisx0208_backward);
    while (j - i > 1) {
	k = (i + j) / 2;
	rr = jisx0208_backward[k].r;
	cc = jisx0208_backward[k].c;
	uu = jisx0208_forward[rr][cc];
	if (unicode > uu)
	    i = k;
	else if (unicode < uu)
	    j = k;
	else {
	    *r = rr;
	    *c = cc;
	    return 1;
	}
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movl $0x1adf, -0x38(%rbp)    # imm = 0x1ADF
movl -0x38(%rbp), %eax
subl -0x34(%rbp), %eax
cmpl $0x1, %eax
jle 0xaa4a
movl -0x34(%rbp), %eax
addl -0x38(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x3c(%rbp)
movslq -0x3c(%rbp), %rcx
leaq 0x58997(%rip), %rax     # 0x63360
movzbl (%rax,%rcx,2), %eax
movl %eax, -0x24(%rbp)
movslq -0x3c(%rbp), %rcx
leaq 0x58985(%rip), %rax     # 0x63360
movzbl 0x1(%rax,%rcx,2), %eax
movl %eax, -0x28(%rbp)
movslq -0x24(%rbp), %rcx
leaq 0x54462(%rip), %rax     # 0x5ee50
imulq $0xbc, %rcx, %rcx
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
jle 0xaa16
movl -0x3c(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0xaa45
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
jge 0xaa28
movl -0x3c(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0xaa43
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x28(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xaa51
jmp 0xaa45
jmp 0xa99e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/jisx0212.c
// Function: unicode_to_jisx0212
int unicode_to_jisx0212(long int unicode, int *r, int *c)
{
    int rr, cc;
    long int uu;
    int i, j, k;

    i = -1;
    j = lenof(jisx0212_backward);
    while (j - i > 1) {
	k = (i + j) / 2;
	rr = jisx0212_backward[k].r;
	cc = jisx0212_backward[k].c;
	uu = jisx0212_forward[rr][cc];
	if (unicode > uu)
	    i = k;
	else if (unicode < uu)
	    j = k;
	else {
	    *r = rr;
	    *c = cc;
	    return 1;
	}
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movl $0x17b3, -0x38(%rbp)    # imm = 0x17B3
movl -0x38(%rbp), %eax
subl -0x34(%rbp), %eax
cmpl $0x1, %eax
jle 0xabba
movl -0x34(%rbp), %eax
addl -0x38(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x3c(%rbp)
movslq -0x3c(%rbp), %rcx
leaq 0x60327(%rip), %rax     # 0x6ae60
movzbl (%rax,%rcx,2), %eax
movl %eax, -0x24(%rbp)
movslq -0x3c(%rbp), %rcx
leaq 0x60315(%rip), %rax     # 0x6ae60
movzbl 0x1(%rax,%rcx,2), %eax
movl %eax, -0x28(%rbp)
movslq -0x24(%rbp), %rcx
leaq 0x5bdf2(%rip), %rax     # 0x66950
imulq $0xbc, %rcx, %rcx
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
jle 0xab86
movl -0x3c(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0xabb5
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
jge 0xab98
movl -0x3c(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0xabb3
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x28(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xabc1
jmp 0xabb5
jmp 0xab0e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/ksx1001.c
// Function: unicode_to_cp949
int unicode_to_cp949(long int unicode, int *r, int *c)
{
    int rr, cc;
    long int uu;
    int i, j, k;

    i = -1;
    j = lenof(cp949_backward);
    while (j - i > 1) {
	k = (i + j) / 2;
	rr = cp949_backward[k].r;
	cc = cp949_backward[k].c;
	uu = cp949_forward[rr][cc];
	if (unicode > uu)
	    i = k;
	else if (unicode < uu)
	    j = k;
	else {
	    *r = rr;
	    *c = cc;
	    return 1;
	}
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movl $0x4298, -0x38(%rbp)    # imm = 0x4298
movl -0x38(%rbp), %eax
subl -0x34(%rbp), %eax
cmpl $0x1, %eax
jle 0xad3a
movl -0x34(%rbp), %eax
addl -0x38(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x3c(%rbp)
movslq -0x3c(%rbp), %rcx
leaq 0x6f187(%rip), %rax     # 0x79e40
movzbl (%rax,%rcx,2), %eax
movl %eax, -0x24(%rbp)
movslq -0x3c(%rbp), %rcx
leaq 0x6f175(%rip), %rax     # 0x79e40
movzbl 0x1(%rax,%rcx,2), %eax
movl %eax, -0x28(%rbp)
movslq -0x24(%rbp), %rcx
leaq 0x63162(%rip), %rax     # 0x6de40
imulq $0x180, %rcx, %rcx      # imm = 0x180
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
jle 0xad06
movl -0x3c(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0xad35
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
jge 0xad18
movl -0x3c(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0xad33
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x28(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xad41
jmp 0xad35
jmp 0xac8e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/ksx1001.c
// Function: unicode_to_ksx1001
int unicode_to_ksx1001(long int unicode, int *r, int *c)
{
    int rr, cc;
    if (!unicode_to_cp949(unicode, &rr, &cc))
	return 0;
    rr -= 0x21;
    cc -= 0x61;
    if (rr < 0 || rr >= 94 || cc < 0 || cc >= 94)
	return 0;
    *r = rr;
    *c = cc;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xac70
cmpl $0x0, %eax
jne 0xae23
movl $0x0, -0x4(%rbp)
jmp 0xae6f
movl -0x24(%rbp), %eax
subl $0x21, %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
subl $0x61, %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0xae4d
cmpl $0x5e, -0x24(%rbp)
jge 0xae4d
cmpl $0x0, -0x28(%rbp)
jl 0xae4d
cmpl $0x5e, -0x28(%rbp)
jl 0xae56
movl $0x0, -0x4(%rbp)
jmp 0xae6f
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x28(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/localenc.c
// Function: charset_to_localenc
const char *charset_to_localenc(int charset)
{
    int i;

    for (i = 0; i < (int)lenof(localencs); i++)
	if (charset == localencs[i].charset)
	    return localencs[i].name;

    return NULL;		       /* not found */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x66, -0x10(%rbp)
jge 0xaed6
movl -0xc(%rbp), %eax
movslq -0x10(%rbp), %rdx
leaq 0x9ec1e(%rip), %rcx     # 0xa9ac0
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
jne 0xaec9
movslq -0x10(%rbp), %rcx
leaq 0x9ec07(%rip), %rax     # 0xa9ac0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xaede
jmp 0xaecb
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xae8e
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/localenc.c
// Function: charset_from_localenc
int charset_from_localenc(const char *name)
{
    int i;

    if ( (i = charset_from_mimeenc(name)) != CS_NONE)
	return i;
    if ( (i = charset_from_xenc(name)) != CS_NONE)
	return i;
    if ( (i = charset_from_emacsenc(name)) != CS_NONE)
	return i;

    for (i = 0; i < (int)lenof(localencs); i++) {
	const char *p, *q;
	p = name;
	q = localencs[i].name;
	while (*p || *q) {
		if (tolower((unsigned char)*p) != tolower((unsigned char)*q))
		break;
	    p++; q++;
	}
	if (!*p && !*q)
	    return localencs[i].charset;
    }

    return CS_NONE;		       /* not found */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb120
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0xaf18
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb02f
movq -0x10(%rbp), %rdi
callq 0xc8b0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0xaf34
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb02f
movq -0x10(%rbp), %rdi
callq 0xca20
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0xaf50
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb02f
movl $0x0, -0x14(%rbp)
cmpl $0x66, -0x14(%rbp)
jge 0xb028
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x9eb4c(%rip), %rax     # 0xa9ac0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
jne 0xafa3
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xafac
jmp 0xafec
movq -0x20(%rbp), %rax
movzbl (%rax), %edi
callq 0x6080
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movzbl (%rax), %edi
callq 0x6080
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
je 0xafd2
jmp 0xafec
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xaf82
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xb018
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xb018
movslq -0x14(%rbp), %rcx
leaq 0x9eab7(%rip), %rax     # 0xa9ac0
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xb02f
jmp 0xb01a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xaf57
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/localenc.c
// Function: charset_localenc_nth
int charset_localenc_nth(int n)
{
    int i;

    for (i = 0; i < (int)lenof(localencs); i++)
	if (localencs[i].return_in_enum && !n--)
	    return localencs[i].charset;

    return CS_NONE;		       /* end of list */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x66, -0xc(%rbp)
jge 0xb0a3
movslq -0xc(%rbp), %rcx
leaq 0x9ea61(%rip), %rax     # 0xa9ac0
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, 0xc(%rax)
je 0xb096
movl -0x8(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x8(%rbp)
cmpl $0x0, %eax
jne 0xb096
movslq -0xc(%rbp), %rcx
leaq 0x9ea39(%rip), %rax     # 0xa9ac0
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xb0aa
jmp 0xb098
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb04e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/mimeenc.c
// Function: charset_to_mimeenc
const char *charset_to_mimeenc(int charset)
{
    int i;

    for (i = 0; i < (int)lenof(mimeencs); i++)
	if (charset == mimeencs[i].charset)
	    return mimeencs[i].name;

    return NULL;		       /* not found */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0xd2, -0x10(%rbp)
jge 0xb109
movl -0xc(%rbp), %eax
movslq -0x10(%rbp), %rdx
leaq 0x9f04b(%rip), %rcx     # 0xaa120
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
jne 0xb0fc
movslq -0x10(%rbp), %rcx
leaq 0x9f034(%rip), %rax     # 0xaa120
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xb111
jmp 0xb0fe
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xb0be
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/mimeenc.c
// Function: charset_from_mimeenc
int charset_from_mimeenc(const char *name)
{
    int i;

    for (i = 0; i < (int)lenof(mimeencs); i++) {
	const char *p, *q;
	p = name;
	q = mimeencs[i].name;
	while (*p || *q) {
		if (tolower((unsigned char)*p) != tolower((unsigned char)*q))
		break;
	    p++; q++;
	}
	if (!*p && !*q)
	    return mimeencs[i].charset;
    }

    return CS_NONE;		       /* not found */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xd2, -0x14(%rbp)
jge 0xb207
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x9efcd(%rip), %rax     # 0xaa120
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
jne 0xb182
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xb18b
jmp 0xb1cb
movq -0x20(%rbp), %rax
movzbl (%rax), %edi
callq 0x6080
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movzbl (%rax), %edi
callq 0x6080
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
je 0xb1b1
jmp 0xb1cb
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xb161
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xb1f7
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xb1f7
movslq -0x14(%rbp), %rcx
leaq 0x9ef38(%rip), %rax     # 0xaa120
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xb20e
jmp 0xb1f9
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb133
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/sbcs.c
// Function: sbcs_from_unicode
long int sbcs_from_unicode(const struct sbcs_data *sd, long int input_chr)
{
    int i, j, k, c;

    /*
     * Binary-search in the ucs2sbcs table.
     */
    i = -1;
    j = sd->nvalid;
    while (i+1 < j) {
	k = (i+j)/2;
	c = sd->ucs2sbcs[k];
	if (input_chr < (long int)sd->sbcs2ucs[c])
	    j = k;
	else if (input_chr > (long int)sd->sbcs2ucs[c])
	    i = k;
	else {
	    return c;
	}
    }
    return ERROR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl 0x900(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
cmpl -0x20(%rbp), %eax
jge 0xb331
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzbl 0x800(%rax,%rcx), %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x28(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
jge 0xb309
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0xb32f
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x28(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
jle 0xb323
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xb32d
movslq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb339
jmp 0xb32f
jmp 0xb2c0
movq $0xffff, -0x8(%rbp)     # imm = 0xFFFF
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/sbcs.c
// Function: write_sbcs
int write_sbcs(charset_spec const *charset, long int input_chr,
	       charset_state *state,
	       void (*emit)(void *ctx, long int output), void *emitctx)
{
    const struct sbcs_data *sd = charset->data;
    long int ret;

    UNUSEDARG(state);

    if (input_chr == -1)
	return TRUE;		       /* stateless; no cleanup required */

    ret = sbcs_from_unicode(sd, input_chr);
    if (ret == ERROR)
	return FALSE;

    emit(emitctx, ret);
    return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0xb380
movl $0x1, -0x4(%rbp)
jmp 0xb3b9
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb2a0
movq %rax, -0x40(%rbp)
cmpq $0xffff, -0x40(%rbp)    # imm = 0xFFFF
jne 0xb3a4
movl $0x0, -0x4(%rbp)
jmp 0xb3b9
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq *%rax
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/shiftjis.c
// Function: write_sjis
static int write_sjis(charset_spec const *charset, long int input_chr,
		      charset_state *state,
		      void (*emit)(void *ctx, long int output), void *emitctx)
{
    UNUSEDARG(charset);
    UNUSEDARG(state);

    if (input_chr == -1)
	return TRUE;		       /* stateless; no cleanup required */

    if (input_chr < 0x80 && input_chr != 0x5C && input_chr != 0x7E) {
	emit(emitctx, input_chr);
	return TRUE;
    } else if (input_chr == 0xA5) {
	emit(emitctx, 0x5C);
	return TRUE;
    } else if (input_chr == 0x203E) {
	emit(emitctx, 0x7E);
	return TRUE;
    } else if (input_chr >= 0xFF61 && input_chr <= 0xFF9F) {
	emit(emitctx, input_chr - (0xFF61 - 0xA1));
	return TRUE;
    } else {
	int r, c;
	if (unicode_to_jisx0208(input_chr, &r, &c)) {
	    c += 94 * (r % 2);
	    r /= 2;
	    r += 0x81;
	    if (r >= 0xA0) r += 0xE0 - 0xA0;
	    c += 0x40;
	    if (c >= 0x7F) c++;
	    emit(emitctx, r);
	    emit(emitctx, c);
	    return TRUE;
	} else {
	    return FALSE;
	}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0xb5bf
movl $0x1, -0x4(%rbp)
jmp 0xb709
cmpq $0x80, -0x18(%rbp)
jge 0xb5f1
cmpq $0x5c, -0x18(%rbp)
je 0xb5f1
cmpq $0x7e, -0x18(%rbp)
je 0xb5f1
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movl $0x1, -0x4(%rbp)
jmp 0xb709
cmpq $0xa5, -0x18(%rbp)
jne 0xb616
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdi
movl $0x5c, %esi
callq *%rax
movl $0x1, -0x4(%rbp)
jmp 0xb709
cmpq $0x203e, -0x18(%rbp)    # imm = 0x203E
jne 0xb63b
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdi
movl $0x7e, %esi
callq *%rax
movl $0x1, -0x4(%rbp)
jmp 0xb709
cmpq $0xff61, -0x18(%rbp)    # imm = 0xFF61
jl 0xb670
cmpq $0xff9f, -0x18(%rbp)    # imm = 0xFF9F
jg 0xb670
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
subq $0xfec0, %rsi           # imm = 0xFEC0
callq *%rax
movl $0x1, -0x4(%rbp)
jmp 0xb709
movq -0x18(%rbp), %rdi
leaq -0x34(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0xa980
cmpl $0x0, %eax
je 0xb702
movl -0x34(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
imull $0x5e, %edx, %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addl $0x81, %eax
movl %eax, -0x34(%rbp)
cmpl $0xa0, -0x34(%rbp)
jl 0xb6c5
movl -0x34(%rbp), %eax
addl $0x40, %eax
movl %eax, -0x34(%rbp)
movl -0x38(%rbp), %eax
addl $0x40, %eax
movl %eax, -0x38(%rbp)
cmpl $0x7f, -0x38(%rbp)
jl 0xb6dd
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq *%rax
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdi
movslq -0x38(%rbp), %rsi
callq *%rax
movl $0x1, -0x4(%rbp)
jmp 0xb709
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)