LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: print_mex_else_cases(_IO_FILE*, Func*)
void print_mex_else_cases(FILE* fp, Func* f)
{
    for (Func* fcall = f; fcall; fcall = fcall->next)
        fprintf(fp,
                "    else if (strcmp(id, stubids%d_) == 0)\n"
                "        mexStub%d(nlhs,plhs, nrhs-1,prhs+1);\n",
                fcall->id, fcall->id);

    int maxid = max_routine_id(f);

    fprintf(fp,
            "    else if (strcmp(id, \"*profile on*\") == 0) {\n"
            "        if (!mexprofrecord_) {\n"
            "            mexprofrecord_ = (int*) malloc(%d * sizeof(int));\n"
            "            mexLock();\n"
            "        }\n"
            "        memset(mexprofrecord_, 0, %d * sizeof(int));\n"
            "    } else if (strcmp(id, \"*profile off*\") == 0) {\n"
            "        if (mexprofrecord_) {\n"
            "            free(mexprofrecord_);\n"
            "            mexUnlock();\n"
            "        }\n"
            "        mexprofrecord_ = NULL;\n"
            "    } else if (strcmp(id, \"*profile report*\") == 0) {\n",
            maxid+1, maxid+1);

    make_profile_output(fp, f, "mexPrintf(");

    fprintf(fp,
            "    } else if (strcmp(id, \"*profile log*\") == 0) {\n"
            "        FILE* logfp;\n"
            "        if (nrhs != 2 || mxGetString(prhs[1], id, sizeof(id)) != 0)\n"
            "            mexErrMsgTxt(\"Must have two string arguments\");\n"
            "        logfp = fopen(id, \"w+\");\n"
            "        if (!logfp)\n"
            "            mexErrMsgTxt(\"Cannot open log for output\");\n");

    make_profile_output(fp, f, "fprintf(logfp, ");

    fprintf(fp, "        fclose(logfp);\n");

    fprintf(fp,
            "    } else\n"
            "        mexErrMsgTxt(\"Unknown identifier\");\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x115cd
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x28(%rax), %edx
movq -0x18(%rbp), %rax
movl 0x28(%rax), %ecx
leaq 0xbc97(%rip), %rsi      # 0x1d24f
movb $0x0, %al
callq 0x33a0
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x11598
movq -0x10(%rbp), %rdi
callq 0xce90
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %edx
addl $0x1, %edx
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
leaq 0xbcb7(%rip), %rsi      # 0x1d2a7
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0xbe70(%rip), %rdx      # 0x1d476
callq 0x11450
movq -0x8(%rbp), %rdi
leaq 0xbe6b(%rip), %rsi      # 0x1d481
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0xbf8b(%rip), %rdx      # 0x1d5b7
callq 0x11450
movq -0x8(%rbp), %rdi
leaq 0xbf8b(%rip), %rsi      # 0x1d5c7
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
leaq 0xbf91(%rip), %rsi      # 0x1d5df
movb $0x0, %al
callq 0x33a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: print_mex_init(_IO_FILE*)
void print_mex_init(FILE* fp)
{

    fprintf(fp, "%s", mwrap_banner);
    fprintf(fp, "%s", mex_header);

    fprintf(fp, "\n");
    if (mw_use_gpu)
        mex_use_gpu(fp);
    if (mw_use_c99_complex)
        mex_c99_complex(fp);
    else if (mw_use_cpp_complex)
      {
        mex_cpp_complex(fp);
	if (mw_use_gpu)
	  mex_gpucpp_complex(fp);
      }

    //    fprintf(fp, "\n");
    //    fprintf(fp, "%s", mwrap_compat_type_support);
    //    fprintf(fp, "\n");
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq 0x13c19(%rip), %rdx     # 0x25290
leaq 0x3913(%rip), %rsi      # 0x14f91
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq 0x13bf8(%rip), %rdx     # 0x25288
leaq 0x38fa(%rip), %rsi      # 0x14f91
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
leaq 0x9ab9(%rip), %rsi      # 0x1b162
movb $0x0, %al
callq 0x33a0
leaq 0x13c19(%rip), %rax     # 0x252d0
testb $0x1, (%rax)
je 0x116c5
movq -0x8(%rbp), %rdi
callq 0xcee0
leaq 0x13c07(%rip), %rax     # 0x252d3
testb $0x1, (%rax)
je 0x116dc
movq -0x8(%rbp), %rdi
callq 0xcf70
jmp 0x1170a
leaq 0x13bef(%rip), %rax     # 0x252d2
testb $0x1, (%rax)
je 0x11708
movq -0x8(%rbp), %rdi
callq 0xcf10
leaq 0x13bd8(%rip), %rax     # 0x252d0
testb $0x1, (%rax)
je 0x11706
movq -0x8(%rbp), %rdi
callq 0xcf40
jmp 0x11708
jmp 0x1170a
addq $0x10, %rsp
popq %rbp
retq
// File: zgimbutas[P]mwrap/src/mwrap-cgen.cc
// Function: print_mex_file(_IO_FILE*, Func*)
void print_mex_file(FILE* fp, Func* f)
{

    mex_define_copiers(fp);
    mex_casting_getters(fp);

    if (has_fortran(f)) {
        mex_define_fnames(fp, f);
        mex_fortran_decls(fp, f);
    }

    print_mex_stubs(fp, f);
    fprintf(fp, "%s", mexBase);
    fprintf(fp, "\n");
    if (mw_use_gpu)
        fprintf(fp, "    mxInitGPU();\n");
    fprintf(fp, "\n");
    fprintf(fp, "%s", mexBaseIf);
    print_mex_else_cases(fp, f);
    fprintf(fp, "}\n\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd2c0
movq -0x8(%rbp), %rdi
callq 0xe590
movq -0x10(%rbp), %rdi
callq 0xcdc0
testb $0x1, %al
jne 0x11741
jmp 0x1175b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe040
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe210
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11540
movq -0x8(%rbp), %rdi
movq 0x13b25(%rip), %rdx     # 0x25298
leaq 0x3817(%rip), %rsi      # 0x14f91
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
leaq 0x99d6(%rip), %rsi      # 0x1b162
movb $0x0, %al
callq 0x33a0
leaq 0x13b36(%rip), %rax     # 0x252d0
testb $0x1, (%rax)
je 0x117b1
movq -0x8(%rbp), %rdi
leaq 0xc149(%rip), %rsi      # 0x1d8f3
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
leaq 0x99a6(%rip), %rsi      # 0x1b162
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq 0x13ad2(%rip), %rdx     # 0x252a0
leaq 0x37bc(%rip), %rsi      # 0x14f91
movb $0x0, %al
callq 0x33a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11580
movq -0x8(%rbp), %rdi
leaq 0xb9d1(%rip), %rsi      # 0x1d1c5
movb $0x0, %al
callq 0x33a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: statgen[P]statgen/lib/tclap-1.2.0/examples/test5.cpp
// Function: main
int main(int argc, char** argv)
{

	parseOptions(argc,argv);

	cout << "for A OR B we got : " << _orTest<< endl
		 << "for string C we got : " << _testc << endl
		 << "for string D we got : " << _testd << endl
		 << "for E or F or G we got: " << _orTest2 << endl;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x4760
movq 0x1992e(%rip), %rdi     # 0x1dfd0
leaq 0x10989(%rip), %rsi     # 0x15032
callq 0x4220
movq %rax, %rdi
leaq 0x19be0(%rip), %rsi     # 0x1e298
callq 0x4200
movq %rax, %rdi
movq 0x198e1(%rip), %rsi     # 0x1dfa8
callq 0x4260
movq %rax, %rdi
leaq 0x10971(%rip), %rsi     # 0x15047
callq 0x4220
movq %rax, %rdi
leaq 0x19bf3(%rip), %rsi     # 0x1e2d8
callq 0x4200
movq %rax, %rdi
movq 0x198b4(%rip), %rsi     # 0x1dfa8
callq 0x4260
movq %rax, %rdi
leaq 0x1095b(%rip), %rsi     # 0x1505e
callq 0x4220
movq %rax, %rdi
movb 0x19be7(%rip), %al      # 0x1e2f8
andb $0x1, %al
movzbl %al, %esi
callq 0x4410
movq %rax, %rdi
movq 0x19883(%rip), %rsi     # 0x1dfa8
callq 0x4260
movq %rax, %rdi
leaq 0x10941(%rip), %rsi     # 0x15075
callq 0x4220
movq %rax, %rdi
leaq 0x19b75(%rip), %rsi     # 0x1e2b8
callq 0x4200
movq %rax, %rdi
movq 0x19856(%rip), %rsi     # 0x1dfa8
callq 0x4260
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: wx-csy[P]librmq/prep.cpp
// Function: perm_to_preorder(std::array<unsigned char, 8ul>)
preorder_t perm_to_preorder(perm_t perm) {
    preorder_t result;
    int ptr = 0;
    std::stack<std::pair<int, int>> stk; stk.emplace(0, SEG_LENGTH);
    while (stk.size()) {
        int l, r; std::tie(l, r) = stk.top(); stk.pop();
        if (l == r) continue;
        int m = std::min_element(perm.begin() + l, perm.begin() + r) - perm.begin();
        result[ptr++] = m;
        stk.emplace(l, m);
        stk.emplace(m + 1, r);
    }
    return result;
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0xd8(%rsp)
movl $0x0, 0xd4(%rsp)
leaq 0x80(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x1e40
movq 0x40(%rsp), %rdi
movl $0x0, 0x7c(%rsp)
leaq 0x7c28(%rip), %rdx      # 0x9008
leaq 0x7c(%rsp), %rsi
callq 0x1e70
jmp 0x13ec
jmp 0x13ee
leaq 0x80(%rsp), %rdi
callq 0x1ea0
movq %rax, 0x38(%rsp)
jmp 0x1402
movq 0x38(%rsp), %rax
cmpq $0x0, %rax
je 0x1557
leaq 0x80(%rsp), %rdi
callq 0x1eb0
movq %rax, 0x30(%rsp)
jmp 0x1425
leaq 0x50(%rsp), %rdi
movq %rdi, 0x28(%rsp)
leaq 0x68(%rsp), %rsi
leaq 0x64(%rsp), %rdx
callq 0x1ec0
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1f00
leaq 0x80(%rsp), %rdi
callq 0x1f70
jmp 0x145c
movl 0x68(%rsp), %eax
cmpl 0x64(%rsp), %eax
jne 0x1488
jmp 0x13ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x2060
jmp 0x1574
leaq 0xd8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x1fc0
movq 0x10(%rsp), %rdi
movslq 0x68(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
callq 0x1fc0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
movslq 0x64(%rsp), %rax
addq %rax, %rsi
callq 0x1f80
movq %rax, 0x20(%rsp)
jmp 0x14cd
leaq 0xd8(%rsp), %rdi
callq 0x1fc0
movq %rax, %rcx
movq 0x20(%rsp), %rax
subl %ecx, %eax
movl %eax, 0x4c(%rsp)
movb 0x4c(%rsp), %al
movb %al, 0xf(%rsp)
movslq 0xd4(%rsp), %rsi
movl %esi, %eax
incl %eax
movl %eax, 0xd4(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0x1fd0
movb 0xf(%rsp), %cl
movb %cl, (%rax)
leaq 0x80(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x4c(%rsp), %rdx
callq 0x2000
jmp 0x152f
movl 0x4c(%rsp), %eax
incl %eax
movl %eax, 0x48(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x64(%rsp), %rdx
callq 0x2030
jmp 0x1552
jmp 0x13ee
leaq 0x80(%rsp), %rdi
callq 0x2060
movq 0xe0(%rsp), %rax
addq $0xe8, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x1180
nop
// File: wx-csy[P]librmq/prep.cpp
// Function: print_lookup(std::array<unsigned char, 8ul>)
void print_lookup(perm_t perm) {
    int result[SEG_LENGTH][SEG_LENGTH];
    memset(result, -1, sizeof result);
    for (int i = 1; i <= SEG_LENGTH; i++) {
        for (int j = 0; j < i; j++) {
            result[j][i-1] = std::min_element(perm.begin() + j, perm.begin() + i) - perm.begin();
        }
    }
    putchar('{');
    for (int i = 0; i < SEG_LENGTH; i++)
        for (int j = 0; j < SEG_LENGTH; j++)
            printf("%d,", result[i][j]);
    printf("},\n");
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x120(%rsp)
leaq 0x20(%rsp), %rdi
movl $0xff, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x10a0
movl $0x1, 0x1c(%rsp)
movslq 0x1c(%rsp), %rax
cmpq $0x8, %rax
ja 0x1669
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x1657
leaq 0x120(%rsp), %rdi
callq 0x1fc0
movslq 0x18(%rsp), %rcx
addq %rcx, %rax
movq %rax, (%rsp)
leaq 0x120(%rsp), %rdi
callq 0x1fc0
movq (%rsp), %rdi
movq %rax, %rsi
movslq 0x1c(%rsp), %rax
addq %rax, %rsi
callq 0x1f80
movq %rax, 0x8(%rsp)
leaq 0x120(%rsp), %rdi
callq 0x1fc0
movq %rax, %rcx
movq 0x8(%rsp), %rax
subq %rcx, %rax
movl %eax, %edx
movslq 0x18(%rsp), %rcx
leaq 0x20(%rsp), %rax
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x15c2
jmp 0x1659
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x15ab
movl $0x7b, %edi
callq 0x1110
movl $0x0, 0x14(%rsp)
movslq 0x14(%rsp), %rax
cmpq $0x8, %rax
jae 0x16dc
movl $0x0, 0x10(%rsp)
movslq 0x10(%rsp), %rax
cmpq $0x8, %rax
jae 0x16cd
movslq 0x14(%rsp), %rcx
leaq 0x20(%rsp), %rax
shlq $0x5, %rcx
addq %rcx, %rax
movslq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0x7958(%rip), %rdi      # 0x9011
movb $0x0, %al
callq 0x1030
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x168e
jmp 0x16cf
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x167b
leaq 0x7ae5(%rip), %rdi      # 0x91c8
movb $0x0, %al
callq 0x1030
addq $0x128, %rsp            # imm = 0x128
retq
nopw %cs:(%rax,%rax)
// File: wx-csy[P]librmq/prep.cpp
// Function: print_lookup_pref(std::array<unsigned char, 8ul>)
void print_lookup_pref(perm_t perm) {
    putchar('{');
    for (int i = 1; i <= SEG_LENGTH; i++) {
        int value = std::min_element(perm.begin(), perm.begin() + i) - perm.begin(); 
        printf("%d,", value);
    }
    printf("},\n");
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x7b, %edi
callq 0x1110
movl $0x1, 0x1c(%rsp)
movslq 0x1c(%rsp), %rax
cmpq $0x8, %rax
ja 0x1791
leaq 0x20(%rsp), %rdi
callq 0x1fc0
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1fc0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movslq 0x1c(%rsp), %rax
addq %rax, %rsi
callq 0x1f80
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1fc0
movq %rax, %rcx
movq 0x10(%rsp), %rax
subq %rcx, %rax
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %esi
leaq 0x7894(%rip), %rdi      # 0x9011
movb $0x0, %al
callq 0x1030
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x171b
leaq 0x7a30(%rip), %rdi      # 0x91c8
movb $0x0, %al
callq 0x1030
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: wx-csy[P]librmq/prep.cpp
// Function: print_lookup_suf(std::array<unsigned char, 8ul>)
void print_lookup_suf(perm_t perm) {
    putchar('{');
    for (int i = 0; i < SEG_LENGTH; i++) {
        int value = std::min_element(perm.begin() + i, perm.end()) - perm.begin(); 
        printf("%d,", value);
    }
    printf("},\n");
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x7b, %edi
callq 0x1110
movl $0x0, 0x1c(%rsp)
movslq 0x1c(%rsp), %rax
cmpq $0x8, %rax
jae 0x1841
leaq 0x20(%rsp), %rdi
callq 0x1fc0
movslq 0x1c(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x2070
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x1f80
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1fc0
movq %rax, %rcx
movq 0x10(%rsp), %rax
subq %rcx, %rax
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %esi
leaq 0x77e4(%rip), %rdi      # 0x9011
movb $0x0, %al
callq 0x1030
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x17cb
leaq 0x7980(%rip), %rdi      # 0x91c8
movb $0x0, %al
callq 0x1030
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: wx-csy[P]librmq/prep.cpp
// Function: work()
void work() {
    perm_t perm; std::iota(perm.begin(), perm.end(), 0);
    do {
        preorder_t preorder = perm_to_preorder(perm);
        int id = tree_id.emplace(preorder, tree_id.size()).first->second;
        if (id == trees.size()) {
            trees.emplace_back(preorder);
            tree_sample.emplace(preorder, perm);
        }
        instances.emplace_back(perm, instances.size(), id);
    } while (std::next_permutation(perm.begin(), perm.end()));
}

// Assembly:
subq $0x88, %rsp
leaq 0x80(%rsp), %rdi
callq 0x1fc0
movq %rax, 0x20(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x2070
movq 0x20(%rsp), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x2090
movq 0x80(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0x13a0
movq %rax, 0x78(%rsp)
leaq 0xc850(%rip), %rdi      # 0xe108
movq %rdi, 0x10(%rsp)
callq 0x2130
movq 0x10(%rsp), %rdi
movq %rax, 0x50(%rsp)
leaq 0x78(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x20e0
movb %dl, 0x48(%rsp)
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x58(%rsp)
movb 0x48(%rsp), %al
movb %al, 0x60(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x2140
movl 0x8(%rax), %eax
movl %eax, 0x6c(%rsp)
movslq 0x6c(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0xc7d8(%rip), %rdi      # 0xe0f0
callq 0x2160
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jne 0x195d
leaq 0xc7bf(%rip), %rdi      # 0xe0f0
leaq 0x78(%rsp), %rsi
callq 0x2180
leaq 0xc7f6(%rip), %rdi      # 0xe138
leaq 0x78(%rsp), %rsi
leaq 0x80(%rsp), %rdx
callq 0x21f0
movq %rax, 0x30(%rsp)
movb %dl, 0x38(%rsp)
leaq 0xc80c(%rip), %rdi      # 0xe170
callq 0x22d0
movq %rax, 0x28(%rsp)
leaq 0xc7fb(%rip), %rdi      # 0xe170
leaq 0x80(%rsp), %rsi
leaq 0x28(%rsp), %rdx
leaq 0x6c(%rsp), %rcx
callq 0x2240
leaq 0x80(%rsp), %rdi
callq 0x1fc0
movq %rax, 0x8(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x2070
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x22f0
testb $0x1, %al
jne 0x1895
addq $0x88, %rsp
retq
nopl (%rax,%rax)
// File: wx-csy[P]librmq/prep.cpp
// Function: decision_tree_node::serialize()
void serialize() {
        if (crit < 0) {
            printf("    {-1, %d, -1, -1},\n", tree_id);
        } else {
            printf("    {%d, -1, %d, %d},\n", 
                crit, subtree[0]->id, subtree[1]->id);
        }
        if (subtree[0]) subtree[0]->serialize();
        if (subtree[1]) subtree[1]->serialize();
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x4(%rax)
jge 0x2651
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
leaq 0x6b6d(%rip), %rdi      # 0x91b5
movb $0x0, %al
callq 0x1030
jmp 0x2673
movq 0x8(%rsp), %rax
movl 0x4(%rax), %esi
movq 0x10(%rax), %rcx
movl (%rcx), %edx
movq 0x18(%rax), %rax
movl (%rax), %ecx
leaq 0x6b60(%rip), %rdi      # 0x91cc
movb $0x0, %al
callq 0x1030
movq 0x8(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x268d
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x2620
movq 0x8(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x26a7
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x2620
addq $0x18, %rsp
retq
nopl (%rax)
// File: wx-csy[P]librmq/prep.cpp
// Function: decision_tree_node::should_stop(std::vector<instance, std::allocator<instance>> const&)
static int should_stop(const std::vector<instance>& instances) {
        int tree_id = instances.front().tree_id;
        for (auto& inst : instances) 
            if (inst.tree_id != tree_id) return -1;
        return tree_id;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x3ab0
movl 0xc(%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x3940
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x3970
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x39a0
testb $0x1, %al
jne 0x37a7
jmp 0x37da
leaq 0x10(%rsp), %rdi
callq 0x39e0
movq %rax, (%rsp)
movq (%rsp), %rax
movl 0xc(%rax), %eax
cmpl 0x24(%rsp), %eax
je 0x37cc
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x37e2
jmp 0x37ce
leaq 0x10(%rsp), %rdi
callq 0x3a90
jmp 0x3792
movl 0x24(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: wx-csy[P]librmq/prep.cpp
// Function: decision_tree_node::select_criterion(std::vector<instance, std::allocator<instance>> const&)
static int select_criterion(const std::vector<instance>& instances) {
        // balance rule
        int cnt[SEG_LENGTH * SEG_LENGTH] = {0};
        for (int i = 0; i < SEG_LENGTH * SEG_LENGTH; i++) {
            for (auto& inst : instances) if (inst.bs[i]) cnt[i]++;
            cnt[i] = std::min(cnt[i], (int)instances.size() - cnt[i]);
        }
        return std::max_element(std::begin(cnt), std::end(cnt)) - cnt;
    }

// Assembly:
subq $0x148, %rsp            # imm = 0x148
movq %rdi, 0x140(%rsp)
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x10a0
movl $0x0, 0x3c(%rsp)
movslq 0x3c(%rsp), %rax
cmpq $0x40, %rax
jae 0x3903
movq 0x140(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x3940
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x3970
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x39a0
testb $0x1, %al
jne 0x3867
jmp 0x38a9
leaq 0x28(%rsp), %rdi
callq 0x39e0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0x39f0
testb $0x1, %al
jne 0x388b
jmp 0x389b
movslq 0x3c(%rsp), %rax
movl 0x40(%rsp,%rax,4), %ecx
addl $0x1, %ecx
movl %ecx, 0x40(%rsp,%rax,4)
jmp 0x389d
leaq 0x28(%rsp), %rdi
callq 0x3a90
jmp 0x3852
movslq 0x3c(%rsp), %rcx
leaq 0x40(%rsp), %rax
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x140(%rsp), %rdi
callq 0x22d0
movq 0x8(%rsp), %rdi
movslq 0x3c(%rsp), %rcx
subl 0x40(%rsp,%rcx,4), %eax
movl %eax, 0x14(%rsp)
leaq 0x14(%rsp), %rsi
callq 0x3ae0
movl (%rax), %ecx
movslq 0x3c(%rsp), %rax
movl %ecx, 0x40(%rsp,%rax,4)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x3818
leaq 0x40(%rsp), %rdi
callq 0x3b60
movq %rax, (%rsp)
leaq 0x40(%rsp), %rdi
callq 0x3b70
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x3b20
leaq 0x40(%rsp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
addq $0x148, %rsp            # imm = 0x148
retq
nopl (%rax,%rax)
// File: wx-csy[P]librmq/prep.cpp
// Function: instance::instance(std::array<unsigned char, 8ul>, int, int)
instance(perm_t perm, int perm_id, int tree_id) :
            perm_id(perm_id), tree_id(tree_id) {
        std::memset(&bs, 0, sizeof bs);
        for (int i = 0; i < SEG_LENGTH; i++)
            for (int j = 0; j < i; j++)
                bs[j * SEG_LENGTH + i] = (perm[j] < perm[i]);
    }

// Assembly:
subq $0x48, %rsp
movq %rsi, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movl %ecx, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x7c10
movq 0x10(%rsp), %rdi
movl 0x34(%rsp), %eax
movl %eax, 0x8(%rdi)
movl 0x30(%rsp), %eax
movl %eax, 0xc(%rdi)
xorl %esi, %esi
movl $0x8, %edx
callq 0x10a0
movl $0x0, 0x2c(%rsp)
movslq 0x2c(%rsp), %rax
cmpq $0x8, %rax
jae 0x7c09
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x7bf7
movslq 0x28(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x1fd0
movzbl (%rax), %eax
movl %eax, 0x8(%rsp)
movslq 0x2c(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x1fd0
movq 0x10(%rsp), %rsi
movq %rax, %rcx
movl 0x8(%rsp), %eax
movzbl (%rcx), %ecx
cmpl %ecx, %eax
setl %al
movb %al, 0xf(%rsp)
movslq 0x28(%rsp), %rdx
shlq $0x3, %rdx
movslq 0x2c(%rsp), %rax
addq %rax, %rdx
leaq 0x18(%rsp), %rdi
callq 0x7c20
movb 0xf(%rsp), %al
movzbl %al, %esi
andl $0x1, %esi
leaq 0x18(%rsp), %rdi
callq 0x7c60
leaq 0x18(%rsp), %rdi
callq 0x7cd0
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x7b63
jmp 0x7bf9
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x7b4c
addq $0x48, %rsp
retq
nop
// File: 4n6ist[P]usn_analytics/lib/usnjrnl.cpp
// Function: UsnJrnl::WriteBundledHeader(_IO_FILE*, bool)
int UsnJrnl::WriteBundledHeader(FILE *fp, bool lt) {
  string tzstr;
  tzstr = get_timezone_str(lt);

  fprintf(fp, "\"Usn\"\t");
  fprintf(fp, "\"Records\"\t");
  fprintf(fp, "\"TimeStamp(%s)\"\t", tzstr.c_str());
  fprintf(fp, "\"TimeTaken\"\t");
  fprintf(fp, "\"FileName\"\t");
  fprintf(fp, "\"Reason\"\t");
  fprintf(fp, "\"FileAttr\"\t");
  fprintf(fp, "\"FileID\"\t");
  fprintf(fp, "\"ParentID\"\t");
  fprintf(fp, "\"Path\"");
  fprintf(fp, "\n");
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x34b0
movzbl -0x11(%rbp), %esi
andl $0x1, %esi
leaq -0x58(%rbp), %rdi
callq 0x19f50
jmp 0x6bd2
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3450
leaq -0x58(%rbp), %rdi
callq 0x31d0
movq -0x10(%rbp), %rdi
leaq 0x15708(%rip), %rsi     # 0x1c2fb
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x156fd(%rip), %rsi     # 0x1c302
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3120
movq -0x70(%rbp), %rdi
movq %rax, %rdx
leaq 0x156e2(%rip), %rsi     # 0x1c30d
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x156e1(%rip), %rsi     # 0x1c31e
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x156dc(%rip), %rsi     # 0x1c32b
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x156d6(%rip), %rsi     # 0x1c337
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x156ce(%rip), %rsi     # 0x1c341
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x156c8(%rip), %rsi     # 0x1c34d
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x156c0(%rip), %rsi     # 0x1c357
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x156ba(%rip), %rsi     # 0x1c363
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x15cd6(%rip), %rsi     # 0x1c991
movb $0x0, %al
callq 0x34d0
leaq -0x38(%rbp), %rdi
callq 0x31d0
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31d0
movq -0x60(%rbp), %rdi
callq 0x35c0
nopw %cs:(%rax,%rax)
// File: 4n6ist[P]usn_analytics/lib/usnjrnl.cpp
// Function: UsnJrnl::WriteExecutedHeader(_IO_FILE*, bool)
int UsnJrnl::WriteExecutedHeader(FILE *fp, bool lt) {
  string tzstr;
  tzstr = get_timezone_str(lt);

  fprintf(fp, "\"Usn\"\t");
  fprintf(fp, "\"TimeStamp(%s)\"\t", tzstr.c_str());
  fprintf(fp, "\"ExeName\"\t");
  fprintf(fp, "\"ExeCount\"\t");
  fprintf(fp, "\"FileName\"\t");
  fprintf(fp, "\"Reason\"\t");
  fprintf(fp, "\"Records\"\t");
  fprintf(fp, "\"TimeTaken\"\t");
  fprintf(fp, "\"FileID\"");
  fprintf(fp, "\n");
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x34b0
movzbl -0x11(%rbp), %esi
andl $0x1, %esi
leaq -0x58(%rbp), %rdi
callq 0x19f50
jmp 0x7132
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3450
leaq -0x58(%rbp), %rdi
callq 0x31d0
movq -0x10(%rbp), %rdi
leaq 0x151a8(%rip), %rsi     # 0x1c2fb
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3120
movq -0x70(%rbp), %rdi
movq %rax, %rdx
leaq 0x15194(%rip), %rsi     # 0x1c30d
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x15210(%rip), %rsi     # 0x1c39b
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x15209(%rip), %rsi     # 0x1c3a6
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x1517c(%rip), %rsi     # 0x1c32b
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x15176(%rip), %rsi     # 0x1c337
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x1512f(%rip), %rsi     # 0x1c302
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x15139(%rip), %rsi     # 0x1c31e
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x151bb(%rip), %rsi     # 0x1c3b2
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x15788(%rip), %rsi     # 0x1c991
movb $0x0, %al
callq 0x34d0
leaq -0x38(%rbp), %rdi
callq 0x31d0
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31d0
movq -0x60(%rbp), %rdi
callq 0x35c0
nop
// File: 4n6ist[P]usn_analytics/lib/usnjrnl.cpp
// Function: UsnJrnl::WriteOpenedHeader(_IO_FILE*, bool)
int UsnJrnl::WriteOpenedHeader(FILE *fp, bool lt) {
  string tzstr;
  tzstr = get_timezone_str(lt);

  fprintf(fp, "\"Usn\"\t");
  fprintf(fp, "\"TimeStamp(%s)\"\t", tzstr.c_str());
  fprintf(fp, "\"Path\"\t");
  fprintf(fp, "\"FileName\"\t");
  fprintf(fp, "\"Reason\"\t");
  fprintf(fp, "\"Records\"\t");
  fprintf(fp, "\"TimeTaken\"\t");
  fprintf(fp, "\"FileID\"\t");
  fprintf(fp, "\"ParentID\"");
  fprintf(fp, "\n");
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x34b0
movzbl -0x11(%rbp), %esi
andl $0x1, %esi
leaq -0x58(%rbp), %rdi
callq 0x19f50
jmp 0x7b02
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3450
leaq -0x58(%rbp), %rdi
callq 0x31d0
movq -0x10(%rbp), %rdi
leaq 0x147d8(%rip), %rsi     # 0x1c2fb
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3120
movq -0x70(%rbp), %rdi
movq %rax, %rdx
leaq 0x147c4(%rip), %rsi     # 0x1c30d
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x148bc(%rip), %rsi     # 0x1c417
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x147be(%rip), %rsi     # 0x1c32b
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x147b8(%rip), %rsi     # 0x1c337
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x14771(%rip), %rsi     # 0x1c302
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x1477b(%rip), %rsi     # 0x1c31e
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x14798(%rip), %rsi     # 0x1c34d
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x14858(%rip), %rsi     # 0x1c41f
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x14db8(%rip), %rsi     # 0x1c991
movb $0x0, %al
callq 0x34d0
leaq -0x38(%rbp), %rdi
callq 0x31d0
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31d0
movq -0x60(%rbp), %rdi
callq 0x35c0
nop
// File: 4n6ist[P]usn_analytics/lib/usnjrnl.cpp
// Function: UsnJrnl::WriteFileNameList(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned short, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, unsigned short>>>*)
void UsnJrnl::WriteFileNameList(string name, map<string, uint16_t> *table){
  fprintf(fp_ofreport, "\n[%s] %lu files (name, count)\n", name.c_str(), (*table).size());
  int i=0;
  for(auto x: (*table)) {
    fprintf(fp_ofreport, "%s, %d\n", x.first.c_str(), x.second);
    i++;
    if(i > 1024) {
      fprintf(fp_ofreport, "reached 1024 files...skip the rest\n");
      break;
    }      
  }
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, %rax
movq -0x88(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x78(%rbp)
callq 0x3120
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb9d0
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rdx
movq %rax, %rcx
leaq 0x12d6b(%rip), %rsi     # 0x1c597
movb $0x0, %al
callq 0x34d0
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xafb0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xaef0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xafe0
testb $0x1, %al
jne 0x9872
jmp 0x9917
leaq -0x30(%rbp), %rdi
callq 0xb010
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0xb030
movq -0x80(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x90(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3120
movq -0x90(%rbp), %rdi
movq %rax, %rdx
movzwl -0x40(%rbp), %ecx
leaq 0x12b37(%rip), %rsi     # 0x1c3eb
movb $0x0, %al
callq 0x34d0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x400, -0x1c(%rbp)     # imm = 0x400
jle 0x98ec
movq -0x80(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x12b79(%rip), %rsi     # 0x1c455
movb $0x0, %al
callq 0x34d0
movl $0x2, -0x64(%rbp)
jmp 0x98f3
movl $0x0, -0x64(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xb070
movl -0x64(%rbp), %eax
testl %eax, %eax
je 0x9907
jmp 0x9905
jmp 0x9917
jmp 0x9909
leaq -0x30(%rbp), %rdi
callq 0xb090
jmp 0x985c
addq $0x90, %rsp
popq %rbp
retq
// File: 4n6ist[P]usn_analytics/lib/usnjrnl.cpp
// Function: UsnJrnl::WriteAllHeader(_IO_FILE*, bool)
int UsnJrnl::WriteAllHeader(FILE *fp, bool lt) {
  string tzstr;
  tzstr = get_timezone_str(lt);
  
  fprintf(fp, "\"Offset\"\t");
  fprintf(fp, "\"RecLength\"\t");
  fprintf(fp, "\"MajorVer\"\t");
  fprintf(fp, "\"MinorVer\"\t");
  fprintf(fp, "\"FileID\"\t");
  fprintf(fp, "\"FileSeq\"\t");
  fprintf(fp, "\"ParentID\"\t");
  fprintf(fp, "\"ParentSeq\"\t");
  fprintf(fp, "\"Usn\"\t");
  fprintf(fp, "\"TimeStamp(%s)\"\t", tzstr.c_str());
  fprintf(fp, "\"Reason\"\t");
  fprintf(fp, "\"SourceInfo\"\t");
  fprintf(fp, "\"SecurityId\"\t");
  fprintf(fp, "\"FileAttr\"\t");
  fprintf(fp, "\"FileNameLength\"\t");
  fprintf(fp, "\"FileNameOffset\"\t");
  fprintf(fp, "\"FileName\"");
  fprintf(fp, "\n");
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x34b0
movzbl -0x11(%rbp), %esi
andl $0x1, %esi
leaq -0x58(%rbp), %rdi
callq 0x19f50
jmp 0x9952
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3450
leaq -0x58(%rbp), %rdi
callq 0x31d0
movq -0x10(%rbp), %rdi
leaq 0x12b92(%rip), %rsi     # 0x1c505
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x12b8a(%rip), %rsi     # 0x1c50f
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x12b85(%rip), %rsi     # 0x1c51c
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x12b7f(%rip), %rsi     # 0x1c528
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x12992(%rip), %rsi     # 0x1c34d
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x12b67(%rip), %rsi     # 0x1c534
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x12978(%rip), %rsi     # 0x1c357
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x12b4e(%rip), %rsi     # 0x1c53f
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x128f8(%rip), %rsi     # 0x1c2fb
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3120
movq -0x70(%rbp), %rdi
movq %rax, %rdx
leaq 0x128e4(%rip), %rsi     # 0x1c30d
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x128fc(%rip), %rsi     # 0x1c337
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x12aff(%rip), %rsi     # 0x1c54c
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x12afb(%rip), %rsi     # 0x1c55a
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x128d0(%rip), %rsi     # 0x1c341
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x12ae5(%rip), %rsi     # 0x1c568
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x12ae5(%rip), %rsi     # 0x1c57a
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x12ae5(%rip), %rsi     # 0x1c58c
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x12ed8(%rip), %rsi     # 0x1c991
movb $0x0, %al
callq 0x34d0
leaq -0x38(%rbp), %rdi
callq 0x31d0
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31d0
movq -0x60(%rbp), %rdi
callq 0x35c0
nop
// File: 4n6ist[P]usn_analytics/lib/usnrecord.cpp
// Function: UsnRecord::IsValidRecord(unsigned long)
int UsnRecord::IsValidRecord(uint64_t _offset) {

  UsnRecord::ReadRecord(_offset);

  // validation check
  if(usn_record.RecordLength < 64 || usn_record.RecordLength > 576 || usn_record.RecordLength % 8 != 0)
    return NOT_RECORD;
      
  if(usn_record.MinorVersion != 0)
    return NOT_RECORD;
  
  if(usn_record.MajorVersion == 2) {
    if(usn_record.FileNameOffset != 60)
      return NOT_RECORD;
	  if(is_valid_ts(usn_record.TimeStamp) && is_valid_usn(usn_record.Usn)
      && usn_record.Reason != 0 && usn_record.FileNameLength < 512 && usn_record.FileNameLength % 2 == 0)
		  return V2_RECORD;
	  else
		  return CORRUPT_RECORD;
  }
  else if(usn_record.MajorVersion == 3)
    return V3_RECORD;
  else if(usn_record.MajorVersion == 4)
    return V4_RECORD;
  else
    return NOT_RECORD;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x18(%rbp), %rsi
callq 0x16590
movq -0x20(%rbp), %rax
cmpl $0x40, 0x10(%rax)
jb 0x16497
movq -0x20(%rbp), %rax
cmpl $0x240, 0x10(%rax)      # imm = 0x240
ja 0x16497
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x7, %eax
cmpl $0x0, %eax
je 0x164a3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1657b
movq -0x20(%rbp), %rax
movzwl 0x16(%rax), %eax
cmpl $0x0, %eax
je 0x164bc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1657b
movq -0x20(%rbp), %rax
movzwl 0x14(%rax), %eax
cmpl $0x2, %eax
jne 0x16548
movq -0x20(%rbp), %rax
movzwl 0x4a(%rax), %eax
cmpl $0x3c, %eax
je 0x164e2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1657b
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x17910
testb $0x1, %al
jne 0x164f5
jmp 0x1653f
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x178e0
testb $0x1, %al
jne 0x16508
jmp 0x1653f
movq -0x20(%rbp), %rax
cmpl $0x0, 0x38(%rax)
je 0x1653f
movq -0x20(%rbp), %rax
movzwl 0x48(%rax), %eax
cmpl $0x200, %eax            # imm = 0x200
jge 0x1653f
movq -0x20(%rbp), %rax
movzwl 0x48(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x1653f
movl $0x2, -0x4(%rbp)
jmp 0x1657b
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x1657b
movq -0x20(%rbp), %rax
movzwl 0x14(%rax), %eax
cmpl $0x3, %eax
jne 0x1655e
movl $0x3, -0x4(%rbp)
jmp 0x1657b
movq -0x20(%rbp), %rax
movzwl 0x14(%rax), %eax
cmpl $0x4, %eax
jne 0x16574
movl $0x4, -0x4(%rbp)
jmp 0x1657b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 4n6ist[P]usn_analytics/lib/usnrecord.cpp
// Function: UsnRecord::ReadRecord(unsigned long)
int UsnRecord::ReadRecord(uint64_t _offset) {
  
  offset = _offset;
  data = (unsigned char*)malloc(sizeof(USN_RECORD_V2));

  fseeko64(fp_in, offset, SEEK_SET);

  if(fread(data, 1, sizeof(USN_RECORD_V2), fp_in) != sizeof(USN_RECORD_V2)) {
    free(data);
    return -1;
  }

  memcpy(&(usn_record), data, sizeof(USN_RECORD_V2));
    
  free(data);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, 0x4c(%rax)
movl $0x3c, %edi
callq 0x3490
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq (%rax), %rdi
movq 0x4c(%rax), %rsi
xorl %edx, %edx
callq 0x3580
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq (%rax), %rcx
movl $0x1, %esi
movl $0x3c, %edx
callq 0x34f0
cmpq $0x3c, %rax
je 0x16609
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3430
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x16636
movq -0x20(%rbp), %rax
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rax), %rsi
movl $0x3c, %edx
callq 0x3290
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3430
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 4n6ist[P]usn_analytics/lib/usnrecord.cpp
// Function: UsnRecord::ParseRecord()
int UsnRecord::ParseRecord() {
  
  cid = uint32_t(usn_record.FileReferenceNumber & 0x0000FFFFFFFFFFFF);
  cid_seq = uint16_t(usn_record.FileReferenceNumber >> 48);
  pid = uint32_t(usn_record.ParentFileReferenceNumber & 0x0000FFFFFFFFFFFF);
  pid_seq = uint16_t(usn_record.ParentFileReferenceNumber >> 48);
  UsnRecord::GetFileName();

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x18(%rdi), %rax
movl %eax, 0x54(%rdi)
movq 0x18(%rdi), %rax
shrq $0x30, %rax
movw %ax, 0x58(%rdi)
movabsq $0xffffffffffff, %rax   # imm = 0xFFFFFFFFFFFF
andq 0x20(%rdi), %rax
movl %eax, 0x5a(%rdi)
movq 0x20(%rdi), %rax
shrq $0x30, %rax
movw %ax, 0x5e(%rdi)
callq 0x166a0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 4n6ist[P]usn_analytics/lib/usnrecord.cpp
// Function: UsnRecord::GetFileName()
int UsnRecord::GetFileName() {

  data = (unsigned char*)malloc(usn_record.FileNameLength);
  fseeko64(fp_in, offset + usn_record.FileNameOffset, SEEK_SET);
  if(fread(data, 1, usn_record.FileNameLength, fp_in) != usn_record.FileNameLength) {
    free(data);
    return -1;
  }

  file_name = UTF16toUTF8((char16_t*)(data), usn_record.FileNameLength/2);

  // remove illegal characer
  size_t pos;
  while((pos = file_name.find_first_of("/:*?\"<>|\\\t\r\n")) != string::npos)
    file_name.erase(pos, 1);
  
  if (usn_record.FileAttributes & FOLDER)
    file_name += "\\";
  
  free(data);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movzwl 0x48(%rax), %eax
movl %eax, %edi
callq 0x3490
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq (%rax), %rdi
movq 0x4c(%rax), %rsi
movzwl 0x4a(%rax), %eax
addq %rax, %rsi
xorl %edx, %edx
callq 0x3580
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
movzwl 0x48(%rax), %ecx
movl %ecx, %edx
movq (%rax), %rcx
movl $0x1, %esi
callq 0x34f0
movq -0x40(%rbp), %rcx
movzwl 0x48(%rcx), %ecx
cmpq %rcx, %rax
je 0x16720
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3430
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x167ca
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rsi
movzwl 0x48(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %edx
leaq -0x30(%rbp), %rdi
callq 0x19ae0
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
leaq -0x30(%rbp), %rsi
callq 0x3450
leaq -0x30(%rbp), %rdi
callq 0x31d0
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
leaq 0x5fa2(%rip), %rsi      # 0x1c70a
xorl %eax, %eax
movl %eax, %edx
callq 0x3170
movq %rax, -0x38(%rbp)
cmpq $-0x1, %rax
je 0x16793
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
movq -0x38(%rbp), %rsi
movl $0x1, %edx
callq 0x30b0
jmp 0x16759
movq -0x40(%rbp), %rax
movl 0x44(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x167b6
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
leaq 0x59ef(%rip), %rsi      # 0x1c1a0
callq 0x3310
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3430
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 4n6ist[P]usn_analytics/lib/usnrecord.cpp
// Function: UsnRecord::ReadParseWriteRecord(_IO_FILE*, unsigned long)
int UsnRecord::ReadParseWriteRecord(FILE* fp, uint64_t offset) {
  UsnRecord::ReadRecord(offset);
  UsnRecord::ParseRecord();
  UsnRecord::WriteRecord(fp);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x18(%rbp), %rsi
callq 0x16590
movq -0x20(%rbp), %rdi
callq 0x16640
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16820
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 4n6ist[P]usn_analytics/lib/usnrecord.cpp
// Function: UsnMain::StoreRecord(UsnRecord*)
int UsnMain::StoreRecord(UsnRecord* ur) {
  usn = ur->usn_record.Usn;
  timestamp_i = ur->usn_record.TimeStamp;
  timestamp_s = parse_datetimemicro(ur->usn_record.TimeStamp, lt);
  file_name = ur->file_name;
  reasons_i = ur->usn_record.Reason;
  parse_reason(ur->usn_record.Reason, &(reasons_s));
  attrs_i = ur->usn_record.FileAttributes;
  parse_file_attr(ur->usn_record.FileAttributes, &(attrs_s)); 
  cid = ur->cid;
  pid = ur->pid;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq %rcx, 0xa(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
leaq 0x10672(%rip), %rax     # 0x27340
movb (%rax), %al
leaq -0x30(%rbp), %rdi
andb $0x1, %al
movzbl %al, %edx
callq 0x17b20
movq -0x38(%rbp), %rdi
addq $0x12, %rdi
leaq -0x30(%rbp), %rsi
callq 0x3450
leaq -0x30(%rbp), %rdi
callq 0x31d0
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
addq $0x3a, %rdi
callq 0x3050
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, 0x5a(%rsi)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %edi
addq $0x5e, %rsi
callq 0x18a90
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x44(%rax), %eax
movl %eax, 0x7e(%rsi)
movq -0x10(%rbp), %rax
movl 0x44(%rax), %edi
addq $0x82, %rsi
callq 0x17eb0
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x54(%rcx), %ecx
movl %ecx, 0xa2(%rax)
movq -0x10(%rbp), %rcx
movl 0x5a(%rcx), %ecx
movl %ecx, 0xa6(%rax)
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 4n6ist[P]usn_analytics/lib/usnrecord.cpp
// Function: UsnMain::StoreRecord(UsnRecord*, unsigned short, double)
int UsnMain::StoreRecord(UsnRecord* ur, uint16_t _rec_cnt, double _time_taken) {
  usn = ur->usn_record.Usn;
  rec_cnt = _rec_cnt;
  timestamp_i = ur->usn_record.TimeStamp;
  timestamp_s = parse_datetimemicro(ur->usn_record.TimeStamp, lt);
  time_taken = _time_taken;
  file_name = ur->file_name;
  reasons_i = ur->usn_record.Reason;
  parse_reason(ur->usn_record.Reason, &(reasons_s));
  attrs_i = ur->usn_record.FileAttributes;
  parse_file_attr(ur->usn_record.FileAttributes, &(attrs_s)); 
  cid = ur->cid;
  pid = ur->pid;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, (%rax)
movw -0x12(%rbp), %cx
movw %cx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq %rcx, 0xa(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
leaq 0x1056e(%rip), %rax     # 0x27340
movb (%rax), %al
leaq -0x40(%rbp), %rdi
andb $0x1, %al
movzbl %al, %edx
callq 0x17b20
movq -0x48(%rbp), %rdi
addq $0x12, %rdi
leaq -0x40(%rbp), %rsi
callq 0x3450
leaq -0x40(%rbp), %rdi
callq 0x31d0
movq -0x48(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x32(%rdi)
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
addq $0x3a, %rdi
callq 0x3050
movq -0x48(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, 0x5a(%rsi)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %edi
addq $0x5e, %rsi
callq 0x18a90
movq -0x48(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x44(%rax), %eax
movl %eax, 0x7e(%rsi)
movq -0x10(%rbp), %rax
movl 0x44(%rax), %edi
addq $0x82, %rsi
callq 0x17eb0
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x54(%rcx), %ecx
movl %ecx, 0xa2(%rax)
movq -0x10(%rbp), %rcx
movl 0x5a(%rcx), %ecx
movl %ecx, 0xa6(%rax)
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
// File: 4n6ist[P]usn_analytics/lib/usnrecord.cpp
// Function: UsnMain::WriteBundledRecord(_IO_FILE*)
int UsnMain::WriteBundledRecord(FILE *fp) {
  fprintf(fp, "\"%llu\"\t", usn);
  fprintf(fp, "\"%u\"\t", rec_cnt);
  fprintf(fp, "\"%s\"\t", timestamp_s.c_str());
  fprintf(fp, "\"%f\"\t", time_taken);
  fprintf(fp, "\"%s\"\t", file_name.c_str());
  fprintf(fp, "\"%s\"\t", reasons_s.c_str());
  fprintf(fp, "\"%s\"\t", attrs_s.c_str());
  fprintf(fp, "\"%u\"\t", cid);
  fprintf(fp, "\"%u\"\t", pid);
  fprintf(fp, "\"%s\"\t", file_path.c_str());
  fprintf(fp, "\n");
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq (%rax), %rdx
leaq 0x5871(%rip), %rsi      # 0x1c717
movb $0x0, %al
callq 0x34d0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movzwl 0x8(%rax), %edx
leaq 0x585f(%rip), %rsi      # 0x1c71f
movb $0x0, %al
callq 0x34d0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x12, %rdi
callq 0x3120
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq 0x5842(%rip), %rsi      # 0x1c72c
movb $0x0, %al
callq 0x34d0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movsd 0x32(%rax), %xmm0
leaq 0x584a(%rip), %rsi      # 0x1c74f
movb $0x1, %al
callq 0x34d0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x3a, %rdi
callq 0x3120
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x57fd(%rip), %rsi      # 0x1c72c
movb $0x0, %al
callq 0x34d0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x5e, %rdi
callq 0x3120
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x57d3(%rip), %rsi      # 0x1c72c
movb $0x0, %al
callq 0x34d0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x82, %rdi
callq 0x3120
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x57a6(%rip), %rsi      # 0x1c72c
movb $0x0, %al
callq 0x34d0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0xa2(%rax), %edx
leaq 0x577d(%rip), %rsi      # 0x1c71f
movb $0x0, %al
callq 0x34d0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0xa6(%rax), %edx
leaq 0x5761(%rip), %rsi      # 0x1c71f
movb $0x0, %al
callq 0x34d0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0xaa, %rdi
callq 0x3120
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq 0x5741(%rip), %rsi      # 0x1c72c
movb $0x0, %al
callq 0x34d0
movq -0x10(%rbp), %rdi
leaq 0x5994(%rip), %rsi      # 0x1c991
movb $0x0, %al
callq 0x34d0
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)