LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mrlordkaj[P]i2cdevlib-pi/L3GD20H/L3GD20H.cpp
// Function: L3GD20H::setOutputDataRate(unsigned short)
void L3GD20H::setOutputDataRate(uint16_t rate) {
	uint8_t writeVal;
	bool lowODRwriteVal;

	if (rate ==12) {
		writeVal = L3GD20H_RATE_100_12;
		setLowODREnabled(true);
	} else if (rate == 25) {
		writeVal = L3GD20H_RATE_200_25;
		setLowODREnabled(true);
	} else if (rate == 50) {
		writeVal = L3GD20H_RATE_400_50;
		setLowODREnabled(true);
	} else if (rate == 100) {
		writeVal = L3GD20H_RATE_100_12;
		setLowODREnabled(false);
	} else if (rate == 200) {
		writeVal = L3GD20H_RATE_200_25;
		setLowODREnabled(false);
	} else if (rate == 400) {
		writeVal = L3GD20H_RATE_400_50;
		setLowODREnabled(false);
	} else {
		writeVal = L3GD20H_RATE_800_50;
		setLowODREnabled(false);
	}
	
	I2Cdev::writeBits(devAddr, L3GD20H_RA_CTRL1, L3GD20H_ODR_BIT,
		L3GD20H_ODR_LENGTH, writeVal); 
}

