LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/StepDetectorSensor.cpp
// Function: StepDetectorSensor::readEvents(sensors_event_t*, int)
int StepDetectorSensor::readEvents(sensors_event_t* data, int count)
{
	if (count < 1)
		return -EINVAL;

	ssize_t n = mInputReader.fill(data_fd);
	if (n < 0)
		return n;

	int numEventReceived = 0;
	input_event const* event;

	while (count && mInputReader.readEvent(&event)) {

		if (event->type == EVENT_TYPE_STEP_D) {

#if (DEBUG_STEP_D == 1)
	STLOGD("StepDetectorSensor::readEvents (event_code=%d)", event->code);
#endif
			switch(event->code) {
			case EVENT_TYPE_STEP_D_DATA:

				break;
#if defined(INPUT_EVENT_HAS_TIMESTAMP)
			case EVENT_TYPE_TIME_MSB:
				timestamp = ((int64_t)(event->value)) << 32;

				break;
			case EVENT_TYPE_TIME_LSB:
				timestamp |= (uint32_t)(event->value);

				break;
#endif
			default:
				STLOGE("StepDetectorSensor: unknown event code \
					(type = %d, code = %d)", event->type,
								event->code);
			}
		} else if (event->type == EV_SYN) {

#if !defined(INPUT_EVENT_HAS_TIMESTAMP)
			timestamp = timevalToNano(event->time);
#endif
			mPendingEvent.timestamp = timestamp;
			memcpy(data, &mPendingEvent, sizeof(mPendingEvent));
			data++;
			count--;
			numEventReceived++;
#if (DEBUG_STEP_D == 1)
			STLOGD("StepDetectorSensor::readEvents (time = %lld), count(%d), received(%d)",
						mPendingEvent.timestamp,
						count, numEventReceived);
#endif

		} else {
			STLOGE("StepDetectorSensor: unknown event (type=%d, code=%d)",
						event->type, event->code);
		}
		mInputReader.next();
	}

	return numEventReceived;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testl %edx, %edx
jle 0x79a1
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1028(%rdi), %r12
movl 0x1020(%rdi), %esi
movq %r12, %rdi
callq 0x50a0
testq %rax, %rax
js 0x79a8
leaq 0x1050(%r15), %rax
movq %rax, 0x8(%rsp)
xorl %ebx, %ebx
leaq 0x10(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x5290
testq %rax, %rax
je 0x79ab
movq 0x10(%rsp), %rax
movzwl 0x10(%rax), %ecx
testl %ecx, %ecx
je 0x7961
cmpl $0x4, %ecx
jne 0x7993
movzwl 0x12(%rax), %ecx
cmpl $0x7, %ecx
je 0x7989
cmpl $0x4, %ecx
jne 0x7993
movl 0x14(%rax), %eax
shlq $0x20, %rax
movq %rax, 0x10b8(%r15)
jmp 0x7993
movq 0x10b8(%r15), %rax
movq %rax, 0x1060(%r15)
movl $0xd, %ecx
movq %r14, %rdi
movq 0x8(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
addq $0x68, %r14
decl %ebp
incl %ebx
jmp 0x7993
movl 0x14(%rax), %eax
orq %rax, 0x10b8(%r15)
movq %r12, %rdi
callq 0x5210
testl %ebp, %ebp
jne 0x7921
jmp 0x79ab
movl $0xffffffea, %ebx       # imm = 0xFFFFFFEA
jmp 0x79ab
movq %rax, %rbx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/TiltSensor.cpp
// Function: TiltSensor::TiltSensor()
TiltSensor::TiltSensor()
	: SensorBase(NULL, SENSOR_DATANAME_TILT),
	mInputReader(4)
{
	mPendingEvent.version = sizeof(sensors_event_t);
	mPendingEvent.sensor = ID_TILT_DETECTOR;
	mPendingEvent.type = SENSOR_TYPE_TILT_DETECTOR;
	mPendingEvent.data[0] = 1.0f;

	if (data_fd) {
		STLOGI("TiltSensor::TiltSensor device_sysfs_path:(%s)", sysfs_device_path);
	} else {
		STLOGE("TiltSensor::TiltSensor device_sysfs_path:(%s) not found", sysfs_device_path);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xad3(%rip), %rdx       # 0x849d
xorl %esi, %esi
callq 0x5060
movq 0x45d8(%rip), %rax      # 0xbfb0
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x1028(%rbx), %rdi
movl $0x4, %esi
callq 0x5120
movabsq $0x1300000068, %rax     # imm = 0x1300000068
movq %rax, 0x1050(%rbx)
movl $0x16, 0x1058(%rbx)
movl $0x3f800000, 0x1068(%rbx) # imm = 0x3F800000
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5150
movq %r14, %rdi
callq 0x53c0
// File: /workspace/github_c_makefile_star2_O3/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/TiltSensor.cpp
// Function: TiltSensor::enable(int, int, int)
int TiltSensor::enable(int32_t handle, int en, int  __attribute__((unused))type)
{
	int err = 0;
	int flags = en ? 1 : 0;

	if (flags) {
		if (!mEnabled) {
			err = writeEnable(SENSORS_TILT_DETECTOR_HANDLE, flags);
			if(err >= 0)
				err = 0;
		}
		mEnabled = 1;
	} else {
		if (mEnabled){
			err = writeEnable(SENSORS_TILT_DETECTOR_HANDLE, flags);
			if(err >= 0) {
				err = 0;
				mEnabled = 0;
			}
		}
	}

	if(err >= 0 ) {
		STLOGD("TiltSensor::enable(%d), handle: %d, mEnabled: %d",
						flags, handle, mEnabled);
	} else {
		STLOGE("TiltSensor::enable(%d), handle: %d, mEnabled: %d",
						flags, handle, mEnabled);
	}

	return err;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %eax
xorl %edx, %edx
movq 0x44e8(%rip), %rbx      # 0xbf98
movl (%rbx), %ecx
testl %eax, %eax
setne %dl
je 0x7ad6
movl $0x1, %ebp
testl %ecx, %ecx
jne 0x7aeb
movq (%rdi), %rax
movl $0x13, %esi
callq *0x40(%rax)
movl %eax, %ecx
sarl $0x1f, %eax
andl %ecx, %eax
jmp 0x7aed
testl %ecx, %ecx
je 0x7af6
movq (%rdi), %rax
movl $0x13, %esi
callq *0x40(%rax)
testl %eax, %eax
js 0x7aef
xorl %ebp, %ebp
xorl %eax, %eax
movl %ebp, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
jmp 0x7aef
// File: /workspace/github_c_makefile_star2_O3/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/TiltSensor.cpp
// Function: TiltSensor::readEvents(sensors_event_t*, int)
int TiltSensor::readEvents(sensors_event_t* data, int count)
{
	int numEventReceived = 0;
	input_event const* event;

	if (count < 1)
		return -EINVAL;

	ssize_t n = mInputReader.fill(data_fd);
	if (n < 0)
		return n;

	while (count && mInputReader.readEvent(&event)) {
		if (event->type == EVENT_TYPE_TILT) {
#if (DEBUG_TILT == 1)
	STLOGD("TiltSensor::readEvents (event_code=%d)", event->code);
#endif
			switch(event->code) {
			case EVENT_TYPE_TILT_DATA:
				tilt_data = event->value;

				break;
#if defined(INPUT_EVENT_HAS_TIMESTAMP)
			case EVENT_TYPE_TIME_MSB:
				timestamp = ((int64_t)(event->value)) << 32;

				break;
			case EVENT_TYPE_TIME_LSB:
				timestamp |= (uint32_t)(event->value);

				break;
#endif
			default:
				STLOGE("TiltSensor: unknown event code (type = %d, code = %d)",
							event->type, event->code);
			}
		} else if (event->type == EV_SYN) {
#if !defined(INPUT_EVENT_HAS_TIMESTAMP)
			timestamp = timevalToNano(event->time);
#endif
			mPendingEvent.timestamp = timestamp;
			memcpy(data, &mPendingEvent, sizeof(mPendingEvent));
			data++;
			count--;
			numEventReceived++;
#if (DEBUG_TILT == 1)
			STLOGD("TiltSensor::readEvents (time = %lld), count(%d), received(%d)",
						mPendingEvent.timestamp,
						count, numEventReceived);
#endif
		} else {
			STLOGE("TiltSensor: unknown event (type=%d, code=%d)",
						event->type, event->code);
		}
		mInputReader.next();
	}

	return numEventReceived;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testl %edx, %edx
jle 0x7c11
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1028(%rdi), %r13
movl 0x1020(%rdi), %esi
movq %r13, %rdi
callq 0x50a0
testq %rax, %rax
js 0x7c19
leaq 0x1050(%r15), %rax
movq %rax, 0x8(%rsp)
xorl %r12d, %r12d
leaq 0x10(%rsp), %rbp
movq %r13, %rdi
movq %rbp, %rsi
callq 0x5290
testq %rax, %rax
je 0x7c1c
movq 0x10(%rsp), %rax
movzwl 0x10(%rax), %ecx
testl %ecx, %ecx
je 0x7bc0
cmpl $0x4, %ecx
jne 0x7be7
movzwl 0x12(%rax), %ecx
cmpl $0x7, %ecx
je 0x7c05
cmpl $0x4, %ecx
je 0x7bf5
testl %ecx, %ecx
jne 0x7be7
movl 0x14(%rax), %eax
movl %eax, 0x10c0(%r15)
jmp 0x7be7
movq 0x10b8(%r15), %rax
movq %rax, 0x1060(%r15)
movl $0xd, %ecx
movq %r14, %rdi
movq 0x8(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
addq $0x68, %r14
decl %ebx
incl %r12d
movq %r13, %rdi
callq 0x5210
testl %ebx, %ebx
jne 0x7b7c
jmp 0x7c1c
movl 0x14(%rax), %eax
shlq $0x20, %rax
movq %rax, 0x10b8(%r15)
jmp 0x7be7
movl 0x14(%rax), %eax
orq %rax, 0x10b8(%r15)
jmp 0x7be7
movl $0xffffffea, %r12d      # imm = 0xFFFFFFEA
jmp 0x7c1c
movq %rax, %r12
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/USArmyResearchLab[P]ARL_OpenSHMEM/src/autogen/shmem_collect64.c
// Function: shmem_collect64
void shmem_collect64(void *dest, const void *source, size_t nelems, 
	int pe_start, int log_pe_stride, int pe_size, long* psync)
{
	int pe = __shmem.my_pe;
	int pe_step = 0x1 << log_pe_stride;
	int pe_end = pe_start + pe_step * (pe_size - 1);
	int my_offset = 0;
	int inelems = (int)nelems;

	/* We know the value here is 0 and we can use it and reset it before
	 * it is needed in the barrier */

	volatile long* offset = psync + SHMEM_COLLECT_SYNC_SIZE - 1;

	int* neighbor_offset = (int*)shmem_ptr((void*)offset, pe + pe_step);

	if (__builtin_expect((pe == pe_start),0)) {

		*neighbor_offset = my_offset + inelems;

	} else {

		/// spin until neighbor sets offset 
		while (!(my_offset = *offset));

		*offset = SHMEM_SYNC_VALUE;

		if (__builtin_expect((pe != pe_end),1))
			*neighbor_offset = my_offset + inelems;
	}

	int i, j;
	for (i = pe_start; i <= pe_end; i += pe_step) {
		int64_t* dst = (int64_t*)shmem_ptr((void*)dest, i) + my_offset;
		for (j = 0; j < inelems; j++) dst[j] = ((int64_t*)source)[j];
	}

	shmem_barrier(pe_start, log_pe_stride, pe_size, psync);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %r12d
movq %rdx, (%rsp)
movq %rsi, %r13
movq %rdi, 0x30(%rsp)
movq 0x70(%rsp), %rdx
leaq 0x4efc(%rip), %rax      # 0x61f0
pushq $0x1
popq %rbp
movl %r8d, %ecx
shll %cl, %ebp
movq %r9, 0x28(%rsp)
leal -0x1(%r9), %esi
movl %r8d, 0x14(%rsp)
shll %cl, %esi
movl 0x4(%rax), %ebx
movq %rsi, 0x8(%rsp)
leal (%rsi,%r12), %r14d
movq %rdx, 0x20(%rsp)
leaq 0x38(%rdx), %r15
leal (%rbx,%rbp), %esi
movq %r15, %rdi
callq 0x1e1c
movq %r12, 0x18(%rsp)
cmpl %r12d, %ebx
je 0x13d3
movq (%r15), %rcx
testl %ecx, %ecx
je 0x133a
movq $0x0, (%r15)
cmpl %r14d, %ebx
je 0x13de
movq (%rsp), %rdx
addl %ecx, %edx
movq 0x8(%rsp), %rsi
movl %edx, (%rax)
testl %esi, %esi
js 0x13ad
movslq %ecx, %rbx
shlq $0x3, %rbx
movq (%rsp), %r12
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
movq 0x18(%rsp), %rax
movl %eax, %r15d
movq 0x30(%rsp), %rdi
movl %r15d, %esi
callq 0x1e1c
cmpl $0x0, (%rsp)
jle 0x13a5
addq %rbx, %rax
xorl %ecx, %ecx
movq (%r13,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
incq %rcx
cmpq %rcx, %r12
jne 0x1394
addl %ebp, %r15d
cmpl %r14d, %r15d
jle 0x137c
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3204
xorl %ecx, %ecx
movq (%rsp), %rdx
jmp 0x1357
movq 0x8(%rsp), %rsi
jmp 0x135e
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]push_swap_42/srcs_push_swap/ft_push_swap.c
// Function: main
int			main(int ac, char **av)
{
	t_stack	s;
	char	**arg;

	if (ac == 1)
		return (0);
	s.a = NULL;
	s.b = NULL;
	s.buf = NULL;
	arg = ft_get_av(av + 1);
	s.size = ft_size_of_arg(arg);
	ft_set_a_and_b(&s, arg, s.size);
	s.size < 200 ? ft_process_sort(&s) : ft_process_sort500(&s);
	if (s.buf)
	{
		s.size_a = s.size;
		s.size_b = 0;
		ft_make_simple(&s, &s.buf);
		ft_print_solution(s.buf);
	}
	ft_free_stack(&s);
	ft_free_tab_str(arg);
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpl $0x1, %edi
je 0x136b
movq %rsi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
xorl %r15d, %r15d
movq %r15, 0x20(%rsp)
movq %r15, 0x8(%rsp)
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0x1272
xorl %r13d, %r13d
leaq 0x2e74(%rip), %r14      # 0x4056
xorl %r15d, %r15d
movl $0x20, %esi
callq 0x3218
movq %rax, %r12
movq (%rax), %rdi
testq %rdi, %rdi
je 0x1259
movq %r12, %rbp
callq 0x31dc
testl %eax, %eax
jne 0x1223
movq (%rbp), %rdi
cmpb $0x2d, (%rdi)
jne 0x137c
incq %rdi
callq 0x31dc
testl %eax, %eax
je 0x137c
movq (%rbp), %rsi
movq %r15, %rdi
movl $0x1, %edx
callq 0x3139
movq %rax, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x3139
movq %rax, %r15
movq %rax, 0x8(%rsp)
movq 0x8(%rbp), %rdi
addq $0x8, %rbp
testq %rdi, %rdi
jne 0x11fd
movq %r12, %rdi
callq 0x31a4
movq 0x10(%rbx,%r13,8), %rdi
incq %r13
testq %rdi, %rdi
jne 0x11e5
movq %r15, %rdi
movl $0xa, %esi
callq 0x3218
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3184
movq %rbx, %rdi
callq 0x3046
movslq %eax, %rdx
leaq 0x10(%rsp), %r14
movq %rdx, 0x18(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2fa1
cmpq $0xc7, 0x18(%r14)
ja 0x12c1
leaq 0x10(%rsp), %rdi
callq 0x17dc
jmp 0x12cb
leaq 0x10(%rsp), %rdi
callq 0x1b34
cmpq $0x0, 0x20(%rsp)
je 0x1359
leaq 0x20(%rsp), %rsi
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rsi)
movq $0x0, 0x18(%rsi)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x13a0
movq 0x10(%r14), %rdi
movq %rdi, 0x8(%rsp)
movl $0xa, %esi
callq 0x3218
testq %rax, %rax
je 0x1348
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3184
movq (%r14), %rdi
testq %rdi, %rdi
je 0x133e
movq %r14, %r15
addq $0x8, %r15
callq 0x340c
movq (%r15), %rdi
addq $0x8, %r15
testq %rdi, %rdi
jne 0x132d
movq %r14, %rdi
callq 0x31a4
jmp 0x1359
leaq 0x2cb5(%rip), %rdi      # 0x4004
movl $0x2, %esi
callq 0x3444
leaq 0x10(%rsp), %rdi
callq 0x2d94
movq %rbx, %rdi
callq 0x31a4
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
callq 0x31a4
leaq 0x2c79(%rip), %rdi      # 0x4004
movl $0x2, %esi
callq 0x3444
movl $0x1, %edi
callq 0x1090
nop
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]push_swap_42/srcs_push_swap/ft_order.c
// Function: ft_is_good
int			ft_is_good(long *tab, size_t size, int which)
{
	size_t		i;

	i = 0;
	while (i + 1 < size)
	{
		if ((which == 0 && tab[i] < tab[i + 1])
				|| (which == 1 && tab[i] > tab[i + 1]))
			return (FALSE);
		i++;
	}
	return (TRUE);
}

// Assembly:
movl $0x1, %eax
cmpq $0x2, %rsi
jb 0x1f11
movl $0x1, %ecx
cmpl $0x1, %edx
je 0x1efe
testl %edx, %edx
jne 0x1f09
movq -0x8(%rdi,%rcx,8), %r8
cmpq (%rdi,%rcx,8), %r8
jge 0x1f09
jmp 0x1f12
movq -0x8(%rdi,%rcx,8), %r8
cmpq (%rdi,%rcx,8), %r8
jg 0x1f12
incq %rcx
cmpq %rcx, %rsi
jne 0x1ee8
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]push_swap_42/srcs_push_swap/ft_order.c
// Function: ft_check_ok
int			ft_check_ok(t_stack *s, int which)
{
	int		rot;
	size_t	size;

	size = (which == 1) ? s->size_b : s->size_a;
	if ((which == 1 && s->size_b == 0)
			|| (which == 0 && s->size_a == 0))
		return (-1);
	if ((rot = ft_check_rotate(which ? s->b : s->a, size, which)))
		return (rot);
	return (FALSE);
}

// Assembly:
movl %esi, %edx
xorl %eax, %eax
cmpl $0x1, %esi
sete %al
movq 0x20(%rdi,%rax,8), %rsi
jne 0x1f2f
cmpq $0x0, 0x28(%rdi)
jne 0x1f33
jmp 0x1f45
testl %edx, %edx
je 0x1f3c
addq $0x8, %rdi
movq (%rdi), %rdi
jmp 0x1f4b
xorl %edx, %edx
cmpq $0x0, 0x20(%rdi)
jne 0x1f37
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]push_swap_42/srcs_push_swap/ft_order.c
// Function: ft_check_rotate
static int	ft_check_rotate(long *tab, size_t size, int which)
{
	size_t	i;
	t_stack	s;
	long	*tmp;

	s.size_a = which == 1 ? 0 : size;
	s.size_b = which == 0 ? 0 : size;
	if (!(tmp = ft_dup_stack(tab, size)))
		return (0);
	s.a = which == 1 ? NULL : tmp;
	s.b = which == 0 ? NULL : tmp;
	i = 0;
	while (i < size)
	{
		if (ft_is_good(tmp, size, which))
		{
			free(tmp);
			return (i ? (int)i : -1);
		}
		ft_exec_rotate(&s, which == 1 ? "rb" : "ra");
		i++;
	}
	free(tmp);
	return (FALSE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %r14
xorl %ecx, %ecx
cmpl $0x1, %edx
movq %rsi, %rax
cmoveq %rcx, %rax
movq %rdi, %r12
movq %rax, 0x28(%rsp)
testl %edx, %edx
movq %rsi, %rax
cmoveq %rcx, %rax
movq %rax, 0x30(%rsp)
leaq (,%rsi,8), %r13
movq %r13, %rdi
callq 0x1070
movq %rax, %r15
testq %rax, %rax
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x1fd2
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1060
xorl %eax, %eax
cmpl $0x1, %ebp
movq %r15, %rcx
cmoveq %rax, %rcx
testl %ebp, %ebp
movq %rcx, 0x8(%rsp)
movq %r15, %rcx
cmoveq %rax, %rcx
movq %rcx, 0x10(%rsp)
jmp 0x1fff
testq %r15, %r15
je 0x206c
xorl %eax, %eax
cmpl $0x1, %ebp
movq %r15, %rcx
cmoveq %rax, %rcx
testl %ebp, %ebp
movq %rcx, 0x8(%rsp)
movq %r15, %rcx
cmoveq %rax, %rcx
movq %rcx, 0x10(%rsp)
testq %r14, %r14
je 0x2064
cmpl $0x1, %ebp
leaq 0x2010(%rip), %rax      # 0x4019
leaq 0x2005(%rip), %r12      # 0x4015
cmoveq %rax, %r12
xorl %ebx, %ebx
leaq 0x8(%rsp), %r13
cmpq $0x1, %r14
je 0x2093
movl $0x1, %eax
cmpl $0x1, %ebp
je 0x203c
testl %ebp, %ebp
jne 0x2047
movq -0x8(%r15,%rax,8), %rcx
cmpq (%r15,%rax,8), %rcx
jge 0x2047
jmp 0x2051
movq -0x8(%r15,%rax,8), %rcx
cmpq (%r15,%rax,8), %rcx
jg 0x2051
incq %rax
cmpq %rax, %r14
jne 0x2026
jmp 0x2070
movq %r13, %rdi
movq %r12, %rsi
callq 0x2bf2
incq %rbx
cmpq %r14, %rbx
jne 0x201b
movq %r15, %rdi
callq 0x1030
xorl %eax, %eax
jmp 0x2084
movq %r15, %rdi
callq 0x1030
movl %ebx, %eax
testq %rbx, %rbx
jne 0x2084
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x1030
jmp 0x207f
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]push_swap_42/srcs_push_swap/ft_order.c
// Function: ft_reposition
int			ft_reposition(t_stack *s, int *ret_a, int *ret_b, int exec)
{
	int		rot_a;
	int		rot_b;

	rot_a = 0;
	rot_b = 0;
	*ret_a = ft_check_ok(s, 0);
	*ret_b = ft_check_ok(s, 1);
	if (*ret_a > 0 && exec)
		rot_a = *ret_a;
	if (*ret_b > 0 && exec)
		rot_b = *ret_b;
	while (rot_a-- > 0 && rot_b-- > 0)
		ft_cmd(ft_exec_rotate, s, "rr");
	while (rot_a-- > 0)
		ft_cmd(ft_exec_rotate, s, "ra");
	while (rot_b-- > 0)
		ft_cmd(ft_exec_rotate, s, "rb");
	return (*ret_a && *ret_b ? TRUE : FALSE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r15
movq 0x20(%rdi), %rsi
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rsi, %rsi
je 0x20d4
movq (%r15), %rdi
xorl %edx, %edx
callq 0x1f4b
movl %eax, (%r13)
movq 0x28(%r15), %rsi
testq %rsi, %rsi
je 0x20f2
movq 0x8(%r15), %rdi
movl $0x1, %edx
callq 0x1f4b
movl %eax, %r12d
movq %rbx, 0x8(%rsp)
movl %r12d, (%rbx)
xorl %r14d, %r14d
testl %r12d, %r12d
cmovgl %r12d, %r14d
movq %r13, 0x10(%rsp)
movl (%r13), %ebx
testl %ebp, %ebp
cmovel %ebp, %r14d
sete %al
testl %ebx, %ebx
setle %cl
orb %al, %cl
jne 0x2182
leaq 0xacc(%rip), %r12       # 0x2bf2
leaq 0x1ef5(%rip), %r13      # 0x4022
movl %r14d, %ebp
testl %r14d, %r14d
jle 0x2155
decl %ebx
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x2343
leal 0x1(%rbx), %eax
leal -0x1(%rbp), %r14d
cmpl $0x1, %eax
jg 0x212d
decl %ebp
jmp 0x217f
cmpl $0x1, %ebx
je 0x21af
decl %ebp
leaq 0xa8f(%rip), %r12       # 0x2bf2
leaq 0x1eab(%rip), %r13      # 0x4015
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x2343
decl %ebx
cmpl $0x1, %ebx
ja 0x216a
movl %ebp, %r14d
testl %r14d, %r14d
jle 0x21af
incl %r14d
leaq 0xa61(%rip), %r12       # 0x2bf2
leaq 0x1e81(%rip), %r13      # 0x4019
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x2343
decl %r14d
cmpl $0x1, %r14d
ja 0x2198
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax)
je 0x21c8
xorl %eax, %eax
movq 0x8(%rsp), %rcx
cmpl $0x0, (%rcx)
setne %al
jmp 0x21ca
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]push_swap_42/srcs_push_swap/ft_tool_push_swap.c
// Function: ft_third
int		ft_third(long *tab, int size)
{
	long	*cpy;
	int		i;
	int		ret;

	i = 0;
	if (!(cpy = (long *)malloc(sizeof(long) * size)))
		return (tab[size - 1]);
	while (i < size)
	{
		cpy[i] = tab[i];
		i++;
	}
	ft_insertsort_long(cpy, size);
	ret = cpy[size - 1];
	free(cpy);
	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r15
movslq %esi, %rbx
leaq (,%rbx,8), %rdi
callq 0x1070
testq %rax, %rax
je 0x226d
movq %rax, %r14
testl %ebp, %ebp
jle 0x2253
movl %ebp, %edx
shlq $0x3, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1060
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3595
movq -0x8(%r14,%rbx,8), %rbx
movq %r14, %rdi
callq 0x1030
jmp 0x2272
movq -0x8(%r15,%rbx,8), %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]push_swap_42/srcs_push_swap/ft_tool_push_swap.c
// Function: ft_med_stack
int		ft_med_stack(long *tab, int size)
{
	long	*cpy;
	int		i;
	int		ret;
	int		tmp_size;

	i = -1;
	if (!(cpy = (long *)malloc(sizeof(long) * size)))
		return (tab[size - 1]);
	while (++i < size)
	{
		cpy[i] = tab[i];
	}
	ft_insertsort_long(cpy, size);
	tmp_size = size;
	if (size >= 300)
		size = size / 4 + size % 4;
	else if (size >= 12)
		size = size / 3 + size % 3;
	else
		size = size / 2;
	if (tmp_size < size)
		size = tmp_size - 1;
	ret = size > 0 ? cpy[size] : cpy[0];
	free(cpy);
	return (ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %r12
movslq %esi, %r15
leaq (,%r15,8), %rdi
callq 0x1070
testq %rax, %rax
je 0x22db
movq %rax, %rbx
testl %r14d, %r14d
jle 0x22e2
movl %r14d, %edx
shlq $0x3, %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1060
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3595
cmpl $0x12c, %r14d           # imm = 0x12C
jb 0x22ef
movl %r14d, %eax
shrl $0x2, %eax
leal (%rax,%rax,2), %ecx
jmp 0x2305
movq -0x8(%r12,%r15,8), %r14
jmp 0x2334
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3595
jmp 0x230c
cmpl $0xc, %r14d
jb 0x230c
movzwl %r14w, %eax
imull $0xaaab, %eax, %ecx     # imm = 0xAAAB
shrl $0x10, %ecx
andl $-0x2, %ecx
movl %r14d, %eax
subl %ecx, %eax
jmp 0x2317
movl %r14d, %eax
shrl $0x1f, %eax
addl %r14d, %eax
sarl %eax
leal -0x1(%r14), %ecx
cmpl %r14d, %eax
cmovlel %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovgl %ecx, %eax
movq (%rbx,%rax,8), %r14
movq %rbx, %rdi
callq 0x1030
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]push_swap_42/srcs_push_swap/ft_post_process.c
// Function: ft_post_process
int			ft_post_process(t_stack *s, char **buf, char **tab)
{
	int		i;

	i = 0;
	if (ft_strequ(tab[i], "pa") && ft_strequ(tab[i + 1], "pa"))
		i = ft_reduce_push(s, buf, tab, 0);
	else if (ft_strequ(tab[i], "pb") && ft_strequ(tab[i + 1], "pb"))
		i = ft_reduce_push(s, buf, tab, 0);
	else if ((ft_strequ(tab[i], "ra") || ft_strequ(tab[i], "rra"))
			&& ft_strequ(tab[i], tab[i + 1]))
		i = ft_reduce_rotate(s, buf, tab, 0);
	else if ((ft_strequ(tab[i], "rb") || ft_strequ(tab[i], "rrb"))
			&& ft_strequ(tab[i], tab[i + 1]))
		i = ft_reduce_rotate(s, buf, tab, 1);
	return (i);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdx), %rdi
leaq 0x1c80(%rip), %rsi      # 0x4028
callq 0x3060
testl %eax, %eax
je 0x23c5
movq 0x8(%rbx), %rdi
leaq 0x1c6c(%rip), %rsi      # 0x4028
callq 0x3060
testl %eax, %eax
jne 0x23ec
movq (%rbx), %rdi
leaq 0x1c5c(%rip), %rsi      # 0x402b
callq 0x3060
testl %eax, %eax
je 0x23ff
movq 0x8(%rbx), %rdi
leaq 0x1c48(%rip), %rsi      # 0x402b
callq 0x3060
testl %eax, %eax
je 0x23ff
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2498
movq (%rbx), %rdi
leaq 0x1c0c(%rip), %rsi      # 0x4015
callq 0x3060
testl %eax, %eax
jne 0x2425
movq (%rbx), %rdi
leaq 0x1bf8(%rip), %rsi      # 0x4014
callq 0x3060
testl %eax, %eax
je 0x2442
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x3060
testl %eax, %eax
je 0x2442
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
jmp 0x2486
movq (%rbx), %rdi
leaq 0x1bcd(%rip), %rsi      # 0x4019
callq 0x3060
testl %eax, %eax
jne 0x2468
movq (%rbx), %rdi
leaq 0x1bb9(%rip), %rsi      # 0x4018
callq 0x3060
testl %eax, %eax
je 0x2490
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x3060
testl %eax, %eax
je 0x2490
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x25b4
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]push_swap_42/srcs_push_swap/ft_post_process.c
// Function: ft_reduce_push
static int	ft_reduce_push(t_stack *s, char **buf, char **tab, int which)
{
	int		i;
	int		tmp;

	tmp = 0;
	i = ft_how_push(tab, which, &tmp);
	while (tmp > 0)
	{
		*buf = ft_strjoinfree(*buf, which ? "pb\n" : "pa\n", FIRST);
		tmp--;
		s->size_a = which ? s->size_a - 1 : s->size_a + 1;
		s->size_b = which ? s->size_b + 1 : s->size_b - 1;
	}
	while (tmp < 0)
	{
		*buf = ft_strjoinfree(*buf, which ? "pa\n" : "pb\n", FIRST);
		tmp++;
		s->size_a = which ? s->size_a + 1 : s->size_a - 1;
		s->size_b = which ? s->size_b - 1 : s->size_b + 1;
	}
	return (i);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rdi
leaq 0x1b72(%rip), %rsi      # 0x4028
callq 0x3060
xorl %r13d, %r13d
testl %eax, %eax
je 0x24dd
leaq 0x1b5f(%rip), %r12      # 0x4028
movq 0x8(%r15,%r13,8), %rdi
incq %r13
movq %r12, %rsi
callq 0x3060
testl %eax, %eax
jne 0x24c9
movl %r13d, %r12d
movq (%r15,%r12,8), %rdi
leaq 0x1b40(%rip), %rsi      # 0x402b
callq 0x3060
movl %r13d, %ebp
testl %eax, %eax
je 0x2527
leaq (%r15,%r12,8), %rbp
addq $0x8, %rbp
xorl %r13d, %r13d
leaq 0x1b22(%rip), %r15      # 0x402b
movq (%rbp,%r13,8), %rdi
movq %r15, %rsi
callq 0x3060
incq %r13
testl %eax, %eax
jne 0x2509
leal (%r12,%r13), %ebp
subl %r13d, %r12d
movl %r12d, %r13d
testl %r13d, %r13d
jle 0x256b
movq (%rbx), %rax
incl %r13d
leaq 0x1b1b(%rip), %r15      # 0x4054
movq %rax, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x3139
movq %rax, (%rbx)
movdqu 0x20(%r14), %xmm0
paddq 0x1ae6(%rip), %xmm0     # 0x4040
movdqu %xmm0, 0x20(%r14)
decl %r13d
cmpl $0x1, %r13d
ja 0x2539
jmp 0x25a3
jns 0x25a3
movq (%rbx), %rax
leaq 0x1ad9(%rip), %r15      # 0x4050
movq %rax, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x3139
movq %rax, (%rbx)
movdqu 0x20(%r14), %xmm0
paddq 0x1a98(%rip), %xmm0     # 0x4030
movdqu %xmm0, 0x20(%r14)
incl %r13d
jne 0x2577
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]push_swap_42/srcs_push_swap/ft_post_process.c
// Function: ft_reduce_rotate
static int	ft_reduce_rotate(t_stack *s, char **buf, char **tab, int which)
{
	int		i;
	int		tmp;
	char	*str;

	i = 0;
	str = tab[i];
	while (ft_strequ(tab[i], tab[i + 1]))
		i++;
	tmp = ++i;
	if ((which && tmp > (int)s->size_b / 2)
			|| (!which && tmp > (int)s->size_a / 2))
		tmp = which ? tmp - s->size_b : tmp - s->size_a;
	if (tmp >= 0)
		i = 0;
	while (tmp < 0)
	{
		if (which)
			*buf = ft_strjoinfree(*buf, ft_strequ(str, "rb")
					? "rrb\n" : "rb\n", FIRST);
		else
			*buf = ft_strjoinfree(*buf, ft_strequ(str, "ra")
					? "rra\n" : "ra\n", FIRST);
		tmp++;
	}
	return (i);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbp
movq (%rdx), %r15
xorl %r12d, %r12d
movq (%r13,%r12,8), %rdi
movq 0x8(%r13,%r12,8), %rsi
incq %r12
callq 0x3060
testl %eax, %eax
jne 0x25d0
leaq -0x1(%r12), %rcx
testl %ebx, %ebx
je 0x25f4
movl 0x28(%rbp), %eax
jmp 0x25f7
movl 0x20(%rbp), %eax
movl %eax, %edx
shrl $0x1f, %edx
addl %eax, %edx
sarl %edx
movl %r12d, %r13d
cmpl %ecx, %edx
jg 0x260a
subl %eax, %r13d
xorl %eax, %eax
testl %r13d, %r13d
jns 0x2671
movq (%r14), %rbp
movq %r15, %rdi
testl %ebx, %ebx
je 0x263b
leaq 0x19f7(%rip), %rsi      # 0x4019
callq 0x3060
leaq 0x1a2b(%rip), %rsi      # 0x4059
testl %eax, %eax
je 0x2659
leaq 0x1a1f(%rip), %rsi      # 0x4058
jmp 0x2659
leaq 0x19d3(%rip), %rsi      # 0x4015
callq 0x3060
leaq 0x1a10(%rip), %rsi      # 0x405e
testl %eax, %eax
je 0x2659
leaq 0x1a04(%rip), %rsi      # 0x405d
movq %rbp, %rdi
movl $0x1, %edx
callq 0x3139
movq %rax, (%r14)
incl %r13d
jne 0x2611
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]push_swap_42/srcs_push_swap/ft_algo_tool.c
// Function: ft_over_pivot
int			ft_over_pivot(long *tab, size_t size, long pivot, int which)
{
	size_t		i;

	i = 0;
	while (i < size)
	{
		if ((!which && tab[i] < pivot) || (which && tab[i] >= pivot))
			return (TRUE);
		i++;
	}
	return (FALSE);
}

// Assembly:
testq %rsi, %rsi
je 0x26a3
xorl %eax, %eax
movq (%rdi,%rax,8), %r8
testl %ecx, %ecx
je 0x2696
cmpq %rdx, %r8
jl 0x269b
jmp 0x26a6
cmpq %rdx, %r8
jl 0x26a6
incq %rax
cmpq %rax, %rsi
jne 0x2687
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]push_swap_42/srcs_push_swap/ft_algo_tool.c
// Function: ft_three_a
void		ft_three_a(t_stack *s)
{
	if (s->size_a <= 1 || ft_is_good(s->a, s->size_a, 0))
		return ;
	else if (s->size_a == 2)
	{
		if (s->a[s->size_a - 1] > s->a[s->size_a - 2])
			ft_cmd(ft_exec_swap, s, "sa");
	}
	else
		ft_three_a_extend(s);
}

// Assembly:
pushq %rbx
movq 0x20(%rdi), %rsi
cmpq $0x2, %rsi
jb 0x26c8
movq %rdi, %rbx
movq (%rdi), %rdi
xorl %edx, %edx
callq 0x1ed8
testl %eax, %eax
je 0x26ca
popq %rbx
retq
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
cmpq $0x2, %rsi
jne 0x26e5
movq 0x8(%rdi), %rax
cmpq (%rdi), %rax
jle 0x26c8
jmp 0x27b3
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x21dc
testl %eax, %eax
je 0x270c
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
movq -0x10(%rdi,%rsi,8), %rdx
callq 0x21fb
testl %eax, %eax
je 0x27c3
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x21dc
testl %eax, %eax
je 0x2749
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
movq -0x10(%rdi,%rsi,8), %rdx
callq 0x21fb
testl %eax, %eax
je 0x2749
leaq 0x4b5(%rip), %rdi       # 0x2bf2
leaq 0x18d1(%rip), %rdx      # 0x4015
jmp 0x27e7
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x21fb
testl %eax, %eax
je 0x278b
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
movq -0x10(%rdi,%rsi,8), %rdx
callq 0x21dc
testl %eax, %eax
je 0x278b
leaq 0x478(%rip), %rdi       # 0x2bf2
leaq 0x1893(%rip), %rdx      # 0x4014
movq %rbx, %rsi
callq 0x2343
jmp 0x27b3
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x21fb
testl %eax, %eax
jne 0x27d9
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
movq (%rdi), %rdx
callq 0x21dc
testl %eax, %eax
je 0x27d9
leaq 0x2f6(%rip), %rdi       # 0x2ab0
leaq 0x1849(%rip), %rdx      # 0x400a
jmp 0x27e7
leaq 0x2e6(%rip), %rdi       # 0x2ab0
leaq 0x1839(%rip), %rdx      # 0x400a
movq %rbx, %rsi
callq 0x2343
leaq 0x412(%rip), %rdi       # 0x2bf2
leaq 0x182d(%rip), %rdx      # 0x4014
movq %rbx, %rsi
popq %rbx
jmp 0x2343
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]push_swap_42/srcs_push_swap/ft_algo_tool.c
// Function: ft_three_b
void		ft_three_b(t_stack *s)
{
	if (s->size_b <= 1 || ft_is_good(s->b, s->size_b, 1))
		return ;
	else if (s->size_b == 2)
	{
		if (s->b[s->size_b - 1] < s->b[s->size_b - 2])
			ft_cmd(ft_exec_swap, s, "sb");
	}
	else
		ft_three_b_extend(s);
}

// Assembly:
pushq %rbx
movq 0x28(%rdi), %rsi
cmpq $0x2, %rsi
jb 0x2810
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movl $0x1, %edx
callq 0x1ed8
testl %eax, %eax
je 0x2812
popq %rbx
retq
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
cmpq $0x2, %rsi
jne 0x282e
movq 0x8(%rdi), %rax
cmpq (%rdi), %rax
jge 0x2810
jmp 0x2903
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x21fb
testl %eax, %eax
je 0x2856
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq -0x10(%rdi,%rsi,8), %rdx
callq 0x21dc
testl %eax, %eax
je 0x2913
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x21fb
testl %eax, %eax
je 0x2895
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq -0x10(%rdi,%rsi,8), %rdx
callq 0x21dc
testl %eax, %eax
je 0x2895
leaq 0x369(%rip), %rdi       # 0x2bf2
leaq 0x1789(%rip), %rdx      # 0x4019
jmp 0x2937
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x21dc
testl %eax, %eax
je 0x28d9
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq -0x10(%rdi,%rsi,8), %rdx
callq 0x21fb
testl %eax, %eax
je 0x28d9
leaq 0x32a(%rip), %rdi       # 0x2bf2
leaq 0x1749(%rip), %rdx      # 0x4018
movq %rbx, %rsi
callq 0x2343
jmp 0x2903
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x21dc
testl %eax, %eax
jne 0x2929
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq (%rdi), %rdx
callq 0x21fb
testl %eax, %eax
je 0x2929
leaq 0x1a6(%rip), %rdi       # 0x2ab0
leaq 0x16fc(%rip), %rdx      # 0x400d
jmp 0x2937
leaq 0x196(%rip), %rdi       # 0x2ab0
leaq 0x16ec(%rip), %rdx      # 0x400d
movq %rbx, %rsi
callq 0x2343
leaq 0x2c2(%rip), %rdi       # 0x2bf2
leaq 0x16e1(%rip), %rdx      # 0x4018
movq %rbx, %rsi
popq %rbx
jmp 0x2343
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]push_swap_42/libft/srcs/sort/ft_insertsort_integer.c
// Function: ft_insertsort_integer
void		ft_insertsort_integer(int *tab, size_t size)
{
	size_t	i;
	size_t	j;

	if (!tab)
		return ;
	i = 0;
	while (++i < size)
	{
		j = 0;
		while (j < i)
		{
			if (tab[i] < tab[j++])
				ft_insert_elem(tab, i, j);
		}
	}
}

// Assembly:
testq %rdi, %rdi
sete %al
cmpq $0x2, %rsi
setb %cl
orb %al, %cl
jne 0x3594
pushq %rbp
pushq %r14
pushq %rbx
leaq 0x4(%rdi), %rax
movl $0x1, %r8d
xorl %ecx, %ecx
movq %rcx, %rdx
movq %r8, %rcx
addq $0x2, %rdx
xorl %r9d, %r9d
movq %r9, %rbx
cmpq $0x1, %r8
movl $0x0, %r11d
sbbq %r8, %r11
movl (%rdi,%rcx,4), %r10d
incq %r9
cmpl (%rdi,%rbx,4), %r10d
jge 0x357b
movq %rdx, %rbx
subq %r9, %rbx
cmpq $0x1, %rbx
adcq $0x0, %rbx
xorl %r14d, %r14d
movl -0x4(%rax,%r14,4), %ebp
movl %ebp, (%rax,%r14,4)
decq %r14
cmpq %r14, %r11
jne 0x3560
movq %rcx, %r11
subq %rbx, %r11
movl %r10d, (%rdi,%r11,4)
decq %r8
cmpq %rcx, %r9
jne 0x3532
leaq 0x1(%rcx), %r8
addq $0x4, %rax
cmpq %rsi, %r8
jne 0x3525
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]push_swap_42/libft/srcs/sort/ft_insertsort_integer.c
// Function: ft_insertsort_long
void		ft_insertsort_long(long *tab, size_t size)
{
	size_t	i;
	size_t	j;

	if (!tab)
		return ;
	i = 0;
	while (++i < size)
	{
		j = 0;
		while (j < i)
		{
			if (tab[i] < tab[j++])
				ft_insert_elem_long(tab, i, j);
		}
	}
}

// Assembly:
testq %rdi, %rdi
sete %al
cmpq $0x2, %rsi
setb %cl
orb %al, %cl
jne 0x362e
pushq %r15
pushq %r14
pushq %rbx
leaq 0x8(%rdi), %rax
movl $0x1, %r8d
xorl %ecx, %ecx
movq %rcx, %rdx
movq %r8, %rcx
addq $0x2, %rdx
xorl %r9d, %r9d
movq %r9, %rbx
cmpq $0x1, %r8
movl $0x0, %r11d
sbbq %r8, %r11
movq (%rdi,%rcx,8), %r10
incq %r9
cmpq (%rdi,%rbx,8), %r10
jge 0x3614
movq %rdx, %rbx
subq %r9, %rbx
cmpq $0x1, %rbx
adcq $0x0, %rbx
xorl %r14d, %r14d
movq -0x8(%rax,%r14,8), %r15
movq %r15, (%rax,%r14,8)
decq %r14
cmpq %r14, %r11
jne 0x35f6
movslq %r10d, %r10
movq %rcx, %r11
subq %rbx, %r11
movq %r10, (%rdi,%r11,8)
decq %r8
cmpq %rcx, %r9
jne 0x35c8
leaq 0x1(%rcx), %r8
addq $0x8, %rax
cmpq %rsi, %r8
jne 0x35bb
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]libcperciva/tests/elasticarray/main.c
// Function: main
int
main(int argc, char * argv[])
{
	const char * ch;

	WARNP_INIT;

	/* Process arguments. */
	while ((ch = GETOPT(argc, argv)) != NULL) {
		GETOPT_SWITCH(ch) {
		GETOPT_OPT("-x"):
			exit(selftest());
		GETOPT_OPT("-t"):
			exit(elasticarray_perftest());
		GETOPT_DEFAULT:
			usage();
		}
	}

	usage();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x17cc
callq 0x2c3c
movl %ebp, %edi
movq %rbx, %rsi
callq 0x2368
testq %rax, %rax
jne 0x17e0
callq 0x1d40
movq %rax, %r14
leaq 0x4956(%rip), %r13      # 0x6140
leaq 0x1813(%rip), %r15      # 0x3004
leaq 0x180f(%rip), %r12      # 0x3007
movq $0x101, (%rsp)          # imm = 0x101
movq (%rsp), %rax
decq %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x0, (%r13)
je 0x1829
movq %r14, %rdi
callq 0x26af
addq (%rsp), %rax
jmp 0x1837
movq 0x10(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x10(%rsp)
cmpq $0x102, %rax            # imm = 0x102
je 0x188a
cmpq $0x104, %rax            # imm = 0x104
je 0x1875
cmpq $0x106, %rax            # imm = 0x106
je 0x18a9
cmpl $0x0, (%r13)
jne 0x17db
cmpl $0x0, 0xc(%rsp)
jne 0x1814
movl $0x106, %edi            # imm = 0x106
subq (%rsp), %rdi
callq 0x28bd
movl $0x1, 0xc(%rsp)
jmp 0x1814
cmpl $0x0, (%r13)
jne 0x18cc
movl $0x104, %esi            # imm = 0x104
subq (%rsp), %rsi
movq %r12, %rdi
jmp 0x189d
cmpl $0x0, (%r13)
jne 0x18d3
movl $0x102, %esi            # imm = 0x102
subq (%rsp), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x276c
jmp 0x1814
movl $0x1, (%r13)
movl %ebp, %edi
movq %rbx, %rsi
callq 0x2368
movq %rax, %r14
testq %rax, %rax
jne 0x17f8
jmp 0x17db
callq 0x1d84
jmp 0x18d8
callq 0x18df
movl %eax, %edi
callq 0x11c0
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]libcperciva/tests/elasticarray/elasticarray_perftest.c
// Function: elasticarray_perftest
int
elasticarray_perftest(void)
{

	/* Benchmark elasticarray_append() and elasticarray_shrink(). */
	if (check_append_shrink())
		goto err0;

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl $0x4, %esi
xorl %edi, %edi
callq 0x200c
testq %rax, %rax
je 0x1ffc
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2a00
testl %eax, %eax
je 0x1dde
callq 0x1070
cmpl $0x0, (%rax)
je 0x1fe6
movq %rax, %r14
leaq 0x12b5(%rip), %rdi      # 0x3080
xorl %eax, %eax
callq 0x2cbc
movl $0x0, (%r14)
jmp 0x1ff4
leaq 0x4(%rsp), %r14
movl $0x0, (%r14)
movl $0x1, %edx
movl $0x4, %ecx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x217b
testl %eax, %eax
jne 0x1ff4
movl 0x4(%rsp), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rsp)
cmpl $0xf423f, %eax          # imm = 0xF423F
jl 0x1dea
leaq 0x8(%rsp), %rdi
callq 0x2a00
testl %eax, %eax
jne 0x1db3
movq 0x8(%rsp), %r14
movq 0x10(%rsp), %r15
leaq 0x18(%rsp), %rdi
subq (%rdi), %r14
subq 0x8(%rdi), %r15
callq 0x2a00
testl %eax, %eax
jne 0x1db3
cvtsi2sd %r14, %xmm0
cvtsi2sd %r15, %xmm1
mulsd 0x120c(%rip), %xmm1     # 0x3068
addsd %xmm0, %xmm1
mulsd 0x1208(%rip), %xmm1     # 0x3070
divsd 0x1208(%rip), %xmm1     # 0x3078
movsd %xmm1, 0x38(%rsp)
movl $0x0, 0x4(%rsp)
movl $0x1, %esi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x221f
movl 0x4(%rsp), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rsp)
cmpl $0xf423f, %eax          # imm = 0xF423F
jl 0x1e7e
leaq 0x8(%rsp), %rdi
callq 0x2a00
testl %eax, %eax
jne 0x1db3
movq 0x8(%rsp), %r14
movq 0x10(%rsp), %r15
leaq 0x18(%rsp), %rdi
subq (%rdi), %r14
subq 0x8(%rdi), %r15
callq 0x2a00
testl %eax, %eax
jne 0x1db3
xorps %xmm0, %xmm0
cvtsi2sd %r14, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r15, %xmm1
mulsd 0x1179(%rip), %xmm1     # 0x3068
addsd %xmm0, %xmm1
mulsd 0x1175(%rip), %xmm1     # 0x3070
divsd 0x1175(%rip), %xmm1     # 0x3078
movsd %xmm1, 0x30(%rsp)
leaq 0x4(%rsp), %r14
movl $0x0, (%r14)
movl $0x1, %edx
movl $0x4, %ecx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x217b
testl %eax, %eax
jne 0x1ff4
movl $0x1, %esi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x221f
movl 0x4(%rsp), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rsp)
cmpl $0xf423f, %eax          # imm = 0xF423F
jl 0x1f15
leaq 0x8(%rsp), %rdi
callq 0x2a00
testl %eax, %eax
jne 0x1db3
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
subq 0x18(%rsp), %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
subq 0x20(%rsp), %rcx
xorps %xmm1, %xmm1
cvtsi2sd %rcx, %xmm1
mulsd 0x10d4(%rip), %xmm1     # 0x3068
addsd %xmm0, %xmm1
mulsd 0x10d0(%rip), %xmm1     # 0x3070
divsd 0x10d0(%rip), %xmm1     # 0x3078
movsd %xmm1, 0x28(%rsp)
movq %rbx, %rdi
callq 0x20b4
leaq 0x10dd(%rip), %rdi      # 0x309a
callq 0x1090
leaq 0x10c1(%rip), %rdi      # 0x308a
movsd 0x38(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
movsd 0x28(%rsp), %xmm2
movb $0x3, %al
callq 0x10d0
xorl %eax, %eax
jmp 0x2001
leaq 0x1093(%rip), %rdi      # 0x3080
xorl %eax, %eax
callq 0x2ddb
movq %rbx, %rdi
callq 0x20b4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_04/stack.c
// Function: swap
double pop(void)
{
  if (sp > 0)
  {
    return stack[--sp];
  }
  else
  {
    printf("Error: stack empty.\n");
  }

  return 0.0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl 0x279d(%rip), %eax      # 0x4070
leaq 0x27a6(%rip), %rbx      # 0x4080
testl %eax, %eax
jle 0x18ed
decl %eax
movl %eax, 0x278a(%rip)      # 0x4070
movsd (%rbx,%rax,8), %xmm0
jmp 0x1902
leaq 0x7ae(%rip), %rdi       # 0x20a2
callq 0x1030
xorps %xmm0, %xmm0
movl 0x276e(%rip), %eax      # 0x4070
testl %eax, %eax
jle 0x1915
decl %eax
movl %eax, 0x2762(%rip)      # 0x4070
movsd (%rbx,%rax,8), %xmm1
jmp 0x1936
leaq 0x786(%rip), %rdi       # 0x20a2
movsd %xmm0, 0x8(%rsp)
callq 0x1030
movsd 0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
movl 0x273a(%rip), %eax      # 0x4070
cmpl $0x63, %eax
jg 0x194d
leal 0x1(%rax), %ecx
movl %ecx, 0x272c(%rip)      # 0x4070
cltq
movsd %xmm0, (%rbx,%rax,8)
jmp 0x196b
leaq 0x73b(%rip), %rdi       # 0x208f
movsd %xmm1, 0x8(%rsp)
callq 0x1030
movsd 0x8(%rsp), %xmm1
movl 0x2705(%rip), %ecx      # 0x4070
cmpl $0x63, %ecx
jg 0x1987
leal 0x1(%rcx), %eax
movl %eax, 0x26f7(%rip)      # 0x4070
movslq %ecx, %rax
movsd %xmm1, (%rbx,%rax,8)
addq $0x10, %rsp
popq %rbx
retq
leaq 0x701(%rip), %rdi       # 0x208f
addq $0x10, %rsp
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/ikbenlike[P]nngutils/src/base64.c
// Function: tripletoquad
char *tripletoquad(char *x, char *r){

    r[0] = lookup(x[0] >> 2);
    r[1] = lookup(((x[0] & 0b00000011) << 4) | ((x[1] & 0b11110000) >> 4));
    r[2] = lookup(((x[1] & 0b00001111) << 2) | ((x[2] & 0b11000000) >> 6));
    r[3] = lookup(x[2] & 0b00111111);

    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rax
movb (%rdi), %cl
sarb $0x2, %cl
movq 0x2b92(%rip), %rdx      # 0x40a8
movsbq %cl, %rcx
movb (%rdx,%rcx), %cl
movb %cl, (%rsi)
movzbl (%rdi), %ecx
shll $0x4, %ecx
andl $0x30, %ecx
movzbl 0x1(%rdi), %edx
shrl $0x4, %edx
orl %ecx, %edx
movq 0x2b70(%rip), %rcx      # 0x40a8
movb (%rcx,%rdx), %cl
movb %cl, 0x1(%rsi)
movzbl 0x1(%rdi), %ecx
andl $0xf, %ecx
movzbl 0x2(%rdi), %edx
shrl $0x6, %edx
leal (%rdx,%rcx,4), %ecx
movq 0x2b52(%rip), %rdx      # 0x40a8
movb (%rdx,%rcx), %cl
movb %cl, 0x2(%rsi)
movzbl 0x2(%rdi), %ecx
andl $0x3f, %ecx
movq 0x2b3e(%rip), %rdx      # 0x40a8
movb (%rdx,%rcx), %cl
movb %cl, 0x3(%rsi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ikbenlike[P]nngutils/src/base64.c
// Function: wrap_quad
void wrap_quad(char *quad, struct base64_args *args){
    static int printed = 0;
    for(int i = 0; i < 4; i++){
        if(printed++ == args->wrap && args->wrap != 0){
            putchar('\n');
            printed = 1;
        }
        putchar(quad[i]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movslq 0x2b28(%rip), %rax      # 0x40b4
leal 0x1(%rax), %ecx
movl %ecx, 0x2b1f(%rip)      # 0x40b4
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
setne %al
testq %rcx, %rcx
sete %cl
orb %al, %cl
jne 0x15bd
movl $0xa, %edi
callq 0x1040
movl $0x1, 0x2af7(%rip)      # 0x40b4
movsbl (%r14,%r15), %edi
callq 0x1040
incq %r15
cmpq $0x4, %r15
jne 0x1585
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ikbenlike[P]nngutils/src/base64.c
// Function: encode_buffer
void encode_buffer(ssize_t size, char *buf, struct base64_args *args){
    //assert(buf[2] == '\n');
    size_t last_triplet = size - size % 3;
    size_t i = 0;
    char *quad = calloc(4, sizeof(char));
    for(; i < last_triplet; i += 3){
        tripletoquad(&buf[i], quad);
        wrap_quad(quad, args);
        memset(quad, 0, 4);
    }
    if(i < size){
        char *triplet = calloc(3, sizeof(char));
        size_t diff = size - i;
        triplet[0] = buf[i];
        if(diff == 2){
            triplet[1] = buf[i+1];
            tripletoquad(triplet, quad);
            quad[3] = '=';
        }
        else if(diff == 3 || diff == 1){
            tripletoquad(triplet, quad);
            quad[2] = '=';
            quad[3] = '=';
        }
        wrap_quad(quad, args);
        if(args->wrap != 0){
            putchar('\n');
        }
    }
    free(quad);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %rax
movabsq $0x5555555555555556, %rcx # imm = 0x5555555555555556
movq %rdi, -0x30(%rbp)
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
addq %rdx, %rax
leaq (%rax,%rax,2), %r15
movl $0x4, %edi
movl $0x1, %esi
callq 0x10b0
movq %rax, %r14
xorl %r13d, %r13d
testq %r15, %r15
je 0x1652
leaq (%r12,%r13), %rdi
movq %r14, %rsi
callq 0x1503
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1572
movl $0x0, (%r14)
addq $0x3, %r13
cmpq %r15, %r13
jb 0x162b
movq -0x30(%rbp), %r15
subq %r13, %r15
jbe 0x16c6
movl $0x3, %edi
movl $0x1, %esi
callq 0x10b0
movb (%r12,%r13), %cl
movb %cl, (%rax)
cmpq $0x2, %r15
jne 0x168b
movb 0x1(%r12,%r13), %cl
movb %cl, 0x1(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x1503
jmp 0x16a5
andq $-0x3, %r15
cmpq $0x1, %r15
jne 0x16aa
movq %rax, %rdi
movq %r14, %rsi
callq 0x1503
movb $0x3d, 0x2(%r14)
movb $0x3d, 0x3(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1572
cmpq $0x0, 0x8(%rbx)
je 0x16c6
movl $0xa, %edi
callq 0x1040
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/ikbenlike[P]nngutils/src/base64.c
// Function: encode_file
void encode_file(struct base64_args *args){
    char *buf = calloc(4096, sizeof(char));
    int fd = open(args->file, O_RDONLY);
    if(fd == -1){
        handle_error(errno, args);
    }

    ssize_t r = 0;
    for(r = read(fd, buf, 4095); r > 0; r = read(fd, buf, 4095)){
        encode_buffer(r, buf, args);
    }

    free(buf);
    close(fd);

    if(r == -1){
        handle_error(errno, args);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x1000, %edi           # imm = 0x1000
movl $0x1, %esi
callq 0x10b0
movq %rax, %r14
movq 0x18(%rbx), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x10f0
cmpl $-0x1, %eax
je 0x1758
movl %eax, %r15d
jmp 0x1721
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x15db
movl $0xfff, %edx            # imm = 0xFFF
movl %r15d, %edi
movq %r14, %rsi
callq 0x10a0
movq %rax, %r12
testq %rax, %rax
jg 0x1713
movq %r14, %rdi
callq 0x1030
movl %r15d, %edi
callq 0x1090
cmpq $-0x1, %r12
je 0x1758
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1050
movl (%rax), %edi
movq %rbx, %rsi
callq 0x129c
// File: /workspace/github_c_makefile_star2_O3/ikbenlike[P]nngutils/src/base64.c
// Function: main
int main(int argc, char **argv){
    struct base64_args *args = calloc(1, sizeof(struct base64_args));
    parse_args(args, argc, argv);

    /*printf("decode: %d\n", args->decode);
    printf("ignore garbage: %d\n", args->ignore_garbage);
    printf("wrap: %d\n", args->wrap);
    printf("help: %d\n", args->help);
    printf("version: %d\n", args->version);
    printf("file: %s\n", args->file);*/

    if(args->file != NULL && strcmp(args->file, "-") && args->decode == false){
        encode_file(args);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %r15d
movl $0x1, %edi
movl $0x20, %esi
callq 0x10b0
movq %rax, %rbx
movq %rax, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x12e8
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x17b8
cmpb $0x2d, (%rax)
jne 0x17ab
cmpb $0x0, 0x1(%rax)
je 0x17b8
cmpb $0x0, (%rbx)
jne 0x17b8
movq %rbx, %rdi
callq 0x16dc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq