LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x25b3(%rip), %rsi      # 0xc717
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3380
movzwl 0x8(%r14), %edx
leaq 0x25a5(%rip), %r15      # 0xc71f
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3380
movq 0x12(%r14), %rdx
leaq 0x259a(%rip), %r12      # 0xc72c
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3380
movsd 0x32(%r14), %xmm0
leaq 0x25a3(%rip), %rsi      # 0xc74f
movq %rbx, %rdi
movb $0x1, %al
callq 0x3380
movq 0x3a(%r14), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3380
movq 0x5e(%r14), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3380
movq 0x82(%r14), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3380
movl 0xa2(%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3380
movl 0xa6(%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3380
movq 0xaa(%r14), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3380
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x3330
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3150
leaq 0x3a(%r14), %rsi
leaq 0x4a(%rbx), %r15
movq %r15, %rdi
callq 0x3150
movq 0x52(%rbx), %rcx
addq $-0xc, %rcx
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3280
leaq 0x28(%rbx), %rdi
movq %r12, %rsi
callq 0x3320
movq %r12, %rdi
callq 0x3100
movq 0x28(%rbx), %r15
movq 0x30(%rbx), %r12
cmpq %r13, %r12
je 0xa310
movsbl (%r15,%r13), %edi
callq 0x3390
movb %al, (%r15,%r13)
incq %r13
jmp 0xa2f8
movw %bp, 0x48(%rbx)
movzwl 0x8(%r14), %eax
movw %ax, 0x8a(%rbx)
leaq 0x5e(%r14), %rsi
leaq 0x6a(%rbx), %rdi
callq 0x3150
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_O2/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 0x23a5(%rip), %rsi      # 0xc717
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3380
movq 0x8(%r14), %rdx
leaq 0x23a5(%rip), %r12      # 0xc72c
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3380
movq 0x28(%r14), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3380
movzwl 0x48(%r14), %edx
leaq 0x236e(%rip), %r15      # 0xc71f
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3380
movq 0x4a(%r14), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3380
movq 0x6a(%r14), %rdx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3380
movzwl 0x8a(%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3380
movsd 0x8c(%r14), %xmm0
leaq 0x234a(%rip), %rsi      # 0xc74f
movq %rbx, %rdi
movb $0x1, %al
callq 0x3380
movl 0x94(%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3380
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x3330
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3150
leaq 0xaa(%r14), %rsi
leaq 0x28(%rbx), %rdi
callq 0x3150
leaq 0x3a(%r14), %rsi
leaq 0x48(%rbx), %rdi
callq 0x3150
leaq 0x5e(%r14), %rsi
leaq 0x68(%rbx), %rdi
callq 0x3150
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_O2/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 0x2208(%rip), %rsi      # 0xc717
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3380
movq 0x8(%r14), %rdx
leaq 0x2208(%rip), %r15      # 0xc72c
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3380
movq 0x28(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3380
movq 0x48(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3380
movq 0x68(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3380
movzwl 0x88(%r14), %edx
leaq 0x21ac(%rip), %r15      # 0xc71f
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3380
movsd 0x8a(%r14), %xmm0
leaq 0x21bf(%rip), %rsi      # 0xc74f
movq %rbx, %rdi
movb $0x1, %al
callq 0x3380
movl 0x92(%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3380
movl 0x96(%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3380
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x3330
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3160
movq %rax, %r14
xorl %edi, %edi
callq 0x3230
movq %rax, %r15
subq (%rbx), %r14
cvtsi2sd %r14, %xmm0
divsd 0x213c(%rip), %xmm0     # 0xc758
leaq 0x213d(%rip), %rdi      # 0xc760
movb $0x1, %al
callq 0x3040
subq 0x8(%rbx), %r15
leaq 0x2139(%rip), %rdi      # 0xc76e
movq %r15, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x3040
// File: /workspace/github_cpp_makefile_star2_O2/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 0x33c0
testq %rax, %rax
je 0xa687
movq %rax, %rbx
movq %rbx, %rdi
callq 0x33d0
testq %rax, %rax
sete %bpl
je 0xa67d
cmpb $0x2e, 0x13(%rax)
jne 0xa67d
cmpb $0x0, 0x14(%rax)
je 0xa654
cmpb $0x2e, 0x14(%rax)
jne 0xa67d
cmpb $0x0, 0x15(%rax)
je 0xa654
movq %rbx, %rdi
callq 0x3420
jmp 0xa689
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x31a0
movl %eax, %ebx
cmpl $-0x1, %eax
je 0xa6ef
leaq 0x1995(%rip), %rsi      # 0xc048
movl %ebx, %edi
callq 0x32a0
movq %rax, %r14
testq %rax, %rax
je 0xa6fd
leaq 0x8(%rsp), %rsi
movl %ebx, %edi
callq 0x34a0
cmpl $-0x1, %eax
je 0xa70b
movq %r14, %rdi
callq 0x3250
testl %eax, %eax
jne 0xa719
movq 0x38(%rsp), %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
leaq 0x2092(%rip), %rdi      # 0xc788
callq 0x31f0
jmp 0xa6ac
leaq 0x2084(%rip), %rdi      # 0xc788
callq 0x31f0
jmp 0xa6c2
leaq 0x2085(%rip), %rdi      # 0xc797
callq 0x31f0
jmp 0xa6d3
leaq 0x208b(%rip), %rdi      # 0xc7ab
callq 0x31f0
jmp 0xa6df
// File: /workspace/github_cpp_makefile_star2_O2/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
movl $0x989680, %esi         # imm = 0x989680
xorl %edx, %edx
divq %rsi
movabsq $-0x2b6109100, %rdx     # imm = 0xFFFFFFFD49EF6F00
addq %rax, %rdx
movq %rdx, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
testl %ecx, %ecx
je 0xa791
callq 0x31b0
jmp 0xa796
callq 0x3200
leaq 0x201e(%rip), %rdx      # 0xc7bb
leaq 0x10(%rsp), %r14
pushq $0x14
popq %rsi
movq %r14, %rdi
movq %rax, %rcx
callq 0x31d0
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7072
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl $0x989680, %esi         # imm = 0x989680
xorl %edx, %edx
divq %rsi
movabsq $-0x2b6109100, %rdx     # imm = 0xFFFFFFFD49EF6F00
addq %rax, %rdx
movq %rdx, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
testl %ecx, %ecx
je 0xa806
callq 0x31b0
jmp 0xa80b
callq 0x3200
leaq 0x1fbb(%rip), %rdx      # 0xc7cd
leaq 0x10(%rsp), %r14
pushq $0x10
popq %rsi
movq %r14, %rdi
movq %rax, %rcx
callq 0x31d0
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7072
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/4n6ist[P]usn_analytics/lib/utils.cpp
// Function: parse_datetimemicro[abi:cxx11](unsigned long, bool)
string parse_datetimemicro(uint64_t _time, bool lt) {  
  char buf1[32], buf2[7];
  struct tm *tm_info;
  int microseconds;
  time_t epoch;
  string time_str;
 
  // 11644473600.0 seconds from 1601/01/01 to 1970/01/01
  epoch = _time/(10*1000*1000) - 11644473600L;
  microseconds = (_time%(10*1000*1000))/10;
 
  if(lt)
    tm_info = localtime(&epoch);
  else
    tm_info = gmtime(&epoch);
 
  strftime(buf1, 20, "%Y/%m/%d %H:%M:%S", tm_info);
  sprintf(buf2, "%06d", microseconds);  
  time_str = string(buf1) + "." + string(buf2);
  
  return time_str;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movl %edx, %ecx
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rdx
movq %rdx, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0x989680, %esi         # imm = 0x989680
xorl %edx, %edx
divq %rsi
movabsq $-0x2b6109100, %rsi     # imm = 0xFFFFFFFD49EF6F00
addq %rax, %rsi
movq %rsi, 0x10(%rsp)
pushq $0xa
popq %rsi
movl %edx, %eax
xorl %edx, %edx
divl %esi
movl %eax, %ebp
leaq 0x10(%rsp), %rdi
testl %ecx, %ecx
je 0xa89a
callq 0x31b0
jmp 0xa89f
callq 0x3200
leaq 0x1f15(%rip), %rdx      # 0xc7bb
leaq 0xa0(%rsp), %r14
pushq $0x14
popq %rsi
movq %r14, %rdi
movq %rax, %rcx
callq 0x31d0
leaq 0x1f18(%rip), %rsi      # 0xc7db
leaq 0x19(%rsp), %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x3070
leaq 0x40(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x7072
leaq 0x1e9c(%rip), %rdx      # 0xc786
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x7031
leaq 0x20(%rsp), %rdi
leaq 0x19(%rsp), %rsi
leaq 0xe(%rsp), %rdx
callq 0x7072
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x71b8
leaq 0x80(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3320
movq %r14, %rdi
callq 0x3100
leaq 0x20(%rsp), %rdi
callq 0x3100
leaq 0x60(%rsp), %rdi
callq 0x3100
leaq 0x40(%rsp), %rdi
callq 0x3100
movq %rbx, %rax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x3100
jmp 0xa97e
movq %rax, %r14
leaq 0x60(%rsp), %rdi
callq 0x3100
jmp 0xa98d
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x3100
jmp 0xa99c
movq %rax, %r14
movq %rbx, %rdi
callq 0x3100
movq %r14, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %rsi
cmpq 0x8(%r15), %rsi
je 0xaa1f
movq %rdx, %r14
movq %rbx, %rdi
callq 0x34e0
movq 0x8(%r15), %r12
subq (%r15), %r12
sarq $0x5, %r12
pushq $0x1
popq %r13
pushq $0x20
popq %rbp
cmpq %r12, %r13
jae 0xaa1f
testq %r14, %r14
je 0xaa08
movq %rbx, %rdi
movq %r14, %rsi
callq 0x34b0
movq (%r15), %rsi
addq %rbp, %rsi
movq %rbx, %rdi
callq 0x34e0
incq %r13
addq $0x20, %rbp
jmp 0xa9f3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xaa33
movq %rax, %r14
movq %rbx, %rdi
callq 0x3100
movq %r14, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rdi, %rbx
testl %esi, %esi
je 0xb7b1
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x3230
movq %r14, %rdi
callq 0x31b0
movl 0x4(%rax), %r15d
movl 0x8(%rax), %r12d
movq %r14, %rdi
callq 0x3200
subl 0x8(%rax), %r12d
subl 0x4(%rax), %r15d
movq %rax, %rdi
callq 0x3170
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 0x117a(%rip), %rax      # 0xc904
leaq 0x1174(%rip), %rsi      # 0xc905
cmovnsq %rax, %rsi
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x3070
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0xb7c0
leaq 0x1157(%rip), %rsi      # 0xc90f
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x7072
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x101f(%rip), %rdi      # 0xca3f
callq 0x33f0
leaq 0x1055(%rip), %rdi      # 0xca81
callq 0x33f0
leaq 0x107b(%rip), %rdi      # 0xcab3
callq 0x33f0
leaq 0x10b4(%rip), %rdi      # 0xcaf8
callq 0x33f0
leaq 0x10e0(%rip), %rdi      # 0xcb30
callq 0x33f0
leaq 0x10f8(%rip), %rdi      # 0xcb54
popq %rax
jmp 0x33f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x36f2
leaq 0xe8f(%rip), %rdi       # 0xc916
xorl %eax, %eax
callq 0x3040
movq %r14, %rdi
callq 0x3956
cmpb $0x1, 0x6802(%rip)      # 0x1229f
jne 0xbab6
movzbl 0x67f2(%rip), %edx      # 0x12298
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x6ce4
jmp 0xbb60
movq %rsp, %rdi
callq 0x3ac0
leaq 0xe62(%rip), %rdi       # 0xc927
xorl %eax, %eax
callq 0x3040
movq %rsp, %rdi
callq 0x3bee
leaq 0xe5a(%rip), %rdi       # 0xc935
xorl %eax, %eax
callq 0x3040
movq %rsp, %rdi
callq 0x4f48
leaq 0xe56(%rip), %rdi       # 0xc947
xorl %eax, %eax
callq 0x3040
movzbl 0x6799(%rip), %edx      # 0x12298
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x52fc
leaq 0xe44(%rip), %rdi       # 0xc955
xorl %eax, %eax
callq 0x3040
movzbl 0x6779(%rip), %edx      # 0x12298
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x56d8
leaq 0xe39(%rip), %rdi       # 0xc96a
xorl %eax, %eax
callq 0x3040
movzbl 0x6759(%rip), %edx      # 0x12298
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x5c68
leaq 0xe2c(%rip), %rdi       # 0xc97d
xorl %eax, %eax
callq 0x3040
movq %rsp, %rdi
callq 0x6076
movq %rsp, %rdi
callq 0x369c
addq $0xf8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x369c
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x30, %rsp
movl 0x20(%rsi), %eax
testl %eax, %eax
jle 0x296e
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
movq %rsp, %r12
cmpl %eax, %ebp
jge 0x2961
movq %rbx, %rsi
movl %ebp, %edx
callq 0x299e
movl %eax, (%rsp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2ad0
movq %r14, %rdi
movq %r12, %rsi
callq 0x2aee
movq %r15, %rdi
callq 0x2080
incl %ebp
movl 0x20(%rbx), %eax
jmp 0x292b
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16f8(%rip), %rdi      # 0x406d
leaq 0x1703(%rip), %rsi      # 0x407f
leaq 0x1707(%rip), %rcx      # 0x408a
pushq $0xd
popq %rdx
callq 0x20c0
movq %rax, %rbx
movq %r15, %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x16fb(%rip), %rdx      # 0x40ae
leaq 0x10(%rsp), %rdi
movl $0x80, %esi
xorl %eax, %eax
callq 0x21b0
testl %eax, %eax
jle 0x29e9
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rbx
movl %eax, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x2e64
movl (%rbx), %eax
addq $0x90, %rsp
popq %rbx
retq
leaq 0x16c4(%rip), %rdi      # 0x40b4
leaq 0x1688(%rip), %rsi      # 0x407f
leaq 0x16be(%rip), %rcx      # 0x40bc
pushq $0x2f
popq %rdx
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5c99(%rip), %r14      # 0x7fe0
movq (%r14), %rax
movq (%rdi), %rdx
leaq 0x2cf4(%rip), %rsi      # 0x5048
movq %rax, %rdi
xorl %eax, %eax
callq 0x21a0
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x2170
movq (%r14), %rcx
leaq 0x2cf2(%rip), %rdi      # 0x5065
pushq $0xf
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x2230
movq (%r14), %rcx
leaq 0x2cea(%rip), %rdi      # 0x5075
pushq $0x51
popq %rsi
movq %rbx, %rdx
callq 0x2230
movq (%r14), %rcx
leaq 0x2d27(%rip), %rdi      # 0x50c7
pushq $0x6f
popq %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3e10
callq 0x2120
andq $0x0, (%rbx)
andq $0x0, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %ecx
cmpl 0x14(%rdi), %ecx
jne 0x3e3b
movq (%rbx), %rcx
movq 0x8(%rbx), %rdi
pushq $0x1
popq %rsi
movl $0x100000, %edx         # imm = 0x100000
callq 0x21c0
movl %eax, 0x14(%rbx)
xorl %ecx, %ecx
testl %eax, %eax
jle 0x3e4d
movq 0x8(%rbx), %rax
leal 0x1(%rcx), %edx
movl %edx, 0x10(%rbx)
movslq %ecx, %rcx
movb (%rax,%rcx), %al
popq %rbx
retq
pushq $0x4
popq %rdi
callq 0x20b0
orl $-0x1, (%rax)
movq 0x4169(%rip), %rsi      # 0x7fc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x4
popq %r14
subl $0x1, %r14d
jb 0x3e8d
movq %rbx, %rdi
callq 0x3e12
movzbl %al, %eax
shll $0x8, %ebp
orl %eax, %ebp
jmp 0x3e75
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %rdi
movl %esi, (%rdi)
decl %edx
movl %edx, 0x4(%rdi)
andl $0x0, 0x8(%rdi)
pushq $0x3
popq %rsi
callq 0x4050
movl 0x38(%rbx), %ecx
cmpl %eax, %ecx
je 0x3ee4
movl %eax, 0x38(%rbx)
cmpl %eax, %ecx
setne %al
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0xf
popq %rax
cmovnel %ecx, %eax
movl 0x38(%rdi), %ecx
cmpl %eax, %ecx
je 0x3f26
movl %eax, 0x38(%rdi)
cmpl %eax, %ecx
setne %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3f5c
cmpl %edx, 0x40(%rdi)
je 0x3f6f
movl %edx, 0x40(%rdi)
jmp 0x3f79
testl %esi, %esi
pushq $0xf
popq %rax
cmovel %esi, %eax
cmpl %eax, 0x38(%rdi)
jne 0x3f72
cmpl $0x0, 0x40(%rdi)
jne 0x3f72
xorl %eax, %eax
retq
andl $0x0, 0x40(%rdi)
movl %eax, 0x38(%rdi)
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3faf
movl %eax, 0x38(%rdi)
cmpl %eax, %ecx
setne %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kipa00[P]AplusB-mc/interpreter/node.cpp
// Function: subtractor::update(int, int)
bool subtractor::update(int power, int side) {
	int calculated_power = std::max(power - side, 0);
	if (this->power == calculated_power) {
		return false;
	}
	this->power = calculated_power;
	return true;
}

// Assembly:
subl %edx, %esi
xorl %eax, %eax
testl %esi, %esi
cmovgl %esi, %eax
movl 0x38(%rdi), %ecx
cmpl %eax, %ecx
je 0x3feb
movl %eax, 0x38(%rdi)
cmpl %eax, %ecx
setne %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kipa00[P]AplusB-mc/interpreter/node.cpp
// Function: lever::set_as(int)
bool lever::set_as(int power) {
	power = power ? 15 : 0;
	if (this->power == power) {
		return false;
	}
	this->power = power;
	return true;
}

// Assembly:
testl %esi, %esi
pushq $0xf
popq %rax
cmovel %esi, %eax
movl 0x38(%rdi), %ecx
cmpl %eax, %ecx
je 0x4026
movl %eax, 0x38(%rdi)
cmpl %eax, %ecx
setne %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH04_Expressions/examples/arraysizeof.cc
// Function: main
int main()
{
   // sizeof(ia)/sizeof(*ia) returns the number of elements in ia
   constexpr size_t sz = sizeof(ia)/sizeof(*ia);

   int arr2[sz];  // ok sizeof returns a constant expression 

   cout << "ia size: " << sz << endl;

   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x2e11(%rip), %rdi      # 0x3fd8
leaq 0xe36(%rip), %rsi       # 0x2004
callq 0x1060
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x1040
movq %rax, %rdi
callq 0x1030
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Saevon[P]node-diskfree/./test/test.cpp
// Function: main
int main(void) {
    uint64_t free, available, total;
    uint64_t err;

    err = GetDiskSpace(VALID_PATH, &available, &total, &free);

    assertEqual(err, 0, "error reading 'c:'");
    assertTrue(total > 0, "total disk space is wrong");
    assertTrue(total >= free, "total disk space less than free space??");
    assertTrue(total >= available, "total disk space less than available space??");
    assertTrue(free >= available, "free disk space is less than available space??");


    err = GetDiskSpace("c", &available, &total, &free);

    assertTrue(isErrBadPath(err), "no error reading invalid path");

    printf("avail: %" PRIu64 "\n", available);
    printf("free : %" PRIu64 "\n", free);
    printf("total: %" PRIu64 "\n", total);

    printf("Test Complete\n");

    //uint64_t val = DBL_MAX;
    //uint64_t val = //0xFFFFFFFFFFFFF800;
    uint64_t val = 0xFFFFFFFFFFFFF802;
    double val2 = (double) val;
    printf("%" PRIu64 "\n", val);
    printf("%f\n", val2);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
leaq 0xdcf(%rip), %rdi       # 0x2020
leaq -0x18(%rbp), %rsi
leaq -0x10(%rbp), %rbx
leaq -0x20(%rbp), %rcx
movq %rbx, %rdx
callq 0x116c
leaq 0xdb6(%rip), %rdx       # 0x2022
movq %rax, %rdi
xorl %esi, %esi
callq 0x1208
movq (%rbx), %rax
testq %rax, %rax
jne 0x128e
leaq 0xdb0(%rip), %rdi       # 0x2035
callq 0x1040
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x12a4
leaq 0xdb4(%rip), %rdi       # 0x204f
callq 0x1040
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jae 0x12bd
leaq 0xdc3(%rip), %rdi       # 0x2077
callq 0x1040
movq -0x18(%rbp), %rcx
cmpq %rcx, -0x20(%rbp)
jae 0x12cf
leaq 0xdda(%rip), %rdi       # 0x20a4
callq 0x1040
leaq 0xdfd(%rip), %rdi       # 0x20d3
leaq -0x18(%rbp), %rsi
leaq -0x10(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x116c
movq %rax, %rdi
callq 0x11cc
testb %al, %al
jne 0x12ff
leaq 0xddb(%rip), %rdi       # 0x20d5
callq 0x1040
movq -0x18(%rbp), %rsi
leaq 0xde9(%rip), %rdi       # 0x20f3
xorl %eax, %eax
callq 0x1050
movq -0x20(%rbp), %rsi
leaq 0xde3(%rip), %rdi       # 0x20ff
xorl %eax, %eax
callq 0x1050
movq -0x10(%rbp), %rsi
leaq 0xddd(%rip), %rdi       # 0x210b
xorl %eax, %eax
callq 0x1050
leaq 0xddf(%rip), %rdi       # 0x211b
callq 0x1040
leaq 0xdbe(%rip), %rdi       # 0x2106
movq $-0x7fe, %rsi           # imm = 0xF802
xorl %eax, %eax
callq 0x1050
leaq 0xdba(%rip), %rdi       # 0x2117
movsd 0xca3(%rip), %xmm0      # 0x2008
movb $0x1, %al
callq 0x1050
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sthapliyal37[P]Microprocessor_8085_Updated/Validation.cpp
// Function: registerNumber(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int registerNumber(string str)
{
	if(str=="A")
		return 0;
	if(str=="B")
		return 1;
	if(str=="C")
		return 2;
	if(str=="D")
		return 3;
	if(str=="E")
		return 4;
	if(str=="H")
		return 5;
	if(str=="L")
		return 6;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7912(%rip), %rsi      # 0xa062
callq 0x2f0d
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
jne 0x27cf
leaq 0x78bc(%rip), %rsi      # 0xa020
movq %rbx, %rdi
callq 0x2f0d
testb %al, %al
je 0x2774
pushq $0x1
jmp 0x27ce
leaq 0x7899(%rip), %rsi      # 0xa014
movq %rbx, %rdi
callq 0x2f0d
testb %al, %al
je 0x278b
pushq $0x2
jmp 0x27ce
leaq 0x78a2(%rip), %rsi      # 0xa034
movq %rbx, %rdi
callq 0x2f0d
testb %al, %al
je 0x27a2
pushq $0x3
jmp 0x27ce
leaq 0x785b(%rip), %rsi      # 0xa004
movq %rbx, %rdi
callq 0x2f0d
testb %al, %al
je 0x27b9
pushq $0x4
jmp 0x27ce
leaq 0x7846(%rip), %rsi      # 0xa006
movq %rbx, %rdi
callq 0x2f0d
testb %al, %al
je 0x27d6
pushq $0x5
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x782b(%rip), %rsi      # 0xa008
movq %rbx, %rdi
callq 0x2f0d
xorl %ecx, %ecx
testb %al, %al
pushq $0x6
popq %rax
cmovel %ecx, %eax
jmp 0x27cf
// File: /workspace/github_cpp_makefile_star2_O2/sthapliyal37[P]Microprocessor_8085_Updated/Validation.cpp
// Function: itos[abi:cxx11](int)
string itos(int integer)
{	
		stringstream ss; 
  		ss<<integer;  
  		string s;  
  		ss>>s; 
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x198(%rbp), %rdi
callq 0x2160
leaq -0x188(%rbp), %rdi
movl %r14d, %esi
callq 0x2300
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq -0x198(%rbp), %rdi
movq %rbx, %rsi
callq 0x2260
leaq -0x198(%rbp), %rdi
callq 0x2180
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
jmp 0x286a
movq %rax, %r14
leaq -0x198(%rbp), %rdi
callq 0x2180
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/sthapliyal37[P]Microprocessor_8085_Updated/Validation.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string split(string s)
{
string p="ABC";
	int i=0;
	while(s[i]!=' ' && s[i]!='\0')		
	{
					p[i]=s[i];
					i++;
	}	
		p[i]='\0';
		return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x777c(%rip), %rsi      # 0xa012
leaq -0x11(%rbp), %rdx
callq 0x2f1e
xorl %eax, %eax
movq (%r14), %rcx
movzbl (%rcx,%rax), %ecx
testb $-0x21, %cl
je 0x28b8
movq (%rbx), %rdx
movb %cl, (%rdx,%rax)
incq %rax
jmp 0x28a1
movq (%rbx), %rcx
movb $0x0, (%rcx,%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sthapliyal37[P]Microprocessor_8085_Updated/Validation.cpp
// Function: validityData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool validityData(string a)
{
	int l=a.length();
	if(l==2)
	{
		if((a[0]>='0'&&a[0]<='9')||(a[0]>='A'&&a[0]<='F'))
		{
			if((a[1]>='0'&&a[1]<='9')||(a[1]>='A'&&a[1]<='F'))
				return true;
			else 
				return false;
		}
		else
			return false;
	}
	else 
		return false;
}

// Assembly:
cmpl $0x2, 0x8(%rdi)
jne 0x2912
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movb (%rax), %cl
cmpb $0x30, %cl
jl 0x290e
cmpb $0x3a, %cl
setb %dl
addb $-0x41, %cl
cmpb $0x6, %cl
setb %cl
orb %dl, %cl
cmpb $0x1, %cl
jne 0x290e
movb 0x1(%rax), %al
cmpb $0x30, %al
jl 0x290e
cmpb $0x3a, %al
setb %cl
addb $-0x41, %al
cmpb $0x6, %al
setb %al
orb %cl, %al
movb $0x1, %al
jne 0x2910
xorl %eax, %eax
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/sthapliyal37[P]Microprocessor_8085_Updated/Validation.cpp
// Function: validityAddress(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool validityAddress(string data)
{
	bool flag;
	int l=data.length();
	if(l==4)
	{
		for(int i=0;i<l;i++)
			if(( data[i]>='0' && data[i]<='9')||( data[i]>='A' && data[i]<='F' ))
				flag = true;
			else
				flag = false;
		return flag;
	}
	else
		return false;
}

// Assembly:
cmpl $0x4, 0x8(%rdi)
jne 0x294c
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rcx
xorl %edx, %edx
cmpq $0x4, %rdx
je 0x2950
movb (%rcx,%rdx), %al
cmpb $0x30, %al
jl 0x2945
cmpb $0x3a, %al
setb %sil
addb $-0x41, %al
cmpb $0x6, %al
setb %al
orb %sil, %al
movb $0x1, %al
jne 0x2947
xorl %eax, %eax
incq %rdx
jmp 0x2924
xorl %eax, %eax
jmp 0x2951
popq %rbp
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/sthapliyal37[P]Microprocessor_8085_Updated/Validation.cpp
// Function: memoryValidation(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool memoryValidation(string start)
{
			int num=0;
			int n=start.length();
			for(int i=0;i<n;i++)
			{	
					int a=stoi(start[i]);
					num=(num*10) + a; 
			}
			if(num>=2000 && num<=8000)
							return 1;
			return 0;				
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x8(%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorl %edx, %edx
cmpq %rcx, %rax
je 0x297d
movq (%rdi), %rsi
movsbl (%rsi,%rcx), %esi
imull $0xa, %edx, %edx
addl %esi, %edx
addl $-0x30, %edx
incq %rcx
jmp 0x2964
addl $0xfffff830, %edx       # imm = 0xFFFFF830
cmpl $0x1771, %edx           # imm = 0x1771
setb %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sthapliyal37[P]Microprocessor_8085_Updated/Memory_Allocation.cpp
// Function: sumBase14(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
char *sumBase14(string num1, string num2) 
{ 
	int l1 = num1.length(); 
	int l2 = num2.length(); 
	char *res; 
	int i; 
	int nml1, nml2, res_nml; 
	bool carry = 0; 
		
	if(l1 != l2) 
	{ 
		cout << "Function doesn't support numbers of different"
				" lengths. If you want to add such numbers then"
				" prefix smaller number with required no. of zeroes"; 
		assert(0); 
	} 
	res = new char[(sizeof(char)*(l1 + 1))]; 
			
	for(i = l1-1; i >= 0; i--) 
	{ 
		nml1 = getNumeralValue(num1[i]); 
		nml2 = getNumeralValue(num2[i]); 
		
		res_nml = carry + nml1 + nml2; 
		
		if(res_nml >= 14) 
		{ 
			carry = 1; 
			res_nml -= 14; 
		} 
		else
		{ 
			carry = 0; 
		} 
		res[i+1] = getNumeral(res_nml); 
	} 
	if(carry == 0) 
		return (res + 1); 
	
	res[0] = '1'; 
	return res; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, -0x30(%rbp)
movq 0x8(%rdi), %rax
movq %rsi, -0x38(%rbp)
cmpl 0x8(%rsi), %eax
jne 0x30a6
movl %eax, %r13d
leal 0x1(%r13), %eax
movslq %eax, %rdi
callq 0x2030
movq %rax, %r15
xorl %ebx, %ebx
testl %r13d, %r13d
jle 0x3087
leaq -0x1(%r13), %r14
movq -0x30(%rbp), %rax
movq (%rax), %rax
movsbl -0x1(%rax,%r13), %edi
callq 0x30d6
movl %eax, %r12d
movq -0x38(%rbp), %rax
movq (%rax), %rax
movsbl -0x1(%rax,%r13), %edi
callq 0x30d6
addl %ebx, %r12d
leal (%r12,%rax), %ecx
xorl %ebx, %ebx
cmpl $0xe, %ecx
setae %bl
leal -0xe(%rax,%r12), %edi
cmovbl %ecx, %edi
callq 0x3113
movb %al, (%r15,%r13)
movq %r14, %r13
jmp 0x3032
testl %ebx, %ebx
je 0x3091
movb $0x31, (%r15)
jmp 0x3094
incq %r15
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xaf23(%rip), %rdi      # 0xdfd0
leaq 0x6ff6(%rip), %rsi      # 0xa0aa
callq 0x21e0
leaq 0x712b(%rip), %rdi      # 0xa1eb
leaq 0x7071(%rip), %rsi      # 0xa138
leaq 0x7080(%rip), %rcx      # 0xa14e
pushq $0x1a
popq %rdx
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/sthapliyal37[P]Microprocessor_8085_Updated/Memory_Allocation.cpp
// Function: getNumeralValue(char)
int getNumeralValue(char num) 
{ 
	if( num >= '0' && num <= '9') 
		return (num - '0'); 
	if( num >= 'A' && num <= 'D') 
		return (num - 'A' + 10); 
			
	assert(0); 
}

// Assembly:
leal -0x30(%rdi), %eax
cmpb $0xa, %al
jae 0x30e1
pushq $-0x30
jmp 0x30ea
leal -0x41(%rdi), %eax
cmpb $0x4, %al
jae 0x30f2
pushq $-0x37
popq %rcx
movsbl %dil, %eax
addl %ecx, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x70ee(%rip), %rdi      # 0xa1eb
leaq 0x7034(%rip), %rsi      # 0xa138
leaq 0x7063(%rip), %rcx      # 0xa16e
pushq $0x3e
popq %rdx
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/sthapliyal37[P]Microprocessor_8085_Updated/Memory_Allocation.cpp
// Function: getNumeral(int)
char getNumeral(int val) 
{ 
	if( val >= 0 && val <= 9) 
		return (val + '0'); 
	if( val >= 10 && val <= 14) 
		return (val + 'A' - 10); 
	assert(0); 
}

// Assembly:
cmpl $0x9, %edi
ja 0x311e
orb $0x30, %dil
jmp 0x312a
leal -0xa(%rdi), %eax
cmpl $0x4, %eax
ja 0x312d
addb $0x37, %dil
movl %edi, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x70b3(%rip), %rdi      # 0xa1eb
leaq 0x6ff9(%rip), %rsi      # 0xa138
leaq 0x7042(%rip), %rcx      # 0xa188
pushq $0x46
popq %rdx
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/sthapliyal37[P]Microprocessor_8085_Updated/Memory_Allocation.cpp
// Function: hexadecimalToDecimal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int hexadecimalToDecimal(string hexVal) 
{    
    int len = hexVal.length(); 
      
    int base = 1; 
      
    int dec_val = 0; 
      
    for (int i=len-1; i>=0; i--) 
    {    
        if (hexVal[i]>='0' && hexVal[i]<='9') 
        { 
            dec_val += (hexVal[i] - 48)*base; 
                  
            base = base * 16; 
        } 
          else if (hexVal[i]>='a' && hexVal[i]<='f') 
        { 
            dec_val += (hexVal[i] - 55)*base; 
          
            base = base*16; 
        } 
    } 
      
    return dec_val; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x8(%rdi), %ecx
xorl %eax, %eax
movl $0x1, %edx
movl %ecx, %esi
decq %rcx
testl %esi, %esi
jle 0x319d
movq (%rdi), %r8
movsbl (%r8,%rcx), %r8d
cmpl $0x2f, %r8d
jle 0x3183
cmpb $0x39, %r8b
jbe 0x3187
leal -0x61(%r8), %r9d
cmpb $0x5, %r9b
jbe 0x318d
decl %esi
jmp 0x315e
addl $-0x30, %r8d
jmp 0x3191
addl $-0x37, %r8d
imull %edx, %r8d
addl %r8d, %eax
shll $0x4, %edx
jmp 0x315c
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sthapliyal37[P]Microprocessor_8085_Updated/Essential.cpp
// Function: increaseAddress(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string increaseAddress(string a)
{
	int number[5];
	string nextAddress="";
	int l=a.length();
	for(int i=l-1;i>=0;i--)
	{
		if(a[i]>='A'&&a[i]<='F')
			number[i]=(int)(10+(a[i]-'A'));
		if(a[i]>='0'&&a[i]<='9')
			number[i]=(int)(a[i]-'0');
	}
	number[l-1]++;
	for(int i=l-1;i>=0;i--)
	{
		if(number[i]>=0&&number[i]<=15)
			break;
		if(number[i]>=16)
		{
			number[i]=number[i]%16;
			number[i-1]++;
		}
	}
	for(int i=0;i<l;i++)
	{
		if(number[i]>=0&&number[i]<=9)
			nextAddress+=(char)('0'+(number[i]));
		else if(number[i]>=10 && number[i]<=15)
			nextAddress+=(char)('A'+(number[i]-10));
	}
	return nextAddress;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x6984(%rip), %rsi      # 0xa202
leaq -0x19(%rbp), %rdx
callq 0x2f1e
movl 0x8(%r14), %r15d
leal -0x1(%r15), %eax
pushq $-0x37
popq %rcx
pushq $-0x30
popq %rdx
movl %eax, %esi
testl %esi, %esi
js 0x38cf
movl %esi, %edi
movq (%r14), %r8
movsbl (%r8,%rdi), %r8d
cmpl $0x41, %r8d
jl 0x38b6
movl %ecx, %r9d
cmpb $0x47, %r8b
jb 0x38c3
jmp 0x38cb
leal -0x30(%r8), %r10d
movl %edx, %r9d
cmpb $0x9, %r10b
ja 0x38cb
addl %r8d, %r9d
movl %r9d, -0x30(%rbp,%rdi,4)
decl %esi
jmp 0x3897
cltq
incl -0x30(%rbp,%rax,4)
testq %rax, %rax
js 0x38f5
movl -0x30(%rbp,%rax,4), %ecx
cmpl $0x10, %ecx
jb 0x38f5
jl 0x38f0
andl $0xf, %ecx
movl %ecx, -0x30(%rbp,%rax,4)
incl -0x34(%rbp,%rax,4)
decq %rax
jmp 0x38d5
xorl %r14d, %r14d
testl %r15d, %r15d
cmovlel %r14d, %r15d
cmpq %r14, %r15
je 0x392c
movl -0x30(%rbp,%r14,4), %eax
cmpl $0x9, %eax
ja 0x3912
orb $0x30, %al
jmp 0x391c
leal -0xa(%rax), %ecx
cmpl $0x5, %ecx
ja 0x3927
addb $0x37, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x21b0
incq %r14
jmp 0x38ff
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/sthapliyal37[P]Microprocessor_8085_Updated/Essential.cpp
// Function: complement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string complement(string a)
{
	int l=a.length();
	string complment="";
	for(int i=0;i<l;i++)
	{
		if(a[i]>='0'&&a[i]<='9')
		{
			int diff=15-(a[i]-'0');
			if(diff>=0&&diff<=9)
				complment+=('0'+diff);
			else if(diff>=10&&diff<=15)
				complment+=('A'+(diff-10));	
		}
		if(a[i]>='A'&&a[i]<='F')
		{
			int value=a[i]-'A';
			int diff=15-value;
			if(diff>=0&&diff<=9)
				complment+=('0'+diff);
			else if(diff>=10&&diff<=15)
				complment+=('A'+(diff-10));
		}
	}
	return complment;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %r15d
leaq 0x6896(%rip), %rsi      # 0xa202
leaq -0x29(%rbp), %rdx
callq 0x2f1e
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
pushq $0x6f
popq %r13
cmpq %r12, %r15
je 0x39d5
movq (%r14), %rax
movb (%rax,%r12), %al
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x39b2
leal -0x36(%rax), %edx
movl %r13d, %ecx
cmpb $0xa, %dl
jb 0x39a5
pushq $0x76
popq %rcx
subb %al, %cl
movzbl %cl, %esi
movq %rbx, %rdi
callq 0x21b0
movq (%r14), %rax
movb (%rax,%r12), %al
leal -0x41(%rax), %ecx
cmpb $0x6, %cl
jae 0x39d0
movb $-0x79, %cl
subb %al, %cl
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x21b0
incq %r12
jmp 0x3983
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x39e9
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/sthapliyal37[P]Microprocessor_8085_Updated/Essential.cpp
// Function: decimalToHex[abi:cxx11](int*)
string decimalToHex(int* deciml)
{
	string hex="";
	int size=sizeof(deciml)/sizeof(deciml[0]);
	for(int i=0;i<size;i++)
	{
		if(deciml[i]>=0 && deciml[i]<=9)
			hex = hex + char('0' + deciml[i]);
		else if(deciml[i]>=10 && deciml[i]<=15)
			hex+=(char)('A'+(deciml[i]-10));
	}
	return hex;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x67ea(%rip), %rsi      # 0xa202
leaq -0x40(%rbp), %r15
movq %r15, %rdx
callq 0x2f1e
xorl %r12d, %r12d
cmpq $0x2, %r12
je 0x3a75
movl (%r14,%r12,4), %eax
cmpl $0x9, %eax
ja 0x3a5b
orb $0x30, %al
movsbl %al, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x401e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2250
movq %r15, %rdi
callq 0x20f0
jmp 0x3a70
leal -0xa(%rax), %ecx
cmpl $0x5, %ecx
ja 0x3a70
addb $0x37, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x21b0
incq %r12
jmp 0x3a27
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a87
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2310