LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb3d2(%rip), %r15      # 0xf0ec
movq %r15, %rdi
xorl %eax, %eax
callq 0x3040
leaq 0xb3df(%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 0x3360
movq 0x18(%rbx), %rdi
leaq 0xb3c5(%rip), %rsi      # 0xf11f
movq %r14, %rdx
xorl %eax, %eax
callq 0x3360
movq 0x20(%rbx), %r15
movq 0x28(%rbx), %r12
cmpq %r12, %r15
je 0x3d9e
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 0x9b9d
movq %r15, %rdi
movq %r12, %rsi
callq 0x9c86
movq 0x20(%rbx), %rdi
movq 0x28(%rbx), %rsi
callq 0x9f1b
movq 0x28(%rbx), %rcx
cmpq %rcx, %rax
je 0x3dca
movq 0x28(%rbx), %rdx
movq %rdx, %rsi
subq %rcx, %rsi
addq %rsi, %rax
cmpq %rax, %rdx
je 0x3dca
movq %rax, 0x28(%rbx)
movq 0x28(%rbx), %rax
subq 0x20(%rbx), %rax
sarq $0x3, %rax
movq %r14, %rsi
subq %rax, %rsi
je 0x3e48
leaq 0xb349(%rip), %rdi      # 0xf12e
xorl %eax, %eax
callq 0x3040
movq 0x28(%rbx), %rsi
subq 0x20(%rbx), %rsi
sarq $0x3, %rsi
leaq 0xb34e(%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 0xb348(%rip), %rsi      # 0xf168
movq %r14, %rdx
xorl %eax, %eax
callq 0x3360
movq 0x18(%rbx), %rdi
movq 0x28(%rbx), %rdx
subq 0x20(%rbx), %rdx
sarq $0x3, %rdx
leaq 0xb340(%rip), %rsi      # 0xf181
xorl %eax, %eax
callq 0x3360
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xde82
movq %rsp, %rdi
leaq 0x20(%rsp), %r14
movq %r14, %rsi
callq 0x3300
movq (%r14), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x61af
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3230
leaq 0x9143(%rip), %rdi      # 0xf2f9
movl $0x6, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34c0
leaq 0x9131(%rip), %rdi      # 0xf300
movl $0xa, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34c0
movq (%rsp), %rdx
leaq 0x911f(%rip), %rsi      # 0xf30b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3360
leaq 0x911f(%rip), %rdi      # 0xf31c
movl $0xc, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34c0
leaq 0x9113(%rip), %rdi      # 0xf329
movl $0xb, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34c0
leaq 0x9106(%rip), %rdi      # 0xf335
movl $0x9, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34c0
leaq 0x90f7(%rip), %rdi      # 0xf33f
movl $0xb, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34c0
leaq 0x90ea(%rip), %rdi      # 0xf34b
movl $0x9, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34c0
leaq 0x90db(%rip), %rdi      # 0xf355
movl $0xb, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34c0
leaq 0x90ce(%rip), %rdi      # 0xf361
movl $0x6, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34c0
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3310
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x62c8
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 0x62ed
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x3470
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xde82
movq %rsp, %rdi
leaq 0x20(%rsp), %r14
movq %r14, %rsi
callq 0x3300
movq (%r14), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x68af
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3230
leaq 0x8a43(%rip), %rdi      # 0xf2f9
movl $0x6, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34c0
movq (%rsp), %rdx
leaq 0x8a38(%rip), %rsi      # 0xf30b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3360
leaq 0x8ab5(%rip), %rdi      # 0xf399
movl $0xa, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34c0
leaq 0x8aa7(%rip), %rdi      # 0xf3a4
movl $0xb, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34c0
leaq 0x8a13(%rip), %rdi      # 0xf329
movl $0xb, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34c0
leaq 0x8a06(%rip), %rdi      # 0xf335
movl $0x9, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34c0
leaq 0x89b8(%rip), %rdi      # 0xf300
movl $0xa, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34c0
leaq 0x89bb(%rip), %rdi      # 0xf31c
movl $0xc, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34c0
leaq 0x8a36(%rip), %rdi      # 0xf3b0
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34c0
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3310
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x69af
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 0x69d4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x3470
// File: /workspace/github_cpp_makefile_star2_O1/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 0xde82
movq %rsp, %rdi
leaq 0x20(%rsp), %r14
movq %r14, %rsi
callq 0x3300
movq (%r14), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x70a1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3230
leaq 0x8251(%rip), %rdi      # 0xf2f9
movl $0x6, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34c0
movq (%rsp), %rdx
leaq 0x8246(%rip), %rsi      # 0xf30b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3360
leaq 0x8336(%rip), %rdi      # 0xf40c
movl $0x7, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34c0
leaq 0x823a(%rip), %rdi      # 0xf329
movl $0xb, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34c0
leaq 0x822d(%rip), %rdi      # 0xf335
movl $0x9, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34c0
leaq 0x81df(%rip), %rdi      # 0xf300
movl $0xa, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34c0
leaq 0x81e2(%rip), %rdi      # 0xf31c
movl $0xc, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34c0
leaq 0x81f8(%rip), %rdi      # 0xf34b
movl $0x9, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34c0
leaq 0x82a8(%rip), %rdi      # 0xf414
movl $0xa, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x34c0
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3310
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x71a1
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 0x71c6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x3470
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6f30(%rip), %rsi      # 0xf58c
xorl %eax, %eax
callq 0x3360
movq 0x18(%rbx), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
je 0x8716
movl $0x401, %r12d           # imm = 0x401
leaq 0x10(%rsp), %rbp
leaq 0x6d63(%rip), %r13      # 0xf3e9
movq %rbp, (%rsp)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x9574
movzwl 0x40(%r15), %ecx
movw %cx, 0x20(%rsp)
movq 0x18(%r14), %rdi
movq (%rsp), %rdx
movq %r13, %rsi
xorl %eax, %eax
callq 0x3360
decl %r12d
je 0x86e6
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x86d4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3230
movq %r15, %rdi
callq 0x3150
movq %rax, %r15
cmpq %rbx, %rax
jne 0x8686
jmp 0x8716
movq 0x18(%r14), %rcx
leaq 0x6d59(%rip), %rdi      # 0xf44a
movl $0x23, %esi
movl $0x1, %edx
callq 0x34c0
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x8716
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_O1/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 0xbb9e
movl 0x10(%rbx), %ecx
leal -0x40(%rcx), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x200, %edx            # imm = 0x200
ja 0xbb95
andl $0x7, %ecx
jne 0xbb95
cmpw $0x0, 0x16(%rbx)
jne 0xbb95
movzwl 0x14(%rbx), %ecx
cmpl $0x4, %ecx
je 0xbb90
cmpl $0x3, %ecx
je 0xbb8c
cmpl $0x2, %ecx
jne 0xbb95
cmpw $0x3c, 0x4a(%rbx)
jne 0xbb95
movq 0x30(%rbx), %rdi
callq 0xc8c9
testb %al, %al
je 0xbb85
movq 0x28(%rbx), %rdi
callq 0xc8b8
testb %al, %al
je 0xbb85
cmpl $0x0, 0x38(%rbx)
je 0xbb85
movzwl 0x48(%rbx), %eax
testl $0xfe01, %eax           # imm = 0xFE01
je 0xbb97
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0xbb95
movl %ecx, %eax
jmp 0xbb95
movl $0x4, %eax
popq %rbx
retq
movl $0x2, %eax
jmp 0xbb95
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3440
movq (%r14), %rcx
movq 0x8(%r14), %rdi
movl $0x1, %esi
movl $0x3c, %edx
callq 0x3390
cmpq $0x3c, %rax
jne 0xbc0f
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 0xbc18
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_O1/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 %rax
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
movl %eax, 0x54(%rdi)
shrq $0x30, %rax
movw %ax, 0x58(%rdi)
movl %ecx, 0x5a(%rdi)
shrq $0x30, %rcx
movw %cx, 0x5e(%rdi)
callq 0xbc4e
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x28, %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 0x3440
movq (%rbx), %rcx
movq 0x8(%rbx), %rdi
movzwl 0x48(%rbx), %edx
movl $0x1, %esi
callq 0x3390
movzwl 0x48(%rbx), %edx
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpq %rdx, %rax
jne 0xbd42
movq 0x8(%rbx), %rsi
shrl %edx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xdbcd
leaq 0x60(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x3300
movq (%r15), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xbcdf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3230
leaq 0x3a24(%rip), %rsi      # 0xf70a
xorl %r15d, %r15d
movl $0xc, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x33b0
cmpq $-0x1, %rax
je 0xbd2d
leaq 0x3a05(%rip), %r12      # 0xf70a
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x3080
movl $0xc, %ecx
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x33b0
cmpq $-0x1, %rax
jne 0xbd05
testb $0x10, 0x44(%rbx)
je 0xbd42
leaq 0x3464(%rip), %rsi      # 0xf19e
movq %r14, %rdi
callq 0x34b0
movq 0x8(%rbx), %rdi
callq 0x32e0
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xbb9e
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 0xbc4e
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbd8e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x813d(%rip), %rax      # 0x14280
movzbl (%rax), %edx
movq %rsp, %r15
movq %r15, %rdi
callq 0xca07
leaq 0x12(%rbx), %rdi
movq %r15, %rsi
callq 0x3300
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xc177
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 0xd3bf
movl 0x44(%r14), %edi
movl %edi, 0x7e(%rbx)
leaq 0x82(%rbx), %rsi
callq 0xcdc3
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_O1/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 0x8089(%rip), %rax      # 0x14280
movzbl (%rax), %edx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0xca07
leaq 0x12(%rbx), %rdi
movq %r15, %rsi
callq 0x3300
movq (%r15), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xc22d
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 0xd3bf
movl 0x44(%r14), %edi
movl %edi, 0x7e(%rbx)
leaq 0x82(%rbx), %rsi
callq 0xcdc3
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_O1/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 0x3477(%rip), %rsi      # 0xf717
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3360
movzwl 0x8(%r14), %edx
leaq 0x3469(%rip), %r15      # 0xf71f
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3360
movq 0x12(%r14), %rdx
leaq 0x345e(%rip), %r12      # 0xf72c
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3360
movsd 0x32(%r14), %xmm0
leaq 0x3467(%rip), %rsi      # 0xf74f
movq %rbx, %rdi
movb $0x1, %al
callq 0x3360
movq 0x3a(%r14), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3360
movq 0x5e(%r14), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3360
movq 0x82(%r14), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3360
movl 0xa2(%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3360
movl 0xa6(%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3360
movq 0xaa(%r14), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3360
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_O1/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 0xc43a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3230
movq 0x30(%rbx), %r15
testq %r15, %r15
je 0xc460
movq 0x28(%rbx), %r12
xorl %r13d, %r13d
movsbl (%r12,%r13), %edi
callq 0x3370
movb %al, (%r12,%r13)
incq %r13
cmpq %r13, %r15
jne 0xc44a
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_O1/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 0x3255(%rip), %rsi      # 0xf717
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3360
movq 0x8(%r14), %rdx
leaq 0x3255(%rip), %r12      # 0xf72c
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3360
movq 0x28(%r14), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3360
movzwl 0x48(%r14), %edx
leaq 0x321e(%rip), %r15      # 0xf71f
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3360
movq 0x4a(%r14), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3360
movq 0x6a(%r14), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3360
movzwl 0x8a(%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3360
movsd 0x8c(%r14), %xmm0
leaq 0x31fa(%rip), %rsi      # 0xf74f
movq %rbx, %rdi
movb $0x1, %al
callq 0x3360
movl 0x94(%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3360
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_O1/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)
movl 0xa2(%r14), %eax
movl %eax, 0x92(%rbx)
movl 0xa6(%r14), %eax
movl %eax, 0x96(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x30ae(%rip), %rsi      # 0xf717
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3360
movq 0x8(%r14), %rdx
leaq 0x30ae(%rip), %r15      # 0xf72c
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3360
movq 0x28(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3360
movq 0x48(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3360
movq 0x68(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3360
movzwl 0x88(%r14), %edx
leaq 0x3052(%rip), %r15      # 0xf71f
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3360
movsd 0x8a(%r14), %xmm0
leaq 0x3065(%rip), %rsi      # 0xf74f
movq %rbx, %rdi
movb $0x1, %al
callq 0x3360
movl 0x92(%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3360
movl 0x96(%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3360
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_O1/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 0x2fe0(%rip), %xmm0     # 0xf758
leaq 0x2fe1(%rip), %rdi      # 0xf760
movb $0x1, %al
callq 0x3040
subq 0x8(%rbx), %r15
leaq 0x2fdd(%rip), %rdi      # 0xf76e
movq %r15, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x3040
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
callq 0x33a0
testq %rax, %rax
je 0xc80a
movq %rax, %rbx
movq %rax, %rdi
callq 0x33c0
movb $0x1, %bpl
testq %rax, %rax
je 0xc810
movq %rax, %r12
leaq 0x2fb8(%rip), %r14      # 0xf787
leaq 0x2fb0(%rip), %r15      # 0xf786
addq $0x13, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3350
testl %eax, %eax
je 0xc7f8
movq %r12, %rdi
movq %r15, %rsi
callq 0x3350
testl %eax, %eax
jne 0xc80e
movq %rbx, %rdi
callq 0x33c0
movq %rax, %r12
testq %rax, %rax
jne 0xc7d6
jmp 0xc810
xorl %ebp, %ebp
jmp 0xc818
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x3410
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc880
leaq 0x2804(%rip), %rsi      # 0xf048
movl %ebx, %edi
callq 0x3270
movq %rax, %r14
testq %rax, %rax
je 0xc88e
leaq 0x8(%rsp), %rsi
movl %ebx, %edi
callq 0x3490
cmpl $-0x1, %eax
je 0xc89c
movq %r14, %rdi
callq 0x3210
testl %eax, %eax
jne 0xc8aa
movq 0x38(%rsp), %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
leaq 0x2f02(%rip), %rdi      # 0xf789
callq 0x31c0
jmp 0xc83d
leaq 0x2ef4(%rip), %rdi      # 0xf789
callq 0x31c0
jmp 0xc853
leaq 0x2ef5(%rip), %rdi      # 0xf798
callq 0x31c0
jmp 0xc864
leaq 0x2efb(%rip), %rdi      # 0xf7ac
callq 0x31c0
jmp 0xc870
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc929
callq 0x3180
jmp 0xc92e
callq 0x31d0
leaq 0x2e87(%rip), %rdx      # 0xf7bc
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 0x97be
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/4n6ist[P]usn_analytics/lib/utils.cpp
// Function: parse_datetime_iso8601[abi:cxx11](unsigned long, bool)
string parse_datetime_iso8601(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, 16, "%Y%m%dT%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 0xc9b9
callq 0x3180
jmp 0xc9be
callq 0x31d0
leaq 0x2e09(%rip), %rdx      # 0xf7ce
leaq 0x10(%rsp), %r14
movl $0x10, %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 0x97be
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/4n6ist[P]usn_analytics/lib/utils.cpp
// Function: join(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, char const*)
string join(const vector<string>& v, const char* delim = 0) {
  std::string s;
  if (!v.empty()) {
    s += v[0];
    for (decltype(v.size()) i = 1, c = v.size(); i < c; ++i) {
      if (delim) s += delim;
      s += v[i];
    }
  }
  return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %rax
cmpq 0x8(%rsi), %rax
je 0xcd90
movq %rdx, %r14
movq %rsi, %r15
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x30b0
movq 0x8(%r15), %r13
subq (%r15), %r13
sarq $0x5, %r13
cmpq $0x2, %r13
jb 0xcd90
decq %r13
movl $0x28, %ebp
testq %r14, %r14
je 0xcd73
movq %rbx, %rdi
movq %r14, %rsi
callq 0x34b0
movq (%r15), %rax
movq -0x8(%rax,%rbp), %rsi
movq (%rax,%rbp), %rdx
movq %rbx, %rdi
callq 0x30b0
addq $0x20, %rbp
decq %r13
jne 0xcd63
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcda4
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0xcdbb
movq (%r12), %rsi
incq %rsi
callq 0x3230
movq %r14, %rdi
callq 0x3470
// File: /workspace/github_cpp_makefile_star2_O1/4n6ist[P]usn_analytics/lib/utils.cpp
// Function: get_timezone_str[abi:cxx11](bool)
string get_timezone_str(bool lt) {
  if (lt) {
    time_t t1, t2;
    time(&t1);
    struct tm *tm_info;
    int tz_hour, tz_min;
    char tzstr[16];

    tm_info = localtime(&t1);
    tz_hour = tm_info->tm_hour;
    tz_min = tm_info->tm_min;	

    tm_info = gmtime(&t1);
    tz_hour -= tm_info->tm_hour;
    tz_min -= tm_info->tm_min;

    t2 = mktime(tm_info);

    if(t1-t2 > 0 && tz_hour < 0)
      tz_hour += 24;

    if(tz_min < 0) {
      tz_min += 60;  
      tz_hour--;
    }
    
    if(tz_hour >= 0)
      sprintf(tzstr, "+%02d:%02d", tz_hour, tz_min); 
    else
      sprintf(tzstr, "%02d:%02d", tz_hour, tz_min);

    return string(tzstr);
  }
  else 
    return "+00:00";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testl %esi, %esi
je 0xdf2d
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x3200
movq %r14, %rdi
callq 0x3180
movl 0x4(%rax), %r15d
movl 0x8(%rax), %r12d
movq %r14, %rdi
callq 0x31d0
subl 0x8(%rax), %r12d
subl 0x4(%rax), %r15d
movq %rax, %rdi
callq 0x3140
leal 0x18(%r12), %esi
cmpq %rax, (%r14)
cmovlel %r12d, %esi
testl %r12d, %r12d
cmovnsl %r12d, %esi
leal 0x3c(%r15), %ecx
movl %r15d, %edx
sarl $0x1f, %edx
testl %r15d, %r15d
cmovnsl %r15d, %ecx
addl %esi, %edx
leaq 0x1a0b(%rip), %rax      # 0xf905
leaq 0x1a05(%rip), %rsi      # 0xf906
cmovnsq %rax, %rsi
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x3070
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x30e0
leaq (%rsp,%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0xdf45
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x19d5(%rip), %rsi      # 0xf910
leaq 0x19d4(%rip), %rdx      # 0xf916
movq %rbx, %rdi
callq 0x97be
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/4n6ist[P]usn_analytics/src/main.cpp
// Function: usage()
void usage(void) {
	printf("USN Analytics (https://www.kazamiya.net/usn_analytics/) v.201801\n\n");
	printf("Usage  : usn_analytics.exe [-ru] -o output input\n\n");
	printf("     -r: parse all of USN_RECORD and write to all.csv with raw style\n");
	printf("     -u: treat a timestamp as UTC (default: Local Time)\n");
	printf(" -o out: specify a output directory\n");
	printf("     in: specify a bunch of data including USN_RECORD\n\n");
}

// Assembly:
pushq %rax
leaq 0x1818(%rip), %rdi      # 0xfa40
callq 0x33e0
leaq 0x184e(%rip), %rdi      # 0xfa82
callq 0x33e0
leaq 0x1874(%rip), %rdi      # 0xfab4
callq 0x33e0
leaq 0x18ad(%rip), %rdi      # 0xfaf9
callq 0x33e0
leaq 0x18d9(%rip), %rdi      # 0xfb31
callq 0x33e0
leaq 0x18f1(%rip), %rdi      # 0xfb55
popq %rax
jmp 0x33e0
// File: /workspace/github_cpp_makefile_star2_O1/4n6ist[P]usn_analytics/src/main.cpp
// Function: process(char*, char*)
void process(char *ifname, char *odname) {
    
  UsnJrnl usnjrnl = UsnJrnl(ifname, odname);

  printf("Search USNRECORD");
  usnjrnl.GetAllUsnOffset();
  if (raw == true) {
    usnjrnl.WriteAllRecords(odname, lt);
  } else {
    usnjrnl.PreProcess();
    printf("Check records");
    usnjrnl.CheckRecords();
    printf("Path construction");
    usnjrnl.PostProcess();
    printf("Write records");
    usnjrnl.WriteBundledRecords(odname, lt);
    printf("Check executed trace");
    usnjrnl.WriteExecutedRecords(odname, lt);
    printf("Check opened trace");
    usnjrnl.WriteOpenedRecords(odname, lt);
    printf("Check suspicious trace");
    usnjrnl.WriteSuspiciousInfo();
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x37ca
leaq 0x1688(%rip), %rdi      # 0xf917
xorl %eax, %eax
callq 0x3040
movq %r14, %rdi
callq 0x3b26
cmpb $0x1, 0x5fe2(%rip)      # 0x14287
jne 0xe2be
movzbl 0x5fd2(%rip), %edx      # 0x14280
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x8972
jmp 0xe368
movq %rsp, %rdi
callq 0x3cf0
leaq 0x165b(%rip), %rdi      # 0xf928
xorl %eax, %eax
callq 0x3040
movq %rsp, %rdi
callq 0x3e56
leaq 0x1653(%rip), %rdi      # 0xf936
xorl %eax, %eax
callq 0x3040
movq %rsp, %rdi
callq 0x5eba
leaq 0x164f(%rip), %rdi      # 0xf948
xorl %eax, %eax
callq 0x3040
movzbl 0x5f79(%rip), %edx      # 0x14280
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x62f6
leaq 0x163d(%rip), %rdi      # 0xf956
xorl %eax, %eax
callq 0x3040
movzbl 0x5f59(%rip), %edx      # 0x14280
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x69dc
leaq 0x1632(%rip), %rdi      # 0xf96b
xorl %eax, %eax
callq 0x3040
movzbl 0x5f39(%rip), %edx      # 0x14280
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x71ce
leaq 0x1625(%rip), %rdi      # 0xf97e
xorl %eax, %eax
callq 0x3040
movq %rsp, %rdi
callq 0x77b8
movq %rsp, %rdi
callq 0x375c
addq $0xf8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x375c
movq %rbx, %rdi
callq 0x3470
// File: /workspace/github_cpp_makefile_star2_O1/QiumingLu[P]conhash/conhash.cc
// Function: ConHash::AddNode(Node const&)
void ConHash::AddNode(const Node& node) {
  assert(node.replicas > 0);
  for (int i = 0; i < node.replicas; ++i) {
    uint32_t key = Hash(node.identify, i);
    vnodes_.insert(std::make_pair(key, node));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpl $0x0, 0x20(%rsi)
jle 0x2d5f
movq %rsi, %rbx
cmpl $0x0, 0x20(%rsi)
jle 0x2d50
movq %rdi, %r14
leaq 0x10(%rsp), %r15
xorl %ebp, %ebp
leaq 0x20(%rsp), %r13
leaq 0x8(%rsp), %r12
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2da0
movl %eax, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x2b04
movl 0x20(%rbx), %eax
movl %eax, 0x30(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x2ee2
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x2d49
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2110
incl %ebp
cmpl 0x20(%rbx), %ebp
jl 0x2cfb
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1307(%rip), %rdi      # 0x406d
leaq 0x1312(%rip), %rsi      # 0x407f
leaq 0x1316(%rip), %rcx      # 0x408a
movl $0xd, %edx
callq 0x20a0
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x2d98
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2110
movq %rbx, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O1/QiumingLu[P]conhash/conhash.cc
// Function: ConHash::Hash(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
uint32_t ConHash::Hash(const std::string& identify, int i) {
  char buf[128];
  int len = snprintf(buf, sizeof(buf), "%s#%d", identify.c_str(), i);
  assert(len > 0);
  uint32_t out;
  MurmurHash3_x86_32(buf, len, 0, &out);
  return out;
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
movl %edx, %r8d
movq (%rsi), %rcx
leaq 0x12f9(%rip), %rdx      # 0x40ae
leaq 0x10(%rsp), %rdi
movl $0x80, %esi
xorl %eax, %eax
callq 0x2170
testl %eax, %eax
jle 0x2deb
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rbx
movl %eax, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x3188
movl (%rbx), %eax
addq $0x90, %rsp
popq %rbx
retq
leaq 0x12c2(%rip), %rdi      # 0x40b4
leaq 0x1286(%rip), %rsi      # 0x407f
leaq 0x12bc(%rip), %rcx      # 0x40bc
movl $0x2f, %edx
callq 0x20a0
// File: /workspace/github_cpp_makefile_star2_O1/kipa00[P]AplusB-mc/interpreter/main.cpp
// Function: help(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void help(string fn) {
	fprintf(stderr, "Usage: %s [other flags ...]\n", fn.c_str());
	fprintf(stderr, "\n");
	fprintf(stderr, "flags include:\n");
	fprintf(stderr, "  --max-tick (number)\n    limit execution tick to given number of ticks maximum.\n");
	fprintf(stderr, "  --ban-block (wire|torch|repeater|comparator)\n    if given circuit contains the block, rejects the execution.\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x5d95(%rip), %r14      # 0x7fe0
movq (%r14), %rax
movq (%rdi), %rdx
leaq 0x2e60(%rip), %rsi      # 0x50b8
movq %rax, %rdi
xorl %eax, %eax
callq 0x2190
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x2160
movq (%r14), %rcx
leaq 0x2e5e(%rip), %rdi      # 0x50d5
pushq $0xf
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x2220
movq (%r14), %rcx
leaq 0x2e56(%rip), %rdi      # 0x50e5
pushq $0x51
popq %rsi
movq %rbx, %rdx
callq 0x2220
movq (%r14), %rcx
leaq 0x2e93(%rip), %rdi      # 0x5137
pushq $0x6f
popq %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/kipa00[P]AplusB-mc/interpreter/bytestream.cpp
// Function: bytereader::close()
void bytereader::close() {
	if (fp) {
		fclose(fp);
		fp = nullptr;
		pos = len = 0;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x422e
callq 0x2110
xorl %eax, %eax
movq %rax, (%rbx)
movq %rax, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/kipa00[P]AplusB-mc/interpreter/bytestream.cpp
// Function: bytereader::read_byte()
byte bytereader::read_byte() {
	if (pos == len) {
		if ((len = fread(buf, 1, 1048576, fp)) <= 0) {
			throw EOF_ERROR;
		}
		pos = 0;
	}
	return buf[pos++];
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rdi), %eax
cmpl 0x14(%rdi), %eax
jne 0x4260
movq (%rbx), %rcx
movq 0x8(%rbx), %rdi
movl $0x1, %esi
movl $0x100000, %edx         # imm = 0x100000
callq 0x21b0
movl %eax, 0x14(%rbx)
testl %eax, %eax
jle 0x4273
movl $0x0, 0x10(%rbx)
movq 0x8(%rbx), %rax
movslq 0x10(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x10(%rbx)
movb (%rax,%rcx), %al
popq %rbx
retq
movl $0x4, %edi
callq 0x20a0
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq 0x3d3e(%rip), %rsi      # 0x7fc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/kipa00[P]AplusB-mc/interpreter/bytestream.cpp
// Function: bytereader::read_int()
int bytereader::read_int() {
	u32 x;
	int i;
	for (i=0; i<4; ++i) {
		(x <<= 8) |= read_byte();
	}
	return (int)x;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x4, %r14d
movq %rbx, %rdi
callq 0x4230
movzbl %al, %eax
shll $0x8, %ebp
orl %eax, %ebp
decl %r14d
jne 0x42a1
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/kipa00[P]AplusB-mc/interpreter/node.cpp
// Function: wire::update(int, int)
bool wire::update(int power, int side) {
	int calculated_power = std::max({power, side - 1, 0});
	if (this->power == calculated_power) {
		return false;
	}
	this->power = calculated_power;
	return true;
}

// Assembly:
leaq -0xc(%rsp), %rax
movl %esi, (%rax)
decl %edx
movl %edx, 0x4(%rax)
movl $0x0, 0x8(%rax)
movl $0x4, %ecx
movl (%rax), %edx
cmpl -0xc(%rsp,%rcx), %edx
jge 0x4312
leaq (%rsp,%rcx), %rax
addq $-0xc, %rax
addq $0x4, %rcx
cmpq $0xc, %rcx
jne 0x4302
movl (%rax), %eax
movl 0x38(%rdi), %ecx
cmpl %eax, %ecx
je 0x4328
movl %eax, 0x38(%rdi)
cmpl %eax, %ecx
setne %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/kipa00[P]AplusB-mc/interpreter/node.cpp
// Function: torch::update(int)
bool torch::update(int power) {
	int calculated_power = power ? 0 : 15;
	if (this->power == calculated_power) {
		return false;
	}
	this->power = calculated_power;
	return true;
}

// Assembly:
xorl %ecx, %ecx
testl %esi, %esi
movl $0xf, %eax
cmovnel %ecx, %eax
movl 0x38(%rdi), %ecx
cmpl %eax, %ecx
je 0x4366
movl %eax, 0x38(%rdi)
cmpl %eax, %ecx
setne %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/kipa00[P]AplusB-mc/interpreter/node.cpp
// Function: repeater::update(int, int)
bool repeater::update(int power, int side) {
	if (side) {
		if (lock == side) {
			return false;
		}
		lock = side;
		return true;
	}
	int calculated_power = power ? 15 : 0;
	if (this->power == calculated_power && lock == side) {
		return false;
	}
	this->lock = side;
	this->power = calculated_power;
	return true;
}

// Assembly:
testl %edx, %edx
je 0x439e
cmpl %edx, 0x40(%rdi)
je 0x43b3
movl %edx, 0x40(%rdi)
jmp 0x43c0
testl %esi, %esi
movl $0xf, %eax
cmovel %esi, %eax
cmpl %eax, 0x38(%rdi)
jne 0x43b6
cmpl $0x0, 0x40(%rdi)
jne 0x43b6
xorl %eax, %eax
retq
movl $0x0, 0x40(%rdi)
movl %eax, 0x38(%rdi)
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kipa00[P]AplusB-mc/interpreter/node.cpp
// Function: comparator::update(int, int)
bool comparator::update(int power, int side) {
	int calculated_power = power >= side ? power : 0;
	if (this->power == calculated_power) {
		return false;
	}
	this->power = calculated_power;
	return true;
}

// Assembly:
xorl %eax, %eax
cmpl %edx, %esi
cmovgel %esi, %eax
movl 0x38(%rdi), %ecx
cmpl %eax, %ecx
je 0x43f7
movl %eax, 0x38(%rdi)
cmpl %eax, %ecx
setne %al
retq
nop