// Assembly:
subq $0x18, %rsp
movw %si, %ax
movq %rdi, 0x10(%rsp)
movw %ax, 0xe(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movzwl 0xe(%rsp), %eax
cmpl $0xc, %eax
jne 0x3651c
movq (%rsp), %rdi
movb $0x0, 0xd(%rsp)
movl $0x1, %esi
callq 0x22860
jmp 0x365cf
movzwl 0xe(%rsp), %eax
cmpl $0x19, %eax
jne 0x3653e
movq (%rsp), %rdi
movb $0x1, 0xd(%rsp)
movl $0x1, %esi
callq 0x22860
jmp 0x365cd
movzwl 0xe(%rsp), %eax
cmpl $0x32, %eax
jne 0x3655d
movq (%rsp), %rdi
movb $0x2, 0xd(%rsp)
movl $0x1, %esi
callq 0x22860
jmp 0x365cb
movzwl 0xe(%rsp), %eax
cmpl $0x64, %eax
jne 0x36579
movq (%rsp), %rdi
movb $0x0, 0xd(%rsp)
xorl %esi, %esi
callq 0x22860
jmp 0x365c9
movzwl 0xe(%rsp), %eax
cmpl $0xc8, %eax
jne 0x36597
movq (%rsp), %rdi
movb $0x1, 0xd(%rsp)
xorl %esi, %esi
callq 0x22860
jmp 0x365c7
movzwl 0xe(%rsp), %eax
cmpl $0x190, %eax            # imm = 0x190
jne 0x365b5
movq (%rsp), %rdi
movb $0x2, 0xd(%rsp)
xorl %esi, %esi
callq 0x22860
jmp 0x365c5
movq (%rsp), %rdi
movb $0x3, 0xd(%rsp)
xorl %esi, %esi
callq 0x22860
jmp 0x365c7
jmp 0x365c9
jmp 0x365cb
jmp 0x365cd
jmp 0x365cf
movq (%rsp), %rax
movb (%rax), %al
movl $0x20, %esi
movl $0x7, %edx
movl $0x2, %ecx
movzbl %al, %edi
movzbl 0xd(%rsp), %r8d
callq 0x22ca0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/L3GD20H/L3GD20H.cpp
// Function: L3GD20H::getOutputDataRate()
uint16_t L3GD20H::getOutputDataRate() {
	I2Cdev::readBits(devAddr, L3GD20H_RA_CTRL1, L3GD20H_ODR_BIT, 
		L3GD20H_ODR_LENGTH, buffer);
	uint8_t rate = buffer[0];

	if (rate == L3GD20H_RATE_100_12) {
		if (getLowODREnabled() == true) {
			return 12;
		} else {
			return 100;	
		}
	} else if (rate == L3GD20H_RATE_200_25) {
		if (getLowODREnabled() == true) {
			return 25;
		} else {
			return 200;
		}
	} else if (rate == L3GD20H_RATE_400_50) {
		if (getLowODREnabled() == true) {
			return 50;
		} else {
			return 400;
		}
	} else if (rate == L3GD20H_RATE_800_50) {
		if (getLowODREnabled() == true) {
			return 50;
		} else {
			return 800;
		}
	}
	return 800;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %r8
movq %r8, 0x8(%rsp)
movb (%r8), %dil
addq $0x1, %r8
movl $0x20, %esi
movl $0x7, %edx
movl $0x2, %ecx
movq 0x258a8(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r9d
callq 0x23150
movq 0x8(%rsp), %rax
movb 0x1(%rax), %al
movb %al, 0x17(%rsp)
movzbl 0x17(%rsp), %eax
cmpl $0x0, %eax
jne 0x366bf
movq 0x8(%rsp), %rdi
callq 0x22c70
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x366b3
movw $0xc, 0x26(%rsp)
jmp 0x3675c
movw $0x64, 0x26(%rsp)
jmp 0x3675c
movzbl 0x17(%rsp), %eax
cmpl $0x1, %eax
jne 0x366ef
movq 0x8(%rsp), %rdi
callq 0x22c70
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x366e6
movw $0x19, 0x26(%rsp)
jmp 0x3675c
movw $0xc8, 0x26(%rsp)
jmp 0x3675c
movzbl 0x17(%rsp), %eax
cmpl $0x2, %eax
jne 0x3671f
movq 0x8(%rsp), %rdi
callq 0x22c70
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x36716
movw $0x32, 0x26(%rsp)
jmp 0x3675c
movw $0x190, 0x26(%rsp)      # imm = 0x190
jmp 0x3675c
movzbl 0x17(%rsp), %eax
cmpl $0x3, %eax
jne 0x3674f
movq 0x8(%rsp), %rdi
callq 0x22c70
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x36746
movw $0x32, 0x26(%rsp)
jmp 0x3675c
movw $0x320, 0x26(%rsp)      # imm = 0x320
jmp 0x3675c
jmp 0x36751
jmp 0x36753
jmp 0x36755
movw $0x320, 0x26(%rsp)      # imm = 0x320
movw 0x26(%rsp), %ax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/L3GD20H/L3GD20H.cpp
// Function: L3GD20H::setFullScale(unsigned short)
void L3GD20H::setFullScale(uint16_t scale) {
	uint8_t writeBits;
	
	if (scale == 250) {
		writeBits = L3GD20H_FS_250;
	} else if (scale == 500) {
		writeBits = L3GD20H_FS_500;
	} else {
		writeBits = L3GD20H_FS_2000;
	}

	I2Cdev::writeBits(devAddr, L3GD20H_RA_CTRL4, L3GD20H_FS_BIT, 
		L3GD20H_FS_LENGTH, writeBits);
}

// Assembly:
subq $0x18, %rsp
movw %si, %ax
movq %rdi, 0x10(%rsp)
movw %ax, 0xe(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movzwl 0xe(%rsp), %eax
cmpl $0xfa, %eax
jne 0x3713d
movb $0x0, 0xd(%rsp)
jmp 0x37157
movzwl 0xe(%rsp), %eax
cmpl $0x1f4, %eax            # imm = 0x1F4
jne 0x37150
movb $0x1, 0xd(%rsp)
jmp 0x37155
movb $0x2, 0xd(%rsp)
jmp 0x37157
movq (%rsp), %rax
movb (%rax), %al
movl $0x23, %esi
movl $0x5, %edx
movl $0x2, %ecx
movzbl %al, %edi
movzbl 0xd(%rsp), %r8d
callq 0x22ca0
addq $0x18, %rsp
retq
nop
// File: mrlordkaj[P]i2cdevlib-pi/L3GD20H/L3GD20H.cpp
// Function: L3GD20H::getFullScale()
uint16_t L3GD20H::getFullScale() {
	I2Cdev::readBits(devAddr, L3GD20H_RA_CTRL4, 
		L3GD20H_FS_BIT, L3GD20H_FS_LENGTH, buffer);
	uint8_t readBits = buffer[0];
	
	if (readBits == L3GD20H_FS_250) {
		return 250;
	} else if (readBits == L3GD20H_FS_500) {
		return 500;
	} else {
		return 2000;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %r8
movq %r8, 0x8(%rsp)
movb (%r8), %dil
addq $0x1, %r8
movl $0x23, %esi
movl $0x5, %edx
movl $0x2, %ecx
movq 0x24d68(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r9d
callq 0x23150
movq 0x8(%rsp), %rax
movb 0x1(%rax), %al
movb %al, 0x17(%rsp)
movzbl 0x17(%rsp), %eax
cmpl $0x0, %eax
jne 0x371dc
movw $0xfa, 0x26(%rsp)
jmp 0x371f6
movzbl 0x17(%rsp), %eax
cmpl $0x1, %eax
jne 0x371ef
movw $0x1f4, 0x26(%rsp)      # imm = 0x1F4
jmp 0x371f6
movw $0x7d0, 0x26(%rsp)      # imm = 0x7D0
movw 0x26(%rsp), %ax
addq $0x28, %rsp
retq
// File: mrlordkaj[P]i2cdevlib-pi/L3GD20H/L3GD20H.cpp
// Function: L3GD20H::setDataFilter(unsigned char)
void L3GD20H::setDataFilter(uint8_t filter) {
	if (filter == L3GD20H_HIGH_PASS || filter == L3GD20H_LOW_HIGH_PASS) {
		setHighPassFilterEnabled(true);
	} else {
		setHighPassFilterEnabled(false);
	}
	
	I2Cdev::writeBits(devAddr, L3GD20H_RA_CTRL5, L3GD20H_OUT_SEL_BIT, 
		L3GD20H_OUT_SEL_LENGTH, filter);
	I2Cdev::writeBits(devAddr, L3GD20H_RA_CTRL5, L3GD20H_IG_SEL_BIT, 
		L3GD20H_IG_SEL_LENGTH, filter);
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0x1, %eax
je 0x3752d
movzbl 0xf(%rsp), %eax
cmpl $0x3, %eax
jne 0x3753d
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x22530
jmp 0x37548
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x22530
movq (%rsp), %rax
movb (%rax), %al
movl $0x24, %esi
movl $0x1, %edx
movl $0x2, %ecx
movzbl %al, %edi
movzbl 0xf(%rsp), %r8d
callq 0x22ca0
movq (%rsp), %rax
movb (%rax), %al
movl $0x24, %esi
movl $0x3, %edx
movl $0x2, %ecx
movzbl %al, %edi
movzbl 0xf(%rsp), %r8d
callq 0x22ca0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/L3GD20H/L3GD20H.cpp
// Function: L3GD20H::getDataFilter()
uint8_t L3GD20H::getDataFilter() {
	I2Cdev::readBits(devAddr, L3GD20H_RA_CTRL5, L3GD20H_OUT_SEL_BIT, 
		L3GD20H_OUT_SEL_LENGTH, buffer);
	uint8_t outBits = buffer[0];

	if (outBits == L3GD20H_NON_HIGH_PASS || outBits == L3GD20H_HIGH_PASS) {
		return outBits;
	}

	if (getHighPassFilterEnabled()) {
		return L3GD20H_LOW_HIGH_PASS;
	} else {
		return L3GD20H_LOW_PASS;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %r8
movq %r8, 0x8(%rsp)
movb (%r8), %dil
addq $0x1, %r8
movl $0x24, %esi
movl $0x1, %edx
movl $0x2, %ecx
movq 0x24948(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r9d
callq 0x23150
movq 0x8(%rsp), %rax
movb 0x1(%rax), %al
movb %al, 0x17(%rsp)
movzbl 0x17(%rsp), %eax
cmpl $0x0, %eax
je 0x375fd
movzbl 0x17(%rsp), %eax
cmpl $0x1, %eax
jne 0x37607
movb 0x17(%rsp), %al
movb %al, 0x27(%rsp)
jmp 0x37623
movq 0x8(%rsp), %rdi
callq 0x226e0
testb $0x1, %al
jne 0x37617
jmp 0x3761e
movb $0x3, 0x27(%rsp)
jmp 0x37623
movb $0x2, 0x27(%rsp)
movb 0x27(%rsp), %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: mrlordkaj[P]i2cdevlib-pi/L3GD20H/L3GD20H.cpp
// Function: L3GD20H::getAngularVelocity(short*, short*, short*)
void L3GD20H::getAngularVelocity(int16_t* x, int16_t* y, int16_t* z) {
	I2Cdev::readBytes(devAddr, L3GD20H_RA_OUT_X_L | 0x80, 6, buffer);
	if (endianMode == L3GD20H_LITTLE_ENDIAN) {
		*x = (((int16_t)buffer[1]) << 8) | buffer[0];
		*y = (((int16_t)buffer[3]) << 8) | buffer[2];
		*z = (((int16_t)buffer[5]) << 8) | buffer[4];
	} else {
		*x = (((int16_t)buffer[0]) << 8) | buffer[1];
		*y = (((int16_t)buffer[2]) << 8) | buffer[3];
		*z = (((int16_t)buffer[4]) << 8) | buffer[5];
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movb (%rcx), %dil
addq $0x1, %rcx
movl $0xa8, %esi
movl $0x6, %edx
movq 0x2457f(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq (%rsp), %rax
movb 0x7(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x37a08
movq (%rsp), %rcx
movzbl 0x2(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x1(%rcx), %edx
orl %edx, %eax
movw %ax, %dx
movq 0x18(%rsp), %rax
movw %dx, (%rax)
movzbl 0x4(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x3(%rcx), %edx
orl %edx, %eax
movw %ax, %dx
movq 0x10(%rsp), %rax
movw %dx, (%rax)
movzbl 0x6(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x5(%rcx), %ecx
orl %ecx, %eax
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, (%rax)
jmp 0x37a57
movq (%rsp), %rcx
movzbl 0x1(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x2(%rcx), %edx
orl %edx, %eax
movw %ax, %dx
movq 0x18(%rsp), %rax
movw %dx, (%rax)
movzbl 0x3(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x4(%rcx), %edx
orl %edx, %eax
movw %ax, %dx
movq 0x10(%rsp), %rax
movw %dx, (%rax)
movzbl 0x5(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x6(%rcx), %ecx
orl %ecx, %eax
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, (%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: mrlordkaj[P]i2cdevlib-pi/L3GD20H/L3GD20H.cpp
// Function: L3GD20H::getAngularVelocityX()
int16_t L3GD20H::getAngularVelocityX() {
	I2Cdev::readBytes(devAddr, L3GD20H_RA_OUT_X_L | 0x80, 2, buffer);
	if (endianMode == L3GD20H_LITTLE_ENDIAN) {
		return (((int16_t)buffer[1]) << 8) | buffer[0];
	} else {
		return (((int16_t)buffer[0]) << 8) | buffer[1];
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq %rcx, (%rsp)
movb (%rcx), %dil
addq $0x1, %rcx
movl $0xa8, %esi
movl $0x2, %edx
movq 0x2448e(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq (%rsp), %rax
movb 0x7(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x37ac1
movq (%rsp), %rcx
movzbl 0x2(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x1(%rcx), %ecx
orl %ecx, %eax
movw %ax, 0x16(%rsp)
jmp 0x37ad8
movq (%rsp), %rcx
movzbl 0x1(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x2(%rcx), %ecx
orl %ecx, %eax
movw %ax, 0x16(%rsp)
movw 0x16(%rsp), %ax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/L3GD20H/L3GD20H.cpp
// Function: L3GD20H::getAngularVelocityY()
int16_t L3GD20H::getAngularVelocityY() {
	I2Cdev::readBytes(devAddr, L3GD20H_RA_OUT_Y_L | 0x80, 2, buffer);
	if (endianMode == L3GD20H_LITTLE_ENDIAN) {
		return (((int16_t)buffer[1]) << 8) | buffer[0];
	} else {
		return (((int16_t)buffer[0]) << 8) | buffer[1];
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq %rcx, (%rsp)
movb (%rcx), %dil
addq $0x1, %rcx
movl $0xaa, %esi
movl $0x2, %edx
movq 0x243fe(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq (%rsp), %rax
movb 0x7(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x37b51
movq (%rsp), %rcx
movzbl 0x2(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x1(%rcx), %ecx
orl %ecx, %eax
movw %ax, 0x16(%rsp)
jmp 0x37b68
movq (%rsp), %rcx
movzbl 0x1(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x2(%rcx), %ecx
orl %ecx, %eax
movw %ax, 0x16(%rsp)
movw 0x16(%rsp), %ax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/L3GD20H/L3GD20H.cpp
// Function: L3GD20H::getAngularVelocityZ()
int16_t L3GD20H::getAngularVelocityZ() {
	I2Cdev::readBytes(devAddr, L3GD20H_RA_OUT_Z_L | 0x80, 2, buffer);
	if (endianMode == L3GD20H_LITTLE_ENDIAN) {
		return (((int16_t)buffer[1]) << 8) | buffer[0];
	} else {
		return (((int16_t)buffer[0]) << 8) | buffer[1];
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq %rcx, (%rsp)
movb (%rcx), %dil
addq $0x1, %rcx
movl $0xac, %esi
movl $0x2, %edx
movq 0x2436e(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq (%rsp), %rax
movb 0x7(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x37be1
movq (%rsp), %rcx
movzbl 0x2(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x1(%rcx), %ecx
orl %ecx, %eax
movw %ax, 0x16(%rsp)
jmp 0x37bf8
movq (%rsp), %rcx
movzbl 0x1(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x2(%rcx), %ecx
orl %ecx, %eax
movw %ax, 0x16(%rsp)
movw 0x16(%rsp), %ax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/LM73/LM73.cpp
// Function: LM73::getTemp()
float LM73::getTemp() {
    uint16_t buf;
    int16_t temp;
    I2Cdev::readWord(devAddr, LM73_RA_TEMP, &buf);
    temp = buf;
    temp = (temp>>2);
    return 0.03125f * (float)temp;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %edi
movq 0x23290(%rip), %rax     # 0x5bf18
movzwl (%rax), %ecx
xorl %esi, %esi
leaq 0xe(%rsp), %rdx
callq 0x22c40
movw 0xe(%rsp), %ax
movw %ax, 0xc(%rsp)
movswl 0xc(%rsp), %eax
shrl $0x2, %eax
movw %ax, 0xc(%rsp)
movswl 0xc(%rsp), %eax
cvtsi2ss %eax, %xmm1
movss 0x123b9(%rip), %xmm0    # 0x4b078
mulss %xmm1, %xmm0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/LM73/LM73.cpp
// Function: LM73::setResolution(unsigned char)
void LM73::setResolution(uint8_t resolution) {
    if(10 < resolution && resolution < 15) {
        LM73::getCtrlStat();
        devCtrlStat.bit.RES = resolution - 11;
        LM73::setCtrlStat(devCtrlStat);
    }
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movzbl 0x1f(%rsp), %ecx
movl $0xa, %eax
cmpl %ecx, %eax
jge 0x38d3f
movzbl 0x1f(%rsp), %eax
cmpl $0xf, %eax
jge 0x38d3f
movq 0x8(%rsp), %rdi
callq 0x23050
movq 0x8(%rsp), %rdi
movl %eax, 0x18(%rsp)
movzbl 0x1f(%rsp), %eax
subl $0xb, %eax
movb %al, %cl
movb 0x8(%rdi), %al
andb $0x3, %cl
shlb $0x5, %cl
andb $-0x61, %al
orb %cl, %al
movb %al, 0x8(%rdi)
movl 0x8(%rdi), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %esi
callq 0x225d0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: mrlordkaj[P]i2cdevlib-pi/LSM303DLHC/LSM303DLHC.cpp
// Function: LSM303DLHC::testConnection()
bool LSM303DLHC::testConnection() {
    I2Cdev::readByte(devAddrA, LSM303DLHC_RA_CTRL_REG1_A, buffer);
    uint8_t origValA = buffer[0];
    I2Cdev::readByte(devAddrM, LSM303DLHC_RA_CRA_REG_M, buffer);
    uint8_t origValM = buffer[0];

    uint8_t zeros = 0b00000000;
    I2Cdev::writeByte(devAddrA, LSM303DLHC_RA_CTRL_REG1_A, zeros);
    I2Cdev::writeByte(devAddrM, LSM303DLHC_RA_CRA_REG_M, zeros);
    
    I2Cdev::readByte(devAddrA, LSM303DLHC_RA_CTRL_REG1_A, buffer);
    uint8_t newValA = buffer[0];
    I2Cdev::readByte(devAddrM, LSM303DLHC_RA_CRA_REG_M, buffer);
    uint8_t newValM = buffer[0];
    
    I2Cdev::writeByte(devAddrA, LSM303DLHC_RA_CTRL_REG1_A, origValA);
    I2Cdev::writeByte(devAddrM, LSM303DLHC_RA_CRA_REG_M, origValM);

    if ((newValM == zeros) and (newValA == zeros)) {
      return true;
    }
    return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdx
movq %rdx, 0x8(%rsp)
movb (%rdx), %cl
addq $0x2, %rdx
movl $0x20, %esi
movq 0x23113(%rip), %rax     # 0x5bf18
movzbl %cl, %edi
movzwl (%rax), %ecx
callq 0x22ce0
movq 0x8(%rsp), %rdx
movb 0x2(%rdx), %al
movb %al, 0x17(%rsp)
movb 0x1(%rdx), %cl
addq $0x2, %rdx
xorl %esi, %esi
movq 0x230ec(%rip), %rax     # 0x5bf18
movzbl %cl, %edi
movzwl (%rax), %ecx
callq 0x22ce0
movq 0x8(%rsp), %rax
movb 0x2(%rax), %cl
movb %cl, 0x16(%rsp)
movb $0x0, 0x15(%rsp)
movb (%rax), %al
movl $0x20, %esi
movzbl %al, %edi
movzbl 0x15(%rsp), %edx
callq 0x22ad0
movq 0x8(%rsp), %rax
movb 0x1(%rax), %al
xorl %esi, %esi
movzbl %al, %edi
movzbl 0x15(%rsp), %edx
callq 0x22ad0
movq 0x8(%rsp), %rdx
movb (%rdx), %cl
addq $0x2, %rdx
movl $0x20, %esi
movq 0x2308e(%rip), %rax     # 0x5bf18
movzbl %cl, %edi
movzwl (%rax), %ecx
callq 0x22ce0
movq 0x8(%rsp), %rdx
movb 0x2(%rdx), %al
movb %al, 0x14(%rsp)
movb 0x1(%rdx), %cl
addq $0x2, %rdx
xorl %esi, %esi
movq 0x23067(%rip), %rax     # 0x5bf18
movzbl %cl, %edi
movzwl (%rax), %ecx
callq 0x22ce0
movq 0x8(%rsp), %rax
movb 0x2(%rax), %cl
movb %cl, 0x13(%rsp)
movb (%rax), %al
movl $0x20, %esi
movzbl %al, %edi
movzbl 0x17(%rsp), %edx
callq 0x22ad0
movq 0x8(%rsp), %rax
movb 0x1(%rax), %al
xorl %esi, %esi
movzbl %al, %edi
movzbl 0x16(%rsp), %edx
callq 0x22ad0
movzbl 0x13(%rsp), %eax
movzbl 0x15(%rsp), %ecx
cmpl %ecx, %eax
jne 0x38f16
movzbl 0x14(%rsp), %eax
movzbl 0x15(%rsp), %ecx
cmpl %ecx, %eax
jne 0x38f16
movb $0x1, 0x27(%rsp)
jmp 0x38f1b
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/LSM303DLHC/LSM303DLHC.cpp
// Function: LSM303DLHC::setAccelOutputDataRate(unsigned short)
void LSM303DLHC::setAccelOutputDataRate(uint16_t rate) {
  uint8_t writeVal;
  
  if (rate == 0) {
    writeVal = LSM303DLHC_ODR_RATE_POWERDOWN;
  } else if (rate == 1) {
    writeVal = LSM303DLHC_ODR_RATE_1;
  } else if (rate == 10) {
    writeVal = LSM303DLHC_ODR_RATE_10;
  } else if (rate == 25) {
    writeVal = LSM303DLHC_ODR_RATE_25;
  } else if (rate == 50) {
    writeVal = LSM303DLHC_ODR_RATE_50;
  } else if (rate == 100) {
    writeVal = LSM303DLHC_ODR_RATE_100;
  } else if (rate == 200) {
    writeVal = LSM303DLHC_ODR_RATE_200;
  } else if (rate == 400) {
    writeVal = LSM303DLHC_ODR_RATE_400;
  } else if (rate == 1620) {
    writeVal = LSM303DLHC_ODR_RATE_1620_LP;
  } else if (rate == 1344) {
    writeVal = LSM303DLHC_ODR_RATE_1344_N_5376_LP;
  } else if (rate == 5376) {
    writeVal = LSM303DLHC_ODR_RATE_1344_N_5376_LP;
  }
  
  I2Cdev::writeBits(devAddrA, LSM303DLHC_RA_CTRL_REG1_A, LSM303DLHC_ODR_BIT,
    LSM303DLHC_ODR_LENGTH, writeVal); 
}

// Assembly:
subq $0x18, %rsp
movw %si, %ax
movq %rdi, 0x10(%rsp)
movw %ax, 0xe(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movzwl 0xe(%rsp), %eax
cmpl $0x0, %eax
jne 0x38f5e
movb $0x0, 0xd(%rsp)
jmp 0x3902d
movzwl 0xe(%rsp), %eax
cmpl $0x1, %eax
jne 0x38f72
movb $0x1, 0xd(%rsp)
jmp 0x3902b
movzwl 0xe(%rsp), %eax
cmpl $0xa, %eax
jne 0x38f86
movb $0x2, 0xd(%rsp)
jmp 0x39029
movzwl 0xe(%rsp), %eax
cmpl $0x19, %eax
jne 0x38f9a
movb $0x3, 0xd(%rsp)
jmp 0x39027
movzwl 0xe(%rsp), %eax
cmpl $0x32, %eax
jne 0x38fab
movb $0x4, 0xd(%rsp)
jmp 0x39025
movzwl 0xe(%rsp), %eax
cmpl $0x64, %eax
jne 0x38fbc
movb $0x5, 0xd(%rsp)
jmp 0x39023
movzwl 0xe(%rsp), %eax
cmpl $0xc8, %eax
jne 0x38fcf
movb $0x6, 0xd(%rsp)
jmp 0x39021
movzwl 0xe(%rsp), %eax
cmpl $0x190, %eax            # imm = 0x190
jne 0x38fe2
movb $0x7, 0xd(%rsp)
jmp 0x3901f
movzwl 0xe(%rsp), %eax
cmpl $0x654, %eax            # imm = 0x654
jne 0x38ff5
movb $0x8, 0xd(%rsp)
jmp 0x3901d
movzwl 0xe(%rsp), %eax
cmpl $0x540, %eax            # imm = 0x540
jne 0x39008
movb $0x9, 0xd(%rsp)
jmp 0x3901b
movzwl 0xe(%rsp), %eax
cmpl $0x1500, %eax           # imm = 0x1500
jne 0x39019
movb $0x9, 0xd(%rsp)
jmp 0x3901b
jmp 0x3901d
jmp 0x3901f
jmp 0x39021
jmp 0x39023
jmp 0x39025
jmp 0x39027
jmp 0x39029
jmp 0x3902b
jmp 0x3902d
movq (%rsp), %rax
movb (%rax), %al
movl $0x20, %esi
movl $0x7, %edx
movl $0x4, %ecx
movzbl %al, %edi
movzbl 0xd(%rsp), %r8d
callq 0x22ca0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/LSM303DLHC/LSM303DLHC.cpp
// Function: LSM303DLHC::getAccelOutputDataRate()
uint16_t LSM303DLHC::getAccelOutputDataRate() {
  I2Cdev::readBits(devAddrA, LSM303DLHC_RA_CTRL_REG1_A, LSM303DLHC_ODR_BIT,
    LSM303DLHC_ODR_LENGTH, buffer);
  uint8_t rate = buffer[0];
  
  if (rate == LSM303DLHC_ODR_RATE_POWERDOWN) {
    return 0;
  } else if (rate == LSM303DLHC_ODR_RATE_1) {
    return 1;
  } else if (rate == LSM303DLHC_ODR_RATE_10) {
    return 10;
  } else if (rate == LSM303DLHC_ODR_RATE_25) {
    return 25;
  } else if (rate == LSM303DLHC_ODR_RATE_50) {
    return 50;
  } else if (rate == LSM303DLHC_ODR_RATE_100) {
    return 100;
  } else if (rate == LSM303DLHC_ODR_RATE_200) {
    return 200;
  } else if (rate == LSM303DLHC_ODR_RATE_400) {
    return 400;
  } else if (rate == LSM303DLHC_ODR_RATE_1620_LP) {
    return 1620;
  } else if (rate == LSM303DLHC_ODR_RATE_1344_N_5376_LP) {
    return 1344;
  } else if (rate == LSM303DLHC_ODR_RATE_1344_N_5376_LP) {
    return 5376;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %r8
movq %r8, 0x8(%rsp)
movb (%r8), %dil
addq $0x2, %r8
movl $0x20, %esi
movl $0x7, %edx
movl $0x4, %ecx
movq 0x22e88(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r9d
callq 0x23150
movq 0x8(%rsp), %rax
movb 0x2(%rax), %al
movb %al, 0x17(%rsp)
movzbl 0x17(%rsp), %eax
cmpl $0x0, %eax
jne 0x390bf
movw $0x0, 0x26(%rsp)
jmp 0x3919f
movzbl 0x17(%rsp), %eax
cmpl $0x1, %eax
jne 0x390d5
movw $0x1, 0x26(%rsp)
jmp 0x3919f
movzbl 0x17(%rsp), %eax
cmpl $0x2, %eax
jne 0x390eb
movw $0xa, 0x26(%rsp)
jmp 0x3919f
movzbl 0x17(%rsp), %eax
cmpl $0x3, %eax
jne 0x39101
movw $0x19, 0x26(%rsp)
jmp 0x3919f
movzbl 0x17(%rsp), %eax
cmpl $0x4, %eax
jne 0x39117
movw $0x32, 0x26(%rsp)
jmp 0x3919f
movzbl 0x17(%rsp), %eax
cmpl $0x5, %eax
jne 0x3912a
movw $0x64, 0x26(%rsp)
jmp 0x3919f
movzbl 0x17(%rsp), %eax
cmpl $0x6, %eax
jne 0x3913d
movw $0xc8, 0x26(%rsp)
jmp 0x3919f
movzbl 0x17(%rsp), %eax
cmpl $0x7, %eax
jne 0x39150
movw $0x190, 0x26(%rsp)      # imm = 0x190
jmp 0x3919f
movzbl 0x17(%rsp), %eax
cmpl $0x8, %eax
jne 0x39163
movw $0x654, 0x26(%rsp)      # imm = 0x654
jmp 0x3919f
movzbl 0x17(%rsp), %eax
cmpl $0x9, %eax
jne 0x39176
movw $0x540, 0x26(%rsp)      # imm = 0x540
jmp 0x3919f
movzbl 0x17(%rsp), %eax
cmpl $0x9, %eax
jne 0x39189
movw $0x1500, 0x26(%rsp)     # imm = 0x1500
jmp 0x3919f
jmp 0x3918b
jmp 0x3918d
jmp 0x3918f
jmp 0x39191
jmp 0x39193
jmp 0x39195
jmp 0x39197
jmp 0x39199
jmp 0x3919b
jmp 0x3919d
ud2
movw 0x26(%rsp), %ax
addq $0x28, %rsp
retq
nopl (%rax)
// File: mrlordkaj[P]i2cdevlib-pi/LSM303DLHC/LSM303DLHC.cpp
// Function: LSM303DLHC::setAccelFullScale(unsigned char)
void LSM303DLHC::setAccelFullScale(uint8_t scale) {
  uint8_t writeBits;
  
  if (scale == 2) {
    writeBits = LSM303DLHC_FS_2;
  } else if (scale == 4) {
    writeBits = LSM303DLHC_FS_4;
  } else if (scale == 8) {
    writeBits = LSM303DLHC_FS_8;
  } else {
    writeBits = LSM303DLHC_FS_16;
  }

  I2Cdev::writeBits(devAddrA, LSM303DLHC_RA_CTRL_REG4_A, LSM303DLHC_FS_BIT, 
    LSM303DLHC_FS_LENGTH, writeBits);
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0x2, %eax
jne 0x39a2a
movb $0x0, 0xe(%rsp)
jmp 0x39a55
movzbl 0xf(%rsp), %eax
cmpl $0x4, %eax
jne 0x39a3b
movb $0x1, 0xe(%rsp)
jmp 0x39a53
movzbl 0xf(%rsp), %eax
cmpl $0x8, %eax
jne 0x39a4c
movb $0x2, 0xe(%rsp)
jmp 0x39a51
movb $0x3, 0xe(%rsp)
jmp 0x39a53
jmp 0x39a55
movq (%rsp), %rax
movb (%rax), %al
movl $0x23, %esi
movl $0x5, %edx
movl $0x2, %ecx
movzbl %al, %edi
movzbl 0xe(%rsp), %r8d
callq 0x22ca0
addq $0x18, %rsp
retq
nopl (%rax)
// File: mrlordkaj[P]i2cdevlib-pi/LSM303DLHC/LSM303DLHC.cpp
// Function: LSM303DLHC::getAccelFullScale()
uint8_t LSM303DLHC::getAccelFullScale() {
  I2Cdev::readBits(devAddrA, LSM303DLHC_RA_CTRL_REG4_A, 
    LSM303DLHC_FS_BIT, LSM303DLHC_FS_LENGTH, buffer);
  uint8_t readBits = buffer[0];
  
  if (readBits == LSM303DLHC_FS_2) {
    return 2;
  } else if (readBits == LSM303DLHC_FS_4) {
    return 4;
  } else if (readBits == LSM303DLHC_FS_8) {
    return 8;
  } else {
    return 16;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %r8
movq %r8, 0x8(%rsp)
movb (%r8), %dil
addq $0x2, %r8
movl $0x23, %esi
movl $0x5, %edx
movl $0x2, %ecx
movq 0x22468(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r9d
callq 0x23150
movq 0x8(%rsp), %rax
movb 0x2(%rax), %al
movb %al, 0x17(%rsp)
movzbl 0x17(%rsp), %eax
cmpl $0x0, %eax
jne 0x39ada
movb $0x2, 0x27(%rsp)
jmp 0x39b01
movzbl 0x17(%rsp), %eax
cmpl $0x1, %eax
jne 0x39aeb
movb $0x4, 0x27(%rsp)
jmp 0x39b01
movzbl 0x17(%rsp), %eax
cmpl $0x2, %eax
jne 0x39afc
movb $0x8, 0x27(%rsp)
jmp 0x39b01
movb $0x10, 0x27(%rsp)
movb 0x27(%rsp), %al
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/LSM303DLHC/LSM303DLHC.cpp
// Function: LSM303DLHC::getAcceleration(short*, short*, short*)
void LSM303DLHC::getAcceleration(int16_t* x, int16_t* y, int16_t* z) {
  I2Cdev::readBytes(devAddrA, LSM303DLHC_RA_OUT_X_L_A | 0x80, 6, buffer);
  if (endianMode == LSM303DLHC_LITTLE_ENDIAN) {
    *x = (((int16_t)buffer[1]) << 8) | buffer[0];
    *y = (((int16_t)buffer[3]) << 8) | buffer[2];
    *z = (((int16_t)buffer[5]) << 8) | buffer[4];
  } else {
    *x = (((int16_t)buffer[0]) << 8) | buffer[1];
    *y = (((int16_t)buffer[2]) << 8) | buffer[3];
    *z = (((int16_t)buffer[4]) << 8) | buffer[5];
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movb (%rcx), %dil
addq $0x2, %rcx
movl $0xa8, %esi
movl $0x6, %edx
movq 0x219ef(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq (%rsp), %rax
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x3a598
movq (%rsp), %rcx
movzbl 0x3(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x2(%rcx), %edx
orl %edx, %eax
movw %ax, %dx
movq 0x18(%rsp), %rax
movw %dx, (%rax)
movzbl 0x5(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x4(%rcx), %edx
orl %edx, %eax
movw %ax, %dx
movq 0x10(%rsp), %rax
movw %dx, (%rax)
movzbl 0x7(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x6(%rcx), %ecx
orl %ecx, %eax
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, (%rax)
jmp 0x3a5e7
movq (%rsp), %rcx
movzbl 0x2(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x3(%rcx), %edx
orl %edx, %eax
movw %ax, %dx
movq 0x18(%rsp), %rax
movw %dx, (%rax)
movzbl 0x4(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x5(%rcx), %edx
orl %edx, %eax
movw %ax, %dx
movq 0x10(%rsp), %rax
movw %dx, (%rax)
movzbl 0x6(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x7(%rcx), %ecx
orl %ecx, %eax
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, (%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: mrlordkaj[P]i2cdevlib-pi/LSM303DLHC/LSM303DLHC.cpp
// Function: LSM303DLHC::getAccelerationX()
int16_t LSM303DLHC::getAccelerationX() {
  I2Cdev::readBytes(devAddrA, LSM303DLHC_RA_OUT_X_L_A | 0x80, 2, buffer);
  if (endianMode == LSM303DLHC_LITTLE_ENDIAN) {
    return (((int16_t)buffer[1]) << 8) | buffer[0];
  } else {
    return (((int16_t)buffer[0]) << 8) | buffer[1];
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq %rcx, (%rsp)
movb (%rcx), %dil
addq $0x2, %rcx
movl $0xa8, %esi
movl $0x2, %edx
movq 0x218fe(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq (%rsp), %rax
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x3a651
movq (%rsp), %rcx
movzbl 0x3(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x2(%rcx), %ecx
orl %ecx, %eax
movw %ax, 0x16(%rsp)
jmp 0x3a668
movq (%rsp), %rcx
movzbl 0x2(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x3(%rcx), %ecx
orl %ecx, %eax
movw %ax, 0x16(%rsp)
movw 0x16(%rsp), %ax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/LSM303DLHC/LSM303DLHC.cpp
// Function: LSM303DLHC::getAccelerationY()
int16_t LSM303DLHC::getAccelerationY() {
  I2Cdev::readBytes(devAddrA, LSM303DLHC_RA_OUT_Y_L_A | 0x80, 2, buffer);
  if (endianMode == LSM303DLHC_LITTLE_ENDIAN) {
    return (((int16_t)buffer[1]) << 8) | buffer[0];
  } else {
    return (((int16_t)buffer[0]) << 8) | buffer[1];
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq %rcx, (%rsp)
movb (%rcx), %dil
addq $0x2, %rcx
movl $0xaa, %esi
movl $0x2, %edx
movq 0x2186e(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq (%rsp), %rax
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x3a6e1
movq (%rsp), %rcx
movzbl 0x3(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x2(%rcx), %ecx
orl %ecx, %eax
movw %ax, 0x16(%rsp)
jmp 0x3a6f8
movq (%rsp), %rcx
movzbl 0x2(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x3(%rcx), %ecx
orl %ecx, %eax
movw %ax, 0x16(%rsp)
movw 0x16(%rsp), %ax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/LSM303DLHC/LSM303DLHC.cpp
// Function: LSM303DLHC::getAccelerationZ()
int16_t LSM303DLHC::getAccelerationZ() {
  I2Cdev::readBytes(devAddrA, LSM303DLHC_RA_OUT_Z_L_A | 0x80, 2, buffer);
  if (endianMode == LSM303DLHC_LITTLE_ENDIAN) {
    return (((int16_t)buffer[1]) << 8) | buffer[0];
  } else {
    return (((int16_t)buffer[0]) << 8) | buffer[1];
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq %rcx, (%rsp)
movb (%rcx), %dil
addq $0x2, %rcx
movl $0xac, %esi
movl $0x2, %edx
movq 0x217de(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq (%rsp), %rax
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x3a771
movq (%rsp), %rcx
movzbl 0x3(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x2(%rcx), %ecx
orl %ecx, %eax
movw %ax, 0x16(%rsp)
jmp 0x3a788
movq (%rsp), %rcx
movzbl 0x2(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x3(%rcx), %ecx
orl %ecx, %eax
movw %ax, 0x16(%rsp)
movw 0x16(%rsp), %ax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/LSM303DLHC/LSM303DLHC.cpp
// Function: LSM303DLHC::setMagOutputDataRate(unsigned char)
void LSM303DLHC::setMagOutputDataRate(uint8_t rate){
  uint8_t writeBit;
  if (rate == 0){
    writeBit = LSM303DLHC_DO_RATE_0;
  } else if (rate == 1){
    writeBit = LSM303DLHC_DO_RATE_1;
  } else if (rate == 3){
    writeBit = LSM303DLHC_DO_RATE_3;
  } else if (rate == 7){
    writeBit = LSM303DLHC_DO_RATE_7;
  } else if (rate == 15){
    writeBit = LSM303DLHC_DO_RATE_15;
  } else if (rate == 30){
    writeBit = LSM303DLHC_DO_RATE_30;
  } else if (rate == 75){
    writeBit = LSM303DLHC_DO_RATE_75;
  } else if (rate == 220){
    writeBit = LSM303DLHC_DO_RATE_220;
  }

  I2Cdev::writeBits(devAddrM, LSM303DLHC_RA_CRA_REG_M, LSM303DLHC_DO_BIT,
    LSM303DLHC_DO_LENGTH, writeBit);
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0x0, %eax
jne 0x3bc2d
movb $0x0, 0xe(%rsp)
jmp 0x3bcb2
movzbl 0xf(%rsp), %eax
cmpl $0x1, %eax
jne 0x3bc3e
movb $0x1, 0xe(%rsp)
jmp 0x3bcb0
movzbl 0xf(%rsp), %eax
cmpl $0x3, %eax
jne 0x3bc4f
movb $0x2, 0xe(%rsp)
jmp 0x3bcae
movzbl 0xf(%rsp), %eax
cmpl $0x7, %eax
jne 0x3bc60
movb $0x3, 0xe(%rsp)
jmp 0x3bcac
movzbl 0xf(%rsp), %eax
cmpl $0xf, %eax
jne 0x3bc71
movb $0x4, 0xe(%rsp)
jmp 0x3bcaa
movzbl 0xf(%rsp), %eax
cmpl $0x1e, %eax
jne 0x3bc82
movb $0x5, 0xe(%rsp)
jmp 0x3bca8
movzbl 0xf(%rsp), %eax
cmpl $0x4b, %eax
jne 0x3bc93
movb $0x6, 0xe(%rsp)
jmp 0x3bca6
movzbl 0xf(%rsp), %eax
cmpl $0xdc, %eax
jne 0x3bca4
movb $0x7, 0xe(%rsp)
jmp 0x3bca6
jmp 0x3bca8
jmp 0x3bcaa
jmp 0x3bcac
jmp 0x3bcae
jmp 0x3bcb0
jmp 0x3bcb2
movq (%rsp), %rax
movb 0x1(%rax), %al
xorl %esi, %esi
movl $0x4, %edx
movl $0x3, %ecx
movzbl %al, %edi
movzbl 0xe(%rsp), %r8d
callq 0x22ca0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/LSM303DLHC/LSM303DLHC.cpp
// Function: LSM303DLHC::getMagOutputDataRate()
uint8_t LSM303DLHC::getMagOutputDataRate(){
  I2Cdev::readBits(devAddrM, LSM303DLHC_RA_CRA_REG_M, LSM303DLHC_DO_BIT,
    LSM303DLHC_DO_LENGTH, buffer);
  uint8_t rate = buffer[0];

  if (rate == LSM303DLHC_DO_RATE_0){
    return 0; 
  } else if (rate == LSM303DLHC_DO_RATE_1){
    return 1; 
  } else if (rate == LSM303DLHC_DO_RATE_3){
    return 3; 
  } else if (rate == LSM303DLHC_DO_RATE_7){
    return 7; 
  } else if (rate == LSM303DLHC_DO_RATE_15){
    return 15; 
  } else if (rate == LSM303DLHC_DO_RATE_30){
    return 30; 
  } else if (rate == LSM303DLHC_DO_RATE_75){
    return 75; 
  } else if (rate == LSM303DLHC_DO_RATE_220){
    return 220; 
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %r8
movq %r8, 0x8(%rsp)
movb 0x1(%r8), %dil
addq $0x2, %r8
xorl %esi, %esi
movl $0x4, %edx
movl $0x3, %ecx
movq 0x2020a(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r9d
callq 0x23150
movq 0x8(%rsp), %rax
movb 0x2(%rax), %al
movb %al, 0x17(%rsp)
movzbl 0x17(%rsp), %eax
cmpl $0x0, %eax
jne 0x3bd3b
movb $0x0, 0x27(%rsp)
jmp 0x3bdc2
movzbl 0x17(%rsp), %eax
cmpl $0x1, %eax
jne 0x3bd4c
movb $0x1, 0x27(%rsp)
jmp 0x3bdc2
movzbl 0x17(%rsp), %eax
cmpl $0x2, %eax
jne 0x3bd5d
movb $0x3, 0x27(%rsp)
jmp 0x3bdc2
movzbl 0x17(%rsp), %eax
cmpl $0x3, %eax
jne 0x3bd6e
movb $0x7, 0x27(%rsp)
jmp 0x3bdc2
movzbl 0x17(%rsp), %eax
cmpl $0x4, %eax
jne 0x3bd7f
movb $0xf, 0x27(%rsp)
jmp 0x3bdc2
movzbl 0x17(%rsp), %eax
cmpl $0x5, %eax
jne 0x3bd90
movb $0x1e, 0x27(%rsp)
jmp 0x3bdc2
movzbl 0x17(%rsp), %eax
cmpl $0x6, %eax
jne 0x3bda1
movb $0x4b, 0x27(%rsp)
jmp 0x3bdc2
movzbl 0x17(%rsp), %eax
cmpl $0x7, %eax
jne 0x3bdb2
movb $-0x24, 0x27(%rsp)
jmp 0x3bdc2
jmp 0x3bdb4
jmp 0x3bdb6
jmp 0x3bdb8
jmp 0x3bdba
jmp 0x3bdbc
jmp 0x3bdbe
jmp 0x3bdc0
ud2
movb 0x27(%rsp), %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/LSM303DLHC/LSM303DLHC.cpp
// Function: LSM303DLHC::setMagGain(unsigned short)
void LSM303DLHC::setMagGain(uint16_t gain){
  uint8_t writeBit;
  if (gain == 230){
    writeBit = LSM303DLHC_GN_230;
  } else if (gain == 330){
    writeBit = LSM303DLHC_GN_330;
  } else if (gain == 400){
    writeBit = LSM303DLHC_GN_400;
  } else if (gain == 450){
    writeBit = LSM303DLHC_GN_450;
  } else if (gain == 670){
    writeBit = LSM303DLHC_GN_670;
  } else if (gain == 855){
    writeBit = LSM303DLHC_GN_855;
  } else if (gain == 1100){
    writeBit = LSM303DLHC_GN_1100;
  }

  I2Cdev::writeBits(devAddrM, LSM303DLHC_RA_CRB_REG_M, LSM303DLHC_GN_BIT, LSM303DLHC_GN_LENGTH,
    writeBit);
}

// Assembly:
subq $0x18, %rsp
movw %si, %ax
movq %rdi, 0x10(%rsp)
movw %ax, 0xe(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movzwl 0xe(%rsp), %eax
cmpl $0xe6, %eax
jne 0x3bdfd
movb $0x7, 0xd(%rsp)
jmp 0x3be79
movzwl 0xe(%rsp), %eax
cmpl $0x14a, %eax            # imm = 0x14A
jne 0x3be10
movb $0x6, 0xd(%rsp)
jmp 0x3be77
movzwl 0xe(%rsp), %eax
cmpl $0x190, %eax            # imm = 0x190
jne 0x3be23
movb $0x5, 0xd(%rsp)
jmp 0x3be75
movzwl 0xe(%rsp), %eax
cmpl $0x1c2, %eax            # imm = 0x1C2
jne 0x3be36
movb $0x4, 0xd(%rsp)
jmp 0x3be73
movzwl 0xe(%rsp), %eax
cmpl $0x29e, %eax            # imm = 0x29E
jne 0x3be49
movb $0x3, 0xd(%rsp)
jmp 0x3be71
movzwl 0xe(%rsp), %eax
cmpl $0x357, %eax            # imm = 0x357
jne 0x3be5c
movb $0x2, 0xd(%rsp)
jmp 0x3be6f
movzwl 0xe(%rsp), %eax
cmpl $0x44c, %eax            # imm = 0x44C
jne 0x3be6d
movb $0x1, 0xd(%rsp)
jmp 0x3be6f
jmp 0x3be71
jmp 0x3be73
jmp 0x3be75
jmp 0x3be77
jmp 0x3be79
movq (%rsp), %rax
movb 0x1(%rax), %al
movl $0x1, %esi
movl $0x7, %edx
movl $0x3, %ecx
movzbl %al, %edi
movzbl 0xd(%rsp), %r8d
callq 0x22ca0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/LSM303DLHC/LSM303DLHC.cpp
// Function: LSM303DLHC::getMagGain()
uint16_t LSM303DLHC::getMagGain(){
  I2Cdev::readBits(devAddrM, LSM303DLHC_RA_CRB_REG_M, LSM303DLHC_GN_BIT, LSM303DLHC_GN_LENGTH,
    buffer);
  uint8_t gain = buffer[0];
  if (gain == LSM303DLHC_GN_230){
    return 230; 
  } else if (gain == LSM303DLHC_GN_330){
    return 330; 
  } else if (gain == LSM303DLHC_GN_400){
    return 400; 
  } else if (gain == LSM303DLHC_GN_450){
    return 450; 
  } else if (gain == LSM303DLHC_GN_670){
    return 670; 
  } else if (gain == LSM303DLHC_GN_855){
    return 855; 
  } else if (gain == LSM303DLHC_GN_1100){
    return 1100; 
  } 
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %r8
movq %r8, 0x8(%rsp)
movb 0x1(%r8), %dil
addq $0x2, %r8
movl $0x1, %esi
movl $0x7, %edx
movl $0x3, %ecx
movq 0x20037(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r9d
callq 0x23150
movq 0x8(%rsp), %rax
movb 0x2(%rax), %al
movb %al, 0x17(%rsp)
movzbl 0x17(%rsp), %eax
cmpl $0x7, %eax
jne 0x3bf10
movw $0xe6, 0x26(%rsp)
jmp 0x3bf90
movzbl 0x17(%rsp), %eax
cmpl $0x6, %eax
jne 0x3bf23
movw $0x14a, 0x26(%rsp)      # imm = 0x14A
jmp 0x3bf90
movzbl 0x17(%rsp), %eax
cmpl $0x5, %eax
jne 0x3bf36
movw $0x190, 0x26(%rsp)      # imm = 0x190
jmp 0x3bf90
movzbl 0x17(%rsp), %eax
cmpl $0x4, %eax
jne 0x3bf49
movw $0x1c2, 0x26(%rsp)      # imm = 0x1C2
jmp 0x3bf90
movzbl 0x17(%rsp), %eax
cmpl $0x3, %eax
jne 0x3bf5c
movw $0x29e, 0x26(%rsp)      # imm = 0x29E
jmp 0x3bf90
movzbl 0x17(%rsp), %eax
cmpl $0x2, %eax
jne 0x3bf6f
movw $0x357, 0x26(%rsp)      # imm = 0x357
jmp 0x3bf90
movzbl 0x17(%rsp), %eax
cmpl $0x1, %eax
jne 0x3bf82
movw $0x44c, 0x26(%rsp)      # imm = 0x44C
jmp 0x3bf90
jmp 0x3bf84
jmp 0x3bf86
jmp 0x3bf88
jmp 0x3bf8a
jmp 0x3bf8c
jmp 0x3bf8e
ud2
movw 0x26(%rsp), %ax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/LSM303DLHC/LSM303DLHC.cpp
// Function: LSM303DLHC::getMag(short*, short*, short*)
void LSM303DLHC::getMag(int16_t* x, int16_t* y, int16_t* z){
  I2Cdev::readBytes(devAddrM, LSM303DLHC_RA_OUT_X_H_M, 6, buffer);
  *x = ((((int16_t)buffer[0]) << 8) | buffer[1]);
  *z = ((((int16_t)buffer[2]) << 8) | buffer[3]);
  *y = ((((int16_t)buffer[4]) << 8) | buffer[5]);

}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movb 0x1(%rcx), %dil
addq $0x2, %rcx
movl $0x3, %esi
movl $0x6, %edx
movq 0x1feae(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq (%rsp), %rcx
movzbl 0x2(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x3(%rcx), %edx
orl %edx, %eax
movw %ax, %dx
movq 0x18(%rsp), %rax
movw %dx, (%rax)
movzbl 0x4(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x5(%rcx), %edx
orl %edx, %eax
movw %ax, %dx
movq 0x8(%rsp), %rax
movw %dx, (%rax)
movzbl 0x6(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x7(%rcx), %ecx
orl %ecx, %eax
movw %ax, %cx
movq 0x10(%rsp), %rax
movw %cx, (%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/MPR121/MPR121.cpp
// Function: MPR121::getTouchStatus(unsigned char)
bool MPR121::getTouchStatus(uint8_t channel) {
  const uint8_t statusReg = (channel < 8) ? ELE0_ELE7_TOUCH_STATUS : ELE8_ELE11_ELEPROX_TOUCH_STATUS;
  uint8_t buf = 0;
  I2Cdev::readByte(m_devAddr, statusReg, &buf);
  const bool touchActive = (channel < 8) ? (buf & (1 << channel)) > 0 : (buf & (1 << (channel - 8))) > 0;
  return touchActive;
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movzbl 0xf(%rsp), %esi
movl $0x1, %ecx
xorl %edx, %edx
cmpl $0x8, %esi
cmovll %edx, %ecx
movb %cl, 0xe(%rsp)
movb $0x0, 0xd(%rsp)
movb (%rax), %sil
movb 0xe(%rsp), %cl
leaq 0xd(%rsp), %rdx
movq 0x1f7f5(%rip), %rax     # 0x5bf18
movzbl %sil, %edi
movzbl %cl, %esi
movzwl (%rax), %ecx
callq 0x22ce0
movzbl 0xf(%rsp), %eax
cmpl $0x8, %eax
jge 0x3c75d
movzbl 0xd(%rsp), %eax
movzbl 0xf(%rsp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setg %al
movb %al, 0xb(%rsp)
jmp 0x3c77f
movzbl 0xd(%rsp), %eax
movzbl 0xf(%rsp), %ecx
subl $0x8, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setg %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
andb $0x1, %al
movb %al, 0xc(%rsp)
movb 0xc(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/MPR121/MPR121.cpp
// Function: MPR121::getTouchStatus()
uint16_t MPR121::getTouchStatus() {
  uint16_t statusBuf;
  uint8_t buf;
  I2Cdev::readByte(m_devAddr, ELE0_ELE7_TOUCH_STATUS, &buf);
  statusBuf = buf;
  I2Cdev::readByte(m_devAddr, ELE8_ELE11_ELEPROX_TOUCH_STATUS, &buf);
  statusBuf += (buf << 8);
  return statusBuf;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movb (%rax), %cl
xorl %esi, %esi
leaq 0xd(%rsp), %rdx
movq 0x1f756(%rip), %rax     # 0x5bf18
movzbl %cl, %edi
movzwl (%rax), %ecx
callq 0x22ce0
movq (%rsp), %rax
movzbl 0xd(%rsp), %ecx
movw %cx, 0xe(%rsp)
movb (%rax), %cl
movl $0x1, %esi
leaq 0xd(%rsp), %rdx
movq 0x1f72a(%rip), %rax     # 0x5bf18
movzbl %cl, %edi
movzwl (%rax), %ecx
callq 0x22ce0
movzbl 0xd(%rsp), %ecx
shll $0x8, %ecx
movzwl 0xe(%rsp), %eax
addl %ecx, %eax
movw %ax, 0xe(%rsp)
movw 0xe(%rsp), %ax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/MPR121/MPR121.cpp
// Function: MPR121::serviceCallbacks()
void MPR121::serviceCallbacks() {
  for (uint8_t channel = 0; channel < NUM_CHANNELS; channel++) { 
    bool touchStatus = getTouchStatus(channel);
    if (touchStatus != m_prevTouchStatus[channel]) {
      for (uint8_t type = 0; type < NUM_EVENTS; type++) { 
        const CallbackPtrType cb = touchStatus ? m_callbackMap[channel][TOUCHED] : m_callbackMap[channel][RELEASED]; 
        if (cb != 0) {
          cb();           
        }
      }
      m_prevTouchStatus[channel] = touchStatus; 
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movb $0x0, 0x1f(%rsp)
movzbl 0x1f(%rsp), %eax
cmpl $0xc, %eax
jge 0x3c960
movq 0x8(%rsp), %rdi
movzbl 0x1f(%rsp), %esi
callq 0x22750
movq 0x8(%rsp), %rcx
andb $0x1, %al
movb %al, 0x1e(%rsp)
movb 0x1e(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movzbl 0x1f(%rsp), %edx
movb 0xc8(%rcx,%rdx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x3c94f
movb $0x0, 0x1d(%rsp)
movzbl 0x1d(%rsp), %eax
cmpl $0x2, %eax
jge 0x3c937
testb $0x1, 0x1e(%rsp)
je 0x3c8f7
movq 0x8(%rsp), %rax
addq $0x8, %rax
movzbl 0x1f(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, (%rsp)
jmp 0x3c914
movq 0x8(%rsp), %rax
addq $0x8, %rax
movzbl 0x1f(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x3c929
callq *0x10(%rsp)
jmp 0x3c92b
movb 0x1d(%rsp), %al
addb $0x1, %al
movb %al, 0x1d(%rsp)
jmp 0x3c8c8
movq 0x8(%rsp), %rax
movb 0x1e(%rsp), %dl
movzbl 0x1f(%rsp), %ecx
andb $0x1, %dl
movb %dl, 0xc8(%rax,%rcx)
jmp 0x3c951
movb 0x1f(%rsp), %al
addb $0x1, %al
movb %al, 0x1f(%rsp)
jmp 0x3c878
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: mrlordkaj[P]i2cdevlib-pi/MPU6050/MPU6050.cpp
// Function: MPU6050::initialize()
void MPU6050::initialize() {
    setClockSource(MPU6050_CLOCK_PLL_XGYRO);
    setFullScaleGyroRange(MPU6050_GYRO_FS_250);
    setFullScaleAccelRange(MPU6050_ACCEL_FS_2);
    setSleepEnabled(false); // thanks to Jack Elston for pointing this one out!
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x1, %esi
callq 0x22ea0
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x22690
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x22440
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x22160
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/MPU6050/MPU6050.cpp
// Function: MPU6050::getMotion6(short*, short*, short*, short*, short*, short*)
void MPU6050::getMotion6(int16_t* ax, int16_t* ay, int16_t* az, int16_t* gx, int16_t* gy, int16_t* gz) {
    I2Cdev::readBytes(devAddr, MPU6050_RA_ACCEL_XOUT_H, 14, buffer);
    *ax = (((int16_t)buffer[0]) << 8) | buffer[1];
    *ay = (((int16_t)buffer[2]) << 8) | buffer[3];
    *az = (((int16_t)buffer[4]) << 8) | buffer[5];
    *gx = (((int16_t)buffer[8]) << 8) | buffer[9];
    *gy = (((int16_t)buffer[10]) << 8) | buffer[11];
    *gz = (((int16_t)buffer[12]) << 8) | buffer[13];
}

// Assembly:
subq $0x38, %rsp
movq 0x40(%rsp), %rax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, (%rsp)
movb (%rcx), %dil
addq $0x1, %rcx
movl $0x3b, %esi
movl $0xe, %edx
movq 0x1cb50(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzwl (%rax), %r8d
callq 0x22b50
movq (%rsp), %rcx
movzbl 0x1(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x2(%rcx), %edx
orl %edx, %eax
movw %ax, %dx
movq 0x28(%rsp), %rax
movw %dx, (%rax)
movzbl 0x3(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x4(%rcx), %edx
orl %edx, %eax
movw %ax, %dx
movq 0x20(%rsp), %rax
movw %dx, (%rax)
movzbl 0x5(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0x6(%rcx), %edx
orl %edx, %eax
movw %ax, %dx
movq 0x18(%rsp), %rax
movw %dx, (%rax)
movzbl 0x9(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0xa(%rcx), %edx
orl %edx, %eax
movw %ax, %dx
movq 0x10(%rsp), %rax
movw %dx, (%rax)
movzbl 0xb(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0xc(%rcx), %edx
orl %edx, %eax
movw %ax, %dx
movq 0x8(%rsp), %rax
movw %dx, (%rax)
movzbl 0xd(%rcx), %eax
cwtl
shll $0x8, %eax
movzbl 0xe(%rcx), %ecx
orl %ecx, %eax
movw %ax, %cx
movq 0x40(%rsp), %rax
movw %cx, (%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/MPU6050/MPU6050.cpp
// Function: MPU6050::getSlaveDelayEnabled(unsigned char)
bool MPU6050::getSlaveDelayEnabled(uint8_t num) {
    // MPU6050_DELAYCTRL_I2C_SLV4_DLY_EN_BIT is 4, SLV3 is 3, etc.
    if (num > 4) return 0;
    I2Cdev::readBit(devAddr, MPU6050_RA_I2C_MST_DELAY_CTRL, num, buffer);
    return buffer[0];
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movzbl 0x17(%rsp), %eax
cmpl $0x4, %eax
jle 0x3fc8b
movb $0x0, 0x27(%rsp)
jmp 0x3fcc9
movq 0x8(%rsp), %rcx
movb (%rcx), %dil
movb 0x17(%rsp), %dl
addq $0x1, %rcx
movl $0x67, %esi
movq 0x1c271(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzbl %dl, %edx
movzwl (%rax), %r8d
callq 0x23320
movq 0x8(%rsp), %rax
cmpb $0x0, 0x1(%rax)
setne %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/MPU6050/MPU6050.cpp
// Function: MPU6050::getFIFOBytes(unsigned char*, unsigned char)
void MPU6050::getFIFOBytes(uint8_t *data, uint8_t length) {
    if(length > 0){
        I2Cdev::readBytes(devAddr, MPU6050_RA_FIFO_R_W, length, data);
    } else {
    	*data = 0;
    }
}

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movzbl 0x17(%rsp), %eax
cmpl $0x0, %eax
jle 0x407f7
movq 0x8(%rsp), %rax
movb (%rax), %dil
movb 0x17(%rsp), %dl
movq 0x18(%rsp), %rcx
movl $0x74, %esi
movq 0x1b733(%rip), %rax     # 0x5bf18
movzbl %dil, %edi
movzbl %dl, %edx
movzwl (%rax), %r8d
callq 0x22b50
jmp 0x407ff
movq 0x18(%rsp), %rax
movb $0x0, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mrlordkaj[P]i2cdevlib-pi/MPU6050/MPU6050.cpp
// Function: MPU6050::setMemoryBank(unsigned char, bool, bool)
void MPU6050::setMemoryBank(uint8_t bank, bool prefetchEnabled, bool userBank) {
    bank &= 0x1F;
    if (userBank) bank |= 0x20;
    if (prefetchEnabled) bank |= 0x40;
    I2Cdev::writeByte(devAddr, MPU6050_RA_BANK_SEL, bank);
}

// Assembly:
subq $0x18, %rsp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, 0x10(%rsp)
movb %dl, 0xf(%rsp)
andb $0x1, %cl
movb %cl, 0xe(%rsp)
andb $0x1, %al
movb %al, 0xd(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movzbl 0xf(%rsp), %eax
andl $0x1f, %eax
movb %al, 0xf(%rsp)
testb $0x1, 0xd(%rsp)
je 0x41669
movzbl 0xf(%rsp), %eax
orl $0x20, %eax
movb %al, 0xf(%rsp)
testb $0x1, 0xe(%rsp)
je 0x4167c
movzbl 0xf(%rsp), %eax
orl $0x40, %eax
movb %al, 0xf(%rsp)
movq (%rsp), %rax
movb (%rax), %al
movl $0x6d, %esi
movzbl %al, %edi
movzbl 0xf(%rsp), %edx
callq 0x22ad0
addq $0x18, %rsp
retq
nopl (%rax)