LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/0x0203[P]schack_poc/main.c
// Function: shuffle_packet
static int shuffle_packet(char *packet, int packet_len, uint8_t **ret, int bph,
			  uint8_t *hop_list, int hops, int start_offset)
{
    int		    len;
    int		    pad;
    int		    i;
    int		    hop_index = 0;

    if (!ret || !packet || !hop_list || !bph || !hops)
	return 0;

    //len = strlen(packet);
    len = (bph * hops);
    len = len * ((packet_len + len - 1 - start_offset) / len);


    (*ret) = malloc(len);
    if (!*ret)
	return 0;

    memset(*ret, 0, len);

    for (i=0; i<len; i++)
    {
	hop_index = (i / bph) % hops;
	(*ret)[i] = (uint8_t)packet[i+start_offset] ^ (uint8_t)hop_list[hop_index];
    }
    return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movl $0x0, -0x44(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x36a39
cmpq $0x0, -0x10(%rbp)
je 0x36a39
cmpq $0x0, -0x30(%rbp)
je 0x36a39
cmpl $0x0, -0x24(%rbp)
je 0x36a39
cmpl $0x0, -0x34(%rbp)
jne 0x36a45
movl $0x0, -0x4(%rbp)
jmp 0x36b05
movl -0x24(%rbp), %eax
imull -0x34(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x14(%rbp), %eax
addl -0x38(%rbp), %eax
subl $0x1, %eax
subl 0x10(%rbp), %eax
cltd
idivl -0x38(%rbp)
movl %eax, %ecx
movl -0x48(%rbp), %eax
imull %ecx, %eax
movl %eax, -0x38(%rbp)
movslq -0x38(%rbp), %rdi
callq 0x3160
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x36a96
movl $0x0, -0x4(%rbp)
jmp 0x36b05
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movslq -0x38(%rbp), %rdx
xorl %esi, %esi
callq 0x3070
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x36aff
movl -0x40(%rbp), %eax
cltd
idivl -0x24(%rbp)
cltd
idivl -0x34(%rbp)
movl %edx, -0x44(%rbp)
movq -0x10(%rbp), %rax
movl -0x40(%rbp), %ecx
addl 0x10(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movq -0x30(%rbp), %rcx
movslq -0x44(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x40(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x36aaf
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/0x0203[P]schack_poc/main.c
// Function: pretty_print_raw
static int pretty_print_raw(uint8_t *data, char *save, int data_len, int save_offset)
{
    int i, count = 0;

    count += sprintf(&save[count+save_offset], "0x%4.4X   ", 0);
    for (i=0; i < data_len; i++)
    {
	count += sprintf(&save[count+save_offset], "%2.2X ", data[i]);
	if (((i+1) % 16) == 0)
	{
	    count += sprintf(&save[count+save_offset], "\n0x%4.4X   ", i+1);
	    continue;
	}
	if (((i+1) % 8) == 0)
	    count += sprintf(&save[count+save_offset], "  ");
	if (((i+1) % 4) == 0)
	    count += sprintf(&save[count+save_offset], "  ");
    }
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %eax
addl -0x18(%rbp), %eax
cltq
addq %rax, %rdi
leaq 0x14818(%rip), %rsi     # 0x4b35b
xorl %edx, %edx
movb $0x0, %al
callq 0x32a0
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x36c4e
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %eax
addl -0x18(%rbp), %eax
cltq
addq %rax, %rdi
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %edx
leaq 0x147cc(%rip), %rsi     # 0x4b353
movb $0x0, %al
callq 0x32a0
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl $0x10, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x36bd2
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %eax
addl -0x18(%rbp), %eax
cltq
addq %rax, %rdi
movl -0x1c(%rbp), %edx
addl $0x1, %edx
leaq 0x14797(%rip), %rsi     # 0x4b35a
movb $0x0, %al
callq 0x32a0
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x36c40
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl $0x8, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x36c08
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %eax
addl -0x18(%rbp), %eax
cltq
addq %rax, %rdi
leaq 0x1418f(%rip), %rsi     # 0x4ad8a
movb $0x0, %al
callq 0x32a0
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x36c3e
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %eax
addl -0x18(%rbp), %eax
cltq
addq %rax, %rdi
leaq 0x14159(%rip), %rsi     # 0x4ad8a
movb $0x0, %al
callq 0x32a0
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x36c40
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x36b59
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/0x0203[P]schack_poc/./ascii.c
// Function: ascii
static int
ascii(struct nk_context *ctx, int show)
{
    int has_focus;
    int len;

    if (show)
    {
	nk_window_show(ctx, WIN_ASCII_NAME, NK_SHOWN);
	nk_window_set_focus(ctx, WIN_ASCII_NAME);
    }
    else
	return 0;

    if (nk_begin(ctx, WIN_ASCII_NAME, nk_rect(10, 10, 710, 565),
        NK_WINDOW_BORDER|NK_WINDOW_TITLE|NK_WINDOW_CLOSABLE|NK_WINDOW_MINIMIZABLE|
	NK_WINDOW_NO_SCROLLBAR|NK_WINDOW_MOVABLE))
    {
	nk_layout_row_dynamic(ctx, 520, 1);
	nk_edit_string(ctx,
		      NK_EDIT_EDITOR|NK_EDIT_READ_ONLY,
		      (char *)ascii_table,
		      &len,
		      sizeof(ascii_table),
		      nk_filter_ascii);
    }
    nk_end(ctx);

    if (nk_window_is_hidden(ctx, WIN_ASCII_NAME) || nk_window_is_closed(ctx, WIN_ASCII_NAME))
	return 0;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x37a7c
movq -0x10(%rbp), %rdi
leaq 0x13a8c(%rip), %rsi     # 0x4b4ec
movl $0x1, %edx
callq 0x16930
movq -0x10(%rbp), %rdi
leaq 0x13a77(%rip), %rsi     # 0x4b4ec
callq 0x16a50
jmp 0x37a88
movl $0x0, -0x4(%rbp)
jmp 0x37b5d
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movss 0xa5a4(%rip), %xmm1     # 0x4203c
movss 0xa600(%rip), %xmm2     # 0x420a0
movss 0xa5fc(%rip), %xmm3     # 0x420a4
movaps %xmm1, %xmm0
callq 0x36c0
movq -0x38(%rbp), %rdi
movlpd %xmm0, -0x2c(%rbp)
movlpd %xmm1, -0x24(%rbp)
movsd -0x2c(%rbp), %xmm0
movsd -0x24(%rbp), %xmm1
leaq 0x13a1d(%rip), %rsi     # 0x4b4ec
movl $0x7b, %edx
callq 0x12320
cmpl $0x0, %eax
je 0x37b1a
movq -0x10(%rbp), %rdi
movss 0xa5be(%rip), %xmm0     # 0x420a8
movl $0x1, %esi
callq 0x1aba0
movq -0x10(%rbp), %rdi
movl $0x469, %esi            # imm = 0x469
leaq 0xa7ec(%rip), %rdx      # 0x422f0
leaq -0x1c(%rbp), %rcx
movl $0xe84, %r8d            # imm = 0xE84
leaq -0x10bc5(%rip), %r9     # 0x26f50
callq 0x27240
movq -0x10(%rbp), %rdi
callq 0x142e0
movq -0x10(%rbp), %rdi
leaq 0x139be(%rip), %rsi     # 0x4b4ec
callq 0x16400
cmpl $0x0, %eax
jne 0x37b4d
movq -0x10(%rbp), %rdi
leaq 0x139a9(%rip), %rsi     # 0x4b4ec
callq 0x16350
cmpl $0x0, %eax
je 0x37b56
movl $0x0, -0x4(%rbp)
jmp 0x37b5d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/0x0203[P]schack_poc/main.c
// Function: sleep_for
static void
sleep_for(long t)
{
    struct timespec req;
    const time_t sec = (int)(t/1000);
    const long ms = t - (sec * 1000);
    req.tv_sec = sec;
    req.tv_nsec = ms * 1000000L;
    while(-1 == nanosleep(&req, &req));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
cltq
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
imulq $0x3e8, -0x20(%rbp), %rcx # imm = 0x3E8
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
imulq $0xf4240, -0x28(%rbp), %rax # imm = 0xF4240
movq %rax, -0x10(%rbp)
leaq -0x18(%rbp), %rsi
movq %rsi, %rdi
callq 0x3410
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x37bd0
jmp 0x37bb7
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kyz[P]amostools/./amoslib.c
// Function: print_binary
static void print_binary(FILE *out, uint32_t value) {
    char buf[33], *p = &buf[33];
    *--p = '\0';
    do {*--p = value & 1 ? '1' : '0'; value >>= 1; } while (value);
    fprintf(out, "%%%s", p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x30(%rbp), %rax
addq $0x21, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x38(%rbp)
movb $0x0, -0x1(%rax)
movl -0xc(%rbp), %edx
andl $0x1, %edx
movl $0x30, %eax
movl $0x31, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, %cl
movq -0x38(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x38(%rbp)
movb %cl, -0x1(%rax)
movl -0xc(%rbp), %eax
shrl %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x1e1e
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq 0x250e(%rip), %rsi      # 0x4373
movb $0x0, %al
callq 0x1150
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kyz[P]amostools/./amoslib.c
// Function: print_string
static int print_string(FILE *out, uint8_t *s, char quote) {
    int len = amos_deek(s);
    char fmt[20];
    snprintf(fmt, sizeof(fmt), "%c%%%d.%ds%c", quote, len, len, quote);
    fprintf(out, fmt, &s[2]);
    return len + 2 + (len & 1 ? 1 : 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
shll $0x8, %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
movsbl -0x11(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl -0x18(%rbp), %r9d
movsbl -0x11(%rbp), %eax
movl $0x14, %esi
leaq 0x24ac(%rip), %rdx      # 0x4378
movl %eax, (%rsp)
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x2, %rdx
movb $0x0, %al
callq 0x1150
movl -0x18(%rbp), %eax
addl $0x2, %eax
movl -0x18(%rbp), %esi
andl $0x1, %esi
xorl %ecx, %ecx
movl $0x1, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
addl %ecx, %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kyz[P]amostools/./amoslib.c
// Function: print_float
static void print_float(FILE *out, uint32_t value) {
    int e = value & 0x7F;
    float f = e ? (value >> 8) * exp2f(e - 88) : 0;
    char buf[20];
    /* print in %G format, adding '.0' if not present */
    snprintf(buf, sizeof(buf), "%G", f);
    fprintf(out, "%s", buf);
    for (char *p = &buf[0]; *p; p++) if (*p == '.' || *p == 'E') return;
    fprintf(out, ".0");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0x7f, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x1f5f
movl -0xc(%rbp), %eax
shrl $0x8, %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x40(%rbp)
movl -0x10(%rbp), %eax
subl $0x58, %eax
cvtsi2ss %eax, %xmm0
callq 0x10c0
movaps %xmm0, %xmm1
movss -0x40(%rbp), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, -0x3c(%rbp)
jmp 0x1f69
xorps %xmm0, %xmm0
movss %xmm0, -0x3c(%rbp)
jmp 0x1f69
movss -0x3c(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
leaq -0x30(%rbp), %rdi
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movl $0x14, %esi
leaq 0x23f9(%rip), %rdx      # 0x4385
movb $0x1, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rdx
leaq 0x23d3(%rip), %rsi      # 0x4375
movb $0x0, %al
callq 0x1150
leaq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpb $0x0, (%rax)
je 0x1fe4
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
je 0x1fd2
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x45, %eax
jne 0x1fd4
jmp 0x1ff6
jmp 0x1fd6
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x1fb1
movq -0x8(%rbp), %rdi
leaq 0x2399(%rip), %rsi      # 0x4388
movb $0x0, %al
callq 0x1150
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kyz[P]amostools/./amoslib.c
// Function: print_double
static void print_double(FILE *out, uint32_t vh, uint32_t vl) {
    int e = (vh >> 20) & 0x7FF;
    double dl = e ? vl * exp2(e - 1075) : 0;
    double dh = e ? ((vh & 0xFFFFF) | 0x100000) * exp2(e - 1043) : 0;
    char buf[30];
    /* print in %.15g format, adding '.0 if not included */
    snprintf(buf, sizeof(buf), "%.15g", dl + dh);
    fprintf(out, "%s", buf);
    for (char *p = &buf[0]; *p; p++) if (*p == '.') return;
    fprintf(out, ".0");

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
shrl $0x14, %eax
andl $0x7ff, %eax            # imm = 0x7FF
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x205a
movl -0x10(%rbp), %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x68(%rbp)
movl -0x14(%rbp), %eax
subl $0x433, %eax            # imm = 0x433
cvtsi2sd %eax, %xmm0
callq 0x1030
movaps %xmm0, %xmm1
movsd -0x68(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x60(%rbp)
jmp 0x2064
xorps %xmm0, %xmm0
movsd %xmm0, -0x60(%rbp)
jmp 0x2064
movsd -0x60(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x20ae
movl -0xc(%rbp), %eax
andl $0xfffff, %eax          # imm = 0xFFFFF
orl $0x100000, %eax         # imm = 0x100000
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x78(%rbp)
movl -0x14(%rbp), %eax
subl $0x413, %eax            # imm = 0x413
cvtsi2sd %eax, %xmm0
callq 0x1030
movaps %xmm0, %xmm1
movsd -0x78(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x70(%rbp)
jmp 0x20b8
xorps %xmm0, %xmm0
movsd %xmm0, -0x70(%rbp)
jmp 0x20b8
movsd -0x70(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
leaq -0x50(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movl $0x1e, %esi
leaq 0x22af(%rip), %rdx      # 0x438b
movb $0x1, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rdx
leaq 0x2283(%rip), %rsi      # 0x4375
movb $0x0, %al
callq 0x1150
leaq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2128
movq -0x58(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x2118
jmp 0x213a
jmp 0x211a
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x2101
movq -0x8(%rbp), %rdi
leaq 0x2255(%rip), %rsi      # 0x4388
movb $0x0, %al
callq 0x1150
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kyz[P]amostools/./amoslib.c
// Function: AMOS_free_tokens
void AMOS_free_tokens(struct AMOS_token *table[AMOS_TOKEN_TABLE_SIZE]) {
    int i;
    for (i = 0; i < AMOS_TOKEN_TABLE_SIZE; i++) {
        struct AMOS_token *e, *next;
        for (e = table[i]; e; e = next) {
            next = e->next;
            free(e);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x2069, -0xc(%rbp)     # imm = 0x2069
jge 0x2ede
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2ed1
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1040
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x2eac
jmp 0x2ed3
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2e93
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kyz[P]amostools/listamos.c
// Function: read_extension_file
void read_extension_file(char *filename, int slot) {
    uint8_t *buf;
    size_t len;

    if ((buf = read_file(filename, &len))) {
        if (slot == -1) {
            slot = AMOS_find_slot(buf, len);
        }
        if (slot == -1) {
            fprintf(stderr, "%s: can't determine extension slot"
                            " (use -eNN=filename to set slot NN)\n", filename);
        }
        else if (extensions_loaded[slot]) {
            fprintf(stderr, "%s: extension already loaded in slot %d\n", filename, slot);
        }
        else if (AMOS_parse_extension(buf, len, slot, 6, table)) {
            fprintf(stderr, "%s: not an AMOS extension\n", filename);
        }
        else {
            fprintf(stderr, "%s: loaded into slot %d\n", filename, slot);
            extensions_loaded[slot] = 1;
        }
        free(buf);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x12d0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x3003
cmpl $-0x1, -0xc(%rbp)
jne 0x2f30
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2bd0
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x2f57
movq 0x30bb(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x112b(%rip), %rsi      # 0x4076
movb $0x0, %al
callq 0x1150
jmp 0x2ffa
movslq -0xc(%rbp), %rcx
leaq 0x16ade(%rip), %rax     # 0x19a40
cmpb $0x0, (%rax,%rcx)
je 0x2f89
movq 0x3089(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %ecx
leaq 0x113d(%rip), %rsi      # 0x40bd
movb $0x0, %al
callq 0x1150
jmp 0x2ff8
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0xc(%rbp), %edx
movl $0x6, %ecx
leaq 0x6750(%rip), %r8       # 0x96f0
callq 0x2720
cmpl $0x0, %eax
je 0x2fc8
movq 0x3047(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x1127(%rip), %rsi      # 0x40e6
movb $0x0, %al
callq 0x1150
jmp 0x2ff6
movq 0x3029(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %ecx
leaq 0x1121(%rip), %rsi      # 0x4101
movb $0x0, %al
callq 0x1150
movslq -0xc(%rbp), %rcx
leaq 0x16a4e(%rip), %rax     # 0x19a40
movb $0x1, (%rax,%rcx)
jmp 0x2ff8
jmp 0x2ffa
movq -0x18(%rbp), %rdi
callq 0x1040
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kyz[P]amostools/listamos.c
// Function: read_extensions
int read_extensions(int argc, char *argv[]) {
    int i, slot;

    /* look for -e options */
    for (i = 1; i < argc; i++) {
        if (*argv[i] != '-') break; /* end of arg processing */
        if (!strcmp(argv[i], "-e")) {
            read_extension_file(argv[++i], -1);
        }
        else if (sscanf(argv[i], "-e%d=", &slot) == 2) {
            if (slot < 1 || slot > 25) {
                fprintf(stderr, "invalid extension slot %d (must be 1-25)\n", slot);
            }
            else {
                read_extension_file(strchr(argv[i], '=') + 1, slot);
            }
        }
        else if (argv[i][1] == 'c' || argv[i][1] == 'd') {
            i++; /* skip arg */
        }
    }
    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x3145
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x304b
jmp 0x3145
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x10bc(%rip), %rsi      # 0x411a
callq 0x1140
cmpl $0x0, %eax
jne 0x308b
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2ef0
jmp 0x3135
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x107f(%rip), %rsi      # 0x411d
leaq -0x18(%rbp), %rdx
movb $0x0, %al
callq 0x1190
cmpl $0x2, %eax
jne 0x30fe
cmpl $0x1, -0x18(%rbp)
jl 0x30ba
cmpl $0x19, -0x18(%rbp)
jle 0x30d7
movq 0x2f37(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
movl -0x18(%rbp), %edx
leaq 0x1055(%rip), %rsi      # 0x4123
movb $0x0, %al
callq 0x1150
jmp 0x30fc
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x3d, %esi
callq 0x10e0
movq %rax, %rdi
addq $0x1, %rdi
movl -0x18(%rbp), %esi
callq 0x2ef0
jmp 0x3133
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl 0x1(%rax), %eax
cmpl $0x63, %eax
je 0x3128
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl 0x1(%rax), %eax
cmpl $0x64, %eax
jne 0x3131
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3133
jmp 0x3135
jmp 0x3137
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3026
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kyz[P]amostools/listamos.c
// Function: read_default_extensions
void read_default_extensions() {
    AMOS_parse_extension(ext00_base, sizeof(ext00_base), 0, -194, table);
    if (!extensions_loaded[1]) {
        AMOS_parse_extension(ext01_music, sizeof(ext01_music), 1, 6, table);
    }
    if (!extensions_loaded[2]) {
        AMOS_parse_extension(ext02_compact, sizeof(ext02_compact), 2, 6, table);
    }
    if (!extensions_loaded[3]) {
        AMOS_parse_extension(ext03_request, sizeof(ext03_request), 3, 6, table);
    }
    if (!extensions_loaded[6]) {
        AMOS_parse_extension(ext06_ioports, sizeof(ext06_ioports), 6, 6, table);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2b35(%rip), %rdi      # 0x6150
movl $0x2cfe, %esi           # imm = 0x2CFE
xorl %edx, %edx
movl $0xffffff3e, %ecx       # imm = 0xFFFFFF3E
leaq 0x60c2(%rip), %r8       # 0x96f0
callq 0x2720
cmpb $0x0, 0x16407(%rip)     # 0x19a41
jne 0x365e
leaq 0x580d(%rip), %rdi      # 0x8e50
movl $0x3ce, %esi            # imm = 0x3CE
movl $0x1, %edx
movl $0x6, %ecx
leaq 0x6097(%rip), %r8       # 0x96f0
callq 0x2720
cmpb $0x0, 0x163dd(%rip)     # 0x19a42
jne 0x3689
leaq 0x5bb2(%rip), %rdi      # 0x9220
movl $0xa4, %esi
movl $0x2, %edx
movl $0x6, %ecx
leaq 0x606c(%rip), %r8       # 0x96f0
callq 0x2720
cmpb $0x0, 0x163b3(%rip)     # 0x19a43
jne 0x36b4
leaq 0x5c37(%rip), %rdi      # 0x92d0
movl $0x70, %esi
movl $0x3, %edx
movl $0x6, %ecx
leaq 0x6041(%rip), %r8       # 0x96f0
callq 0x2720
cmpb $0x0, 0x1638b(%rip)     # 0x19a46
jne 0x36dc
leaq 0x5c7c(%rip), %rdi      # 0x9340
movl $0x394, %esi            # imm = 0x394
movl $0x6, %ecx
leaq 0x601b(%rip), %r8       # 0x96f0
movl %ecx, %edx
callq 0x2720
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kyx0r[P]xkeyboard/xkeyboard.c
// Function: handle_error
static int handle_error(Display *d, XErrorEvent *event)
{
	char errortext[96];
	XGetErrorText(dpy, event->error_code, errortext, 96);

	fprintf(stderr, "xkeyboard: %s (%d/%d)\n", errortext,
		event->request_code, event->minor_code);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x16e41(%rip), %rdi     # 0x197f8
movq -0x10(%rbp), %rax
movzbl 0x20(%rax), %esi
leaq -0x70(%rbp), %rdx
movl $0x60, %ecx
callq 0x2230
movq 0x6624(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
leaq -0x70(%rbp), %rdx
movq -0x10(%rbp), %rax
movzbl 0x21(%rax), %ecx
movq -0x10(%rbp), %rax
movzbl 0x22(%rax), %r8d
leaq 0x489d(%rip), %rsi      # 0x7290
movb $0x0, %al
callq 0x21a0
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kyx0r[P]xkeyboard/xkeyboard.c
// Function: create_pixmaps
void create_pixmaps(void)
{
	static int initialized = 0;
	int i;

	if (initialized) {
		for (i = 0; i < NUM_KEYCAPS; i++) {
			XFreePixmap(dpy, mykc[i]);
		}
	}
	else
	{
		for (i = 0; i < NUM_CONSTPGM; i++) {
			if(cpgmlist[i].pgm)
			{
				cpgm[i] = scale_pic(
						&cpgmlist[i], 
						cpgmlist[i].w,
						cpgmlist[i].h, 
						i);
			}
		}
	}
	for (i = 0; i < NUM_KEYCAPS; i++) {
		if(mykclist[i].pgm)
		{
			mykc[i] = scale_pic(
					&mykclist[i], 
					mykclist[i].w,
					mykclist[i].h, 
					i);
		}
	}
	initialized = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x16c39(%rip)     # 0x19a38
je 0x2e3d
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq $0xd, %rax
jae 0x2e38
movq 0x169df(%rip), %rdi     # 0x197f8
movslq -0x4(%rbp), %rcx
leaq 0x16c1c(%rip), %rax     # 0x19a40
movq (%rax,%rcx,8), %rsi
callq 0x2120
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2e08
jmp 0x2ece
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq $0xf, %rax
jae 0x2ecc
movslq -0x4(%rbp), %rcx
leaq 0x16897(%rip), %rax     # 0x196f0
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x2ebc
movslq -0x4(%rbp), %rax
leaq 0x1687e(%rip), %rdi     # 0x196f0
shlq $0x4, %rax
addq %rax, %rdi
movslq -0x4(%rbp), %rcx
leaq 0x1686c(%rip), %rax     # 0x196f0
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %esi
movslq -0x4(%rbp), %rcx
leaq 0x16858(%rip), %rax     # 0x196f0
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %edx
movl -0x4(%rbp), %ecx
callq 0x2a10
movq %rax, %rdx
movslq -0x4(%rbp), %rcx
leaq 0x16bf8(%rip), %rax     # 0x19ab0
movq %rdx, (%rax,%rcx,8)
jmp 0x2ebe
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2e44
jmp 0x2ece
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq $0xd, %rax
jae 0x2f5d
movslq -0x4(%rbp), %rcx
leaq 0x16736(%rip), %rax     # 0x19620
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x2f4d
movslq -0x4(%rbp), %rax
leaq 0x1671d(%rip), %rdi     # 0x19620
shlq $0x4, %rax
addq %rax, %rdi
movslq -0x4(%rbp), %rcx
leaq 0x1670b(%rip), %rax     # 0x19620
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %esi
movslq -0x4(%rbp), %rcx
leaq 0x166f7(%rip), %rax     # 0x19620
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %edx
movl -0x4(%rbp), %ecx
callq 0x2a10
movq %rax, %rdx
movslq -0x4(%rbp), %rcx
leaq 0x16af7(%rip), %rax     # 0x19a40
movq %rdx, (%rax,%rcx,8)
jmp 0x2f4f
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2ed5
movl $0x1, 0x16ad1(%rip)     # 0x19a38
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kyx0r[P]xkeyboard/xkeyboard.c
// Function: move_constkeys
void move_constkeys()
{
	XMoveWindow(dpy, zoomwin, myhint.width - 45, 16);
	XMoveWindow(dpy, modewin, myhint.width - 85, 16);
	XMoveWindow(dpy, movewin, myhint.width - 125, 16);
	XMoveWindow(dpy, mousewin, myhint.width - 165, 16);
	XMoveWindow(dpy, lbcornerwin, myhint.width - 16, myhint.height - 16);
	XMoveWindow(dpy, closewindow, 0, myhint.height - closewindow_uppgm.height);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x1687d(%rip), %rdi     # 0x197f8
movq 0x16ba6(%rip), %rsi     # 0x19b28
movl 0x168b0(%rip), %edx     # 0x19838
subl $0x2d, %edx
movl $0x10, %ecx
callq 0x2100
movq 0x1685c(%rip), %rdi     # 0x197f8
movq 0x16b8d(%rip), %rsi     # 0x19b30
movl 0x1688f(%rip), %edx     # 0x19838
subl $0x55, %edx
movl $0x10, %ecx
callq 0x2100
movq 0x1683b(%rip), %rdi     # 0x197f8
movq 0x16b74(%rip), %rsi     # 0x19b38
movl 0x1686e(%rip), %edx     # 0x19838
subl $0x7d, %edx
movl $0x10, %ecx
callq 0x2100
movq 0x1681a(%rip), %rdi     # 0x197f8
movq 0x16b5b(%rip), %rsi     # 0x19b40
movl 0x1684d(%rip), %edx     # 0x19838
subl $0xa5, %edx
movl $0x10, %ecx
callq 0x2100
movq 0x167f6(%rip), %rdi     # 0x197f8
movq 0x16b3f(%rip), %rsi     # 0x19b48
movl 0x16829(%rip), %edx     # 0x19838
subl $0x10, %edx
movl 0x16824(%rip), %ecx     # 0x1983c
subl $0x10, %ecx
callq 0x2100
movq 0x167d1(%rip), %rdi     # 0x197f8
movq 0x16b22(%rip), %rsi     # 0x19b50
movl 0x16808(%rip), %ecx     # 0x1983c
subl 0x1313a(%rip), %ecx     # 0x16174
xorl %edx, %edx
callq 0x2100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kyx0r[P]xkeyboard/xkeyboard.c
// Function: show
void show()
{
	if(myhint.y + myhint.height > screenheight)
	{
		myhint.y -= myhint.height-closewindow_uppgm.height;
	}
	XMoveResizeWindow(dpy, mywindow, myhint.x, myhint.y, myhint.width, myhint.height);
	move_constkeys();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x1478a(%rip), %eax     # 0x19834
addl 0x1478c(%rip), %eax     # 0x1983c
cmpl 0x14752(%rip), %eax     # 0x19808
jle 0x50d2
movl 0x1477e(%rip), %ecx     # 0x1983c
subl 0x110b0(%rip), %ecx     # 0x16174
movl 0x1476a(%rip), %eax     # 0x19834
subl %ecx, %eax
movl %eax, 0x14762(%rip)     # 0x19834
movq 0x1471f(%rip), %rdi     # 0x197f8
movq 0x14890(%rip), %rsi     # 0x19970
movl 0x1474a(%rip), %edx     # 0x19830
movl 0x14748(%rip), %ecx     # 0x19834
movl 0x14745(%rip), %r8d     # 0x19838
movl 0x14742(%rip), %r9d     # 0x1983c
callq 0x2110
callq 0x2f70
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kyx0r[P]xkeyboard/xkeyboard.c
// Function: resize_win
void resize_win()
{
	int x, y, nx, ny = 0; 
	XEvent ev;
	Time lasttime = 0;

	if (XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
		None, None, CurrentTime) != GrabSuccess)
	if (!getrootptr(&x, &y))
		return;
	do {
		XMaskEvent(dpy, MOUSEMASK|ExposureMask|SubstructureRedirectMask, &ev);
		switch(ev.type) {
		case ConfigureRequest:
		case Expose:
		case MapRequest:
			break;
		case MotionNotify:
			if ((ev.xmotion.time - lasttime) <= (1000 / 60))
				continue;
			lasttime = ev.xmotion.time;
			nx = ev.xmotion.x;
			ny = ev.xmotion.y;
			myhint.width = nx - myhint.x;
			myhint.height = ny - myhint.y;
			XMoveResizeWindow(dpy, mywindow, myhint.x, myhint.y, myhint.width, myhint.height);
			move_constkeys();
			break;
		}
	} while (ev.type != ButtonRelease);
	do_control(); //redraw the fonts
	XUngrabPointer(dpy, CurrentTime);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movl $0x0, -0x10(%rbp)
movq $0x0, -0xd8(%rbp)
movq 0x144a4(%rip), %rdi     # 0x197f8
movq 0x144b5(%rip), %rsi     # 0x19810
xorl %edx, %edx
movl $0x4c, %ecx
movl $0x1, %r9d
xorl %eax, %eax
movl %r9d, %r8d
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0x2160
cmpl $0x0, %eax
je 0x53aa
leaq -0x4(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x5110
cmpl $0x0, %eax
jne 0x53a8
jmp 0x54a5
jmp 0x53aa
jmp 0x53ac
movq 0x14445(%rip), %rdi     # 0x197f8
movl $0x10804c, %esi         # imm = 0x10804C
leaq -0xd0(%rbp), %rdx
callq 0x23d0
movl -0xd0(%rbp), %eax
addl $-0x6, %eax
movl %eax, %ecx
movq %rcx, -0xe0(%rbp)
subl $0x11, %eax
ja 0x5481
movq -0xe0(%rbp), %rax
leaq 0x1c5f(%rip), %rcx      # 0x704c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x5481
movq -0x98(%rbp), %rax
subq -0xd8(%rbp), %rax
cmpq $0x10, %rax
ja 0x5411
jmp 0x5483
movq -0x98(%rbp), %rax
movq %rax, -0xd8(%rbp)
movl -0x90(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x8c(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
subl 0x143f6(%rip), %eax     # 0x19830
movl %eax, 0x143f8(%rip)     # 0x19838
movl -0x10(%rbp), %eax
subl 0x143eb(%rip), %eax     # 0x19834
movl %eax, 0x143ed(%rip)     # 0x1983c
movq 0x143a2(%rip), %rdi     # 0x197f8
movq 0x14513(%rip), %rsi     # 0x19970
movl 0x143cd(%rip), %edx     # 0x19830
movl 0x143cb(%rip), %ecx     # 0x19834
movl 0x143c8(%rip), %r8d     # 0x19838
movl 0x143c5(%rip), %r9d     # 0x1983c
callq 0x2110
callq 0x2f70
jmp 0x5483
cmpl $0x5, -0xd0(%rbp)
jne 0x53ac
callq 0x41b0
movq 0x1435c(%rip), %rdi     # 0x197f8
xorl %eax, %eax
movl %eax, %esi
callq 0x21e0
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kyx0r[P]xkeyboard/xkeyboard.c
// Function: reset_keyspos
void reset_keyspos()
{
	int i;
	for (i = 0; i < MAX_KEYS; i++) {
		xk[i].x -= xkeyoffs; 
		xk[i].y -= ykeyoffs;
	}
	for (i = 0; i < NUM_BORDERS; i++) {
		mb[i].x	-= xkeyoffs;
		mb[i].y -= ykeyoffs;	
	}
	xkeyoffs = 0;
	ykeyoffs = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
cmpl $0x69, -0x4(%rbp)
jge 0x550c
movl 0x18d89(%rip), %edx     # 0x1e250
movslq -0x4(%rbp), %rcx
leaq 0x3e6e(%rip), %rax      # 0x9340
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x4(%rax)
movl 0x18d6d(%rip), %edx     # 0x1e254
movslq -0x4(%rbp), %rcx
leaq 0x3e4e(%rip), %rax      # 0x9340
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x8(%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x54bb
movl $0x0, -0x4(%rbp)
cmpl $0x13, -0x4(%rbp)
jge 0x5562
movl 0x18d31(%rip), %edx     # 0x1e250
movslq -0x4(%rbp), %rcx
leaq 0x3ce6(%rip), %rax      # 0x9210
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movl 0x18d17(%rip), %edx     # 0x1e254
movslq -0x4(%rbp), %rcx
leaq 0x3cc8(%rip), %rax      # 0x9210
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x4(%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x5513
movl $0x0, 0x18ce4(%rip)     # 0x1e250
movl $0x0, 0x18cde(%rip)     # 0x1e254
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kyx0r[P]xkeyboard/xkeyboard.c
// Function: wait_btn_press
void wait_btn_press()
{
	XEvent ev;
	if (XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
		None, None, CurrentTime) != GrabSuccess)
		return;
	do {
		XMaskEvent(dpy, MOUSEMASK|ExposureMask|SubstructureRedirectMask, &ev);
	} while (ev.type != ButtonPress);
	XUngrabPointer(dpy, CurrentTime);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq 0x13f16(%rip), %rdi     # 0x197f8
movq 0x13f27(%rip), %rsi     # 0x19810
xorl %edx, %edx
movl $0x4c, %ecx
movl $0x1, %r9d
xorl %eax, %eax
movl %r9d, %r8d
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0x2160
cmpl $0x0, %eax
je 0x5921
jmp 0x5954
jmp 0x5923
movq 0x13ece(%rip), %rdi     # 0x197f8
movl $0x10804c, %esi         # imm = 0x10804C
leaq -0xc0(%rbp), %rdx
callq 0x23d0
cmpl $0x4, -0xc0(%rbp)
jne 0x5923
movq 0x13ead(%rip), %rdi     # 0x197f8
xorl %eax, %eax
movl %eax, %esi
callq 0x21e0
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kyx0r[P]xkeyboard/xkeyboard.c
// Function: wait_btn_release
void wait_btn_release()
{
	XEvent ev;
	if (XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
		None, None, CurrentTime) != GrabSuccess)
		return;
	do {
		XMaskEvent(dpy, MOUSEMASK|ExposureMask|SubstructureRedirectMask, &ev);
	} while (ev.type != ButtonRelease);
	XUngrabPointer(dpy, CurrentTime);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq 0x13e86(%rip), %rdi     # 0x197f8
movq 0x13e97(%rip), %rsi     # 0x19810
xorl %edx, %edx
movl $0x4c, %ecx
movl $0x1, %r9d
xorl %eax, %eax
movl %r9d, %r8d
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0x2160
cmpl $0x0, %eax
je 0x59b1
jmp 0x59e4
jmp 0x59b3
movq 0x13e3e(%rip), %rdi     # 0x197f8
movl $0x10804c, %esi         # imm = 0x10804C
leaq -0xc0(%rbp), %rdx
callq 0x23d0
cmpl $0x5, -0xc0(%rbp)
jne 0x59b3
movq 0x13e1d(%rip), %rdi     # 0x197f8
xorl %eax, %eax
movl %eax, %esi
callq 0x21e0
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kyx0r[P]xkeyboard/xkeyboard.c
// Function: doubleclick
int doubleclick(unsigned int ms)
{
	static Time laststamp = 0;
	Time stamp = myevent.xbutton.time;
	if(stamp - laststamp < ms)
	{
		return 1;
	} 
	laststamp = stamp;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq 0x187aa(%rip), %rax     # 0x1e1a8
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
subq 0x1884b(%rip), %rax     # 0x1e258
movl -0x8(%rbp), %ecx
cmpq %rcx, %rax
jae 0x5a1e
movl $0x1, -0x4(%rbp)
jmp 0x5a30
movq -0x10(%rbp), %rax
movq %rax, 0x1882f(%rip)     # 0x1e258
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kyx0r[P]xkeyboard/xkeyboard.c
// Function: btn_press
void btn_press(Display *display, int button)
{
	// Create and setting up the event
	XEvent event;
	memset (&event, 0, sizeof (event));
	event.xbutton.button = button;
	event.xbutton.same_screen = True;
	event.xbutton.subwindow = DefaultRootWindow (display);
	while (event.xbutton.subwindow)
	{
		event.xbutton.window = event.xbutton.subwindow;
		XQueryPointer (display, event.xbutton.window,
				&event.xbutton.root, &event.xbutton.subwindow,
				&event.xbutton.x_root, &event.xbutton.y_root,
				&event.xbutton.x, &event.xbutton.y,
				&event.xbutton.state);
	}
	// Press
	if(event.xbutton.window != mousewin)
	{
		if(sendkey)
		{
			event.type = ButtonPress;
			if (XSendEvent (display, PointerWindow, True, ButtonPressMask, &event) == 0)
				fprintf (stderr, "Error to send the event!\n");
			XFlush (display);
		} else {
			XTestFakeButtonEvent(dpy, button, True, CurrentTime);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0xd0(%rbp), %rdi
xorl %esi, %esi
movl $0xc0, %edx
callq 0x2140
movl -0xc(%rbp), %eax
movl %eax, -0x7c(%rbp)
movl $0x1, -0x78(%rbp)
movq -0x8(%rbp), %rax
movq 0xe8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0xe0(%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0xa0(%rbp)
cmpq $0x0, -0xa0(%rbp)
je 0x5b22
movq -0xa0(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
leaq -0xd0(%rbp), %rdx
addq $0x28, %rdx
leaq -0xd0(%rbp), %rcx
addq $0x30, %rcx
leaq -0xd0(%rbp), %r8
addq $0x48, %r8
leaq -0xd0(%rbp), %r9
addq $0x4c, %r9
leaq -0xd0(%rbp), %r11
addq $0x40, %r11
leaq -0xd0(%rbp), %r10
addq $0x44, %r10
leaq -0xd0(%rbp), %rax
addq $0x50, %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x21c0
jmp 0x5a9a
movq -0xb0(%rbp), %rax
cmpq 0x14010(%rip), %rax     # 0x19b40
je 0x5ba5
cmpl $0x0, 0x18713(%rip)     # 0x1e24c
je 0x5b8b
movl $0x4, -0xd0(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
movl $0x4, %ecx
leaq -0xd0(%rbp), %r8
callq 0x2030
cmpl $0x0, %eax
jne 0x5b80
movq 0x3489(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
leaq 0x16ee(%rip), %rsi      # 0x7267
movb $0x0, %al
callq 0x21a0
movq -0x8(%rbp), %rdi
callq 0x2300
jmp 0x5ba3
movq 0x13c66(%rip), %rdi     # 0x197f8
movl -0xc(%rbp), %esi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x2170
jmp 0x5ba5
addq $0xf0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kyx0r[P]xkeyboard/xkeyboard.c
// Function: btn_release
void btn_release(Display *display, int button)
{
	// Create and setting up the event
	XEvent event;
	memset (&event, 0, sizeof (event));
	event.xbutton.button = button;
	event.xbutton.same_screen = True;
	event.xbutton.subwindow = DefaultRootWindow (display);
	while (event.xbutton.subwindow)
	{
		event.xbutton.window = event.xbutton.subwindow;
		XQueryPointer (display, event.xbutton.window,
				&event.xbutton.root, &event.xbutton.subwindow,
				&event.xbutton.x_root, &event.xbutton.y_root,
				&event.xbutton.x, &event.xbutton.y,
				&event.xbutton.state);
	}
	if(event.xbutton.window != mousewin)
	{
		if(sendkey)
		{
			event.type = ButtonRelease;
			if (XSendEvent (display, PointerWindow, True, ButtonReleaseMask, &event) == 0)
				fprintf (stderr, "Error to send the event!\n");
			XFlush (display);
		} else {
			XTestFakeButtonEvent(dpy, button, False, CurrentTime);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0xd0(%rbp), %rdi
xorl %esi, %esi
movl $0xc0, %edx
callq 0x2140
movl -0xc(%rbp), %eax
movl %eax, -0x7c(%rbp)
movl $0x1, -0x78(%rbp)
movq -0x8(%rbp), %rax
movq 0xe8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0xe0(%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0xa0(%rbp)
cmpq $0x0, -0xa0(%rbp)
je 0x5c92
movq -0xa0(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
leaq -0xd0(%rbp), %rdx
addq $0x28, %rdx
leaq -0xd0(%rbp), %rcx
addq $0x30, %rcx
leaq -0xd0(%rbp), %r8
addq $0x48, %r8
leaq -0xd0(%rbp), %r9
addq $0x4c, %r9
leaq -0xd0(%rbp), %r11
addq $0x40, %r11
leaq -0xd0(%rbp), %r10
addq $0x44, %r10
leaq -0xd0(%rbp), %rax
addq $0x50, %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x21c0
jmp 0x5c0a
movq -0xb0(%rbp), %rax
cmpq 0x13ea0(%rip), %rax     # 0x19b40
je 0x5d12
cmpl $0x0, 0x185a3(%rip)     # 0x1e24c
je 0x5cfb
movl $0x5, -0xd0(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
movl $0x8, %ecx
leaq -0xd0(%rbp), %r8
callq 0x2030
cmpl $0x0, %eax
jne 0x5cf0
movq 0x3319(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
leaq 0x157e(%rip), %rsi      # 0x7267
movb $0x0, %al
callq 0x21a0
movq -0x8(%rbp), %rdi
callq 0x2300
jmp 0x5d10
movq 0x13af6(%rip), %rdi     # 0x197f8
movl -0xc(%rbp), %esi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x2170
jmp 0x5d12
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/examples/roster.c
// Function: handle_reply
int handle_reply(xmpp_conn_t * const conn,
		 xmpp_stanza_t * const stanza,
		 void * const userdata)
{
    xmpp_stanza_t *query, *item;
    char *type, *name;

    type = xmpp_stanza_get_type(stanza);
    if (strcmp(type, "error") == 0)
	fprintf(stderr, "ERROR: query failed\n");
    else {
	query = xmpp_stanza_get_child_by_name(stanza, "query");
	printf("Roster:\n");
	for (item = xmpp_stanza_get_children(query); item; 
	     item = xmpp_stanza_get_next(item))
	    if ((name = xmpp_stanza_get_attribute(item, "name")))
		printf("\t %s (%s) sub=%s\n", 
		       name,
		       xmpp_stanza_get_attribute(item, "jid"),
		       xmpp_stanza_get_attribute(item, "subscription"));
	    else
		printf("\t %s sub=%s\n",
		       xmpp_stanza_get_attribute(item, "jid"),
		       xmpp_stanza_get_attribute(item, "subscription"));
	printf("END OF LIST\n");
    }

    /* disconnect */
    xmpp_disconnect(conn);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12100
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x1160a(%rip), %rsi     # 0x13a86
callq 0x2270
cmpl $0x0, %eax
jne 0x24a3
movq 0x15b5b(%rip), %rax     # 0x17fe8
movq (%rax), %rdi
leaq 0x10b6d(%rip), %rsi     # 0x13004
movb $0x0, %al
callq 0x20d0
jmp 0x2599
movq -0x10(%rbp), %rdi
leaq 0x10b6b(%rip), %rsi     # 0x13019
callq 0x12160
movq %rax, -0x20(%rbp)
leaq 0x10b61(%rip), %rdi     # 0x1301f
movb $0x0, %al
callq 0x2030
movq -0x20(%rbp), %rdi
callq 0x12240
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x258b
movq -0x28(%rbp), %rdi
leaq 0x10e87(%rip), %rsi     # 0x1336f
callq 0x12470
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x253e
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x10b30(%rip), %rsi     # 0x1303a
callq 0x12470
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x10b20(%rip), %rsi     # 0x1303e
callq 0x12470
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rax, %rcx
leaq 0x10af3(%rip), %rdi     # 0x13028
movb $0x0, %al
callq 0x2030
jmp 0x2577
movq -0x28(%rbp), %rdi
leaq 0x10af1(%rip), %rsi     # 0x1303a
callq 0x12470
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x10ae1(%rip), %rsi     # 0x1303e
callq 0x12470
movq -0x50(%rbp), %rsi
movq %rax, %rdx
leaq 0x10adb(%rip), %rdi     # 0x1304b
movb $0x0, %al
callq 0x2030
jmp 0x2579
movq -0x28(%rbp), %rdi
callq 0x12260
movq %rax, -0x28(%rbp)
jmp 0x24d2
leaq 0x10ac6(%rip), %rdi     # 0x13058
movb $0x0, %al
callq 0x2030
movq -0x8(%rbp), %rdi
callq 0x5530
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/examples/roster.c
// Function: conn_handler
void conn_handler(xmpp_conn_t * const conn, const xmpp_conn_event_t status, 
		  const int error, xmpp_stream_error_t * const stream_error,
		  void * const userdata)
{
    xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
    xmpp_stanza_t *iq, *query;

    if (status == XMPP_CONN_CONNECT) {
	fprintf(stderr, "DEBUG: connected\n");
	
	/* create iq stanza for request */
	iq = xmpp_stanza_new(ctx);
	xmpp_stanza_set_name(iq, "iq");
	xmpp_stanza_set_type(iq, "get");
	xmpp_stanza_set_id(iq, "roster1");

	query = xmpp_stanza_new(ctx);
	xmpp_stanza_set_name(query, "query");
	xmpp_stanza_set_ns(query, XMPP_NS_ROSTER);

	xmpp_stanza_add_child(iq, query);

	/* we can release the stanza since it belongs to iq now */
	xmpp_stanza_release(query);

	/* set up reply handler */
	xmpp_id_handler_add(conn, handle_reply, "roster1", ctx);

	/* send out the stanza */
	xmpp_send(conn, iq);

	/* release the stanza */
	xmpp_stanza_release(iq);
    } else {
	fprintf(stderr, "DEBUG: disconnected\n");
	xmpp_stop(ctx);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x26a7
movq 0x15a05(%rip), %rax     # 0x17fe8
movq (%rax), %rdi
leaq 0x10a78(%rip), %rsi     # 0x13065
movb $0x0, %al
callq 0x20d0
movq -0x28(%rbp), %rdi
callq 0x112d0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x10a6b(%rip), %rsi     # 0x13077
callq 0x11b70
movq -0x30(%rbp), %rdi
leaq 0x10a5e(%rip), %rsi     # 0x1307a
callq 0x12440
movq -0x30(%rbp), %rdi
leaq 0x10a52(%rip), %rsi     # 0x1307e
callq 0x12410
movq -0x28(%rbp), %rdi
callq 0x112d0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq 0x109d0(%rip), %rsi     # 0x13019
callq 0x11b70
movq -0x38(%rbp), %rdi
leaq 0x10a2d(%rip), %rsi     # 0x13086
callq 0x11e40
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x11e70
movq -0x38(%rbp), %rdi
callq 0x115a0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rcx
leaq -0x233(%rip), %rsi      # 0x2450
leaq 0x109f4(%rip), %rdx     # 0x1307e
callq 0x7720
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x58b0
movq -0x30(%rbp), %rdi
callq 0x115a0
jmp 0x26c8
movq 0x1593a(%rip), %rax     # 0x17fe8
movq (%rax), %rdi
leaq 0x109df(%rip), %rsi     # 0x13097
movb $0x0, %al
callq 0x20d0
movq -0x28(%rbp), %rdi
callq 0x6c90
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_str2int.c
// Function: main
int main(int argc, char **argv) {
    int verbose = 0, opt, res;

    while ((opt = getopt(argc, argv, "v")) != -1) {
        switch (opt) {
        case 'v':
            verbose = 1;
            break;
        default:
            fprintf(stderr, "Usage: %s [-v]\n", argv[0]);
            return EXIT_FAILURE;
        }
    }

    res = check_str2int(verbose);
    res |= check_strprint(verbose);
    return res ? EXIT_FAILURE : EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0xe33b5(%rip), %rdx     # 0xe8e80
callq 0x40c0
movl %eax, -0x18(%rbp)
cmpl $-0x1, %eax
je 0x5b15
movl -0x18(%rbp), %eax
subl $0x76, %eax
jne 0x5aeb
jmp 0x5ae2
movl $0x1, -0x14(%rbp)
jmp 0x5b13
movq 0xff4ee(%rip), %rax     # 0x104fe0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xe1501(%rip), %rsi     # 0xe7004
movb $0x0, %al
callq 0x46d0
movl $0x1, -0x4(%rbp)
jmp 0x5b41
jmp 0x5abd
movl -0x14(%rbp), %edi
callq 0x5b50
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %edi
callq 0x61d0
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_str2int.c
// Function: check_strprint2
static int
check_strprint2(int verbose, const char *str, size_t len, size_t destlen,
                char quote, const char *expect) {
    char buf[100];
    hts_strprint(buf, destlen, quote, str, len);
    if (strcmp(buf, expect) != 0) {
        fprintf(stderr, "hts_strprint failed: length %zu: got \"%.*s\", "
                "expected \"%s\"\n", destlen, (int) destlen, buf, expect);
        return -1;
    }
    else if (verbose) {
        fprintf(stderr, "hts_strprint OK: length %zu: got \"%s\"\n",
                destlen, expect);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %r8b, %al
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb %al, -0x21(%rbp)
movq %r9, -0x30(%rbp)
leaq -0xa0(%rbp), %rdi
movq -0x20(%rbp), %rsi
movb -0x21(%rbp), %al
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movsbl %al, %edx
callq 0x7f10
leaq -0xa0(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4690
cmpl $0x0, %eax
je 0x6b6d
movq 0xfe4a2(%rip), %rax     # 0x104fe0
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
movq -0x20(%rbp), %rax
movl %eax, %ecx
leaq -0xa0(%rbp), %r8
movq -0x30(%rbp), %r9
leaq 0xe06b1(%rip), %rsi     # 0xe720e
movb $0x0, %al
callq 0x46d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6b9c
cmpl $0x0, -0x8(%rbp)
je 0x6b93
movq 0xfe466(%rip), %rax     # 0x104fe0
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq 0xe06be(%rip), %rsi     # 0xe724a
movb $0x0, %al
callq 0x46d0
jmp 0x6b95
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)