LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/InputEventReader.cpp
// Function: InputEventCircularReader::fill(int)
ssize_t InputEventCircularReader::fill(int fd)
{
	size_t numEventsRead = 0;
	if (mFreeSpace) {
		const ssize_t nread = read(fd, mHead, mFreeSpace * sizeof(input_event));
		if (nread<0 || nread % sizeof(input_event)) {
			return nread < 0 ? -errno : -EINVAL;
		}

		numEventsRead = nread / sizeof(input_event);
		if (numEventsRead) {
			mHead += numEventsRead;
			mFreeSpace -= numEventsRead;
			if (mHead > mBufferEnd) {
				size_t s = mHead - mBufferEnd;
				memcpy(mBuffer, mBufferEnd, s * sizeof(input_event));
				mHead = mBuffer + s;
			}
		}
	}
	return numEventsRead;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x20(%rdi), %rcx
testq %rcx, %rcx
je 0x7086
movq %rdi, %r14
movq 0x10(%rdi), %rax
imulq $0x18, %rcx, %rdx
movl %esi, %edi
movq %rax, %rsi
callq 0x5360
movq %rax, %rcx
pushq $0x18
popq %rsi
xorl %edx, %edx
divq %rsi
testq %rcx, %rcx
js 0x708a
testq %rdx, %rdx
jne 0x708a
movq %rax, %rbx
cmpq $0x18, %rcx
jb 0x709f
imulq $0x18, %rbx, %r15
addq 0x10(%r14), %r15
movq %r15, 0x10(%r14)
subq %rbx, 0x20(%r14)
movq 0x8(%r14), %rsi
subq %rsi, %r15
jbe 0x709f
movq (%r14), %rdi
movq %r15, %rdx
callq 0x51b0
addq (%r14), %r15
movq %r15, 0x10(%r14)
jmp 0x709f
xorl %ebx, %ebx
jmp 0x709f
testq %rcx, %rcx
js 0x7094
pushq $-0x16
popq %rbx
jmp 0x709f
callq 0x5070
movslq (%rax), %rbx
negq %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/InputEventReader.cpp
// Function: InputEventCircularReader::next()
void InputEventCircularReader::next()
{
	mCurr++;
	mFreeSpace++;
	if(mCurr >= mBufferEnd) {
		mCurr = mBuffer;
	}
}

// Assembly:
movq 0x18(%rdi), %rax
addq $0x18, %rax
movq %rax, 0x18(%rdi)
incq 0x20(%rdi)
cmpq 0x8(%rdi), %rax
jb 0x70e9
movq (%rdi), %rax
movq %rax, 0x18(%rdi)
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1300(%rip), %rdx      # 0x83fa
xorl %esi, %esi
callq 0x5060
movq 0x4dc8(%rip), %rax      # 0xbed0
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x1028(%rbx), %rdi
pushq $0x4
popq %rsi
callq 0x5110
movabsq $0x1600000068, %rax     # imm = 0x1600000068
movq %rax, 0x1050(%rbx)
movl $0x11, 0x1058(%rbx)
movl $0x3f800000, 0x1068(%rbx) # imm = 0x3F800000
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5160
movq %r14, %rdi
callq 0x5420
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %edx, %eax
xorl %edx, %edx
movq 0x4d94(%rip), %rbx      # 0xbf58
movl (%rbx), %ecx
testl %eax, %eax
setne %dl
je 0x71e6
pushq $0x1
popq %rbp
testl %ecx, %ecx
jne 0x71f9
movq (%rdi), %rax
pushq $0x16
popq %rsi
callq *0x40(%rax)
movl %eax, %ecx
sarl $0x1f, %eax
andl %ecx, %eax
jmp 0x71fb
testl %ecx, %ecx
je 0x7204
movq (%rdi), %rax
pushq $0x16
popq %rsi
callq *0x40(%rax)
testl %eax, %eax
js 0x71fd
xorl %ebp, %ebp
xorl %eax, %eax
movl %ebp, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
jmp 0x71fd
// File: /workspace/github_c_makefile_star2_O2/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/SignMotionSensor.cpp
// Function: SignMotionSensor::readEvents(sensors_event_t*, int)
int SignMotionSensor::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_SIGN_M) {

#if (DEBUG_SIGN_M == 1)
	STLOGD("SignMotionSensor::readEvents (event_code=%d)", event->code);
#endif
			switch(event->code) {
			case EVENT_TYPE_SIGN_M_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("SignMotionSensor: unknown event code \
					(type = %d, code = %d)", event->type,
								event->code);
			}
		} else if (event->type == EV_SYN) {

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

		} else {
			STLOGE("SignMotionSensor: 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 0x72fe
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 0x7304
leaq 0x1050(%r15), %rax
movq %rax, 0x8(%rsp)
xorl %r12d, %r12d
leaq 0x10(%rsp), %rbp
testl %ebx, %ebx
je 0x7307
movq %r13, %rdi
movq %rbp, %rsi
callq 0x52c0
testq %rax, %rax
je 0x7307
movq 0x10(%rsp), %rax
movzwl 0x10(%rax), %ecx
testl %ecx, %ecx
je 0x72b0
cmpl $0x4, %ecx
jne 0x72f1
movzwl 0x12(%rax), %ecx
cmpl $0x7, %ecx
je 0x72e7
cmpl $0x4, %ecx
jne 0x72f1
movl 0x14(%rax), %eax
shlq $0x20, %rax
movq %rax, 0x10b8(%r15)
jmp 0x72f1
movq (%r15), %rax
movq %r15, %rdi
pushq $0x16
popq %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x30(%rax)
movq 0x10b8(%r15), %rax
movq %rax, 0x1060(%r15)
pushq $0xd
popq %rcx
movq %r14, %rdi
movq 0x8(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
addq $0x68, %r14
decl %ebx
incl %r12d
jmp 0x72f1
movl 0x14(%rax), %eax
orq %rax, 0x10b8(%r15)
movq %r13, %rdi
callq 0x5230
jmp 0x7264
pushq $-0x16
popq %r12
jmp 0x7307
movq %rax, %r12
movl %r12d, %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_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1109(%rip), %rdx      # 0x8433
xorl %esi, %esi
callq 0x5060
movq 0x4c38(%rip), %rax      # 0xbf70
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x1028(%rbx), %rdi
pushq $0x4
popq %rsi
callq 0x5110
movabsq $0x1400000068, %rax     # imm = 0x1400000068
movq %rax, 0x1050(%rbx)
movl $0x13, 0x1058(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1068(%rbx)
movups %xmm0, 0x1078(%rbx)
movups %xmm0, 0x1088(%rbx)
movups %xmm0, 0x1098(%rbx)
andq $0x0, 0x10c8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5160
movq %r14, %rdi
callq 0x5420
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %edx, %eax
xorl %edx, %edx
movq 0x4b1e(%rip), %rbx      # 0xbf30
movl (%rbx), %ecx
testl %eax, %eax
setne %dl
je 0x7434
pushq $0x1
popq %rbp
testl %ecx, %ecx
jne 0x7447
movq (%rdi), %rax
pushq $0x14
popq %rsi
callq *0x40(%rax)
movl %eax, %ecx
sarl $0x1f, %eax
andl %ecx, %eax
jmp 0x7449
testl %ecx, %ecx
je 0x7452
movq (%rdi), %rax
pushq $0x14
popq %rsi
callq *0x40(%rax)
testl %eax, %eax
js 0x744b
xorl %ebp, %ebp
xorl %eax, %eax
movl %ebp, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
jmp 0x744b
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
cmpq %rdx, 0x10c8(%rdi)
je 0x749e
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movl $0xf4240, %ecx          # imm = 0xF4240
movq %rdx, %rax
cqto
idivq %rcx
movq (%rdi), %rcx
pushq $0x14
popq %rsi
movq %rax, %rdx
callq *0x48(%rcx)
testl %eax, %eax
js 0x7497
movq %rbx, 0x10c8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/StepCounterSensor.cpp
// Function: StepCounterSensor::readEvents(sensors_event_t*, int)
int StepCounterSensor::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_C) {

#if (DEBUG_STEP_C == 1)
	STLOGD("StepCounterSensor::readEvents (event_code=%d)", event->code);
#endif
			switch(event->code) {
			case EVENT_TYPE_STEP_C_DATA:
				steps = (uint32_t)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("StepCounterSensor: 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.u64.step_counter = (uint64_t)steps;
			mPendingEvent.timestamp = timestamp;
			memcpy(data, &mPendingEvent, sizeof(mPendingEvent));
			data++;
			count--;
			numEventReceived++;
#if (DEBUG_STEP_C == 1)
			STLOGD("StepCounterSensor::readEvents (time = %lld), count(%d), received(%d), steps(%d)",
						mPendingEvent.timestamp,
						count, numEventReceived, steps);
#endif

		} else {
			STLOGE("StepCounterSensor: 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 0x7598
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 0x759e
leaq 0x1050(%r15), %rax
movq %rax, 0x8(%rsp)
xorl %r12d, %r12d
leaq 0x10(%rsp), %rbp
testl %ebx, %ebx
je 0x75a1
movq %r13, %rdi
movq %rbp, %rsi
callq 0x52c0
testq %rax, %rax
je 0x75a1
movq 0x10(%rsp), %rax
movzwl 0x10(%rax), %ecx
testl %ecx, %ecx
je 0x753c
cmpl $0x4, %ecx
jne 0x756f
movzwl 0x12(%rax), %ecx
cmpl $0x7, %ecx
je 0x758c
cmpl $0x4, %ecx
je 0x757c
testl %ecx, %ecx
jne 0x756f
movl 0x14(%rax), %eax
movl %eax, 0x10c0(%r15)
jmp 0x756f
movl 0x10c0(%r15), %eax
movq %rax, 0x1068(%r15)
movq 0x10b8(%r15), %rax
movq %rax, 0x1060(%r15)
pushq $0xd
popq %rcx
movq %r14, %rdi
movq 0x8(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
addq $0x68, %r14
decl %ebx
incl %r12d
movq %r13, %rdi
callq 0x5230
jmp 0x74f0
movl 0x14(%rax), %eax
shlq $0x20, %rax
movq %rax, 0x10b8(%r15)
jmp 0x756f
movl 0x14(%rax), %eax
orq %rax, 0x10b8(%r15)
jmp 0x756f
pushq $-0x16
popq %r12
jmp 0x75a1
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_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xea5(%rip), %rdx       # 0x8467
xorl %esi, %esi
callq 0x5060
movq 0x4a20(%rip), %rax      # 0xbff0
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x1028(%rbx), %rdi
pushq $0x4
popq %rsi
callq 0x5110
movabsq $0x1500000068, %rax     # imm = 0x1500000068
movq %rax, 0x1050(%rbx)
movl $0x12, 0x1058(%rbx)
movl $0x3f800000, 0x1068(%rbx) # imm = 0x3F800000
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5160
movq %r14, %rdi
callq 0x5420
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %edx, %eax
xorl %edx, %edx
movq 0x4914(%rip), %rbx      # 0xbfa0
movl (%rbx), %ecx
testl %eax, %eax
setne %dl
je 0x76ae
pushq $0x1
popq %rbp
testl %ecx, %ecx
jne 0x76c1
movq (%rdi), %rax
pushq $0x15
popq %rsi
callq *0x40(%rax)
movl %eax, %ecx
sarl $0x1f, %eax
andl %ecx, %eax
jmp 0x76c3
testl %ecx, %ecx
je 0x76cc
movq (%rdi), %rax
pushq $0x15
popq %rsi
callq *0x40(%rax)
testl %eax, %eax
js 0x76c5
xorl %ebp, %ebp
xorl %eax, %eax
movl %ebp, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
jmp 0x76c5
// File: /workspace/github_c_makefile_star2_O2/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 0x77b2
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 0x77b8
leaq 0x1050(%r15), %rax
movq %rax, 0x8(%rsp)
xorl %r12d, %r12d
leaq 0x10(%rsp), %rbp
testl %ebx, %ebx
je 0x77bb
movq %r13, %rdi
movq %rbp, %rsi
callq 0x52c0
testq %rax, %rax
je 0x77bb
movq 0x10(%rsp), %rax
movzwl 0x10(%rax), %ecx
testl %ecx, %ecx
je 0x7774
cmpl $0x4, %ecx
jne 0x77a5
movzwl 0x12(%rax), %ecx
cmpl $0x7, %ecx
je 0x779b
cmpl $0x4, %ecx
jne 0x77a5
movl 0x14(%rax), %eax
shlq $0x20, %rax
movq %rax, 0x10b8(%r15)
jmp 0x77a5
movq 0x10b8(%r15), %rax
movq %rax, 0x1060(%r15)
pushq $0xd
popq %rcx
movq %r14, %rdi
movq 0x8(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
addq $0x68, %r14
decl %ebx
incl %r12d
jmp 0x77a5
movl 0x14(%rax), %eax
orq %rax, 0x10b8(%r15)
movq %r13, %rdi
callq 0x5230
jmp 0x772c
pushq $-0x16
popq %r12
jmp 0x77bb
movq %rax, %r12
movl %r12d, %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_O2/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 0xcbf(%rip), %rdx       # 0x849d
xorl %esi, %esi
callq 0x5060
movq 0x47c4(%rip), %rax      # 0xbfb0
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x1028(%rbx), %rdi
pushq $0x4
popq %rsi
callq 0x5110
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 0x5160
movq %r14, %rdi
callq 0x5420
// File: /workspace/github_c_makefile_star2_O2/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 0x46f0(%rip), %rbx      # 0xbf98
movl (%rbx), %ecx
testl %eax, %eax
setne %dl
je 0x78ca
pushq $0x1
popq %rbp
testl %ecx, %ecx
jne 0x78dd
movq (%rdi), %rax
pushq $0x13
popq %rsi
callq *0x40(%rax)
movl %eax, %ecx
sarl $0x1f, %eax
andl %ecx, %eax
jmp 0x78df
testl %ecx, %ecx
je 0x78e8
movq (%rdi), %rax
pushq $0x13
popq %rsi
callq *0x40(%rax)
testl %eax, %eax
js 0x78e1
xorl %ebp, %ebp
xorl %eax, %eax
movl %ebp, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
jmp 0x78e1
// File: /workspace/github_c_makefile_star2_O2/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 0x7a01
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 0x7a06
leaq 0x1050(%r15), %rax
movq %rax, 0x8(%rsp)
xorl %ebx, %ebx
leaq 0x10(%rsp), %r13
testl %ebp, %ebp
je 0x7a09
movq %r12, %rdi
movq %r13, %rsi
callq 0x52c0
testq %rax, %rax
je 0x7a09
movq 0x10(%rsp), %rax
movzwl 0x10(%rax), %ecx
testl %ecx, %ecx
je 0x79b7
cmpl $0x4, %ecx
jne 0x79db
movzwl 0x12(%rax), %ecx
cmpl $0x7, %ecx
je 0x79f5
cmpl $0x4, %ecx
je 0x79e5
testl %ecx, %ecx
jne 0x79db
movl 0x14(%rax), %eax
movl %eax, 0x10c0(%r15)
jmp 0x79db
movq 0x10b8(%r15), %rax
movq %rax, 0x1060(%r15)
pushq $0xd
popq %rcx
movq %r14, %rdi
movq 0x8(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
addq $0x68, %r14
decl %ebp
incl %ebx
movq %r12, %rdi
callq 0x5230
jmp 0x796b
movl 0x14(%rax), %eax
shlq $0x20, %rax
movq %rax, 0x10b8(%r15)
jmp 0x79db
movl 0x14(%rax), %eax
orq %rax, 0x10b8(%r15)
jmp 0x79db
pushq $-0x16
popq %rbx
jmp 0x7a09
movq %rax, %rbx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
movl %ecx, %r10d
movl %ecx, 0x8(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, 0x20(%rsp)
movq 0x60(%rsp), %rdx
leaq 0x32f8(%rip), %rax      # 0x61f0
pushq $0x1
popq %rbp
movl %r8d, %ecx
shll %cl, %ebp
movq %r9, 0x18(%rsp)
leal -0x1(%r9), %r15d
movl %r8d, 0xc(%rsp)
shll %cl, %r15d
movl 0x4(%rax), %ebx
addl %r10d, %r15d
movq %rdx, 0x10(%rsp)
leaq 0x38(%rdx), %r14
leal (%rbx,%rbp), %esi
movq %r14, %rdi
callq 0x1c5c
cmpl 0x8(%rsp), %ebx
je 0x2fb7
movq (%r14), %rcx
testl %ecx, %ecx
je 0x2f35
movq $0x0, (%r14)
cmpl %r15d, %ebx
je 0x2f4e
leal (%rcx,%r12), %edx
movl %edx, (%rax)
movslq %ecx, %rbx
shlq $0x3, %rbx
xorl %eax, %eax
testl %r12d, %r12d
cmovlel %eax, %r12d
movl 0x8(%rsp), %r14d
cmpl %r15d, %r14d
jg 0x2f92
movq 0x20(%rsp), %rdi
movl %r14d, %esi
callq 0x1c5c
addq %rbx, %rax
xorl %ecx, %ecx
cmpq %rcx, %r12
je 0x2f8d
movq (%r13,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
incq %rcx
jmp 0x2f7a
addl %ebp, %r14d
jmp 0x2f63
movl 0x8(%rsp), %edi
movl 0xc(%rsp), %esi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2fc0
xorl %ecx, %ecx
movl %r12d, %edx
jmp 0x2f4c
nop
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, 0x8(%rsp)
cmpl $0x1, %edi
je 0x130a
leaq 0x20(%rsp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x10(%rax)
andq $0x0, (%rax)
andq $0x0, (%rsp)
xorl %ebp, %ebp
pushq $0x1
popq %r15
leaq 0x2eac(%rip), %r12      # 0x4056
xorl %r13d, %r13d
movq 0x8(%rsp), %rax
movq 0x8(%rax,%rbp,8), %rdi
testq %rdi, %rdi
je 0x122d
pushq $0x20
popq %rsi
callq 0x2ee0
movq %rax, %r14
movq %rax, %rbx
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1220
callq 0x2eb0
testl %eax, %eax
jne 0x11f7
movq (%rbx), %rdi
cmpb $0x2d, (%rdi)
jne 0x131b
incq %rdi
callq 0x2eb0
testl %eax, %eax
je 0x131b
movq (%rbx), %rsi
movq %r13, %rdi
movl %r15d, %edx
callq 0x2e15
movq %rax, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x2e15
movq %rax, %r13
movq %rax, (%rsp)
addq $0x8, %rbx
jmp 0x11ca
movq %r14, %rdi
callq 0x2e7c
incq %rbp
jmp 0x11ad
pushq $0xa
popq %rsi
movq %r13, %rdi
callq 0x2ee0
movq %rax, %r14
movq %rsp, %rdi
callq 0x2e60
movq %r14, %rdi
callq 0x2d28
movslq %eax, %rdx
leaq 0x10(%rsp), %rbx
movq %rdx, 0x18(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c95
cmpq $0xc7, 0x18(%rbx)
ja 0x1278
leaq 0x10(%rsp), %rdi
callq 0x1748
jmp 0x1282
leaq 0x10(%rsp), %rdi
callq 0x1a50
cmpq $0x0, 0x20(%rsp)
je 0x12f8
leaq 0x10(%rsp), %rbx
movq 0x18(%rbx), %rax
movq %rax, 0x20(%rbx)
andq $0x0, 0x28(%rbx)
movq %rbx, %rdi
leaq 0x20(%rsp), %rsi
callq 0x133c
movq 0x10(%rbx), %rdi
movq %rdi, (%rsp)
pushq $0xa
popq %rsi
callq 0x2ee0
testq %rax, %rax
je 0x12e9
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2e60
movq %rbx, %r15
movq (%r15), %rdi
testq %rdi, %rdi
je 0x12df
callq 0x30d4
addq $0x8, %r15
jmp 0x12cc
movq %rbx, %rdi
callq 0x2e7c
jmp 0x12f8
leaq 0x2d14(%rip), %rdi      # 0x4004
pushq $0x2
popq %rsi
callq 0x310c
leaq 0x10(%rsp), %rdi
callq 0x2ac8
movq %r14, %rdi
callq 0x2e7c
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x2e7c
leaq 0x2cda(%rip), %rdi      # 0x4004
pushq $0x2
popq %rsi
callq 0x310c
pushq $0x1
popq %rdi
callq 0x1060
nop
// File: /workspace/github_c_makefile_star2_O2/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 $0x1
popq %rcx
pushq $0x1
popq %rax
cmpq %rsi, %rcx
jae 0x1ddf
cmpl $0x1, %edx
je 0x1dcd
testl %edx, %edx
jne 0x1dd8
movq -0x8(%rdi,%rcx,8), %r8
cmpq (%rdi,%rcx,8), %r8
jge 0x1dd8
jmp 0x1ddd
movq -0x8(%rdi,%rcx,8), %r8
cmpq (%rdi,%rcx,8), %r8
jg 0x1ddd
incq %rcx
jmp 0x1db2
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
xorl %eax, %eax
cmpl $0x1, %esi
sete %al
movq 0x20(%rdi,%rax,8), %r14
jne 0x1e0e
cmpq $0x0, 0x28(%rdi)
je 0x1eea
xorl %eax, %eax
jmp 0x1e19
movq %r14, %rax
testl %ebx, %ebx
je 0x1ed3
movq 0x8(%rdi), %r13
xorl %r12d, %r12d
movq %r14, %rcx
movq %rax, 0x28(%rsp)
movq %rcx, 0x30(%rsp)
leaq (,%r14,8), %rdi
callq 0x1050
testq %rax, %rax
je 0x1ebb
movq %rax, %r15
xorl %eax, %eax
cmpq %rax, %r14
je 0x1e57
movq (%r13,%rax,8), %rcx
movq %rcx, (%r15,%rax,8)
incq %rax
jmp 0x1e44
xorl %ebp, %ebp
testb %r12b, %r12b
movq %r15, %rax
cmovneq %rbp, %rax
cmpl $0x1, %ebx
movq %r15, %rcx
cmoveq %rbp, %rcx
leaq 0x8(%rsp), %r12
movq %rcx, (%r12)
movq %rax, 0x8(%r12)
leaq 0x2197(%rip), %rax      # 0x4019
leaq 0x218c(%rip), %r13      # 0x4015
cmoveq %rax, %r13
cmpq %rbp, %r14
je 0x1eb3
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1dac
testl %eax, %eax
jne 0x1ebf
movq %r12, %rdi
movq %r13, %rsi
callq 0x2986
incq %rbp
jmp 0x1e8d
movq %r15, %rdi
callq 0x1030
xorl %eax, %eax
jmp 0x1eed
movq %r15, %rdi
callq 0x1030
xorl %eax, %eax
cmpq $0x1, %rbp
sbbl %eax, %eax
orl %ebp, %eax
jmp 0x1eed
cmpq $0x0, 0x20(%rdi)
je 0x1eea
movq (%rdi), %r13
movb $0x1, %r12b
xorl %ecx, %ecx
movq %r14, %rax
jmp 0x1e23
pushq $-0x1
popq %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movl %ecx, %r12d
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x1de0
movl %eax, (%r14)
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x1de0
movl %eax, %ebp
movq %r13, (%rsp)
movl %eax, (%r13)
testl %eax, %eax
cmovlel %ebx, %ebp
movl (%r14), %eax
testl %eax, %eax
cmovgl %eax, %ebx
testl %r12d, %r12d
cmovel %r12d, %ebx
cmovel %r12d, %ebp
leaq 0xa33(%rip), %r12       # 0x2986
leaq 0x20c8(%rip), %r13      # 0x4022
testl %ebx, %ebx
jle 0x1f78
testl %ebp, %ebp
jle 0x1f76
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x2158
decl %ebx
decl %ebp
jmp 0x1f5a
decl %ebp
decl %ebx
leaq 0xa05(%rip), %r12       # 0x2986
leaq 0x208d(%rip), %r13      # 0x4015
testl %ebx, %ebx
jle 0x1f9e
decl %ebx
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x2158
jmp 0x1f88
leaq 0x9e1(%rip), %r12       # 0x2986
leaq 0x206d(%rip), %r13      # 0x4019
testl %ebp, %ebp
jle 0x1fc2
decl %ebp
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x2158
jmp 0x1fac
cmpl $0x0, (%r14)
je 0x1fd6
xorl %eax, %eax
movq (%rsp), %rcx
cmpl $0x0, (%rcx)
setne %al
jmp 0x1fd8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r12d
movq %rdi, %r15
movslq %esi, %rbx
leaq (,%rbx,8), %rdi
callq 0x1050
testq %rax, %rax
je 0x2083
movq %rax, %r14
xorl %eax, %eax
testl %r12d, %r12d
cmovlel %eax, %r12d
cmpq %rax, %r12
je 0x2069
movq (%r15,%rax,8), %rcx
movq %rcx, (%r14,%rax,8)
incq %rax
jmp 0x2057
movq %r14, %rdi
movq %rbx, %rsi
callq 0x322a
movq -0x8(%r14,%rbx,8), %rbx
movq %r14, %rdi
callq 0x1030
jmp 0x2088
movq -0x8(%r15,%rbx,8), %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1050
testq %rax, %rax
je 0x20fe
movq %rax, %rbx
xorl %eax, %eax
testl %r14d, %r14d
movl $0x0, %ecx
cmovgl %r14d, %ecx
cmpq %rax, %rcx
je 0x20dc
movq (%r12,%rax,8), %rdx
movq %rdx, (%rbx,%rax,8)
incq %rax
jmp 0x20ca
movq %rbx, %rdi
movq %r15, %rsi
callq 0x322a
cmpl $0x12c, %r14d           # imm = 0x12C
jl 0x2105
movl %r14d, %eax
shrl $0x2, %eax
imull $-0x3, %eax, %eax
addl %r14d, %eax
jmp 0x212c
movq -0x8(%r12,%r15,8), %r14
jmp 0x2149
cmpl $0xc, %r14d
jl 0x2123
movw $0x3, %cx
movl %r14d, %eax
xorl %edx, %edx
divw %cx
addl %eax, %eax
movzwl %ax, %ecx
movl %r14d, %eax
subl %ecx, %eax
jmp 0x212c
pushq $0x2
popq %rcx
movl %r14d, %eax
cltd
idivl %ecx
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_O2/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 0x1e74(%rip), %rsi      # 0x4028
callq 0x2d3c
testl %eax, %eax
je 0x21d1
movq 0x8(%rbx), %rdi
leaq 0x1e60(%rip), %rsi      # 0x4028
callq 0x2d3c
testl %eax, %eax
jne 0x21f8
movq (%rbx), %rdi
leaq 0x1e50(%rip), %rsi      # 0x402b
callq 0x2d3c
testl %eax, %eax
je 0x220b
movq 0x8(%rbx), %rdi
leaq 0x1e3c(%rip), %rsi      # 0x402b
callq 0x2d3c
testl %eax, %eax
je 0x220b
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x22a2
movq (%rbx), %rdi
leaq 0x1e00(%rip), %rsi      # 0x4015
callq 0x2d3c
testl %eax, %eax
jne 0x2231
movq (%rbx), %rdi
leaq 0x1dec(%rip), %rsi      # 0x4014
callq 0x2d3c
testl %eax, %eax
je 0x224e
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x2d3c
testl %eax, %eax
je 0x224e
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
jmp 0x2290
movq (%rbx), %rdi
leaq 0x1dc1(%rip), %rsi      # 0x4019
callq 0x2d3c
testl %eax, %eax
jne 0x2274
movq (%rbx), %rdi
leaq 0x1dad(%rip), %rsi      # 0x4018
callq 0x2d3c
testl %eax, %eax
je 0x229a
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x2d3c
testl %eax, %eax
je 0x229a
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2375
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r12
movq %rsi, %r14
movq %rdi, %r15
pushq $-0x1
popq %rbx
leaq 0x1d68(%rip), %r13      # 0x4028
movq 0x8(%r12,%rbx,8), %rdi
movq %r13, %rsi
callq 0x2d3c
incq %rbx
testl %eax, %eax
jne 0x22c0
leaq 0x1d50(%rip), %r13      # 0x402b
movl %ebx, %ebp
movq (%r12,%rbx,8), %rdi
movq %r13, %rsi
callq 0x2d3c
testl %eax, %eax
je 0x22f4
incq %rbx
decl %ebp
jmp 0x22dd
leaq 0x1d59(%rip), %r12      # 0x4054
pushq $0x1
popq %r13
testl %ebp, %ebp
jle 0x232c
movq (%r14), %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x2e15
movq %rax, (%r14)
decl %ebp
movdqu 0x20(%r15), %xmm0
paddq 0x1d1c(%rip), %xmm0     # 0x4040
movdqu %xmm0, 0x20(%r15)
jmp 0x22ff
leaq 0x1d1d(%rip), %r12      # 0x4050
pushq $0x1
popq %r13
testl %ebp, %ebp
jns 0x2364
movq (%r14), %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x2e15
movq %rax, (%r14)
incl %ebp
movdqu 0x20(%r15), %xmm0
paddq 0x1cd4(%rip), %xmm0     # 0x4030
movdqu %xmm0, 0x20(%r15)
jmp 0x2337
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2d3c
testl %eax, %eax
jne 0x2391
leaq -0x1(%r12), %rsi
testl %ebx, %ebx
je 0x23b5
movl 0x28(%rbp), %ecx
jmp 0x23b8
movl 0x20(%rbp), %ecx
pushq $0x2
popq %rdi
movl %ecx, %eax
cltd
idivl %edi
movl %r12d, %r13d
cmpl %esi, %eax
jg 0x23ca
subl %ecx, %r13d
movl %r13d, 0x4(%rsp)
testl %r13d, %r13d
jns 0x242f
movq (%r14), %rbp
movq %r15, %rdi
testl %ebx, %ebx
je 0x23fe
leaq 0x1c34(%rip), %rsi      # 0x4019
callq 0x2d3c
leaq 0x1c68(%rip), %rsi      # 0x4059
testl %eax, %eax
je 0x241c
leaq 0x1c5c(%rip), %rsi      # 0x4058
jmp 0x241c
leaq 0x1c10(%rip), %rsi      # 0x4015
callq 0x2d3c
leaq 0x1c4d(%rip), %rsi      # 0x405e
testl %eax, %eax
je 0x241c
leaq 0x1c41(%rip), %rsi      # 0x405d
movq %rbp, %rdi
pushq $0x1
popq %rdx
callq 0x2e15
movq %rax, (%r14)
incl %r13d
jmp 0x23cf
movl 0x4(%rsp), %eax
sarl $0x1f, %eax
andl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
pushq $0x1
popq %r8
xorl %r9d, %r9d
cmpq %r9, %rsi
je 0x2472
movq (%rdi,%r9,8), %r10
testl %ecx, %ecx
je 0x2465
cmpq %rdx, %r10
jl 0x246a
jmp 0x246f
cmpq %rdx, %r10
jl 0x246f
incq %r9
jmp 0x2451
movl %r8d, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x248f
movq %rdi, %rbx
movq (%rdi), %rdi
xorl %edx, %edx
callq 0x1dac
testl %eax, %eax
je 0x2491
popq %rbx
retq
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
cmpq $0x2, %rsi
jne 0x24ac
movq 0x8(%rdi), %rax
cmpq (%rdi), %rax
jle 0x248f
jmp 0x257a
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x1fe8
testl %eax, %eax
je 0x24d3
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
movq -0x10(%rdi,%rsi,8), %rdx
callq 0x2008
testl %eax, %eax
je 0x258a
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x1fe8
testl %eax, %eax
je 0x2510
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
movq -0x10(%rdi,%rsi,8), %rdx
callq 0x2008
testl %eax, %eax
je 0x2510
leaq 0x482(%rip), %rdi       # 0x2986
leaq 0x1b0a(%rip), %rdx      # 0x4015
jmp 0x25ae
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x2008
testl %eax, %eax
je 0x2552
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
movq -0x10(%rdi,%rsi,8), %rdx
callq 0x1fe8
testl %eax, %eax
je 0x2552
leaq 0x445(%rip), %rdi       # 0x2986
leaq 0x1acc(%rip), %rdx      # 0x4014
movq %rbx, %rsi
callq 0x2158
jmp 0x257a
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x2008
testl %eax, %eax
jne 0x25a0
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
movq (%rdi), %rdx
callq 0x1fe8
testl %eax, %eax
je 0x25a0
leaq 0x2cf(%rip), %rdi       # 0x2850
leaq 0x1a82(%rip), %rdx      # 0x400a
jmp 0x25ae
leaq 0x2bf(%rip), %rdi       # 0x2850
leaq 0x1a72(%rip), %rdx      # 0x400a
movq %rbx, %rsi
callq 0x2158
leaq 0x3df(%rip), %rdi       # 0x2986
leaq 0x1a66(%rip), %rdx      # 0x4014
movq %rbx, %rsi
popq %rbx
jmp 0x2158
// File: /workspace/github_c_makefile_star2_O2/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 0x25d5
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
pushq $0x1
popq %rdx
callq 0x1dac
testl %eax, %eax
je 0x25d7
popq %rbx
retq
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
cmpq $0x2, %rsi
jne 0x25f3
movq 0x8(%rdi), %rax
cmpq (%rdi), %rax
jge 0x25d5
jmp 0x26c8
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x2008
testl %eax, %eax
je 0x261b
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq -0x10(%rdi,%rsi,8), %rdx
callq 0x1fe8
testl %eax, %eax
je 0x26d8
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x2008
testl %eax, %eax
je 0x265a
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq -0x10(%rdi,%rsi,8), %rdx
callq 0x1fe8
testl %eax, %eax
je 0x265a
leaq 0x338(%rip), %rdi       # 0x2986
leaq 0x19c4(%rip), %rdx      # 0x4019
jmp 0x26fc
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x1fe8
testl %eax, %eax
je 0x269e
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq -0x10(%rdi,%rsi,8), %rdx
callq 0x2008
testl %eax, %eax
je 0x269e
leaq 0x2f9(%rip), %rdi       # 0x2986
leaq 0x1984(%rip), %rdx      # 0x4018
movq %rbx, %rsi
callq 0x2158
jmp 0x26c8
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x1fe8
testl %eax, %eax
jne 0x26ee
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq (%rdi), %rdx
callq 0x2008
testl %eax, %eax
je 0x26ee
leaq 0x181(%rip), %rdi       # 0x2850
leaq 0x1937(%rip), %rdx      # 0x400d
jmp 0x26fc
leaq 0x171(%rip), %rdi       # 0x2850
leaq 0x1927(%rip), %rdx      # 0x400d
movq %rbx, %rsi
callq 0x2158
leaq 0x291(%rip), %rdi       # 0x2986
leaq 0x191c(%rip), %rdx      # 0x4018
movq %rbx, %rsi
popq %rbx
jmp 0x2158
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
je 0x3229
pushq %rbp
pushq %r14
pushq %rbx
movabsq $0x1, %rax
xorl %ecx, %ecx
movq %rdi, %rdx
movq %rax, %r8
xorl %r9d, %r9d
incq %r9
cmpq %rsi, %r9
jae 0x3225
movq %rcx, %r10
xorl %r11d, %r11d
cmpq %r8, %r11
je 0x3219
movl (%rdi,%r9,4), %ebx
cmpl (%rdi,%r11,4), %ebx
jge 0x3211
movq %rax, %r14
cmpq %r14, %r10
je 0x320d
movl -0x4(%rdx,%r14,4), %ebp
movl %ebp, (%rdx,%r14,4)
decq %r14
jmp 0x31fa
movl %ebx, (%rdi,%r11,4)
incq %r11
incq %r10
jmp 0x31e8
incq %r8
addq $0x4, %rdx
decq %rcx
jmp 0x31da
popq %rbx
popq %r14
popq %rbp
retq