LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu.c
// Function: mpu_get_gyro_reg(short*)
uint8_t mpu_get_gyro_reg(int16_t *data)
{
	uint8_t tmp[6];

	if (!(st.chip_cfg.sensors & INV_XYZ_GYRO))
		return 1;

	if (i2c_read(st.hw->addr, st.reg->raw_gyro, 6, tmp))
		return 1;
	data[0] = (tmp[0] << 8) | tmp[1];
	data[1] = (tmp[2] << 8) | tmp[3];
	data[2] = (tmp[4] << 8) | tmp[5];
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movb $0x1, %bpl
testb $0x70, 0x7c8d(%rip)     # 0xa232
je 0x25fa
movq %rdi, %rbx
movq 0x7c6f(%rip), %rax      # 0xa220
movzbl (%rax), %edi
movq 0x7c5d(%rip), %rax      # 0xa218
movzbl 0xe(%rax), %esi
leaq 0x2(%rsp), %rcx
movl $0x6, %edx
callq 0x4e41
cmpb $-0x1, %al
je 0x25fa
movzwl 0x2(%rsp), %eax
rolw $0x8, %ax
movw %ax, (%rbx)
movzwl 0x4(%rsp), %eax
rolw $0x8, %ax
movw %ax, 0x2(%rbx)
movzwl 0x6(%rsp), %eax
rolw $0x8, %ax
movw %ax, 0x4(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu.c
// Function: mpu_get_accel_reg(short*)
uint8_t mpu_get_accel_reg(int16_t *data)
{
	uint8_t tmp[6];

	if (!(st.chip_cfg.sensors & INV_XYZ_ACCEL))
		return 1;

	if (i2c_read(st.hw->addr, st.reg->raw_accel, 6, tmp))
		return 1;
	data[0] = (tmp[0] << 8) | tmp[1];
	data[1] = (tmp[2] << 8) | tmp[3];
	data[2] = (tmp[4] << 8) | tmp[5];
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movb $0x1, %bpl
testb $0x8, 0x7c22(%rip)      # 0xa232
je 0x2665
movq %rdi, %rbx
movq 0x7c04(%rip), %rax      # 0xa220
movzbl (%rax), %edi
movq 0x7bf2(%rip), %rax      # 0xa218
movzbl 0xf(%rax), %esi
leaq 0x2(%rsp), %rcx
movl $0x6, %edx
callq 0x4e41
cmpb $-0x1, %al
je 0x2665
movzwl 0x2(%rsp), %eax
rolw $0x8, %ax
movw %ax, (%rbx)
movzwl 0x4(%rsp), %eax
rolw $0x8, %ax
movw %ax, 0x2(%rbx)
movzwl 0x6(%rsp), %eax
rolw $0x8, %ax
movw %ax, 0x4(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu.c
// Function: mpu_get_temperature(int*)
uint8_t mpu_get_temperature(int32_t *data)
{
	uint8_t tmp[2];
	int16_t raw;

	if (!(st.chip_cfg.sensors))
		return 1;

	if (i2c_read(st.hw->addr, st.reg->temp, 2, tmp))
		return 1;
	raw = (tmp[0] << 8) | tmp[1];

	data[0] = (int32_t)((35 + ((raw - (float)st.hw->temp_offset) / st.hw->temp_sens)) * 65536L);
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movb $0x1, %bpl
cmpb $0x0, 0x7bb7(%rip)      # 0xa232
je 0x26f0
movq %rdi, %rbx
movq 0x7b99(%rip), %rax      # 0xa220
movzbl (%rax), %edi
movq 0x7b87(%rip), %rax      # 0xa218
movzbl 0x10(%rax), %esi
leaq 0x6(%rsp), %rcx
movl $0x2, %edx
callq 0x4e41
cmpb $-0x1, %al
je 0x26f0
movzwl 0x6(%rsp), %eax
rolw $0x8, %ax
cwtl
cvtsi2ss %eax, %xmm0
movq 0x7b63(%rip), %rax      # 0xa220
movswl 0x8(%rax), %ecx
cvtsi2ss %ecx, %xmm1
subss %xmm1, %xmm0
movzwl 0x6(%rax), %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
addss 0x3e1c(%rip), %xmm0     # 0x64fc
mulss 0x3e18(%rip), %xmm0     # 0x6500
cvttss2si %xmm0, %eax
movl %eax, (%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu.c
// Function: mpu_set_accel_bias(int const*)
uint8_t mpu_set_accel_bias(const int32_t *accel_bias)
{
	uint8_t data[6];
	int16_t accel_hw[3];
	int16_t got_accel[3];
	int16_t fg[3];

	if (!accel_bias)
		return 1;
	if (!accel_bias[0] && !accel_bias[1] && !accel_bias[2])
		return 0;

	if (i2c_read(st.hw->addr, 3, 3, data))
		return 1;
	fg[0] = ((data[0] >> 4) + 8) & 0xf;
	fg[1] = ((data[1] >> 4) + 8) & 0xf;
	fg[2] = ((data[2] >> 4) + 8) & 0xf;

	accel_hw[0] = (int16_t)(accel_bias[0] * 2 / (64 + fg[0]));
	accel_hw[1] = (int16_t)(accel_bias[1] * 2 / (64 + fg[1]));
	accel_hw[2] = (int16_t)(accel_bias[2] * 2 / (64 + fg[2]));

	if (i2c_read(st.hw->addr, 0x06, 6, data))
		return 1;

	got_accel[0] = ((int16_t)data[0] << 8) | data[1];
	got_accel[1] = ((int16_t)data[2] << 8) | data[3];
	got_accel[2] = ((int16_t)data[4] << 8) | data[5];

	accel_hw[0] += got_accel[0];
	accel_hw[1] += got_accel[1];
	accel_hw[2] += got_accel[2];

	data[0] = (accel_hw[0] >> 8) & 0xff;
	data[1] = (accel_hw[0]) & 0xff;
	data[2] = (accel_hw[1] >> 8) & 0xff;
	data[3] = (accel_hw[1]) & 0xff;
	data[4] = (accel_hw[2] >> 8) & 0xff;
	data[5] = (accel_hw[2]) & 0xff;

	if (i2c_write(st.hw->addr, 0x06, 6, data))
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movb $0x1, %bl
testq %rdi, %rdi
je 0x2830
movq %rdi, %r14
cmpl $0x0, (%rdi)
jne 0x272c
cmpl $0x0, 0x4(%r14)
jne 0x272c
cmpl $0x0, 0x8(%r14)
je 0x2841
movq 0x7aed(%rip), %rax      # 0xa220
movzbl (%rax), %edi
leaq 0xe(%rsp), %rcx
movl $0x3, %esi
movl $0x3, %edx
callq 0x4e41
cmpb $-0x1, %al
je 0x2830
leaq 0xe(%rsp), %rcx
movzbl (%rcx), %r12d
movzbl 0x1(%rcx), %r13d
movzbl 0x2(%rcx), %ebp
movl (%r14), %eax
movl %eax, 0x14(%rsp)
movl 0x4(%r14), %r15d
movl 0x8(%r14), %r14d
movq 0x7aa6(%rip), %rax      # 0xa220
movzbl (%rax), %edi
movl $0x6, %esi
movl $0x6, %edx
callq 0x4e41
cmpb $-0x1, %al
je 0x2830
addl %r14d, %r14d
shrl $0x4, %ebp
xorl $0x48, %ebp
movl %r14d, %eax
cltd
idivl %ebp
movl %eax, %esi
addl %r15d, %r15d
shrl $0x4, %r13d
xorl $0x48, %r13d
movl %r15d, %eax
cltd
idivl %r13d
movl %eax, %edi
movl 0x14(%rsp), %eax
addl %eax, %eax
shrl $0x4, %r12d
xorl $0x48, %r12d
cltd
idivl %r12d
movl %eax, %r8d
leaq 0xe(%rsp), %rcx
movzwl (%rcx), %eax
movzwl 0x2(%rcx), %edx
rolw $0x8, %ax
movzwl %ax, %eax
rolw $0x8, %dx
movzwl %dx, %edx
movzwl 0x4(%rcx), %r9d
rolw $0x8, %r9w
movzwl %r9w, %ebx
addl %r8d, %eax
addl %edi, %edx
addl %esi, %ebx
movb %ah, 0xe(%rsp)
movb %al, 0x1(%rcx)
movb %dh, 0x10(%rsp)
movb %dl, 0x3(%rcx)
movb %bh, 0x12(%rsp)
movb %bl, 0x5(%rcx)
movq 0x7a07(%rip), %rax      # 0xa220
movzbl (%rax), %edi
movl $0x6, %esi
movl $0x6, %edx
callq 0x50a2
testl %eax, %eax
setne %bl
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebx, %ebx
jmp 0x2830
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu.c
// Function: set_int_enable(unsigned char)
static int set_int_enable(uint8_t enable)
{
	uint8_t tmp;

	if (st.chip_cfg.dmp_on)
	{
		if (enable)
			tmp = BIT_DMP_INT_EN;
		else
			tmp = 0x00;
		if (i2c_write(st.hw->addr, st.reg->int_enable, 1, &tmp))
			return 1;
		st.chip_cfg.int_enable = tmp;
	}
	else
	{
		if (!st.chip_cfg.sensors)
			return 1;
		if (enable && st.chip_cfg.int_enable)
			return 0;
		if (enable)
			tmp = BIT_DATA_RDY_EN;
		else
			tmp = 0x00;
		if (i2c_write(st.hw->addr, st.reg->int_enable, 1, &tmp))
			return 1;
		st.chip_cfg.int_enable = tmp;
	}
	return 0;
}

// Assembly:
pushq %rax
cmpb $0x0, 0x7691(%rip)      # 0xa24c
je 0x2bfb
testb %dil, %dil
setne %al
addb %al, %al
leaq 0x7(%rsp), %rcx
movb %al, (%rcx)
movq 0x764d(%rip), %rax      # 0xa220
movzbl (%rax), %edi
movq 0x763b(%rip), %rax      # 0xa218
movzbl 0x11(%rax), %esi
movl $0x1, %edx
callq 0x50a2
testl %eax, %eax
jne 0x2c12
movb 0x7(%rsp), %al
movb %al, 0x7640(%rip)       # 0xa239
jmp 0x2c12
cmpb $0x0, 0x7630(%rip)      # 0xa232
je 0x2c12
testb %dil, %dil
je 0x2c14
cmpb $0x0, 0x7629(%rip)      # 0xa239
je 0x2c14
popq %rax
retq
testb %dil, %dil
leaq 0x7(%rsp), %rcx
setne (%rcx)
jmp 0x2bcc
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu.c
// Function: mpu_read_fifo_stream(unsigned short, unsigned char*, unsigned char*)
uint8_t mpu_read_fifo_stream(uint16_t length, uint8_t *data,
														 uint8_t *more)
{
	uint8_t tmp[2];
	uint16_t fifo_count;
	if (!st.chip_cfg.dmp_on)
    {
		return 1;
    }
	if (!st.chip_cfg.sensors)
    {
		return 1;
    }

	if (i2c_read(st.hw->addr, st.reg->fifo_count_h, 2, tmp))
		return 1;
	fifo_count = (tmp[0] << 8) | tmp[1];
	if (fifo_count < length)
	{
		more[0] = 0;
		return 1;
	}
	if (fifo_count > (st.hw->max_fifo >> 1))
	{
		/* FIFO is 50% full, better check overflow bit. */
		if (i2c_read(st.hw->addr, st.reg->int_status, 1, tmp))
			return 1;
		if (tmp[0] & BIT_FIFO_OVERFLOW)
		{
			mpu_reset_fifo();
			return 2;
		}
	}
#if defined MPU_DEBUG
    printf_P("FIFO count: %hd\r\n", fifo_count);
#endif

	if (i2c_read(st.hw->addr, st.reg->fifo_r_w, length, data))
		return 1;
	more[0] = fifo_count / length - 1;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpb $0x0, 0x7389(%rip)      # 0xa24c
movb $0x1, %bl
je 0x2f9e
cmpb $0x0, 0x7360(%rip)      # 0xa232
je 0x2f9e
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
movq 0x7339(%rip), %rax      # 0xa220
movzbl (%rax), %edi
movq 0x7327(%rip), %rax      # 0xa218
movzbl 0xc(%rax), %esi
leaq 0xe(%rsp), %rcx
movl $0x2, %edx
callq 0x4e41
cmpb $-0x1, %al
je 0x2f9e
movzwl 0xe(%rsp), %r12d
rolw $0x8, %r12w
movzwl %r12w, %ecx
movzwl %bp, %eax
cmpl %eax, %ecx
jae 0x2f28
movb $0x0, (%r14)
jmp 0x2f9e
movq 0x72f1(%rip), %rax      # 0xa220
movzwl 0x2(%rax), %edx
shrl %edx
cmpl %edx, %ecx
jbe 0x2f68
movzbl (%rax), %edi
movq 0x72d5(%rip), %rax      # 0xa218
movzbl 0x13(%rax), %esi
leaq 0xe(%rsp), %rcx
movl $0x1, %edx
callq 0x4e41
cmpb $-0x1, %al
je 0x2f9e
testb $0x10, 0xe(%rsp)
jne 0x2f97
movq 0x72b8(%rip), %rax      # 0xa220
movzbl (%rax), %edi
movq 0x72a6(%rip), %rax      # 0xa218
movzbl 0xd(%rax), %esi
movzbl %bpl, %edx
movq %r15, %rcx
callq 0x4e41
cmpb $-0x1, %al
je 0x2f9e
xorl %ebx, %ebx
movl %r12d, %eax
xorl %edx, %edx
divw %bp
decb %al
movb %al, (%r14)
jmp 0x2f9e
callq 0x2845
movb $0x2, %bl
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu.c
// Function: mpu_set_dmp_state(unsigned char)
uint8_t mpu_set_dmp_state(uint8_t enable)
{
	uint8_t tmp;
	if (st.chip_cfg.dmp_on == enable)
		return 0;

	if (enable)
	{
		if (!st.chip_cfg.dmp_loaded)
			return 1;
		/* Disable data ready interrupt. */
		set_int_enable(0);
		/* Disable bypass mode. */
		mpu_set_bypass(0);
		/* Keep constant sample rate, FIFO rate controlled by DMP. */
		mpu_set_sample_rate(st.chip_cfg.dmp_sample_rate);
		/* Remove FIFO elements. */
		tmp = 0;
		i2c_write(st.hw->addr, 0x23, 1, &tmp);
		st.chip_cfg.dmp_on = 1;
		/* Enable DMP interrupt. */
		set_int_enable(1);
		mpu_reset_fifo();
	}
	else
	{
		/* Disable DMP interrupt. */
		set_int_enable(0);
		/* Restore FIFO settings. */
		tmp = st.chip_cfg.fifo_enable;
		i2c_write(st.hw->addr, 0x23, 1, &tmp);
		st.chip_cfg.dmp_on = 0;
		mpu_reset_fifo();
	}
	return 0;
}

// Assembly:
pushq %rax
cmpb %dil, 0x6eb0(%rip)      # 0xa24c
je 0x343b
testb %dil, %dil
je 0x3402
cmpb $0x0, 0x6e9f(%rip)      # 0xa24d
je 0x343f
xorl %edi, %edi
callq 0x2bb3
xorl %edi, %edi
callq 0x21f0
movzwl 0x6e85(%rip), %edi      # 0xa24e
callq 0x20b0
leaq 0x7(%rsp), %rcx
movb $0x0, (%rcx)
movq 0x6e43(%rip), %rax      # 0xa220
movzbl (%rax), %edi
movl $0x23, %esi
movl $0x1, %edx
callq 0x50a2
movb $0x1, 0x6e56(%rip)      # 0xa24c
movl $0x1, %edi
callq 0x2bb3
jmp 0x3436
xorl %edi, %edi
callq 0x2bb3
movb 0x6e29(%rip), %al       # 0xa238
leaq 0x7(%rsp), %rcx
movb %al, (%rcx)
movq 0x6e03(%rip), %rax      # 0xa220
movzbl (%rax), %edi
movl $0x23, %esi
movl $0x1, %edx
callq 0x50a2
movb $0x0, 0x6e16(%rip)      # 0xa24c
callq 0x2845
xorl %eax, %eax
popq %rcx
retq
movb $0x1, %al
jmp 0x343d
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu.c
// Function: mpu_write_mem(unsigned short, unsigned short, unsigned char*)
uint8_t mpu_write_mem(uint16_t mem_addr, uint16_t length,
											uint8_t *data)
{
	uint8_t tmp[2];

	if (!data)
		return 1;
	if (!st.chip_cfg.sensors)
		return 1;

	tmp[0] = (uint8_t)(mem_addr >> 8);
	tmp[1] = (uint8_t)(mem_addr & 0xFF);

	/* Check bank boundaries. */
	if (tmp[1] + length > st.hw->bank_size)
		return 1;

	if (i2c_write(st.hw->addr, st.reg->bank_sel, 2, tmp))
		return 1;
	if (i2c_write(st.hw->addr, st.reg->mem_r_w, length, data))
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movb $0x1, %bpl
testq %rdx, %rdx
je 0x3a20
cmpb $0x0, 0x6886(%rip)      # 0xa232
je 0x3a20
movq %rdx, %rbx
movl %esi, %r14d
movl %edi, %eax
rolw $0x8, %ax
movw %ax, 0xe(%rsp)
movzbl %dil, %eax
movzwl %r14w, %ecx
addl %eax, %ecx
movq 0x6850(%rip), %rax      # 0xa220
movzwl 0xa(%rax), %edx
cmpl %edx, %ecx
ja 0x3a20
movzbl (%rax), %edi
movq 0x6836(%rip), %rax      # 0xa218
movzbl 0x1b(%rax), %esi
leaq 0xe(%rsp), %rcx
movl $0x2, %edx
callq 0x50a2
testl %eax, %eax
jne 0x3a20
movq 0x6820(%rip), %rax      # 0xa220
movzbl (%rax), %edi
movq 0x680e(%rip), %rax      # 0xa218
movzbl 0x18(%rax), %esi
movzbl %r14b, %edx
movq %rbx, %rcx
callq 0x50a2
testl %eax, %eax
setne %bpl
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu.c
// Function: mpu_load_firmware(unsigned short, unsigned char const*, unsigned short, unsigned short)
uint8_t mpu_load_firmware(uint16_t length, const uint8_t *firmware,
													uint16_t start_addr, uint16_t sample_rate)
{
	uint16_t ii;
	uint16_t this_write;
	uint8_t *pgm_buf;
	uint8_t jj;
	/* Must divide evenly into st.hw->bank_size to avoid bank crossings. */
#define LOAD_CHUNK  (16)
	uint8_t cur[LOAD_CHUNK], tmp[2];
	pgm_buf = (uint8_t *)malloc(LOAD_CHUNK);

	if (st.chip_cfg.dmp_loaded)
		/* DMP should only be loaded once. */
		return 1;

	if (!firmware)
		return 1;
	for (ii = 0; ii < length; ii += this_write)
	{
		this_write = min(LOAD_CHUNK, length - ii);		
		for (jj = 0; jj < LOAD_CHUNK; jj++) pgm_buf[jj] = firmware[ii+jj];//pgm_read_byte(firmware + ii + jj);
		if (mpu_write_mem(ii, this_write, pgm_buf))
			return 1;
		if (mpu_read_mem(ii, this_write, cur))
			return 1;
		if (memcmp(pgm_buf, cur, this_write))
			return 2;
	}

	/* Set program start address. */
	tmp[0] = start_addr >> 8;
	tmp[1] = start_addr & 0xFF;
	if (i2c_write(st.hw->addr, st.reg->prgm_start_h, 2, tmp))
		return 1;

	st.chip_cfg.dmp_loaded = 1;
	st.chip_cfg.dmp_sample_rate = sample_rate;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movl %edi, 0x4(%rsp)
movl $0x10, %edi
callq 0x10b0
movq %rax, %r13
movb $0x1, %al
movq %r14, 0x18(%rsp)
testq %r14, %r14
je 0x3bea
cmpb $0x0, 0x674f(%rip)      # 0xa24d
jne 0x3bea
movl %ebp, 0xc(%rsp)
movl %ebx, 0x8(%rsp)
cmpw $0x0, 0x4(%rsp)
je 0x3b99
movzwl 0x4(%rsp), %eax
movl %eax, 0x10(%rsp)
xorl %eax, %eax
leaq 0x20(%rsp), %r15
xorl %ebp, %ebp
movl 0x10(%rsp), %r12d
subl %eax, %r12d
cmpl $0x10, %r12d
movl $0x10, %ecx
cmovgel %ecx, %r12d
movl %eax, %eax
movq 0x18(%rsp), %rcx
movups (%rcx,%rax), %xmm0
movups %xmm0, (%r13)
movzwl %r12w, %ebx
movzwl %bp, %r14d
movl %r14d, %edi
movl %ebx, %esi
movq %r13, %rdx
callq 0x3995
testb %al, %al
jne 0x3be4
movl %r14d, %edi
movl %ebx, %esi
movq %r15, %rdx
callq 0x3a2b
testb %al, %al
jne 0x3be4
movzwl %r12w, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x10a0
testl %eax, %eax
jne 0x3be8
addl %r12d, %ebp
movzwl %bp, %eax
cmpw 0x4(%rsp), %ax
jb 0x3b2a
movl 0xc(%rsp), %eax
rolw $0x8, %ax
leaq 0x16(%rsp), %rcx
movw %ax, (%rcx)
movq 0x6670(%rip), %rax      # 0xa220
movzbl (%rax), %edi
movq 0x665e(%rip), %rax      # 0xa218
movzbl 0x1d(%rax), %esi
movl $0x2, %edx
callq 0x50a2
testl %eax, %eax
movb $0x1, %al
jne 0x3bea
movb $0x1, 0x6678(%rip)      # 0xa24d
movl 0x8(%rsp), %eax
movw %ax, 0x666e(%rip)       # 0xa24e
xorl %eax, %eax
jmp 0x3bea
movb $0x1, %al
jmp 0x3bea
movb $0x2, %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu_dmp_motion_driver.c
// Function: dmp_set_orientation(unsigned short)
uint8_t dmp_set_orientation(uint16_t orient)
{
	uint8_t gyro_regs[3], accel_regs[3];
	const uint8_t gyro_axes[3] = {DINA4C, DINACD, DINA6C};
	const uint8_t accel_axes[3] = {DINA0C, DINAC9, DINA2C};
	const uint8_t gyro_sign[3] = {DINA36, DINA56, DINA76};
	const uint8_t accel_sign[3] = {DINA26, DINA46, DINA66};

	gyro_regs[0] = gyro_axes[orient & 3];
	gyro_regs[1] = gyro_axes[(orient >> 3) & 3];
	gyro_regs[2] = gyro_axes[(orient >> 6) & 3];
	accel_regs[0] = accel_axes[orient & 3];
	accel_regs[1] = accel_axes[(orient >> 3) & 3];
	accel_regs[2] = accel_axes[(orient >> 6) & 3];

	/* Chip-to-body, axes only. */
	if (mpu_write_mem(FCFG_1, 3, gyro_regs))
		return 1;
	if (mpu_write_mem(FCFG_2, 3, accel_regs))
		return 1;

	memcpy(gyro_regs, gyro_sign, 3);
	memcpy(accel_regs, accel_sign, 3);
	if (orient & 4)
	{
		gyro_regs[0] |= 1;
		accel_regs[0] |= 1;
	}
	if (orient & 0x20)
	{
		gyro_regs[1] |= 1;
		accel_regs[1] |= 1;
	}
	if (orient & 0x100)
	{
		gyro_regs[2] |= 1;
		accel_regs[2] |= 1;
	}

	/* Chip-to-body, sign only. */
	if (mpu_write_mem(FCFG_3, 3, gyro_regs))
		return 1;
	if (mpu_write_mem(FCFG_7, 3, accel_regs))
		return 1;
	dmp.orient = orient;
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl %edi, %eax
andl $0x3, %eax
leaq 0x322d(%rip), %rcx      # 0x71a6
movb (%rax,%rcx), %sil
leaq 0x4(%rsp), %rdx
movb %sil, (%rdx)
movl %edi, %esi
shrl $0x3, %esi
andl $0x3, %esi
movb (%rsi,%rcx), %dil
movb %dil, 0x1(%rdx)
movl %ebx, %edi
shrl $0x6, %edi
andl $0x3, %edi
movb (%rdi,%rcx), %cl
movb %cl, 0x2(%rdx)
leaq 0x31ff(%rip), %rcx      # 0x71a9
movb (%rax,%rcx), %al
movb %al, (%rsp)
movb (%rsi,%rcx), %al
movb %al, 0x1(%rsp)
movb (%rdi,%rcx), %al
movb %al, 0x2(%rsp)
movl $0x426, %edi            # imm = 0x426
movl $0x3, %esi
callq 0x3995
movb $0x1, %bpl
testb %al, %al
jne 0x4069
movq %rsp, %rdx
movl $0x42a, %edi            # imm = 0x42A
movl $0x3, %esi
callq 0x3995
testb %al, %al
jne 0x4069
movb $0x76, 0x6(%rsp)
movw $0x5636, 0x4(%rsp)      # imm = 0x5636
movw $0x4626, (%rsp)         # imm = 0x4626
movb $0x66, 0x2(%rsp)
testb $0x4, %bl
je 0x4013
movb $0x37, 0x4(%rsp)
movb $0x27, (%rsp)
testb $0x20, %bl
je 0x4022
movb $0x57, 0x5(%rsp)
movb $0x47, 0x1(%rsp)
btl $0x8, %ebx
jae 0x4032
movb $0x77, 0x6(%rsp)
movb $0x67, 0x2(%rsp)
leaq 0x4(%rsp), %rdx
movl $0x440, %edi            # imm = 0x440
movl $0x3, %esi
callq 0x3995
testb %al, %al
jne 0x4069
movq %rsp, %rdx
movl $0x431, %edi            # imm = 0x431
movl $0x3, %esi
callq 0x3995
testb %al, %al
jne 0x4069
movw %bx, 0x61f9(%rip)       # 0xa260
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu_dmp_motion_driver.c
// Function: dmp_set_fifo_rate(unsigned short)
uint8_t dmp_set_fifo_rate(uint16_t rate)
{
	const uint8_t regs_end[12] = {DINAFE, DINAF2, DINAAB,
																0xc4, DINAAA, DINAF1, DINADF, DINADF, 0xBB, 0xAF, DINADF, DINADF
															 };
	uint16_t div;
	uint8_t tmp[8];

	if (rate > DMP_SAMPLE_RATE)
		return 1;
	div = DMP_SAMPLE_RATE / rate - 1;
	tmp[0] = (uint8_t)((div >> 8) & 0xFF);
	tmp[1] = (uint8_t)(div & 0xFF);
	if (mpu_write_mem(D_0_22, 2, tmp))
		return 1;
	if (mpu_write_mem(CFG_6, 12, (uint8_t*)regs_end))
		return 1;

	dmp.fifo_rate = rate;
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movabsq $-0x20200e553b540d02, %rax # imm = 0xDFDFF1AAC4ABF2FE
movq %rax, (%rsp)
movl $0xdfdfafbb, 0x8(%rsp)  # imm = 0xDFDFAFBB
movb $0x1, %bl
cmpl $0xc8, %edi
ja 0x432b
movl %edi, %ebp
movb $-0x38, %al
movzbl %al, %eax
divb %bpl
leaq 0x10(%rsp), %rdx
movb $0x0, (%rdx)
decb %al
movb %al, 0x1(%rdx)
movl $0x216, %edi            # imm = 0x216
movl $0x2, %esi
callq 0x3995
testb %al, %al
jne 0x432b
movq %rsp, %rdx
movl $0xac1, %edi            # imm = 0xAC1
movl $0xc, %esi
callq 0x3995
testb %al, %al
jne 0x432b
movw %bp, 0x5f43(%rip)       # 0xa26c
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu_dmp_motion_driver.c
// Function: dmp_set_tap_axes(unsigned char)
uint8_t dmp_set_tap_axes(uint8_t axis)
{
	uint8_t tmp = 0;

	if (axis & TAP_X)
		tmp |= 0x30;
	if (axis & TAP_Y)
		tmp |= 0x0C;
	if (axis & TAP_Z)
		tmp |= 0x03;
	return mpu_write_mem(D_1_72, 1, &tmp);
}

// Assembly:
pushq %rax
movl %edi, %eax
andl $0x1, %eax
movl $0x30, %ecx
cmovel %eax, %ecx
leal 0xc(%rcx), %eax
testb $0x2, %dil
movzbl %al, %eax
cmovel %ecx, %eax
movl %eax, %ecx
orb $0x3, %cl
testb $0x4, %dil
movzbl %cl, %ecx
cmovel %eax, %ecx
leaq 0x7(%rsp), %rdx
movb %cl, (%rdx)
movl $0x148, %edi            # imm = 0x148
movl $0x1, %esi
callq 0x3995
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu_dmp_motion_driver.c
// Function: dmp_set_tap_count(unsigned char)
uint8_t dmp_set_tap_count(uint8_t min_taps)
{
	uint8_t tmp;

	if (min_taps < 1)
		min_taps = 1;
	else if (min_taps > 4)
		min_taps = 4;

	tmp = min_taps - 1;
	return mpu_write_mem(D_1_79, 1, &tmp);
}

// Assembly:
testl %edi, %edi
je 0x44f0
movzbl %dil, %ecx
cmpb $0x4, %cl
movl $0x4, %eax
cmovbl %ecx, %eax
decb %al
jmp 0x44f2
xorl %eax, %eax
pushq %rax
leaq 0x7(%rsp), %rdx
movb %al, (%rdx)
movl $0x14f, %edi            # imm = 0x14F
movl $0x1, %esi
callq 0x3995
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu_dmp_motion_driver.c
// Function: dmp_set_tap_time(unsigned short)
uint8_t dmp_set_tap_time(uint16_t time)
{
	uint16_t dmp_time;
	uint8_t tmp[2];

	dmp_time = time / (1000 / DMP_SAMPLE_RATE);
	tmp[0] = (uint8_t)(dmp_time >> 8);
	tmp[1] = (uint8_t)(dmp_time & 0xFF);
	return mpu_write_mem(DMP_TAPW_MIN, 2, tmp);
}

// Assembly:
pushq %rax
imull $0xcccd, %edi, %eax     # imm = 0xCCCD
shrl $0x12, %eax
rolw $0x8, %ax
leaq 0x6(%rsp), %rdx
movw %ax, (%rdx)
movl $0x1de, %edi            # imm = 0x1DE
movl $0x2, %esi
callq 0x3995
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu_dmp_motion_driver.c
// Function: dmp_set_tap_time_multi(unsigned short)
uint8_t dmp_set_tap_time_multi(uint16_t time)
{
	uint16_t dmp_time;
	uint8_t tmp[2];

	dmp_time = time / (1000 / DMP_SAMPLE_RATE);
	tmp[0] = (uint8_t)(dmp_time >> 8);
	tmp[1] = (uint8_t)(dmp_time & 0xFF);
	return mpu_write_mem(D_1_218, 2, tmp);
}

// Assembly:
pushq %rax
imull $0xcccd, %edi, %eax     # imm = 0xCCCD
shrl $0x12, %eax
rolw $0x8, %ax
leaq 0x6(%rsp), %rdx
movw %ax, (%rdx)
movl $0x1da, %edi            # imm = 0x1DA
movl $0x2, %esi
callq 0x3995
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu_dmp_motion_driver.c
// Function: dmp_set_shake_reject_time(unsigned short)
uint8_t dmp_set_shake_reject_time(uint16_t time)
{
	uint8_t tmp[2];

	time /= (1000 / DMP_SAMPLE_RATE);
	tmp[0] = time >> 8;
	tmp[1] = time & 0xFF;
	return mpu_write_mem(D_1_90,2,tmp);
}

// Assembly:
pushq %rax
imull $0xcccd, %edi, %eax     # imm = 0xCCCD
shrl $0x12, %eax
rolw $0x8, %ax
leaq 0x6(%rsp), %rdx
movw %ax, (%rdx)
movl $0x15a, %edi            # imm = 0x15A
movl $0x2, %esi
callq 0x3995
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu_dmp_motion_driver.c
// Function: dmp_set_shake_reject_timeout(unsigned short)
uint8_t dmp_set_shake_reject_timeout(uint16_t time)
{
	uint8_t tmp[2];

	time /= (1000 / DMP_SAMPLE_RATE);
	tmp[0] = time >> 8;
	tmp[1] = time & 0xFF;
	return mpu_write_mem(D_1_88,2,tmp);
}

// Assembly:
pushq %rax
imull $0xcccd, %edi, %eax     # imm = 0xCCCD
shrl $0x12, %eax
rolw $0x8, %ax
leaq 0x6(%rsp), %rdx
movw %ax, (%rdx)
movl $0x158, %edi            # imm = 0x158
movl $0x2, %esi
callq 0x3995
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu_dmp_motion_driver.c
// Function: dmp_get_pedometer_step_count(unsigned int*)
uint8_t dmp_get_pedometer_step_count(uint32_t *count)
{
	uint8_t tmp[4];
	if (!count)
		return 1;

	if (mpu_read_mem(D_PEDSTD_STEPCTR, 4, tmp))
		return 1;

	count[0] = ((uint32_t)tmp[0] << 24) | ((uint32_t)tmp[1] << 16) |
						 ((uint32_t)tmp[2] << 8) | tmp[3];
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movb $0x1, %bl
testq %rdi, %rdi
je 0x460d
movq %rdi, %r14
leaq 0x4(%rsp), %rdx
movl $0x360, %edi            # imm = 0x360
movl $0x4, %esi
callq 0x3a2b
testb %al, %al
jne 0x460d
movl 0x4(%rsp), %eax
bswapl %eax
movl %eax, (%r14)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu_dmp_motion_driver.c
// Function: dmp_get_pedometer_walk_time(unsigned int*)
uint8_t dmp_get_pedometer_walk_time(uint32_t *time)
{
	uint8_t tmp[4];
	if (!time)
		return 1;

	if (mpu_read_mem(D_PEDSTD_TIMECTR, 4, tmp))
		return 1;

	time[0] = (((uint32_t)tmp[0] << 24) | ((uint32_t)tmp[1] << 16) |
						 ((uint32_t)tmp[2] << 8) | tmp[3]) * 20;
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movb $0x1, %bpl
testq %rdi, %rdi
je 0x4668
movq %rdi, %rbx
leaq 0x4(%rsp), %rdx
movl $0x3c4, %edi            # imm = 0x3C4
movl $0x4, %esi
callq 0x3a2b
testb %al, %al
jne 0x4668
movl 0x4(%rsp), %eax
bswapl %eax
shll $0x2, %eax
leal (%rax,%rax,4), %eax
movl %eax, (%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu_dmp_motion_driver.c
// Function: dmp_set_pedometer_walk_time(unsigned int)
uint8_t dmp_set_pedometer_walk_time(uint32_t time)
{
	uint8_t tmp[4];

	time /= 20;

	tmp[0] = (uint8_t)((time >> 24) & 0xFF);
	tmp[1] = (uint8_t)((time >> 16) & 0xFF);
	tmp[2] = (uint8_t)((time >> 8) & 0xFF);
	tmp[3] = (uint8_t)(time & 0xFF);
	return mpu_write_mem(D_PEDSTD_TIMECTR, 4, tmp);
}

// Assembly:
pushq %rax
movl %edi, %eax
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
imulq %rax, %rcx
shrq $0x24, %rcx
bswapl %ecx
leaq 0x4(%rsp), %rdx
movl %ecx, (%rdx)
movl $0x3c4, %edi            # imm = 0x3C4
movl $0x4, %esi
callq 0x3995
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu_dmp_motion_driver.c
// Function: dmp_enable_gyro_cal(unsigned char)
uint8_t dmp_enable_gyro_cal(uint8_t enable)
{
	if (enable)
	{
		uint8_t regs[9] = {0xb8, 0xaa, 0xb3, 0x8d, 0xb4, 0x98, 0x0d, 0x35, 0x5d};
		return mpu_write_mem(CFG_MOTION_BIAS, 9, regs);
	}
	else
	{
		uint8_t regs[9] = {0xb8, 0xaa, 0xaa, 0xaa, 0xb0, 0x88, 0xc3, 0xc5, 0xc7};
		return mpu_write_mem(CFG_MOTION_BIAS, 9, regs);
	}
}

// Assembly:
subq $0x18, %rsp
testl %edi, %edi
je 0x4a3f
movabsq $0x350d98b48db3aab8, %rax # imm = 0x350D98B48DB3AAB8
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movb $0x5d, 0x8(%rdx)
jmp 0x4a55
movabsq $-0x3a3c774f55555548, %rax # imm = 0xC5C388B0AAAAAAB8
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movb $-0x39, 0x8(%rdx)
movl $0x4b8, %edi            # imm = 0x4B8
movl $0x9, %esi
callq 0x3995
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu_dmp_motion_driver.c
// Function: dmp_set_interrupt_mode(unsigned char)
uint8_t dmp_set_interrupt_mode(uint8_t mode)
{
	const uint8_t regs_continuous[11] =
	{0xd8, 0xb1, 0xb9, 0xf3, 0x8b, 0xa3, 0x91, 0xb6, 0x09, 0xb4, 0xd9};
	const uint8_t regs_gesture[11] =
	{0xda, 0xb1, 0xb9, 0xf3, 0x8b, 0xa3, 0x91, 0xb6, 0xda, 0xb4, 0xda};

	switch (mode)
	{
	case DMP_INT_CONTINUOUS:
		return mpu_write_mem(CFG_FIFO_ON_EVENT, 11,
												 (uint8_t*)regs_continuous);
	case DMP_INT_GESTURE:
		return mpu_write_mem(CFG_FIFO_ON_EVENT, 11,
												 (uint8_t*)regs_gesture);
	default:
		return 1;
	}
}

// Assembly:
subq $0x28, %rsp
movabsq $-0x496e5c740c464e28, %rax # imm = 0xB691A38BF3B9B1D8
movq %rax, 0x18(%rsp)
movl $0xd9b409b6, 0x1f(%rsp) # imm = 0xD9B409B6
movabsq $-0x496e5c740c464e26, %rax # imm = 0xB691A38BF3B9B1DA
movq %rax, 0x8(%rsp)
movl $0xdab4dab6, 0xf(%rsp)  # imm = 0xDAB4DAB6
cmpl $0x2, %edi
je 0x4b25
movb $0x1, %al
cmpl $0x1, %edi
jne 0x4b39
leaq 0x8(%rsp), %rdx
jmp 0x4b2a
leaq 0x18(%rsp), %rdx
movl $0xa82, %edi            # imm = 0xA82
movl $0xb, %esi
callq 0x3995
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/libs/I2Cdev/I2Cdev.c
// Function: readBitW(unsigned char, unsigned char, unsigned char, unsigned short*)
int8_t readBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t *data) {
    uint16_t b;
    uint8_t count = readWord(devAddr, regAddr, &b);
    *data = b & (1 << bitNum);
    return count;
}

// Assembly:
pushq %rbx
movq %rcx, %rbx
leaq 0x25a0(%rip), %rdi      # 0x7356
callq 0x1110
movw $0x0, (%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/libs/I2Cdev/I2Cdev.c
// Function: readBits(unsigned char, unsigned char, unsigned char, unsigned char, unsigned char*)
int8_t readBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t *data) {
    // 01101001 read byte
    // 76543210 bit numbers
    //    xxx   args: bitStart=4, length=3
    //    010   masked
    //   -> 010 shifted
    uint8_t count, b;
    if ((count = readByte(devAddr, regAddr, &b)) != 0) {
        uint8_t mask = ((1 << length) - 1) << (bitStart - length + 1);
        b &= mask;
        b >>= (bitStart - length + 1);
        *data = b;
    }
    return count;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movl %ecx, %r14d
movl %edx, %ebp
leaq 0xf(%rsp), %rcx
movl $0x1, %edx
callq 0x4e41
testb %al, %al
je 0x4e27
movzbl %r14b, %ecx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
shll %cl, %esi
notl %esi
movzbl %bpl, %edx
subl %ecx, %edx
incb %dl
movl %edx, %ecx
shll %cl, %esi
andb 0xf(%rsp), %sil
movzbl %sil, %esi
shrl %cl, %esi
movb %sil, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/libs/I2Cdev/I2Cdev.c
// Function: readBytes(unsigned char, unsigned char, unsigned char, unsigned char*)
int8_t readBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t *data) {
    int8_t count = 0;
#ifdef DEBUG
    printf("read %#x %#x %u\n",devAddr,regAddr,length);
#endif
    int fd = open("/dev/i2c-1", O_RDWR);

    if (fd < 0) {
        fprintf(stderr, "Failed to open device: %s\n", strerror(errno));
        return(-1);
    }
    if (ioctl(fd, I2C_SLAVE, devAddr) < 0) {
        fprintf(stderr, "Failed to select device: %s\n", strerror(errno));
        close(fd);
        return(-1);
    }
    if (write(fd, &regAddr, 1) != 1) {
        fprintf(stderr, "Failed to write reg: %s\n", strerror(errno));
        close(fd);
        return(-1);
    }
    count = read(fd, data, length);
    if (count < 0) {
        fprintf(stderr, "Failed to read device(%d): %s\n", count, strerror(errno));
        close(fd);
        return(-1);
    } else if (count != length) {
        fprintf(stderr, "Short read  from device, expected %d, got %d\n", length, count);
        close(fd);
        return(-1);
    }
    close(fd);

    return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebp
movl %edi, %r15d
movb %sil, 0x7(%rsp)
leaq 0x23cc(%rip), %rdi      # 0x7228
movl $0x2, %esi
xorl %eax, %eax
callq 0x1070
testl %eax, %eax
js 0x4ec6
movl %eax, %ebx
movzbl %r15b, %edx
movl $0x703, %esi            # imm = 0x703
movl %eax, %edi
xorl %eax, %eax
callq 0x10d0
testl %eax, %eax
js 0x4ecd
leaq 0x7(%rsp), %rsi
movl $0x1, %edx
movl %ebx, %edi
callq 0x1060
cmpq $0x1, %rax
jne 0x4ed6
movzbl %bpl, %r15d
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1100
movq %rax, %r14
movsbl %r14b, %ecx
testb %r14b, %r14b
js 0x4edf
cmpl %r15d, %ecx
jne 0x4eea
movl %ebx, %edi
callq 0x1120
jmp 0x4f0f
callq 0x11fb
jmp 0x4f0c
movl %ebx, %edi
callq 0x11bd
jmp 0x4f0c
movl %ebx, %edi
callq 0x1140
jmp 0x4f0c
movl %ecx, %edi
movl %ebx, %esi
callq 0x117e
jmp 0x4f0c
movq 0x50ef(%rip), %rax      # 0x9fe0
movq (%rax), %rdi
leaq 0x23a8(%rip), %rsi      # 0x72a3
movl %r15d, %edx
xorl %eax, %eax
callq 0x10f0
movl %ebx, %edi
callq 0x1120
movb $-0x1, %r14b
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/libs/I2Cdev/I2Cdev.c
// Function: readWords(unsigned char, unsigned char, unsigned char, unsigned short*)
int8_t readWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t *data) {
    int8_t count = 0;

    printf("ReadWords() not implemented\n");
    // Use readBytes() and potential byteswap
    *data = 0; // keep the compiler quiet

    return count;
}

// Assembly:
pushq %rbx
movq %rcx, %rbx
leaq 0x242e(%rip), %rdi      # 0x7356
callq 0x1110
movw $0x0, (%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/libs/I2Cdev/I2Cdev.c
// Function: writeBit(unsigned char, unsigned char, unsigned char, unsigned char)
int writeBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t data) {
    uint8_t b;
    readByte(devAddr, regAddr, &b);
    b = (data != 0) ? (b | (1 << bitNum)) : (b & ~(1 << bitNum));
    return writeByte(devAddr, regAddr, b);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
leaq 0xe(%rsp), %r12
movl $0x1, %edx
movq %r12, %rcx
callq 0x4e41
movzbl (%r12), %eax
movl %eax, %ecx
btsl %ebp, %ecx
btrl %ebp, %eax
testl %ebx, %ebx
cmovnel %ecx, %eax
leaq 0xf(%rsp), %rcx
movb %al, (%rcx)
movl %r15d, %edi
movl %r14d, %esi
movl $0x1, %edx
callq 0x50a2
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/libs/I2Cdev/I2Cdev.c
// Function: writeBitW(unsigned char, unsigned char, unsigned char, unsigned short)
int writeBitW(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint16_t data) {
    uint16_t w;
    readWord(devAddr, regAddr, &w);
    w = (data != 0) ? (w | (1 << bitNum)) : (w & ~(1 << bitNum));
    return writeWord(devAddr, regAddr, w);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
leaq 0x2396(%rip), %rdi      # 0x7356
callq 0x1110
movl $0x1, %eax
movl %ebp, %ecx
shll %cl, %eax
testl %ebx, %ebx
cmovel %ebx, %eax
leaq 0x6(%rsp), %rcx
movw %ax, (%rcx)
movl %r15d, %edi
movl %r14d, %esi
movl $0x1, %edx
callq 0x5195
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/libs/I2Cdev/I2Cdev.c
// Function: writeBits(unsigned char, unsigned char, unsigned char, unsigned char, unsigned char)
int writeBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t data) {
    //      010 value to write
    // 76543210 bit numbers
    //    xxx   args: bitStart=4, length=3
    // 00011100 mask byte
    // 10101111 original value (sample)
    // 10100011 original & ~mask
    // 10101011 masked | value
    uint8_t b;
    if (readByte(devAddr, regAddr, &b) != 0) {
        uint8_t mask = ((1 << length) - 1) << (bitStart - length + 1);
        data <<= (bitStart - length + 1); // shift data into correct position
        data &= mask; // zero all non-important bits in data
        b &= ~(mask); // zero all important bits in existing byte
        b |= data; // combine data with existing byte
        return writeByte(devAddr, regAddr, b);
    } else {
        return -1;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r8d, %r14d
movl %ecx, %r12d
movl %edx, %r15d
movl %esi, %ebx
movl %edi, %ebp
leaq 0xe(%rsp), %rcx
movl $0x1, %edx
callq 0x4e41
testb %al, %al
je 0x507c
movzbl %r12b, %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
shll %cl, %edx
notl %edx
movzbl %r15b, %eax
subl %ecx, %eax
incb %al
movzbl %r14b, %esi
andl %edx, %esi
movl %eax, %ecx
shll %cl, %edx
shll %cl, %esi
notb %dl
andb 0xe(%rsp), %dl
orb %dl, %sil
leaq 0xf(%rsp), %rcx
movb %sil, (%rcx)
movzbl %bpl, %edi
movzbl %bl, %esi
movl $0x1, %edx
callq 0x50a2
jmp 0x5081
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/libs/I2Cdev/I2Cdev.c
// Function: writeBytes(unsigned char, unsigned char, unsigned char, unsigned char*)
int writeBytes(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint8_t* data) {
    int8_t count = 0;
    uint8_t buf[128];
    int fd;

#ifdef DEBUG
    printf("write %#x %#x\n",devAddr,regAddr);
#endif
    if (length > 127) {
        fprintf(stderr, "Byte write count (%d) > 127\n", length);
        return -1;
    }

    fd = open("/dev/i2c-1", O_RDWR);
    if (fd < 0) {
        fprintf(stderr, "Failed to open device: %s\n", strerror(errno));
        return -1;
    }
    if (ioctl(fd, I2C_SLAVE, devAddr) < 0) {
        fprintf(stderr, "Failed to select device: %s\n", strerror(errno));
        close(fd);
        return -1;
    }
    buf[0] = regAddr;
    memcpy(buf+1,data,length);
    count = write(fd, buf, length+1);
    if (count < 0) {
        fprintf(stderr, "Failed to write device(%d): %s\n", count, strerror(errno));
        close(fd);
        return -1;
    } else if (count != length+1) {
        fprintf(stderr, "Short write to device, expected %d, got %d\n", length+1, count);
        close(fd);
        return -1;
    }
    close(fd);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movl %edx, %ebx
testb %bl, %bl
js 0x5128
movq %rcx, %r14
movl %esi, %r15d
movl %edi, %r12d
leaq 0x2161(%rip), %rdi      # 0x7228
movl $0x2, %esi
xorl %eax, %eax
callq 0x1070
testl %eax, %eax
js 0x5144
movl %eax, %ebp
movzbl %r12b, %edx
movl $0x703, %esi            # imm = 0x703
movl %eax, %edi
xorl %eax, %eax
callq 0x10d0
testl %eax, %eax
js 0x514b
leaq 0x1(%rsp), %rdi
movb %r15b, -0x1(%rdi)
movzbl %bl, %edx
movq %r14, %rsi
callq 0x1080
incl %ebx
movq %rsp, %rsi
movl %ebp, %edi
movq %rbx, %rdx
callq 0x1060
movsbl %al, %ecx
testl %ecx, %ecx
js 0x5154
cmpl %ebx, %ecx
jne 0x515f
movl %ebp, %edi
callq 0x1120
xorl %eax, %eax
jmp 0x5185
movq 0x4eb1(%rip), %rax      # 0x9fe0
movq (%rax), %rdi
leaq 0x2198(%rip), %rsi      # 0x72d1
movl %ebx, %edx
xorl %eax, %eax
callq 0x10f0
jmp 0x5180
callq 0x12a4
jmp 0x5180
movl %ebp, %edi
callq 0x1266
jmp 0x5180
movl %ecx, %edi
movl %ebp, %esi
callq 0x1227
jmp 0x5180
movq 0x4e7a(%rip), %rax      # 0x9fe0
movq (%rax), %rdi
leaq 0x219e(%rip), %rsi      # 0x730e
movl %ebx, %edx
xorl %eax, %eax
callq 0x10f0
movl %ebp, %edi
callq 0x1120
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ZombiesYard[P]MPU6050-DMP-raspberry-pi/libs/I2Cdev/I2Cdev.c
// Function: writeWords(unsigned char, unsigned char, unsigned char, unsigned short*)
int writeWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t* data) {
    int8_t count = 0;
    uint8_t buf[128];
    int i, fd;

    // Should do potential byteswap and call writeBytes() really, but that
    // messes with the callers buffer

    if (length > 63) {
        fprintf(stderr, "Word write count (%d) > 63\n", length);
        return -1;
    }

    fd = open("/dev/i2c-1", O_RDWR);
    if (fd < 0) {
        fprintf(stderr, "Failed to open device: %s\n", strerror(errno));
        return -1;
    }
    if (ioctl(fd, I2C_SLAVE, devAddr) < 0) {
        fprintf(stderr, "Failed to select device: %s\n", strerror(errno));
        close(fd);
        return -1;
    }
    buf[0] = regAddr;
    for (i = 0; i < length; i++) {
        buf[i*2+1] = data[i] >> 8;
        buf[i*2+2] = data[i];
    }
    count = write(fd, buf, length*2+1);
    if (count < 0) {
        fprintf(stderr, "Failed to write device(%d): %s\n", count, strerror(errno));
        close(fd);
        return -1;
    } else if (count != length*2+1) {
        fprintf(stderr, "Short write to device, expected %d, got %d\n", length+1, count);
        close(fd);
        return -1;
    }
    close(fd);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movl %edx, %ebx
cmpb $0x40, %bl
jae 0x523a
movq %rcx, %r14
movl %esi, %r15d
movl %edi, %r12d
leaq 0x2069(%rip), %rdi      # 0x7228
movl $0x2, %esi
xorl %eax, %eax
callq 0x1070
testl %eax, %eax
js 0x5256
movl %eax, %ebp
movzbl %r12b, %edx
movl $0x703, %esi            # imm = 0x703
movl %eax, %edi
xorl %eax, %eax
callq 0x10d0
testl %eax, %eax
js 0x525d
movb %r15b, (%rsp)
testb %bl, %bl
je 0x520e
movzbl %bl, %eax
xorl %ecx, %ecx
movzwl (%r14,%rcx,2), %edx
rolw $0x8, %dx
movw %dx, 0x1(%rsp,%rcx,2)
incq %rcx
cmpq %rcx, %rax
jne 0x51f8
leal 0x1(,%rbx,2), %r14d
movq %rsp, %rsi
movl %ebp, %edi
movq %r14, %rdx
callq 0x1060
movsbl %al, %ecx
testl %ecx, %ecx
js 0x5266
cmpl %r14d, %ecx
jne 0x5271
movl %ebp, %edi
callq 0x1120
xorl %eax, %eax
jmp 0x5299
movq 0x4d9f(%rip), %rax      # 0x9fe0
movq (%rax), %rdi
leaq 0x20ef(%rip), %rsi      # 0x733a
movl %ebx, %edx
xorl %eax, %eax
callq 0x10f0
jmp 0x5294
callq 0x134d
jmp 0x5294
movl %ebp, %edi
callq 0x130f
jmp 0x5294
movl %ecx, %edi
movl %ebp, %esi
callq 0x12d0
jmp 0x5294
movq 0x4d68(%rip), %rax      # 0x9fe0
movq (%rax), %rdi
incl %ebx
leaq 0x208a(%rip), %rsi      # 0x730e
movl %ebx, %edx
xorl %eax, %eax
callq 0x10f0
movl %ebp, %edi
callq 0x1120
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/antonblanchard[P]will-it-scale/main.c
// Function: new_task
void new_task(void *(func)(void *), void *arg)
{
	int pid;

	parent_pid = getpid();

	pid = fork();
	if (pid < 0) {
		perror("fork");
		exit(1);
	}

	if (!pid) {
		struct sigaction sa;

		memset(&sa, 0, sizeof(sa));
		sa.sa_handler = watchdog;
		sa.sa_flags = SA_RESTART;
		sigaction(SIGALRM, &sa, NULL);
		alarm(1);

		func(arg);
	}

	pids[nr_pids++] = pid;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x20e0
movl %eax, 0x2da4(%rip)      # 0x51b0
callq 0x22b0
testl %eax, %eax
js 0x2489
movl %eax, %ebp
jne 0x2461
leaq 0x8(%rsp), %r15
movl $0x90, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x2150
leaq 0x5a(%rip), %rax        # 0x248e
movq %rax, -0x8(%r15)
movl $0x10000000, 0x80(%r15) # imm = 0x10000000
movq %rsp, %rsi
movl $0xe, %edi
xorl %edx, %edx
callq 0x20b0
movl $0x1, %edi
callq 0x2160
movq %r14, %rdi
callq *%rbx
movslq 0x6d58(%rip), %rax      # 0x91c0
leal 0x1(%rax), %ecx
movl %ecx, 0x6d4f(%rip)      # 0x91c0
leaq 0x2d48(%rip), %rcx      # 0x51c0
movl %ebp, (%rcx,%rax,4)
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x22d0
// File: /workspace/github_c_makefile_star2_O3/antonblanchard[P]will-it-scale/main.c
// Function: new_task_affinity
void new_task_affinity(struct args *args)
{
	int pid;

	parent_pid = getpid();

	pid = fork();
	if (pid < 0) {
		perror("fork");
		exit(1);
	}

	if (!pid) {
		struct sigaction sa;

		memset(&sa, 0, sizeof(sa));
		sa.sa_handler = watchdog;
		sa.sa_flags = SA_RESTART;
		sigaction(SIGALRM, &sa, NULL);
		alarm(1);

		testcase_trampoline(args);
	}

	pids[nr_pids++] = pid;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
callq 0x20e0
movl %eax, 0x2ce4(%rip)      # 0x51b0
callq 0x22b0
testl %eax, %eax
js 0x2588
movl %eax, %ebp
jne 0x2562
leaq 0x10(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2150
leaq -0x6e(%rip), %rax       # 0x248e
movq %rax, -0x8(%r14)
movl $0x10000000, 0x80(%r14) # imm = 0x10000000
leaq 0x8(%rsp), %rsi
movl $0xe, %edi
xorl %edx, %edx
callq 0x20b0
movl $0x1, %edi
callq 0x2160
movl 0x18(%rbx), %eax
movq %rsp, %r14
movl %eax, (%r14)
movl $0x1, 0x4(%r14)
movl $0x1, %esi
movq %r14, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
cmpl $-0x1, %eax
jne 0x2558
callq 0x2070
cmpl $0x4, (%rax)
je 0x2537
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
callq *(%rbx)
movslq 0x6c57(%rip), %rax      # 0x91c0
leal 0x1(%rax), %ecx
movl %ecx, 0x6c4e(%rip)      # 0x91c0
leaq 0x2c47(%rip), %rcx      # 0x51c0
movl %ebp, (%rcx,%rax,4)
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x22e5
// File: /workspace/github_c_makefile_star2_O3/antonblanchard[P]will-it-scale/main.c
// Function: kill_tasks
static void kill_tasks(void)
{
	int i;

	for (i = 0; i < nr_pids; i++)
		kill(pids[i], SIGTERM);
	for (i = 0; i < nr_pids; i++)
		waitpid(pids[i], NULL, 0);
}

// Assembly:
cmpl $0x0, 0x6503(%rip)      # 0x91c0
jle 0x2d1f
pushq %r14
pushq %rbx
pushq %rax
leaq 0x24f6(%rip), %rbx      # 0x51c0
xorl %r14d, %r14d
movl (%rbx), %edi
movl $0xf, %esi
callq 0x21b0
incq %r14
movslq 0x64dd(%rip), %rax      # 0x91c0
addq $0x4, %rbx
cmpq %rax, %r14
jl 0x2ccd
testl %eax, %eax
jle 0x2d18
leaq 0x24c9(%rip), %rbx      # 0x51c0
xorl %r14d, %r14d
movl (%rbx), %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2220
incq %r14
movslq 0x64b1(%rip), %rax      # 0x91c0
addq $0x4, %rbx
cmpq %rax, %r14
jl 0x2cfa
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/antonblanchard[P]will-it-scale/tests/writeseek2.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char buf[BUFLEN];
	int fd = open(tmpfile, O_RDWR);

	assert(fd >= 0);

	while (1) {
		lseek(fd, 0, SEEK_SET);
		assert(write(fd, buf, BUFLEN) == BUFLEN);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rdi, %rbx
leaq 0x23be(%rip), %rdi      # 0x5180
movl $0x2, %esi
xorl %eax, %eax
callq 0x2230
testl %eax, %eax
js 0x2e3d
movl %eax, %ebp
movl %eax, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2130
movq %rsp, %rsi
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
callq 0x20d0
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x2e1e
movq %rsp, %r14
incq (%rbx)
movl %ebp, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2130
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
movq %r14, %rsi
callq 0x20d0
cmpq $0x1000, %rax           # imm = 0x1000
je 0x2df9
leaq 0x524(%rip), %rdi       # 0x3349
leaq 0x487(%rip), %rsi       # 0x32b3
leaq 0x4e3(%rip), %rcx       # 0x3316
movl $0x21, %edx
callq 0x2140
leaq 0x467(%rip), %rdi       # 0x32ab
leaq 0x468(%rip), %rsi       # 0x32b3
leaq 0x4c4(%rip), %rcx       # 0x3316
movl $0x1d, %edx
callq 0x2140
// File: /workspace/github_c_makefile_star2_O3/dxwc[P]sfeed/sfeed.c
// Function: main
int
main(int argc, char *argv[])
{
	if (pledge("stdio", NULL) == -1)
		err(1, "pledge");

	if (argc > 1)
		baseurl = argv[1];

	parser.xmlattr = xmlattr;
	parser.xmlattrend = xmlattrend;
	parser.xmlattrstart = xmlattrstart;
	parser.xmlcdata = xmlcdata;
	parser.xmldata = xmldata;
	parser.xmldataentity = xmldataentity;
	parser.xmltagend = xmltagend;
	parser.xmltagstart = xmltagstart;
	parser.xmltagstartparsed = xmltagstartparsed;

	/* NOTE: getnext is defined in xml.h for inline optimization */
	xml_parse(&parser);

	return 0;
}

// Assembly:
cmpl $0x2, %edi
jl 0x22f7
movq 0x8(%rsi), %rax
movq %rax, 0x4e09(%rip)      # 0x7100
pushq %rax
leaq 0x87(%rip), %rax        # 0x2386
movq %rax, 0x4ffa(%rip)      # 0x7300
leaq 0x4ff3(%rip), %rdi      # 0x7300
leaq 0x330(%rip), %rax       # 0x2644
movq %rax, 0x4fed(%rip)      # 0x7308
leaq 0x35e(%rip), %rax       # 0x2680
movq %rax, 0x4fe7(%rip)      # 0x7310
leaq 0x3ca(%rip), %rax       # 0x26fa
movq %rax, 0x4ff1(%rip)      # 0x7328
leaq 0x3cd(%rip), %rax       # 0x270b
movq %rax, 0x500b(%rip)      # 0x7350
leaq 0x419(%rip), %rax       # 0x2765
movq %rax, 0x500d(%rip)      # 0x7360
leaq 0x45d(%rip), %rax       # 0x27b7
movq %rax, 0x500f(%rip)      # 0x7370
leaq 0x659(%rip), %rax       # 0x29c1
movq %rax, 0x5009(%rip)      # 0x7378
leaq 0x7ff(%rip), %rax       # 0x2b75
movq %rax, 0x5003(%rip)      # 0x7380
callq 0x3fe9
xorl %eax, %eax
popq %rcx
retq