LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genevalab[P]msmove/streec.c
// Function: cinr
int cinr(int nsam, int nsites)
{
	int len, el, lsg, lsgm1, ic, is, endic;
	int spot = (int)(nlinks * genrand_real3()) + 1;
	struct seg *pseg;
	
	for (ic=0; ic < nchrom; ic++)
	{
		lsg = chrom[ic].nseg;
		lsgm1 = lsg-1;
		pseg = chrom[ic].pseg;
		el = ((pseg+lsgm1)->end)-(pseg->beg);
		if (spot <= el)
			break;
		spot -= el;
	}
	is = pseg->beg+spot-1;
	endic = (pseg+lsgm1)->end;
	xover(nsam, ic, is);
	len = (int)floor(1.0+log(genrand_real3())/lnpc);
	if (is+len >= endic)
		return ic;  
	if (is+len < (chrom[nchrom-1].pseg)->beg)
	{
		ca(nsam, nsites, ic, nchrom-1);
		return -1;
	}
	xover(nsam, nchrom-1, is+len);
	ca(nsam, nsites, ic, nchrom-1);
	return ic;	

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %r14d
cvtsi2sdq 0x5d6a(%rip), %xmm0 # 0xb558
movsd %xmm0, -0x30(%rbp)
callq 0x449a
mulsd -0x30(%rbp), %xmm0
cvttsd2si %xmm0, %eax
incl %eax
movl 0x5d47(%rip), %edx      # 0xb550
movq 0x5d20(%rip), %rdi      # 0xb530
addq $0x8, %rdi
xorl %r15d, %r15d
movl %eax, %r8d
movslq -0x8(%rdi), %rsi
movq (%rdi), %rcx
leaq (%rsi,%rsi,2), %r9
movl -0x8(%rcx,%r9,4), %r9d
subl (%rcx), %r9d
subl %r9d, %r8d
jle 0x5847
incq %r15
addq $0x10, %rdi
movl %r8d, %eax
cmpq %r15, %rdx
jne 0x581a
movl %edx, %r15d
movl %r8d, %eax
decl %esi
movl (%rcx), %edx
movl %eax, %r12d
addl %edx, %r12d
addl %eax, %edx
decl %edx
movslq %esi, %rax
leaq (%rax,%rax,2), %rax
movl 0x4(%rcx,%rax,4), %r13d
movl %r14d, %edi
movl %r15d, %esi
callq 0x5ed5
callq 0x449a
callq 0x1070
divsd 0x5cfa(%rip), %xmm0     # 0xb578
addsd 0x1782(%rip), %xmm0     # 0x7008
callq 0x1180
cvttsd2si %xmm0, %eax
leal (%rax,%r12), %edx
decl %edx
cmpl %r13d, %edx
jge 0x58e6
movq 0x5c8f(%rip), %rax      # 0xb530
movslq 0x5ca8(%rip), %rcx      # 0xb550
decq %rcx
movq %rcx, %rsi
shlq $0x4, %rsi
movq 0x8(%rax,%rsi), %rax
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpl (%rax), %edx
jl 0x58d6
movl %r14d, %edi
movl %ecx, %esi
callq 0x5ed5
movl 0x5c7f(%rip), %ecx      # 0xb550
decl %ecx
movl %r15d, %r12d
movl %r14d, %edi
movl %ebx, %esi
movl %r15d, %edx
callq 0x59b8
movl %r12d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genevalab[P]msmove/streec.c
// Function: pick2_chrom
int pick2_chrom(int pop, int config[], int *pc1, int *pc2)
{
	int c1, c2, cs, cb, i, count;
	
	pick2(config[pop], &c1, &c2);
	cs = c1 > c2 ? c2 : c1;
	cb = c1 > c2 ? c1 : c2;
	i = count = 0;
	for(;;)
	{
		while (chrom[i].pop != pop) 
			i++;
		if (count == cs)
			break;
		count++;
		i++;
	}
	*pc1 = i;
	i++;
	count++;
	for(;;)
	{
		while (chrom[i].pop != pop)
			i++;
		if (count == cb)
			break;
		count++;
		i++;
	}
	*pc2 = i;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movl %edi, %r14d
movslq %edi, %rax
movl (%rsi,%rax,4), %edi
leaq -0x30(%rbp), %r12
leaq -0x2c(%rbp), %r13
movq %r12, %rsi
movq %r13, %rdx
callq 0x3ff1
movl (%r12), %edi
movl (%r13), %eax
cmpl %eax, %edi
movl %eax, %ecx
cmovll %edi, %ecx
movq 0x5bf2(%rip), %rsi      # 0xb530
leaq 0x4(%rsi), %r8
xorl %edx, %edx
xorl %r9d, %r9d
movslq %edx, %rdx
leal -0x1(%rdx), %r10d
movq %rdx, %r11
shlq $0x4, %r11
addq %r8, %r11
incq %rdx
incl %r10d
leaq 0x10(%r11), %r12
cmpl %r14d, (%r11)
movq %r12, %r11
jne 0x5958
cmpl %ecx, %r9d
je 0x5974
incl %r9d
jmp 0x5947
cmpl %eax, %edi
cmovgl %edi, %eax
movl %r10d, (%r15)
addq $0x14, %rsi
decq %rdx
movslq %edx, %rdx
movq %rdx, %rdi
shlq $0x4, %rdi
addq %rsi, %rdi
incq %rdx
leaq 0x10(%rdi), %r8
cmpl %r14d, (%rdi)
movq %r8, %rdi
jne 0x5990
incl %ecx
cmpl %eax, %ecx
jne 0x5983
movl %edx, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genevalab[P]msmove/streec.c
// Function: isseg
int isseg(int start, int c, int *psg)
{
	int ns = chrom[c].nseg;
	struct seg *pseg = chrom[c].pseg;

	for(; ((*psg) < ns) && ((pseg+(*psg))->beg <= start); ++(*psg))
		if ((pseg+(*psg))->end >= start)
			return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x51a1(%rip), %r9       # 0xb530
movslq %esi, %rsi
shlq $0x4, %rsi
movl (%r9,%rsi), %ecx
movslq (%rdx), %r8
xorl %eax, %eax
cmpl %ecx, %r8d
jge 0x63e1
movq 0x8(%r9,%rsi), %rsi
leaq (%r8,%r8,2), %r9
leaq (%rsi,%r9,4), %rsi
addq $0x4, %rsi
negl %ecx
incl %r8d
cmpl %edi, -0x4(%rsi)
jg 0x63e1
cmpl %edi, (%rsi)
jge 0x63dc
movl %r8d, (%rdx)
addq $0xc, %rsi
leal (%rcx,%r8), %r9d
incl %r9d
incl %r8d
cmpl $0x1, %r9d
jne 0x63ba
jmp 0x63e1
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/buffer.c
// Function: buffer_append
void buffer_append(buffer* buffer, char* data, size_t length)
{
    size_t offset = buffer->length;
    buffer->length += length;

    char* newdata = realloc(buffer->data, buffer->length);
    if (newdata == NULL) {
        perror("Unable to allocate memory");
        exit(2);
    }
    memcpy(newdata + offset, data, length);
    buffer->data = newdata;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %r12
movq 0x8(%rdi), %rdi
leaq (%r12,%rdx), %rsi
movq %rsi, (%rbx)
callq 0x10c0
testq %rax, %rax
je 0x131c
movq %rax, %r13
addq %rax, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x10a0
movq %r13, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1110
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cli.c
// Function: read_all_stdin
buffer read_all_stdin() {
    buffer out_data = make_buffer();
    
    char buffer[BUFFER_SIZE];
    
    size_t amount_read;
    while ((amount_read = fread(buffer, 1, BUFFER_SIZE, stdin)) > 0) {
        buffer_append(&out_data, buffer, amount_read);
    };

    if (ferror(stdin)) {
        perror("Could not read stdin");
        exit(3);
    }

    return out_data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x818, %rsp            # imm = 0x818
xorl %eax, %eax
callq 0x12bc
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq 0x9c96(%rip), %r15      # 0xafe0
movq (%r15), %rcx
leaq -0x830(%rbp), %rdi
movl $0x1, %esi
movl $0x800, %edx            # imm = 0x800
callq 0x1060
testq %rax, %rax
je 0x139b
leaq -0x28(%rbp), %rbx
leaq -0x830(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x12c6
movq (%r15), %rcx
movl $0x1, %esi
movl $0x800, %edx            # imm = 0x800
movq %r14, %rdi
callq 0x1060
testq %rax, %rax
jne 0x1373
movq (%r15), %rdi
callq 0x1050
testl %eax, %eax
jne 0x13bd
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdx
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1128
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cli.c
// Function: main
int main(int argc, char *argv[]) {

    int print_strings = 0;

    struct option long_options[] =
    {
        {"print-strings", no_argument, &print_strings, 1},
        {NULL, 0, NULL, 0}
    };

    while (getopt_long(argc, argv, "", long_options, NULL) != -1) {}

#ifdef _WIN32
    // Switch stdin to binary
    if (_setmode(_fileno(stdin), _O_BINARY) == -1) {
        perror("Could not switch stdin to binary");
        exit(1);
    }
#endif

    buffer b = read_all_stdin();
    dump_msgpack(b, print_strings);
    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movl %edi, %r14d
xorl %eax, %eax
leaq -0x24(%rbp), %rcx
movl %eax, (%rcx)
leaq 0x4c4d(%rip), %rdx      # 0x6033
leaq -0x70(%rbp), %r15
movq %rdx, (%r15)
movl %eax, 0x8(%r15)
movq %rcx, 0x10(%r15)
movl $0x1, 0x18(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%r15)
movaps %xmm0, 0x30(%r15)
leaq 0x5366(%rip), %r12      # 0x6777
movl %r14d, %edi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x1070
cmpl $-0x1, %eax
jne 0x1411
callq 0x1324
xorl %ecx, %ecx
cmpl $0x0, -0x24(%rbp)
setne %cl
movq %rax, %rdi
movq %rdx, %rsi
movl %ecx, %edx
callq 0x4f3b
movl $0xa, %edi
callq 0x1040
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_init
void cmp_init(cmp_ctx_t *ctx, void *buf, cmp_reader read,
                                         cmp_skipper skip,
                                         cmp_writer write) {
  ctx->error = ERROR_NONE;
  ctx->buf = buf;
  ctx->read = read;
  ctx->skip = skip;
  ctx->write = write;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x0, (%rdi)
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_pfix
bool cmp_write_pfix(cmp_ctx_t *ctx, uint8_t c) {
  if (c <= 0x7F)
    return write_fixed_value(ctx, c);

  ctx->error = INPUT_VALUE_TOO_LARGE_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testb %sil, %sil
js 0x14e4
leaq -0x9(%rbp), %rax
movb %sil, (%rax)
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x20(%rbx)
movb $0x6, %cl
cmpq $0x1, %rax
sete %al
jne 0x14e8
jmp 0x14ea
movb $0x5, %cl
xorl %eax, %eax
movb %cl, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_nfix
bool cmp_write_nfix(cmp_ctx_t *ctx, int8_t c) {
  if (c >= -32 && c <= -1)
    return write_fixed_value(ctx, c);

  ctx->error = INPUT_VALUE_TOO_LARGE_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $-0x20, %sil
jb 0x1522
leaq -0x9(%rbp), %rax
movb %sil, (%rax)
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x20(%rbx)
movb $0x6, %cl
cmpq $0x1, %rax
sete %al
jne 0x1526
jmp 0x1528
movb $0x5, %cl
xorl %eax, %eax
movb %cl, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_s16
bool cmp_write_s16(cmp_ctx_t *ctx, int16_t s) {
  if (!write_type_marker(ctx, S16_MARKER))
    return false;

  s = be16(s);

  return ctx->write(ctx, &s, sizeof(int16_t));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movw %si, -0xa(%rbp)
leaq -0xb(%rbp), %rsi
movb $-0x2f, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
cmpq $0x1, %rax
jne 0x15f8
leaq -0xa(%rbp), %rsi
rolw $0x8, (%rsi)
movl $0x2, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
setne %al
jmp 0x15fd
movb $0x8, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_s32
bool cmp_write_s32(cmp_ctx_t *ctx, int32_t i) {
  if (!write_type_marker(ctx, S32_MARKER))
    return false;

  i = be32(i);

  return ctx->write(ctx, &i, sizeof(int32_t));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, -0x10(%rbp)
leaq -0x9(%rbp), %rsi
movb $-0x2e, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
cmpq $0x1, %rax
jne 0x1642
leaq -0x10(%rbp), %rsi
movl (%rsi), %eax
bswapl %eax
movl %eax, (%rsi)
movl $0x4, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
setne %al
jmp 0x1647
movb $0x8, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_s64
bool cmp_write_s64(cmp_ctx_t *ctx, int64_t l) {
  if (!write_type_marker(ctx, S64_MARKER))
    return false;

  l = be64(l);

  return ctx->write(ctx, &l, sizeof(int64_t));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsi, -0x18(%rbp)
leaq -0x9(%rbp), %rsi
movb $-0x2d, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
cmpq $0x1, %rax
jne 0x1693
leaq -0x18(%rbp), %rsi
movq (%rsi), %rax
bswapq %rax
movq %rax, (%rsi)
movl $0x8, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
setne %al
jmp 0x1698
movb $0x8, (%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_integer
bool cmp_write_integer(cmp_ctx_t *ctx, int64_t d) {
  if (d >= 0)
    return cmp_write_uinteger(ctx, d);
  if (d >= -32)
    return cmp_write_nfix(ctx, (int8_t)d);
  if (d >= -128)
    return cmp_write_s8(ctx, (int8_t)d);
  if (d >= -32768)
    return cmp_write_s16(ctx, (int16_t)d);
  if (d >= (-2147483647 - 1))
    return cmp_write_s32(ctx, (int32_t)d);

  return cmp_write_s64(ctx, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
js 0x16bb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1746
cmpq $-0x20, %rsi
jl 0x16e6
jb 0x16fe
leaq -0x9(%rbp), %rax
movb %sil, (%rax)
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x20(%rbx)
cmpq $0x1, %rax
sete %al
je 0x1703
movb $0x6, (%rbx)
jmp 0x1701
cmpq $-0x80, %rsi
jl 0x170a
movsbl %sil, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1576
movb $0x5, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpq $-0x8000, %rsi          # imm = 0x8000
jl 0x1724
movswl %si, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x15bb
movq %rbx, %rdi
cmpq $-0x80000000, %rsi      # imm = 0x80000000
jl 0x173b
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1604
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x164e
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_uinteger
bool cmp_write_uinteger(cmp_ctx_t *ctx, uint64_t u) {
  if (u <= 0x7F)
    return cmp_write_pfix(ctx, (uint8_t)u);
  if (u <= 0xFF)
    return cmp_write_u8(ctx, (uint8_t)u);
  if (u <= 0xFFFF)
    return cmp_write_u16(ctx, (uint16_t)u);
  if (u <= 0xFFFFFFFF)
    return cmp_write_u32(ctx, (uint32_t)u);

  return cmp_write_u64(ctx, u);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x7f, %rsi
ja 0x177f
leaq -0x9(%rbp), %rax
movb %sil, (%rax)
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x20(%rbx)
cmpq $0x1, %rax
sete %al
je 0x1778
movb $0x6, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpq $0xff, %rsi
ja 0x179a
movzbl %sil, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1813
cmpq $0xffff, %rsi           # imm = 0xFFFF
ja 0x17b4
movzwl %si, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1858
movq %rsi, %rax
movq %rbx, %rdi
shrq $0x20, %rax
jne 0x17cb
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x18a1
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x18eb
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_u16
bool cmp_write_u16(cmp_ctx_t *ctx, uint16_t s) {
  if (!write_type_marker(ctx, U16_MARKER))
    return false;

  s = be16(s);

  return ctx->write(ctx, &s, sizeof(uint16_t));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movw %si, -0xa(%rbp)
leaq -0xb(%rbp), %rsi
movb $-0x33, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
cmpq $0x1, %rax
jne 0x1895
leaq -0xa(%rbp), %rsi
rolw $0x8, (%rsi)
movl $0x2, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
setne %al
jmp 0x189a
movb $0x8, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_u32
bool cmp_write_u32(cmp_ctx_t *ctx, uint32_t i) {
  if (!write_type_marker(ctx, U32_MARKER))
    return false;

  i = be32(i);

  return ctx->write(ctx, &i, sizeof(uint32_t));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, -0x10(%rbp)
leaq -0x9(%rbp), %rsi
movb $-0x32, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
cmpq $0x1, %rax
jne 0x18df
leaq -0x10(%rbp), %rsi
movl (%rsi), %eax
bswapl %eax
movl %eax, (%rsi)
movl $0x4, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
setne %al
jmp 0x18e4
movb $0x8, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_u64
bool cmp_write_u64(cmp_ctx_t *ctx, uint64_t l) {
  if (!write_type_marker(ctx, U64_MARKER))
    return false;

  l = be64(l);

  return ctx->write(ctx, &l, sizeof(uint64_t));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsi, -0x18(%rbp)
leaq -0x9(%rbp), %rsi
movb $-0x31, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
cmpq $0x1, %rax
jne 0x1930
leaq -0x18(%rbp), %rsi
movq (%rsi), %rax
bswapq %rax
movq %rax, (%rsi)
movl $0x8, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
setne %al
jmp 0x1935
movb $0x8, (%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_float
bool cmp_write_float(cmp_ctx_t *ctx, float f) {
  if (!write_type_marker(ctx, FLOAT_MARKER))
    return false;

  /*
   * We may need to swap the float's bytes, but we can't just swap them inside
   * the float because the swapped bytes may not constitute a valid float.
   * Therefore, we have to create a buffer and swap the bytes there.
   */
  if (!is_bigendian()) {
    char swapped[sizeof(float)];
    char *fbuf = (char *)&f;
    size_t i;

    for (i = 0; i < sizeof(float); i++)
      swapped[i] = fbuf[sizeof(float) - i - 1];

    return ctx->write(ctx, swapped, sizeof(float));
  }

  return ctx->write(ctx, &f, sizeof(float));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movss %xmm0, -0x10(%rbp)
leaq -0x9(%rbp), %rsi
movb $-0x36, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
cmpq $0x1, %rax
jne 0x1991
leaq -0xd(%rbp), %rax
xorl %ecx, %ecx
movb (%rax), %dl
movb %dl, -0x14(%rbp,%rcx)
incq %rcx
decq %rax
cmpq $0x4, %rcx
jne 0x1968
leaq -0x14(%rbp), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
setne %al
jmp 0x1996
movb $0x8, (%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_double
bool cmp_write_double(cmp_ctx_t *ctx, double d) {
  if (!write_type_marker(ctx, DOUBLE_MARKER))
    return false;

  /* Same deal for doubles */
  if (!is_bigendian()) {
    char swapped[sizeof(double)];
    char *dbuf = (char *)&d;
    size_t i;

    for (i = 0; i < sizeof(double); i++)
      swapped[i] = dbuf[sizeof(double) - i - 1];

    return ctx->write(ctx, swapped, sizeof(double));
  }

  return ctx->write(ctx, &d, sizeof(double));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movsd %xmm0, -0x18(%rbp)
leaq -0x10(%rbp), %rsi
movb $-0x35, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
cmpq $0x1, %rax
jne 0x19f2
leaq -0x11(%rbp), %rax
xorl %ecx, %ecx
movb (%rax), %dl
movb %dl, -0x10(%rbp,%rcx)
incq %rcx
decq %rax
cmpq $0x8, %rcx
jne 0x19c9
leaq -0x10(%rbp), %rsi
movl $0x8, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
setne %al
jmp 0x19f7
movb $0x8, (%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_decimal
bool cmp_write_decimal(cmp_ctx_t *ctx, double d) {
  float f = (float)d;
  double df = (double)f;

  if (df == d)
    return cmp_write_float(ctx, f);
  else
    return cmp_write_double(ctx, d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cvtsd2ss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm2
ucomisd %xmm0, %xmm2
jne 0x1a1b
jp 0x1a1b
movaps %xmm1, %xmm0
popq %rbp
jmp 0x193c
popq %rbp
jmp 0x199d
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixstr_marker
bool cmp_write_fixstr_marker(cmp_ctx_t *ctx, uint8_t size) {
  if (size <= FIXSTR_SIZE)
    return write_fixed_value(ctx, FIXSTR_MARKER | size);

  ctx->error = INPUT_VALUE_TOO_LARGE_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1f, %sil
ja 0x1b59
orb $-0x60, %sil
leaq -0x9(%rbp), %rax
movb %sil, (%rax)
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x20(%rbx)
movb $0x6, %cl
cmpq $0x1, %rax
sete %al
jne 0x1b5d
jmp 0x1b5f
movb $0x5, %cl
xorl %eax, %eax
movb %cl, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixstr
bool cmp_write_fixstr(cmp_ctx_t *ctx, const char *data, uint8_t size) {
  if (!cmp_write_fixstr_marker(ctx, size))
    return false;

  if (size == 0)
    return true;

  if (ctx->write(ctx, data, size))
    return true;

  ctx->error = DATA_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r15d
movq %rdi, %rbx
movb $0x5, %cl
cmpb $0x1f, %r15b
ja 0x1bc0
movq %rsi, %r14
movl %r15d, %eax
orb $-0x60, %al
leaq -0x21(%rbp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movb $0x6, %cl
cmpq $0x1, %rax
jne 0x1bc0
movb $0x1, %r12b
testb %r15b, %r15b
je 0x1bc5
movzbl %r15b, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rbx)
testq %rax, %rax
jne 0x1bc5
movb $0xa, %cl
movb %cl, (%rbx)
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_str8_marker
bool cmp_write_str8_marker(cmp_ctx_t *ctx, uint8_t size) {
  if (!write_type_marker(ctx, STR8_MARKER))
    return false;

  if (ctx->write(ctx, &size, sizeof(uint8_t)))
    return true;

  ctx->error = LENGTH_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb %sil, -0x9(%rbp)
leaq -0xa(%rbp), %rsi
movb $-0x27, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x1c14
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x1c18
movb $0xf, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_str8
bool cmp_write_str8(cmp_ctx_t *ctx, const char *data, uint8_t size) {
  if (!cmp_write_str8_marker(ctx, size))
    return false;

  if (size == 0)
    return true;

  if (ctx->write(ctx, data, size))
    return true;

  ctx->error = DATA_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
movl %edx, %esi
callq 0x1bd5
testb %al, %al
je 0x1c5b
movb $0x1, %r14b
testb %r12b, %r12b
je 0x1c5e
movzbl %r12b, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq *0x20(%rbx)
testq %rax, %rax
jne 0x1c5e
movb $0xa, (%rbx)
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_str16_marker
bool cmp_write_str16_marker(cmp_ctx_t *ctx, uint16_t size) {
  if (!write_type_marker(ctx, STR16_MARKER))
    return false;

  size = be16(size);

  if (ctx->write(ctx, &size, sizeof(uint16_t)))
    return true;

  ctx->error = LENGTH_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movw %si, -0xa(%rbp)
leaq -0xb(%rbp), %rsi
movb $-0x26, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x1cad
leaq -0xa(%rbp), %rsi
rolw $0x8, (%rsi)
movl $0x2, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x1cb1
movb $0xf, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_str16
bool cmp_write_str16(cmp_ctx_t *ctx, const char *data, uint16_t size) {
  if (!cmp_write_str16_marker(ctx, size))
    return false;

  if (size == 0)
    return true;

  if (ctx->write(ctx, data, size))
    return true;

  ctx->error = DATA_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
movl %edx, %esi
callq 0x1c6a
testb %al, %al
je 0x1cf5
movb $0x1, %r14b
testw %r12w, %r12w
je 0x1cf8
movzwl %r12w, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq *0x20(%rbx)
testq %rax, %rax
jne 0x1cf8
movb $0xa, (%rbx)
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_str32_marker
bool cmp_write_str32_marker(cmp_ctx_t *ctx, uint32_t size) {
  if (!write_type_marker(ctx, STR32_MARKER))
    return false;

  size = be32(size);

  if (ctx->write(ctx, &size, sizeof(uint32_t)))
    return true;

  ctx->error = LENGTH_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, -0x10(%rbp)
leaq -0x9(%rbp), %rsi
movb $-0x25, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x1d48
leaq -0x10(%rbp), %rsi
movl (%rsi), %eax
bswapl %eax
movl %eax, (%rsi)
movl $0x4, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x1d4c
movb $0xf, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_str32
bool cmp_write_str32(cmp_ctx_t *ctx, const char *data, uint32_t size) {
  if (!cmp_write_str32_marker(ctx, size))
    return false;

  if (size == 0)
    return true;

  if (ctx->write(ctx, data, size))
    return true;

  ctx->error = DATA_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %r14
movl %edx, %esi
callq 0x1d04
testb %al, %al
je 0x1d8f
movb $0x1, %bl
testl %r12d, %r12d
je 0x1d91
movl %r12d, %edx
movq %r14, %rdi
movq %r15, %rsi
callq *0x20(%r14)
testq %rax, %rax
jne 0x1d91
movb $0xa, (%r14)
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_str_marker
bool cmp_write_str_marker(cmp_ctx_t *ctx, uint32_t size) {
  if (size <= FIXSTR_SIZE)
    return cmp_write_fixstr_marker(ctx, (uint8_t)size);
  if (size <= 0xFF)
    return cmp_write_str8_marker(ctx, (uint8_t)size);
  if (size <= 0xFFFF)
    return cmp_write_str16_marker(ctx, (uint16_t)size);

  return cmp_write_str32_marker(ctx, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1f, %esi
ja 0x1dd8
orb $-0x60, %sil
leaq -0x9(%rbp), %rax
movb %sil, (%rax)
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x20(%rbx)
cmpq $0x1, %rax
sete %al
je 0x1dd1
movb $0x6, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpl $0xff, %esi
ja 0x1df2
movzbl %sil, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1bd5
cmpl $0xffff, %esi           # imm = 0xFFFF
ja 0x1e0b
movzwl %si, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1c6a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1d04
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_str_marker_v4
bool cmp_write_str_marker_v4(cmp_ctx_t *ctx, uint32_t size) {
  if (size <= FIXSTR_SIZE)
    return cmp_write_fixstr_marker(ctx, (uint8_t)size);
  if (size <= 0xFFFF)
    return cmp_write_str16_marker(ctx, (uint16_t)size);

  return cmp_write_str32_marker(ctx, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1f, %esi
ja 0x1e55
orb $-0x60, %sil
leaq -0x9(%rbp), %rax
movb %sil, (%rax)
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x20(%rbx)
cmpq $0x1, %rax
sete %al
je 0x1e4e
movb $0x6, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpl $0xffff, %esi           # imm = 0xFFFF
ja 0x1e6e
movzwl %si, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1c6a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1d04
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_str
bool cmp_write_str(cmp_ctx_t *ctx, const char *data, uint32_t size) {
  if (size <= FIXSTR_SIZE)
    return cmp_write_fixstr(ctx, data, (uint8_t)size);
  if (size <= 0xFF)
    return cmp_write_str8(ctx, data, (uint8_t)size);
  if (size <= 0xFFFF)
    return cmp_write_str16(ctx, data, (uint16_t)size);

  return cmp_write_str32(ctx, data, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x1f, %edx
ja 0x1e8e
movzbl %dl, %edx
popq %rbp
jmp 0x1b66
cmpl $0xff, %edx
ja 0x1e9f
movzbl %dl, %edx
popq %rbp
jmp 0x1c1f
cmpl $0xffff, %edx           # imm = 0xFFFF
ja 0x1eb0
movzwl %dx, %edx
popq %rbp
jmp 0x1cb8
popq %rbp
jmp 0x1d53
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_str_v4
bool cmp_write_str_v4(cmp_ctx_t *ctx, const char *data, uint32_t size) {
  if (size <= FIXSTR_SIZE)
    return cmp_write_fixstr(ctx, data, (uint8_t)size);
  if (size <= 0xFFFF)
    return cmp_write_str16(ctx, data, (uint16_t)size);

  return cmp_write_str32(ctx, data, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x1f, %edx
ja 0x1ec8
movzbl %dl, %edx
popq %rbp
jmp 0x1b66
cmpl $0xffff, %edx           # imm = 0xFFFF
ja 0x1ed9
movzwl %dx, %edx
popq %rbp
jmp 0x1cb8
popq %rbp
jmp 0x1d53
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_bin8_marker
bool cmp_write_bin8_marker(cmp_ctx_t *ctx, uint8_t size) {
  if (!write_type_marker(ctx, BIN8_MARKER))
    return false;

  if (ctx->write(ctx, &size, sizeof(uint8_t)))
    return true;

  ctx->error = LENGTH_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb %sil, -0x9(%rbp)
leaq -0xa(%rbp), %rsi
movb $-0x3c, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x1f1e
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x1f22
movb $0xf, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_bin8
bool cmp_write_bin8(cmp_ctx_t *ctx, const void *data, uint8_t size) {
  if (!cmp_write_bin8_marker(ctx, size))
    return false;

  if (size == 0)
    return true;

  if (ctx->write(ctx, data, size))
    return true;

  ctx->error = DATA_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
movl %edx, %esi
callq 0x1edf
testb %al, %al
je 0x1f65
movb $0x1, %r14b
testb %r12b, %r12b
je 0x1f68
movzbl %r12b, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq *0x20(%rbx)
testq %rax, %rax
jne 0x1f68
movb $0xa, (%rbx)
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_bin16
bool cmp_write_bin16(cmp_ctx_t *ctx, const void *data, uint16_t size) {
  if (!cmp_write_bin16_marker(ctx, size))
    return false;

  if (size == 0)
    return true;

  if (ctx->write(ctx, data, size))
    return true;

  ctx->error = DATA_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
movl %edx, %esi
callq 0x1f74
testb %al, %al
je 0x1fff
movb $0x1, %r14b
testw %r12w, %r12w
je 0x2002
movzwl %r12w, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq *0x20(%rbx)
testq %rax, %rax
jne 0x2002
movb $0xa, (%rbx)
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_bin32_marker
bool cmp_write_bin32_marker(cmp_ctx_t *ctx, uint32_t size) {
  if (!write_type_marker(ctx, BIN32_MARKER))
    return false;

  size = be32(size);

  if (ctx->write(ctx, &size, sizeof(uint32_t)))
    return true;

  ctx->error = LENGTH_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, -0x10(%rbp)
leaq -0x9(%rbp), %rsi
movb $-0x3a, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x2052
leaq -0x10(%rbp), %rsi
movl (%rsi), %eax
bswapl %eax
movl %eax, (%rsi)
movl $0x4, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2056
movb $0xf, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_bin32
bool cmp_write_bin32(cmp_ctx_t *ctx, const void *data, uint32_t size) {
  if (!cmp_write_bin32_marker(ctx, size))
    return false;

  if (size == 0)
    return true;

  if (ctx->write(ctx, data, size))
    return true;

  ctx->error = DATA_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %r14
movl %edx, %esi
callq 0x200e
testb %al, %al
je 0x2099
movb $0x1, %bl
testl %r12d, %r12d
je 0x209b
movl %r12d, %edx
movq %r14, %rdi
movq %r15, %rsi
callq *0x20(%r14)
testq %rax, %rax
jne 0x209b
movb $0xa, (%r14)
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_bin_marker
bool cmp_write_bin_marker(cmp_ctx_t *ctx, uint32_t size) {
  if (size <= 0xFF)
    return cmp_write_bin8_marker(ctx, (uint8_t)size);
  if (size <= 0xFFFF)
    return cmp_write_bin16_marker(ctx, (uint16_t)size);

  return cmp_write_bin32_marker(ctx, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0xff, %esi
ja 0x20bc
movzbl %sil, %esi
popq %rbp
jmp 0x1edf
cmpl $0xffff, %esi           # imm = 0xFFFF
ja 0x20cd
movzwl %si, %esi
popq %rbp
jmp 0x1f74
popq %rbp
jmp 0x200e
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_bin
bool cmp_write_bin(cmp_ctx_t *ctx, const void *data, uint32_t size) {
  if (size <= 0xFF)
    return cmp_write_bin8(ctx, data, (uint8_t)size);
  if (size <= 0xFFFF)
    return cmp_write_bin16(ctx, data, (uint16_t)size);

  return cmp_write_bin32(ctx, data, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0xff, %edx
ja 0x20e8
movzbl %dl, %edx
popq %rbp
jmp 0x1f29
cmpl $0xffff, %edx           # imm = 0xFFFF
ja 0x20f9
movzwl %dx, %edx
popq %rbp
jmp 0x1fc2
popq %rbp
jmp 0x205d
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixarray
bool cmp_write_fixarray(cmp_ctx_t *ctx, uint8_t size) {
  if (size <= FIXARRAY_SIZE)
    return write_fixed_value(ctx, FIXARRAY_MARKER | size);

  ctx->error = INPUT_VALUE_TOO_LARGE_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0xf, %sil
ja 0x2134
orb $-0x70, %sil
leaq -0x9(%rbp), %rax
movb %sil, (%rax)
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x20(%rbx)
movb $0x6, %cl
cmpq $0x1, %rax
sete %al
jne 0x2138
jmp 0x213a
movb $0x5, %cl
xorl %eax, %eax
movb %cl, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_array16
bool cmp_write_array16(cmp_ctx_t *ctx, uint16_t size) {
  if (!write_type_marker(ctx, ARRAY16_MARKER))
    return false;

  size = be16(size);

  if (ctx->write(ctx, &size, sizeof(uint16_t)))
    return true;

  ctx->error = LENGTH_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movw %si, -0xa(%rbp)
leaq -0xb(%rbp), %rsi
movb $-0x24, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x2184
leaq -0xa(%rbp), %rsi
rolw $0x8, (%rsi)
movl $0x2, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2188
movb $0xf, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_array32
bool cmp_write_array32(cmp_ctx_t *ctx, uint32_t size) {
  if (!write_type_marker(ctx, ARRAY32_MARKER))
    return false;

  size = be32(size);

  if (ctx->write(ctx, &size, sizeof(uint32_t)))
    return true;

  ctx->error = LENGTH_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, -0x10(%rbp)
leaq -0x9(%rbp), %rsi
movb $-0x23, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x21d3
leaq -0x10(%rbp), %rsi
movl (%rsi), %eax
bswapl %eax
movl %eax, (%rsi)
movl $0x4, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x21d7
movb $0xf, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_array
bool cmp_write_array(cmp_ctx_t *ctx, uint32_t size) {
  if (size <= FIXARRAY_SIZE)
    return cmp_write_fixarray(ctx, (uint8_t)size);
  if (size <= 0xFFFF)
    return cmp_write_array16(ctx, (uint16_t)size);

  return cmp_write_array32(ctx, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0xf, %esi
ja 0x221a
orb $-0x70, %sil
leaq -0x9(%rbp), %rax
movb %sil, (%rax)
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x20(%rbx)
cmpq $0x1, %rax
sete %al
je 0x2213
movb $0x6, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpl $0xffff, %esi           # imm = 0xFFFF
ja 0x2233
movzwl %si, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2141
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x218f
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixmap
bool cmp_write_fixmap(cmp_ctx_t *ctx, uint8_t size) {
  if (size <= FIXMAP_SIZE)
    return write_fixed_value(ctx, FIXMAP_MARKER | size);

  ctx->error = INPUT_VALUE_TOO_LARGE_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0xf, %sil
ja 0x2276
orb $-0x80, %sil
leaq -0x9(%rbp), %rax
movb %sil, (%rax)
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x20(%rbx)
movb $0x6, %cl
cmpq $0x1, %rax
sete %al
jne 0x227a
jmp 0x227c
movb $0x5, %cl
xorl %eax, %eax
movb %cl, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_map16
bool cmp_write_map16(cmp_ctx_t *ctx, uint16_t size) {
  if (!write_type_marker(ctx, MAP16_MARKER))
    return false;

  size = be16(size);

  if (ctx->write(ctx, &size, sizeof(uint16_t)))
    return true;

  ctx->error = LENGTH_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movw %si, -0xa(%rbp)
leaq -0xb(%rbp), %rsi
movb $-0x22, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x22c6
leaq -0xa(%rbp), %rsi
rolw $0x8, (%rsi)
movl $0x2, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x22ca
movb $0xf, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_map32
bool cmp_write_map32(cmp_ctx_t *ctx, uint32_t size) {
  if (!write_type_marker(ctx, MAP32_MARKER))
    return false;

  size = be32(size);

  if (ctx->write(ctx, &size, sizeof(uint32_t)))
    return true;

  ctx->error = LENGTH_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, -0x10(%rbp)
leaq -0x9(%rbp), %rsi
movb $-0x21, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x2315
leaq -0x10(%rbp), %rsi
movl (%rsi), %eax
bswapl %eax
movl %eax, (%rsi)
movl $0x4, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2319
movb $0xf, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_map
bool cmp_write_map(cmp_ctx_t *ctx, uint32_t size) {
  if (size <= FIXMAP_SIZE)
    return cmp_write_fixmap(ctx, (uint8_t)size);
  if (size <= 0xFFFF)
    return cmp_write_map16(ctx, (uint16_t)size);

  return cmp_write_map32(ctx, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0xf, %esi
ja 0x235c
orb $-0x80, %sil
leaq -0x9(%rbp), %rax
movb %sil, (%rax)
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x20(%rbx)
cmpq $0x1, %rax
sete %al
je 0x2355
movb $0x6, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpl $0xffff, %esi           # imm = 0xFFFF
ja 0x2375
movzwl %si, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2283
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x22d1
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixext1_marker
bool cmp_write_fixext1_marker(cmp_ctx_t *ctx, int8_t type) {
  if (!write_type_marker(ctx, FIXEXT1_MARKER))
    return false;

  if (ctx->write(ctx, &type, sizeof(int8_t)))
    return true;

  ctx->error = EXT_TYPE_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb %sil, -0x9(%rbp)
leaq -0xa(%rbp), %rsi
movb $-0x2c, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x23c2
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x23c6
movb $0xc, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixext1
bool cmp_write_fixext1(cmp_ctx_t *ctx, int8_t type, const void *data) {
  if (!cmp_write_fixext1_marker(ctx, type))
    return false;

  if (ctx->write(ctx, data, 1))
    return true;

  ctx->error = DATA_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x2383
testb %al, %al
je 0x23fe
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2400
movb $0xa, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixext2_marker
bool cmp_write_fixext2_marker(cmp_ctx_t *ctx, int8_t type) {
  if (!write_type_marker(ctx, FIXEXT2_MARKER))
    return false;

  if (ctx->write(ctx, &type, sizeof(int8_t)))
    return true;

  ctx->error = EXT_TYPE_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb %sil, -0x9(%rbp)
leaq -0xa(%rbp), %rsi
movb $-0x2b, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x2444
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2448
movb $0xc, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixext2
bool cmp_write_fixext2(cmp_ctx_t *ctx, int8_t type, const void *data) {
  if (!cmp_write_fixext2_marker(ctx, type))
    return false;

  if (ctx->write(ctx, data, 2))
    return true;

  ctx->error = DATA_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x2405
testb %al, %al
je 0x2480
movl $0x2, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2482
movb $0xa, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixext4_marker
bool cmp_write_fixext4_marker(cmp_ctx_t *ctx, int8_t type) {
  if (!write_type_marker(ctx, FIXEXT4_MARKER))
    return false;

  if (ctx->write(ctx, &type, sizeof(int8_t)))
    return true;

  ctx->error = EXT_TYPE_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb %sil, -0x9(%rbp)
leaq -0xa(%rbp), %rsi
movb $-0x2a, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x24c6
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x24ca
movb $0xc, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixext4
bool cmp_write_fixext4(cmp_ctx_t *ctx, int8_t type, const void *data) {
  if (!cmp_write_fixext4_marker(ctx, type))
    return false;

  if (ctx->write(ctx, data, 4))
    return true;

  ctx->error = DATA_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x2487
testb %al, %al
je 0x2502
movl $0x4, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2504
movb $0xa, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixext8_marker
bool cmp_write_fixext8_marker(cmp_ctx_t *ctx, int8_t type) {
  if (!write_type_marker(ctx, FIXEXT8_MARKER))
    return false;

  if (ctx->write(ctx, &type, sizeof(int8_t)))
    return true;

  ctx->error = EXT_TYPE_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb %sil, -0x9(%rbp)
leaq -0xa(%rbp), %rsi
movb $-0x29, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x2548
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x254c
movb $0xc, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixext8
bool cmp_write_fixext8(cmp_ctx_t *ctx, int8_t type, const void *data) {
  if (!cmp_write_fixext8_marker(ctx, type))
    return false;

  if (ctx->write(ctx, data, 8))
    return true;

  ctx->error = DATA_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x2509
testb %al, %al
je 0x2584
movl $0x8, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2586
movb $0xa, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_fixext16_marker
bool cmp_write_fixext16_marker(cmp_ctx_t *ctx, int8_t type) {
  if (!write_type_marker(ctx, FIXEXT16_MARKER))
    return false;

  if (ctx->write(ctx, &type, sizeof(int8_t)))
    return true;

  ctx->error = EXT_TYPE_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb %sil, -0x9(%rbp)
leaq -0xa(%rbp), %rsi
movb $-0x28, (%rsi)
movl $0x1, %edx
callq *0x20(%rdi)
movb $0x8, %cl
cmpq $0x1, %rax
jne 0x25ca
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq *0x20(%rbx)
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x25ce
movb $0xc, %cl
movb %cl, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq