LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x82e1
movq %rbx, %rdi
callq 0x8e54
testq %r14, %r14
je 0xaf35
movq %r14, %rax
cmpb $0x0, 0x24(%rax)
jne 0xaf08
movq 0x58(%rax), %rax
testq %rax, %rax
jne 0xaef7
jmp 0xaf1e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8a48
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8c1a
movq %r14, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xab41
movq 0x58(%r15), %r15
testq %r15, %r15
jne 0xaf21
movq 0x112bc(%rip), %rdi     # 0x1c1f8
movq %rbx, %rsi
callq 0x31d0
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3230
leaq 0x112d8(%rip), %rax     # 0x1c230
cmpb $0x1, (%rax)
jne 0xaf76
leaq 0xba81(%rip), %rdi      # 0x169e5
movl $0x11, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3370
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3230
movq 0x11276(%rip), %rdi     # 0x1c200
movq %rbx, %rsi
callq 0x31d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xad29
leaq 0xb313(%rip), %rdi      # 0x162b7
movl $0x3, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3370
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
callq 0x36ef
movq 0xea37(%rip), %rbx      # 0x11fd0
leaq 0x9a82(%rip), %rsi      # 0xd022
movl $0x14, %edx
movq %rbx, %rdi
callq 0x31d0
movq 0xec1c(%rip), %rsi      # 0x121d0
movq 0xec1d(%rip), %rdx      # 0x121d8
movq %rbx, %rdi
callq 0x31d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3110
movq %rax, %rbx
leaq 0x9a40(%rip), %rsi      # 0xd037
movl $0x16, %edx
movq %rax, %rdi
callq 0x31d0
movq 0xec05(%rip), %rsi      # 0x12210
movq 0xec06(%rip), %rdx      # 0x12218
movq %rbx, %rdi
callq 0x31d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3110
movq %rax, %rbx
leaq 0x9a00(%rip), %rsi      # 0xd04e
movl $0x16, %edx
movq %rax, %rdi
callq 0x31d0
movzbl 0xebce(%rip), %esi      # 0x12230
movq %rbx, %rdi
callq 0x3280
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3110
movq %rax, %rbx
leaq 0x99c7(%rip), %rsi      # 0xd065
movl $0x18, %edx
movq %rax, %rdi
callq 0x31d0
movq 0xeb3e(%rip), %rsi      # 0x121f0
movq 0xeb3f(%rip), %rdx      # 0x121f8
movq %rbx, %rdi
callq 0x31d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3110
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
leaq 0x8(%rsp), %r14
movq %rdi, (%r14)
leaq 0x10(%rsp), %rbx
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rdi
movl $0xff, %esi
callq 0x1090
movl $0x1, %eax
xorl %ecx, %ecx
leaq (%rsp,%rax), %rdx
addq $0x8, %rdx
leaq -0x1(%rax), %rsi
movq %rcx, %rdi
xorl %r8d, %r8d
leaq (%rsp,%r8), %r9
addq $0x8, %r9
leaq (%rsp,%r8), %r10
addq $0x9, %r10
cmpq %rdx, %r10
je 0x184d
movb (%r9), %r11b
movq %rdi, %r15
movzbl (%r10), %ebp
cmpb %r11b, %bpl
movzbl %r11b, %r11d
cmovbl %ebp, %r11d
cmovbq %r10, %r9
incq %r10
decq %r15
jne 0x1832
subl %r14d, %r9d
movq %r8, %r10
shlq $0x5, %r10
addq %rsp, %r10
addq $0x10, %r10
movl %r9d, (%r10,%rsi,4)
incq %r8
decq %rdi
cmpq %rax, %r8
jne 0x1817
incq %rax
incq %rcx
cmpq $0x9, %rax
jne 0x1805
movl $0x7b, %edi
callq 0x1100
leaq 0x179f(%rip), %r14      # 0x3029
xorl %r15d, %r15d
xorl %r12d, %r12d
movl (%rbx,%r12,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1030
incq %r12
cmpq $0x8, %r12
jne 0x1890
incq %r15
addq $0x20, %rbx
cmpq $0x8, %r15
jne 0x188d
leaq 0x1970(%rip), %rdi      # 0x322b
callq 0x1140
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x9(%rsp), %r14
movq %rdi, -0x1(%r14)
movl $0x7b, %edi
callq 0x1100
movl $0x1, %r15d
leaq 0x8(%rsp), %r12
leaq 0x1727(%rip), %rbx      # 0x3029
xorl %r13d, %r13d
movq %r12, %rsi
cmpq $0x1, %r15
je 0x1933
movb 0x8(%rsp), %al
movq %r13, %rcx
movq %r14, %rdx
movq %r12, %rsi
movzbl (%rdx), %edi
cmpb %al, %dil
movzbl %al, %eax
cmovbl %edi, %eax
cmovbq %rdx, %rsi
incq %rdx
decq %rcx
jne 0x191b
subl %r12d, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1030
incq %r15
incq %r13
cmpq $0x9, %r15
jne 0x1905
leaq 0x18d8(%rip), %rdi      # 0x322b
callq 0x1140
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %r15
movq %rdi, (%r15)
movl $0x7b, %edi
callq 0x1100
movl $0x1, %eax
leaq 0x169c(%rip), %r14      # 0x3029
xorl %ebx, %ebx
leaq (%rsp,%rbx), %rsi
addq $0x8, %rsi
movq %rax, %rbx
movb (%rsi), %al
movq %rbx, %rcx
leaq (%rsp,%rcx), %rdx
addq $0x8, %rdx
movzbl (%rdx), %edi
cmpb %al, %dil
movzbl %al, %eax
cmovbl %edi, %eax
cmovbq %rdx, %rsi
incq %rcx
cmpq $0x8, %rcx
jne 0x199f
subl %r15d, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1030
leaq 0x1(%rbx), %rax
cmpq $0x8, %rax
jne 0x198f
leaq 0x164b(%rip), %rdi      # 0x3029
movl %ebx, %esi
xorl %eax, %eax
callq 0x1030
leaq 0x183d(%rip), %rdi      # 0x322b
callq 0x1140
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movabsq $0x706050403020100, %rax # imm = 0x706050403020100
leaq 0x28(%rsp), %rbx
movq %rax, -0x8(%rbx)
leaq 0x18(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0x20(%rsp), %r13
leaq 0x4734(%rip), %rbp      # 0x6168
leaq 0xc(%rsp), %r14
movq 0x20(%rsp), %rdi
callq 0x156c
movq %rax, 0x18(%rsp)
movq 0x46d9(%rip), %rax      # 0x6128
movq %rax, 0x10(%rsp)
leaq 0x46a5(%rip), %rdi      # 0x6100
movq %r15, %rsi
movq %r12, %rdx
callq 0x2690
movslq 0x28(%rax), %rax
movl %eax, 0xc(%rsp)
movq 0x467b(%rip), %rsi      # 0x60f0
movq %rsi, %rcx
subq 0x4669(%rip), %rcx      # 0x60e8
sarq $0x3, %rcx
cmpq %rax, %rcx
jne 0x1ac4
cmpq 0x4669(%rip), %rsi      # 0x60f8
je 0x1aa3
movq 0x18(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x464f(%rip)      # 0x60f0
jmp 0x1ab2
leaq 0x463e(%rip), %rdi      # 0x60e8
movq %r15, %rdx
callq 0x2800
leaq 0x4677(%rip), %rdi      # 0x6130
movq %r15, %rsi
movq %r13, %rdx
callq 0x293c
movq 0x46a5(%rip), %rax      # 0x6170
subq 0x4696(%rip), %rax      # 0x6168
sarq $0x4, %rax
movq %rax, 0x10(%rsp)
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x1b9c
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2c34
testb %al, %al
jne 0x1a39
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wx-csy[P]librmq/prep.cpp
// Function: decision_tree_node::decision_tree_node(std::vector<instance, std::allocator<instance>> const&, int)
decision_tree_node(const std::vector<instance>& instances, int dep) {
        id = next_node_id++;
        tree_id = should_stop(instances);
        if (tree_id >= 0) {
            crit = -1;
        } else {
            crit = select_criterion(instances);
            std::vector<instance> subtree_inst[2];
            for (auto& inst : instances) 
                subtree_inst[inst.bs[crit]].push_back(inst);
            for (int i = 0; i < 2; i++)
                subtree[i] = new decision_tree_node(subtree_inst[i], dep + 1);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, 0xc(%rsp)
movq %rsi, %r15
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movl 0x4565(%rip), %eax      # 0x6160
leal 0x1(%rax), %ecx
movl %ecx, 0x455c(%rip)      # 0x6160
movl %eax, (%rdi)
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
movl 0xc(%rcx), %eax
cmpq %rdx, %rcx
je 0x1c20
cmpl %eax, 0xc(%rcx)
jne 0x1c35
addq $0x10, %rcx
jmp 0x1c10
movl %eax, 0x8(%r14)
testl %eax, %eax
js 0x1c3d
movl $0xffffffff, 0x4(%r14)  # imm = 0xFFFFFFFF
jmp 0x1d17
movl $0xffffffff, 0x8(%r14)  # imm = 0xFFFFFFFF
movq %r15, %rdi
callq 0x1f6e
movl %eax, 0x4(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq (%r15), %r12
movq 0x8(%r15), %r15
cmpq %r15, %r12
je 0x1cab
movq (%r12), %rax
movl 0x4(%r14), %ecx
xorl %edx, %edx
btq %rcx, %rax
setb %dl
leaq (%rdx,%rdx,2), %rax
leaq (%rsp,%rax,8), %rdi
addq $0x10, %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x1c9d
movups (%r12), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rdi)
jmp 0x1ca5
movq %r12, %rdx
callq 0x201e
addq $0x10, %r12
jmp 0x1c62
addq $0x10, %r14
leaq 0x28(%rsp), %r13
incl 0xc(%rsp)
leaq 0x10(%rsp), %r15
movb $0x1, %bpl
xorl %ebx, %ebx
movl $0x20, %edi
callq 0x10d0
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movl 0xc(%rsp), %edx
callq 0x1bd6
movq %r12, (%r14,%rbx,8)
movl $0x1, %ebx
movq %r13, %r15
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x1cc2
movl $0x30, %ebx
movq -0x8(%rsp,%rbx), %rdi
testq %rdi, %rdi
je 0x1d11
movq 0x8(%rsp,%rbx), %rsi
subq %rdi, %rsi
callq 0x10e0
addq $-0x18, %rbx
jne 0x1cfa
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1d28
movq %rax, %rbx
jmp 0x1d3d
movq %rax, %rbx
movl $0x20, %esi
movq %r12, %rdi
callq 0x10e0
movl $0x30, %r14d
movq -0x8(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x1d5a
movq 0x8(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x10e0
addq $-0x18, %r14
jne 0x1d43
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1456(%rip), %r14      # 0x31cd
leaq 0x1466(%rip), %r15      # 0x31e4
movl 0x4(%rbx), %esi
testl %esi, %esi
js 0x1d9d
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
movl (%rax), %edx
movl (%rcx), %ecx
movq %r15, %rdi
xorl %eax, %eax
callq 0x1030
jmp 0x1daa
movl 0x8(%rbx), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1030
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1db8
callq 0x1d68
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x1d7e
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %r15
movq %rsp, %rbx
xorl %r14d, %r14d
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1090
movq (%r15), %rax
movq 0x8(%r15), %rdx
movq %rdx, %rsi
subq %rax, %rsi
shrq $0x4, %rsi
cmpq %rdx, %rax
je 0x1fc8
movl $0x1, %edi
movl %r14d, %ecx
shlq %cl, %rdi
movq %rax, %rcx
testq %rdi, (%rcx)
je 0x1fbf
incl (%rsp,%r14,4)
addq $0x10, %rcx
cmpq %rdx, %rcx
jne 0x1fb6
movl (%rsp,%r14,4), %ecx
movl %esi, %edi
subl %ecx, %edi
cmpl %ecx, %edi
cmovgel %ecx, %edi
movl %edi, (%rsp,%r14,4)
incq %r14
cmpq $0x40, %r14
jne 0x1fa3
movl $0x4, %eax
movl (%rsp), %ecx
leaq (%rsp,%rax), %rdx
movl (%rdx), %esi
cmpl %esi, %ecx
cmovlel %esi, %ecx
cmovlq %rdx, %rbx
addq $0x4, %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x1fea
movq %rsp, %rax
subq %rax, %rbx
shrq $0x2, %rbx
movl %ebx, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq %rsi, -0x8(%rsp)
movl %edx, 0x8(%rdi)
movl %ecx, 0xc(%rdi)
movq $0x0, (%rdi)
xorl %eax, %eax
xorl %ecx, %ecx
testq %rax, %rax
je 0x2c2a
movb -0x8(%rsp,%rax), %dl
movq %rax, %rsi
xorl %r8d, %r8d
movq %rcx, %r9
btrq %rsi, %r9
btsq %rsi, %rcx
cmpb %dl, -0x8(%rsp,%r8)
cmovaeq %r9, %rcx
incq %r8
addq $0x8, %rsi
cmpq %r8, %rax
jne 0x2c07
movq %rcx, (%rdi)
incq %rax
cmpq $0x8, %rax
jne 0x2bf8
retq
// File: /workspace/github_cpp_makefile_star2_O3/4n6ist[P]usn_analytics/lib/usnjrnl.cpp
// Function: UsnJrnl::PreProcess()
int UsnJrnl::PreProcess() {
  uint64_t usn_num = usn_set.size();

  printf("%8lu corrupt records skipped\n", corrupt_offset_set.size());
  printf("%8llu records found\n", usn_num);
  fprintf(fp_ofreport, "%8lu corrupt records skipped\n", corrupt_offset_set.size());
  fprintf(fp_ofreport, "%8llu records\n", usn_num);   

  // USN Sort & Deduplication
  sort(usn_set.begin(), usn_set.end());
  usn_set.erase(std::unique(usn_set.begin(), usn_set.end()), usn_set.end());
  
  if (usn_num != usn_set.size()) {
    printf("%8llu duplicate records found\n", usn_num - usn_set.size()); 
    printf("%8lu unique records found\n", usn_set.size()); 
    fprintf(fp_ofreport, "%8llu duplicate records\n", usn_num - usn_set.size()); 
    fprintf(fp_ofreport, "%8lu unique records\n", usn_set.size()); 
  }
  
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %r14
movq 0x40(%rdi), %rsi
subq 0x20(%rdi), %r14
sarq $0x3, %r14
subq 0x38(%rdi), %rsi
sarq $0x3, %rsi
leaq 0xb3e2(%rip), %r15      # 0xf0ec
movq %r15, %rdi
xorl %eax, %eax
callq 0x3040
leaq 0xb3ef(%rip), %rdi      # 0xf10a
movq %r14, %rsi
xorl %eax, %eax
callq 0x3040
movq 0x18(%rbx), %rdi
movq 0x40(%rbx), %rdx
subq 0x38(%rbx), %rdx
sarq $0x3, %rdx
movq %r15, %rsi
xorl %eax, %eax
callq 0x3350
movq 0x18(%rbx), %rdi
leaq 0xb3d5(%rip), %rsi      # 0xf11f
movq %r14, %rdx
xorl %eax, %eax
callq 0x3350
movq 0x20(%rbx), %r15
movq 0x28(%rbx), %r12
cmpq %r12, %r15
je 0x3dd6
movq %r12, %rax
subq %r15, %rax
sarq $0x3, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x9c04
movq %r15, %rdi
movq %r12, %rsi
callq 0x9ced
movq 0x20(%rbx), %r15
movq 0x28(%rbx), %rax
cmpq %rax, %r15
je 0x3deb
leaq 0x8(%r15), %rcx
cmpq %rax, %rcx
je 0x3deb
movq -0x8(%rcx), %rdx
leaq 0x8(%rcx), %rsi
cmpq (%rcx), %rdx
movq %rsi, %rcx
jne 0x3d9f
leaq -0x10(%rsi), %rcx
cmpq %rax, %rsi
je 0x3ddb
movq %rdx, %rdi
movq (%rsi), %rdx
cmpq %rdx, %rdi
je 0x3dd0
movq %rdx, 0x8(%rcx)
addq $0x8, %rcx
addq $0x8, %rsi
jmp 0x3db8
movq %r15, %rax
jmp 0x3deb
addq $0x8, %rcx
cmpq %rax, %rcx
je 0x3deb
movq %rcx, 0x28(%rbx)
movq %rcx, %rax
subq %r15, %rax
sarq $0x3, %rax
movq %r14, %rsi
subq %rax, %rsi
je 0x3e64
leaq 0xb32d(%rip), %rdi      # 0xf12e
xorl %eax, %eax
callq 0x3040
movq 0x28(%rbx), %rsi
subq 0x20(%rbx), %rsi
sarq $0x3, %rsi
leaq 0xb332(%rip), %rdi      # 0xf14d
xorl %eax, %eax
callq 0x3040
movq 0x18(%rbx), %rdi
movq 0x28(%rbx), %rax
subq 0x20(%rbx), %rax
sarq $0x3, %rax
subq %rax, %r14
leaq 0xb32c(%rip), %rsi      # 0xf168
movq %r14, %rdx
xorl %eax, %eax
callq 0x3350
movq 0x18(%rbx), %rdi
movq 0x28(%rbx), %rdx
subq 0x20(%rbx), %rdx
sarq $0x3, %rdx
leaq 0xb324(%rip), %rsi      # 0xf181
xorl %eax, %eax
callq 0x3350
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x20(%rsp), %rdi
movl %edx, %esi
callq 0xde4e
movq %rsp, %rdi
leaq 0x20(%rsp), %r14
movq %r14, %rsi
callq 0x3300
movq (%r14), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x61b1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3230
leaq 0x9141(%rip), %rdi      # 0xf2f9
movl $0x6, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34b0
leaq 0x912f(%rip), %rdi      # 0xf300
movl $0xa, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34b0
movq (%rsp), %rdx
leaq 0x911d(%rip), %rsi      # 0xf30b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3350
leaq 0x911d(%rip), %rdi      # 0xf31c
movl $0xc, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34b0
leaq 0x9111(%rip), %rdi      # 0xf329
movl $0xb, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34b0
leaq 0x9104(%rip), %rdi      # 0xf335
movl $0x9, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34b0
leaq 0x90f5(%rip), %rdi      # 0xf33f
movl $0xb, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34b0
leaq 0x90e8(%rip), %rdi      # 0xf34b
movl $0x9, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34b0
leaq 0x90d9(%rip), %rdi      # 0xf355
movl $0xb, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34b0
leaq 0x90cc(%rip), %rdi      # 0xf361
movl $0x6, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34b0
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3310
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x62ca
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3230
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x62ef
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x20(%rsp), %rdi
movl %edx, %esi
callq 0xde4e
movq %rsp, %rdi
leaq 0x20(%rsp), %r14
movq %r14, %rsi
callq 0x3300
movq (%r14), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x68a5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3230
leaq 0x8a4d(%rip), %rdi      # 0xf2f9
movl $0x6, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34b0
movq (%rsp), %rdx
leaq 0x8a42(%rip), %rsi      # 0xf30b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3350
leaq 0x8abf(%rip), %rdi      # 0xf399
movl $0xa, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34b0
leaq 0x8ab1(%rip), %rdi      # 0xf3a4
movl $0xb, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34b0
leaq 0x8a1d(%rip), %rdi      # 0xf329
movl $0xb, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34b0
leaq 0x8a10(%rip), %rdi      # 0xf335
movl $0x9, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34b0
leaq 0x89c2(%rip), %rdi      # 0xf300
movl $0xa, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34b0
leaq 0x89c5(%rip), %rdi      # 0xf31c
movl $0xc, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34b0
leaq 0x8a40(%rip), %rdi      # 0xf3b0
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34b0
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3310
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x69a5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3230
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x69ca
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x20(%rsp), %rdi
movl %edx, %esi
callq 0xde4e
movq %rsp, %rdi
leaq 0x20(%rsp), %r14
movq %r14, %rsi
callq 0x3300
movq (%r14), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x70a9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3230
leaq 0x8249(%rip), %rdi      # 0xf2f9
movl $0x6, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34b0
movq (%rsp), %rdx
leaq 0x823e(%rip), %rsi      # 0xf30b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3350
leaq 0x832e(%rip), %rdi      # 0xf40c
movl $0x7, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34b0
leaq 0x8232(%rip), %rdi      # 0xf329
movl $0xb, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34b0
leaq 0x8225(%rip), %rdi      # 0xf335
movl $0x9, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34b0
leaq 0x81d7(%rip), %rdi      # 0xf300
movl $0xa, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34b0
leaq 0x81da(%rip), %rdi      # 0xf31c
movl $0xc, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34b0
leaq 0x81f0(%rip), %rdi      # 0xf34b
movl $0x9, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34b0
leaq 0x82a0(%rip), %rdi      # 0xf414
movl $0xa, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34b0
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3310
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x71a9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3230
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x71ce
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq (%rsi), %rdx
movq 0x28(%rbx), %rcx
leaq 0x6ef8(%rip), %rsi      # 0xf58c
xorl %eax, %eax
callq 0x3350
movq 0x18(%rbx), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
je 0x874e
movl $0x401, %r12d           # imm = 0x401
leaq 0x10(%rsp), %rbp
leaq 0x6d2b(%rip), %r13      # 0xf3e9
movq %rbp, (%rsp)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x95ce
movzwl 0x40(%r15), %ecx
movw %cx, 0x20(%rsp)
movq 0x18(%r14), %rdi
movq (%rsp), %rdx
movq %r13, %rsi
xorl %eax, %eax
callq 0x3350
decl %r12d
je 0x871e
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x870c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3230
movq %r15, %rdi
callq 0x3150
movq %rax, %r15
cmpq %rbx, %rax
jne 0x86be
jmp 0x874e
movq 0x18(%r14), %rcx
leaq 0x6d21(%rip), %rdi      # 0xf44a
movl $0x23, %esi
movl $0x1, %edx
callq 0x34b0
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x874e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3230
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
callq 0xbba2
movl 0x10(%rbx), %ecx
leal -0x40(%rcx), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x200, %edx            # imm = 0x200
ja 0xbb99
andl $0x7, %ecx
jne 0xbb99
cmpw $0x0, 0x16(%rbx)
jne 0xbb99
movzwl 0x14(%rbx), %ecx
cmpl $0x4, %ecx
je 0xbb94
cmpl $0x3, %ecx
je 0xbb90
cmpl $0x2, %ecx
jne 0xbb99
cmpw $0x3c, 0x4a(%rbx)
jne 0xbb99
movq 0x30(%rbx), %rdi
callq 0xc897
testb %al, %al
je 0xbb89
movq 0x28(%rbx), %rdi
callq 0xc886
testb %al, %al
je 0xbb89
cmpl $0x0, 0x38(%rbx)
je 0xbb89
movzwl 0x48(%rbx), %eax
testl $0xfe01, %eax           # imm = 0xFE01
je 0xbb9b
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0xbb99
movl %ecx, %eax
jmp 0xbb99
movl $0x4, %eax
popq %rbx
retq
movl $0x2, %eax
jmp 0xbb99
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, 0x4c(%rdi)
movl $0x3c, %edi
callq 0x3320
movq %rax, 0x8(%r14)
movq (%r14), %rdi
xorl %ebx, %ebx
movq %r15, %rsi
xorl %edx, %edx
callq 0x3430
movq (%r14), %rcx
movq 0x8(%r14), %rdi
movl $0x1, %esi
movl $0x3c, %edx
callq 0x3380
cmpq $0x3c, %rax
jne 0xbc13
movq 0x8(%r14), %rdi
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movups 0x20(%rdi), %xmm2
movups 0x2c(%rdi), %xmm3
movups %xmm0, 0x10(%r14)
movups %xmm1, 0x20(%r14)
movups %xmm2, 0x30(%r14)
movups %xmm3, 0x3c(%r14)
jmp 0xbc1c
movq 0x8(%r14), %rdi
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
callq 0x32e0
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movzwl 0x48(%rdi), %edi
callq 0x3320
movq %rax, 0x8(%rbx)
movq (%rbx), %rdi
movzwl 0x4a(%rbx), %esi
addq 0x4c(%rbx), %rsi
xorl %edx, %edx
callq 0x3430
movq (%rbx), %rcx
movq 0x8(%rbx), %rdi
movzwl 0x48(%rbx), %edx
movl $0x1, %esi
callq 0x3380
movzwl 0x48(%rbx), %edx
cmpq %rdx, %rax
jne 0xbd46
movq 0x8(%rbx), %rsi
shrl %edx
movq %rsp, %r15
movq %r15, %rdi
callq 0xdb91
leaq 0x60(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x3300
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xbcd9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3230
leaq 0x3a2a(%rip), %rsi      # 0xf70a
movl $0xc, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x33a0
cmpq $-0x1, %rax
je 0xbd24
leaq 0x3a0e(%rip), %r15      # 0xf70a
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x3080
movl $0xc, %ecx
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x33a0
cmpq $-0x1, %rax
jne 0xbcfc
testb $0x10, 0x44(%rbx)
je 0xbd39
leaq 0x346d(%rip), %rsi      # 0xf19e
movq %r14, %rdi
callq 0x34a0
movq 0x8(%rbx), %rdi
callq 0x32e0
xorl %eax, %eax
jmp 0xbd54
movq 0x8(%rbx), %rdi
callq 0x32e0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rsi
callq 0xbba2
movq 0x18(%r14), %rax
movq 0x20(%r14), %rcx
movl %eax, 0x54(%r14)
shrq $0x30, %rax
movw %ax, 0x58(%r14)
movl %ecx, 0x5a(%r14)
shrq $0x30, %rcx
movw %cx, 0x5e(%r14)
movq %r14, %rdi
callq 0xbc52
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbd92
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rsi), %rax
movq %rax, (%rdi)
movq 0x30(%rsi), %rsi
movq %rsi, 0xa(%rdi)
leaq 0x8131(%rip), %rax      # 0x14278
movzbl (%rax), %edx
movq %rsp, %r15
movq %r15, %rdi
callq 0xc9d5
leaq 0x12(%rbx), %rdi
movq %r15, %rsi
callq 0x3300
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xc17b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3230
leaq 0x60(%r14), %rsi
leaq 0x3a(%rbx), %rdi
callq 0x3120
movl 0x38(%r14), %edi
movl %edi, 0x5a(%rbx)
leaq 0x5e(%rbx), %rsi
callq 0xd383
movl 0x44(%r14), %edi
movl %edi, 0x7e(%rbx)
leaq 0x82(%rbx), %rsi
callq 0xcd87
movl 0x54(%r14), %eax
movl %eax, 0xa2(%rbx)
movl 0x5a(%r14), %eax
movl %eax, 0xa6(%rbx)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rsi), %rax
movq %rax, (%rdi)
movw %dx, 0x8(%rdi)
movq 0x30(%rsi), %rsi
movq %rsi, 0xa(%rdi)
leaq 0x807d(%rip), %rax      # 0x14278
movzbl (%rax), %edx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0xc9d5
leaq 0x12(%rbx), %rdi
movq %r15, %rsi
callq 0x3300
movq (%r15), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xc231
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3230
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x32(%rbx)
leaq 0x60(%r14), %rsi
leaq 0x3a(%rbx), %rdi
callq 0x3120
movl 0x38(%r14), %edi
movl %edi, 0x5a(%rbx)
leaq 0x5e(%rbx), %rsi
callq 0xd383
movl 0x44(%r14), %edi
movl %edi, 0x7e(%rbx)
leaq 0x82(%rbx), %rsi
callq 0xcd87
movl 0x54(%r14), %eax
movl %eax, 0xa2(%rbx)
movl 0x5a(%r14), %eax
movl %eax, 0xa6(%rbx)
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdx
leaq 0x3473(%rip), %rsi      # 0xf717
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3350
movzwl 0x8(%r14), %edx
leaq 0x3465(%rip), %r15      # 0xf71f
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3350
movq 0x12(%r14), %rdx
leaq 0x345a(%rip), %r12      # 0xf72c
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3350
movsd 0x32(%r14), %xmm0
leaq 0x3463(%rip), %rsi      # 0xf74f
movq %rbx, %rdi
movb $0x1, %al
callq 0x3350
movq 0x3a(%r14), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3350
movq 0x5e(%r14), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3350
movq 0x82(%r14), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3350
movl 0xa2(%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3350
movl 0xa6(%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3350
movq 0xaa(%r14), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3350
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3310
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/4n6ist[P]usn_analytics/lib/usnrecord.cpp
// Function: UsnExecuted::StoreRecord(UsnMain*, unsigned short)
int UsnExecuted::StoreRecord(UsnMain* um, uint16_t _exe_cnt) {
  usn = um->usn;
  timestamp_s = um->timestamp_s;
  file_name = um->file_name;
  exe_name = file_name.substr(0, file_name.size()-12); // "-XXXXXXXX.pf" length 
  transform(exe_name.begin(), exe_name.end(), exe_name.begin(), ::tolower);  
  exe_cnt = _exe_cnt;
  rec_cnt = um->rec_cnt;
  reasons_s = um->reasons_s;  
  time_taken = um->time_taken;
  cid = um->cid;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rdi)
addq $0x12, %rsi
addq $0x8, %rdi
callq 0x3120
leaq 0x3a(%r14), %rsi
leaq 0x4a(%rbx), %r15
movq %r15, %rdi
callq 0x3120
movq 0x52(%rbx), %rcx
addq $-0xc, %rcx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3250
leaq 0x28(%rbx), %rdi
movq %r12, %rsi
callq 0x3300
movq (%r12), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xc43e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3230
movq 0x30(%rbx), %r15
testq %r15, %r15
je 0xc464
movq 0x28(%rbx), %r12
xorl %r13d, %r13d
movsbl (%r12,%r13), %edi
callq 0x3360
movb %al, (%r12,%r13)
incq %r13
cmpq %r13, %r15
jne 0xc44e
movw %bp, 0x48(%rbx)
movzwl 0x8(%r14), %eax
movw %ax, 0x8a(%rbx)
leaq 0x5e(%r14), %rsi
leaq 0x6a(%rbx), %rdi
callq 0x3120
movsd 0x32(%r14), %xmm0
movsd %xmm0, 0x8c(%rbx)
movl 0xa2(%r14), %eax
movl %eax, 0x94(%rbx)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/4n6ist[P]usn_analytics/lib/usnrecord.cpp
// Function: UsnExecuted::WriteExecutedRecord(_IO_FILE*)
int UsnExecuted::WriteExecutedRecord(FILE *fp) {
  fprintf(fp, "\"%llu\"\t", usn);
  fprintf(fp, "\"%s\"\t", timestamp_s.c_str());
  fprintf(fp, "\"%s\"\t", exe_name.c_str());
  fprintf(fp, "\"%u\"\t", exe_cnt);
  fprintf(fp, "\"%s\"\t", file_name.c_str());
  fprintf(fp, "\"%s\"\t", reasons_s.c_str());
  fprintf(fp, "\"%u\"\t", rec_cnt);
  fprintf(fp, "\"%f\"\t", time_taken);
  fprintf(fp, "\"%u\"\t", cid);
  fprintf(fp, "\n");
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdx
leaq 0x3251(%rip), %rsi      # 0xf717
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3350
movq 0x8(%r14), %rdx
leaq 0x3251(%rip), %r12      # 0xf72c
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3350
movq 0x28(%r14), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3350
movzwl 0x48(%r14), %edx
leaq 0x321a(%rip), %r15      # 0xf71f
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3350
movq 0x4a(%r14), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3350
movq 0x6a(%r14), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3350
movzwl 0x8a(%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3350
movsd 0x8c(%r14), %xmm0
leaq 0x31f6(%rip), %rsi      # 0xf74f
movq %rbx, %rdi
movb $0x1, %al
callq 0x3350
movl 0x94(%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3350
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3310
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/4n6ist[P]usn_analytics/lib/usnrecord.cpp
// Function: UsnOpened::StoreRecord(UsnMain*)
int UsnOpened::StoreRecord(UsnMain* um) {
  usn = um->usn;
  timestamp_s = um->timestamp_s;
  file_path = um->file_path;
  file_name = um->file_name;
  reasons_s = um->reasons_s;  
  rec_cnt = um->rec_cnt;
  time_taken = um->time_taken;
  cid = um->cid;
  pid = um->pid;
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rdi)
addq $0x12, %rsi
addq $0x8, %rdi
callq 0x3120
leaq 0xaa(%r14), %rsi
leaq 0x28(%rbx), %rdi
callq 0x3120
leaq 0x3a(%r14), %rsi
leaq 0x48(%rbx), %rdi
callq 0x3120
leaq 0x5e(%r14), %rsi
leaq 0x68(%rbx), %rdi
callq 0x3120
movzwl 0x8(%r14), %eax
movw %ax, 0x88(%rbx)
movsd 0x32(%r14), %xmm0
movsd %xmm0, 0x8a(%rbx)
movq 0xa2(%r14), %rax
movq %rax, 0x92(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/4n6ist[P]usn_analytics/lib/usnrecord.cpp
// Function: UsnOpened::WriteOpenedRecord(_IO_FILE*)
int UsnOpened::WriteOpenedRecord(FILE *fp) {
  fprintf(fp, "\"%llu\"\t", usn);
  fprintf(fp, "\"%s\"\t", timestamp_s.c_str());
  fprintf(fp, "\"%s\"\t", file_path.c_str());
  fprintf(fp, "\"%s\"\t", file_name.c_str());
  fprintf(fp, "\"%s\"\t", reasons_s.c_str());
  fprintf(fp, "\"%u\"\t", rec_cnt);
  fprintf(fp, "\"%f\"\t", time_taken);
  fprintf(fp, "\"%u\"\t", cid);
  fprintf(fp, "\"%u\"\t", pid);
  fprintf(fp, "\n");
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdx
leaq 0x30b6(%rip), %rsi      # 0xf717
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3350
movq 0x8(%r14), %rdx
leaq 0x30b6(%rip), %r15      # 0xf72c
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3350
movq 0x28(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3350
movq 0x48(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3350
movq 0x68(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3350
movzwl 0x88(%r14), %edx
leaq 0x305a(%rip), %r15      # 0xf71f
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3350
movsd 0x8a(%r14), %xmm0
leaq 0x306d(%rip), %rsi      # 0xf74f
movq %rbx, %rdi
movb $0x1, %al
callq 0x3350
movl 0x92(%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3350
movl 0x96(%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3350
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3310
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/4n6ist[P]usn_analytics/lib/utils.cpp
// Function: timer::~timer()
timer::~timer() {
  clock_t c_end;
  time_t t_end;
  c_end = clock();
  t_end = time(NULL);
  printf("CPU Time: %f\n", (double)(c_end-c_start) / CLOCKS_PER_SEC);
  printf("Processed Time: %ld(s)\n", (t_end-t_start));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x3130
movq %rax, %r14
xorl %edi, %edi
callq 0x3200
movq %rax, %r15
subq (%rbx), %r14
cvtsi2sd %r14, %xmm0
divsd 0x2fe8(%rip), %xmm0     # 0xf758
leaq 0x2fe9(%rip), %rdi      # 0xf760
movb $0x1, %al
callq 0x3040
subq 0x8(%rbx), %r15
leaq 0x2fe5(%rip), %rdi      # 0xf76e
movq %r15, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x3040
// File: /workspace/github_cpp_makefile_star2_O3/4n6ist[P]usn_analytics/lib/utils.cpp
// Function: is_empty_dir(char const*)
bool is_empty_dir(const char *out_dname){
  DIR *pdir;

  if((pdir = opendir(out_dname)) == NULL)
    return false;

  struct dirent *pent;

  // check there is at least one file
  for(pent = readdir(pdir); pent != NULL; pent = readdir(pdir)) {
    if(strcmp(pent->d_name, ".") != 0 && strcmp(pent->d_name, "..") != 0) {// ignore "." and ".."
      closedir(pdir);
      return false;
    }
  }
  closedir(pdir);
  return true;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
callq 0x3390
testq %rax, %rax
je 0xc7da
movq %rax, %rbx
movq %rax, %rdi
callq 0x33b0
movb $0x1, %bpl
testq %rax, %rax
je 0xc7e0
cmpb $0x2e, 0x13(%rax)
jne 0xc7de
cmpb $0x0, 0x14(%rax)
je 0xc7d0
cmpb $0x2e, 0x14(%rax)
jne 0xc7de
cmpb $0x0, 0x15(%rax)
jne 0xc7de
movq %rbx, %rdi
callq 0x33b0
jmp 0xc7b3
xorl %ebp, %ebp
jmp 0xc7e8
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x3400
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/4n6ist[P]usn_analytics/lib/utils.cpp
// Function: get_file_size(char const*)
uint64_t get_file_size(const char *in_fname) {
  FILE *fp;
#ifdef _WIN32
  struct __stat64 st;
#elif __APPLE__
  struct stat st;
#else
  struct stat64 st;
#endif
  int fd;

  fd = open(in_fname, O_RDONLY);
  if (fd == -1)
    perror("cant open file");

  fp = fdopen(fd, "rb");

  if (fp == NULL)
    perror("cant open file");

#ifdef _WIN32
  if (_fstat64(fd, &st) == -1)
#elif __APPLE__
  if (fstat(fd, &st) == -1)
#else
  if (fstat64(fd, &st) == -1)
#endif
    perror("cant get file state");

  if (fclose(fp) != 0)
    perror("cant close file");

  return st.st_size;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
xorl %esi, %esi
xorl %eax, %eax
callq 0x3170
movl %eax, %ebx
cmpl $-0x1, %eax
je 0xc84e
leaq 0x2836(%rip), %rsi      # 0xf048
movl %ebx, %edi
callq 0x3270
movq %rax, %r14
testq %rax, %rax
je 0xc85c
leaq 0x8(%rsp), %rsi
movl %ebx, %edi
callq 0x3480
cmpl $-0x1, %eax
je 0xc86a
movq %r14, %rdi
callq 0x3210
testl %eax, %eax
jne 0xc878
movq 0x38(%rsp), %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
leaq 0x2f33(%rip), %rdi      # 0xf788
callq 0x31c0
jmp 0xc80b
leaq 0x2f25(%rip), %rdi      # 0xf788
callq 0x31c0
jmp 0xc821
leaq 0x2f26(%rip), %rdi      # 0xf797
callq 0x31c0
jmp 0xc832
leaq 0x2f2c(%rip), %rdi      # 0xf7ab
callq 0x31c0
jmp 0xc83e
// File: /workspace/github_cpp_makefile_star2_O3/4n6ist[P]usn_analytics/lib/utils.cpp
// Function: parse_datetime[abi:cxx11](unsigned long, bool)
string parse_datetime(uint64_t _time, bool lt) {
  char buf[32];
  struct tm *tm_info;
  time_t epoch;

  // 11644473600 seconds from 1601/01/01 to 1970/01/01
  epoch = _time/(10*1000*1000) - 11644473600L;

  if(lt)
    tm_info = localtime(&epoch);
  else
    tm_info = gmtime(&epoch);

  strftime(buf, 20, "%Y/%m/%d %H:%M:%S", tm_info);
  
  return string(buf);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %ecx
movq %rsi, %rax
movq %rdi, %rbx
movabsq $-0x29406b2a1a85bd43, %rdx # imm = 0xD6BF94D5E57A42BD
mulq %rdx
shrq $0x17, %rdx
movabsq $-0x2b6109100, %rax     # imm = 0xFFFFFFFD49EF6F00
addq %rdx, %rax
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
testl %ecx, %ecx
je 0xc8f7
callq 0x3180
jmp 0xc8fc
callq 0x31d0
leaq 0x2eb8(%rip), %rdx      # 0xf7bb
leaq 0x10(%rsp), %r14
movl $0x14, %esi
movq %r14, %rdi
movq %rax, %rcx
callq 0x31a0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x30e0
leaq (%rsp,%rax), %rdx
addq $0x10, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x981e
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq