LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/tests/string.c
// Function: test5
static int _test5(String const * string, String const * key, ssize_t expected)
{
	ssize_t res;

	/* string_index */
	printf("%s: Testing %s\n", PROGNAME, "string_index()");
	if((res = string_index(string, key)) != expected)
	{
		printf("%s: %s, %s, %zd: Test failed (expected: %zd)\n",
				PROGNAME, string, key, res, expected);
		return 2;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0x45f(%rip), %rdi       # 0x206a
leaq 0x468(%rip), %rsi       # 0x207a
leaq 0x4f0(%rip), %rdx       # 0x2109
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1030
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
je 0x1c65
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x20(%rbp), %r9
leaq 0x4ca(%rip), %rdi       # 0x2118
leaq 0x425(%rip), %rsi       # 0x207a
movb $0x0, %al
callq 0x1090
movl $0x2, -0x4(%rbp)
jmp 0x1c6c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/tests/string.c
// Function: test6
static int _test6(String const * string, String const * key, ssize_t expected)
{
	ssize_t res;

	/* string_rindex */
	printf("%s: Testing %s\n", PROGNAME, "string_rindex()");
	if((res = string_rindex(string, key)) != expected)
	{
		printf("%s: %s, %s, %zd: Test failed (expected: %zd)\n",
				PROGNAME, string, key, res, expected);
		return 2;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0x3cf(%rip), %rdi       # 0x206a
leaq 0x3d8(%rip), %rsi       # 0x207a
leaq 0x49d(%rip), %rdx       # 0x2146
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10a0
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
je 0x1cf5
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x20(%rbp), %r9
leaq 0x43a(%rip), %rdi       # 0x2118
leaq 0x395(%rip), %rsi       # 0x207a
movb $0x0, %al
callq 0x1090
movl $0x2, -0x4(%rbp)
jmp 0x1cfc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/tests/string.c
// Function: test7
static int _test7(String const * string, size_t length,
		String const * expected)
{
	int ret = 0;
	String * s;

	printf("%s: Testing %s\n", PROGNAME, "string_new_length()");
	if((s = string_new_length(string, length)) == NULL)
		return 2;
	if(string_compare(s, expected) != 0)
	{
		printf("%s: %s, %zu, \"%s\": Test failed (expected: \"%s\")\n",
				PROGNAME, string, length, s, expected);
		ret = 2;
	}
	string_delete(s);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
leaq 0x338(%rip), %rdi       # 0x206a
leaq 0x341(%rip), %rsi       # 0x207a
leaq 0x416(%rip), %rdx       # 0x2156
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1040
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x1d67
movl $0x2, -0x4(%rbp)
jmp 0x1db4
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1070
cmpl $0x0, %eax
je 0x1da5
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x20(%rbp), %r9
leaq 0x3da(%rip), %rdi       # 0x216a
leaq 0x2e3(%rip), %rsi       # 0x207a
movb $0x0, %al
callq 0x1090
movl $0x2, -0x24(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1080
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/tests/string.c
// Function: test8
static int _test8(String const * string, String const * expected)
{
	int ret = 0;
	String * s;

	printf("%s: Testing %s\n", PROGNAME, "string_tolower()");
	if((s = string_new(string)) == NULL)
		return 2;
	string_tolower(s);
	if(string_compare(s, expected) != 0)
	{
		printf("%s: %s, \"%s\": Test failed (expected: \"%s\")\n",
				PROGNAME, string, s, expected);
		ret = 2;
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
leaq 0x28c(%rip), %rdi       # 0x206a
leaq 0x295(%rip), %rsi       # 0x207a
leaq 0x3af(%rip), %rdx       # 0x219b
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rdi
callq 0x1050
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x1e0f
movl $0x2, -0x4(%rbp)
jmp 0x1e58
movq -0x28(%rbp), %rdi
callq 0x10e0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1070
cmpl $0x0, %eax
je 0x1e52
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %r8
leaq 0x36f(%rip), %rdi       # 0x21ac
leaq 0x236(%rip), %rsi       # 0x207a
movb $0x0, %al
callq 0x1090
movl $0x2, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/tests/string.c
// Function: test9
static int _test9(String const * string, String const * expected)
{
	int ret = 0;
	String * s;

	printf("%s: Testing %s\n", PROGNAME, "string_toupper()");
	if((s = string_new(string)) == NULL)
		return 2;
	string_toupper(s);
	if(string_compare(s, expected) != 0)
	{
		printf("%s: %s, \"%s\": Test failed (expected: \"%s\")\n",
				PROGNAME, string, s, expected);
		ret = 2;
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
leaq 0x1dc(%rip), %rdi       # 0x206a
leaq 0x1e5(%rip), %rsi       # 0x207a
leaq 0x33c(%rip), %rdx       # 0x21d8
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rdi
callq 0x1050
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x1ebf
movl $0x2, -0x4(%rbp)
jmp 0x1f08
movq -0x28(%rbp), %rdi
callq 0x10d0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1070
cmpl $0x0, %eax
je 0x1f02
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %r8
leaq 0x2bf(%rip), %rdi       # 0x21ac
leaq 0x186(%rip), %rsi       # 0x207a
movb $0x0, %al
callq 0x1090
movl $0x2, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/shellaes128v1d5n64/ref/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(
                         unsigned char *m, unsigned long long *mlen,
                         unsigned char *nsec,
                         const unsigned char *c, unsigned long long clen,
                         const unsigned char *ad, unsigned long long adlen,
                         const unsigned char *npub,
                         const unsigned char *k)
{
    int flag;

    *mlen=clen-CRYPTO_ABYTES;

    flag=shellaesDec(k, npub, ad, adlen, c, clen, m, *mlen);

 //   (void) nsec;

    if(flag!=0){
        return 0;
    }
    else{
        return -1;
    }
}

// Assembly:
subq $0x58, %rsp
movq 0x70(%rsp), %rax
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq %r9, 0x20(%rsp)
movq 0x28(%rsp), %rcx
subq $0x10, %rcx
movq 0x40(%rsp), %rax
movq %rcx, (%rax)
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x60(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x28(%rsp), %r9
movq 0x48(%rsp), %r10
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x2090
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x5090
movl $0x0, 0x54(%rsp)
jmp 0x5098
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/shellaes128v1d5n64/ref/shellaes.c
// Function: printf_byte_string
void printf_byte_string(const u8 b[], unsigned long long int blen){
    unsigned long long int i;

    for(i=0; i<blen; ++i){
        printf("%3x", b[i]);

        if(i%16==15&&i!=0){
            printf("\n");
        }
    }
    printf("\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x511f
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x8f4b(%rip), %rdi      # 0xe030
movb $0x0, %al
callq 0x2050
movq (%rsp), %rax
andq $0xf, %rax
cmpq $0xf, %rax
jne 0x510f
cmpq $0x0, (%rsp)
je 0x510f
leaq 0x8f2c(%rip), %rdi      # 0xe034
movb $0x0, %al
callq 0x2050
jmp 0x5111
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x50c6
leaq 0x8f0e(%rip), %rdi      # 0xe034
movb $0x0, %al
callq 0x2050
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/shellaes128v1d5n64/ref/shellaes.c
// Function: checksum_state_string
void checksum_state_string(const u8 byte1[], u8 checksum[], unsigned long long int blen){
    memset(checksum, 0x00, 16);

    while(blen!=0){
        xor_byte_string(byte1, checksum, 16);
        byte1+=16;
        blen-=16;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2070
cmpq $0x0, (%rsp)
je 0x51fa
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x10, %edx
callq 0x2240
movq 0x10(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
movq (%rsp), %rax
subq $0x10, %rax
movq %rax, (%rsp)
jmp 0x51c3
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/shellaes128v1d5n64/ref/shellaes.c
// Function: double_mask
void double_mask(u8 maskstate[]){
    int i;
    u8 msb;
    u8 tempbyte;

    msb=(maskstate[0] & 0x80)?1:0;

    u8 carry=0;

    for(i=15; i>=0; --i){
        tempbyte=maskstate[i];
        maskstate[i]=(tempbyte<<1)|carry;
        carry=tempbyte>>7;
    }

    if(msb){
        maskstate[15]^=0x87;
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movzbl (%rax), %edx
andl $0x80, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, -0xd(%rsp)
movb $0x0, -0xf(%rsp)
movl $0xf, -0xc(%rsp)
cmpl $0x0, -0xc(%rsp)
jl 0x527f
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, -0xe(%rsp)
movzbl -0xe(%rsp), %eax
shll %eax
movzbl -0xf(%rsp), %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
movb %dl, (%rax,%rcx)
movzbl -0xe(%rsp), %eax
sarl $0x7, %eax
movb %al, -0xf(%rsp)
movl -0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x5231
cmpb $0x0, -0xd(%rsp)
je 0x5298
movq -0x8(%rsp), %rax
movzbl 0xf(%rax), %ecx
xorl $0x87, %ecx
movb %cl, 0xf(%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/shellaes128v1d5n64/ref/shellaes.c
// Function: MIX
void MIX(u8 byte1[], u8 byte2[], unsigned int blen){
    u8 temp[blen];
    u8 tempbyte;
    int i;
    u8 carry;

    memcpy(temp, byte1, blen);
    xor_byte_string(byte2, temp, blen);

    /*left rotate temp[] by one bit*/
    carry=temp[0]>>7;
    for(i=blen-1; i>=0; --i){
        tempbyte=temp[i];
        temp[i]=tempbyte<<1;
        temp[i]|=carry;
        carry=tempbyte>>7;
    }

    xor_byte_string(temp, byte1, blen);
    xor_byte_string(temp, byte2, blen);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x20(%rbp)
movq %rax, %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rdi
subq %rcx, %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rsp
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x2270
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x2240
movq -0x40(%rbp), %rax
movzbl (%rax), %eax
sarl $0x7, %eax
movb %al, -0x31(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jl 0x5358
movq -0x40(%rbp), %rax
movslq -0x30(%rbp), %rcx
movb (%rax,%rcx), %cl
movb %cl, -0x29(%rbp)
movzbl -0x29(%rbp), %ecx
shll %ecx
movb %cl, %dl
movslq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
movzbl -0x31(%rbp), %esi
movslq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %edx
orl %esi, %edx
movb %dl, (%rax,%rcx)
movzbl -0x29(%rbp), %eax
sarl $0x7, %eax
movb %al, -0x31(%rbp)
movl -0x30(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x530f
movq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x2240
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x2240
movq -0x20(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/shellaes128v1d5n64/ref/shellaes.c
// Function: XEXLayerEnc
void XEXLayerEnc(const u32 rk[], const u8 Lprime[], const u8 Z[], u8 C[], unsigned long long int ctlen){

    u8 mask[16];
    u8 temp[16];
    u8 ct[16];

    memcpy(mask, Lprime, 16);

    while(ctlen!=0){
        double_mask(mask);

        memcpy(temp, Z, 16);

        xor_byte_string(mask, temp, 16);
        aesEncrypt(rk, temp, ct);
        xor_byte_string(mask, ct, 16);
        memcpy(C, ct, 16);

        C+=16;
        Z+=16;
        ctlen-=16;
    }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x62fb
leaq 0x20(%rsp), %rdi
callq 0x21e0
movq 0x40(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x10, %edx
callq 0x2240
movq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %rsp, %rdx
callq 0x2200
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movl $0x10, %edx
callq 0x2240
movq 0x38(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x38(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x40(%rsp)
movq 0x30(%rsp), %rax
subq $0x10, %rax
movq %rax, 0x30(%rsp)
jmp 0x6253
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/shellaes128v1d5n64/ref/shellaes.c
// Function: tagGen
void tagGen(const u32 rk[], const u8 checksum[], const u8 Lprime[], const u8 U[], const u8 F[], u8 T[], unsigned long long int ptlen){
    u8 mask1[16], mask2[16];
    u8 temp[16];

    /*generate 3*Lprime and 7*Lprime and store them in mask1[] and mask2[] respectively*/
    memcpy(mask1, Lprime, 16);
    double_mask(mask1);
    memcpy(mask2, mask1, 16);
    xor_byte_string(Lprime, mask1, 16);

    double_mask(mask2);
    xor_byte_string(mask1, mask2, 16);

    /*generate 2^{lm+1}*3*Lprime and 2^{lm+1}*7*Lprime and store them in mask1[] and mask2[] respectively*/
    while(ptlen!=0){
        double_mask(mask1);
        double_mask(mask2);
        ptlen-=16;
    }
    double_mask(mask1);
    double_mask(mask2);

    /*produce the tag value*/
    xor_byte_string(checksum, mask1, 16);

    aesEncrypt(rk, mask1, temp);
    xor_byte_string(U, temp, 16);
    xor_byte_string(mask2, temp, 16);

    aesEncrypt(rk, temp, T);
    xor_byte_string(mask2, T, 16);
    xor_byte_string(F, T, 16);
}

// Assembly:
subq $0x68, %rsp
movq 0x70(%rsp), %rax
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x21e0
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x10, %edx
callq 0x2240
leaq 0x10(%rsp), %rdi
callq 0x21e0
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x10, %edx
callq 0x2240
cmpq $0x0, 0x70(%rsp)
je 0x6499
leaq 0x20(%rsp), %rdi
callq 0x21e0
leaq 0x10(%rsp), %rdi
callq 0x21e0
movq 0x70(%rsp), %rax
subq $0x10, %rax
movq %rax, 0x70(%rsp)
jmp 0x646d
leaq 0x20(%rsp), %rdi
callq 0x21e0
leaq 0x10(%rsp), %rdi
callq 0x21e0
movq 0x58(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x10, %edx
callq 0x2240
movq 0x60(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
callq 0x2200
movq 0x48(%rsp), %rdi
movq %rsp, %rsi
movl $0x10, %edx
callq 0x2240
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
movl $0x10, %edx
callq 0x2240
movq 0x60(%rsp), %rdi
movq %rsp, %rsi
movq 0x38(%rsp), %rdx
callq 0x2200
leaq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl $0x10, %edx
callq 0x2240
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl $0x10, %edx
callq 0x2240
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/shellaes128v1d5n64/ref/shellaes.c
// Function: tagVef
int tagVef(const u32 rk[], const u8 checksum[], const u8 Lprime[], const u8 U[], const u8 F[], const u8 T[], unsigned long long int ptlen){

    u8 tempT[16];
    int flag=1;
    int i;

    tagGen(rk, checksum, Lprime, U, F, tempT, ptlen);

    for(i=0; i<16; ++i){
        if(tempT[i]!=T[i]){
            flag=0;
        }
    }
    return flag;
}

// Assembly:
subq $0x58, %rsp
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movl $0x1, 0xc(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
leaq 0x10(%rsp), %r9
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
callq 0x2080
movl $0x0, 0x8(%rsp)
cmpl $0x10, 0x8(%rsp)
jge 0x65dd
movslq 0x8(%rsp), %rax
movzbl 0x10(%rsp,%rax), %eax
movq 0x28(%rsp), %rcx
movslq 0x8(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x65ce
movl $0x0, 0xc(%rsp)
jmp 0x65d0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x65a3
movl 0xc(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/shellaes128v1d5n64/ref/shellaes.c
// Function: shellaesEnc
void shellaesEnc(const u8 key[], const u8 nonce[], const u8 ad[], unsigned long long int adlen, const u8 p[], unsigned long long int ptlen, u8 c[], unsigned long long int ctlen){

    u8 tag[16];


    if(ptlen<16){
        /*plaintext is shorter than one block*/
        shellaesEnc_short(key, nonce, ad, adlen, p, ptlen, c, tag);
    }
    else if (ptlen%16==0){
        /*plaintext is multiple blocks long */
        shellaesEnc_fb(key, nonce, ad, adlen, p, ptlen, c, tag);
    }
    else{
         /*plaintext is longer than one block, and has a length that is not a mutiple of block length */
        shellaesEnc_nfb(key, nonce, ad, adlen, p, ptlen, c, tag);
    }

    /*append the tag to ciphertext*/
    memcpy(c+ptlen, tag, 16);

    /*
    printf("the ciphertext and the tag is \n");
    printf_byte_string(c, ctlen);
    */
}

// Assembly:
subq $0x58, %rsp
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
cmpq $0x10, 0x28(%rsp)
jae 0x8a5c
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x28(%rsp), %r9
movq 0x60(%rsp), %r10
leaq 0x10(%rsp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x2110
jmp 0x8adb
movq 0x28(%rsp), %rax
andq $0xf, %rax
cmpq $0x0, %rax
jne 0x8aa3
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x28(%rsp), %r9
movq 0x60(%rsp), %r10
leaq 0x10(%rsp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x2280
jmp 0x8ad9
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x28(%rsp), %r9
movq 0x60(%rsp), %r10
leaq 0x10(%rsp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x2260
jmp 0x8adb
movq 0x60(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %rdx
movq %rdx, (%rax,%rcx)
movq 0x18(%rsp), %rdx
movq %rdx, 0x8(%rax,%rcx)
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/shellaes128v1d5n64/ref/shellaes.c
// Function: shellaesDec
int shellaesDec(const u8 key[], const u8 nonce[], const u8 ad[], unsigned long long int adlen, const u8 c[], unsigned long long int ctlen, u8 p[], unsigned long long int ptlen){

    u8 tag[16];
    int flag;

    memcpy(tag, c+ptlen, 16);

    if(ptlen<16){
        /*plaintext is shorter than one block*/
        flag=shellaesDec_short(key, nonce, ad, adlen, c, ptlen, p, tag);
    }
    else if (ptlen%16==0){
        /*plaintext is multiple blocks long */
        flag=shellaesDecVef_fb(key, nonce, ad, adlen, c, ptlen, p, tag);
    }
    else{
        /*plaintext is longer than one block, and has a length that is not a mutiple of block length */
        flag=shellaesDec_nfb(key, nonce, ad, adlen, c, ptlen, p, tag);
    }

    return flag;
}

// Assembly:
subq $0x68, %rsp
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %rax
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq 0x78(%rsp), %rcx
movq (%rax,%rcx), %rdx
movq %rdx, 0x20(%rsp)
movq 0x8(%rax,%rcx), %rax
movq %rax, 0x28(%rsp)
cmpq $0x10, 0x78(%rsp)
jae 0x8b90
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq 0x40(%rsp), %r8
movq 0x78(%rsp), %r9
movq 0x70(%rsp), %r10
leaq 0x20(%rsp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x20c0
movl %eax, 0x1c(%rsp)
jmp 0x8c17
movq 0x78(%rsp), %rax
andq $0xf, %rax
cmpq $0x0, %rax
jne 0x8bdb
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq 0x40(%rsp), %r8
movq 0x78(%rsp), %r9
movq 0x70(%rsp), %r10
leaq 0x20(%rsp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x20f0
movl %eax, 0x1c(%rsp)
jmp 0x8c15
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq 0x40(%rsp), %r8
movq 0x78(%rsp), %r9
movq 0x70(%rsp), %r10
leaq 0x20(%rsp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x2100
movl %eax, 0x1c(%rsp)
jmp 0x8c17
movl 0x1c(%rsp), %eax
addq $0x68, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/ZombiesYard[P]MPU6050-DMP-raspberry-pi/main.c
// Function: main
int main() 
{
	//初始化mpu6050的dmp
	ms_open();
	do{
		ms_update();
		printf("yaw = %2.1f\tpitch = %2.1f\troll = %2.1f\ttemperature = %2.1f\tcompass = %2.1f, %2.1f, %2.1f\n",
		 ypr[YAW], ypr[PITCH], ypr[ROLL], temp, compass[0], compass[1], compass[2]);
		delay_ms(5);
	}while(1);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x1350
callq 0x1760
leaq 0xaec4(%rip), %rax      # 0xc174
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xaeb5(%rip), %rax      # 0xc174
movss 0x4(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
leaq 0xaea5(%rip), %rax      # 0xc174
movss 0x8(%rax), %xmm2
cvtss2sd %xmm2, %xmm2
leaq 0xaeb1(%rip), %rax      # 0xc190
movss (%rax), %xmm3
cvtss2sd %xmm3, %xmm3
leaq 0xaebe(%rip), %rax      # 0xc1ac
movss (%rax), %xmm4
cvtss2sd %xmm4, %xmm4
leaq 0xaeaf(%rip), %rax      # 0xc1ac
movss 0x4(%rax), %xmm5
cvtss2sd %xmm5, %xmm5
leaq 0xae9f(%rip), %rax      # 0xc1ac
movss 0x8(%rax), %xmm6
cvtss2sd %xmm6, %xmm6
leaq 0x6ce7(%rip), %rdi      # 0x8004
movb $0x7, %al
callq 0x1040
movl $0x1388, %edi           # imm = 0x1388
callq 0x10f0
movb $0x1, %al
testb $0x1, %al
jne 0x12a4
jmp 0x133a
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/sensor.c
// Function: GetGravity(VectorFloat*, Quaternion*)
uint8_t GetGravity(VectorFloat *v, Quaternion *q) {
	v -> x = 2 * (q -> x*q -> z - q -> w*q -> y);
	v -> y = 2 * (q -> w*q -> x + q -> y*q -> z);
	v -> z = q -> w*q -> w - q -> x*q -> x - q -> y*q -> y + q -> z*q -> z;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm1
movq -0x10(%rbp), %rax
movss 0xc(%rax), %xmm2
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x10(%rbp), %rax
mulss 0x8(%rax), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movss 0x6630(%rip), %xmm0     # 0x807c
mulss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
movq -0x10(%rbp), %rax
movss (%rax), %xmm1
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm2
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
mulss 0xc(%rax), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movss 0x65f1(%rip), %xmm0     # 0x807c
mulss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x10(%rbp), %rax
movss (%rax), %xmm2
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm1
movq -0x10(%rbp), %rax
mulss 0x4(%rax), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm1
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm2
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq -0x10(%rbp), %rax
movss 0xc(%rax), %xmm0
movq -0x10(%rbp), %rax
movss 0xc(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x8(%rax)
xorl %eax, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/sensor.c
// Function: GetYawPitchRoll(float*, Quaternion*, VectorFloat*)
uint8_t GetYawPitchRoll(float *data, Quaternion *q, VectorFloat *gravity) {
	// yaw: (about Z axis)
	data[0] = atan2(2*q -> x*q -> y - 2*q -> w*q -> z, 2*q -> w*q -> w + 2*q -> x*q -> x - 1);
	// pitch: (nose up/down, about Y axis)
	data[1] = atan(gravity -> x / sqrt(gravity -> y*gravity -> y + gravity -> z*gravity -> z));
	// roll: (tilt left/right, about X axis)
	data[2] = atan(gravity -> y / sqrt(gravity -> x*gravity -> x + gravity -> z*gravity -> z));
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movss 0x653c(%rip), %xmm0     # 0x807c
mulss 0x4(%rax), %xmm0
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm2
movq -0x10(%rbp), %rax
movss 0x6522(%rip), %xmm1     # 0x807c
mulss (%rax), %xmm1
movq -0x10(%rbp), %rax
mulss 0xc(%rax), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x10(%rbp), %rax
movss 0x64f4(%rip), %xmm1     # 0x807c
mulss (%rax), %xmm1
movq -0x10(%rbp), %rax
movss (%rax), %xmm3
movq -0x10(%rbp), %rax
movss 0x64dc(%rip), %xmm2     # 0x807c
mulss 0x4(%rax), %xmm2
movq -0x10(%rbp), %rax
mulss 0x4(%rax), %xmm2
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
movss 0x64a2(%rip), %xmm2     # 0x8060
subss %xmm2, %xmm1
callq 0x1d90
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm2
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm1
movq -0x18(%rbp), %rax
mulss 0x8(%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
callq 0x1de0
movaps %xmm0, %xmm1
movss -0x20(%rbp), %xmm0
divss %xmm1, %xmm0
callq 0x1dc0
movq -0x8(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
movss (%rax), %xmm2
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm1
movq -0x18(%rbp), %rax
mulss 0x8(%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
callq 0x1de0
movaps %xmm0, %xmm1
movss -0x1c(%rbp), %xmm0
divss %xmm1, %xmm0
callq 0x1dc0
movq -0x8(%rbp), %rax
movss %xmm0, 0x8(%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/./helper_3dmath.h
// Function: Quaternion::Quaternion()
Quaternion() {
            w = 1.0f;
            x = 0.0f;
            y = 0.0f;
            z = 0.0f;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movss 0x637c(%rip), %xmm0     # 0x8060
movss %xmm0, (%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/./helper_3dmath.h
// Function: Quaternion::Quaternion(int*)
Quaternion(int32_t *data) {
	    w = (float)data[0] / 16384.0f;
	    x = (float)data[1] / 16384.0f;
	    y = (float)data[2] / 16384.0f;
	    z = (float)data[3] / 16384.0f;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cvtsi2ssl (%rcx), %xmm0
movss 0x6348(%rip), %xmm1     # 0x8078
divss %xmm1, %xmm0
movss %xmm0, (%rax)
movq -0x10(%rbp), %rcx
cvtsi2ssl 0x4(%rcx), %xmm0
movss 0x632f(%rip), %xmm1     # 0x8078
divss %xmm1, %xmm0
movss %xmm0, 0x4(%rax)
movq -0x10(%rbp), %rcx
cvtsi2ssl 0x8(%rcx), %xmm0
movss 0x6315(%rip), %xmm1     # 0x8078
divss %xmm1, %xmm0
movss %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rcx
cvtsi2ssl 0xc(%rcx), %xmm0
movss 0x62fb(%rip), %xmm1     # 0x8078
divss %xmm1, %xmm0
movss %xmm0, 0xc(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu.c
// Function: mpu_reg_dump()
uint8_t mpu_reg_dump(void)
{
	uint8_t ii;
	uint8_t data;

	for (ii = 0; ii < st.hw->num_reg; ii++)
	{
		if (ii == st.reg->fifo_r_w || ii == st.reg->mem_r_w)
			continue;
		if (i2c_read(st.hw->addr, ii, 1, &data))
			return 1;
#if defined MPU_DEBUG
		printf_P("%#5x: %#5x\r\r\n", ii, data);
#endif
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x0, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
movq 0xa401(%rip), %rcx      # 0xc218
movzbl 0x4(%rcx), %ecx
cmpl %ecx, %eax
jge 0x1e8c
movzbl -0x2(%rbp), %eax
movq 0xa3e6(%rip), %rcx      # 0xc210
movzbl 0xd(%rcx), %ecx
cmpl %ecx, %eax
je 0x1e45
movzbl -0x2(%rbp), %eax
movq 0xa3d3(%rip), %rcx      # 0xc210
movzbl 0x18(%rcx), %ecx
cmpl %ecx, %eax
jne 0x1e47
jmp 0x1e82
movq 0xa3ca(%rip), %rax      # 0xc218
movb (%rax), %al
movl $0x1, %edx
leaq -0x3(%rbp), %rcx
movzbl %al, %edi
movzbl -0x2(%rbp), %esi
callq 0x6df0
movsbl %al, %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $-0x1, %edx
cmovnel %ecx, %eax
cmpl $0x0, %eax
je 0x1e80
movb $0x1, -0x1(%rbp)
jmp 0x1e90
jmp 0x1e82
movb -0x2(%rbp), %al
addb $0x1, %al
movb %al, -0x2(%rbp)
jmp 0x1e0c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu.c
// Function: mpu_read_reg(unsigned char, unsigned char*)
uint8_t mpu_read_reg(uint8_t reg, uint8_t *data)
{
	if (reg == st.reg->fifo_r_w || reg == st.reg->mem_r_w)
		return 1;
	if (reg >= st.hw->num_reg)
		return 1;
	return i2c_read(st.hw->addr, reg, 1, data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movzbl -0x2(%rbp), %eax
movq 0xa353(%rip), %rcx      # 0xc210
movzbl 0xd(%rcx), %ecx
cmpl %ecx, %eax
je 0x1ed8
movzbl -0x2(%rbp), %eax
movq 0xa340(%rip), %rcx      # 0xc210
movzbl 0x18(%rcx), %ecx
cmpl %ecx, %eax
jne 0x1ede
movb $0x1, -0x1(%rbp)
jmp 0x1f2c
movzbl -0x2(%rbp), %eax
movq 0xa32f(%rip), %rcx      # 0xc218
movzbl 0x4(%rcx), %ecx
cmpl %ecx, %eax
jl 0x1ef7
movb $0x1, -0x1(%rbp)
jmp 0x1f2c
movq 0xa31a(%rip), %rax      # 0xc218
movb (%rax), %sil
movb -0x2(%rbp), %al
movq -0x10(%rbp), %rcx
movl $0x1, %edx
movzbl %sil, %edi
movzbl %al, %esi
callq 0x6df0
movsbl %al, %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $-0x1, %edx
cmovnel %ecx, %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu.c
// Function: mpu_set_gyro_fsr(unsigned short)
uint8_t mpu_set_gyro_fsr(uint16_t fsr)
{
	uint8_t data;

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

	switch (fsr)
	{
	case 250:
		data = INV_FSR_250DPS << 3;
		break;
	case 500:
		data = INV_FSR_500DPS << 3;
		break;
	case 1000:
		data = INV_FSR_1000DPS << 3;
		break;
	case 2000:
		data = INV_FSR_2000DPS << 3;
		break;
	default:
		return 1;
	}

	if (st.chip_cfg.gyro_fsr == (data >> 3))
		return 0;
	if (i2c_write(st.hw->addr, st.reg->gyro_cfg, 1, &data))
		return 1;
	st.chip_cfg.gyro_fsr = data >> 3;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x4(%rbp)
cmpb $0x0, 0x9e34(%rip)      # 0xc22a
jne 0x2401
movb $0x1, -0x1(%rbp)
jmp 0x24ae
movzwl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0xfa, %eax
je 0x2435
jmp 0x2411
movl -0xc(%rbp), %eax
subl $0x1f4, %eax            # imm = 0x1F4
je 0x243b
jmp 0x241d
movl -0xc(%rbp), %eax
subl $0x3e8, %eax            # imm = 0x3E8
je 0x2441
jmp 0x2429
movl -0xc(%rbp), %eax
subl $0x7d0, %eax            # imm = 0x7D0
je 0x2447
jmp 0x244d
movb $0x0, -0x5(%rbp)
jmp 0x2453
movb $0x8, -0x5(%rbp)
jmp 0x2453
movb $0x10, -0x5(%rbp)
jmp 0x2453
movb $0x18, -0x5(%rbp)
jmp 0x2453
movb $0x1, -0x1(%rbp)
jmp 0x24ae
movzbl 0x9dce(%rip), %eax      # 0xc228
movzbl -0x5(%rbp), %ecx
sarl $0x3, %ecx
cmpl %ecx, %eax
jne 0x246b
movb $0x0, -0x1(%rbp)
jmp 0x24ae
movq 0x9da6(%rip), %rax      # 0xc218
movb (%rax), %sil
movq 0x9d94(%rip), %rax      # 0xc210
movl $0x1, %edx
leaq -0x5(%rbp), %rcx
movzbl %sil, %edi
movzbl 0x6(%rax), %esi
callq 0x7360
cmpl $0x0, %eax
je 0x249d
movb $0x1, -0x1(%rbp)
jmp 0x24ae
movzbl -0x5(%rbp), %eax
sarl $0x3, %eax
movb %al, 0x9d7e(%rip)       # 0xc228
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu.c
// Function: mpu_set_accel_fsr(unsigned char)
uint8_t mpu_set_accel_fsr(uint8_t fsr)
{
	uint8_t data;

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

	switch (fsr)
	{
	case 2:
		data = INV_FSR_2G << 3;
		break;
	case 4:
		data = INV_FSR_4G << 3;
		break;
	case 8:
		data = INV_FSR_8G << 3;
		break;
	case 16:
		data = INV_FSR_16G << 3;
		break;
	default:
		return 1;
	}

	if (st.chip_cfg.accel_fsr == (data >> 3))
		return 0;
	if (i2c_write(st.hw->addr, st.reg->accel_cfg, 1, &data))
		return 1;
	st.chip_cfg.accel_fsr = data >> 3;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
cmpb $0x0, 0x9d55(%rip)      # 0xc22a
jne 0x24e0
movb $0x1, -0x1(%rbp)
jmp 0x257f
movzbl -0x2(%rbp), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0xe, %eax
ja 0x251e
movq -0x10(%rbp), %rax
leaq 0x5fab(%rip), %rcx      # 0x84a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x0, -0x3(%rbp)
jmp 0x2524
movb $0x8, -0x3(%rbp)
jmp 0x2524
movb $0x10, -0x3(%rbp)
jmp 0x2524
movb $0x18, -0x3(%rbp)
jmp 0x2524
movb $0x1, -0x1(%rbp)
jmp 0x257f
movzbl 0x9cfe(%rip), %eax      # 0xc229
movzbl -0x3(%rbp), %ecx
sarl $0x3, %ecx
cmpl %ecx, %eax
jne 0x253c
movb $0x0, -0x1(%rbp)
jmp 0x257f
movq 0x9cd5(%rip), %rax      # 0xc218
movb (%rax), %sil
movq 0x9cc3(%rip), %rax      # 0xc210
movl $0x1, %edx
leaq -0x3(%rbp), %rcx
movzbl %sil, %edi
movzbl 0x7(%rax), %esi
callq 0x7360
cmpl $0x0, %eax
je 0x256e
movb $0x1, -0x1(%rbp)
jmp 0x257f
movzbl -0x3(%rbp), %eax
sarl $0x3, %eax
movb %al, 0x9cae(%rip)       # 0xc229
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu.c
// Function: mpu_set_lpf(unsigned short)
uint8_t mpu_set_lpf(uint16_t lpf)
{
	uint8_t data;

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

	if (lpf >= 188)
		data = INV_FILTER_188HZ;
	else if (lpf >= 98)
		data = INV_FILTER_98HZ;
	else if (lpf >= 42)
		data = INV_FILTER_42HZ;
	else if (lpf >= 20)
		data = INV_FILTER_20HZ;
	else if (lpf >= 10)
		data = INV_FILTER_10HZ;
	else
		data = INV_FILTER_5HZ;

	if (st.chip_cfg.lpf == data)
		return 0;
	if (i2c_write(st.hw->addr, st.reg->lpf, 1, &data))
		return 1;
	st.chip_cfg.lpf = data;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x4(%rbp)
cmpb $0x0, 0x9c84(%rip)      # 0xc22a
jne 0x25b1
movb $0x1, -0x1(%rbp)
jmp 0x265e
movzwl -0x4(%rbp), %eax
cmpl $0xbc, %eax
jl 0x25c2
movb $0x1, -0x5(%rbp)
jmp 0x260a
movzwl -0x4(%rbp), %eax
cmpl $0x62, %eax
jl 0x25d1
movb $0x2, -0x5(%rbp)
jmp 0x2608
movzwl -0x4(%rbp), %eax
cmpl $0x2a, %eax
jl 0x25e0
movb $0x3, -0x5(%rbp)
jmp 0x2606
movzwl -0x4(%rbp), %eax
cmpl $0x14, %eax
jl 0x25ef
movb $0x4, -0x5(%rbp)
jmp 0x2604
movzwl -0x4(%rbp), %eax
cmpl $0xa, %eax
jl 0x25fe
movb $0x5, -0x5(%rbp)
jmp 0x2602
movb $0x6, -0x5(%rbp)
jmp 0x2604
jmp 0x2606
jmp 0x2608
jmp 0x260a
movzbl 0x9c1a(%rip), %eax      # 0xc22b
movzbl -0x5(%rbp), %ecx
cmpl %ecx, %eax
jne 0x261f
movb $0x0, -0x1(%rbp)
jmp 0x265e
movq 0x9bf2(%rip), %rax      # 0xc218
movb (%rax), %sil
movq 0x9be0(%rip), %rax      # 0xc210
movl $0x1, %edx
leaq -0x5(%rbp), %rcx
movzbl %sil, %edi
movzbl 0x2(%rax), %esi
callq 0x7360
cmpl $0x0, %eax
je 0x2651
movb $0x1, -0x1(%rbp)
jmp 0x265e
movb -0x5(%rbp), %al
movb %al, 0x9bd1(%rip)       # 0xc22b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu.c
// Function: mpu_set_sample_rate(unsigned short)
uint8_t mpu_set_sample_rate(uint16_t rate)
{
	uint8_t data;

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

	if (st.chip_cfg.dmp_on)
		return 1;
	else
	{
		if (st.chip_cfg.lp_accel_mode)
		{
			if (rate && (rate <= 40))
			{
				/* Just stay in low-power accel mode. */
				mpu_lp_accel_mode(rate);
				return 0;
			}
			/* Requested rate exceeds the allowed frequencies in LP accel mode,
			 * switch back to full-power mode.
			 */
			mpu_lp_accel_mode(0);
		}
		if (rate < 4)
			rate = 4;
		else if (rate > 1000)
			rate = 1000;

		data = 1000 / rate - 1;
		if (i2c_write(st.hw->addr, st.reg->rate_div, 1, &data))
			return 1;

		st.chip_cfg.sample_rate = 1000 / (1 + data);

#ifdef AK89xx_SECONDARY
		mpu_set_compass_sample_rate(min(st.chip_cfg.compass_sample_rate, MAX_COMPASS_SAMPLE_RATE));
#endif

		/* Automatically set LPF to 1/2 sampling rate. */
		mpu_set_lpf(st.chip_cfg.sample_rate >> 1);
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x4(%rbp)
cmpb $0x0, 0x9ba4(%rip)      # 0xc22a
jne 0x2691
movb $0x1, -0x1(%rbp)
jmp 0x276b
cmpb $0x0, 0x9bac(%rip)      # 0xc244
je 0x26a3
movb $0x1, -0x1(%rbp)
jmp 0x276b
cmpb $0x0, 0x9b8a(%rip)      # 0xc234
je 0x26d8
cmpw $0x0, -0x4(%rbp)
je 0x26d1
movzwl -0x4(%rbp), %eax
cmpl $0x28, %eax
jg 0x26d1
movw -0x4(%rbp), %ax
movzbl %al, %edi
callq 0x2bf0
movb $0x0, -0x1(%rbp)
jmp 0x276b
xorl %edi, %edi
callq 0x2bf0
movzwl -0x4(%rbp), %eax
cmpl $0x4, %eax
jge 0x26e9
movw $0x4, -0x4(%rbp)
jmp 0x26fc
movzwl -0x4(%rbp), %eax
cmpl $0x3e8, %eax            # imm = 0x3E8
jle 0x26fa
movw $0x3e8, -0x4(%rbp)      # imm = 0x3E8
jmp 0x26fc
movzwl -0x4(%rbp), %ecx
movl $0x3e8, %eax            # imm = 0x3E8
cltd
idivl %ecx
subl $0x1, %eax
movb %al, -0x5(%rbp)
movq 0x9b03(%rip), %rax      # 0xc218
movb (%rax), %sil
movq 0x9af1(%rip), %rax      # 0xc210
movl $0x1, %edx
leaq -0x5(%rbp), %rcx
movzbl %sil, %edi
movzbl 0x1(%rax), %esi
callq 0x7360
cmpl $0x0, %eax
je 0x2740
movb $0x1, -0x1(%rbp)
jmp 0x276b
movzbl -0x5(%rbp), %ecx
addl $0x1, %ecx
movl $0x3e8, %eax            # imm = 0x3E8
cltd
idivl %ecx
movw %ax, 0x9ad8(%rip)       # 0xc22e
movzwl 0x9ad1(%rip), %eax      # 0xc22e
sarl %eax
movzwl %ax, %edi
callq 0x2590
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu.c
// Function: mpu_configure_fifo(unsigned char)
uint8_t mpu_configure_fifo(uint8_t sensors)
{
	uint8_t prev;
	int result = 0;

	/* Compass data isn't going into the FIFO. Stop trying. */
	sensors &= ~INV_XYZ_COMPASS;

	if (st.chip_cfg.dmp_on)
		return 0;
	else
	{
		if (!(st.chip_cfg.sensors))
			return 1;
		prev = st.chip_cfg.fifo_enable;
		st.chip_cfg.fifo_enable = sensors & st.chip_cfg.sensors;
		if (st.chip_cfg.fifo_enable != sensors)
			/* You're not getting what you asked for. Some sensors are
			 * asleep.
			 */
			result = -1;
		else
			result = 0;
		if (sensors || st.chip_cfg.lp_accel_mode)
			set_int_enable(1);
		else
			set_int_enable(0);
		if (sensors)
		{
			if (mpu_reset_fifo())
			{
				st.chip_cfg.fifo_enable = prev;
				return 1;
			}
		}
	}

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
movl $0x0, -0x8(%rbp)
movzbl -0x2(%rbp), %eax
andl $-0x2, %eax
movb %al, -0x2(%rbp)
cmpb $0x0, 0x9a9e(%rip)      # 0xc244
je 0x27b1
movb $0x0, -0x1(%rbp)
jmp 0x2848
cmpb $0x0, 0x9a72(%rip)      # 0xc22a
jne 0x27c3
movb $0x1, -0x1(%rbp)
jmp 0x2848
movb 0x9a67(%rip), %al       # 0xc230
movb %al, -0x3(%rbp)
movzbl -0x2(%rbp), %eax
movzbl 0x9a53(%rip), %ecx      # 0xc22a
andl %ecx, %eax
movb %al, 0x9a51(%rip)       # 0xc230
movzbl 0x9a4a(%rip), %eax      # 0xc230
movzbl -0x2(%rbp), %ecx
cmpl %ecx, %eax
je 0x27f7
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
jmp 0x27fe
movl $0x0, -0x8(%rbp)
cmpb $0x0, -0x2(%rbp)
jne 0x280d
cmpb $0x0, 0x9a29(%rip)      # 0xc234
je 0x2819
movl $0x1, %edi
callq 0x3880
jmp 0x2820
xorl %edi, %edi
callq 0x3880
cmpb $0x0, -0x2(%rbp)
je 0x2840
callq 0x3270
cmpb $0x0, %al
je 0x283e
movb -0x3(%rbp), %al
movb %al, 0x99f8(%rip)       # 0xc230
movb $0x1, -0x1(%rbp)
jmp 0x2848
jmp 0x2840
jmp 0x2842
movl -0x8(%rbp), %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ZombiesYard[P]MPU6050-DMP-raspberry-pi/MotionSensor/inv_mpu_lib/inv_mpu.c
// Function: mpu_set_int_latched(unsigned char)
uint8_t mpu_set_int_latched(uint8_t enable)
{
	uint8_t tmp;
	if (st.chip_cfg.latched_int == enable)
		return 0;

	if (enable)
		tmp = BIT_LATCH_EN | BIT_ANY_RD_CLR;
	else
		tmp = 0;
	if (st.chip_cfg.bypass_mode)
		tmp |= BIT_BYPASS_EN;
	if (st.chip_cfg.active_low_int)
		tmp |= BIT_ACTL;
	if (i2c_write(st.hw->addr, st.reg->int_pin_cfg, 1, &tmp))
		return 1;
	st.chip_cfg.latched_int = enable;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl 0x94de(%rip), %eax      # 0xc243
movzbl -0x2(%rbp), %ecx
cmpl %ecx, %eax
jne 0x2d73
movb $0x0, -0x1(%rbp)
jmp 0x2dea
cmpb $0x0, -0x2(%rbp)
je 0x2d7f
movb $0x30, -0x3(%rbp)
jmp 0x2d83
movb $0x0, -0x3(%rbp)
cmpb $0x0, 0x94a8(%rip)      # 0xc232
je 0x2d96
movzbl -0x3(%rbp), %eax
orl $0x2, %eax
movb %al, -0x3(%rbp)
cmpb $0x0, 0x94a5(%rip)      # 0xc242
je 0x2dab
movzbl -0x3(%rbp), %eax
orl $0x80, %eax
movb %al, -0x3(%rbp)
movq 0x9466(%rip), %rax      # 0xc218
movb (%rax), %sil
movq 0x9454(%rip), %rax      # 0xc210
movl $0x1, %edx
leaq -0x3(%rbp), %rcx
movzbl %sil, %edi
movzbl 0x17(%rax), %esi
callq 0x7360
cmpl $0x0, %eax
je 0x2ddd
movb $0x1, -0x1(%rbp)
jmp 0x2dea
movb -0x2(%rbp), %al
movb %al, 0x945d(%rip)       # 0xc243
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movzbl 0x9417(%rip), %eax      # 0xc22a
andl $0x70, %eax
cmpl $0x0, %eax
jne 0x2e24
movb $0x1, -0x1(%rbp)
jmp 0x2eb3
movq 0x93ed(%rip), %rax      # 0xc218
movb (%rax), %sil
movq 0x93db(%rip), %rax      # 0xc210
movb 0xe(%rax), %al
leaq -0x16(%rbp), %rcx
movl $0x6, %edx
movzbl %sil, %edi
movzbl %al, %esi
callq 0x6df0
movsbl %al, %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $-0x1, %edx
cmovnel %ecx, %eax
cmpl $0x0, %eax
je 0x2e68
movb $0x1, -0x1(%rbp)
jmp 0x2eb3
movzbl -0x16(%rbp), %eax
shll $0x8, %eax
movzbl -0x15(%rbp), %ecx
orl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
movzbl -0x14(%rbp), %eax
shll $0x8, %eax
movzbl -0x13(%rbp), %ecx
orl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x2(%rax)
movzbl -0x12(%rbp), %eax
shll $0x8, %eax
movzbl -0x11(%rbp), %ecx
orl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x4(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movzbl 0x9357(%rip), %eax      # 0xc22a
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x2ee4
movb $0x1, -0x1(%rbp)
jmp 0x2f73
movq 0x932d(%rip), %rax      # 0xc218
movb (%rax), %sil
movq 0x931b(%rip), %rax      # 0xc210
movb 0xf(%rax), %al
leaq -0x16(%rbp), %rcx
movl $0x6, %edx
movzbl %sil, %edi
movzbl %al, %esi
callq 0x6df0
movsbl %al, %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $-0x1, %edx
cmovnel %ecx, %eax
cmpl $0x0, %eax
je 0x2f28
movb $0x1, -0x1(%rbp)
jmp 0x2f73
movzbl -0x16(%rbp), %eax
shll $0x8, %eax
movzbl -0x15(%rbp), %ecx
orl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
movzbl -0x14(%rbp), %eax
shll $0x8, %eax
movzbl -0x13(%rbp), %ecx
orl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x2(%rax)
movzbl -0x12(%rbp), %eax
shll $0x8, %eax
movzbl -0x11(%rbp), %ecx
orl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x4(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpb $0x0, 0x9297(%rip)      # 0xc22a
jne 0x2f9e
movb $0x1, -0x1(%rbp)
jmp 0x3047
movq 0x9273(%rip), %rax      # 0xc218
movb (%rax), %sil
movq 0x9261(%rip), %rax      # 0xc210
movb 0x10(%rax), %al
leaq -0x12(%rbp), %rcx
movl $0x2, %edx
movzbl %sil, %edi
movzbl %al, %esi
callq 0x6df0
movsbl %al, %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $-0x1, %edx
cmovnel %ecx, %eax
cmpl $0x0, %eax
je 0x2fe2
movb $0x1, -0x1(%rbp)
jmp 0x3047
movzbl -0x12(%rbp), %eax
shll $0x8, %eax
movzbl -0x11(%rbp), %ecx
orl %ecx, %eax
movw %ax, -0x14(%rbp)
movswl -0x14(%rbp), %eax
cvtsi2ss %eax, %xmm1
movq 0x9216(%rip), %rax      # 0xc218
movswl 0x8(%rax), %eax
cvtsi2ss %eax, %xmm0
subss %xmm0, %xmm1
movq 0x9203(%rip), %rax      # 0xc218
movzwl 0x6(%rax), %eax
cvtsi2ss %eax, %xmm0
divss %xmm0, %xmm1
movss 0x545b(%rip), %xmm0     # 0x8484
addss %xmm1, %xmm0
movss 0x5033(%rip), %xmm1     # 0x8068
mulss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq