LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genevalab[P]msmove/ms.c
// Function: cmatrix
char **cmatrix(int nsam, int len)
{
	int i;
	char **m;
	if (!(m = (char**)malloc((size_t)nsam*sizeof(char*))))
		perror("alloc error in cmatrix");
	for (i=0; i < nsam; i++)
		if (!(m[i] = (char*)malloc((size_t)len*sizeof(char))))
			perror("alloc error in cmatric. 2");
	return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
movl %edi, %ebx
movslq %edi, %rdi
shlq $0x3, %rdi
callq 0x1100
movq %rax, %r14
testq %rax, %rax
je 0x260b
movslq %r15d, %r15
xorl %r13d, %r13d
testl %ebx, %ebx
cmovlel %r13d, %ebx
leaq 0x3be8(%rip), %r12      # 0x61bc
cmpq %r13, %rbx
je 0x25f9
movq %r15, %rdi
callq 0x1100
movq %rax, (%r14,%r13,8)
testq %rax, %rax
je 0x25ef
incq %r13
jmp 0x25d4
movq %r12, %rdi
callq 0x1070
jmp 0x25ea
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3b93(%rip), %rdi      # 0x61a5
callq 0x1070
jmp 0x25c1
// File: /workspace/github_c_makefile_star2_O2/genevalab[P]msmove/ms.c
// Function: prtree
void prtree(struct node *ptree, int nsam)
{
	int i;
	int *descl = (int*)malloc((size_t)(2*nsam-1)*sizeof(int));
	int *descr = (int*)malloc((size_t)(2*nsam-1)*sizeof(int));

	for (i=0; i < 2*nsam-1; i++)
		descl[i] = descr[i] = -1;
	for (i=0; i <  2*nsam-2; i++)
	{
		if (descl[(ptree+i)->abv] == -1)
			descl[(ptree+i)->abv] = i;
		else
			descr[(ptree+i)->abv] = i;
	}
	parens(ptree, descl, descr, 2*nsam-2);
	free(descl);
	free(descr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leal -0x1(,%rsi,2), %r13d
movl %esi, %r14d
addl %esi, %r14d
movslq %r14d, %rax
leaq -0x4(,%rax,4), %r12
movq %r12, %rdi
callq 0x1100
movq %rax, %r15
movq %r12, %rdi
callq 0x1100
movq %rax, %r12
xorl %eax, %eax
testl %r13d, %r13d
cmovlel %eax, %r13d
cmpq %rax, %r13
je 0x2e2b
orl $-0x1, (%r12,%rax,4)
orl $-0x1, (%r15,%rax,4)
incq %rax
jmp 0x2e17
addl $-0x2, %r14d
xorl %eax, %eax
testl %r14d, %r14d
movl $0x0, %ecx
cmovgl %r14d, %ecx
movq %rbx, %rdx
cmpq %rax, %rcx
je 0x2e60
movslq (%rdx), %rsi
cmpl $-0x1, (%r15,%rsi,4)
movq %r12, %rdi
cmoveq %r15, %rdi
movl %eax, (%rdi,%rsi,4)
incq %rax
addq $0x10, %rdx
jmp 0x2e40
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %r14d, %ecx
callq 0x3735
movq %r15, %rdi
callq 0x10c0
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10c0
// File: /workspace/github_c_makefile_star2_O2/genevalab[P]msmove/ms.c
// Function: ndes_setup
void ndes_setup(struct node *ptree, int nsam)
{
	int i;
	for (i=0; i < nsam; i++)
		(ptree + i)->ndes = 1;
	for (i=nsam; i < 2*nsam-1; i++)
		(ptree+i)->ndes = 0;
	for (i=0; i < 2*nsam-2; i++)
		(ptree+((ptree+i)->abv))->ndes += (ptree+i)->ndes;
}

// Assembly:
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ecx
cmovgl %esi, %ecx
shlq $0x4, %rcx
cmpq %rax, %rcx
je 0x2eb2
movl $0x1, 0x4(%rdi,%rax)
addq $0x10, %rax
jmp 0x2e9f
pushq %rbp
movq %rsp, %rbp
leal (%rsi,%rsi), %eax
leal -0x1(%rsi,%rsi), %edx
movslq %esi, %rcx
movslq %edx, %rdx
movq %rcx, %rsi
shlq $0x4, %rsi
addq %rdi, %rsi
addq $0x4, %rsi
cmpq %rdx, %rcx
jge 0x2ee2
andl $0x0, (%rsi)
incq %rcx
addq $0x10, %rsi
jmp 0x2ed1
cmpl $0x3, %eax
movl $0x2, %ecx
cmovgel %eax, %ecx
addl $-0x2, %ecx
shlq $0x4, %rcx
xorl %eax, %eax
popq %rbp
cmpq %rax, %rcx
je 0x2f12
movl 0x4(%rdi,%rax), %edx
movslq (%rdi,%rax), %rsi
shlq $0x4, %rsi
addl %edx, 0x4(%rdi,%rsi)
addq $0x10, %rax
jmp 0x2ef7
retq
// File: /workspace/github_c_makefile_star2_O2/genevalab[P]msmove/ms.c
// Function: ttime
double ttime(struct node *ptree, int nsam)
{
	int i;
	double t = (ptree+2*nsam-2)->time;

	for (i=nsam; i < 2*nsam-1; i++)
		t += (ptree+i)->time;
	
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leal (%rsi,%rsi), %eax
cltq
shlq $0x4, %rax
movsd -0x18(%rdi,%rax), %xmm0
leal -0x1(,%rsi,2), %ecx
movslq %esi, %rax
movslq %ecx, %rcx
movq %rax, %rdx
shlq $0x4, %rdx
addq %rdi, %rdx
addq $0x8, %rdx
cmpq %rcx, %rax
jge 0x2f53
addsd (%rdx), %xmm0
incq %rax
addq $0x10, %rdx
jmp 0x2f41
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genevalab[P]msmove/ms.c
// Function: ttimemf
double ttimemf(struct node *ptree, int nsam, int mfreq)
{
	int i;
	double t = 0;

	for (i=0; i < 2*nsam-2; i++)
		if (((ptree+i)->ndes >= mfreq) && ((ptree+i)->ndes <= nsam - mfreq))
			t += (ptree+(ptree+i)->abv)->time - (ptree+i)->time;
	
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leal (%rsi,%rsi), %ecx
subl %edx, %esi
cmpl $0x3, %ecx
movl $0x2, %eax
cmovgel %ecx, %eax
addl $-0x2, %eax
shlq $0x4, %rax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x2fb2
movl 0x4(%rdi,%rcx), %r8d
cmpl %edx, %r8d
setl %r9b
cmpl %esi, %r8d
setg %r8b
orb %r9b, %r8b
jne 0x2fac
movslq (%rdi,%rcx), %r8
shlq $0x4, %r8
movsd 0x8(%rdi,%r8), %xmm1
subsd 0x8(%rdi,%rcx), %xmm1
addsd %xmm1, %xmm0
addq $0x10, %rcx
jmp 0x2f76
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genevalab[P]msmove/ms.c
// Function: poisso
int poisso(double u)
{
	int i = 1;
	double cump, ru, p;

	if (u > 30.0)
	{
		i = (int)(0.5+gasdev(u,u));
		if (i < 0)
			return 0;
		else
			return i;
	} 
	ru = genrand_real3();
	p = exp(-u);
	if (ru < p)
		return 0;
	cump = p;
	while (ru > (cump += (p *= u/i)) )
		i++;
	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
ucomisd 0x3054(%rip), %xmm0     # 0x6018
jbe 0x2fe4
movapd %xmm0, %xmm1
callq 0x3959
addsd 0x3049(%rip), %xmm0     # 0x6020
cvttsd2si %xmm0, %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovgl %ecx, %eax
jmp 0x3039
movapd %xmm0, -0x20(%rbp)
callq 0x3ca9
movsd %xmm0, -0x8(%rbp)
movapd 0x3055(%rip), %xmm0     # 0x6050
xorpd -0x20(%rbp), %xmm0
callq 0x1180
movsd -0x8(%rbp), %xmm5
movapd -0x20(%rbp), %xmm4
xorl %eax, %eax
ucomisd %xmm5, %xmm0
ja 0x3039
xorl %eax, %eax
movapd %xmm0, %xmm1
incl %eax
cvtsi2sd %eax, %xmm2
movapd %xmm4, %xmm3
divsd %xmm2, %xmm3
mulsd %xmm3, %xmm1
addsd %xmm1, %xmm0
ucomisd %xmm0, %xmm5
ja 0x301d
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genevalab[P]msmove/ms.c
// Function: biggerlist
int biggerlist(int nsam, char **list)
{
	int i;
	for (i=0; i < nsam; i++)
	{
		list[i] = (char*)realloc(list[i], (size_t)maxsites*sizeof(char));
		if (list[i] == NULL)
			perror("realloc error. bigger");
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %r14d
xorl %r12d, %r12d
testl %edi, %edi
cmovlel %r12d, %r14d
leaq 0x312f(%rip), %r15      # 0x618f
cmpq %r12, %r14
je 0x308c
movq (%rbx,%r12,8), %rdi
movl 0x6079(%rip), %esi      # 0x90e8
callq 0x1150
movq %rax, (%rbx,%r12,8)
testq %rax, %rax
je 0x3082
incq %r12
jmp 0x3060
movq %r15, %rdi
callq 0x1070
jmp 0x307d
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genevalab[P]msmove/ms.c
// Function: make_gametes
int make_gametes(int nsam, int mfreq, struct node *ptree, double tt, int newsites, int ns, char **list)
{
	int tip, j, node;

	for (j=ns; j < ns+newsites; j++)
	{
		if (mfreq == 1)
			node = pickb(nsam, ptree, tt);
		else
			node = pickbmf(nsam, mfreq, ptree, tt);
		for (tip=0; tip < nsam; tip++)
		{
			if (tdesn(ptree, tip, node))
				list[tip][j] = STATE1;
			else
				list[tip][j] = STATE2;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, -0x48(%rbp)
movsd %xmm0, -0x38(%rbp)
movq %rdx, %r14
addl %r8d, %ecx
xorl %r15d, %r15d
testl %edi, %edi
movl %edi, -0x2c(%rbp)
cmovgl %edi, %r15d
movslq %r8d, %rbx
movslq %ecx, %rax
movq %rax, -0x40(%rbp)
movl %esi, -0x30(%rbp)
cmpq -0x40(%rbp), %rbx
jge 0x3135
cmpl $0x1, %esi
jne 0x30ed
movl -0x2c(%rbp), %edi
movq %r14, %rsi
movsd -0x38(%rbp), %xmm0
callq 0x360e
jmp 0x30fd
movl -0x2c(%rbp), %edi
movq %r14, %rdx
movsd -0x38(%rbp), %xmm0
callq 0x3682
movl %eax, %r13d
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x312d
movq %r14, %rdi
movl %r12d, %esi
movl %r13d, %edx
callq 0x3719
testl %eax, %eax
sete %al
movq -0x48(%rbp), %rcx
movq (%rcx,%r12,8), %rcx
xorb $0x31, %al
movb %al, (%rcx,%rbx)
incq %r12
jmp 0x3103
incq %rbx
movl -0x30(%rbp), %esi
jmp 0x30d0
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genevalab[P]msmove/ms.c
// Function: locate
int locate(int n, double beg, double len, double *ptr)
{
	int i;
	ordran(n, ptr);
	for (i=0; i < n; i++)
		ptr[i] = beg+ptr[i]*len;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movsd %xmm1, -0x20(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %edi, %r14d
callq 0x321f
movsd -0x18(%rbp), %xmm2
movsd -0x20(%rbp), %xmm1
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
cmpq %rax, %r14
je 0x3195
movsd (%rbx,%rax,8), %xmm0
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
movsd %xmm0, (%rbx,%rax,8)
incq %rax
jmp 0x3179
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genevalab[P]msmove/ms.c
// Function: mnmial
int mnmial(int n, int nclass, double p[], int rv[])
{
	int i, j;
	double x, s;

	for (i=0; i < nclass; i++)
		rv[i] = 0;
	for (i=0; i < n; i++)
	{
		x = genrand_real3();
		j = 0;
		s = p[0];
		while ((x > s) && (j < (nclass-1)))
			s += p[++j];
		rv[j]++;
	}
	return j;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %edi, %r15d
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ecx
cmovgl %esi, %ecx
cmpq %rax, %rcx
je 0x31d1
andl $0x0, (%rbx,%rax,4)
incq %rax
jmp 0x31c3
decl %esi
movslq %esi, %r12
xorl %r13d, %r13d
testl %r15d, %r15d
cmovlel %r13d, %r15d
cmpl %r15d, %r13d
je 0x3210
callq 0x3ca9
movsd (%r14), %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
jbe 0x3208
cmpq %r12, %rax
jge 0x3208
addsd 0x8(%r14,%rax,8), %xmm1
incq %rax
jmp 0x31f1
incl (%rbx,%rax,4)
incl %r13d
jmp 0x31e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genevalab[P]msmove/ms.c
// Function: free_eventlist
void free_eventlist(struct devent *pt, int npop)
{
	int pop;
	struct devent *next;
   
	while (pt != 0)
	{
		next = pt->nextde;
		if (pt->detype == 'a')
		{
			for (pop=0; pop < npop; pop++)
				free((pt->mat)[pop]);
			free(pt->mat);
		}
		free(pt);
		pt = next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %ebx
testq %r14, %r14
je 0x3587
movq 0x30(%r14), %r15
cmpb $0x61, 0x28(%r14)
jne 0x357a
xorl %r12d, %r12d
movq 0x20(%r14), %rdi
cmpq %r12, %rbx
je 0x3575
movq (%rdi,%r12,8), %rdi
callq 0x10c0
incq %r12
jmp 0x355e
callq 0x10c0
movq %r14, %rdi
callq 0x10c0
movq %r15, %r14
jmp 0x354b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genevalab[P]msmove/ms.c
// Function: argcheck
void argcheck(int arg, int argc, char *argv[])
{
	if ((arg >= argc ) || (argv[arg][0] == '-'))
	{
		fprintf(stderr, "not enough arguments after %s\n", argv[arg-1]);
		fprintf(stderr, "For usage type: msmove<return>\n");
		exit(EXIT_FAILURE);
	}
}

// Assembly:
movslq %edi, %rax
cmpl %esi, %edi
jge 0x35a1
movq (%rdx,%rax,8), %rcx
cmpb $0x2d, (%rcx)
je 0x35a1
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x5a32(%rip), %rbx      # 0x8fe0
movq (%rbx), %rdi
movq -0x8(%rdx,%rax,8), %rdx
leaq 0x2e3f(%rip), %rsi      # 0x63fc
xorl %eax, %eax
callq 0x1130
movq (%rbx), %rcx
leaq 0x2e4d(%rip), %rdi      # 0x641b
pushq $0x1f
popq %rsi
pushq $0x1
popq %rdx
callq 0x11a0
pushq $0x1
popq %rdi
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O2/genevalab[P]msmove/ms.c
// Function: addtoelist
void addtoelist(struct devent *pt, struct devent *elist) 
{
	struct devent *plast, *pevent, *ptemp;

	pevent = elist;
	while ((pevent != 0) && (pevent->time <= pt->time))
	{
		plast = pevent;
		pevent = pevent->nextde;
	}
	ptemp = plast->nextde;
	plast->nextde = pt;
	pt->nextde = ptemp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
je 0x3600
movq %rsi, %rcx
movsd (%rdi), %xmm0
ucomisd (%rsi), %xmm0
jb 0x3600
movq 0x30(%rcx), %rsi
movq %rcx, %rax
jmp 0x35e5
movq 0x30(%rax), %rcx
movq %rdi, 0x30(%rax)
movq %rcx, 0x30(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genevalab[P]msmove/ms.c
// Function: pickb
int pickb(int nsam, struct node *ptree, double tt)
{
	int i;
	double y = 0;
	double x = genrand_real3()*tt;

	for (i=0; i < 2*nsam-2; i++)
	{
		y += (ptree+(ptree+i)->abv)->time - (ptree+i)->time;
		if (y >= x)
			return i;
	}

	return 2*nsam-3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, -0x18(%rbp)
movq %rsi, %r14
movl %edi, %ebx
callq 0x3ca9
mulsd -0x18(%rbp), %xmm0
addl %ebx, %ebx
cmpl $0x3, %ebx
pushq $0x2
popq %rax
cmovgel %ebx, %eax
addl $-0x2, %eax
leaq 0x8(%r14), %rdx
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x3670
movslq -0x8(%rdx), %rsi
shlq $0x4, %rsi
movsd 0x8(%r14,%rsi), %xmm2
subsd (%rdx), %xmm2
addsd %xmm2, %xmm1
ucomisd %xmm0, %xmm1
jae 0x3675
incq %rcx
addq $0x10, %rdx
jmp 0x3645
addl $-0x3, %ebx
jmp 0x3677
movl %ecx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genevalab[P]msmove/ms.c
// Function: pickbmf
int pickbmf(int nsam, int mfreq, struct node *ptree, double tt)
{
	int i;
	int lastbranch = 0;
	double x = genrand_real3()*tt;
	double y = 0;

	for (i=0; i < 2*nsam-2; i++)
	{
		if (((ptree+i)->ndes >= mfreq) && ((ptree+i)->ndes <= nsam - mfreq))
		{
			y += (ptree+(ptree+i)->abv)->time - (ptree+i)->time;
			lastbranch = i;
		}
		if (y >= x)
			return i;
	}

	return lastbranch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, -0x20(%rbp)
movq %rdx, %rbx
movl %esi, %r14d
movl %edi, %r15d
callq 0x3ca9
mulsd -0x20(%rbp), %xmm0
leal (%r15,%r15), %eax
subl %r14d, %r15d
cmpl $0x3, %eax
pushq $0x2
popq %rcx
cmovgel %eax, %ecx
addl $-0x2, %ecx
leaq 0x8(%rbx), %rdx
xorpd %xmm1, %xmm1
xorl %esi, %esi
xorl %edi, %edi
cmpq %rsi, %rcx
je 0x370c
movl -0x4(%rdx), %eax
cmpl %r14d, %eax
setl %r8b
cmpl %r15d, %eax
setg %al
orb %r8b, %al
cmpb $0x1, %al
jne 0x36e3
movl %esi, %eax
jmp 0x36fd
movslq -0x8(%rdx), %rax
shlq $0x4, %rax
movsd 0x8(%rbx,%rax), %xmm2
subsd (%rdx), %xmm2
addsd %xmm2, %xmm1
movl %esi, %eax
movl %esi, %edi
incq %rsi
addq $0x10, %rdx
ucomisd %xmm0, %xmm1
jb 0x36c3
jmp 0x370e
movl %edi, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genevalab[P]msmove/ms.c
// Function: parens
void parens(struct node *ptree, int *descl, int *descr, int noden)
{
	double time;

	if (descl[noden] == -1)
		fprintf(stdout, "%d:%5.3lf", noden+1, (ptree+((ptree+noden)->abv))->time);
	else
	{
		fprintf(stdout, "(");
		parens(ptree, descl, descr, descl[noden]);
		fprintf(stdout, ",");
		parens(ptree, descl, descr, descr[noden]);
		if ((ptree+noden)->abv == 0)
			fprintf(stdout, ");\n"); 
		else
		{
			time = (ptree+(ptree+noden)->abv)->time - (ptree+noden)->time;
			fprintf(stdout, "):%5.3lf", time);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movslq %ecx, %r12
cmpl $-0x1, (%rsi,%r12,4)
movq 0x5870(%rip), %r13      # 0x8fc8
movq (%r13), %rsi
je 0x37da
movq %rdx, %r14
pushq $0x28
popq %rdi
callq 0x10f0
movl (%r15,%r12,4), %ecx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3735
movq (%r13), %rsi
pushq $0x2c
popq %rdi
callq 0x10f0
movl (%r14,%r12,4), %ecx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3735
shlq $0x4, %r12
movslq (%rbx,%r12), %rax
testq %rax, %rax
je 0x3813
addq %rbx, %r12
shlq $0x4, %rax
movsd 0x8(%rbx,%rax), %xmm0
subsd 0x8(%r12), %xmm0
movq (%r13), %rdi
leaq 0x34ea(%rip), %rsi      # 0x6caf
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1130
leal 0x1(%r12), %edx
shlq $0x4, %r12
movslq (%rbx,%r12), %rax
shlq $0x4, %rax
movsd 0x8(%rbx,%rax), %xmm0
leaq 0x34a9(%rip), %rax      # 0x6ca1
movq %rsi, %rdi
movq %rax, %rsi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1130
movq (%r13), %rcx
leaq 0x348d(%rip), %rdi      # 0x6cab
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11a0
// File: /workspace/github_c_makefile_star2_O2/genevalab[P]msmove/ms.c
// Function: ranvec
int ranvec(int n, double pbuf[])
{
	int i;
	for (i=0; i < n; i++)
		pbuf[i] = genrand_real3();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
xorl %r15d, %r15d
testl %edi, %edi
cmovlel %r15d, %r14d
cmpq %r15, %r14
je 0x38b0
callq 0x3ca9
movsd %xmm0, (%rbx,%r15,8)
incq %r15
jmp 0x389b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genevalab[P]msmove/ms.c
// Function: order
int order(int n, double pbuf[])
{
	int gap, i, j;
	double temp;

	for (gap=n/2; gap > 0; gap /= 2)
		for (i=gap; i < n; i++)
			for (j=i-gap; j >= 0 && pbuf[j] > pbuf[j+gap]; j -= gap)
			{
				temp = pbuf[j];
				pbuf[j] = pbuf[j+gap];
				pbuf[j+gap] = temp;
			}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x2, %ecx
movl %edi, %eax
cltd
idivl %ecx
testl %eax, %eax
jle 0x3916
xorl %ecx, %ecx
movl %eax, %edx
cmpl %edi, %edx
jge 0x3912
movl %ecx, %r8d
testl %r8d, %r8d
js 0x390c
leal (%rax,%r8), %r10d
movl %r8d, %r9d
movsd (%rsi,%r9,8), %xmm0
movl %r10d, %r10d
movsd (%rsi,%r10,8), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x390c
movsd %xmm1, (%rsi,%r9,8)
movsd %xmm0, (%rsi,%r10,8)
subl %eax, %r8d
jmp 0x38da
incl %edx
incl %ecx
jmp 0x38d3
shrl %eax
jmp 0x38cb
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genevalab[P]msmove/ms.c
// Function: dbinom
int dbinom(int n, double p)
{
	int i, s;
	for (i=0, s=0; i < n; i++) 
		if (genrand_real3() <= p)
			++s;
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, -0x18(%rbp)
movl %edi, %r14d
xorl %ebx, %ebx
testl %edi, %edi
cmovlel %ebx, %r14d
subl $0x1, %r14d
jb 0x394e
callq 0x3ca9
movsd -0x18(%rbp), %xmm1
ucomisd %xmm0, %xmm1
sbbl $-0x1, %ebx
jmp 0x3935
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x30, %rsp
movapd %xmm0, %xmm2
cmpb $0x0, 0x581c(%rip)      # 0x9188
je 0x398c
movb $0x0, 0x5813(%rip)      # 0x9188
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x3a14
sqrtsd %xmm1, %xmm0
jmp 0x3a27
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x10(%rbp)
callq 0x3ca9
movapd %xmm0, %xmm1
addsd %xmm0, %xmm1
movsd 0x267d(%rip), %xmm0     # 0x6028
addsd %xmm0, %xmm1
movsd %xmm1, -0x8(%rbp)
callq 0x3ca9
movsd -0x8(%rbp), %xmm3
addsd %xmm0, %xmm0
addsd 0x265e(%rip), %xmm0     # 0x6028
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm3, %xmm3
addsd %xmm1, %xmm3
ucomisd 0x2626(%rip), %xmm3     # 0x6008
jae 0x3996
movsd %xmm0, -0x28(%rbp)
movapd %xmm3, %xmm0
movsd %xmm3, -0x20(%rbp)
callq 0x1060
mulsd 0x2631(%rip), %xmm0     # 0x6030
divsd -0x20(%rbp), %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jb 0x3a35
sqrtsd %xmm0, %xmm3
jmp 0x3a42
movapd %xmm1, %xmm0
movsd %xmm2, -0x10(%rbp)
callq 0x1050
movsd -0x10(%rbp), %xmm2
mulsd 0x5761(%rip), %xmm0     # 0x9190
addsd %xmm2, %xmm0
jmp 0x3a94
callq 0x1050
xorpd %xmm2, %xmm2
movapd %xmm0, %xmm3
movsd -0x18(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
mulsd %xmm3, %xmm1
movsd %xmm1, 0x5738(%rip)     # 0x9190
movb $0x1, 0x5729(%rip)      # 0x9188
ucomisd %xmm2, %xmm0
jb 0x3a6b
sqrtsd %xmm0, %xmm0
jmp 0x3a7a
movsd %xmm3, -0x8(%rbp)
callq 0x1050
movsd -0x8(%rbp), %xmm3
movsd -0x10(%rbp), %xmm1
movsd -0x28(%rbp), %xmm2
mulsd %xmm0, %xmm2
mulsd %xmm3, %xmm2
addsd %xmm1, %xmm2
movapd %xmm2, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
movl %edi, %eax
movq %rax, 0x56f7(%rip)      # 0x91a0
movabsq $0x1, %rcx
leaq 0x56e6(%rip), %rdx      # 0x91a0
cmpq $0x270, %rcx            # imm = 0x270
je 0x3add
movq %rax, %rsi
shrq $0x1e, %rsi
xorl %eax, %esi
imull $0x6c078965, %esi, %eax # imm = 0x6C078965
addl %ecx, %eax
movq %rax, (%rdx,%rcx,8)
incq %rcx
jmp 0x3aba
movl $0x270, 0x5605(%rip)    # imm = 0x270
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genevalab[P]msmove/rand2t.c
// Function: genrand_int32
unsigned long genrand_int32(void)
{
    unsigned long y;
    static unsigned long mag01[2] = {0x0UL, MATRIX_A};
    /* mag01[x] = x * MATRIX_A  for x=0,1 */

    if (mti >= N) 
	{ 
		/* generate N words at one time */
        int kk;

		if (mti == N + 1)         /* if init_genrand() has not been called, */
            init_genrand(5489UL); /* a default initial seed is used */

        for (kk = 0; kk < N - M; kk++) 
		{
            y = (mt[kk] & UPPER_MASK)|(mt[kk + 1] & LOWER_MASK);
            mt[kk] = mt[kk + M] ^ (y >> 1) ^ mag01[y & 0x1UL];
        }
        for (; kk < N - 1; kk++) 
		{
            y = (mt[kk] & UPPER_MASK)|(mt[kk + 1] & LOWER_MASK);
            mt[kk] = mt[kk + (M - N)] ^ (y >> 1) ^ mag01[y & 0x1UL];
        }
        y = (mt[N - 1] & UPPER_MASK)|(mt[0] & LOWER_MASK);
        mt[N - 1] = mt[M - 1] ^ (y >> 1) ^ mag01[y & 0x1UL];
        mti = 0;
    }
  
    y = mt[mti++];

    /* Tempering */
    y ^= (y >> 11);
    y ^= (y << 7) & 0x9d2c5680UL;
    y ^= (y << 15) & 0xefc60000UL;
    y ^= (y >> 18);

    return y;
}

// Assembly:
movslq 0x55fc(%rip), %rax      # 0x90ec
cmpq $0x26f, %rax            # imm = 0x26F
jle 0x3b62
cmpl $0x271, %eax            # imm = 0x271
jne 0x3b0e
pushq %rbp
movq %rsp, %rbp
movl $0x1571, %edi           # imm = 0x1571
callq 0x3a9c
popq %rbp
xorl %edx, %edx
leaq 0x5689(%rip), %rcx      # 0x91a0
movl $0x80000000, %esi       # imm = 0x80000000
leaq 0x31bd(%rip), %rax      # 0x6ce0
cmpq $0xe3, %rdx
je 0x3b74
movl (%rcx,%rdx,8), %edi
andl %esi, %edi
movl 0x8(%rcx,%rdx,8), %r8d
movl %r8d, %r9d
andl $0x7ffffffe, %r9d       # imm = 0x7FFFFFFE
orl %edi, %r9d
shrl %r9d
andl $0x1, %r8d
movq (%rax,%r8,8), %rdi
xorq 0xc68(%rcx,%rdx,8), %rdi
xorq %r9, %rdi
movq %rdi, (%rcx,%rdx,8)
incq %rdx
jmp 0x3b23
leaq 0x5637(%rip), %rcx      # 0x91a0
movq (%rcx,%rax,8), %rcx
incl %eax
jmp 0x3bfc
xorl %edx, %edx
movl $0x80000000, %esi       # imm = 0x80000000
cmpq $0x18c, %rdx            # imm = 0x18C
je 0x3bc1
movl 0x718(%rcx,%rdx,8), %edi
andl %esi, %edi
movl 0x720(%rcx,%rdx,8), %r8d
movl %r8d, %r9d
andl $0x7ffffffe, %r9d       # imm = 0x7FFFFFFE
orl %edi, %r9d
andl $0x1, %r8d
movq (%rax,%r8,8), %rdi
xorq (%rcx,%rdx,8), %rdi
shrl %r9d
xorq %r9, %rdi
movq %rdi, 0x718(%rcx,%rdx,8)
incq %rdx
jmp 0x3b7b
movl $0x80000000, %edx       # imm = 0x80000000
andl 0x694c(%rip), %edx      # 0xa518
movq 0x55cd(%rip), %rcx      # 0x91a0
movl %ecx, %esi
andl $0x7ffffffe, %esi       # imm = 0x7FFFFFFE
orl %edx, %esi
movl %ecx, %edx
andl $0x1, %edx
movq (%rax,%rdx,8), %rax
xorq 0x6213(%rip), %rax      # 0x9e00
shrl %esi
xorq %rsi, %rax
movq %rax, 0x691f(%rip)      # 0xa518
pushq $0x1
popq %rax
movl %eax, 0x54ea(%rip)      # 0x90ec
movq %rcx, %rax
shrq $0xb, %rax
xorq %rcx, %rax
movl %eax, %ecx
shll $0x7, %ecx
andl $0x9d2c5680, %ecx       # imm = 0x9D2C5680
xorq %rax, %rcx
movl %ecx, %edx
shll $0xf, %edx
andl $0xefc60000, %edx       # imm = 0xEFC60000
xorq %rcx, %rdx
movq %rdx, %rax
shrq $0x12, %rax
xorq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %edi, %ebx
cvtsi2sdq 0x58a8(%rip), %xmm0 # 0xa548
movsd %xmm0, -0x10(%rbp)
callq 0x3ca9
mulsd -0x10(%rbp), %xmm0
cvttsd2si %xmm0, %eax
incl %eax
movl 0x5885(%rip), %esi      # 0xa540
movq 0x585e(%rip), %rdx      # 0xa520
xorl %ecx, %ecx
testl %esi, %esi
cmovlel %ecx, %esi
addq $0x8, %rdx
cmpq %rcx, %rsi
je 0x4cfc
movslq -0x8(%rdx), %r8
movq (%rdx), %rdi
imulq $0xc, %r8, %r8
movl -0x8(%rdi,%r8), %r10d
movl (%rdi), %r8d
subl %r8d, %r10d
movl %eax, %r9d
subl %r10d, %r9d
jle 0x4d01
incq %rcx
addq $0x10, %rdx
movl %r9d, %eax
jmp 0x4ccd
movl (%rdi), %r8d
jmp 0x4d03
movl %ecx, %esi
leal (%rax,%r8), %edx
decl %edx
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5495
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
movsd 0x5843(%rip), %xmm0     # 0xa570
movsd %xmm0, -0x20(%rbp)
callq 0x3ca9
mulsd -0x20(%rbp), %xmm0
ucomisd 0x12cc(%rip), %xmm0     # 0x6010
jne 0x4d48
jnp 0x4d25
pushq $-0x1
popq %r14
xorpd %xmm1, %xmm1
pushq $-0x8
popq %r15
movsd %xmm0, -0x30(%rbp)
ucomisd %xmm1, %xmm0
jbe 0x4db4
movsd 0x57f9(%rip), %xmm2     # 0xa560
movsd %xmm2, -0x28(%rbp)
incl %r14d
movl %r14d, %edi
movsd %xmm1, -0x20(%rbp)
callq 0x58fc
cvtsi2sd %eax, %xmm1
movsd -0x28(%rbp), %xmm0
callq 0x1170
movsd 0x1276(%rip), %xmm1     # 0x6008
subsd %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
movsd -0x20(%rbp), %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, -0x20(%rbp)
movsd -0x20(%rbp), %xmm1
addq $0x10, %r15
jmp 0x4d59
movq 0x5765(%rip), %rax      # 0xa520
movq (%rax,%r15), %r15
movl %r14d, %edi
callq 0x58fc
cvtsi2sd %eax, %xmm1
cvtsi2sdl (%r15), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x5783(%rip), %xmm0     # 0xa560
callq 0x1170
movsd 0x121e(%rip), %xmm1     # 0x6008
subsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
callq 0x3ca9
mulsd -0x28(%rbp), %xmm0
movsd 0x1203(%rip), %xmm1     # 0x6008
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x1060
divsd 0x574e(%rip), %xmm0     # 0xa568
addsd 0x11e6(%rip), %xmm0     # 0x6008
callq 0x1160
addsd -0x20(%rbp), %xmm0
addsd 0x11f4(%rip), %xmm0     # 0x6028
cvttsd2si %xmm0, %edx
movl %ebx, %edi
movl %r14d, %esi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5495
// File: /workspace/github_c_makefile_star2_O2/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 0x56e0(%rip), %xmm0 # 0xa548
movsd %xmm0, -0x30(%rbp)
callq 0x3ca9
mulsd -0x30(%rbp), %xmm0
cvttsd2si %xmm0, %eax
incl %eax
movl 0x56bc(%rip), %r15d     # 0xa540
movq 0x5695(%rip), %rdx      # 0xa520
xorl %ecx, %ecx
testl %r15d, %r15d
cmovlel %ecx, %r15d
addq $0x8, %rdx
cmpq %rcx, %r15
je 0x4ecc
movslq -0x8(%rdx), %rsi
movq (%rdx), %rdi
imulq $0xc, %rsi, %r8
movl -0x8(%r8,%rdi), %r12d
movl (%rdi), %r8d
movl %r12d, %r10d
subl %r8d, %r10d
movl %eax, %r9d
subl %r10d, %r9d
jle 0x4edd
decl %esi
incq %rcx
addq $0x10, %rdx
movl %r9d, %eax
jmp 0x4e98
movl (%rdi), %r8d
movslq %esi, %rcx
imulq $0xc, %rcx, %rcx
movl 0x4(%rdi,%rcx), %r12d
jmp 0x4ee0
movl %ecx, %r15d
leal (%rax,%r8), %r13d
leal (%rax,%r8), %edx
decl %edx
movl %r14d, %edi
movl %r15d, %esi
callq 0x5495
callq 0x3ca9
callq 0x1060
divsd 0x5661(%rip), %xmm0     # 0xa568
addsd 0x10f9(%rip), %xmm0     # 0x6008
callq 0x1160
cvttsd2si %xmm0, %eax
leal (%rax,%r13), %edx
decl %edx
cmpl %r12d, %edx
jge 0x4f6f
movq 0x55f6(%rip), %rax      # 0xa520
movslq 0x560f(%rip), %rcx      # 0xa540
decq %rcx
movq %rcx, %rsi
shlq $0x4, %rsi
movq 0x8(%rax,%rsi), %rax
cmpl (%rax), %edx
jge 0x4f4a
pushq $-0x1
popq %r12
jmp 0x4f5f
movl %r14d, %edi
movl %ecx, %esi
callq 0x5495
movl 0x55e6(%rip), %ecx      # 0xa540
decl %ecx
movl %r15d, %r12d
movl %r14d, %edi
movl %ebx, %esi
movl %r15d, %edx
callq 0x5041
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_O2/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 0x3837
movl (%r12), %edi
movl (%r13), %eax
cmpl %eax, %edi
movl %eax, %ecx
cmovll %edi, %ecx
movq 0x5559(%rip), %rsi      # 0xa520
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 0x4fe1
cmpl %ecx, %r9d
je 0x4ffd
incl %r9d
jmp 0x4fd0
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 0x5019
incl %ecx
cmpl %eax, %ecx
jne 0x500c
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_O2/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 0x4bf2(%rip), %rax      # 0xa520
movslq %esi, %rsi
shlq $0x4, %rsi
movslq (%rax,%rsi), %rcx
movq 0x8(%rax,%rsi), %rax
movslq (%rdx), %rsi
imulq $0xc, %rsi, %r8
addq %rax, %r8
addq $0x4, %r8
leal 0x1(%rsi), %r10d
movl $0x1, %r9d
xorl %eax, %eax
cmpq %rcx, %rsi
jge 0x597a
cmpl %edi, -0x4(%r8)
jg 0x597a
cmpl %edi, (%r8)
jge 0x5977
incq %rsi
movl %r10d, (%rdx)
addq $0xc, %r8
incl %r10d
jmp 0x5958
movl %r9d, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x125c
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
leaq 0x3da1(%rip), %rdi      # 0x5004
callq 0x10d0
pushq $0x2
popq %rdi
callq 0x10e0
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x810, %rsp            # imm = 0x810
xorl %eax, %eax
callq 0x11fc
leaq -0x30(%rbp), %rbx
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
movq 0x8d45(%rip), %r12      # 0x9fe0
leaq -0x830(%rbp), %r14
pushq $0x1
popq %r15
movq (%r12), %rcx
movl $0x800, %edx            # imm = 0x800
movq %r14, %rdi
movq %r15, %rsi
callq 0x1060
testq %rax, %rax
je 0x12cf
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1206
jmp 0x12a6
movq (%r12), %rdi
callq 0x1050
testl %eax, %eax
jne 0x12f4
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdx
addq $0x810, %rsp            # imm = 0x810
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3d23(%rip), %rdi      # 0x501e
callq 0x10d0
pushq $0x3
popq %rdi
callq 0x10e0
// File: /workspace/github_c_makefile_star2_O2/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
leaq -0x24(%rbp), %rax
andl $0x0, (%rax)
leaq 0x3d0e(%rip), %rcx      # 0x5033
leaq -0x70(%rbp), %rbx
movq %rcx, (%rbx)
andl $0x0, 0x8(%rbx)
movq %rsi, %r14
movl %edi, %r15d
movq %rax, 0x10(%rbx)
movl $0x1, 0x18(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x30(%rbx)
leaq 0x4424(%rip), %r12      # 0x5777
movl %r15d, %edi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x1070
cmpl $-0x1, %eax
jne 0x1353
callq 0x1270
xorl %ecx, %ecx
cmpl $0x0, -0x24(%rbp)
setne %cl
movq %rax, %rdi
movq %rdx, %rsi
movl %ecx, %edx
callq 0x452e
pushq $0xa
popq %rdi
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_O2/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
testb %sil, %sil
js 0x1404
movzbl %sil, %esi
popq %rbp
jmp 0x140b
movb $0x5, (%rdi)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x9(%rbp), %rax
movb %sil, (%rax)
pushq $0x1
popq %rdx
movq %rax, %rsi
callq *0x20(%rdi)
cmpq $0x1, %rax
je 0x142d
movb $0x6, (%rbx)
cmpq $0x1, %rax
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
cmpb $-0x20, %sil
jb 0x144c
movzbl %sil, %esi
popq %rbp
jmp 0x140b
movb $0x5, (%rdi)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
testb %sil, %sil
js 0x1466
movzbl %sil, %esi
popq %rbp
jmp 0x13f4
cmpb $-0x20, %sil
jb 0x1476
movsbl %sil, %esi
popq %rbp
jmp 0x143b
movb $0x5, (%rdi)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x9(%rbp), %rax
movb %sil, (%rax)
pushq $0x1
popq %rdx
movq %rax, %rsi
callq *0x20(%rdi)
cmpq $0x1, %rax
je 0x14d8
movb $0x8, (%rbx)
cmpq $0x1, %rax
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movl $0xd1, %esi
callq 0x14b6
testb %al, %al
je 0x1523
rolw $0x8, %r14w
leaq -0x12(%rbp), %rsi
movw %r14w, (%rsi)
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
setne %al
jmp 0x1525
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movl $0xd2, %esi
callq 0x14b6
testb %al, %al
je 0x1568
bswapl %r14d
leaq -0x14(%rbp), %rsi
movl %r14d, (%rsi)
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
setne %al
jmp 0x156a
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0xd3, %esi
callq 0x14b6
testb %al, %al
je 0x15ad
bswapq %r14
leaq -0x18(%rbp), %rsi
movq %r14, (%rsi)
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
setne %al
jmp 0x15af
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
testq %rsi, %rsi
js 0x15c7
popq %rbp
jmp 0x160e
cmpq $-0x20, %rsi
jb 0x15d7
movsbl %sil, %esi
popq %rbp
jmp 0x143b
cmpq $-0x80, %rsi
jb 0x15e7
movsbl %sil, %esi
popq %rbp
jmp 0x147d
cmpq $-0x8000, %rsi          # imm = 0x8000
jb 0x15f9
movswl %si, %esi
popq %rbp
jmp 0x14e6
cmpq $-0x80000000, %rsi      # imm = 0x80000000
jb 0x1608
popq %rbp
jmp 0x152e
popq %rbp
jmp 0x1573
// File: /workspace/github_c_makefile_star2_O2/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
cmpq $0x7f, %rsi
ja 0x1622
movzbl %sil, %esi
popq %rbp
jmp 0x13f4
cmpq $0xff, %rsi
ja 0x1635
movzbl %sil, %esi
popq %rbp
jmp 0x1666
cmpq $0xffff, %rsi           # imm = 0xFFFF
ja 0x1647
movzwl %si, %esi
popq %rbp
jmp 0x169f
movq %rsi, %rax
shrq $0x20, %rax
jne 0x1656
popq %rbp
jmp 0x16e7
popq %rbp
jmp 0x172c
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movl $0xcd, %esi
callq 0x14b6
testb %al, %al
je 0x16dc
rolw $0x8, %r14w
leaq -0x12(%rbp), %rsi
movw %r14w, (%rsi)
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
setne %al
jmp 0x16de
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movl $0xce, %esi
callq 0x14b6
testb %al, %al
je 0x1721
bswapl %r14d
leaq -0x14(%rbp), %rsi
movl %r14d, (%rsi)
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
setne %al
jmp 0x1723
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0xcf, %esi
callq 0x14b6
testb %al, %al
je 0x1766
bswapq %r14
leaq -0x18(%rbp), %rsi
movq %r14, (%rsi)
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
setne %al
jmp 0x1768
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movq %rdi, %rbx
movss %xmm0, -0xc(%rbp)
movl $0xca, %esi
callq 0x14b6
testb %al, %al
je 0x17a7
leaq -0x9(%rbp), %rax
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x17ab
movb (%rax), %dl
movb %dl, -0x10(%rbp,%rcx)
incq %rcx
decq %rax
jmp 0x1793
xorl %eax, %eax
jmp 0x17be
leaq -0x10(%rbp), %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, -0x10(%rbp)
movl $0xcb, %esi
callq 0x14b6
testb %al, %al
je 0x17fe
leaq -0x9(%rbp), %rax
xorl %ecx, %ecx
cmpq $0x8, %rcx
je 0x1802
movb (%rax), %dl
movb %dl, -0x18(%rbp,%rcx)
incq %rcx
decq %rax
jmp 0x17ea
xorl %eax, %eax
jmp 0x1815
leaq -0x18(%rbp), %rsi
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq *0x20(%rbx)
testq %rax, %rax
setne %al
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1839
jp 0x1839
movaps %xmm1, %xmm0
popq %rbp
jmp 0x1771
popq %rbp
jmp 0x17c5
// File: /workspace/github_c_makefile_star2_O2/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
cmpb $0x1f, %sil
ja 0x18ac
orb $-0x60, %sil
movzbl %sil, %esi
popq %rbp
jmp 0x140b
movb $0x5, (%rdi)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
movl %edx, %esi
callq 0x1894
testb %al, %al
je 0x18ef
movb $0x1, %r14b
testb %r12b, %r12b
je 0x18f2
movzbl %r12b, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq *0x20(%rbx)
testq %rax, %rax
jne 0x18f2
movb $0xa, (%rbx)
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq