LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genevalab[P]msmove/ms.c
// Function: gasdev
double gasdev(double m, double v)
{
	static int iset = 0;
	static double gset;
	double fac, r, v1, v2;

	if (iset == 0)
	{
		do
		{
			v1 = 2.0*genrand_real3()-1.0;
			v2 = 2.0*genrand_real3()-1.0;
			r = v1*v1+v2*v2;
		} while (r >= 1.0);

		fac = sqrt(-2.0*log(r)/r);
		gset = v1*fac;
		iset = 1;

		return m+sqrt(v)*v2*fac;
	} 
	else
	{
		iset = 0;
		return m+sqrt(v)*gset;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
cmpl $0x0, 0x679f(%rip)      # 0xb198
jne 0x4adf
jmp 0x4a01
callq 0x4ee0
addsd %xmm0, %xmm0
movsd 0x35fe(%rip), %xmm1     # 0x8010
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x4ee0
addsd %xmm0, %xmm0
movsd 0x35e4(%rip), %xmm1     # 0x8010
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
movsd -0x30(%rbp), %xmm2
movsd -0x38(%rbp), %xmm1
mulsd -0x38(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd 0x35a5(%rip), %xmm1     # 0x8008
ucomisd %xmm1, %xmm0
jae 0x4a01
movsd -0x28(%rbp), %xmm0
callq 0x1060
movaps %xmm0, %xmm1
movsd 0x35aa(%rip), %xmm0     # 0x8028
mulsd %xmm1, %xmm0
divsd -0x28(%rbp), %xmm0
callq 0x1050
movsd %xmm0, -0x20(%rbp)
movsd -0x30(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x66fd(%rip)     # 0xb1a0
movl $0x1, 0x66eb(%rip)      # 0xb198
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x1050
movsd -0x40(%rbp), %xmm1
mulsd -0x38(%rbp), %xmm0
movsd -0x20(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x4b17
movl $0x0, 0x66af(%rip)      # 0xb198
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x1050
movsd -0x48(%rbp), %xmm1
movsd 0x6696(%rip), %xmm2     # 0xb1a0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genevalab[P]msmove/rand2t.c
// Function: init_genrand
void init_genrand(unsigned long s)
{
    mt[0] = s & 0xffffffffUL;
    for (mti = 1; mti < N; mti++) 
	{
        mt[mti] = (1812433253UL * (mt[mti - 1] ^ (mt[mti - 1] >> 30)) + mti); 
        /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
        /* In the previous versions, MSBs of the seed affect   */
        /* only MSBs of the array mt[].                        */
        /* 2002/01/09 modified by Makoto Matsumoto             */
        mt[mti] &= 0xffffffffUL;
        /* for >32 bit machines */
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x8(%rbp), %rax
movq %rax, 0x6663(%rip)      # 0xb1b0
movl $0x1, 0x6589(%rip)      # 0xb0e0
cmpl $0x270, 0x657f(%rip)    # imm = 0x270
jge 0x4bfa
movl 0x6573(%rip), %eax      # 0xb0e0
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x6636(%rip), %rax      # 0xb1b0
movq (%rax,%rcx,8), %rax
movl 0x655c(%rip), %ecx      # 0xb0e0
subl $0x1, %ecx
movslq %ecx, %rdx
leaq 0x661f(%rip), %rcx      # 0xb1b0
movq (%rcx,%rdx,8), %rcx
shrq $0x1e, %rcx
xorq %rcx, %rax
imulq $0x6c078965, %rax, %rdx # imm = 0x6C078965
movslq 0x6536(%rip), %rax      # 0xb0e0
addq %rax, %rdx
movslq 0x652c(%rip), %rcx      # 0xb0e0
leaq 0x65f5(%rip), %rax      # 0xb1b0
movq %rdx, (%rax,%rcx,8)
movslq 0x651a(%rip), %rcx      # 0xb0e0
leaq 0x65e3(%rip), %rax      # 0xb1b0
movabsq $0xffffffff, %rdx       # imm = 0xFFFFFFFF
andq (%rax,%rcx,8), %rdx
leaq 0x65ce(%rip), %rax      # 0xb1b0
movq %rdx, (%rax,%rcx,8)
movl 0x64f4(%rip), %eax      # 0xb0e0
addl $0x1, %eax
movl %eax, 0x64eb(%rip)      # 0xb0e0
jmp 0x4b57
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genevalab[P]msmove/streec.c
// Function: re
int re(int nsam)
{
	int el, lsg, lsgm1, ic, is;
	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;
	xover(nsam, ic, is);
	return ic;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
cvtsi2sdq 0x5d84(%rip), %xmm0 # 0xc558
movsd %xmm0, -0x30(%rbp)
callq 0x4ee0
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x5d4c(%rip), %eax      # 0xc550
jge 0x687b
movq 0x5d23(%rip), %rax      # 0xc530
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
movq 0x5d03(%rip), %rax      # 0xc530
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x8(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jg 0x6865
jmp 0x687b
movl -0x8(%rbp), %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x67fb
movq -0x28(%rbp), %rax
movl (%rax), %eax
addl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x4(%rbp), %edi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x7390
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genevalab[P]msmove/streec.c
// Function: cleftr
int cleftr(int nsam)
{
	int is;
	int ic = -1;
	double x, len;
	double sum = 0;
	struct seg *pseg;

	while ((x = cleft * genrand_real3()) == 0);
	while (sum < x)
		sum +=  1.0-pow(pc, links(++ic));
	pseg = chrom[ic].pseg;
	len = links(ic);
	is = (int)(pseg->beg+floor(1.0+log(1.0-(1.0-pow(pc, len))*genrand_real3())/lnpc)-1);
	xover(nsam, ic, is);
	return ic;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x5cae(%rip), %xmm0     # 0xc580
movsd %xmm0, -0x38(%rbp)
callq 0x4ee0
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x68fa
jp 0x68fa
jmp 0x68ca
jmp 0x68fc
movsd -0x28(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x6950
movsd 0x5c5c(%rip), %xmm0     # 0xc570
movsd %xmm0, -0x40(%rbp)
movl -0xc(%rbp), %edi
addl $0x1, %edi
movl %edi, -0xc(%rbp)
callq 0x7ac0
movsd -0x40(%rbp), %xmm0
cvtsi2sd %eax, %xmm1
callq 0x1150
movaps %xmm0, %xmm1
movsd 0x16c8(%rip), %xmm0     # 0x8008
subsd %xmm1, %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x68fc
movq 0x5bd9(%rip), %rax      # 0xc530
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %edi
callq 0x7ac0
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x30(%rbp), %rax
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd 0x5be0(%rip), %xmm0     # 0xc570
movsd -0x20(%rbp), %xmm1
callq 0x1150
movaps %xmm0, %xmm1
movsd 0x1663(%rip), %xmm0     # 0x8008
subsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
callq 0x4ee0
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm1, %xmm0
movsd 0x162a(%rip), %xmm1     # 0x8008
addsd %xmm1, %xmm0
callq 0x1060
movaps %xmm0, %xmm1
divsd 0x5b86(%rip), %xmm1     # 0xc578
movsd 0x160e(%rip), %xmm0     # 0x8008
addsd %xmm1, %xmm0
callq 0x1140
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd 0x15f1(%rip), %xmm1     # 0x8008
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl -0xc(%rbp), %esi
movl -0x8(%rbp), %edx
callq 0x7390
movl -0xc(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %edi
leaq -0x24(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x47c0
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jle 0x6c3f
movl -0x28(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x6c45
movl -0x24(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jle 0x6c5b
movl -0x24(%rbp), %eax
movl %eax, -0x40(%rbp)
jmp 0x6c61
movl -0x28(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x34(%rbp)
jmp 0x6c77
movq 0x58b2(%rip), %rax      # 0xc530
movslq -0x34(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
cmpl -0x4(%rbp), %eax
je 0x6c9c
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x6c77
movl -0x38(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jne 0x6ca6
jmp 0x6cba
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x6c75
movl -0x34(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x6cd7
movq 0x5852(%rip), %rax      # 0xc530
movslq -0x34(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
cmpl -0x4(%rbp), %eax
je 0x6cfc
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x6cd7
movl -0x38(%rbp), %eax
cmpl -0x30(%rbp), %eax
jne 0x6d06
jmp 0x6d1a
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x6cd5
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x49fb(%rip), %rax      # 0xc530
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq 0x49e4(%rip), %rax      # 0xc530
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
xorl %eax, %eax
cmpl -0x1c(%rbp), %ecx
movb %al, -0x29(%rbp)
jge 0x7b8c
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
setle %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x7b95
jmp 0x7bc7
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
cmpl -0x8(%rbp), %eax
jl 0x7bb8
movl $0x1, -0x4(%rbp)
jmp 0x7bce
jmp 0x7bba
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x7b5f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x10c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1282
leaq 0x7d91(%rip), %rdi      # 0x9004
callq 0x10d0
movl $0x2, %edi
callq 0x10e0
movq -0x28(%rbp), %rdi
addq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x10a0
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x820, %rsp            # imm = 0x820
movb $0x0, %al
callq 0x1200
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
leaq -0x810(%rbp), %rdi
movq 0xcd08(%rip), %rax      # 0xdfe0
movq (%rax), %rcx
movl $0x1, %esi
movl $0x800, %edx            # imm = 0x800
callq 0x1050
movq %rax, -0x818(%rbp)
cmpq $0x0, %rax
jbe 0x1310
leaq -0x810(%rbp), %rsi
movq -0x818(%rbp), %rdx
leaq -0x10(%rbp), %rdi
callq 0x1220
jmp 0x12ca
movq 0xccc9(%rip), %rax      # 0xdfe0
movq (%rax), %rdi
callq 0x1040
cmpl $0x0, %eax
je 0x133a
leaq 0x7cf3(%rip), %rdi      # 0x901e
callq 0x10d0
movl $0x3, %edi
callq 0x10e0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x820, %rsp            # imm = 0x820
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
leaq 0x7cbf(%rip), %rax      # 0x9033
movq %rax, -0x60(%rbp)
movl $0x0, -0x58(%rbp)
leaq -0x14(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x1, -0x48(%rbp)
leaq -0x60(%rbp), %rdi
addq $0x20, %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x1080
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rcx
leaq 0x895b(%rip), %rdx      # 0x9d0f
xorl %eax, %eax
movl %eax, %r8d
callq 0x1060
cmpl $-0x1, %eax
je 0x13c5
jmp 0x13a2
callq 0x12b0
movq %rax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
cmpl $0x0, -0x14(%rbp)
setne %al
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movzbl %al, %edx
andl $0x1, %edx
callq 0x7e60
leaq 0x891b(%rip), %rdi      # 0x9d0e
movb $0x0, %al
callq 0x1070
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x7f, %eax
jg 0x150f
movq -0x10(%rbp), %rdi
movzbl -0x11(%rbp), %esi
callq 0x1530
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x151a
movq -0x10(%rbp), %rax
movb $0x5, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: write_fixed_value
static bool write_fixed_value(cmp_ctx_t *ctx, uint8_t value) {
  if (write_byte(ctx, value))
    return true;

  ctx->error = FIXED_VALUE_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movzbl -0x11(%rbp), %esi
callq 0x7bc0
testb $0x1, %al
jne 0x1555
jmp 0x155b
movb $0x1, -0x1(%rbp)
jmp 0x1566
movq -0x10(%rbp), %rax
movb $0x6, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $-0x20, %eax
jl 0x15b8
movsbl -0x11(%rbp), %eax
cmpl $-0x1, %eax
jg 0x15b8
movq -0x10(%rbp), %rdi
movzbl -0x11(%rbp), %esi
callq 0x1530
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x15c3
movq -0x10(%rbp), %rax
movb $0x5, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: cmp_write_sfix
bool cmp_write_sfix(cmp_ctx_t *ctx, int8_t c) {
  if (c >= 0)
    return cmp_write_pfix(ctx, c);
  if (c >= -32 && c <= -1)
    return cmp_write_nfix(ctx, c);

  ctx->error = INPUT_VALUE_TOO_LARGE_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jl 0x15ff
movq -0x10(%rbp), %rdi
movzbl -0x11(%rbp), %esi
callq 0x14e0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1630
movsbl -0x11(%rbp), %eax
cmpl $-0x20, %eax
jl 0x1625
movsbl -0x11(%rbp), %eax
cmpl $-0x1, %eax
jg 0x1625
movq -0x10(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0x1580
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1630
movq -0x10(%rbp), %rax
movb $0x5, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: write_type_marker
static bool write_type_marker(cmp_ctx_t *ctx, uint8_t marker) {
  if (write_byte(ctx, marker))
    return true;

  ctx->error = TYPE_MARKER_WRITING_ERROR;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movzbl -0x11(%rbp), %esi
callq 0x7bc0
testb $0x1, %al
jne 0x16c5
jmp 0x16cb
movb $0x1, -0x1(%rbp)
jmp 0x16d6
movq -0x10(%rbp), %rax
movb $0x8, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
movl $0xd1, %esi
callq 0x16a0
testb $0x1, %al
jne 0x171b
movb $0x0, -0x1(%rbp)
jmp 0x174b
movzwl -0x12(%rbp), %edi
callq 0x1760
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
leaq -0x12(%rbp), %rsi
movl $0x2, %edx
callq *%rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: be16
static uint16_t be16(uint16_t x) {
  char *b = (char *)&x;

  if (!is_bigendian()) {
    char swap = 0;

    swap = b[0];
    b[0] = b[1];
    b[1] = swap;
  }

  return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x2(%rbp)
leaq -0x2(%rbp), %rax
movq %rax, -0x10(%rbp)
movsbl 0x8296(%rip), %eax      # 0x9a10
cmpl $0x0, %eax
je 0x17a3
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movb 0x1(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movw -0x2(%rbp), %ax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0xd2, %esi
callq 0x16a0
testb $0x1, %al
jne 0x17d7
movb $0x0, -0x1(%rbp)
jmp 0x1805
movl -0x14(%rbp), %edi
callq 0x1810
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
movl $0x4, %edx
callq *%rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: be32
static uint32_t be32(uint32_t x) {
  char *b = (char *)&x;

  if (!is_bigendian()) {
    char swap = 0;

    swap = b[0];
    b[0] = b[3];
    b[3] = swap;

    swap = b[1];
    b[1] = b[2];
    b[2] = swap;
  }

  return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
leaq -0x4(%rbp), %rax
movq %rax, -0x10(%rbp)
movsbl 0x81ea(%rip), %eax      # 0x9a10
cmpl $0x0, %eax
je 0x1871
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movb 0x3(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x10(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movb 0x2(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0xd3, %esi
callq 0x16a0
testb $0x1, %al
jne 0x18a8
movb $0x0, -0x1(%rbp)
jmp 0x18d8
movq -0x18(%rbp), %rdi
callq 0x18f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x8, %edx
callq *%rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BatchLabs[P]msgpack-dump/src/cmp.c
// Function: be64
static uint64_t be64(uint64_t x) {
  char *b = (char *)&x;

  if (!is_bigendian()) {
    char swap = 0;

    swap = b[0];
    b[0] = b[7];
    b[7] = swap;

    swap = b[1];
    b[1] = b[6];
    b[6] = swap;

    swap = b[2];
    b[2] = b[5];
    b[5] = swap;

    swap = b[3];
    b[3] = b[4];
    b[4] = swap;
  }

  return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
leaq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movsbl 0x8109(%rip), %eax      # 0x9a10
cmpl $0x0, %eax
je 0x199a
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movb 0x7(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x7(%rax)
movq -0x10(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movb 0x6(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x6(%rax)
movq -0x10(%rbp), %rax
movb 0x2(%rax), %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movb 0x5(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0x10(%rbp), %rax
movb 0x3(%rax), %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movb 0x4(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x19ce
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1a70
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1a5d
cmpq $-0x20, -0x18(%rbp)
jl 0x19ec
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movsbl %al, %esi
callq 0x1580
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1a5d
cmpq $-0x80, -0x18(%rbp)
jl 0x1a0a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movsbl %al, %esi
callq 0x1640
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1a5d
cmpq $-0x8000, -0x18(%rbp)   # imm = 0x8000
jl 0x1a2b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movswl %ax, %esi
callq 0x16f0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1a5d
cmpq $-0x80000000, -0x18(%rbp) # imm = 0x80000000
jl 0x1a4b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %esi
callq 0x17b0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1a5d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1880
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x7f, -0x18(%rbp)
ja 0x1a9e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movzbl %al, %esi
callq 0x14e0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1b13
cmpq $0xff, -0x18(%rbp)
ja 0x1abf
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movzbl %al, %esi
callq 0x1b50
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1b13
cmpq $0xffff, -0x18(%rbp)    # imm = 0xFFFF
ja 0x1ae0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movzwl %ax, %esi
callq 0x1bb0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1b13
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x18(%rbp)
ja 0x1b01
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %esi
callq 0x1c20
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1b13
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c80
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
movl $0xcd, %esi
callq 0x16a0
testb $0x1, %al
jne 0x1bdb
movb $0x0, -0x1(%rbp)
jmp 0x1c0b
movzwl -0x12(%rbp), %edi
callq 0x1760
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
leaq -0x12(%rbp), %rsi
movl $0x2, %edx
callq *%rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0xce, %esi
callq 0x16a0
testb $0x1, %al
jne 0x1c47
movb $0x0, -0x1(%rbp)
jmp 0x1c75
movl -0x14(%rbp), %edi
callq 0x1810
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
movl $0x4, %edx
callq *%rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0xcf, %esi
callq 0x16a0
testb $0x1, %al
jne 0x1ca8
movb $0x0, -0x1(%rbp)
jmp 0x1cd8
movq -0x18(%rbp), %rdi
callq 0x18f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x8, %edx
callq *%rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0xca, %esi
callq 0x16a0
testb $0x1, %al
jne 0x1d1c
movb $0x0, -0x1(%rbp)
jmp 0x1db1
movsbl 0x7ced(%rip), %eax      # 0x9a10
cmpl $0x0, %eax
je 0x1d8e
leaq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x4, -0x28(%rbp)
jae 0x1d69
movq -0x20(%rbp), %rax
movl $0x4, %ecx
subq -0x28(%rbp), %rcx
subq $0x1, %rcx
movb (%rax,%rcx), %cl
movq -0x28(%rbp), %rax
movb %cl, -0x18(%rbp,%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1d38
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x4, %edx
callq *%rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1db1
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
movl $0x4, %edx
callq *%rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0xcb, %esi
callq 0x16a0
testb $0x1, %al
jne 0x1dec
movb $0x0, -0x1(%rbp)
jmp 0x1e81
movsbl 0x7c1d(%rip), %eax      # 0x9a10
cmpl $0x0, %eax
je 0x1e5e
leaq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x8, -0x30(%rbp)
jae 0x1e39
movq -0x28(%rbp), %rax
movl $0x8, %ecx
subq -0x30(%rbp), %rcx
subq $0x1, %rcx
movb (%rax,%rcx), %cl
movq -0x30(%rbp), %rax
movb %cl, -0x20(%rbp,%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1e08
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x8, %edx
callq *%rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1e81
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x8, %edx
callq *%rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
ucomisd -0x18(%rbp), %xmm0
jne 0x1ee0
jp 0x1ee0
movq -0x10(%rbp), %rdi
movss -0x1c(%rbp), %xmm0
callq 0x1cf0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1ef3
movq -0x10(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
callq 0x1dc0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x1f, %eax
jg 0x2067
movq -0x10(%rbp), %rdi
movzbl -0x11(%rbp), %eax
orl $0xa0, %eax
movzbl %al, %esi
callq 0x1530
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2072
movq -0x10(%rbp), %rax
movb $0x5, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movzbl -0x19(%rbp), %esi
callq 0x2030
testb $0x1, %al
jne 0x20ac
movb $0x0, -0x1(%rbp)
jmp 0x20ea
movzbl -0x19(%rbp), %eax
cmpl $0x0, %eax
jne 0x20bb
movb $0x1, -0x1(%rbp)
jmp 0x20ea
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movzbl -0x19(%rbp), %ecx
movl %ecx, %edx
callq *%rax
cmpq $0x0, %rax
je 0x20df
movb $0x1, -0x1(%rbp)
jmp 0x20ea
movq -0x10(%rbp), %rax
movb $0xa, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movl $0xd9, %esi
callq 0x16a0
testb $0x1, %al
jne 0x212a
movb $0x0, -0x1(%rbp)
jmp 0x2158
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
callq *%rax
cmpq $0x0, %rax
je 0x214d
movb $0x1, -0x1(%rbp)
jmp 0x2158
movq -0x10(%rbp), %rax
movb $0xf, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movzbl -0x19(%rbp), %esi
callq 0x2100
testb $0x1, %al
jne 0x219c
movb $0x0, -0x1(%rbp)
jmp 0x21da
movzbl -0x19(%rbp), %eax
cmpl $0x0, %eax
jne 0x21ab
movb $0x1, -0x1(%rbp)
jmp 0x21da
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movzbl -0x19(%rbp), %ecx
movl %ecx, %edx
callq *%rax
cmpq $0x0, %rax
je 0x21cf
movb $0x1, -0x1(%rbp)
jmp 0x21da
movq -0x10(%rbp), %rax
movb $0xa, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
movl $0xda, %esi
callq 0x16a0
testb $0x1, %al
jne 0x221b
movb $0x0, -0x1(%rbp)
jmp 0x2256
movzwl -0x12(%rbp), %edi
callq 0x1760
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
leaq -0x12(%rbp), %rsi
movl $0x2, %edx
callq *%rax
cmpq $0x0, %rax
je 0x224b
movb $0x1, -0x1(%rbp)
jmp 0x2256
movq -0x10(%rbp), %rax
movb $0xf, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movw %dx, %ax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x1a(%rbp), %esi
callq 0x21f0
testb $0x1, %al
jne 0x229e
movb $0x0, -0x1(%rbp)
jmp 0x22dc
movzwl -0x1a(%rbp), %eax
cmpl $0x0, %eax
jne 0x22ad
movb $0x1, -0x1(%rbp)
jmp 0x22dc
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movzwl -0x1a(%rbp), %ecx
movl %ecx, %edx
callq *%rax
cmpq $0x0, %rax
je 0x22d1
movb $0x1, -0x1(%rbp)
jmp 0x22dc
movq -0x10(%rbp), %rax
movb $0xa, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0xdb, %esi
callq 0x16a0
testb $0x1, %al
jne 0x2317
movb $0x0, -0x1(%rbp)
jmp 0x2350
movl -0x14(%rbp), %edi
callq 0x1810
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
movl $0x4, %edx
callq *%rax
cmpq $0x0, %rax
je 0x2345
movb $0x1, -0x1(%rbp)
jmp 0x2350
movq -0x10(%rbp), %rax
movb $0xf, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x22f0
testb $0x1, %al
jne 0x2389
movb $0x0, -0x1(%rbp)
jmp 0x23c3
cmpl $0x0, -0x1c(%rbp)
jne 0x2395
movb $0x1, -0x1(%rbp)
jmp 0x23c3
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
callq *%rax
cmpq $0x0, %rax
je 0x23b8
movb $0x1, -0x1(%rbp)
jmp 0x23c3
movq -0x10(%rbp), %rax
movb $0xa, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x1f, -0x14(%rbp)
ja 0x23fb
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movzbl %al, %esi
callq 0x2030
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x244a
cmpl $0xff, -0x14(%rbp)
ja 0x241a
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movzbl %al, %esi
callq 0x2100
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x244a
cmpl $0xffff, -0x14(%rbp)    # imm = 0xFFFF
ja 0x2439
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movzwl %ax, %esi
callq 0x21f0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x244a
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x22f0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x1f, -0x14(%rbp)
ja 0x248b
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movzbl %al, %esi
callq 0x2030
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x24bb
cmpl $0xffff, -0x14(%rbp)    # imm = 0xFFFF
ja 0x24aa
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movzwl %ax, %esi
callq 0x21f0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x24bb
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x22f0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x1f, -0x1c(%rbp)
ja 0x2503
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
movzbl %al, %edx
callq 0x2080
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x255e
cmpl $0xff, -0x1c(%rbp)
ja 0x2526
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
movzbl %al, %edx
callq 0x2170
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x255e
cmpl $0xffff, -0x1c(%rbp)    # imm = 0xFFFF
ja 0x2549
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
movzwl %ax, %edx
callq 0x2270
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x255e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x2360
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x1f, -0x1c(%rbp)
ja 0x25a3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
movzbl %al, %edx
callq 0x2080
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x25db
cmpl $0xffff, -0x1c(%rbp)    # imm = 0xFFFF
ja 0x25c6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
movzwl %ax, %edx
callq 0x2270
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x25db
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x2360
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)