LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/phoboslab[P]pl_mpeg/./pl_mpeg.h
// Function: plm_video_init_frame
void plm_video_init_frame(plm_video_t *self, plm_frame_t *frame, uint8_t *base) {
	size_t luma_plane_size = self->luma_width * self->luma_height;
	size_t chroma_plane_size = self->chroma_width * self->chroma_height;

	frame->width = self->width;
	frame->height = self->height;
	frame->y.width = self->luma_width;
	frame->y.height = self->luma_height;
	frame->y.data = base;

	frame->cr.width = self->chroma_width;
	frame->cr.height = self->chroma_height;
	frame->cr.data = base + luma_plane_size;

	frame->cb.width = self->chroma_width;
	frame->cb.height = self->chroma_height;
	frame->cb.data = base + luma_plane_size + chroma_plane_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x34(%rcx), %eax
cltq
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x3c(%rcx), %eax
cltq
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x34(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x18(%rbp), %rcx
addq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x18(%rbp), %rcx
addq -0x20(%rbp), %rcx
addq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phoboslab[P]pl_mpeg/./pl_mpeg.h
// Function: plm_video_decode_slice
void plm_video_decode_slice(plm_video_t *self, int slice) {
	self->slice_begin = TRUE;
	self->macroblock_address = (slice - 1) * self->mb_width - 1;

	// Reset motion vectors and DC predictors
	self->motion_backward.h = self->motion_forward.h = 0;
	self->motion_backward.v = self->motion_forward.v = 0;
	self->dc_predictor[0] = 128;
	self->dc_predictor[1] = 128;
	self->dc_predictor[2] = 128;

	self->quantizer_scale = plm_buffer_read(self->buffer, 5);

	// Skip extra
	while (plm_buffer_read(self->buffer, 1)) {
		plm_buffer_skip(self->buffer, 8);
	}

	do {
		plm_video_decode_macroblock(self);
	} while (
		self->macroblock_address < self->mb_size - 1 &&
		plm_buffer_peek_non_zero(self->buffer, 23)
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, 0x78(%rax)
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
imull 0x24(%rax), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x7c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x54(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x68(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x58(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x6c(%rax)
movq -0x8(%rbp), %rax
movl $0x80, 0x90(%rax)
movq -0x8(%rbp), %rax
movl $0x80, 0x94(%rax)
movq -0x8(%rbp), %rax
movl $0x80, 0x98(%rax)
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rdi
movl $0x5, %esi
callq 0x5320
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x74(%rax)
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rdi
movl $0x1, %esi
callq 0x5320
cmpl $0x0, %eax
je 0x6377
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rdi
movl $0x8, %esi
callq 0x5450
jmp 0x6346
jmp 0x6379
movq -0x8(%rbp), %rdi
callq 0x63d0
movq -0x8(%rbp), %rax
movl 0x7c(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %edx
subl $0x1, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0xd(%rbp)
jge 0x63ba
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rdi
movl $0x17, %esi
callq 0x5690
cmpl $0x0, %eax
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x6379
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phoboslab[P]pl_mpeg/./pl_mpeg.h
// Function: plm_video_predict_macroblock
void plm_video_predict_macroblock(plm_video_t *self) {
	int fw_h = self->motion_forward.h;
	int fw_v = self->motion_forward.v;

	if (self->motion_forward.full_px) {
		fw_h <<= 1;
		fw_v <<= 1;
	}

	if (self->picture_type == PLM_VIDEO_PICTURE_TYPE_B) {
		int bw_h = self->motion_backward.h;
		int bw_v = self->motion_backward.v;

		if (self->motion_backward.full_px) {
			bw_h <<= 1;
			bw_v <<= 1;
		}

		if (self->motion_forward.is_set) {
			plm_video_copy_macroblock(self, &self->frame_forward, fw_h, fw_v);
			if (self->motion_backward.is_set) {
				plm_video_interpolate_macroblock(self, &self->frame_backward, bw_h, bw_v);
			}
		}
		else {
			plm_video_copy_macroblock(self, &self->frame_backward, bw_h, bw_v);
		}
	}
	else {
		plm_video_copy_macroblock(self, &self->frame_forward, fw_h, fw_v);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x54(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x58(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x48(%rax)
je 0x67aa
movl -0xc(%rbp), %eax
shll %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
shll %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x3, 0x44(%rax)
jne 0x684c
movq -0x8(%rbp), %rax
movl 0x68(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x5c(%rax)
je 0x67e6
movl -0x14(%rbp), %eax
shll %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
shll %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4c(%rax)
je 0x6830
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0xf0, %rsi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
callq 0x71d0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x60(%rax)
je 0x682e
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x130, %rsi            # imm = 0x130
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x72d0
jmp 0x684a
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x130, %rsi            # imm = 0x130
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x71d0
jmp 0x6866
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0xf0, %rsi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
callq 0x71d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phoboslab[P]pl_mpeg/./pl_mpeg.h
// Function: plm_video_decode_motion_vectors
void plm_video_decode_motion_vectors(plm_video_t *self) {

	// Forward
	if (self->motion_forward.is_set) {
		int r_size = self->motion_forward.r_size;
		self->motion_forward.h = plm_video_decode_motion_vector(self, r_size, self->motion_forward.h);
		self->motion_forward.v = plm_video_decode_motion_vector(self, r_size, self->motion_forward.v);
	}
	else if (self->picture_type == PLM_VIDEO_PICTURE_TYPE_PREDICTIVE) {
		// No motion information in P-picture, reset vectors
		self->motion_forward.h = 0;
		self->motion_forward.v = 0;
	}

	if (self->motion_backward.is_set) {
		int r_size = self->motion_backward.r_size;
		self->motion_backward.h = plm_video_decode_motion_vector(self, r_size, self->motion_backward.h);
		self->motion_backward.v = plm_video_decode_motion_vector(self, r_size, self->motion_backward.v);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4c(%rax)
je 0x68ca
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movl 0x54(%rax), %edx
callq 0x70e0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x54(%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movl 0x58(%rax), %edx
callq 0x70e0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x58(%rax)
jmp 0x68ec
movq -0x8(%rbp), %rax
cmpl $0x2, 0x44(%rax)
jne 0x68ea
movq -0x8(%rbp), %rax
movl $0x0, 0x54(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x58(%rax)
jmp 0x68ec
movq -0x8(%rbp), %rax
cmpl $0x0, 0x60(%rax)
je 0x6938
movq -0x8(%rbp), %rax
movl 0x64(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movq -0x8(%rbp), %rax
movl 0x68(%rax), %edx
callq 0x70e0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x68(%rax)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %edx
callq 0x70e0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x6c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/phoboslab[P]pl_mpeg/./pl_mpeg.h
// Function: plm_video_decode_motion_vector
int plm_video_decode_motion_vector(plm_video_t *self, int r_size, int motion) {
	int fscale = 1 << r_size;
	int m_code = plm_buffer_read_vlc(self->buffer, PLM_VIDEO_MOTION);
	int r = 0;
	int d;

	if ((m_code != 0) && (fscale != 1)) {
		r = plm_buffer_read(self->buffer, r_size);
		d = ((abs(m_code) - 1) << r_size) + r + 1;
		if (m_code < 0) {
			d = -d;
		}
	}
	else {
		d = m_code;
	}

	motion += d;
	if (motion > (fscale << 4) - 1) {
		motion -= fscale << 5;
	}
	else if (motion < (int)((unsigned)(-fscale) << 4)) {
		motion += fscale << 5;
	}

	return motion;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rdi
leaq 0x641f(%rip), %rsi      # 0xd530
callq 0x5700
cwtl
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x716e
cmpl $0x1, -0x14(%rbp)
je 0x716e
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x5320
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
subl $0x1, %eax
movl -0xc(%rbp), %ecx
shll %cl, %eax
addl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x716c
xorl %eax, %eax
subl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x7174
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0x14(%rbp), %ecx
shll $0x4, %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x719d
movl -0x14(%rbp), %ecx
shll $0x5, %ecx
movl -0x10(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x10(%rbp)
jmp 0x71ba
movl -0x10(%rbp), %eax
xorl %ecx, %ecx
subl -0x14(%rbp), %ecx
shll $0x4, %ecx
cmpl %ecx, %eax
jge 0x71b8
movl -0x14(%rbp), %eax
shll $0x5, %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x71ba
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phoboslab[P]pl_mpeg/./pl_mpeg.h
// Function: plm_video_copy_macroblock
void plm_video_copy_macroblock(plm_video_t *self, plm_frame_t *s, int motion_h, int motion_v) {
	plm_frame_t *d = &self->frame_current;
	plm_video_process_macroblock(self, s->y.data, d->y.data, motion_h, motion_v, 16, FALSE);
	plm_video_process_macroblock(self, s->cr.data, d->cr.data, motion_h / 2, motion_v / 2, 8, FALSE);
	plm_video_process_macroblock(self, s->cb.data, d->cb.data, motion_h / 2, motion_v / 2, 8, FALSE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl $0x10, %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x73c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x18(%rbp), %eax
movl $0x2, %r8d
cltd
idivl %r8d
movq -0x30(%rbp), %rdx
movl %eax, %r8d
movl $0x8, %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x73c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x18(%rbp), %eax
movl $0x2, %r8d
cltd
idivl %r8d
movq -0x28(%rbp), %rdx
movl %eax, %r8d
movl $0x8, %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x73c0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phoboslab[P]pl_mpeg/./pl_mpeg.h
// Function: plm_video_interpolate_macroblock
void plm_video_interpolate_macroblock(plm_video_t *self, plm_frame_t *s, int motion_h, int motion_v) {
	plm_frame_t *d = &self->frame_current;
	plm_video_process_macroblock(self, s->y.data, d->y.data, motion_h, motion_v, 16, TRUE);
	plm_video_process_macroblock(self, s->cr.data, d->cr.data, motion_h / 2, motion_v / 2, 8, TRUE);
	plm_video_process_macroblock(self, s->cb.data, d->cb.data, motion_h / 2, motion_v / 2, 8, TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl $0x10, %r9d
movl $0x1, (%rsp)
callq 0x73c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x18(%rbp), %eax
movl $0x2, %r8d
cltd
idivl %r8d
movq -0x30(%rbp), %rdx
movl %eax, %r8d
movl $0x8, %r9d
movl $0x1, (%rsp)
callq 0x73c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x18(%rbp), %eax
movl $0x2, %r8d
cltd
idivl %r8d
movq -0x28(%rbp), %rdx
movl %eax, %r8d
movl $0x8, %r9d
movl $0x1, (%rsp)
callq 0x73c0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phoboslab[P]pl_mpeg/./pl_mpeg.h
// Function: plm_clamp
static inline uint8_t plm_clamp(int n) {
	if (n > 255) {
		n = 255;
	}
	else if (n < 0) {
		n = 0;
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
cmpl $0xff, -0x4(%rbp)
jle 0x7b39
movl $0xff, -0x4(%rbp)
jmp 0x7b48
cmpl $0x0, -0x4(%rbp)
jge 0x7b46
movl $0x0, -0x4(%rbp)
jmp 0x7b48
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phoboslab[P]pl_mpeg/./pl_mpeg.h
// Function: plm_audio_find_frame_sync
int plm_audio_find_frame_sync(plm_audio_t *self) {
	size_t i;
	for (i = self->buffer->bit_index >> 3; i < self->buffer->length-1; i++) {
		if (
			self->buffer->bytes[i] == 0xFF &&
			(self->buffer->bytes[i+1] & 0xFE) == 0xFC
		) {
			self->buffer->bit_index = ((i+1) << 3) + 3;
			return TRUE;
		}
	}
	self->buffer->bit_index = (i + 1) << 3;
	return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0xa157
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x58(%rax), %rax
movq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xff, %eax
jne 0xa144
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x58(%rax), %rax
movq -0x18(%rbp), %rcx
movzbl 0x1(%rax,%rcx), %eax
andl $0xfe, %eax
cmpl $0xfc, %eax
jne 0xa144
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
shlq $0x3, %rcx
addq $0x3, %rcx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xa175
jmp 0xa146
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xa0cb
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
shlq $0x3, %rcx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phoboslab[P]pl_mpeg/pl_mpeg_player_sdl.c
// Function: app_on_audio
void app_on_audio(plm_t *mpeg, plm_samples_t *samples, void *user) {
	app_t *self = (app_t *)user;

	// Hand the decoded samples over to SDL
	
	int size = sizeof(float) * samples->count * 2;
	SDL_QueueAudio(self->audio_device, samples->interleaved, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
shlq $0x2, %rax
shlq %rax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl 0x40(%rax), %edi
movq -0x10(%rbp), %rsi
addq $0xc, %rsi
movl -0x24(%rbp), %edx
callq 0x2280
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phoboslab[P]pl_mpeg/pl_mpeg_player_sdl.c
// Function: app_destroy
void app_destroy(app_t *self) {
	plm_destroy(self->plm);

	if (self->audio_device) {
		SDL_CloseAudioDevice(self->audio_device);
	}

	if (self->texture) {
		SDL_DestroyTexture(self->texture);
	}

	if (self->renderer) {
		SDL_DestroyRenderer(self->renderer);
	}

	if (self->window) {
		SDL_DestroyWindow(self->window);
	}

	SDL_Quit();
	
	free(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2d70
movq -0x8(%rbp), %rax
cmpl $0x0, 0x40(%rax)
je 0xc49e
movq -0x8(%rbp), %rax
movl 0x40(%rax), %edi
callq 0x20c0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xc4b6
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2110
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xc4ce
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x20b0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xc4e6
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2040
callq 0x2070
movq -0x8(%rbp), %rdi
callq 0x21b0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phoboslab[P]pl_mpeg/pl_mpeg_player_sdl.c
// Function: main
int main(int argc, char *argv[]) {
	if (argc < 2) {
		SDL_Log("Usage: pl_mpeg_player_sdl <file.mpg>");
		exit(1);
	}

	SDL_SetMainReady();
	
	app_t *app = app_create(argv[1]);
	while (!app->wants_to_quit) {
		app_update(app);
	}
	app_destroy(app);
	
	return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0xc744
leaq 0x1f04(%rip), %rdi      # 0xe637
movb $0x0, %al
callq 0x21f0
movl $0x1, %edi
callq 0x21c0
callq 0x2100
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xc060
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xc76d
jmp 0xc778
movq -0x18(%rbp), %rdi
callq 0xc500
jmp 0xc75a
movq -0x18(%rbp), %rdi
callq 0xc470
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/context_switch1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	struct args *a;
	char c;
	int ret;
	a = malloc(sizeof(struct args));
	assert(pipe(a->fd1) == 0);
	assert(pipe(a->fd2) == 0);

	new_task(child, a);

	while (1) {
		do {
			ret = write(a->fd1[WRITE], &c, 1);
		} while (ret != 1 && errno == EINTR);
		assert(ret == 1);

		do {
			ret = read(a->fd2[READ], &c, 1);
		} while (ret != 1 && errno == EINTR);
		assert(ret == 1);
			
		(*iterations) += 2;
	}

	free(a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
callq 0x11c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1150
cmpl $0x0, %eax
jne 0x204e
jmp 0x206d
leaq 0x121c(%rip), %rdi      # 0x3271
leaq 0x1227(%rip), %rsi      # 0x3283
movl $0x2d, %edx
leaq 0x1233(%rip), %rcx      # 0x329b
callq 0x1120
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x1150
cmpl $0x0, %eax
jne 0x2081
jmp 0x20a0
leaq 0x1246(%rip), %rdi      # 0x32ce
leaq 0x11f4(%rip), %rsi      # 0x3283
movl $0x2e, %edx
leaq 0x1200(%rip), %rcx      # 0x329b
callq 0x1120
movq -0x18(%rbp), %rsi
leaq 0xe5(%rip), %rdi        # 0x2190
callq 0x13b0
jmp 0x20b2
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edi
leaq -0x19(%rbp), %rsi
movl $0x1, %edx
callq 0x10c0
movl %eax, -0x20(%rbp)
xorl %eax, %eax
cmpl $0x1, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0x20e3
callq 0x1070
cmpl $0x4, (%rax)
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x20b2
cmpl $0x1, -0x20(%rbp)
jne 0x20f2
jmp 0x2111
leaq 0x11e7(%rip), %rdi      # 0x32e0
leaq 0x1183(%rip), %rsi      # 0x3283
movl $0x36, %edx
leaq 0x118f(%rip), %rcx      # 0x329b
callq 0x1120
jmp 0x2113
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edi
leaq -0x19(%rbp), %rsi
movl $0x1, %edx
callq 0x1160
movl %eax, -0x20(%rbp)
xorl %eax, %eax
cmpl $0x1, -0x20(%rbp)
movb %al, -0x22(%rbp)
je 0x2144
callq 0x1070
cmpl $0x4, (%rax)
sete %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
testb $0x1, %al
jne 0x2113
cmpl $0x1, -0x20(%rbp)
jne 0x2153
jmp 0x2172
leaq 0x1186(%rip), %rdi      # 0x32e0
leaq 0x1122(%rip), %rsi      # 0x3283
movl $0x3b, %edx
leaq 0x112e(%rip), %rcx      # 0x329b
callq 0x1120
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
jmp 0x20b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/context_switch1.c
// Function: child
static void *child(void *arg)
{
	struct args *a = arg;
	char c;
	int ret;

	while (1) {
		do {
			ret = read(a->fd1[READ], &c, 1);
		} while (ret != 1 && errno == EINTR);
		assert(ret == 1);

		do {
			ret = write(a->fd2[WRITE], &c, 1);
		} while (ret != 1 && errno == EINTR);
		assert(ret == 1);
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x21a6
movq -0x10(%rbp), %rax
movl (%rax), %edi
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
callq 0x1160
movl %eax, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x1, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x21d6
callq 0x1070
cmpl $0x4, (%rax)
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x21a6
cmpl $0x1, -0x18(%rbp)
jne 0x21e5
jmp 0x2204
leaq 0x10f4(%rip), %rdi      # 0x32e0
leaq 0x1090(%rip), %rsi      # 0x3283
movl $0x1c, %edx
leaq 0x10ea(%rip), %rcx      # 0x32e9
callq 0x1120
jmp 0x2206
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edi
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
callq 0x10c0
movl %eax, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x1, -0x18(%rbp)
movb %al, -0x1a(%rbp)
je 0x2237
callq 0x1070
cmpl $0x4, (%rax)
sete %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0x2206
cmpl $0x1, -0x18(%rbp)
jne 0x2246
jmp 0x2265
leaq 0x1093(%rip), %rdi      # 0x32e0
leaq 0x102f(%rip), %rsi      # 0x3283
movl $0x21, %edx
leaq 0x1089(%rip), %rcx      # 0x32e9
callq 0x1120
jmp 0x21a4
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/glob6.c
// Function: main
int
main(int argc, char **argv)
{
	const char **gav;	/* points to generated argument vector */
	int pmc = 0;		/* pattern-match count                 */

	setmyerrexit(&ut_errexit);
	setmyname(argv[0]);
	setmypid(getpid());

	/*
	 * Set-ID execution is not supported.
	 */
	if (geteuid() != getuid() || getegid() != getgid())
		err(SH_ERR, FMT1S, ERR_SETID);

	if (argc < 2)
		err(SH_ERR, FMT1S, ERR_GARGCOUNT);

	if ((gav = malloc(GAVNEW * sizeof(char *))) == NULL)
		err(SH_ERR, FMT1S, ERR_NOMEM);

	*gav = NULL, gavp = gav;
	gave = &gav[GAVNEW - 1];
	while (*++argv != NULL)
		gav = glob1(gav, *argv, &pmc);
	gavp = NULL;

	if (pmc == 0)
		err(SH_ERR, FMT1S, ERR_NOMATCH);

	(void)err_pexec(gav[0], (char *const *)gav);
	/*NOTREACHED*/
	return SH_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
leaq 0xf5c(%rip), %rdi       # 0x2250
callq 0x2160
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2180
callq 0x10b0
movl %eax, %edi
callq 0x2230
callq 0x1110
movl %eax, -0x20(%rbp)
callq 0x10e0
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
jne 0x133d
callq 0x1190
movl %eax, -0x24(%rbp)
callq 0x1160
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
je 0x1357
movl $0x2, %edi
leaq 0x1ee0(%rip), %rsi      # 0x3229
leaq 0x1db7(%rip), %rdx      # 0x3107
movb $0x0, %al
callq 0x1e00
cmpl $0x2, -0x8(%rbp)
jge 0x1377
movl $0x2, %edi
leaq 0x1ec0(%rip), %rsi      # 0x3229
leaq 0x1daf(%rip), %rdx      # 0x311f
movb $0x0, %al
callq 0x1e00
movl $0x400, %edi            # imm = 0x400
callq 0x1180
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x13a5
movl $0x2, %edi
leaq 0x1e92(%rip), %rsi      # 0x3229
leaq 0x1d8b(%rip), %rdx      # 0x3129
movb $0x0, %al
callq 0x1e00
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x3d4d(%rip)      # 0x5108
movq -0x18(%rbp), %rax
addq $0x3f8, %rax            # imm = 0x3F8
movq %rax, 0x3d44(%rip)      # 0x5110
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x13fc
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x1450
movq %rax, -0x18(%rbp)
jmp 0x13cc
movq $0x0, 0x3d01(%rip) # 0x5108
cmpl $0x0, -0x1c(%rbp)
jne 0x1427
movl $0x2, %edi
leaq 0x1e10(%rip), %rsi      # 0x3229
leaq 0x1d17(%rip), %rdx      # 0x3137
movb $0x0, %al
callq 0x1e00
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x26a0
movl $0x2, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/glob6.c
// Function: gnew
static const char **
gnew(const char **gav)
{
	size_t siz;
	ptrdiff_t gidx;
	const char **nav;
	static unsigned mult = 1;

	if (gavp == gave) {
		mult *= GAVMULT;
		gidx  = (ptrdiff_t)(gavp - gav);
		siz   = (size_t)((gidx + (GAVNEW * mult)) * sizeof(char *));
		if ((nav = realloc(gav, siz)) == NULL)
			err(SH_ERR, FMT1S, ERR_NOMEM);
		gav   = nav;
		gavp  = gav + gidx;
		gave  = &gav[gidx + (GAVNEW * mult) - 1];
	}
	return gav;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x3a15(%rip), %rax      # 0x5108
cmpq 0x3a16(%rip), %rax      # 0x5110
jne 0x17b5
movl 0x39f2(%rip), %eax      # 0x50f8
shll %eax
movl %eax, 0x39ea(%rip)      # 0x50f8
movq 0x39f3(%rip), %rax      # 0x5108
movq -0x8(%rbp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x39ca(%rip), %ecx      # 0x50f8
shll $0x7, %ecx
movl %ecx, %ecx
addq %rcx, %rax
shlq $0x3, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11a0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x176f
movl $0x2, %edi
leaq 0x1ac8(%rip), %rsi      # 0x3229
leaq 0x19c1(%rip), %rdx      # 0x3129
movb $0x0, %al
callq 0x1e00
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x397b(%rip)      # 0x5108
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x395d(%rip), %edx      # 0x50f8
shll $0x7, %edx
movl %edx, %edx
addq %rdx, %rcx
subq $0x1, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x395b(%rip)      # 0x5110
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/glob6.c
// Function: gcat
static char *
gcat(const char *src1, const char *src2)
{
	size_t siz;
	char *b, buf[PATHMAX], c, *dst;
	const char *s;

	*buf = EOS, b = buf, s = src1;
	while ((c = *s++) != EOS) {
		if (b >= &buf[PATHMAX - 1])
			err(SH_ERR, FMT1S, strerror(ENAMETOOLONG));
		if ((c &= ASCII) == EOS) {
			*b++ = SLASH;
			break;
		}
		*b++ = c;
	}

	s = src2;
	do {
		if (b >= &buf[PATHMAX])
			err(SH_ERR, FMT1S, strerror(ENAMETOOLONG));
		*b++ = c = *s++;
	} while (c != EOS);

	siz = b - buf;
	gavtot += siz;
	if (gavtot > GAVMAX)
		err(SH_ERR, FMT1S, ERR_E2BIG);
	if ((dst = malloc(siz)) == NULL) {
		err(SH_ERR, FMT1S, ERR_NOMEM);
		/*NOTREACHED*/
	}

	(void)memcpy(dst, buf, siz);
	return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1040, %rsp           # imm = 0x1040
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x1020(%rbp)
leaq -0x1020(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1038(%rbp)
movq -0x1038(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x1038(%rbp)
movb (%rax), %al
movb %al, -0x1021(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x1894
movq -0x20(%rbp), %rax
leaq -0x1020(%rbp), %rcx
addq $0xfff, %rcx            # imm = 0xFFF
cmpq %rcx, %rax
jb 0x184c
movl $0x24, %edi
callq 0x11c0
movq %rax, %rdx
movl $0x2, %edi
leaq 0x19e4(%rip), %rsi      # 0x3229
movb $0x0, %al
callq 0x1e00
movsbl -0x1021(%rbp), %eax
andl $0x7f, %eax
movb %al, -0x1021(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x1878
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x2f, (%rax)
jmp 0x1894
movb -0x1021(%rbp), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
jmp 0x17f0
movq -0x10(%rbp), %rax
movq %rax, -0x1038(%rbp)
movq -0x20(%rbp), %rax
leaq -0x1020(%rbp), %rcx
addq $0x1000, %rcx           # imm = 0x1000
cmpq %rcx, %rax
jb 0x18d6
movl $0x24, %edi
callq 0x11c0
movq %rax, %rdx
movl $0x2, %edi
leaq 0x195a(%rip), %rsi      # 0x3229
movb $0x0, %al
callq 0x1e00
movq -0x1038(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x1038(%rbp)
movb (%rax), %cl
movb %cl, -0x1021(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movsbl -0x1021(%rbp), %eax
cmpl $0x0, %eax
jne 0x189f
movq -0x20(%rbp), %rax
leaq -0x1020(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq 0x37eb(%rip), %rax      # 0x5118
movq %rax, 0x37e4(%rip)      # 0x5118
cmpq $0x100000, 0x37d9(%rip) # imm = 0x100000
jbe 0x195b
movl $0x2, %edi
leaq 0x18dc(%rip), %rsi      # 0x3229
leaq 0x180c(%rip), %rdx      # 0x3160
movb $0x0, %al
callq 0x1e00
movq -0x18(%rbp), %rdi
callq 0x1180
movq %rax, -0x1030(%rbp)
cmpq $0x0, %rax
jne 0x198b
movl $0x2, %edi
leaq 0x18ac(%rip), %rsi      # 0x3229
leaq 0x17a5(%rip), %rdx      # 0x3129
movb $0x0, %al
callq 0x1e00
movq -0x1030(%rbp), %rdi
leaq -0x1020(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1150
movq -0x1030(%rbp), %rax
addq $0x1040, %rsp           # imm = 0x1040
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/glob6.c
// Function: gopendir
static DIR *
gopendir(const char *dname)
{
	char *b, buf[PATHMAX];
	const char *d;

	for (*buf = EOS, b = buf, d = dname; b < &buf[PATHMAX]; b++, d++)
		if ((*b = (*d & ASCII)) == EOS)
			break;
	return (b >= &buf[PATHMAX]) ? NULL : opendir(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movq %rdi, -0x8(%rbp)
movb $0x0, -0x1010(%rbp)
leaq -0x1010(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1018(%rbp)
movq -0x10(%rbp), %rax
leaq -0x1010(%rbp), %rcx
addq $0x1000, %rcx           # imm = 0x1000
cmpq %rcx, %rax
jae 0x1a42
movq -0x1018(%rbp), %rax
movsbl (%rax), %eax
andl $0x7f, %eax
movq -0x10(%rbp), %rcx
movb %al, (%rcx)
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x1a20
jmp 0x1a42
jmp 0x1a22
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x1018(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x1018(%rbp)
jmp 0x19ec
movq -0x10(%rbp), %rax
leaq -0x1010(%rbp), %rcx
addq $0x1000, %rcx           # imm = 0x1000
cmpq %rcx, %rax
jb 0x1a64
xorl %eax, %eax
movq %rax, -0x1020(%rbp)
jmp 0x1a77
leaq -0x1010(%rbp), %rdi
callq 0x10c0
movq %rax, -0x1020(%rbp)
movq -0x1020(%rbp), %rax
addq $0x1020, %rsp           # imm = 0x1020
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/glob6.c
// Function: gsort
static void
gsort(const char **ogavp)
{
	const char **p1, **p2, *sap;

	p1 = ogavp;
	while (gavp - p1 > 1) {
		p2 = p1;
		while (++p2 < gavp)
			if (strcmp(*p1, *p2) > 0) {
				sap = *p1;
				*p1 = *p2;
				*p2 = sap;
			}
		p1++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x338d(%rip), %rax      # 0x5108
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
cmpq $0x1, %rax
jle 0x1df8
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
cmpq 0x3361(%rip), %rax      # 0x5108
jae 0x1de7
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x1140
cmpl $0x0, %eax
jle 0x1de5
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1d94
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x1d74
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/err.c
// Function: err
void
err(int es, const char *msgfmt, ...)
{
	va_list va;

	if (msgfmt != NULL) {
		va_start(va, msgfmt);
		wmsg(FD2, msgfmt, va);
		va_end(va);
	}
	if (myerrexit == NULL) {
		fd_print(FD2, FMT1S, "err: Invalid myerrexit function pointer");
		abort();
	}

	(*myerrexit)(es);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x1e38
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1e9c
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movl $0x2, %edi
callq 0x1ee0
leaq -0x30(%rbp), %rax
cmpq $0x0, 0x327c(%rip)      # 0x5120
jne 0x1ec5
movl $0x2, %edi
leaq 0x1377(%rip), %rsi      # 0x3229
leaq 0x12b9(%rip), %rdx      # 0x3172
movb $0x0, %al
callq 0x2050
callq 0x1050
movq 0x3254(%rip), %rax      # 0x5120
movl -0x4(%rbp), %edi
callq *%rax
addq $0xe0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/err.c
// Function: wmsg
static void
wmsg(int wfd, const char *msgfmt, va_list va)
{
	char msg[MSGMAX];
	char fmt[FMTMAX];
	struct iovec ev[4];
	int i;

	i = snprintf(fmt, sizeof(fmt), "%s", msgfmt);
	if (i >= 1 && i < (int)sizeof(fmt)) {
		i = vsnprintf(msg, sizeof(msg), fmt, va);
		if (i >= 0 && i < (int)sizeof(msg)) {
			if (write(wfd, msg, strlen(msg)) == -1) {
				ev[0].iov_base = (char *)getmyname();
				ev[0].iov_len  = strlen(getmyname());
				ev[1].iov_base = ": ";
				ev[1].iov_len  = (size_t)2;
				ev[2].iov_base = ERR_WRITE;
				ev[2].iov_len  = strlen(ERR_WRITE);
				ev[3].iov_base = "\n";
				ev[3].iov_len  = (size_t)1;
				(void)writev(FD2, ev, 4);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x910, %rsp            # imm = 0x910
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x8b0(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x41, %esi
leaq 0x129c(%rip), %rdx      # 0x31a9
movb $0x0, %al
callq 0x10f0
movl %eax, -0x8f4(%rbp)
cmpl $0x1, -0x8f4(%rbp)
jl 0x203a
cmpl $0x41, -0x8f4(%rbp)
jge 0x203a
leaq -0x860(%rbp), %rdi
leaq -0x8b0(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x841, %esi            # imm = 0x841
callq 0x1090
movl %eax, -0x8f4(%rbp)
cmpl $0x0, -0x8f4(%rbp)
jl 0x2038
cmpl $0x841, -0x8f4(%rbp)    # imm = 0x841
jge 0x2038
movl -0x4(%rbp), %eax
movl %eax, -0x904(%rbp)
leaq -0x860(%rbp), %rax
movq %rax, -0x900(%rbp)
leaq -0x860(%rbp), %rdi
callq 0x10d0
movl -0x904(%rbp), %edi
movq -0x900(%rbp), %rsi
movq %rax, %rdx
callq 0x10a0
cmpq $-0x1, %rax
jne 0x2036
callq 0x2100
movq %rax, -0x8f0(%rbp)
callq 0x2100
movq %rax, %rdi
callq 0x10d0
movq %rax, -0x8e8(%rbp)
leaq 0x11e7(%rip), %rax      # 0x31c3
movq %rax, -0x8e0(%rbp)
movq $0x2, -0x8d8(%rbp)
leaq 0x11b7(%rip), %rax      # 0x31ac
movq %rax, -0x8d0(%rbp)
movq $0xc, -0x8c8(%rbp)
leaq 0x11c7(%rip), %rax      # 0x31d5
movq %rax, -0x8c0(%rbp)
movq $0x1, -0x8b8(%rbp)
leaq -0x8f0(%rbp), %rsi
movl $0x2, %edi
movl $0x4, %edx
callq 0x1080
jmp 0x2038
jmp 0x203a
addq $0x910, %rsp            # imm = 0x910
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/err.c
// Function: fd_print
void
fd_print(int pfd, const char *msgfmt, ...)
{
	va_list va;

	if (msgfmt != NULL) {
		va_start(va, msgfmt);
		wmsg(pfd, msgfmt, va);
		va_end(va);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x2088
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x20ea
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x1ee0
leaq -0x30(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/err.c
// Function: setmyname
void
setmyname(const char *s)
{
	const char *p;

	if (s != NULL && *s != EOS) {
		if ((p = strrchr(s, SLASH)) != NULL)
			p++;
		else
			p = s;
		if (*p == HYPHEN && *(p + 1) != EOS)
			p++;
		else if (*p == EOS)
			/* should never (but can) be true */
			p = MYNAME;
	} else
		/* should never (but can) be true */
		p = MYNAME;

	myname = p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x220f
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x220f
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x1100
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x21c5
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x21cd
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x21f4
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x21f4
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x220d
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x220b
leaq 0xf9a(%rip), %rax       # 0x31a1
movq %rax, -0x10(%rbp)
jmp 0x220d
jmp 0x221a
leaq 0xf8b(%rip), %rax       # 0x31a1
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x2f03(%rip)      # 0x5128
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/shellaes128v2d5n64/ref/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(
                         unsigned char *m, unsigned long long *mlen,
                         unsigned char *nsec,
                         const unsigned char *c, unsigned long long clen,
                         const unsigned char *ad, unsigned long long adlen,
                         const unsigned char *npub,
                         const unsigned char *k)
{
    int flag;

    *mlen=clen-byte_length_tag;

    flag=shellaesDec(k, npub, ad, adlen, c, clen, m, mlen);

 //   (void) nsec;

    if(flag!=0){
        return 0;
    }
    else{
        return -1;
    }
}

// Assembly:
subq $0x58, %rsp
movq 0x70(%rsp), %rax
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq %r9, 0x20(%rsp)
movq 0x28(%rsp), %rcx
subq $0x10, %rcx
movq 0x40(%rsp), %rax
movq %rcx, (%rax)
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x60(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x28(%rsp), %r9
movq 0x48(%rsp), %r10
movq 0x40(%rsp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1080
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x402d
movl $0x0, 0x54(%rsp)
jmp 0x4035
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/shellaes128v2d5n64/ref/shellaes.c
// Function: tagVef
int tagVef(const u32 rk[], const u8 checksum[], const u8 Lprime[], const u8 U[], const u8 F[], const u8 T[], unsigned long long int ptlen){

    u8 tempT[16];
    int flag=1;
    int i;

    tagGen(rk, checksum, Lprime, U, F, tempT, ptlen);

    for(i=0; i<byte_length_tag; ++i){
        if(tempT[i]!=T[i]){
            flag=0;
        }
    }
    return flag;
}

// Assembly:
subq $0x58, %rsp
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movl $0x1, 0xc(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
leaq 0x10(%rsp), %r9
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
callq 0x1070
movl $0x0, 0x8(%rsp)
cmpl $0x10, 0x8(%rsp)
jge 0x547d
movslq 0x8(%rsp), %rax
movzbl 0x10(%rsp,%rax), %eax
movq 0x28(%rsp), %rcx
movslq 0x8(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x546e
movl $0x0, 0xc(%rsp)
jmp 0x5470
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x5443
movl 0xc(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/shellaes128v2d5n64/ref/shellaes.c
// Function: shellaesEnc
void shellaesEnc(const u8 key[], const u8 nonce[], const u8 ad[], unsigned long long int adlen, const u8 p[], unsigned long long int ptlen, u8 c[], unsigned long long int ctlen){

    u8 tag[16];
    unsigned long long int padp_len=ptlen+16-(ptlen%16);
    u8* padp;

    /*pad plaintexts to multiple blocks*/
    padp=(u8*) malloc(padp_len);
    memcpy(padp, p, ptlen);
    memset(padp+ptlen,0x80,1);
    memset(padp+ptlen+1, 0, 15-(ptlen%16));


    /*encryption of padded plaintext*/
    shellaesEnc_fb(key, nonce, ad, adlen, padp, padp_len, c, tag);
    free(padp);

    /*append the tag to ciphertext*/
    memcpy(c+padp_len, tag, byte_length_tag);
}

// Assembly:
subq $0x68, %rsp
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %rax
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq 0x38(%rsp), %rax
addq $0x10, %rax
movq 0x38(%rsp), %rcx
andq $0xf, %rcx
subq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x10b0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x1200
movq 0x10(%rsp), %rdi
addq 0x38(%rsp), %rdi
movl $0x80, %esi
movl $0x1, %edx
callq 0x1060
movq 0x10(%rsp), %rdi
addq 0x38(%rsp), %rdi
addq $0x1, %rdi
movq 0x38(%rsp), %rax
andq $0xf, %rax
movl $0xf, %edx
subq %rax, %rdx
xorl %esi, %esi
callq 0x1060
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x18(%rsp), %r9
movq 0x70(%rsp), %r10
leaq 0x20(%rsp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1210
movq 0x10(%rsp), %rdi
callq 0x1110
movq 0x70(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rdx
movq %rdx, (%rax,%rcx)
movq 0x28(%rsp), %rdx
movq %rdx, 0x8(%rax,%rcx)
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/shellaes128v2d5n64/ref/shellaes.c
// Function: shellaesDec
int shellaesDec(const u8 key[], const u8 nonce[], const u8 ad[], unsigned long long int adlen, const u8 c[], unsigned long long int ctlen, u8 p[], unsigned long long int* ptlen){

    u8 tag[16];
    int flag;

    memcpy(tag, c+*ptlen, byte_length_tag);

    flag=shellaesDecVef_fb(key, nonce, ad, adlen, c, *ptlen, p, tag);


    /*if the tag is valid, erase the padding bits*/
    if(flag){
        while(p[*ptlen-1]!=0x80){
            *ptlen=*ptlen-1;
        }

        *ptlen=*ptlen-1;
    }

    return flag;
}

// Assembly:
subq $0x68, %rsp
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %rax
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq 0x78(%rsp), %rcx
movq (%rcx), %rcx
movq (%rax,%rcx), %rdx
movq %rdx, 0x20(%rsp)
movq 0x8(%rax,%rcx), %rax
movq %rax, 0x28(%rsp)
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq 0x40(%rsp), %r8
movq 0x78(%rsp), %rax
movq (%rax), %r9
movq 0x70(%rsp), %r10
leaq 0x20(%rsp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x10d0
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x5d48
jmp 0x5d02
movq 0x70(%rsp), %rax
movq 0x78(%rsp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x80, %eax
je 0x5d34
movq 0x78(%rsp), %rax
movq (%rax), %rcx
subq $0x1, %rcx
movq 0x78(%rsp), %rax
movq %rcx, (%rax)
jmp 0x5d02
movq 0x78(%rsp), %rax
movq (%rax), %rcx
subq $0x1, %rcx
movq 0x78(%rsp), %rax
movq %rcx, (%rax)
movl 0x1c(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfptest_template.h
// Function: rrandom_u32
F_UINT rrandom_u(int len)
{
    int bit, pos, n, end;
    F_UINT a;
    
    bit = random() & 1;
    pos = 0;
    a = 0;
    for(;;) {
        n = (random() % len) + 1;
        end = pos + n;
        if (end > len)
            end = len;
        if (bit) {
            n = end - pos;
            if (n == F_SIZE)
                a = (F_UINT)(-1);
            else
                a |= (((F_UINT)1 << n) - 1) << pos;
        }
        if (end >= len)
            break;
        pos = end;
        bit ^= 1;
    }
    return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
callq 0x1080
andq $0x1, %rax
movl %eax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x18(%rbp)
callq 0x1080
movslq -0x4(%rbp), %rcx
cqto
idivq %rcx
addq $0x1, %rdx
movl %edx, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jle 0x1203
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x123b
movl -0x14(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0x20, -0x10(%rbp)
jne 0x1221
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
jmp 0x1239
movl -0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
movl -0xc(%rbp), %ecx
shll %cl, %eax
orl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x123b
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jl 0x1245
jmp 0x1259
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
xorl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x11d5
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mbitsnbites[P]SoftFP/./softfptest_template.h
// Function: rrandom_sf32
F_UINT rrandom_sf(void)
{
    uint32_t a_exp, a_sign;
    F_UINT a_mant;
    a_sign = random() & 1;

    /* generate exponent close to the min/max more often than random */
    switch(random() & 15) {
    case 0:
        a_exp = (random() % (2 * MANT_SIZE)) & EXP_MASK;
        break;
    case 1:
        a_exp = (EXP_MASK - (random() % (2 * MANT_SIZE))) & EXP_MASK;
        break;
    default:
        a_exp = random() & EXP_MASK;
        break;
    }
    a_mant = rrandom_u(MANT_SIZE);
    return pack_sf(a_sign, a_exp, a_mant);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x1080
andl $0x1, %eax
movl %eax, -0x8(%rbp)
callq 0x1080
andq $0xf, %rax
movq %rax, -0x18(%rbp)
je 0x12a0
jmp 0x1294
movq -0x18(%rbp), %rax
subq $0x1, %rax
je 0x12bd
jmp 0x12df
callq 0x1080
movl $0x2e, %ecx
cqto
idivq %rcx
andq $0xff, %rdx
movl %edx, %eax
movl %eax, -0x4(%rbp)
jmp 0x12ed
callq 0x1080
movl $0x2e, %ecx
cqto
idivq %rcx
movl $0xff, %eax
subq %rdx, %rax
andq $0xff, %rax
movl %eax, -0x4(%rbp)
jmp 0x12ed
callq 0x1080
andq $0xff, %rax
movl %eax, -0x4(%rbp)
movl $0x17, %edi
callq 0x11b0
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %edi
movl -0x4(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x1310
addq $0x20, %rsp
popq %rbp
retq
nop