LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/snap.c
// Function: snap
void snap(int index) {
	if (!stack[curws].fwin || stack[curws].fwin->is_e_full || stack[curws].fwin->is_i_full) {
		return;
	}

	if (index == stack[curws].fwin->snap_index) {
		snap_restore_state(stack[curws].fwin);
		return;
	}

	if (stack[curws].fwin->snap_index == SNAP_NONE) {
		snap_save_state(stack[curws].fwin, index);
	} else {
		stack[curws].fwin->snap_index = index;
	}

	update_geometry(stack[curws].fwin, MOVE_RESIZE_MASK, snap_regions[index]);

	if (state == MOVE) {
		return;
	}

	safe_raise(stack[curws].fwin);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x5683(%rip), %r15      # 0xda70
movslq (%r15), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq 0x5531(%rip), %r12      # 0xd930
movq 0x48(%r12,%rax), %r14
testq %r14, %r14
je 0x841d
cmpl $0x0, 0x190(%r14)
jne 0x841d
cmpl $0x0, 0x18c(%r14)
je 0x8426
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %edi, %ebx
movl 0x178(%r14), %eax
cmpl %edi, %eax
jne 0x845a
movl $0x7, 0x178(%r14)
leaq 0x168(%r14), %rdx
movq %r14, %rdi
movl $0xf, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5464
cmpl $0x7, %eax
jne 0x846e
leaq 0x168(%r14), %rsi
movq %r14, %rdi
callq 0x53eb
movl %ebx, 0x178(%r14)
movslq (%r15), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
movq 0x48(%r12,%rax), %rdi
movslq %ebx, %rax
shlq $0x4, %rax
leaq 0x560d(%rip), %rdx      # 0xdaa0
addq %rax, %rdx
movl $0xf, %esi
callq 0x5464
leaq 0x4f9d(%rip), %rax      # 0xd444
cmpl $0x1, (%rax)
je 0x841d
movslq (%r15), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
movq 0x48(%r12,%rax), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4f9c
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/margin.c
// Function: margin_event_helper
void margin_event_helper(xcb_generic_event_t *ev, void (*func)(int)) {
	if (state != MOVE) {
		return;
	}
	
	xcb_enter_notify_event_t *e = (xcb_enter_notify_event_t *)ev;

	for (int i = 0; i < LEN(margins); i++) {
		if (e->event == margins[i].win) {
			func(i);
			return;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x4c7a(%rip), %rax      # 0xd444
cmpl $0x1, (%rax)
jne 0x87ec
movl 0xc(%rdi), %eax
leaq 0x4b9b(%rip), %rcx      # 0xd374
xorl %edi, %edi
cmpl (%rcx), %eax
je 0x87ee
incq %rdi
addq $0x1c, %rcx
cmpq $0x7, %rdi
jne 0x87db
popq %rbp
retq
popq %rbp
jmpq *%rsi
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/color.c
// Function: hex_to_rgb
XRenderColor hex_to_rgb(uint32_t hex) {
	rgba col;
	col.v = xcb_color(hex);

	XRenderColor ret;
	ret.red = col.r * 65535 / 255;
	ret.green = col.g * 65535 / 255;
	ret.blue = col.b * 65535 / 255;
	ret.alpha = col.a * 65535 / 255;

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %ecx, %ecx
cmpl $0x1000000, %edi        # imm = 0x1000000
jb 0x8900
movl %edi, %ecx
shrl $0x18, %ecx
movl %edi, %edx
shrl $0x10, %edx
movl %edi, %esi
shrl $0x8, %esi
movl $0xff, %eax
andl %eax, %edx
imull %ecx, %edx
imulq $0x1010102, %rdx, %rdx  # imm = 0x1010102
shrq $0x20, %rdx
andl %eax, %esi
imull %ecx, %esi
imulq $0x1010102, %rsi, %rsi  # imm = 0x1010102
shrq $0x20, %rsi
movl %edi, %r8d
andl %eax, %r8d
imull %ecx, %r8d
imulq $0x1010102, %r8, %rcx   # imm = 0x1010102
shrq $0x20, %rcx
andl $0xff000000, %edi       # imm = 0xFF000000
andl %eax, %edx
shll $0x10, %edx
shll $0x8, %esi
movzwl %si, %esi
andl %eax, %ecx
orl %edi, %ecx
orl %edx, %ecx
orl %esi, %ecx
movl %ecx, %eax
shrl $0x10, %eax
movl %ecx, %esi
shrl $0x18, %esi
movl $0xff, %edi
andl %edi, %eax
movl %eax, %edx
shll $0x8, %edx
orl %eax, %edx
movl %ecx, %eax
shrl $0x8, %eax
andl %ecx, %edi
movl %edi, %r8d
shll $0x8, %r8d
orl %edi, %r8d
shldl $0x8, %ecx, %esi
shlq $0x30, %rsi
shlq $0x20, %r8
orq %rsi, %r8
shll $0x8, %ecx
andl $0xff0000, %ecx         # imm = 0xFF0000
shll $0x18, %eax
orl %ecx, %eax
orq %r8, %rax
orq %rdx, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kaiserschmarrn0[P]mywm/color.c
// Function: xft_color
XftColor xft_color(uint32_t hex) {
	XRenderColor rc = hex_to_rgb(hex);

	XftColor ret;
	XftColorAllocValue(dpy, vis_ptr, cm, &rc, &ret);

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
callq 0x8890
leaq -0x10(%rbp), %rcx
movq %rax, (%rcx)
leaq 0x4b36(%rip), %rax      # 0xd4a0
movq (%rax), %rdi
leaq 0x4b3c(%rip), %rax      # 0xd4b0
movq (%rax), %rsi
leaq 0x4b3e(%rip), %rax      # 0xd4bc
movl (%rax), %edx
leaq -0x20(%rbp), %rbx
movq %rbx, %r8
callq 0x3450
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ender672[P]liboil/oil_resample.c
// Function: oil_scale_free
void oil_scale_free(struct oil_scale *os)
{
	if (!os) {
		return;
	}

	free(os->rb);
	os->rb = NULL;
	free(os->coeffs_y);
	os->coeffs_y = NULL;
	free(os->coeffs_x);
	os->coeffs_x = NULL;
	free(os->borders_x);
	os->borders_x = NULL;
	free(os->borders_y);
	os->borders_y = NULL;
	free(os->sums_y);
	os->sums_y = NULL;
	free(os->tmp_coeffs);
	os->tmp_coeffs = NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x16a6
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
callq 0x1030
xorl %r14d, %r14d
movq %r14, 0x48(%rbx)
movq 0x20(%rbx), %rdi
callq 0x1030
movq %r14, 0x20(%rbx)
movq 0x28(%rbx), %rdi
callq 0x1030
movq %r14, 0x28(%rbx)
movq 0x30(%rbx), %rdi
callq 0x1030
movq %r14, 0x30(%rbx)
movq 0x38(%rbx), %rdi
callq 0x1030
movq %r14, 0x38(%rbx)
movq 0x40(%rbx), %rdi
callq 0x1030
movq %r14, 0x40(%rbx)
movq 0x50(%rbx), %rdi
callq 0x1030
movq %r14, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ender672[P]liboil/oil_resample.c
// Function: oil_scale_slots
int oil_scale_slots(struct oil_scale *ys)
{
	if (ys->out_height <= ys->in_height) {
		return ys->borders_y[ys->out_pos];
	}
	if (ys->in_pos) {
		return ys->borders_y[ys->in_pos - 1] == 0;
	}
	return ys->borders_y[0] == 0 ? 2 : 1;
}

// Assembly:
movl 0x4(%rdi), %eax
cmpl (%rdi), %eax
jle 0x199f
movslq 0x14(%rdi), %rdx
movq 0x38(%rdi), %rcx
xorl %eax, %eax
testq %rdx, %rdx
je 0x19ab
cmpl $0x0, -0x4(%rcx,%rdx,4)
sete %al
retq
movq 0x38(%rdi), %rax
movslq 0x18(%rdi), %rcx
movl (%rax,%rcx,4), %eax
retq
cmpl $0x1, (%rcx)
adcl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ender672[P]liboil/oil_resample.c
// Function: oil_fix_ratio
int oil_fix_ratio(int src_width, int src_height, int *out_width,
	int *out_height)
{
	double width_ratio, height_ratio, tmp;
	int *adjust_dim;

	if (src_width < 1 || src_height < 1 || *out_width < 1 || *out_height < 1) {
		return -1; // bad argument
	}

	width_ratio = *out_width / (double)src_width;
	height_ratio = *out_height / (double)src_height;
	if (width_ratio < height_ratio) {
		tmp = round(width_ratio * src_height);
		adjust_dim = out_height;
	} else {
		tmp = round(height_ratio * src_width);
		adjust_dim = out_width;
	}
	if (tmp > INT_MAX) {
		return -2; // adjusted dimension out of range
	}
	*adjust_dim = tmp ? tmp : 1;
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
testl %edi, %edi
setle %al
testl %esi, %esi
setle %cl
orb %al, %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0x2fb5
movq %rdx, %rbx
movl (%rdx), %ecx
testl %ecx, %ecx
jle 0x2fb5
movl (%r14), %edx
testl %edx, %edx
jle 0x2fb5
cvtsi2sd %ecx, %xmm0
cvtsi2sd %edi, %xmm1
divsd %xmm1, %xmm0
cvtsi2sd %edx, %xmm3
cvtsi2sd %esi, %xmm2
divsd %xmm2, %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm0, %xmm2
movsd %xmm0, 0x10(%rsp)
movsd %xmm3, 0x8(%rsp)
cmpltsd %xmm3, %xmm0
andpd %xmm0, %xmm2
andnpd %xmm1, %xmm0
orpd %xmm2, %xmm0
callq 0x1040
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
ucomisd 0x2106(%rip), %xmm0     # 0x5080
ja 0x2fb5
movsd 0x8(%rsp), %xmm1
ucomisd 0x10(%rsp), %xmm1
cmovaq %r14, %rbx
xorpd %xmm1, %xmm1
cmpneqsd %xmm0, %xmm1
movapd %xmm1, %xmm2
andpd %xmm0, %xmm2
movsd 0x20cb(%rip), %xmm0     # 0x5070
andnpd %xmm0, %xmm1
orpd %xmm2, %xmm1
cvttsd2si %xmm1, %eax
movl %eax, (%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ender672[P]liboil/oil_resample.c
// Function: calc_coeffs
static void calc_coeffs(float *coeffs, float tx, int taps, int ltrim, int rtrim)
{
	int i;
	float tmp, tap_mult, fudge;

	tap_mult = (float)taps / TAPS;
	tx = 1 - tx - taps / 2 + ltrim;
	fudge = 0.0f;

	for (i=ltrim; i<taps-rtrim; i++) {
		tmp = catrom(fabsf(tx) / tap_mult) / tap_mult;
		fudge += tmp;
		coeffs[i] = tmp;
		tx += 1;
	}
	fudge = 1 / fudge;
	for (i=ltrim; i<taps-rtrim; i++) {
		coeffs[i] *= fudge;
	}
}

// Assembly:
movl %esi, %eax
subl %ecx, %eax
xorps %xmm3, %xmm3
movl %edx, %ecx
cmpl %edx, %eax
jle 0x30c1
cvtsi2ss %esi, %xmm1
mulss 0x20ca(%rip), %xmm1     # 0x50a4
movss 0x20b2(%rip), %xmm2     # 0x5094
movaps %xmm2, %xmm3
movl %esi, %r8d
shrl $0x1f, %r8d
addl %esi, %r8d
sarl %r8d
cvtsi2ss %r8d, %xmm4
subss %xmm0, %xmm3
xorps %xmm0, %xmm0
cvtsi2ss %edx, %xmm0
subss %xmm4, %xmm3
addss %xmm3, %xmm0
leaq (%rdi,%rcx,4), %rsi
xorps %xmm3, %xmm3
movaps 0x20d8(%rip), %xmm4     # 0x50f0
movss 0x2094(%rip), %xmm5     # 0x50b4
movss 0x2090(%rip), %xmm6     # 0x50b8
movss 0x2078(%rip), %xmm7     # 0x50a8
movss 0x2073(%rip), %xmm8     # 0x50ac
movss 0x206e(%rip), %xmm9     # 0x50b0
movss 0x204d(%rip), %xmm10    # 0x5098
movl %edx, %r8d
movaps %xmm0, %xmm12
andps %xmm4, %xmm12
divss %xmm1, %xmm12
ucomiss %xmm12, %xmm2
jbe 0x3080
movaps %xmm12, %xmm11
mulss %xmm5, %xmm11
addss %xmm6, %xmm11
mulss %xmm12, %xmm11
mulss %xmm12, %xmm11
addss %xmm2, %xmm11
jmp 0x30a2
movaps %xmm7, %xmm11
subss %xmm12, %xmm11
mulss %xmm12, %xmm11
addss %xmm8, %xmm11
mulss %xmm12, %xmm11
addss %xmm9, %xmm11
mulss %xmm10, %xmm11
divss %xmm1, %xmm11
addss %xmm11, %xmm3
movss %xmm11, (%rsi)
addss %xmm2, %xmm0
addq $0x4, %rsi
incl %r8d
cmpl %r8d, %eax
jg 0x304e
cmpl %edx, %eax
jle 0x30eb
movss 0x1fc7(%rip), %xmm0     # 0x5094
divss %xmm3, %xmm0
leaq (%rdi,%rcx,4), %rcx
movss (%rcx), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rcx)
addq $0x4, %rcx
incl %edx
cmpl %edx, %eax
jg 0x30d5
retq
// File: /workspace/github_c_makefile_star2_O1/ender672[P]liboil/test.c
// Function: main
int main()
{
	int t = 1531289551;
	//int t = time(NULL);
	printf("seed: %d\n", t);
	srand(t);
	oil_global_init();
	test_scale_all();
	test_scale_catrom_extremes();
	printf("worst error: %Lf\n", worst);
	printf("All tests pass.\n");
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
leaq 0x20e7(%rip), %rdi      # 0x51e0
xorl %ebp, %ebp
movl $0x5b459fcf, %esi       # imm = 0x5B459FCF
xorl %eax, %eax
callq 0x1090
movl $0x5b459fcf, %edi       # imm = 0x5B459FCF
callq 0x10c0
callq 0x122c
movl $0x5, %edi
movl $0x1, %esi
callq 0x3254
movl $0x1, %edi
movl $0x5, %esi
callq 0x3254
movl $0x8, %edi
movl $0x1, %esi
callq 0x3254
movl $0x1, %edi
movl $0x8, %esi
callq 0x3254
movl $0x8, %edi
movl $0x3, %esi
callq 0x3254
movl $0x3, %edi
movl $0x8, %esi
callq 0x3254
movl $0x64, %edi
movl $0x1, %esi
callq 0x3254
movl $0x1, %edi
movl $0x64, %esi
callq 0x3254
movl $0x64, %edi
movl $0x63, %esi
callq 0x3254
movl $0x63, %edi
movl $0x64, %esi
callq 0x3254
movl $0x2, %edi
movl $0x1, %esi
callq 0x3254
movl $0x1, %edi
movl $0x2, %esi
callq 0x3254
movl $0x4, %edi
movl $0x4, %esi
callq 0x334e
movq %rax, %rbx
movq (%rax), %rax
movl %ebp, (%rax)
movq 0x8(%rbx), %rax
movl $0xffff00, %ecx         # imm = 0xFFFF00
movl %ecx, (%rax)
movq 0x10(%rbx), %rax
movl %ecx, (%rax)
movq 0x18(%rbx), %rax
movl %ebp, (%rax)
movl $0x4, %edi
movl $0x4, %esi
movl $0x7, %ecx
movl $0x7, %r8d
movq %rbx, %rdx
movl $0x1, %r9d
callq 0x3397
movl $0x4, %esi
movq %rbx, %rdi
callq 0x4191
fldt 0xc6b2(%rip)            # 0xf8e0
fstpt (%rsp)
leaq 0x1fb2(%rip), %rdi      # 0x51ea
xorl %eax, %eax
callq 0x1090
leaq 0x2068(%rip), %rdi      # 0x52ae
callq 0x1050
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ender672[P]liboil/test.c
// Function: test_scale_each_cs
static void test_scale_each_cs(long dim_a, long dim_b)
{
	test_scale_square_rand(dim_a, dim_b, OIL_CS_G);
	test_scale_square_rand(dim_a, dim_b, OIL_CS_GA);
	test_scale_square_rand(dim_a, dim_b, OIL_CS_RGB);
	test_scale_square_rand(dim_a, dim_b, OIL_CS_RGBA);
	test_scale_square_rand(dim_a, dim_b, OIL_CS_CMYK);
	test_scale_square_rand(dim_a, dim_b, OIL_CS_RGBX);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edx
callq 0x32bc
movq %r14, %rdi
movq %rbx, %rsi
movl $0x2, %edx
callq 0x32bc
movq %r14, %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq 0x32bc
movq %r14, %rdi
movq %rbx, %rsi
movl $0x104, %edx            # imm = 0x104
callq 0x32bc
movq %r14, %rdi
movq %rbx, %rsi
movl $0x204, %edx            # imm = 0x204
callq 0x32bc
movq %r14, %rdi
movq %rbx, %rsi
movl $0x4, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x32bc
// File: /workspace/github_c_makefile_star2_O1/ender672[P]liboil/test.c
// Function: test_scale_square_rand
static void test_scale_square_rand(long in_dim, long out_dim,
	enum oil_colorspace cs)
{
	long i, in_row_stride;
	unsigned char **input_image;

	in_row_stride = OIL_CMP(cs) * in_dim;

	/* Allocate & populate input image */
	input_image = alloc_2d_uchar(in_row_stride, in_dim);
	for (i=0; i<in_dim; i++) {
		fill_rand8(input_image[i], in_row_stride);
	}
	test_scale(in_dim, in_dim, input_image, out_dim, out_dim, cs);
	free_2d_uchar(input_image, in_dim);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
movl %edx, 0xc(%rsp)
movzbl %dl, %r12d
imulq %rdi, %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x334e
movq %rax, %r15
testq %rbx, %rbx
jle 0x331a
xorl %r13d, %r13d
testq %r12, %r12
jle 0x3312
movq (%r15,%r13,8), %rbp
xorl %r14d, %r14d
callq 0x1120
movb %al, (%rbp,%r14)
incq %r14
cmpq %r14, %r12
jne 0x3300
incq %r13
cmpq %rbx, %r13
jne 0x32f4
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq 0x10(%rsp), %rcx
movq %rcx, %r8
movl 0xc(%rsp), %r9d
callq 0x3397
movq %r15, %rdi
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4191
// File: /workspace/github_c_makefile_star2_O1/ender672[P]liboil/test.c
// Function: alloc_2d_uchar
static unsigned char **alloc_2d_uchar(long width, long height)
{
	long i;
	unsigned char **rows;

	rows = malloc(height * sizeof(unsigned char*));
	for (i=0; i<height; i++) {
		rows[i] = malloc(width * sizeof(unsigned char));
	}
	return rows;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq (,%rsi,8), %rdi
callq 0x1100
movq %rax, %r15
testq %rbx, %rbx
jle 0x3388
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x1100
movq %rax, (%r15,%r12,8)
incq %r12
cmpq %r12, %rbx
jne 0x3374
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ender672[P]liboil/test.c
// Function: free_2d_uchar
static void free_2d_uchar(unsigned char **ptr, long height)
{
	int i;

	for (i=0; i<height; i++) {
		free(ptr[i]);
	}
	free(ptr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
jle 0x41b5
movq %rsi, %r14
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x1030
incq %r15
cmpq %r15, %r14
jne 0x41a4
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/ender672[P]liboil/test.c
// Function: alloc_2d_ld
static long double **alloc_2d_ld(long width, long height)
{
	long i;
	long double **rows;

	rows = malloc(height * sizeof(long double*));
	for (i=0; i<height; i++) {
		rows[i] = malloc(width * sizeof(long double));
	}
	return rows;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq (,%rsi,8), %rdi
callq 0x1100
movq %rax, %r15
testq %rbx, %rbx
jle 0x4200
shlq $0x4, %r14
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x1100
movq %rax, (%r15,%r12,8)
incq %r12
cmpq %r12, %rbx
jne 0x41ec
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ender672[P]liboil/test.c
// Function: free_2d_ld
static void free_2d_ld(long double **ptr, long height)
{
	int i;

	for (i=0; i<height; i++) {
		free(ptr[i]);
	}
	free(ptr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
jle 0x4233
movq %rsi, %r14
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x1030
incq %r15
cmpq %r15, %r14
jne 0x4222
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/coapp-packages[P]bzip2/bzip2.c
// Function: copyFileName
static 
void copyFileName ( Char* to, Char* from ) 
{
   if ( strlen(from) > FILE_NAME_LEN-10 )  {
      fprintf (
         stderr,
         "bzip2: file name\n`%s'\n"
         "is suspiciously (more than %d chars) long.\n"
         "Try using a reasonable file name instead.  Sorry! :-)\n",
         from, FILE_NAME_LEN-10
      );
      setExit(1);
      exit(exitValue);
   }

  strncpy(to,from,FILE_NAME_LEN-10);
  to[FILE_NAME_LEN-10]='\0';
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x20f0
cmpq $0x401, %rax            # imm = 0x401
jae 0x3b4f
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2070
movb $0x0, 0x400(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x2478
// File: /workspace/github_c_makefile_star2_O1/coapp-packages[P]bzip2/bzip2.c
// Function: addFlagsFromEnvVar
static 
void addFlagsFromEnvVar ( Cell** argList, Char* varName ) 
{
   Int32 i, j, k;
   Char *envbase, *p;

   envbase = getenv(varName);
   if (envbase != NULL) {
      p = envbase;
      i = 0;
      while (True) {
         if (p[i] == 0) break;
         p += i;
         i = 0;
         while (isspace((Int32)(p[0]))) p++;
         while (p[i] != 0 && !isspace((Int32)(p[i]))) i++;
         if (i > 0) {
            k = i; if (k > FILE_NAME_LEN-10) k = FILE_NAME_LEN-10;
            for (j = 0; j < k; j++) tmpName[j] = p[j];
            tmpName[k] = 0;
            APPEND_FLAG(*argList, tmpName);
         }
      }
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2030
testq %rax, %rax
je 0x3c20
movq %rax, %r12
cmpb $0x0, (%rax)
je 0x3c20
callq 0x22a0
movq %rax, %r14
movl $0x400, %ebp            # imm = 0x400
leaq 0x11eaa(%rip), %r15     # 0x15a40
movq (%r14), %rax
leaq -0x1(%r12), %r13
incq %r12
movq %r12, %rcx
movsbq 0x1(%r13), %rdx
incq %r13
incq %r12
testb $0x20, 0x1(%rax,%rdx,2)
jne 0x3ba1
movb (%r13), %dl
xorl %r12d, %r12d
testb %dl, %dl
je 0x3bd6
movsbq %dl, %rdx
testb $0x20, 0x1(%rax,%rdx,2)
jne 0x3bd6
incl %r12d
movb (%rcx), %dl
incq %rcx
jmp 0x3bbd
testl %r12d, %r12d
je 0x3c0d
cmpl %ebp, %r12d
movl $0x400, %eax            # imm = 0x400
cmovbl %r12d, %eax
xorl %ecx, %ecx
movb (%r13,%rcx), %dl
movb %dl, (%rcx,%r15)
incq %rcx
cmpq %rcx, %rax
jne 0x3be9
movb $0x0, (%rax,%r15)
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x3c2f
movq %rax, (%rbx)
movl %r12d, %eax
leaq (%rax,%r13), %r12
cmpb $0x0, (%r13,%rax)
jne 0x3b96
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coapp-packages[P]bzip2/bzip2.c
// Function: snocString
static 
Cell *snocString ( Cell *root, Char *name )
{
   if (root == NULL) {
      Cell *tmp = mkCell();
      tmp->name = (Char*) myMalloc ( 5 + strlen(name) );
      strcpy ( tmp->name, name );
      return tmp;
   } else {
      Cell *tmp = root;
      while (tmp->link != NULL) tmp = tmp->link;
      tmp->link = snocString ( tmp->link, name );
      return root;
   }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
testq %rdi, %rdi
je 0x3c5e
movq %rdi, %rbx
movq %rdi, %rax
movq %rax, %r15
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x3c42
xorl %edi, %edi
movq %r14, %rsi
callq 0x3c2f
movq %rax, 0x8(%r15)
jmp 0x3c9c
movl $0x10, %edi
callq 0x21c0
testq %rax, %rax
je 0x3ca5
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r14, %rdi
callq 0x20f0
addl $0x5, %eax
movslq %eax, %rdi
callq 0x21c0
testq %rax, %rax
je 0x3ca5
movq %rax, (%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x20a0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x516d
// File: /workspace/github_c_makefile_star2_O1/coapp-packages[P]bzip2/bzip2.c
// Function: mySignalCatcher
static 
void mySignalCatcher ( IntNative n )
{
   fprintf ( stderr,
             "\n%s: Control-C or similar caught, quitting.\n",
             progName );
   cleanUpAndFail(1);
}

// Assembly:
pushq %rax
movq 0x10346(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
movq 0x11d64(%rip), %rdx     # 0x15a20
leaq 0xc6fd(%rip), %rsi      # 0x103c0
xorl %eax, %eax
callq 0x2180
movl $0x1, %edi
callq 0x4fe6
// File: /workspace/github_c_makefile_star2_O1/coapp-packages[P]bzip2/bzip2.c
// Function: outOfMemory
static 
void outOfMemory ( void )
{
   fprintf ( stderr,
             "\n%s: couldn't allocate enough memory\n",
             progName );
   showFileNames();
   cleanUpAndFail(1);
}

// Assembly:
pushq %rax
movq 0xee83(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
movq 0x108a1(%rip), %rdx     # 0x15a20
leaq 0xab02(%rip), %rsi      # 0xfc88
xorl %eax, %eax
callq 0x2180
callq 0x4fd1
movl $0x1, %edi
callq 0x4fe6
// File: /workspace/github_c_makefile_star2_O1/coapp-packages[P]bzip2/bzip2.c
// Function: panic
static 
void panic ( const Char* s )
{
   fprintf ( stderr,
             "\n%s: PANIC -- internal consistency error:\n"
             "\t%s\n"
             "\tThis is a BUG.  Please report it to me at:\n"
             "\tjseward@bzip.org\n",
             progName, s );
   showFileNames();
   cleanUpAndFail( 3 );
}

// Assembly:
pushq %rax
movq %rdi, %rcx
movq 0xee51(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
movq 0x1086f(%rip), %rdx     # 0x15a20
leaq 0xb3b2(%rip), %rsi      # 0x1056a
xorl %eax, %eax
callq 0x2180
callq 0x4fd1
movl $0x3, %edi
callq 0x4fe6
// File: /workspace/github_c_makefile_star2_O1/coapp-packages[P]bzip2/bzip2.c
// Function: fileExists
static 
Bool fileExists ( Char* name )
{
   FILE *tmp   = fopen ( name, "rb" );
   Bool exists = (tmp != NULL);
   if (tmp != NULL) fclose ( tmp );
   return exists;
}

// Assembly:
pushq %rbx
leaq 0xb361(%rip), %rsi      # 0x10537
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
je 0x51eb
movq %rbx, %rdi
callq 0x20e0
testq %rbx, %rbx
setne %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/coapp-packages[P]bzip2/bzip2.c
// Function: hasSuffix
static 
Bool hasSuffix ( Char* s, const Char* suffix )
{
   Int32 ns = strlen(s);
   Int32 nx = strlen(suffix);
   if (ns < nx) return False;
   if (strcmp(s + ns - nx, suffix) == 0) return True;
   return False;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x20f0
movq %rax, %r15
movq %rbx, %rdi
callq 0x20f0
cmpl %eax, %r15d
jge 0x5217
xorl %eax, %eax
jmp 0x5232
movslq %r15d, %rcx
addq %rcx, %r14
cltq
subq %rax, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2160
testl %eax, %eax
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/coapp-packages[P]bzip2/bzip2.c
// Function: fopen_output_safely
static
FILE* fopen_output_safely ( Char* name, const char* mode )
{
#  if BZ_UNIX
   FILE*     fp;
   IntNative fh;
   fh = open(name, O_WRONLY|O_CREAT|O_EXCL, S_IWUSR|S_IRUSR);
   if (fh == -1) return NULL;
   fp = fdopen(fh, mode);
   if (fp == NULL) close(fh);
   return fp;
#  else
   return fopen(name, mode);
#  endif
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0xffbe(%rip), %rdi      # 0x15200
xorl %ebx, %ebx
movl $0xc1, %esi
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x2210
cmpl $-0x1, %eax
je 0x5279
movl %eax, %ebp
leaq 0xb2d7(%rip), %rsi      # 0x1053a
movl %eax, %edi
callq 0x21f0
movq %rax, %rbx
testq %rax, %rax
jne 0x5279
movl %ebp, %edi
callq 0x2130
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coapp-packages[P]bzip2/bzip2.c
// Function: pad
static 
void pad ( Char *s )
{
   Int32 i;
   if ( (Int32)strlen(s) >= longestFileName ) return;
   for (i = 1; i <= longestFileName - (Int32)strlen(s); i++)
      fprintf ( stderr, " " );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0xfb5f(%rip), %rdi      # 0x14df0
callq 0x20f0
cmpl %eax, 0x1078c(%rip)     # 0x15a28
jle 0x52ea
movl 0x10784(%rip), %ebx     # 0x15a28
leaq 0xfb45(%rip), %rdi      # 0x14df0
callq 0x20f0
cmpl %eax, %ebx
jle 0x52ea
xorl %ebp, %ebp
movq 0xed3b(%rip), %r14      # 0x13ff8
leaq 0xfb2c(%rip), %rbx      # 0x14df0
movq (%r14), %rsi
movl $0x20, %edi
callq 0x2140
movl 0x10750(%rip), %r15d    # 0x15a28
movq %rbx, %rdi
callq 0x20f0
subl %eax, %r15d
incl %ebp
cmpl %r15d, %ebp
jl 0x52c4
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coapp-packages[P]bzip2/bzip2.c
// Function: applySavedTimeInfoToOutputFile
static 
void applySavedTimeInfoToOutputFile ( Char *dstName )
{
#  if BZ_UNIX
   IntNative      retVal;
   struct utimbuf uTimBuf;

   uTimBuf.actime = fileMetaInfo.st_atime;
   uTimBuf.modtime = fileMetaInfo.st_mtime;

   retVal = utime ( dstName, &uTimBuf );
   ERROR_IF_NOT_ZERO ( retVal );
#  endif
}

// Assembly:
subq $0x18, %rsp
movq 0x10b98(%rip), %rax     # 0x15e98
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq 0x10b99(%rip), %rax     # 0x15ea8
movq %rax, 0x8(%rsi)
leaq 0xfee6(%rip), %rdi      # 0x15200
callq 0x2040
testl %eax, %eax
jne 0x5328
addq $0x18, %rsp
retq
callq 0x532d
// File: /workspace/github_c_makefile_star2_O1/coapp-packages[P]bzip2/bzip2.c
// Function: ioError
static 
void ioError ( void )
{
   fprintf ( stderr,
             "\n%s: I/O or other error, bailing out.  "
             "Possible reason follows.\n",
             progName );
   perror ( progName );
   showFileNames();
   cleanUpAndFail( 1 );
}

// Assembly:
pushq %rax
movq 0xecc3(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
movq 0x106e1(%rip), %rdx     # 0x15a20
leaq 0xb3cc(%rip), %rsi      # 0x10712
xorl %eax, %eax
callq 0x2180
movq 0x106cc(%rip), %rdi     # 0x15a20
callq 0x2240
callq 0x4fd1
movl $0x1, %edi
callq 0x4fe6
// File: /workspace/github_c_makefile_star2_O1/coapp-packages[P]bzip2/bzip2.c
// Function: uInt64_toAscii
static
void uInt64_toAscii ( char* outbuf, UInt64* n )
{
   Int32  i, q;
   UChar  buf[32];
   Int32  nBuf   = 0;
   UInt64 n_copy = *n;
   do {
      q = uInt64_qrm10 ( &n_copy );
      buf[nBuf] = q + '0';
      nBuf++;
   } while (!uInt64_isZero(&n_copy));
   outbuf[nBuf] = 0;
   for (i = 0; i < nBuf; i++) 
      outbuf[i] = buf[nBuf-i-1];
}

// Assembly:
movq (%rsi), %rax
movq %rax, -0x30(%rsp)
xorl %edx, %edx
movq %rdx, %rax
movl $0x7, %ecx
xorl %edx, %edx
shll $0x8, %edx
movzbl -0x30(%rsp,%rcx), %esi
orl %edx, %esi
imulq $0x66666667, %rsi, %rdx # imm = 0x66666667
shrq $0x22, %rdx
movb %dl, -0x30(%rsp,%rcx)
addl %edx, %edx
leal (%rdx,%rdx,4), %r8d
movl %esi, %edx
subl %r8d, %edx
addq $-0x1, %rcx
jb 0x53c7
orb $0x30, %dl
movb %dl, -0x28(%rsp,%rax)
xorl %edx, %edx
movb -0x30(%rsp,%rdx), %cl
testb %cl, %cl
jne 0x540f
leaq 0x1(%rdx), %rsi
cmpq $0x7, %rdx
movq %rsi, %rdx
jne 0x53fa
leaq 0x1(%rax), %rdx
testb %cl, %cl
jne 0x53bd
movl %edx, %ecx
movb $0x0, (%rdi,%rcx)
movslq %eax, %rcx
addq %rsp, %rcx
addq $-0x28, %rcx
movq $-0x1, %rdx
movb (%rcx), %sil
movb %sil, 0x1(%rdi,%rdx)
decq %rcx
incq %rdx
cmpq %rdx, %rax
jne 0x542e
retq
// File: /workspace/github_c_makefile_star2_O1/coapp-packages[P]bzip2/bzip2.c
// Function: crcError
static 
void crcError ( void )
{
   fprintf ( stderr,
             "\n%s: Data integrity error when decompressing.\n",
             progName );
   showFileNames();
   cadvise();
   cleanUpAndFail( 2 );
}

// Assembly:
pushq %rax
movq 0xeb6f(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
movq 0x1058d(%rip), %rdx     # 0x15a20
leaq 0xb401(%rip), %rsi      # 0x1089b
xorl %eax, %eax
callq 0x2180
callq 0x4fd1
callq 0x5158
movl $0x2, %edi
callq 0x4fe6
// File: /workspace/github_c_makefile_star2_O1/coapp-packages[P]bzip2/bzip2.c
// Function: compressedStreamEOF
static 
void compressedStreamEOF ( void )
{
  if (noisy) {
    fprintf ( stderr,
	      "\n%s: Compressed file ends unexpectedly;\n\t"
	      "perhaps it is corrupted?  *Possible* reason follows.\n",
	      progName );
    perror ( progName );
    showFileNames();
    cadvise();
  }
  cleanUpAndFail( 2 );
}

// Assembly:
pushq %rbx
cmpb $0x0, 0xf90e(%rip)      # 0x14dcb
je 0x5534
movq 0xeb32(%rip), %rbx      # 0x13ff8
movq (%rbx), %rdi
movq 0x10550(%rip), %rdx     # 0x15a20
leaq 0xb3f3(%rip), %rsi      # 0x108ca
xorl %eax, %eax
callq 0x2180
movq 0x1053b(%rip), %rdi     # 0x15a20
callq 0x2240
cmpb $0x0, 0xf8da(%rip)      # 0x14dcb
je 0x5512
movq (%rbx), %rdi
leaq 0xa463(%rip), %rsi      # 0xf960
leaq 0xf8ec(%rip), %rdx      # 0x14df0
leaq 0xfcf5(%rip), %rcx      # 0x15200
xorl %eax, %eax
callq 0x2180
cmpb $0x0, 0xf8b2(%rip)      # 0x14dcb
je 0x5534
movq (%rbx), %rcx
leaq 0xa5fa(%rip), %rdi      # 0xfb1f
movl $0xf0, %esi
movl $0x1, %edx
callq 0x2270
movl $0x2, %edi
callq 0x4fe6
nop
// File: /workspace/github_c_makefile_star2_O1/MAGI003769[P]EE450-Socket-Project/serverC.c
// Function: parse_data2
int parse_data2(char *args[], char *data, char *edges, int *vertices) {
    char *end_str;
    char *token = strtok_r(data, "\n", &end_str);
    int i = 0;

    while (token != NULL) {
        char *end_token;
        //printf("debug: check line -- %s\n", token);
        if(i == 0) {
            split_args2(args, token);
        } else if (i < 4) {
            args[i+2] = token;
        } else {
            strcat(edges, token);
            strcat(edges, "\n");
            char *token2 = strtok_r(token, " ", &end_token);
            int j = 0;
            while (token2 != NULL && j < 2) {
                for(int k = 0; k < MAXNUMVERTICES; k++) {
                    if(vertices[k] == atoi(token2)) {
                        break;
                    } else if(vertices[k] == -1) {
                        vertices[k] = atoi(token2);
                        break;
                    }
                }
                token2 = strtok_r(NULL, " ", &end_token);
                j++;
            }
        }
        token = strtok_r(NULL, "\n", &end_str);
        i++;
    }

    int vtx_num = 0;
    while(vertices[vtx_num] != -1 && vtx_num < MAXNUMVERTICES) {
        vtx_num++;
    }
    return vtx_num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, -0x38(%rbp)
movq %rsi, %rax
movq %rdi, %r12
leaq 0xd9d(%rip), %rsi       # 0x2148
leaq -0x40(%rbp), %rdx
movq %rax, %rdi
callq 0x10b0
testq %rax, %rax
je 0x1496
movq %rax, %r15
xorl %r14d, %r14d
leaq -0x48(%rbp), %r13
movq %r12, -0x30(%rbp)
testq %r14, %r14
je 0x13e3
cmpq $0x3, %r14
ja 0x13f3
movq %r15, 0x10(%r12,%r14,8)
jmp 0x1475
movq %r12, %rdi
movq %r15, %rsi
callq 0x1343
jmp 0x1475
movq -0x38(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x1130
movq %r12, %rdi
callq 0x1050
movw $0xa, (%r12,%rax)
movq -0x30(%rbp), %r12
movq %r15, %rdi
leaq 0xe0c(%rip), %rsi       # 0x222b
movq %r13, %rdx
callq 0x10b0
testq %rax, %rax
je 0x1475
xorl %r15d, %r15d
movq %rax, %rdi
callq 0x1120
xorl %ecx, %ecx
movl (%rbx,%rcx,4), %edx
cmpl %eax, %edx
je 0x1453
cmpl $-0x1, %edx
je 0x1450
incq %rcx
cmpq $0xf, %rcx
jne 0x1439
jmp 0x1453
movl %eax, (%rbx,%rcx,4)
xorl %edi, %edi
leaq 0xdcf(%rip), %rsi       # 0x222b
movq %r13, %rdx
callq 0x10b0
testq %rax, %rax
je 0x1475
leal 0x1(%r15), %ecx
testl %r15d, %r15d
movl %ecx, %r15d
je 0x142f
xorl %edi, %edi
leaq 0xcca(%rip), %rsi       # 0x2148
leaq -0x40(%rbp), %rdx
callq 0x10b0
movq %rax, %r15
incq %r14
testq %rax, %rax
jne 0x13ce
xorl %ecx, %ecx
leaq 0x1(%rcx), %rax
cmpq $0xe, %rcx
ja 0x14ab
cmpl $-0x1, (%rbx,%rcx,4)
movq %rax, %rcx
jne 0x1498
decl %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MAGI003769[P]EE450-Socket-Project/serverC.c
// Function: get_index
int get_index(int *vtx_set, int vtx_num, int target) {
    for(int i = 0; i < vtx_num; i++) {
        if(vtx_set[i] == target)
            return i;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %esi, %esi
jle 0x14de
movl %esi, %esi
xorl %ecx, %ecx
cmpl %edx, (%rdi,%rcx,4)
je 0x14dc
incq %rcx
cmpq %rcx, %rsi
jne 0x14cd
jmp 0x14de
movl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MAGI003769[P]EE450-Socket-Project/serverC.c
// Function: add_edges
void add_edges(int vtx_num, float G[][vtx_num], int *vtx_set, char *edges) {
    char *end_str;
    char *token = strtok_r(edges, "\n", &end_str);
    int i = 0, j = 0;

    while (token != NULL) {
        char *end_token;
        //printf("debug: check line -- %s\n", token);
        int token_idx = 0;
        char *token2 = strtok_r(token, " ", &end_token);
        while (token2 != NULL) {
            if(token_idx == 0) {
                i = get_index(vtx_set, vtx_num, atoi(token2));
            } else if(token_idx == 1) {
                j = get_index(vtx_set, vtx_num, atoi(token2));
            } else {
                //printf("debug: assign edge (%d, %d): %f\n", i, j, atof(token2));
                // Assign the edge value twice as the graph is undirected
                G[i][j] = atof(token2);
                G[j][i] = atof(token2);
            }
            token2 = strtok_r(NULL, " ", &end_token);
            token_idx++;
        }
        token = strtok_r(NULL, "\n", &end_str);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, -0x48(%rbp)
movl %edi, %r15d
leaq 0xc46(%rip), %rsi       # 0x2148
leaq -0x60(%rbp), %rdx
movq %rcx, %rdi
callq 0x10b0
testq %rax, %rax
je 0x1647
movl %r15d, %r13d
movq $0x0, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
movl %r15d, -0x3c(%rbp)
movq %rax, %rdi
leaq 0xcf4(%rip), %rsi       # 0x222b
leaq -0x58(%rbp), %rdx
callq 0x10b0
testq %rax, %rax
je 0x162c
movq %rax, %r12
xorl %r14d, %r14d
cmpl $0x1, %r14d
je 0x158a
testl %r14d, %r14d
jne 0x15b1
movq %r12, %rdi
callq 0x1120
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
testl %r15d, %r15d
jle 0x160b
xorl %ecx, %ecx
cmpl %eax, (%rbx,%rcx,4)
je 0x1602
incq %rcx
cmpq %rcx, %r13
jne 0x1574
jmp 0x160b
movq %r12, %rdi
callq 0x1120
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rcx, -0x38(%rbp)
testl %r15d, %r15d
jle 0x160b
xorl %ecx, %ecx
cmpl %eax, (%rbx,%rcx,4)
je 0x1607
incq %rcx
cmpq %rcx, %r13
jne 0x15a2
jmp 0x160b
movq %r12, %rdi
callq 0x1040
cvtsd2ss %xmm0, %xmm0
movslq -0x2c(%rbp), %rax
movq %rax, -0x50(%rbp)
imulq %r13, %rax
movq -0x48(%rbp), %rcx
leaq (%rcx,%rax,4), %rax
movslq -0x38(%rbp), %r15
movss %xmm0, (%rax,%r15,4)
movq %r12, %rdi
callq 0x1040
cvtsd2ss %xmm0, %xmm0
imulq %r13, %r15
movq -0x48(%rbp), %rax
leaq (%rax,%r15,4), %rax
movl -0x3c(%rbp), %r15d
movq -0x50(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
jmp 0x160b
movl %ecx, -0x2c(%rbp)
jmp 0x160b
movq %rcx, -0x38(%rbp)
xorl %edi, %edi
leaq 0xc17(%rip), %rsi       # 0x222b
leaq -0x58(%rbp), %rdx
callq 0x10b0
movq %rax, %r12
incl %r14d
testq %rax, %rax
jne 0x154f
xorl %edi, %edi
leaq 0xb13(%rip), %rsi       # 0x2148
leaq -0x60(%rbp), %rdx
callq 0x10b0
testq %rax, %rax
jne 0x152d
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MAGI003769[P]EE450-Socket-Project/serverC.c
// Function: minDistance
int minDistance(float dist[], bool sptSet[], int V) 
{ 
    // Initialize min value 
    float min = FLT_MAX, min_index; 
  
    for (int v = 0; v < V; v++) 
        if (sptSet[v] == false && dist[v] <= min) 
            min = dist[v], min_index = v; 
  
    return min_index; 
}

// Assembly:
testl %edx, %edx
jle 0x1692
pushq %rbp
movq %rsp, %rbp
movl %edx, %eax
movss 0x99c(%rip), %xmm0      # 0x2004
xorl %ecx, %ecx
cmpb $0x0, (%rsi,%rcx)
jne 0x1684
movss (%rdi,%rcx,4), %xmm2
ucomiss %xmm2, %xmm0
jb 0x1684
xorps %xmm1, %xmm1
cvtsi2ss %ecx, %xmm1
movaps %xmm2, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x166a
cvttss2si %xmm1, %eax
popq %rbp
retq
retq
// File: /workspace/github_c_makefile_star2_O1/MAGI003769[P]EE450-Socket-Project/serverC.c
// Function: printSolution
int printSolution(int src, float dist[], int V, int parent[]) 
{ 
    //int src = 0; 
    printf("Vertex\t Distance\tPath"); 
    for (int i = 0; i < V; i++) 
    { 
        printf("\n%d -> %d \t\t %.2f\t\t%d", 
                      src, i, dist[i], src); 
        printPath(parent, i); 
    } 
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r12d
movq %rsi, %r14
movl %edi, %r15d
leaq 0x926(%rip), %rdi       # 0x200f
xorl %eax, %eax
callq 0x1060
testl %r12d, %r12d
jle 0x172e
movl %r12d, %r13d
xorl %r12d, %r12d
xorps %xmm0, %xmm0
cvtss2sd (%r14,%r12,4), %xmm0
leaq 0x91a(%rip), %rdi       # 0x2025
movl %r15d, %esi
movl %r12d, %edx
movl %r15d, %ecx
movb $0x1, %al
callq 0x1060
movq %rbx, %rdi
movl %r12d, %esi
callq 0x1693
incq %r12
cmpq %r12, %r13
jne 0x16fb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MAGI003769[P]EE450-Socket-Project/serverC.c
// Function: rec_path
void rec_path(int j, int parent[], int vtx_set[], char *path) 
{ 
      
    // Base Case : If j is source 
    if (parent[j] == - 1) 
        return; 
  
    rec_path(parent[j], parent, vtx_set, path); 

    char tmp[20] = "";
    sprintf(tmp, " -- %d", vtx_set[j]);
    strcat(path, tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movslq %edi, %r12
movl (%rsi,%r12,4), %edi
cmpl $-0x1, %edi
je 0x1798
movq %rcx, %rbx
movq %rdx, %r14
callq 0x173f
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %r15
movaps %xmm0, (%r15)
movl $0x0, 0x10(%r15)
movl (%r14,%r12,4), %edx
leaq 0x885(%rip), %rsi       # 0x2008
movq %r15, %rdi
xorl %eax, %eax
callq 0x1140
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1130
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_05/fsize.c
// Function: main
int main(int argc, char *argv[])
{
  if (argc == 1)
  {
    fsize(".");
  }
  else
  {
    while (--argc > 0)
    {
      fsize(*++argv);
    }
  }

  return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x1, %edi
jne 0x12a2
leaq 0xdae(%rip), %rdi       # 0x2049
callq 0x12cb
jmp 0x12c2
jle 0x12c2
movq %rsi, %rbx
movl %edi, %ebp
addq $0x8, %rbx
incl %ebp
movq (%rbx), %rdi
callq 0x12cb
addq $0x8, %rbx
decl %ebp
cmpl $0x2, %ebp
jg 0x12af
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_05/fsize.c
// Function: fsize
void fsize(char *name)
{
  struct stat buffer;

  if (stat(name, &buffer) == -1)
  {
    fprintf(stderr, "fsize: cannot access %s\n", name);
    return;
  }

  if ((buffer.st_mode & S_IFMT) == S_IFDIR)
  {
    dir_walk(name, fsize);
  }

  /**
   * off_t st_size         File size, in bytes
   * dev_t st_dev          ID of device containing file
   * ino_t st_ino          File serial number
   * mode_t st_mode        Mode of file (see below)
   * nlink_t st_nlink      Number of hard links
   * uid_t st_uid          User ID of the file
   * gid_t st_gid          Group ID of the file
   * dev_t st_rdev         Device ID
   * time_t st_atime       Time of last access
   * time_t st_mtime       Last data modification time
   * time_t st_ctime       Time of last status change
   * blkcnt_t st_blocks    Blocks allocated for file
   * blksize_t st_blksize  Optimal blocksize for I/O
   */

  // Printed in a similary fashion to ls -l
  print_file_flags(buffer.st_mode);
  printf("%lu ", buffer.st_nlink);
  print_file_user(buffer.st_uid);
  print_file_group(buffer.st_gid);
  print_file_size(buffer.st_size);
  print_file_time(buffer.st_atime);
  printf("%s\n", name);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
callq 0x10e0
cmpl $-0x1, %eax
je 0x1358
movl 0x20(%rsp), %ebp
movl %ebp, %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x1307
leaq -0x34(%rip), %rsi       # 0x12cb
movq %rbx, %rdi
callq 0x137c
movl %ebp, %edi
callq 0x148d
movq 0x18(%rsp), %rsi
leaq 0xd0f(%rip), %rdi       # 0x2029
xorl %eax, %eax
callq 0x1090
movl 0x24(%rsp), %edi
callq 0x156b
movl 0x28(%rsp), %edi
callq 0x158f
movq 0x38(%rsp), %rdi
callq 0x15b3
movq 0x50(%rsp), %rdi
callq 0x161e
movq %rbx, %rdi
addq $0x98, %rsp
popq %rbx
popq %rbp
jmp 0x1050
movq 0x2c99(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xca7(%rip), %rsi       # 0x2010
movq %rbx, %rdx
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %rbp
jmp 0x10d0
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_05/fsize.c
// Function: dir_walk
void dir_walk(char *dir_name, void (*func)(char *))
{
  char name[MAX_PATH_LEN];
  struct dirent *dir_entry;
  DIR *dir;

  if ((dir = opendir(dir_name)) == NULL)
  {
    fprintf(stderr, "dir_walk: cannot open %s\n", dir_name);
    return;
  }

  while ((dir_entry = readdir(dir)) != NULL)
  {
    if (strcmp(dir_entry->d_name, ".") == 0 || strcmp(dir_entry->d_name, "..") == 0)
    {
      continue; // Skip self and parent.
    }

    if (strlen(dir_name) + strlen(dir_entry->d_name) + 2 > MAX_PATH_LEN)
    {
      fprintf(stderr, "dir_walk: path too long\n");
    }
    else
    {
      sprintf(name, "%s/%s", dir_name, dir_entry->d_name);
      (*func)(name);
    }
  }

  closedir(dir);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp            # imm = 0x418
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
callq 0x1060
testq %rax, %rax
je 0x1461
movq %rax, %r15
movq %rax, %rdi
callq 0x10f0
testq %rax, %rax
je 0x1447
movq %rax, %r13
leaq 0xc88(%rip), %r12       # 0x2049
leaq 0x10(%rsp), %rbp
addq $0x13, %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x10c0
testl %eax, %eax
je 0x142e
movq %r13, %rdi
leaq 0xc65(%rip), %rsi       # 0x2048
callq 0x10c0
testl %eax, %eax
je 0x142e
movq %rbx, %rdi
callq 0x1080
movq %rax, %r14
movq %r13, %rdi
callq 0x1080
addq %r14, %rax
addq $-0x3ff, %rax           # imm = 0xFC01
cmpq $-0x402, %rax           # imm = 0xFBFE
jbe 0x1440
movq %rbp, %rdi
leaq 0xc4a(%rip), %rsi       # 0x2064
movq %rbx, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x1110
movq %rbp, %rdi
callq *0x8(%rsp)
movq %r15, %rdi
callq 0x10f0
movq %rax, %r13
testq %rax, %rax
jne 0x13c6
jmp 0x1447
callq 0x1140
jmp 0x142e
movq %r15, %rdi
callq 0x10b0
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2b90(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xbbc(%rip), %rsi       # 0x202e
movq %rbx, %rdx
xorl %eax, %eax
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10d0
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_05/fsize.c
// Function: print_file_flags
void print_file_flags(mode_t st_mode)
{
  printf("%c", ((st_mode & S_IFMT) == S_IFDIR) ? 'd' : '-');
  printf("%c", (st_mode & S_IRUSR) ? 'r' : '-');
  printf("%c", (st_mode & S_IWUSR) ? 'w' : '-');
  printf("%c", (st_mode & S_IXUSR) ? 'x' : '-');
  printf("%c", (st_mode & S_IRGRP) ? 'r' : '-');
  printf("%c", (st_mode & S_IWGRP) ? 'w' : '-');
  printf("%c", (st_mode & S_IXGRP) ? 'x' : '-');
  printf("%c", (st_mode & S_IROTH) ? 'r' : '-');
  printf("%c", (st_mode & S_IWOTH) ? 'w' : '-');
  printf("%c ", (st_mode & S_IXOTH) ? 'x' : '-');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebx
movl %edi, %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
movl $0x64, %edi
movl $0x2d, %r12d
cmovnel %r12d, %edi
callq 0x1030
btl $0x8, %ebx
movl $0x72, %ebp
movl $0x72, %edi
cmovael %r12d, %edi
callq 0x1030
testb %bl, %bl
movl $0x77, %r15d
movl $0x77, %edi
cmovnsl %r12d, %edi
callq 0x1030
testb $0x40, %bl
movl $0x78, %r14d
movl $0x78, %edi
cmovel %r12d, %edi
callq 0x1030
testb $0x20, %bl
movl $0x72, %edi
cmovel %r12d, %edi
callq 0x1030
testb $0x10, %bl
movl $0x77, %edi
cmovel %r12d, %edi
callq 0x1030
testb $0x8, %bl
movl $0x78, %edi
cmovel %r12d, %edi
callq 0x1030
testb $0x4, %bl
cmovel %r12d, %ebp
movl %ebp, %edi
callq 0x1030
testb $0x2, %bl
cmovel %r12d, %r15d
movl %r15d, %edi
callq 0x1030
testb $0x1, %bl
cmovel %r12d, %r14d
leaq 0xb11(%rip), %rdi       # 0x206a
movl %r14d, %esi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1090
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_05/fsize.c
// Function: print_file_user
void print_file_user(uid_t st_uid)
{
  struct passwd *password;
  password = getpwuid(st_uid);

  if (password == NULL)
  {
    fprintf(stderr, "Error: cannot find user\n");
    return;
  }

  printf("%s ", password->pw_name);
}

// Assembly:
pushq %rax
callq 0x1070
testq %rax, %rax
je 0x1588
movq (%rax), %rsi
leaq 0xb2c(%rip), %rdi       # 0x20ac
xorl %eax, %eax
popq %rcx
jmp 0x1090
callq 0x1162
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_05/fsize.c
// Function: print_file_group
void print_file_group(gid_t st_gid)
{
  struct group *group;
  group = getgrgid(st_gid);

  if (group == NULL)
  {
    fprintf(stderr, "Error: cannot find group\n");
    return;
  }

  printf("%s ", group->gr_name);
}

// Assembly:
pushq %rax
callq 0x10a0
testq %rax, %rax
je 0x15ac
movq (%rax), %rsi
leaq 0xb08(%rip), %rdi       # 0x20ac
xorl %eax, %eax
popq %rcx
jmp 0x1090
callq 0x117e
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_05/fsize.c
// Function: print_file_size
void print_file_size(size_t size)
{
  static const char *SIZES[] = {"B", "K", "M", "G"};
  size_t div = 0;
  size_t rem = 0;

  while (size >= 1024 && div < (sizeof SIZES / sizeof *SIZES))
  {
    rem = (size % 1024);
    div++;
    size /= 1024;
  }

  printf("%6.1f%s ", (float)size + (float)rem / 1024.0, SIZES[div]);
}

// Assembly:
cmpq $0x400, %rdi            # imm = 0x400
jb 0x15ef
xorl %edx, %edx
movq %rdi, %rcx
leaq 0x1(%rdx), %rax
shrq $0xa, %rdi
cmpq $0x100000, %rcx         # imm = 0x100000
jb 0x15db
cmpq $0x3, %rdx
movq %rax, %rdx
jb 0x15be
andl $0x3ff, %ecx            # imm = 0x3FF
cvtsi2sd %ecx, %xmm1
mulsd 0xa1b(%rip), %xmm1      # 0x2008
jmp 0x15f5
xorpd %xmm1, %xmm1
xorl %eax, %eax
cvtsi2ss %rdi, %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm1, %xmm0
leaq 0xab3(%rip), %rcx       # 0x20bc
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
leaq 0xa90(%rip), %rdi       # 0x20a7
movb $0x1, %al
jmp 0x1090
// File: /workspace/github_c_makefile_star2_O1/dropletzhu[P]msuite/pim_sender.c
// Function: csum
unsigned short
csum (unsigned short *buf, int nwords)
{
	unsigned long sum;
	for (sum = 0; nwords > 0; nwords--)
		sum += *buf++;
	sum = (sum >> 16) + (sum & 0xffff);
	sum += (sum >> 16);

	return ~sum;
}

// Assembly:
testl %esi, %esi
jle 0x1227
incl %esi
xorl %eax, %eax
movzwl (%rdi), %ecx
addq $0x2, %rdi
addq %rcx, %rax
decl %esi
cmpl $0x1, %esi
jg 0x1214
jmp 0x1229
xorl %eax, %eax
movq %rax, %rcx
shrq $0x10, %rcx
movzwl %ax, %eax
addl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
addl %ecx, %eax
notl %eax
retq