LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_c99_zaC99Value_consumezeaszeTUP
static STR* mw_mirth_c99_zaC99Value_consumezeaszeTUP (struct mirth_mirth_zaMirth* in_zaMirth_1, struct mirth_c99_zaC99Value* in_zaC99Value_2, struct mirth_mirth_zaMirth* *out_zaMirth_3) {
	struct mirth_c99_zaC99Resource* v5;
	mw_mirth_c99_zaC99Value_turnzeintozeresourcezx(in_zaC99Value_2, &v5);
	struct mirth_mirth_zaMirth* v6;
	STR* v7 = mw_mirth_c99_zaC99Resource_consumezeaszeTUP(in_zaMirth_1, v5, &v6);
	*out_zaMirth_3 = v6;
	return v7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x28cc50
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x34f330
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_c99_zaC99_zaC99
static void mtp_mirth_c99_zaC99_zaC99 (struct mirth_c99_zaC99* in_zaC99_1, struct mirth_c99_C99zuOptions* *out_C99zuOptions_2, INT *out_Nat_3, INT *out_Nat_4, bool *out_Bool_5, struct mirth_need_zaNeeds* *out_zaNeeds_6, struct std_output_zaOutput* *out_zaOutput_7) {
	struct mirth_c99_zaC99 v8 = *in_zaC99_1;
	free(in_zaC99_1);
	*out_zaOutput_7 = v8.mzaoutput;
	*out_zaNeeds_6 = v8.mzaneeds;
	*out_Bool_5 = v8.mputzeenabled;
	*out_Nat_4 = v8.mfreshzecounter;
	*out_Nat_3 = v8.mdepth;
	*out_C99zuOptions_2 = v8.moptions;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movl $0x30, %edx
callq 0x50e0
movq -0x8(%rbp), %rdi
callq 0x5030
movq -0x38(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movb -0x48(%rbp), %cl
movq -0x28(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movq -0x20(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movq -0x60(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_output_zaOutput_endzx
static void mw_std_output_zaOutput_endzx (struct std_output_zaOutput* in_zaOutput_1, struct std_file_zaFile* *out_zaFile_2) {
	struct std_output_zaOutput* v3;
	mw_std_output_zaOutput_flushzx(in_zaOutput_1, &v3);
	INT v4;
	struct std_file_zaFile* v5;
	ARR* v6;
	mtp_std_output_zaOutput_zaOutput(v3, &v4, &v5, &v6);
	decref(MKINT(v4));
	mw_std_buffer_zaBuffer_rdrop(v6);
	*out_zaFile_2 = v5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x220ec0
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x34fbd0
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x41a34(%rip), %rax     # 0x391428
orq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x34fab5
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x41a0b(%rip), %rax     # 0x391428
orq $0x1, %rax
movq %rax, -0x48(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x50(%rbp), %rax
cmpq $0x0, %rax
je 0x34fab5
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x419e0(%rip), %rax     # 0x391428
orq $0x1, %rax
movq %rax, -0x58(%rbp)
movq -0x60(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x34fab5
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq 0x419bb(%rip), %rax     # 0x391428
orq $0x1, %rax
movq %rax, -0x68(%rbp)
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq -0x70(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x34fab3
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq 0x4198a(%rip), %rax     # 0x391428
orq $0x1, %rax
movq %rax, -0x78(%rbp)
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x127c0
jmp 0x34fab5
jmp 0x34fab7
movq -0x30(%rbp), %rdi
callq 0x337f0
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_mirth_need_zaNeeds_rdrop
static void mw_mirth_need_zaNeeds_rdrop (struct mirth_need_zaNeeds* in_zaNeeds_1) {
	struct std_list_List_1 v2;
	ARR* v3;
	mtp_mirth_need_zaNeeds_zaNeeds(in_zaNeeds_1, &v2, &v3);
	mw_std_set_zaSet_rdrop(v3);
	decref(MK_std_list_List_1(v2));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x34fc40
movq -0x20(%rbp), %rdi
callq 0x34fca0
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x12780
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x28(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x34fbc7
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x12780
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x40(%rbp), %rax
cmpq $0x0, %rax
je 0x34fbc7
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x12780
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x50(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x34fbc7
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x12780
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movabsq $0xfffffffffffc, %rcx   # imm = 0xFFFFFFFFFFFC
andq -0x60(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x34fbc5
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x12780
movq %rax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x127c0
jmp 0x34fbc7
jmp 0x34fbc9
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_std_output_zaOutput_zaOutput
static void mtp_std_output_zaOutput_zaOutput (struct std_output_zaOutput* in_zaOutput_1, INT *out_Sizze_2, struct std_file_zaFile* *out_zaFile_3, ARR* *out_zaBuffer_4) {
	struct std_output_zaOutput v5 = *in_zaOutput_1;
	free(in_zaOutput_1);
	*out_zaBuffer_4 = v5.mzabuffer;
	*out_zaFile_3 = v5.mzafile;
	*out_Sizze_2 = v5.msizze;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5030
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_mirth_mirth_zaMirth_zaMirth
static void mtp_mirth_mirth_zaMirth_zaMirth (struct mirth_mirth_zaMirth* in_zaMirth_1, INT *out_Nat_2, INT *out_Nat_3, struct std_maybe_Maybe_1 *out_Maybe_4, struct std_maybe_Maybe_1 *out_Maybe_5, struct std_list_List_1 *out_List_6, bool *out_Bool_7, struct mirth_mirth_LexicalState* *out_LexicalState_8, INT *out_Int_9, struct std_list_List_1 *out_zaLister_10, struct std_list_List_1 *out_zaLister_11, ARR* *out_zaNameHashMap_12) {
	struct mirth_mirth_zaMirth v13 = *in_zaMirth_1;
	free(in_zaMirth_1);
	*out_zaNameHashMap_12 = v13.mzanamehashmap;
	*out_zaLister_11 = v13.mzapropstack;
	*out_zaLister_10 = v13.mzadiagnostics;
	*out_Int_9 = v13.mmainzehomezeindex;
	*out_LexicalState_8 = v13.mlexicalzestate;
	*out_Bool_7 = v13.mpreferzeinlinezedefs;
	*out_List_6 = v13.mpackagezesearchzepaths;
	*out_Maybe_5 = v13.mmirthzebasezepath;
	*out_Maybe_4 = v13.mbuiltinzy;
	*out_Nat_3 = v13.mnumzewarnings;
	*out_Nat_2 = v13.mnumzeerrors;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq 0x38(%rbp), %rax
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
movl $0x80, %edx
callq 0x50e0
movq -0x8(%rbp), %rdi
callq 0x5030
movq -0x38(%rbp), %rcx
movq 0x38(%rbp), %rax
movq %rcx, (%rax)
movq 0x30(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq 0x28(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq 0x20(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, (%rax)
movq -0x68(%rbp), %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movb -0x70(%rbp), %cl
movq 0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movq -0x30(%rbp), %rax
movq -0x80(%rbp), %rcx
movq %rcx, (%rax)
movq -0x78(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq -0x90(%rbp), %rcx
movq %rcx, (%rax)
movq -0x88(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq -0xa0(%rbp), %rcx
movq %rcx, (%rax)
movq -0x98(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq -0xa8(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq -0xb0(%rbp), %rcx
movq %rcx, (%rax)
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mtp_argzeparser_types_ArgumentParsingError_MissingArg
static STR* mtp_argzeparser_types_ArgumentParsingError_MissingArg (struct argzeparser_types_ArgumentParsingError in_ArgumentParsingError_1) {
	struct argzeparser_types_ArgumentParsingError_MissingArg v3 = *in_ArgumentParsingError_1.ptr.MissingArg;
	if (!--(in_ArgumentParsingError_1.ptr.MissingArg->refs)) {
		free(in_ArgumentParsingError_1.ptr.MissingArg);
	} else {
		incref(MKSTR(v3.mStr));
	}
	return v3.mStr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x350410
movq -0x8(%rbp), %rdi
callq 0x5030
jmp 0x3504b7
jmp 0x350412
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x40d37(%rip), %rax     # 0x391158
orq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x3504b3
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x40d12(%rip), %rax     # 0x391158
orq $0x1, %rax
movq %rax, -0x38(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x40(%rbp), %rax
cmpq $0x0, %rax
je 0x3504b3
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x40ce7(%rip), %rax     # 0x391158
orq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x3504b3
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x40cc2(%rip), %rax     # 0x391158
orq $0x1, %rax
movq %rax, -0x58(%rbp)
movabsq $0xfffffffffffc, %rax   # imm = 0xFFFFFFFFFFFC
andq -0x60(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x3504b5
jmp 0x3504b7
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mirth-lang[P]mirth/bin/mirth1.c
// Function: mw_std_prim_zaWorld_stderrzefile
static void mw_std_prim_zaWorld_stderrzefile (struct std_file_zaFile* *out_zaFile_1) {
	int64_t v4 = 2LL;
	bool v5 = false;
	struct std_file_zaFile* v6;
	mtw_std_file_zaFile_zaFile(v4, v5, &v6);
	*out_zaFile_1 = v6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x2, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %al
leaq -0x20(%rbp), %rdx
andb $0x1, %al
movzbl %al, %esi
callq 0x1b1050
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/size/size.c
// Function: main
int
main(int argc,char **argv)
    {
    int argIndex = 1;

    FILE *in,*out;
    RRA *h;

    argIndex = processOptions(argc,argv);

    if (argc-argIndex == 0)
        {
        in = stdin;
        out = stdout;
        }
    else if (argc-argIndex == 1)
        {
        in = OpenFile(argv[argIndex],"r");
        out = stdout;
        }
    else if (argc-argIndex == 2)
        {
        in = OpenFile(argv[argIndex],"r");
        out = OpenFile(argv[argIndex+1],"w");
        }
    else
        {
        printf("usage: rrasize [<input rra file> [<output rra file>]]\n");
        exit(-1);
        }

    h = readRRA(in,0);

    writeRRA(out,h,"modifiedBy: rrasize",0,0);

    fclose(in);
    fclose(out);

    return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1450
movl %eax, -0x14(%rbp)
movl -0x8(%rbp), %eax
subl -0x14(%rbp), %eax
cmpl $0x0, %eax
jne 0x1368
movq 0x5c8a(%rip), %rax      # 0x6fd8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq 0x5c74(%rip), %rax      # 0x6fd0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x1405
movl -0x8(%rbp), %eax
subl -0x14(%rbp), %eax
cmpl $0x1, %eax
jne 0x139f
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x316a(%rip), %rsi      # 0x44f0
callq 0x16c0
movq %rax, -0x20(%rbp)
movq 0x5c3a(%rip), %rax      # 0x6fd0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x1403
movl -0x8(%rbp), %eax
subl -0x14(%rbp), %eax
cmpl $0x2, %eax
jne 0x13e9
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x3133(%rip), %rsi      # 0x44f0
callq 0x16c0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x2c2b(%rip), %rsi      # 0x4009
callq 0x16c0
movq %rax, -0x28(%rbp)
jmp 0x1401
leaq 0x2c1b(%rip), %rdi      # 0x400b
movb $0x0, %al
callq 0x1090
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x11d0
jmp 0x1403
jmp 0x1405
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2030
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq 0x2c1d(%rip), %rdx      # 0x4042
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x2f60
movq -0x20(%rbp), %rdi
callq 0x1070
movq -0x28(%rbp), %rdi
callq 0x1070
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/SensorBase.cpp
// Function: SensorBase::openInput(char const*)
int SensorBase::openInput(const char* inputDeviceName)
{
	int fd = -1;

	fd = getSysfsDevicePath(sysfs_device_path, inputDeviceName);
	sysfs_device_path_len = strlen(sysfs_device_path);

	return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movq %rdi, %rsi
addq $0x18, %rsi
movq -0x10(%rbp), %rdx
callq 0x50e0
movq -0x20(%rbp), %rdi
movl %eax, -0x14(%rbp)
addq $0x18, %rdi
callq 0x5110
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl %ecx, 0x1018(%rax)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/SensorBase.cpp
// Function: SensorBase::~SensorBase()
SensorBase::~SensorBase()
{
	if (data_fd >= 0)
		close(data_fd);

	if (dev_fd >= 0)
		close(dev_fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x8915(%rip), %rcx      # 0xdf00
addq $0x10, %rcx
movq %rcx, (%rax)
cmpl $0x0, 0x1020(%rax)
jl 0x560e
movq -0x10(%rbp), %rax
movl 0x1020(%rax), %edi
callq 0x5410
jmp 0x560c
jmp 0x560e
movq -0x10(%rbp), %rax
cmpl $0x0, 0x101c(%rax)
jl 0x562e
movq -0x10(%rbp), %rax
movl 0x101c(%rax), %edi
callq 0x5410
jmp 0x562c
jmp 0x562e
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x5f90
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/SensorBase.cpp
// Function: SensorBase::open_device()
int SensorBase::open_device()
{
	if (dev_fd<0 && dev_name) {
		dev_fd = open(dev_name, O_RDONLY);
		STLOGE_IF(dev_fd < 0, "Couldn't open %s (%s)",
			  dev_name, strerror(errno));
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x101c(%rax)
jge 0x5695
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x5695
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x5180
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x101c(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/SensorBase.cpp
// Function: SensorBase::close_device()
int SensorBase::close_device()
{
	if (dev_fd >= 0) {
		close(dev_fd);
		dev_fd = -1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x101c(%rax)
jl 0x56da
movq -0x10(%rbp), %rax
movl 0x101c(%rax), %edi
callq 0x5410
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x101c(%rax) # imm = 0xFFFFFFFF
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/SensorBase.cpp
// Function: SensorBase::writeFullScale(int, int)
int SensorBase::writeFullScale(int32_t handle, int value)
{
	int fd;
	int err;
	char buf[6];
	const char *className;

	switch(handle) {
#if (SENSORS_ACCELEROMETER_ENABLE == 1)
	case SENSORS_ACCELEROMETER_HANDLE:
		strcpy(&sysfs_device_path[sysfs_device_path_len],
		       ACCEL_RANGE_FILE_NAME);
		className = "AccelSensor::setFullScale()";
		break;
#endif
#if (SENSORS_MAGNETIC_FIELD_ENABLE == 1)
	case SENSORS_MAGNETIC_FIELD_HANDLE:
	case SENSORS_UNCALIB_MAGNETIC_FIELD_HANDLE:
		strcpy(&sysfs_device_path[sysfs_device_path_len],
		       MAGN_RANGE_FILE_NAME);
		className = "MagnSensor::setFullScale()";
		break;
#endif
#if (SENSORS_GYROSCOPE_ENABLE == 1)
	case SENSORS_GYROSCOPE_HANDLE:
		strcpy(&sysfs_device_path[sysfs_device_path_len],
		       GYRO_RANGE_FILE_NAME);
		className = "Gyro::setFullScale()";
		break;
#endif
	default:
		return -1;
	}


	fd = open(sysfs_device_path, O_RDWR);
	sprintf(buf,"%d", value);
	err = write(fd, buf, sizeof(buf));
	close(fd);

	if(err >= 0) {
		STLOGI("%s Set new full-scale to %d", className, value);
	} else {
		STLOGE("%s Failed to set Full-scale: %d - %s",
		       className, value, sysfs_device_path);
	}

	return err >= 0 ? 0 : -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
subl $0x1, %eax
je 0x5971
jmp 0x5967
movl -0x34(%rbp), %eax
subl $0x4, %eax
je 0x599f
jmp 0x59cd
movq -0x40(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movslq 0x1018(%rax), %rax
addq %rax, %rdi
leaq 0x481a(%rip), %rsi      # 0xa1a7
callq 0x51f0
leaq 0x481a(%rip), %rax      # 0xa1b3
movq %rax, -0x30(%rbp)
jmp 0x59d6
movq -0x40(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movslq 0x1018(%rax), %rax
addq %rax, %rdi
leaq 0x4814(%rip), %rsi      # 0xa1cf
callq 0x51f0
leaq 0x4813(%rip), %rax      # 0xa1da
movq %rax, -0x30(%rbp)
jmp 0x59d6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5a3b
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
movl $0x2, %esi
movb $0x0, %al
callq 0x5180
movl %eax, -0x1c(%rbp)
leaq -0x26(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0x47f4(%rip), %rsi      # 0xa1ef
movb $0x0, %al
callq 0x5090
movl -0x1c(%rbp), %edi
leaq -0x26(%rbp), %rsi
movl $0x6, %edx
callq 0x50f0
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %edi
callq 0x5410
cmpl $0x0, -0x20(%rbp)
jl 0x5a26
jmp 0x5a28
jmp 0x5a28
movl -0x20(%rbp), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovgel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/sensors.cpp
// Function: sensors_poll_context_t::~sensors_poll_context_t()
sensors_poll_context_t::~sensors_poll_context_t()
{
	for (int i = 0; i < numSensorDrivers ; i++) {
		delete mSensors[i];
	}

#if (ANDROID_VERSION >= ANDROID_JBMR2)
	close(mPollFds[flushFD].fd);
	close(mWriteFlushPipe);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x6, -0xc(%rbp)
jge 0x63a2
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x120(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x6395
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x6397
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x636b
movq -0x18(%rbp), %rax
movl 0x110(%rax), %edi
callq 0x5410
jmp 0x63b3
movq -0x18(%rbp), %rax
movl 0x118(%rax), %edi
callq 0x5410
jmp 0x63c4
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x5f90
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/sensors.cpp
// Function: sensors_poll_context_t::activate(int, int)
int sensors_poll_context_t::activate(int handle, int enabled)
{
	int index = handleToDriver(handle);

	if(index < 0)
		return index;

	return  mSensors[index]->enable(handle, enabled, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0x14(%rbp), %esi
callq 0x53c0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x6413
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6434
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x120(%rax,%rcx,8), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq (%rdi), %rax
xorl %ecx, %ecx
callq *0x30(%rax)
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/sensors.cpp
// Function: sensors_poll_context_t::setDelay(int, long)
int sensors_poll_context_t::setDelay(int handle, int64_t ns)
{
	int index = handleToDriver(handle);

	if(index < 0)
		return index;

	return mSensors[index]->setDelay(handle, ns);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0x14(%rbp), %esi
callq 0x53c0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x6474
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6494
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq 0x120(%rax,%rcx,8), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/sensors.cpp
// Function: sensors_poll_context_t::flush(int)
int sensors_poll_context_t::flush(int sensor_handle)
{
	sensors_event_t flush_event;
	int err;

	flush_event.timestamp = 0;
	flush_event.meta_data.sensor = sensor_handle;
	flush_event.meta_data.what = META_DATA_FLUSH_COMPLETE;
	flush_event.type = SENSOR_TYPE_META_DATA;
	flush_event.version = META_DATA_VERSION;
	flush_event.sensor = 0;

	err = write(mWriteFlushPipe, &flush_event, sizeof(flush_event));
	if (err < 0) {
		ALOGE("Failed to write flush data. %d", err);
		return -EINVAL;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, -0x70(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, -0x64(%rbp)
movl $0x1, -0x68(%rbp)
movl $0x0, -0x78(%rbp)
movl $0x0, -0x80(%rbp)
movl $0x0, -0x7c(%rbp)
movl 0x118(%rax), %edi
leaq -0x80(%rbp), %rsi
movl $0x68, %edx
callq 0x50f0
movl %eax, -0x84(%rbp)
cmpl $0x0, -0x84(%rbp)
jge 0x6747
movq 0x786e(%rip), %rax      # 0xdf88
movq (%rax), %rdi
movl -0x84(%rbp), %r8d
leaq 0x3d41(%rip), %rsi      # 0xa46c
leaq 0x3d6a(%rip), %rdx      # 0xa49c
movl $0x470, %ecx            # imm = 0x470
movb $0x0, %al
callq 0x5320
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x674e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/sensors.cpp
// Function: open_sensors(hw_module_t const*, char const*, hw_device_t**)
static int open_sensors(const struct hw_module_t* module,
			const char __attribute__((unused))*id,
			struct hw_device_t** device)
{
	int status = -EINVAL;
	sensors_poll_context_t *dev = new sensors_poll_context_t();

	memset(&dev->device, 0, sizeof(SENSOR_POLL_DEVICE));

	dev->device.common.tag		= HARDWARE_DEVICE_TAG;

#if (ANDROID_VERSION > ANDROID_KK)
	dev->device.common.version	= SENSORS_DEVICE_API_VERSION_1_3;
#else
#if (ANDROID_VERSION > ANDROID_JBMR2)
	dev->device.common.version	= SENSORS_DEVICE_API_VERSION_1_1;
#else
#if (ANDROID_VERSION == ANDROID_JBMR2)
	dev->device.common.version	= SENSORS_DEVICE_API_VERSION_1_0;
#else
	dev->device.common.version	= 0;
#endif
#endif
#endif
	dev->device.common.module	= const_cast<hw_module_t*>(module);
	dev->device.common.close	= poll__close;
	dev->device.activate		= poll__activate;
	dev->device.setDelay		= poll__setDelay;
	dev->device.poll		= poll__poll;
#if (ANDROID_VERSION >= ANDROID_JBMR2)
	dev->device.batch		= poll__batch;
	dev->device.flush		= poll__flush;
#endif

	*device = &dev->device.common;
	status = 0;

	return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0xffffffea, -0x1c(%rbp) # imm = 0xFFFFFFEA
movl $0x150, %edi            # imm = 0x150
callq 0x5210
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x5400
jmp 0x6796
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0xe0, %edx
callq 0x5130
movq -0x28(%rbp), %rax
movl $0x48574454, (%rax)     # imm = 0x48574454
movq -0x28(%rbp), %rax
movl $0x1030001, 0x4(%rax)   # imm = 0x1030001
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
leaq 0x96(%rip), %rcx        # 0x6870
movq %rcx, 0x70(%rax)
movq -0x28(%rbp), %rax
leaq 0xd7(%rip), %rcx        # 0x68c0
movq %rcx, 0x78(%rax)
movq -0x28(%rbp), %rax
leaq 0xf8(%rip), %rcx        # 0x68f0
movq %rcx, 0x80(%rax)
movq -0x28(%rbp), %rax
leaq 0x126(%rip), %rcx       # 0x6930
movq %rcx, 0x88(%rax)
movq -0x28(%rbp), %rax
leaq 0x154(%rip), %rcx       # 0x6970
movq %rcx, 0x90(%rax)
movq -0x28(%rbp), %rax
leaq 0x182(%rip), %rcx       # 0x69b0
movq %rcx, 0x98(%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x5200
movq -0x30(%rbp), %rdi
callq 0x53d0
nop
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/sensors.cpp
// Function: poll__close(hw_device_t*)
static int poll__close(struct hw_device_t *dev)
{
	sensors_poll_context_t *ctx = (sensors_poll_context_t *)dev;
	if(ctx) {
		delete ctx;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x68ad
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x68ab
movq -0x18(%rbp), %rdi
callq 0x5260
movq -0x18(%rbp), %rdi
callq 0x5200
jmp 0x68ad
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/AccelSensor.cpp
// Function: AccelSensor::setInitialState()
int AccelSensor::setInitialState()
{
	struct input_absinfo absinfo_x;
	struct input_absinfo absinfo_y;
	struct input_absinfo absinfo_z;

	if (!ioctl(data_fd, EVIOCGABS(EVENT_TYPE_ACCEL_X), &absinfo_x) &&
	    !ioctl(data_fd, EVIOCGABS(EVENT_TYPE_ACCEL_Y), &absinfo_y) &&
	    !ioctl(data_fd, EVIOCGABS(EVENT_TYPE_ACCEL_Z), &absinfo_z))
		mHasPendingEvent = true;

	setFullScale(SENSORS_ACCELEROMETER_HANDLE,
		     ACCEL_DEFAULT_FULLSCALE);
	DecimationCount = 0;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl 0x1020(%rax), %edi
movl $0x80184540, %esi       # imm = 0x80184540
leaq -0x20(%rbp), %rdx
movb $0x0, %al
callq 0x52e0
cmpl $0x0, %eax
jne 0x6cd8
movq -0x58(%rbp), %rax
movl 0x1020(%rax), %edi
movl $0x80184541, %esi       # imm = 0x80184541
leaq -0x38(%rbp), %rdx
movb $0x0, %al
callq 0x52e0
cmpl $0x0, %eax
jne 0x6cd8
movq -0x58(%rbp), %rax
movl 0x1020(%rax), %edi
movl $0x80184542, %esi       # imm = 0x80184542
leaq -0x50(%rbp), %rdx
movb $0x0, %al
callq 0x52e0
cmpl $0x0, %eax
jne 0x6cd8
movq -0x58(%rbp), %rax
movb $0x1, 0x1538(%rax)
movq -0x58(%rbp), %rdi
movq (%rdi), %rax
movl $0x1, %esi
movl $0x4, %edx
callq *0x70(%rax)
movq 0x72bd(%rip), %rax      # 0xdfb0
movl $0x0, (%rax)
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/AccelSensor.cpp
// Function: AccelSensor::setDelay(int, long)
int AccelSensor::setDelay(int32_t handle, int64_t delay_ns)
{
	int err = 0;
	int what = -1;
	int64_t delay_ms = NSEC_TO_MSEC(delay_ns);

	if(delay_ms == 0)
		return err;

	what = getWhatFromHandle(handle);
	if (what < 0)
		return what;

	if (mEnabled & (1<<SignificantMotion))
	{
		delay_ms = ACC_DEFAULT_DELAY;
	}

	/**
	 * The handled sensor is disabled. Set 0 in its setDelayBuffer
	 * position and update decimation buffer
	 */
	if (delay_ms == NSEC_TO_MSEC(DELAY_OFF))
		delay_ms = 0;

	// Min setDelay Definition
	setDelayBuffer[what] = delay_ms;

#if (DEBUG_POLL_RATE == 1)
	STLOGD("%s: setDelayBuffer = %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld, %lld",
	       __func__,
	       setDelayBuffer[0], setDelayBuffer[1],
	       setDelayBuffer[2], setDelayBuffer[3],
	       setDelayBuffer[4], setDelayBuffer[5],
	       setDelayBuffer[6], setDelayBuffer[7],
	       setDelayBuffer[8], setDelayBuffer[9],
	       setDelayBuffer[10]);
#endif

	if(mEnabled & 1 << what)
		writeMinDelay();

	return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x24(%rbp)
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
movq -0x20(%rbp), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x6f6d
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6ff2
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
movq (%rdi), %rax
callq *0x58(%rax)
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jge 0x6f8b
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6ff2
movq 0x703e(%rip), %rax      # 0xdfd0
movl (%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x6fa4
movq $0xa, -0x30(%rbp)
cmpq $-0x1, -0x30(%rbp)
jne 0x6fb3
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rdx
movslq -0x28(%rbp), %rcx
movq 0x6fd6(%rip), %rax      # 0xdf98
movq %rdx, (%rax,%rcx,8)
movq 0x7003(%rip), %rax      # 0xdfd0
movl (%rax), %eax
movl -0x28(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x6fec
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/AccelSensor.cpp
// Function: AccelSensor::setFullScale(int, int)
int AccelSensor::setFullScale(int32_t  __attribute__((unused))handle,
			      int value)
{
	int err = -1;

	if(value <= 0)
		return err;
	else
		err = 0;

	if(value != current_fullscale)
	{
		err = writeFullScale(SENSORS_ACCELEROMETER_HANDLE,
				     value);
		if(err >= 0) {
			err = 0;
			current_fullscale = value;
		}
	}
	return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
cmpl $0x0, -0x18(%rbp)
jg 0x721f
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x726a
movl $0x0, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movq 0x6d40(%rip), %rcx      # 0xdf70
cmpl (%rcx), %eax
je 0x7264
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %edx
movq (%rdi), %rax
movl $0x1, %esi
callq *0x38(%rax)
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x7262
movl $0x0, -0x1c(%rbp)
movl -0x18(%rbp), %ecx
movq 0x6d10(%rip), %rax      # 0xdf70
movl %ecx, (%rax)
jmp 0x7264
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/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/AccelSensor.cpp
// Function: AccelSensor::setBufferData(sensors_vec_t*)
bool AccelSensor::setBufferData(sensors_vec_t *value)
{
	pthread_mutex_lock(&dataMutex);
	memcpy(&dataBuffer, value, sizeof(sensors_vec_t));
	pthread_mutex_unlock(&dataMutex);

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x66e1(%rip), %rdi      # 0xded8
callq 0x5350
movq -0x10(%rbp), %rcx
movq 0x66f1(%rip), %rax      # 0xdef8
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x66bc(%rip), %rdi      # 0xded8
callq 0x5190
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/AccelSensor.cpp
// Function: AccelSensor::getBufferData(sensors_vec_t*)
bool AccelSensor::getBufferData(sensors_vec_t *lastBufferedValues)
{
	pthread_mutex_lock(&dataMutex);
	memcpy(lastBufferedValues, &dataBuffer, sizeof(sensors_vec_t));
	pthread_mutex_unlock(&dataMutex);

#if (DEBUG_ACCELEROMETER == 1)
	STLOGD("%s: got values: x:(%f),y:(%f), z:(%f).",
		__func__,
		lastBufferedValues->x,
		lastBufferedValues->y,
		lastBufferedValues->z);
#endif

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x6695(%rip), %rdi      # 0xded8
callq 0x5350
movq -0x8(%rbp), %rax
movq 0x66a5(%rip), %rcx      # 0xdef8
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x6670(%rip), %rdi      # 0xded8
callq 0x5190
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/GyroSensor.cpp
// Function: GyroSensor::GyroSensor()
GyroSensor::GyroSensor()
	: SensorBase(NULL, SENSOR_DATANAME_GYROSCOPE),
	mInputReader(6),
	mHasPendingEvent(false)
{
	pthread_mutex_init(&dataMutex, NULL);

#if (GYROSCOPE_GBIAS_ESTIMATION_FUSION == 0)
	mPendingEvent[Gyro].version = sizeof(sensors_event_t);
	mPendingEvent[Gyro].sensor = ID_GYROSCOPE;
	mPendingEvent[Gyro].type = SENSOR_TYPE_GYROSCOPE;
	mPendingEvent[Gyro].gyro.status = SENSOR_STATUS_ACCURACY_HIGH;

  #if ((SENSORS_UNCALIB_GYROSCOPE_ENABLE == 1) && (GYROSCOPE_GBIAS_ESTIMATION_STANDALONE == 1))
	mPendingEvent[GyroUncalib].version = sizeof(sensors_event_t);
	mPendingEvent[GyroUncalib].sensor = ID_UNCALIB_GYROSCOPE;
	mPendingEvent[GyroUncalib].type = SENSOR_TYPE_GYROSCOPE_UNCALIBRATED;
	mPendingEvent[GyroUncalib].gyro.status = SENSOR_STATUS_ACCURACY_HIGH;
  #endif
#endif

#if defined(STORE_CALIB_GYRO_ENABLED)
	pStoreCalibration = StoreCalibration::getInstance();
#endif

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

	memset(data_raw, 0, sizeof(data_raw));

#if (GYROSCOPE_GBIAS_ESTIMATION_STANDALONE == 1)
	iNemoEngine_API_gbias_Initialization(false);
  #if (SENSORS_ACCELEROMETER_ENABLE == 1)
	acc = new AccelSensor();
  #endif
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
leaq 0x2d99(%rip), %rdx      # 0xa634
xorl %eax, %eax
movl %eax, %esi
callq 0x5060
movq -0x20(%rbp), %rdi
movq 0x6671(%rip), %rax      # 0xdf20
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x1028, %rdi           # imm = 0x1028
movl $0x6, %esi
callq 0x5120
jmp 0x78c9
movq -0x20(%rbp), %rax
movb $0x0, 0x1188(%rax)
movq 0x670d(%rip), %rdi      # 0xdfe8
xorl %eax, %eax
movl %eax, %esi
callq 0x5360
movq -0x20(%rbp), %rax
movl $0x68, 0x1050(%rax)
movl $0x4, 0x1054(%rax)
movl $0x4, 0x1058(%rax)
movb $0x3, 0x1074(%rax)
cmpl $0x0, 0x1020(%rax)
je 0x792f
jmp 0x7931
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x5160
jmp 0x794e
jmp 0x7931
movq -0x20(%rbp), %rdi
addq $0x118c, %rdi           # imm = 0x118C
xorl %esi, %esi
movl $0xc, %edx
callq 0x5130
addq $0x20, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x53d0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/GyroSensor.cpp
// Function: GyroSensor::~GyroSensor()
GyroSensor::~GyroSensor()
{
	if (mEnabled) {
		enable(SENSORS_GYROSCOPE_HANDLE, 0, 0);
	}
#if ((SENSORS_ACCELEROMETER_ENABLE == 1) && (GYROSCOPE_GBIAS_ESTIMATION_STANDALONE == 1))
	acc->~AccelSensor();
#endif
	pthread_mutex_destroy(&dataMutex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x65a5(%rip), %rcx      # 0xdf20
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x664f(%rip), %rax      # 0xdfd8
cmpl $0x0, (%rax)
je 0x79a8
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
movl $0x4, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq *%rax
jmp 0x79a6
jmp 0x79a8
movq 0x6639(%rip), %rdi      # 0xdfe8
callq 0x5230
movq -0x10(%rbp), %rdi
addq $0x1028, %rdi           # imm = 0x1028
callq 0x5280
movq -0x10(%rbp), %rdi
callq 0x5160
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x5f90
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/GyroSensor.cpp
// Function: GyroSensor::setInitialState()
int GyroSensor::setInitialState()
{
	struct input_absinfo absinfo_x;
	struct input_absinfo absinfo_y;
	struct input_absinfo absinfo_z;

	if (!ioctl(data_fd, EVIOCGABS(EVENT_TYPE_GYRO_X), &absinfo_x) &&
		!ioctl(data_fd, EVIOCGABS(EVENT_TYPE_GYRO_Y), &absinfo_y) &&
		!ioctl(data_fd, EVIOCGABS(EVENT_TYPE_GYRO_Z), &absinfo_z))
		mHasPendingEvent = true;

	setFullScale(SENSORS_GYROSCOPE_HANDLE, GYRO_DEFAULT_FULLSCALE);
	startup_samples = samples_to_discard;
	memset(DecimationCount, 0, sizeof(DecimationCount));

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl 0x1020(%rax), %edi
movl $0x80184540, %esi       # imm = 0x80184540
leaq -0x20(%rbp), %rdx
movb $0x0, %al
callq 0x52e0
cmpl $0x0, %eax
jne 0x7a88
movq -0x58(%rbp), %rax
movl 0x1020(%rax), %edi
movl $0x80184541, %esi       # imm = 0x80184541
leaq -0x38(%rbp), %rdx
movb $0x0, %al
callq 0x52e0
cmpl $0x0, %eax
jne 0x7a88
movq -0x58(%rbp), %rax
movl 0x1020(%rax), %edi
movl $0x80184542, %esi       # imm = 0x80184542
leaq -0x50(%rbp), %rdx
movb $0x0, %al
callq 0x52e0
cmpl $0x0, %eax
jne 0x7a88
movq -0x58(%rbp), %rax
movb $0x1, 0x1188(%rax)
movq -0x58(%rbp), %rdi
movq (%rdi), %rax
movl $0x4, %esi
movl $0x7d0, %edx            # imm = 0x7D0
callq *0x70(%rax)
movq 0x6445(%rip), %rax      # 0xdee8
movl (%rax), %ecx
movq 0x6444(%rip), %rax      # 0xdef0
movl %ecx, (%rax)
movq 0x649b(%rip), %rdi      # 0xdf50
xorl %esi, %esi
movl $0xc, %edx
callq 0x5130
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/GyroSensor.cpp
// Function: GyroSensor::setDelay(int, long)
int GyroSensor::setDelay(int32_t handle, int64_t delay_ns)
{
	int what = -1;
	int err = 0;
	int64_t delay_ms = NSEC_TO_MSEC(delay_ns);

	if(delay_ms == 0)
		return err;

	what = getWhatFromHandle(handle);
	if (what < 0)
		return what;

#if (GYROSCOPE_GBIAS_ESTIMATION_STANDALONE == 1)
  #if (SENSORS_ACCELEROMETER_ENABLE == 1)
	if (delay_ns >= 10000000)
		acc->setDelay(SENSORS_GYROSCOPE_HANDLE, delay_ns);
	else
		acc->setDelay(SENSORS_GYROSCOPE_HANDLE, 10000000);

  #endif
#endif

	/**
	 * The handled sensor is disabled. Set 0 in its setDelayBuffer
	 * position and update decimation buffer.
	 */
	if (delay_ms == NSEC_TO_MSEC(DELAY_OFF))
		delay_ms = 0;

	// Min setDelay Definition
	setDelayBuffer[what] = delay_ms;

#if (DEBUG_POLL_RATE == 1)
	STLOGD("%s: setDelayBuffer[] = %lld, %lld, %lld",
		__func__, setDelayBuffer[0], setDelayBuffer[1],
		setDelayBuffer[2]);
#endif

	// Update sysfs
	if(mEnabled & 1<<what)
		writeMinDelay();

	return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x7cea
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7d56
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
movq (%rdi), %rax
callq *0x58(%rax)
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x7d08
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7d56
cmpq $-0x1, -0x30(%rbp)
jne 0x7d17
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rdx
movslq -0x24(%rbp), %rcx
movq 0x626a(%rip), %rax      # 0xdf90
movq %rdx, (%rax,%rcx,8)
movq 0x62a7(%rip), %rax      # 0xdfd8
movl (%rax), %eax
movl -0x24(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x7d50
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/GyroSensor.cpp
// Function: GyroSensor::setFullScale(int, int)
int GyroSensor::setFullScale(int32_t  __attribute__((unused))handle,
			     int value)
{
	int err = -1;

	if(value <= 0)
		return err;
	else
		err = 0;

	if(value != current_fullscale)
	{
		err = writeFullScale(SENSORS_GYROSCOPE_HANDLE, value);
		if(err >= 0) {
			err = 0;
			current_fullscale = value;
		}
	}
	return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
cmpl $0x0, -0x18(%rbp)
jg 0x7faf
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7ffa
movl $0x0, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movq 0x6000(%rip), %rcx      # 0xdfc0
cmpl (%rcx), %eax
je 0x7ff4
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %edx
movq (%rdi), %rax
movl $0x4, %esi
callq *0x38(%rax)
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x7ff2
movl $0x0, -0x1c(%rbp)
movl -0x18(%rbp), %ecx
movq 0x5fd0(%rip), %rax      # 0xdfc0
movl %ecx, (%rax)
jmp 0x7ff4
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/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/GyroSensor.cpp
// Function: GyroSensor::getBufferData(sensors_vec_t*)
bool GyroSensor::getBufferData(sensors_vec_t *lastBufferedValues)
{
	pthread_mutex_lock(&dataMutex);
	memcpy(lastBufferedValues, &dataBuffer, sizeof(sensors_vec_t));
	pthread_mutex_unlock(&dataMutex);

#if (DEBUG_GYROSCOPE == 1)
	STLOGD("%s: getBufferData got values: x:(%f),y:(%f), z:(%f).",
		__func__,
		lastBufferedValues->x,
		lastBufferedValues->y,
		lastBufferedValues->z);
#endif

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x5af5(%rip), %rdi      # 0xdfe8
callq 0x5350
movq -0x8(%rbp), %rax
movq 0x5a0d(%rip), %rcx      # 0xdf10
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x5ad0(%rip), %rdi      # 0xdfe8
callq 0x5190
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/InputEventReader.cpp
// Function: InputEventCircularReader::fill(int)
ssize_t InputEventCircularReader::fill(int fd)
{
	size_t numEventsRead = 0;
	if (mFreeSpace) {
		const ssize_t nread = read(fd, mHead, mFreeSpace * sizeof(input_event));
		if (nread<0 || nread % sizeof(input_event)) {
			return nread < 0 ? -errno : -EINVAL;
		}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, 0x20(%rax)
je 0x8700
movq -0x38(%rbp), %rax
movl -0x14(%rbp), %edi
movq 0x10(%rax), %rsi
imulq $0x18, 0x20(%rax), %rdx
callq 0x5330
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jl 0x863e
movq -0x28(%rbp), %rax
movl $0x18, %ecx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
je 0x866e
cmpq $0x0, -0x28(%rbp)
jge 0x8656
callq 0x5070
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x3c(%rbp)
jmp 0x8660
movl $0xffffffea, %eax       # imm = 0xFFFFFFEA
movl %eax, -0x3c(%rbp)
jmp 0x8660
movl -0x3c(%rbp), %eax
cltq
movq %rax, -0x8(%rbp)
jmp 0x8708
movq -0x28(%rbp), %rax
movl $0x18, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x86fe
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
imulq $0x18, %rax, %rax
addq 0x10(%rcx), %rax
movq %rax, 0x10(%rcx)
movq -0x20(%rbp), %rdx
movq 0x20(%rcx), %rax
subq %rdx, %rax
movq %rax, 0x20(%rcx)
movq 0x10(%rcx), %rax
cmpq 0x8(%rcx), %rax
jbe 0x86fc
movq -0x38(%rbp), %rcx
movq 0x10(%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq (%rax), %rdi
movq 0x8(%rax), %rsi
imulq $0x18, -0x30(%rbp), %rdx
callq 0x51a0
movq -0x38(%rbp), %rax
movq (%rax), %rcx
imulq $0x18, -0x30(%rbp), %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
jmp 0x86fe
jmp 0x8700
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/STMicroelectronics[P]STMems_Android_Sensor_HAL_Input/InputEventReader.cpp
// Function: InputEventCircularReader::next()
void InputEventCircularReader::next()
{
	mCurr++;
	mFreeSpace++;
	if(mCurr >= mBufferEnd) {
		mCurr = mBuffer;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq 0x18(%rcx), %rax
addq $0x18, %rax
movq %rax, 0x18(%rcx)
movq 0x20(%rcx), %rax
addq $0x1, %rax
movq %rax, 0x20(%rcx)
movq 0x18(%rcx), %rax
cmpq 0x8(%rcx), %rax
jb 0x87ad
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, 0x18(%rax)
popq %rbp
retq
nop