LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/SignMotionSensor.cpp
// Function: SignMotionSensor::SignMotionSensor()
SignMotionSensor::SignMotionSensor()
	: SensorBase(NULL, SENSOR_DATANAME_SIGN_M),
	mInputReader(4)
{
	mPendingEvent.version = sizeof(sensors_event_t);
	mPendingEvent.sensor = ID_SIGN_MOTION;
	mPendingEvent.type = SENSOR_TYPE_SIGNIFICANT_MOTION;
	mPendingEvent.data[0] = 1.0f;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
leaq 0x1e99(%rip), %rdx      # 0xa664
xorl %eax, %eax
movl %eax, %esi
callq 0x5060
movq -0x20(%rbp), %rdi
movq 0x56f1(%rip), %rax      # 0xded0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x1028, %rdi           # imm = 0x1028
movl $0x4, %esi
callq 0x5120
jmp 0x87f9
movq -0x20(%rbp), %rax
movl $0x68, 0x1050(%rax)
movl $0x16, 0x1054(%rax)
movl $0x11, 0x1058(%rax)
movss 0x1e3d(%rip), %xmm0     # 0xa660
movss %xmm0, 0x1068(%rax)
cmpl $0x0, 0x1020(%rax)
je 0x884d
jmp 0x884f
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x5160
jmp 0x8855
jmp 0x884f
addq $0x20, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x53d0
nop
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/SignMotionSensor.cpp
// Function: SignMotionSensor::enable(int, int, int)
int SignMotionSensor::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_SIGN_MOTION_HANDLE, flags);
			if(err >= 0)
				err = 0;
		}
		mEnabled = 1;
	} else {
		if (mEnabled){
			err = writeEnable(SENSORS_SIGN_MOTION_HANDLE, flags);
			if(err >= 0) {
				err = 0;
				mEnabled = 0;
			}
		}
	}

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

	return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x10(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x897c
movq 0x561c(%rip), %rax      # 0xdf60
cmpl $0x0, (%rax)
jne 0x896d
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %edx
movq (%rdi), %rax
movl $0x16, %esi
callq *0x40(%rax)
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x896b
movl $0x0, -0x18(%rbp)
jmp 0x896d
movq 0x55ec(%rip), %rax      # 0xdf60
movl $0x1, (%rax)
jmp 0x89bb
movq 0x55dd(%rip), %rax      # 0xdf60
cmpl $0x0, (%rax)
je 0x89b9
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %edx
movq (%rdi), %rax
movl $0x16, %esi
callq *0x40(%rax)
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x89b7
movl $0x0, -0x18(%rbp)
movq 0x55af(%rip), %rax      # 0xdf60
movl $0x0, (%rax)
jmp 0x89b9
jmp 0x89bb
cmpl $0x0, -0x18(%rbp)
jl 0x89c3
jmp 0x89c5
jmp 0x89c5
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/StepCounterSensor.cpp
// Function: StepCounterSensor::StepCounterSensor()
StepCounterSensor::StepCounterSensor()
	: SensorBase(NULL, SENSOR_DATANAME_STEP_C),
	mInputReader(4)
{
	mPendingEvent.version = sizeof(sensors_event_t);
	mPendingEvent.sensor = ID_STEP_COUNTER;
	mPendingEvent.type = SENSOR_TYPE_STEP_COUNTER;
	memset(&mPendingEvent.u64, 0, sizeof(mPendingEvent.u64));
	delivery_rate = 0;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
leaq 0x1ad2(%rip), %rdx      # 0xa69d
xorl %eax, %eax
movl %eax, %esi
callq 0x5060
movq -0x20(%rbp), %rdi
movq 0x5399(%rip), %rax      # 0xdf78
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x1028, %rdi           # imm = 0x1028
movl $0x4, %esi
callq 0x5120
jmp 0x8bf9
movq -0x20(%rbp), %rdi
movl $0x68, 0x1050(%rdi)
movl $0x14, 0x1054(%rdi)
movl $0x13, 0x1058(%rdi)
addq $0x1050, %rdi           # imm = 0x1050
addq $0x18, %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x5130
movq -0x20(%rbp), %rax
movq $0x0, 0x10c8(%rax)
cmpl $0x0, 0x1020(%rax)
je 0x8c63
jmp 0x8c65
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x5160
jmp 0x8c6b
jmp 0x8c65
addq $0x20, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x53d0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/StepCounterSensor.cpp
// Function: StepCounterSensor::enable(int, int, int)
int StepCounterSensor::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_STEP_COUNTER_HANDLE, flags);
			if(err >= 0)
				err = 0;
		}
		mEnabled = 1;
	} else {
		if (mEnabled){
			err = writeEnable(SENSORS_STEP_COUNTER_HANDLE, flags);
			if(err >= 0) {
				err = 0;
				mEnabled = 0;
			}
		}
	}

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

	return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x10(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x8d9c
movq 0x51d4(%rip), %rax      # 0xdf38
cmpl $0x0, (%rax)
jne 0x8d8d
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %edx
movq (%rdi), %rax
movl $0x14, %esi
callq *0x40(%rax)
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x8d8b
movl $0x0, -0x18(%rbp)
jmp 0x8d8d
movq 0x51a4(%rip), %rax      # 0xdf38
movl $0x1, (%rax)
jmp 0x8ddb
movq 0x5195(%rip), %rax      # 0xdf38
cmpl $0x0, (%rax)
je 0x8dd9
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %edx
movq (%rdi), %rax
movl $0x14, %esi
callq *0x40(%rax)
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x8dd7
movl $0x0, -0x18(%rbp)
movq 0x5167(%rip), %rax      # 0xdf38
movl $0x0, (%rax)
jmp 0x8dd9
jmp 0x8ddb
cmpl $0x0, -0x18(%rbp)
jl 0x8de3
jmp 0x8de5
jmp 0x8de5
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/StepCounterSensor.cpp
// Function: StepCounterSensor::setDelay(int, long)
int StepCounterSensor::setDelay(int32_t __attribute__((unused))handle,
							int64_t delay_ns)
{
	int err = 0;

	if (delay_ns != delivery_rate) {
		err = writeDelay(SENSORS_STEP_COUNTER_HANDLE,
						NSEC_TO_MSEC(delay_ns));
		if(err >= 0)
			delivery_rate = delay_ns;
	}
	return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpq 0x10c8(%rcx), %rax
je 0x8e79
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
movq %rax, %rdx
movq (%rdi), %rax
movl $0x14, %esi
callq *0x48(%rax)
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x8e77
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x10c8(%rax)
jmp 0x8e79
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/StepDetectorSensor.cpp
// Function: StepDetectorSensor::StepDetectorSensor()
StepDetectorSensor::StepDetectorSensor()
	: SensorBase(NULL, SENSOR_DATANAME_STEP_D),
	mInputReader(4)
{
	mPendingEvent.version = sizeof(sensors_event_t);
	mPendingEvent.sensor = ID_STEP_DETECTOR;
	mPendingEvent.type = SENSOR_TYPE_STEP_DETECTOR;
	mPendingEvent.data[0] = 1.0f;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
leaq 0x1686(%rip), %rdx      # 0xa6d1
xorl %eax, %eax
movl %eax, %esi
callq 0x5060
movq -0x20(%rbp), %rdi
movq 0x4f99(%rip), %rax      # 0xdff8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x1028, %rdi           # imm = 0x1028
movl $0x4, %esi
callq 0x5120
jmp 0x9079
movq -0x20(%rbp), %rax
movl $0x68, 0x1050(%rax)
movl $0x15, 0x1054(%rax)
movl $0x12, 0x1058(%rax)
movss 0x15bd(%rip), %xmm0     # 0xa660
movss %xmm0, 0x1068(%rax)
cmpl $0x0, 0x1020(%rax)
je 0x90cd
jmp 0x90cf
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x5160
jmp 0x90d5
jmp 0x90cf
addq $0x20, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x53d0
nop
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/StepDetectorSensor.cpp
// Function: StepDetectorSensor::enable(int, int, int)
int StepDetectorSensor::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_STEP_DETECTOR_HANDLE, flags);
			if(err >= 0)
				err = 0;
		}
		mEnabled = 1;
	} else {
		if (mEnabled){
			err = writeEnable(SENSORS_STEP_DETECTOR_HANDLE, flags);
			if(err >= 0) {
				err = 0;
				mEnabled = 0;
			}
		}
	}

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

	return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x10(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x91fc
movq 0x4de4(%rip), %rax      # 0xdfa8
cmpl $0x0, (%rax)
jne 0x91ed
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %edx
movq (%rdi), %rax
movl $0x15, %esi
callq *0x40(%rax)
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x91eb
movl $0x0, -0x18(%rbp)
jmp 0x91ed
movq 0x4db4(%rip), %rax      # 0xdfa8
movl $0x1, (%rax)
jmp 0x923b
movq 0x4da5(%rip), %rax      # 0xdfa8
cmpl $0x0, (%rax)
je 0x9239
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %edx
movq (%rdi), %rax
movl $0x15, %esi
callq *0x40(%rax)
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x9237
movl $0x0, -0x18(%rbp)
movq 0x4d77(%rip), %rax      # 0xdfa8
movl $0x0, (%rax)
jmp 0x9239
jmp 0x923b
cmpl $0x0, -0x18(%rbp)
jl 0x9243
jmp 0x9245
jmp 0x9245
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
leaq 0x12cc(%rip), %rdx      # 0xa707
xorl %eax, %eax
movl %eax, %esi
callq 0x5060
movq -0x20(%rbp), %rdi
movq 0x4b69(%rip), %rax      # 0xdfb8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x1028, %rdi           # imm = 0x1028
movl $0x4, %esi
callq 0x5120
jmp 0x9469
movq -0x20(%rbp), %rax
movl $0x68, 0x1050(%rax)
movl $0x13, 0x1054(%rax)
movl $0x16, 0x1058(%rax)
movss 0x11cd(%rip), %xmm0     # 0xa660
movss %xmm0, 0x1068(%rax)
cmpl $0x0, 0x1020(%rax)
je 0x94bd
jmp 0x94bf
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x5160
jmp 0x94c5
jmp 0x94bf
addq $0x20, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x53d0
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x10(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x95ec
movq 0x49ec(%rip), %rax      # 0xdfa0
cmpl $0x0, (%rax)
jne 0x95dd
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %edx
movq (%rdi), %rax
movl $0x13, %esi
callq *0x40(%rax)
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x95db
movl $0x0, -0x18(%rbp)
jmp 0x95dd
movq 0x49bc(%rip), %rax      # 0xdfa0
movl $0x1, (%rax)
jmp 0x962b
movq 0x49ad(%rip), %rax      # 0xdfa0
cmpl $0x0, (%rax)
je 0x9629
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %edx
movq (%rdi), %rax
movl $0x13, %esi
callq *0x40(%rax)
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x9627
movl $0x0, -0x18(%rbp)
movq 0x497f(%rip), %rax      # 0xdfa0
movl $0x0, (%rax)
jmp 0x9629
jmp 0x962b
cmpl $0x0, -0x18(%rbp)
jl 0x9633
jmp 0x9635
jmp 0x9635
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x1198
movl $0x0, -0x4(%rbp)
jmp 0x124b
movq $0x0, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x1260
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x4840
cltq
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rsi
movq -0x28(%rbp), %rax
movl %eax, %edx
leaq -0x40(%rbp), %rdi
callq 0x4760
cmpq $0xc8, -0x28(%rbp)
jae 0x11f8
leaq -0x40(%rbp), %rdi
callq 0x1b60
jmp 0x1201
leaq -0x40(%rbp), %rdi
callq 0x20f0
cmpq $0x0, -0x30(%rbp)
je 0x1232
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
leaq -0x40(%rbp), %rsi
addq $0x10, %rsi
leaq -0x40(%rbp), %rdi
callq 0x1470
movq -0x30(%rbp), %rdi
callq 0x12f0
leaq -0x40(%rbp), %rdi
callq 0x43a0
movq -0x48(%rbp), %rdi
callq 0x4a90
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_push_swap/ft_push_swap.c
// Function: ft_get_av
static char	**ft_get_av(char **av)
{
	char	**arg;
	char	**tab;
	char	*s;
	int		count;

	s = NULL;
	count = 0;
	while (av[count])
	{
		tab = ft_strsplit(av[count], ' ');
		ft_join_tab(tab, &s);
		ft_free_tab_str(tab);
		count++;
	}
	arg = ft_strsplit(s, '\n');
	ft_strdel(&s);
	return (arg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x12c5
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x20, %esi
callq 0x4b70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1380
movq -0x18(%rbp), %rdi
callq 0x4a90
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x127b
movq -0x20(%rbp), %rdi
movl $0xa, %esi
callq 0x4b70
movq %rax, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x4a50
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_push_swap/ft_push_swap.c
// Function: ft_print_solution
static void	ft_print_solution(char *buf)
{
	char	**tab;
	int		i;

	if (!(tab = ft_strsplit(buf, '\n')))
	{
		ft_putendl_fd("Error", 2);
		return ;
	}
	ft_strdel(&buf);
	i = 0;
	while (tab[i])
		ft_putendl(tab[i++]);
	ft_free_tab_str(tab);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0xa, %esi
callq 0x4b70
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x1327
leaq 0x4ce9(%rip), %rdi      # 0x6004
movl $0x2, %esi
callq 0x5050
jmp 0x136c
leaq -0x8(%rbp), %rdi
callq 0x4a50
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1363
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4ff0
jmp 0x1337
movq -0x10(%rbp), %rdi
callq 0x4a90
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_push_swap/ft_push_swap.c
// Function: ft_join_tab
static void	ft_join_tab(char **tab, char **s)
{
	int		i;

	i = 0;
	while (tab[i])
	{
		if (!(ft_str_is_numeric(tab[i]) || (tab[i][0] == '-'
			&& ft_str_is_numeric(tab[i] + 1))))
		{
			ft_free_tab_str(tab);
			ft_putendl_fd("Error", 2);
			exit(1);
		}
		*s = ft_strjoinfree(*s, tab[i], FIRST);
		*s = ft_strjoinfree(*s, "\n", FIRST);
		i++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1469
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4b00
cmpl $0x0, %eax
jne 0x1412
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x13ee
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
addq $0x1, %rdi
callq 0x4b00
cmpl $0x0, %eax
jne 0x1412
movq -0x8(%rbp), %rdi
callq 0x4a90
leaq 0x4c06(%rip), %rdi      # 0x6004
movl $0x2, %esi
callq 0x5050
movl $0x1, %edi
callq 0x1060
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl $0x1, %edx
callq 0x49f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x4bed(%rip), %rsi      # 0x6034
movl $0x1, %edx
callq 0x49f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1397
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_push_swap/ft_make_simple.c
// Function: ft_make_simple
void		ft_make_simple(t_stack *s, char **buf)
{
	char	**tab;
	int		i;

	if (!(tab = ft_strsplit(*buf, '\n')))
	{
		ft_putendl_fd("Error", 2);
		return ;
	}
	ft_strdel(buf);
	i = ft_loop_tab(s, buf, tab);
	if (tab[i])
	{
		*buf = ft_strjoinfree(*buf, tab[i], FIRST);
		*buf = ft_strjoinfree(*buf, "\n", FIRST);
	}
	ft_free_tab_str(tab);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0xa, %esi
callq 0x4b70
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x14ae
leaq 0x4b62(%rip), %rdi      # 0x6004
movl $0x2, %esi
callq 0x5050
jmp 0x152c
movq -0x10(%rbp), %rdi
callq 0x4a50
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1540
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1523
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl $0x1, %edx
callq 0x49f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x4b25(%rip), %rsi      # 0x6034
movl $0x1, %edx
callq 0x49f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x4a90
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_push_swap/ft_algo.c
// Function: ft_process_sort
int			ft_process_sort(t_stack *s)
{
	int		ret_a;
	int		ret_b;

	if (s->size_a < 4)
		ft_three_a(s);
	while (!ft_reposition(s, &ret_a, &ret_b, 1))
	{
		ft_divide_b_stack(s, &ret_a, &ret_b);
		ft_reposition(s, &ret_a, &ret_b, 0);
		ft_divide_a_stack(s, &ret_a, &ret_b);
		ft_process_sort(s);
	}
	while (s->size_b)
		ft_cmd(ft_exec_push, s, "pa");
	ft_reposition(s, &ret_a, &ret_b, 1);
	return (TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x4, 0x20(%rax)
jae 0x1b80
movq -0x8(%rbp), %rdi
callq 0x3610
jmp 0x1b82
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
movl $0x1, %ecx
callq 0x2a70
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1ba6
jmp 0x1be6
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x1c30
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
xorl %ecx, %ecx
callq 0x2a70
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x1e30
movq -0x8(%rbp), %rdi
callq 0x1b60
jmp 0x1b82
jmp 0x1be8
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1c0c
movq -0x8(%rbp), %rsi
leaq 0x23d2(%rip), %rdi      # 0x3fd0
leaq 0x4423(%rip), %rdx      # 0x6028
callq 0x2f20
jmp 0x1be8
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
movl $0x1, %ecx
callq 0x2a70
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_push_swap/ft_algo.c
// Function: ft_divide_a_stack
static void	ft_divide_a_stack(t_stack *s, int *ret_a, int *ret_b)
{
	long	pivot;

	if (s->size_a < 4)
		ft_three_a(s);
	ft_reposition(s, ret_a, ret_b, 0);
	if (s->size_a < 4 || *ret_a)
		return ;
	pivot = ft_med_stack(s->a, s->size_a);
	while (s->size_a > 3 && ft_over_pivot(s->a, s->size_a, pivot, 0)
			&& !ft_is_good(s->a, s->size_a, 0))
		ft_loop_divide_a(s, ret_a, ret_b, pivot);
	ft_reposition(s, ret_a, ret_b, 1);
	ft_divide_a_stack(s, ret_a, ret_b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x4, 0x20(%rax)
jae 0x1e58
movq -0x8(%rbp), %rdi
callq 0x3610
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0x2a70
movq -0x8(%rbp), %rax
cmpq $0x4, 0x20(%rax)
jb 0x1e7f
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1e84
jmp 0x1f3e
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl %eax, %esi
callq 0x2de0
cltq
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x3, 0x20(%rcx)
movb %al, -0x21(%rbp)
jbe 0x1ef7
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x20(%rbp), %rdx
xorl %ecx, %ecx
callq 0x3590
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0x1ef7
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
xorl %edx, %edx
callq 0x27c0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x1f00
jmp 0x1f17
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1f50
jmp 0x1ea0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x1, %ecx
callq 0x2a70
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1e30
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_push_swap/ft_algo.c
// Function: ft_loop_divide_a
static void	ft_loop_divide_a(t_stack *s, int *ret_a, int *ret_b, long pivot)
{
	if (s->a[s->size_a - 1] > s->a[s->size_a - 2]
		&& s->a[s->size_a - 1] < pivot)
		ft_cmd(ft_exec_swap, s, "sa");
	else if (s->a[s->size_a - 1] < pivot)
	{
		ft_cmd(ft_exec_push, s, "pb");
		while (!ft_is_the_biggest(s->b, s->size_b, s->b[s->size_b - 1]))
			ft_cmd(ft_exec_rotate, s, "rb");
	}
	else
	{
		ft_cmd(ft_exec_rotate, s, "ra");
		if (s->size_b
				&& ft_is_the_smallest(s->b, s->size_b, s->b[s->size_b - 1]))
			ft_cmd(ft_exec_rotate, s, "rb");
	}
	ft_reposition(s, ret_a, ret_b, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x20(%rdx), %rdx
subq $0x2, %rdx
cmpq (%rcx,%rdx,8), %rax
jle 0x1fd1
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x20(%rbp), %rax
jge 0x1fd1
movq -0x8(%rbp), %rsi
leaq 0x1e40(%rip), %rdi      # 0x3e00
leaq 0x4043(%rip), %rdx      # 0x600a
callq 0x2f20
jmp 0x20ca
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x20(%rbp), %rax
jge 0x205b
movq -0x8(%rbp), %rsi
leaq 0x1fd7(%rip), %rdi      # 0x3fd0
leaq 0x402b(%rip), %rdx      # 0x602b
callq 0x2f20
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdx
callq 0x2c50
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2040
jmp 0x2059
movq -0x8(%rbp), %rsi
leaq 0x2095(%rip), %rdi      # 0x40e0
leaq 0x3fc7(%rip), %rdx      # 0x6019
callq 0x2f20
jmp 0x2005
jmp 0x20c8
movq -0x8(%rbp), %rsi
leaq 0x207a(%rip), %rdi      # 0x40e0
leaq 0x3fa8(%rip), %rdx      # 0x6015
callq 0x2f20
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x20c6
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdx
callq 0x2cc0
cmpl $0x0, %eax
je 0x20c6
movq -0x8(%rbp), %rsi
leaq 0x2026(%rip), %rdi      # 0x40e0
leaq 0x3f58(%rip), %rdx      # 0x6019
callq 0x2f20
jmp 0x20c8
jmp 0x20ca
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x1, %ecx
callq 0x2a70
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_push_swap/ft_algo500.c
// Function: ft_process_sort500
int			ft_process_sort500(t_stack *s)
{
	int		ret_a;
	int		ret_b;

	if (s->size_a < 4)
		ft_three_a(s);
	while (!ft_reposition(s, &ret_a, &ret_b, 1))
	{
		ft_divide_b_stack500(s, &ret_a, &ret_b);
		ft_reposition(s, &ret_a, &ret_b, 0);
		ft_divide_a_stack500(s, &ret_a, &ret_b);
		ft_process_sort500(s);
	}
	while (s->size_b)
		ft_cmd(ft_exec_push, s, "pa");
	ft_reposition(s, &ret_a, &ret_b, 1);
	return (TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x4, 0x20(%rax)
jae 0x2110
movq -0x8(%rbp), %rdi
callq 0x3610
jmp 0x2112
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
movl $0x1, %ecx
callq 0x2a70
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2136
jmp 0x2176
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x21c0
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
xorl %ecx, %ecx
callq 0x2a70
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x2350
movq -0x8(%rbp), %rdi
callq 0x20f0
jmp 0x2112
jmp 0x2178
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x219c
movq -0x8(%rbp), %rsi
leaq 0x1e42(%rip), %rdi      # 0x3fd0
leaq 0x3e93(%rip), %rdx      # 0x6028
callq 0x2f20
jmp 0x2178
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
movl $0x1, %ecx
callq 0x2a70
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_push_swap/ft_algo500.c
// Function: ft_divide_b_stack500
static void	ft_divide_b_stack500(t_stack *s, int *ret_a, int *ret_b)
{
	long	pivot;
	size_t	i;

	i = 1;
	if (s->size_b < 4)
		ft_three_b(s);
	ft_reposition(s, ret_a, ret_b, 0);
	if (s->size_b < 4 || *ret_b)
		return ;
	pivot = s->b[s->size_b - 1];
	while (s->size_b > i && s->b[s->size_b - i] < s->b[s->size_b - (i + 1)])
		pivot = s->b[s->size_b - ++i];
	while (s->size_b > 3 && ft_over_pivot(s->b, s->size_b, pivot, 1)
			&& !ft_is_good(s->b, s->size_b, 1))
		ft_loop_divide_b(s, ret_a, ret_b, pivot);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x1, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x4, 0x28(%rax)
jae 0x21f0
movq -0x8(%rbp), %rdi
callq 0x38f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0x2a70
movq -0x8(%rbp), %rax
cmpq $0x4, 0x28(%rax)
jb 0x2217
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x221c
jmp 0x233e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x29(%rbp)
jbe 0x2288
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x28(%rdx), %rdx
movq -0x28(%rbp), %rsi
addq $0x1, %rsi
subq %rsi, %rdx
cmpq (%rcx,%rdx,8), %rax
setl %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x2291
jmp 0x22bd
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq -0x28(%rbp), %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
subq %rdx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
jmp 0x2238
jmp 0x22bf
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x3, 0x28(%rcx)
movb %al, -0x2a(%rbp)
jbe 0x231e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x20(%rbp), %rdx
movl $0x1, %ecx
callq 0x3590
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x2a(%rbp)
je 0x231e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movl $0x1, %edx
callq 0x27c0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x2327
jmp 0x233e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x2480
jmp 0x22bf
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_push_swap/ft_algo500.c
// Function: ft_divide_a_stack500
static void	ft_divide_a_stack500(t_stack *s, int *ret_a, int *ret_b)
{
	long	pivot;

	if (s->size_a < 4)
		ft_three_a(s);
	ft_reposition(s, ret_a, ret_b, 0);
	if (s->size_a < 4 || *ret_a)
		return ;
	pivot = ft_med_stack(s->a, s->size_a);
	if (ft_is_the_smallest(s->a, s->size_a, pivot))
		return ;
	while (s->size_a > 3 && ft_over_pivot(s->a, s->size_a, pivot, 0)
			&& !ft_is_good(s->a, s->size_a, 0))
		ft_loop_divide_a(s, ret_a, ret_b, pivot);
	ft_divide_a_stack500(s, ret_a, ret_b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x4, 0x20(%rax)
jae 0x2378
movq -0x8(%rbp), %rdi
callq 0x3610
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0x2a70
movq -0x8(%rbp), %rax
cmpq $0x4, 0x20(%rax)
jb 0x239f
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x23a4
jmp 0x246c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl %eax, %esi
callq 0x2de0
cltq
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x2cc0
cmpl $0x0, %eax
je 0x23e2
jmp 0x246c
jmp 0x23e4
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x3, 0x20(%rcx)
movb %al, -0x21(%rbp)
jbe 0x243b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x20(%rbp), %rdx
xorl %ecx, %ecx
callq 0x3590
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0x243b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
xorl %edx, %edx
callq 0x27c0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x2444
jmp 0x245b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x2620
jmp 0x23e4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2350
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_push_swap/ft_algo500.c
// Function: ft_loop_divide_b
static void	ft_loop_divide_b(t_stack *s, int *ret_a, int *ret_b, long pivot)
{
	if (s->size_a > 1 && s->a[s->size_a - 1] > s->a[s->size_a - 2])
		ft_cmd(ft_exec_swap, s, "sa");
	else if (s->b[s->size_b - 1] < s->b[s->size_b - 2]
			&& s->b[s->size_b - 1] >= pivot)
		ft_cmd(ft_exec_swap, s, "sb");
	else if (s->b[s->size_b - 1] >= pivot)
		ft_cmd(ft_exec_push, s, "pa");
	else
	{
		ft_cmd(ft_exec_rotate, s, "rb");
		if (s->size_a
				&& ft_is_the_biggest(s->a, s->size_a, s->a[s->size_a - 1]))
			ft_cmd(ft_exec_rotate, s, "ra");
	}
	ft_reposition(s, ret_a, ret_b, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x1, 0x20(%rax)
jbe 0x24ef
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x20(%rdx), %rdx
subq $0x2, %rdx
cmpq (%rcx,%rdx,8), %rax
jle 0x24ef
movq -0x8(%rbp), %rsi
leaq 0x1922(%rip), %rdi      # 0x3e00
leaq 0x3b25(%rip), %rdx      # 0x600a
callq 0x2f20
jmp 0x2601
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x28(%rdx), %rdx
subq $0x2, %rdx
cmpq (%rcx,%rdx,8), %rax
jge 0x255b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x20(%rbp), %rax
jl 0x255b
movq -0x8(%rbp), %rsi
leaq 0x18b6(%rip), %rdi      # 0x3e00
leaq 0x3abc(%rip), %rdx      # 0x600d
callq 0x2f20
jmp 0x25ff
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x20(%rbp), %rax
jl 0x2592
movq -0x8(%rbp), %rsi
leaq 0x1a4c(%rip), %rdi      # 0x3fd0
leaq 0x3a9d(%rip), %rdx      # 0x6028
callq 0x2f20
jmp 0x25fd
movq -0x8(%rbp), %rsi
leaq 0x1b43(%rip), %rdi      # 0x40e0
leaq 0x3a75(%rip), %rdx      # 0x6019
callq 0x2f20
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x25fb
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdx
callq 0x2c50
cmpl $0x0, %eax
je 0x25fb
movq -0x8(%rbp), %rsi
leaq 0x1af1(%rip), %rdi      # 0x40e0
leaq 0x3a1f(%rip), %rdx      # 0x6015
callq 0x2f20
jmp 0x25fd
jmp 0x25ff
jmp 0x2601
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x1, %ecx
callq 0x2a70
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_push_swap/ft_algo500.c
// Function: ft_loop_divide_a
static void	ft_loop_divide_a(t_stack *s, int *ret_a, int *ret_b, long pivot)
{
	if (s->size_b > 1 && s->b[s->size_b - 1] < s->b[s->size_b - 2])
		ft_cmd(ft_exec_swap, s, "sb");
	else if (s->a[s->size_a - 1] > s->a[s->size_a - 2]
			&& s->a[s->size_a - 1] < pivot)
		ft_cmd(ft_exec_swap, s, "sa");
	else if (s->a[s->size_a - 1] < pivot)
		ft_cmd(ft_exec_push, s, "pb");
	else
	{
		ft_cmd(ft_exec_rotate, s, "ra");
		if (s->size_b
				&& ft_is_the_smallest(s->b, s->size_b, s->b[s->size_b - 1]))
			ft_cmd(ft_exec_rotate, s, "rb");
	}
	ft_reposition(s, ret_a, ret_b, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x1, 0x28(%rax)
jbe 0x2691
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x28(%rdx), %rdx
subq $0x2, %rdx
cmpq (%rcx,%rdx,8), %rax
jge 0x2691
movq -0x8(%rbp), %rsi
leaq 0x1780(%rip), %rdi      # 0x3e00
leaq 0x3986(%rip), %rdx      # 0x600d
callq 0x2f20
jmp 0x27a1
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x20(%rdx), %rdx
subq $0x2, %rdx
cmpq (%rcx,%rdx,8), %rax
jle 0x26fa
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x20(%rbp), %rax
jge 0x26fa
movq -0x8(%rbp), %rsi
leaq 0x1717(%rip), %rdi      # 0x3e00
leaq 0x391a(%rip), %rdx      # 0x600a
callq 0x2f20
jmp 0x279f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x20(%rbp), %rax
jge 0x2730
movq -0x8(%rbp), %rsi
leaq 0x18ae(%rip), %rdi      # 0x3fd0
leaq 0x3902(%rip), %rdx      # 0x602b
callq 0x2f20
jmp 0x279d
movq -0x8(%rbp), %rsi
leaq 0x19a5(%rip), %rdi      # 0x40e0
leaq 0x38d3(%rip), %rdx      # 0x6015
callq 0x2f20
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x279b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdx
callq 0x2cc0
cmpl $0x0, %eax
je 0x279b
movq -0x8(%rbp), %rsi
leaq 0x1951(%rip), %rdi      # 0x40e0
leaq 0x3883(%rip), %rdx      # 0x6019
callq 0x2f20
jmp 0x279d
jmp 0x279f
jmp 0x27a1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x1, %ecx
callq 0x2a70
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
cmpq -0x18(%rbp), %rax
jae 0x283e
cmpl $0x0, -0x1c(%rbp)
jne 0x2806
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rdx
cmpq 0x8(%rcx,%rdx,8), %rax
jl 0x2827
cmpl $0x1, -0x1c(%rbp)
jne 0x2830
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rdx
cmpq 0x8(%rcx,%rdx,8), %rax
jle 0x2830
movl $0x0, -0x4(%rbp)
jmp 0x2845
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x27d7
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x2873
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x287f
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x2898
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x28a9
cmpl $0x0, -0x14(%rbp)
jne 0x28b2
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x28b2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x28f8
cmpl $0x0, -0x14(%rbp)
je 0x28c6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x28d1
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x2910
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0x28f1
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x28f8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jne 0x2934
xorl %eax, %eax
movq %rax, -0x68(%rbp)
jmp 0x293c
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x2952
xorl %eax, %eax
movq %rax, -0x70(%rbp)
jmp 0x295a
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2bd0
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
jne 0x2985
movl $0x0, -0x4(%rbp)
jmp 0x2a5e
cmpl $0x1, -0x1c(%rbp)
jne 0x2993
xorl %eax, %eax
movq %rax, -0x78(%rbp)
jmp 0x299b
movq -0x60(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x29b1
xorl %eax, %eax
movq %rax, -0x80(%rbp)
jmp 0x29b9
movq -0x60(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x2a4e
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x27c0
cmpl $0x0, %eax
je 0x2a1c
movq -0x60(%rbp), %rdi
callq 0x1030
cmpq $0x0, -0x28(%rbp)
je 0x2a04
movq -0x28(%rbp), %rax
movl %eax, -0x84(%rbp)
jmp 0x2a11
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x84(%rbp)
jmp 0x2a11
movl -0x84(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2a5e
movl -0x1c(%rbp), %ecx
leaq 0x35ef(%rip), %rsi      # 0x6015
leaq 0x35ec(%rip), %rax      # 0x6019
cmpl $0x1, %ecx
cmoveq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0x40e0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x29c9
movq -0x60(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x2850
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x2850
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x2ad6
cmpl $0x0, -0x1c(%rbp)
je 0x2ad6
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x2aee
cmpl $0x0, -0x1c(%rbp)
je 0x2aee
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x2af0
movl -0x20(%rbp), %ecx
movl %ecx, %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x25(%rbp)
jle 0x2b19
movl -0x24(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x24(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x2b22
jmp 0x2b3b
movq -0x8(%rbp), %rsi
leaq 0x15b3(%rip), %rdi      # 0x40e0
leaq 0x34ee(%rip), %rdx      # 0x6022
callq 0x2f20
jmp 0x2af0
jmp 0x2b3d
movl -0x20(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x20(%rbp)
cmpl $0x0, %eax
jle 0x2b66
movq -0x8(%rbp), %rsi
leaq 0x1588(%rip), %rdi      # 0x40e0
leaq 0x34b6(%rip), %rdx      # 0x6015
callq 0x2f20
jmp 0x2b3d
jmp 0x2b68
movl -0x24(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x24(%rbp)
cmpl $0x0, %eax
jle 0x2b91
movq -0x8(%rbp), %rsi
leaq 0x155d(%rip), %rdi      # 0x40e0
leaq 0x348f(%rip), %rdx      # 0x6019
callq 0x2f20
jmp 0x2b68
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, (%rcx)
movb %al, -0x26(%rbp)
je 0x2bac
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
setne %al
movb %al, -0x26(%rbp)
movb -0x26(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_push_swap/ft_order.c
// Function: ft_dup_stack
static long	*ft_dup_stack(long *tab, size_t size)
{
	long	*s;
	size_t	i;

	i = 0;
	if (!(s = (long *)malloc(sizeof(long) * size)))
		return (NULL);
	while (i < size)
	{
		s[i] = tab[i];
		i++;
	}
	return (s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
shlq $0x3, %rdi
callq 0x1050
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x2c09
movq $0x0, -0x8(%rbp)
jmp 0x2c43
jmp 0x2c0b
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x2c3b
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2c0b
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)