LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/sdss-survey.c
// Function: gcirc_survey
void gcirc_survey(
        double lam1, double eta1, 
        double lam2, double eta2,
        double* dis,  double* theta)
{

  double tlam1 = lam1*D2R;
  //sinlam1 = sin(tlam1);
  double coslam1 = cos(tlam1);
  double sinlam1 = sin(tlam1);

  double tlam2 = lam2*D2R;
  double coslam2 = cos(tlam2);
  double sinlam2 = sin(tlam2);

  double etadiff = (eta2-eta1)*D2R;
  double cosetadiff = cos(etadiff);
  double sinetadiff = sin(etadiff);

  double cosdis = sinlam1*sinlam2 + coslam1*coslam2*cosetadiff;

  if (cosdis < -1.0) cosdis=-1.0;
  if (cosdis >  1.0) cosdis= 1.0;

  *dis = acos(cosdis);

  *theta = atan2( sinetadiff, sinlam1*cosetadiff - coslam1*sinlam2/coslam2 );

  *theta -= M_PI_2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movsd 0xd79(%rip), %xmm0      # 0xe0a8
mulsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x2120
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x2220
movsd %xmm0, -0x48(%rbp)
movsd 0xd49(%rip), %xmm0      # 0xe0a8
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
callq 0x2120
movsd %xmm0, -0x58(%rbp)
movsd -0x50(%rbp), %xmm0
callq 0x2220
movsd %xmm0, -0x60(%rbp)
movsd -0x20(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movsd 0xd0f(%rip), %xmm1      # 0xe0a8
mulsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x68(%rbp), %xmm0
callq 0x2120
movsd %xmm0, -0x70(%rbp)
movsd -0x68(%rbp), %xmm0
callq 0x2220
movsd %xmm0, -0x78(%rbp)
movsd -0x48(%rbp), %xmm0
movsd -0x60(%rbp), %xmm2
movsd -0x40(%rbp), %xmm1
mulsd -0x58(%rbp), %xmm1
mulsd -0x70(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x80(%rbp)
movsd 0xc52(%rip), %xmm0      # 0xe040
ucomisd -0x80(%rbp), %xmm0
jbe 0xd402
movsd 0xc43(%rip), %xmm0      # 0xe040
movsd %xmm0, -0x80(%rbp)
movsd -0x80(%rbp), %xmm0
movsd 0xc19(%rip), %xmm1      # 0xe028
ucomisd %xmm1, %xmm0
jbe 0xd422
movsd 0xc0b(%rip), %xmm0      # 0xe028
movsd %xmm0, -0x80(%rbp)
movsd -0x80(%rbp), %xmm0
callq 0x2130
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x78(%rbp), %xmm0
movsd -0x48(%rbp), %xmm1
movsd -0x70(%rbp), %xmm3
movsd -0x40(%rbp), %xmm2
mulsd -0x60(%rbp), %xmm2
divsd -0x58(%rbp), %xmm2
movq %xmm2, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
callq 0x21e0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x30(%rbp), %rax
movsd (%rax), %xmm0
movsd 0xba2(%rip), %xmm1      # 0xe030
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
addq $0x80, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/sdss-survey.c
// Function: posangle_survey_sincos
double posangle_survey_sincos(double sinlam1, double coslam1,
                              double sineta1, double coseta1,
                              double sinlam2, double coslam2,
                              double sineta2, double coseta2) {

    double cosetadiff = coseta2*coseta1 + sineta2*sineta1;
    double sinetadiff = sineta2*coseta1 - coseta2*sineta2;

    double theta = atan2( sinetadiff, sinlam1*cosetadiff - coslam1*sinlam2/coslam2 );
    theta -= M_PI_2;

    return theta;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movsd %xmm4, -0x28(%rbp)
movsd %xmm5, -0x30(%rbp)
movsd %xmm6, -0x38(%rbp)
movsd %xmm7, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd -0x20(%rbp), %xmm2
movsd -0x38(%rbp), %xmm1
mulsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x38(%rbp), %xmm0
movsd -0x20(%rbp), %xmm2
movsd -0x40(%rbp), %xmm1
mulsd -0x38(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
movsd -0x48(%rbp), %xmm3
movsd -0x10(%rbp), %xmm2
mulsd -0x28(%rbp), %xmm2
divsd -0x30(%rbp), %xmm2
movq %xmm2, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
callq 0x21e0
movsd %xmm0, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
movsd 0xab3(%rip), %xmm1      # 0xe030
subsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/sdss-survey.c
// Function: survey_quad
int survey_quad(double theta) {
    theta = (M_PI_2 - theta)*R2D;
    if (theta >= 0. && theta < 90.) {
        return 0;
    } else if (theta >= 90. && theta < 180.) {
        return 1;
    } else if (theta >= 180. && theta < 270.) {
        return 2;
    } else {
        return 3;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd 0xa7f(%rip), %xmm0      # 0xe030
subsd -0x10(%rbp), %xmm0
movsd 0x1ad2(%rip), %xmm1     # 0xf090
mulsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xd5ed
movsd 0xac3(%rip), %xmm0      # 0xe0a0
ucomisd -0x10(%rbp), %xmm0
jbe 0xd5ed
movl $0x0, -0x4(%rbp)
jmp 0xd64a
movsd -0x10(%rbp), %xmm0
movsd 0xaa6(%rip), %xmm1      # 0xe0a0
ucomisd %xmm1, %xmm0
jb 0xd618
movsd 0x1a80(%rip), %xmm0     # 0xf088
ucomisd -0x10(%rbp), %xmm0
jbe 0xd618
movl $0x1, -0x4(%rbp)
jmp 0xd64a
movsd -0x10(%rbp), %xmm0
movsd 0x1a63(%rip), %xmm1     # 0xf088
ucomisd %xmm1, %xmm0
jb 0xd643
movsd 0x1a75(%rip), %xmm0     # 0xf0a8
ucomisd -0x10(%rbp), %xmm0
jbe 0xd643
movl $0x2, -0x4(%rbp)
jmp 0xd64a
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ravenexp[P]aatrace/match.c
// Function: aatrace_match_tile
struct match_result
aatrace_match_tile(const unsigned char* tilebuf,
		   const unsigned char* fontbuf,
		   int nchars,
		   const struct aatrace_match_ctx* ctx)
{
	switch (ctx->method) {
	default:
	case AATRACE_MATCH_METHOD_MINSAD:
		return aatrace_match_tile_sad(tilebuf, fontbuf, nchars);
	case AATRACE_MATCH_METHOD_MINSADASD:
		return aatrace_match_tile_sadasd(tilebuf, fontbuf, nchars,
						 ctx->sad_weight, ctx->asd_weight);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x1, %eax
je 0x2233
jmp 0x2227
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0x2249
jmp 0x2231
jmp 0x2233
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x2280
movq %rax, -0x8(%rbp)
jmp 0x226c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x28(%rbp), %rax
movl 0x8(%rax), %r8d
callq 0x2370
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ravenexp[P]aatrace/match.c
// Function: aatrace_match_tile_sad
static
struct match_result
aatrace_match_tile_sad(const unsigned char* tilebuf,
		       const unsigned char* fontbuf,
		       int nchars)
{
	struct match_result r;

	unsigned int minsad = 255*FW*FH;
	int best_ch = 0;
	int ch;

	for (ch = 0; ch < nchars; ch++) {
		int l, i;
		unsigned int sad = 0;

		for (l = 0; l < FH; l++)
			for (i = 0; i < FW; i++)
				sad += abs(  tilebuf[l*FW + i]
					   - fontbuf[(ch*FH + l)*FW + i]);

		if (sad < minsad) {
			minsad = sad;
			best_ch = ch;
		}

		if (minsad == 0)
			break;
	}

	r.ch = best_ch;
	r.score = minsad;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x7f80, -0x20(%rbp)    # imm = 0x7F80
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2352
movl $0x0, -0x34(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x10, -0x2c(%rbp)
jge 0x2326
movl $0x0, -0x30(%rbp)
cmpl $0x8, -0x30(%rbp)
jge 0x2319
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %ecx
shll $0x3, %ecx
addl -0x30(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movl -0x28(%rbp), %edx
shll $0x4, %edx
addl -0x2c(%rbp), %edx
shll $0x3, %edx
addl -0x30(%rbp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x22cb
jmp 0x231b
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x22be
movl -0x34(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0x233a
movl -0x34(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x2342
jmp 0x2352
jmp 0x2344
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x22a4
movl -0x24(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ravenexp[P]aatrace/match.c
// Function: aatrace_match_tile_sadasd
static
struct match_result
aatrace_match_tile_sadasd(const unsigned char* tilebuf,
			  const unsigned char* fontbuf,
			  int nchars,
			  unsigned int sad_weight,
			  unsigned int asd_weight)
{
	struct match_result r;

	unsigned int minsadasd = (sad_weight + asd_weight)*255*FW*FH;
	int best_ch = 0;

	int ch;

	for (ch = 0; ch < nchars; ch++) {
		unsigned int sad = 0;
		int sd = 0;
		unsigned int asd;
		unsigned int sadasd;

		int l, i;

		for (l = 0; l < FH; l++) {
			for (i = 0; i < FW; i++) {
				int d = tilebuf[l*FW + i]
				      - fontbuf[(ch*FH + l)*FW + i];
				sd += d;
				sad += abs(d);
			}
		}

		asd = abs(sd);
		sadasd = sad*sad_weight + asd*asd_weight;
		if (sadasd < minsadasd) {
			minsadasd = sadasd;
			best_ch = ch;
		}

		if (minsadasd == 0)
			break;
	}

	r.ch = best_ch;
	r.score = minsadasd;
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl -0x20(%rbp), %eax
addl -0x24(%rbp), %eax
imull $0xff, %eax, %eax
shll $0x3, %eax
shll $0x4, %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x248d
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x44(%rbp)
cmpl $0x10, -0x44(%rbp)
jge 0x2441
movl $0x0, -0x48(%rbp)
cmpl $0x8, -0x48(%rbp)
jge 0x2434
movq -0x10(%rbp), %rax
movl -0x44(%rbp), %ecx
shll $0x3, %ecx
addl -0x48(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movl -0x30(%rbp), %edx
shll $0x4, %edx
addl -0x44(%rbp), %edx
shll $0x3, %edx
addl -0x48(%rbp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x23d7
jmp 0x2436
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x23ca
movl -0x38(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x3c(%rbp)
movl -0x34(%rbp), %eax
imull -0x20(%rbp), %eax
movl -0x3c(%rbp), %ecx
imull -0x24(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x28(%rbp), %eax
jae 0x2475
movl -0x40(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x247d
jmp 0x248d
jmp 0x247f
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x23a9
movl -0x2c(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ravenexp[P]aatrace/cover.c
// Function: aatrace_cover_tile_score
unsigned int
aatrace_cover_tile_score(const struct aatrace_pic* pic,
			 const struct aatrace_font* font,
			 int tl, int tc, int dx, int dy,
			 const struct aatrace_match_ctx* ctx)
{
	const unsigned char* p =
		pic->buf + font->h*pic->ll*tl + font->w*tc;
	unsigned int score = 0;
	int i;

	if (dy > 0)
		for (i = 0; i < dy; i++)
			score += edge_score(p + i*pic->ll, FW, 1, ctx);
	if (dy < 0)
		for (i = dy; i < 0; i++)
			score += edge_score(p + (font->h + i)*pic->ll, FW, 1, ctx);

	if (dx > 0)
		for (i = 0; i < dx; i++)
			score += edge_score(p + i, FH, pic->ll, ctx);
	if (dx < 0)
		for (i = dx; i < 0; i++)
			score += edge_score(p + font->w + i, FH, pic->ll, ctx);

	return score;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x1c(%rcx), %ecx
movq -0x8(%rbp), %rdx
imull 0x8(%rdx), %ecx
imull -0x14(%rbp), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
imull -0x18(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x0, -0x20(%rbp)
jle 0x254c
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x254a
movq -0x28(%rbp), %rdi
movl -0x30(%rbp), %eax
movq -0x8(%rbp), %rcx
imull 0x8(%rcx), %eax
movl %eax, %eax
addq %rax, %rdi
movq 0x10(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x2640
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x250a
jmp 0x254c
cmpl $0x0, -0x20(%rbp)
jge 0x259f
movl -0x20(%rbp), %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jge 0x259d
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
addl -0x30(%rbp), %eax
movq -0x8(%rbp), %rcx
imull 0x8(%rcx), %eax
movl %eax, %eax
addq %rax, %rdi
movq 0x10(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x2640
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2558
jmp 0x259f
cmpl $0x0, -0x1c(%rbp)
jle 0x25e7
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x25e5
movq -0x28(%rbp), %rdi
movslq -0x30(%rbp), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
movq 0x10(%rbp), %rcx
movl $0x10, %esi
callq 0x2640
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x25ac
jmp 0x25e7
cmpl $0x0, -0x1c(%rbp)
jge 0x2637
movl -0x1c(%rbp), %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jge 0x2635
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq 0x18(%rax), %rax
addq %rax, %rdi
movslq -0x30(%rbp), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
movq 0x10(%rbp), %rcx
movl $0x10, %esi
callq 0x2640
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x25f3
jmp 0x2637
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ravenexp[P]aatrace/cover.c
// Function: edge_score
static
unsigned int edge_score(const unsigned char* p, int l,
			unsigned int stride,
			const struct aatrace_match_ctx* ctx)
{
	unsigned int score = 0;
	int i;

	for (i = 0; i < l; i++) {
		score += p[i*stride];
	}

	if (ctx->method == AATRACE_MATCH_METHOD_MINSADASD)
		score *= (ctx->sad_weight + ctx->asd_weight);

	return score;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x268a
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x10(%rbp), %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2660
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x26a8
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
addl 0x8(%rcx), %eax
imull -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ravenexp[P]aatrace/search.c
// Function: aatrace_search_ctx_init
void aatrace_search_ctx_init(struct aatrace_search_ctx* ctx)
{
	ctx->method = AATRACE_DEFAULT_SEARCH_METHOD;
	ctx->flags =  AATRACE_DEFAULT_SEARCH_FLAGS;
	ctx->hrange = AATRACE_DEFAULT_SEARCH_HRANGE;
	ctx->vrange = AATRACE_DEFAULT_SEARCH_VRANGE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0xc(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ravenexp[P]aatrace/convert.c
// Function: aatrace_convert_pic
void aatrace_convert_pic(struct aatrace_text* txt,
			 const struct aatrace_pic* src,
			 const struct aatrace_font* font,
			 const struct aatrace_convert_ctx* ctx)
{
	int tl, tc;

	txt->ll = txt->w = src->w/AATRACE_FONT_WIDTH;
	txt->h = src->h/AATRACE_FONT_HEIGHT;
	txt->buf = (char*)malloc(txt->ll*txt->h);

	for (tl = 0; (tl + 1)*font->h <= src->h; tl++) {
		for (tc = 0; (tc + 1)*font->w <= src->w; tc++) {
			txt->buf[tl*txt->ll + tc] =
				aatrace_search_tile(src, font, tl, tc, &ctx->match, &ctx->search)
				+ font->ascii_offset;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x10(%rcx), %eax
movl %eax, %eax
movl %eax, %edi
callq 0x1110
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movq -0x18(%rbp), %rcx
imull 0x1c(%rcx), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jg 0x2b5a
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movq -0x18(%rbp), %rcx
imull 0x18(%rcx), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jg 0x2b4a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %ecx
movq -0x20(%rbp), %r8
movq -0x20(%rbp), %r9
addq $0xc, %r9
callq 0x26f0
movq -0x18(%rbp), %rcx
addl 0x24(%rcx), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rsi
imull 0x8(%rsi), %ecx
addl -0x28(%rbp), %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2ae6
jmp 0x2b4c
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2ac8
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/src/test_heap-def.c
// Function: s_swap
void s_swap (S * v, vl_uindex a, vl_uindex b)
{
  S t = v[a] ;
  v[a] = v[b] ;
  v[b] = t ;
  printf("Swapping %" VL_FMT_UINDEX "x with %" VL_FMT_UINDEX "\n", a, b) ;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rdx
movq 0x10(%rsp), %rsi
movl (%rdx,%rsi,4), %edx
movl %edx, (%rax,%rcx,4)
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movl 0xc(%rsp), %edx
movl %edx, (%rax,%rcx,4)
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x1e30(%rip), %rdi      # 0x3010
movb $0x0, %al
callq 0x1030
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/lowpass2/lowpass2.c
// Function: processData
static void
processData(FILE *in,FILE *out,RRA *h)
    {
    int amp;

    biquad *m = newBiquad(a0,a1,a2,b1,b2);

    amp = readRRAAmplitude(in,out,h->bitsPerSample,outputComment);
    while (!feof(in))
        {
        int d = updateBiquad(m,amp);
        fprintf(out,"%d\n",(int)(d * AmpFactor));
        //getchar();
        amp = readRRAAmplitude(in,out,h->bitsPerSample,outputComment);
        }
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd 0xf814(%rip), %xmm0     # 0x13440
movsd 0xf814(%rip), %xmm1     # 0x13448
movsd 0xf814(%rip), %xmm2     # 0x13450
movsd 0xf814(%rip), %xmm3     # 0x13458
movsd 0xf814(%rip), %xmm4     # 0x13460
callq 0xccc0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x8165(%rip), %rcx      # 0xbdd0
callq 0xb120
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x21b0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3c8a
jmp 0x3cdc
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xced0
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
cvtsi2sdl -0x2c(%rbp), %xmm0
mulsd 0xf506(%rip), %xmm0     # 0x131b0
cvttsd2si %xmm0, %edx
leaq 0xacce(%rip), %rsi      # 0xe983
movb $0x0, %al
callq 0x2190
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x80fe(%rip), %rcx      # 0xbdd0
callq 0xb120
movl %eax, -0x1c(%rbp)
jmp 0x3c73
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/source.c
// Function: source_new
Source* source_new(const ShearConfig* config) {
    Source* src = calloc(1,sizeof(Source));
    if (src == NULL) {
        wlog("Could not allocate Source\n");
        exit(EXIT_FAILURE);
    }

    src->shear_style = config->shear_style;
    src->mask_style = config->mask_style;
    src->scstyle = config->scstyle;
    src->sourceid_style = config->sourceid_style;

    if (src->scstyle == SIGMACRIT_STYLE_INTERP) {
        src->scinv = dvector_zeros(config->nzl);

        if (src->scinv == NULL) {
            wlog("Could not allocate %ld scinv for source\n", config->nzl);
            exit(EXIT_FAILURE);
        }
    }

    return src;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2140
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7288
movq 0xcd8b(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
leaq 0x86f9(%rip), %rsi      # 0xf970
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x24(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x7318
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x6420
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x7316
movq 0xcd05(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdx
leaq 0x8686(%rip), %rsi      # 0xf98b
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
jmp 0x7318
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/source.c
// Function: source_free
Source* source_free(Source* src) {

    if (src != NULL) {

        if (src->scstyle == SIGMACRIT_STYLE_INTERP) {
            if (src->scinv != NULL) {
                vector_free(src->scinv);
            }
        }

        free(src);
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x739e
movq -0x8(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x7395
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x7393
jmp 0x735a
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x738f
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq $0x0, 0x58(%rax)
jmp 0x7391
jmp 0x7393
jmp 0x7395
movq -0x8(%rbp), %rdi
callq 0x2030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/shear.c
// Function: shear_process_source
void shear_process_source(Shear* self, Source* src) {
    src->hpixid = hpix_eq2pix(self->hpix, src->ra, src->dec);

    int64 hpix_mod = src->hpixid - self->hpix->half_npix;
    TreeNode* node = tree_find(self->lcat->hpix_tree, hpix_mod);

    if (node == NULL) {
        return;
    }

    Lens* lens=NULL;
    Lensum* lensum=NULL;

    vector_foreach(ind, node->indices) {

        lens = &self->lcat->data[*ind];
        lensum = &self->lensums->data[*ind];

        if (lens->z >= self->min_zlens && lens->z <= self->max_zlens) {
            shear_procpair(self, src, lens, lensum);
        }
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x20(%rax), %xmm1
callq 0xa010
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq 0x10(%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xd180
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xa857
jmp 0xa937
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0xa937
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x8(%rbp), %rax
ucomisd 0x28(%rax), %xmm0
jb 0xa924
movq -0x28(%rbp), %rax
movsd 0x18(%rax), %xmm1
movq -0x8(%rbp), %rax
movsd 0x30(%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0xa924
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0xa940
jmp 0xa926
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
jmp 0xa899
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/shear.c
// Function: shear_test_quad_sdss
static int shear_test_quad_sdss(Lens* l, Source* s) {
    return test_quad_sincos_sdss(l->maskflags,
                                 l->sinlam, l->coslam,
                                 l->sineta, l->coseta,
                                 s->sinlam, s->coslam,
                                 s->sineta, s->coseta);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x8(%rbp), %rax
movsd 0x60(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd 0x68(%rax), %xmm1
movq -0x8(%rbp), %rax
movsd 0x70(%rax), %xmm2
movq -0x8(%rbp), %rax
movsd 0x78(%rax), %xmm3
movq -0x10(%rbp), %rax
movsd 0xa8(%rax), %xmm4
movq -0x10(%rbp), %rax
movsd 0xb0(%rax), %xmm5
movq -0x10(%rbp), %rax
movsd 0xb8(%rax), %xmm6
movq -0x10(%rbp), %rax
movsd 0xc0(%rax), %xmm7
callq 0xdf00
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/shear.c
// Function: shear_free
Shear* shear_free(Shear* self) {

    if (self != NULL) {

        self->config   = sconfig_free(self->config);
        self->lcat     = lcat_free(self->lcat);
        self->hpix     = hpix_free(self->hpix);
        self->cosmo    = cosmo_free(self->cosmo);
        self->lensums  = lensums_free(self->lensums);

    }
    free(self);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb459
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3040
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x82c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x90c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8960
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xc4a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x2030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/shear.c
// Function: reset_longitude_bounds
static void reset_longitude_bounds(double *angle,
                                   double min,
                                   double max)
{
    while (*angle<min) {
        *angle += 360.0;
    }
    while (*angle>=max) {
        *angle -= 360.0;
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xb4ab
movq -0x8(%rbp), %rax
movsd 0x49df(%rip), %xmm0     # 0xfe80
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
jmp 0xb482
jmp 0xb4ad
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
ucomisd -0x18(%rbp), %xmm0
jb 0xb4d6
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movsd 0x49b4(%rip), %xmm1     # 0xfe80
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
jmp 0xb4ad
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/interp.c
// Function: interplin
double interplin(const dvector* vx, const dvector* vy, double u) {

    // default to last point
    size_t ilo = vx->size-2;
    size_t ihi = vx->size-1;

    for (size_t i=0; i<vx->size; i++) {

        if (vx->data[i] >= u) {
            if (i == 0) {
                ilo = 0;
                ihi = 1;
            } else {
                ilo = i-1;
                ihi = i;
            }
            break;
        }
    }


    double* x=vx->data;
    double* y=vy->data;
    double val;
    val = ( u-x[ilo] )*( y[ihi] - y[ilo] )/( x[ihi] - x[ilo] ) + y[ilo];

    return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
subq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0xd43b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd -0x18(%rbp), %xmm0
jb 0xd42b
cmpq $0x0, -0x30(%rbp)
jne 0xd415
movq $0x0, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
jmp 0xd429
movq -0x30(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xd43b
jmp 0xd42d
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xd3d7
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movsd -0x18(%rbp), %xmm0
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm1
mulsd %xmm1, %xmm0
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm1
divsd %xmm1, %xmm0
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/xshear.c
// Function: usage_and_exit
void usage_and_exit(void) {
    wlog("usage: \n");
    wlog("   cat source_cat | xshear config_file lens_cat > outfile\n");
    wlog("   cat source_cat1 source_cat2 .. | xshear config_file lens_cat > outfile\n");
    wlog("   cat source_cat | some_filter | xshear config_file lens_cat > outfile\n");
    wlog("   cat source_cat | xshear config_file lens_cat pair_logfile > outfile\n");
    exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x6a2d(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
leaq 0x2d12(%rip), %rsi      # 0x102e7
movb $0x0, %al
callq 0x2170
movq 0x6a15(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
leaq 0x2d03(%rip), %rsi      # 0x102f0
movb $0x0, %al
callq 0x2170
movq 0x69fd(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
leaq 0x2d26(%rip), %rsi      # 0x1032b
movb $0x0, %al
callq 0x2170
movq 0x69e5(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
leaq 0x2d59(%rip), %rsi      # 0x10376
movb $0x0, %al
callq 0x2170
movq 0x69cd(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
leaq 0x2d8a(%rip), %rsi      # 0x103bf
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/quad.c
// Function: quadeq_get_quadrant
int quadeq_get_quadrant(double pa_degrees)
{
    int quadrant;
    if (pa_degrees < -90.) {
        quadrant=3;
    } else if (pa_degrees < 0.0) {
        quadrant=4;
    } else if (pa_degrees < 90.) {
        quadrant=1;
    } else {
        quadrant=2;
    }

    return quadrant;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movsd 0x1df7(%rip), %xmm0     # 0xfe88
ucomisd -0x8(%rbp), %xmm0
jbe 0xe0a1
movl $0x3, -0xc(%rbp)
jmp 0xe0d7
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jbe 0xe0b4
movl $0x4, -0xc(%rbp)
jmp 0xe0d5
movsd 0x1dd4(%rip), %xmm0     # 0xfe90
ucomisd -0x8(%rbp), %xmm0
jbe 0xe0cc
movl $0x1, -0xc(%rbp)
jmp 0xe0d3
movl $0x2, -0xc(%rbp)
jmp 0xe0d5
jmp 0xe0d7
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/quad.c
// Function: quadeq_check_quadrant
int quadeq_check_quadrant(int64 maskflags, int quadrant)
{
	static const int OK=1, BAD=0;

    int allcheck = maskflags & QUADEQ_ALL_OK;
    if (allcheck == 0) {
        return BAD;
    }
    if (allcheck == QUADEQ_ALL_OK) {
        return OK;
    }

    // work with the first good adjacent pair we find.  We already checked the
    // case where all quadrants are OK, so it is now arbitrary which one we
    // check against first, but we should be consistent for a given lens.
    // Might figure out which gives better systematics?
    //
    // It would *not* be right to try another pair if the first good one
    // fails; we need to always check on for a given lens to make sure
    // we only draw pairs from that one.
 
    if ((maskflags & QUADEQ_12_OK) == QUADEQ_12_OK) {
        if ( quadrant==1 || quadrant==2) {
            return OK;
        } else {
            return BAD;
        }
    }
    if ((maskflags & QUADEQ_23_OK) == QUADEQ_23_OK) {
        if ( quadrant==2 || quadrant==3) {
            return OK;
        } else {
            return BAD;
        }
    }
    if ((maskflags & QUADEQ_34_OK) == QUADEQ_34_OK) {
        if ( quadrant==3 || quadrant==4) {
            return OK;
        } else {
            return BAD;
        }
    }
    if ((maskflags & QUADEQ_41_OK) == QUADEQ_41_OK) {
        if ( quadrant==4 || quadrant==1) {
            return OK;
        } else {
            return BAD;
        }
    }

    // if we get here we didn't match a good pair of quadrants
    return BAD;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
andq $0x1f, %rax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0xe108
movl $0x0, -0x4(%rbp)
jmp 0xe1d7
cmpl $0x1f, -0x18(%rbp)
jne 0xe11a
movl $0x1, -0x4(%rbp)
jmp 0xe1d7
movq -0x10(%rbp), %rax
andq $0x2, %rax
cmpq $0x2, %rax
jne 0xe14c
cmpl $0x1, -0x14(%rbp)
je 0xe134
cmpl $0x2, -0x14(%rbp)
jne 0xe140
movl $0x1, -0x4(%rbp)
jmp 0xe1d7
movl $0x0, -0x4(%rbp)
jmp 0xe1d7
movq -0x10(%rbp), %rax
andq $0x4, %rax
cmpq $0x4, %rax
jne 0xe178
cmpl $0x2, -0x14(%rbp)
je 0xe166
cmpl $0x3, -0x14(%rbp)
jne 0xe16f
movl $0x1, -0x4(%rbp)
jmp 0xe1d7
movl $0x0, -0x4(%rbp)
jmp 0xe1d7
movq -0x10(%rbp), %rax
andq $0x8, %rax
cmpq $0x8, %rax
jne 0xe1a4
cmpl $0x3, -0x14(%rbp)
je 0xe192
cmpl $0x4, -0x14(%rbp)
jne 0xe19b
movl $0x1, -0x4(%rbp)
jmp 0xe1d7
movl $0x0, -0x4(%rbp)
jmp 0xe1d7
movq -0x10(%rbp), %rax
andq $0x10, %rax
cmpq $0x10, %rax
jne 0xe1d0
cmpl $0x4, -0x14(%rbp)
je 0xe1be
cmpl $0x1, -0x14(%rbp)
jne 0xe1c7
movl $0x1, -0x4(%rbp)
jmp 0xe1d7
movl $0x0, -0x4(%rbp)
jmp 0xe1d7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/one-one/test/mutex1.c
// Function: thread1
void *thread1(void *arg) {
	while(run == 1) {
		dthread_mutex_lock(&lock);
        c++;
		dthread_mutex_unlock(&lock);

		c1++;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x1, 0x24fc(%rip)      # 0x4090
jne 0x1bd4
leaq 0x2543(%rip), %rdi      # 0x40e0
callq 0x17a0
movq 0x250f(%rip), %rax      # 0x40b8
addq $0x1, %rax
movq %rax, 0x2504(%rip)      # 0x40b8
leaq 0x2525(%rip), %rdi      # 0x40e0
callq 0x1840
movq 0x24f9(%rip), %rax      # 0x40c0
addq $0x1, %rax
movq %rax, 0x24ee(%rip)      # 0x40c0
jmp 0x1b8c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/one-one/test/mutex1.c
// Function: thread2
void *thread2(void *arg) {
	while(run == 1) {
        dthread_mutex_lock(&lock);
        c++;
		dthread_mutex_unlock(&lock);
		c2++;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x1, 0x249c(%rip)      # 0x4090
jne 0x1c34
leaq 0x24e3(%rip), %rdi      # 0x40e0
callq 0x17a0
movq 0x24af(%rip), %rax      # 0x40b8
addq $0x1, %rax
movq %rax, 0x24a4(%rip)      # 0x40b8
leaq 0x24c5(%rip), %rdi      # 0x40e0
callq 0x1840
movq 0x24a1(%rip), %rax      # 0x40c8
addq $0x1, %rax
movq %rax, 0x2496(%rip)      # 0x40c8
jmp 0x1bec
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/one-one/test/mutex1.c
// Function: thread3
void *thread3(void *arg) {
	while(run == 1) {
        dthread_mutex_lock(&lock);
        c++;
		dthread_mutex_unlock(&lock);
		c3++;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x1, 0x243c(%rip)      # 0x4090
jne 0x1c94
leaq 0x2483(%rip), %rdi      # 0x40e0
callq 0x17a0
movq 0x244f(%rip), %rax      # 0x40b8
addq $0x1, %rax
movq %rax, 0x2444(%rip)      # 0x40b8
leaq 0x2465(%rip), %rdi      # 0x40e0
callq 0x1840
movq 0x2449(%rip), %rax      # 0x40d0
addq $0x1, %rax
movq %rax, 0x243e(%rip)      # 0x40d0
jmp 0x1c4c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/one-one/test/mutex1.c
// Function: thread4
void *thread4(void *arg) {
	while(run == 1) {
        dthread_mutex_lock(&lock);
        c++;
		dthread_mutex_unlock(&lock);
		c4++;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x1, 0x23dc(%rip)      # 0x4090
jne 0x1cf4
leaq 0x2423(%rip), %rdi      # 0x40e0
callq 0x17a0
movq 0x23ef(%rip), %rax      # 0x40b8
addq $0x1, %rax
movq %rax, 0x23e4(%rip)      # 0x40b8
leaq 0x2405(%rip), %rdi      # 0x40e0
callq 0x1840
movq 0x23f1(%rip), %rax      # 0x40d8
addq $0x1, %rax
movq %rax, 0x23e6(%rip)      # 0x40d8
jmp 0x1cac
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/one-one/test/mutex1.c
// Function: main
int main() {
	dthread_t th1, th2, th3, th4; 
    dthread_init();
	dthread_mutex_init(&lock);
    printf("\n\n--------------------------------MUTEX LOCK TEST ---------------------------------\n\n");
    printf("***** MUTEX TEST : 1 *****\n");

	dthread_create(&th1, thread1, NULL);
	dthread_create(&th2, thread2, NULL);
	dthread_create(&th3, thread3, NULL);
	dthread_create(&th4, thread4, NULL);

	sleep(2);
	run = 0;
	dthread_join(th1, NULL);
	dthread_join(th2, NULL);
	dthread_join(th3, NULL);
	dthread_join(th4, NULL);

	if(c == c1 + c2 + c3 + c4) {
		printf(GREEN "**PASSED**: MUTEX LOCK test for race problem between 4 threads\n" NONE);
	}
	else {
		printf(RED "**FAILED**: MUTEX LOCK test for race problem between 4 threads\n" NONE);
	}
    // printf("\n%ld %ld %ld %ld %ld %ld\n", c, c1+c2+c3+c4 , c1, c2, c3, c4);

	printf("\n");
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
callq 0x1200
leaq 0x23c5(%rip), %rdi      # 0x40e0
callq 0x1780
leaq 0x31a(%rip), %rdi       # 0x2041
movb $0x0, %al
callq 0x1080
leaq 0x362(%rip), %rdi       # 0x2097
movb $0x0, %al
callq 0x1080
leaq -0x10(%rbp), %rdi
leaq -0x1c7(%rip), %rsi      # 0x1b80
xorl %eax, %eax
movl %eax, %edx
callq 0x1370
leaq -0x18(%rbp), %rdi
leaq -0x17b(%rip), %rsi      # 0x1be0
xorl %eax, %eax
movl %eax, %edx
callq 0x1370
leaq -0x20(%rbp), %rdi
leaq -0x12f(%rip), %rsi      # 0x1c40
xorl %eax, %eax
movl %eax, %edx
callq 0x1370
leaq -0x28(%rbp), %rdi
leaq -0xe3(%rip), %rsi       # 0x1ca0
xorl %eax, %eax
movl %eax, %edx
callq 0x1370
movl $0x2, %edi
callq 0x10f0
movq $0x0, 0x22ef(%rip) # 0x4090
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15d0
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15d0
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15d0
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15d0
movq 0x22dc(%rip), %rax      # 0x40b8
movq 0x22dd(%rip), %rcx      # 0x40c0
addq 0x22de(%rip), %rcx      # 0x40c8
addq 0x22df(%rip), %rcx      # 0x40d0
addq 0x22e0(%rip), %rcx      # 0x40d8
cmpq %rcx, %rax
jne 0x1e0d
leaq 0x2af(%rip), %rdi       # 0x20b3
movb $0x0, %al
callq 0x1080
jmp 0x1e1b
leaq 0x2ec(%rip), %rdi       # 0x2100
movb $0x0, %al
callq 0x1080
leaq 0x273(%rip), %rdi       # 0x2095
movb $0x0, %al
callq 0x1080
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/regftree.c
// Function: regf_parse_sk
static int regf_parse_sk(const char *pref, unsigned off)
{
	const struct regf_cell *rc = st.data + off;
	const struct regf_sk *sk = (void *)rc->data;

	if (regf_cell_check_sign_len(st.data, off, "sk", sizeof(*sk)))
		return -1;

	/* Do not print anything */

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq 0x5f3a(%rip), %rax      # 0x8100
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq 0x5f1d(%rip), %rdi      # 0x8100
movl -0x14(%rbp), %esi
leaq 0x331f(%rip), %rdx      # 0x550c
movl $0x10, %ecx
callq 0x4b20
cmpl $0x0, %eax
je 0x2205
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x220c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/regftree.c
// Function: regf_parse_lst
static int regf_parse_lst(const char *pref, unsigned off, int have_vals)
{
	const struct regf_cell *rc = st.data + off;
	const struct regf_lst *lst = (void *)rc->data;

	if (regf_cell_check_len(st.data, off, "lst", sizeof(*lst)))
		return -1;

	if (strncmp(lst->sign, "lf", 2) == 0) {
		return regf_parse_lst_lf(pref, off, have_vals);
	} else if (strncmp(lst->sign, "lh", 2) == 0) {
		return regf_parse_lst_lh(pref, off, have_vals);
	} else if (strncmp(lst->sign, "li", 2) == 0) {
		return regf_parse_lst_li(pref, off, have_vals);
	} else if (strncmp(lst->sign, "ri", 2) == 0) {
		return regf_parse_lst_ri(pref, off, have_vals);
	} else {
		PR_ERR(off, "lst", "unexpected list signature\n");
		return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq 0x5ec7(%rip), %rax      # 0x8100
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq 0x5eaa(%rip), %rdi      # 0x8100
movl -0x14(%rbp), %esi
leaq 0x370d(%rip), %rdx      # 0x596d
movl $0x4, %ecx
callq 0x4a30
cmpl $0x0, %eax
je 0x227b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2355
movq -0x28(%rbp), %rdi
leaq 0x3289(%rip), %rsi      # 0x550f
movl $0x2, %edx
callq 0x1040
cmpl $0x0, %eax
jne 0x22ac
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x2550
movl %eax, -0x4(%rbp)
jmp 0x2355
movq -0x28(%rbp), %rdi
leaq 0x325b(%rip), %rsi      # 0x5512
movl $0x2, %edx
callq 0x1040
cmpl $0x0, %eax
jne 0x22da
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x2720
movl %eax, -0x4(%rbp)
jmp 0x2355
movq -0x28(%rbp), %rdi
leaq 0x3230(%rip), %rsi      # 0x5515
movl $0x2, %edx
callq 0x1040
cmpl $0x0, %eax
jne 0x2308
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x2900
movl %eax, -0x4(%rbp)
jmp 0x2355
movq -0x28(%rbp), %rdi
leaq 0x3205(%rip), %rsi      # 0x5518
movl $0x2, %edx
callq 0x1040
cmpl $0x0, %eax
jne 0x2336
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x2ae0
movl %eax, -0x4(%rbp)
jmp 0x2355
movl -0x14(%rbp), %esi
leaq 0x31db(%rip), %rdi      # 0x551b
leaq 0x3626(%rip), %rdx      # 0x596d
movb $0x0, %al
callq 0x4760
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/regftree.c
// Function: regf_parse_lst_ri
static int regf_parse_lst_ri(const char *pref, unsigned off, int have_vals)
{
#define RI_PR_WARN(__fmt, ...)	PR_WARN(off, "ri", __fmt, ##__VA_ARGS__)
	const struct regf_cell *rc = st.data + off;
	const struct regf_lst *lst = (void *)rc->data;
	const struct regf_ri_elem *elems = (void *)lst->data;
	struct cell *cell;
	int i, res, ret = 0;

	for (i = 0; i < lst->nelem; ++i) {
		cell = cache_cell_find(elems[i].off);
		if (!cell) {
			RI_PR_WARN("could not find keys list cell 0x%08X\n",
				   elems[i].off);
			ret = -1;
			continue;
		}
		cache_cell_updref(cell, CT_LST);
		res = regf_parse_lst(pref, elems[i].off, have_vals);
		if (res) {
			RI_PR_WARN("could not parse subkey list in cell 0x%08X\n",
				   elems[i].off);
			ret = -1;
			continue;
		}
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq 0x5607(%rip), %rax      # 0x8100
movl -0xc(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x20(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jge 0x2bed
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x1c20
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x2b83
movl -0xc(%rbp), %esi
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
leaq 0x2a5d(%rip), %rdi      # 0x55c9
leaq 0x29a5(%rip), %rdx      # 0x5518
movb $0x0, %al
callq 0x4760
movl $0xffffffff, -0x3c(%rbp) # imm = 0xFFFFFFFF
jmp 0x2bdf
movq -0x30(%rbp), %rdi
movl $0x10, %esi
callq 0x1c80
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %esi
movl -0x10(%rbp), %edx
callq 0x2220
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
je 0x2bdd
movl -0xc(%rbp), %esi
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
leaq 0x2a39(%rip), %rdi      # 0x55ff
leaq 0x294b(%rip), %rdx      # 0x5518
movb $0x0, %al
callq 0x4760
movl $0xffffffff, -0x3c(%rbp) # imm = 0xFFFFFFFF
jmp 0x2bdf
jmp 0x2bdf
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2b29
movl -0x3c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)