LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc987
callq 0x3180
jmp 0xc98c
callq 0x31d0
leaq 0x2e3a(%rip), %rdx      # 0xf7cd
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 0x981e
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xcd54
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 0xcd54
decq %r13
movl $0x28, %ebp
testq %r14, %r14
je 0xcd37
movq %rbx, %rdi
movq %r14, %rsi
callq 0x34a0
movq (%r15), %rax
movq -0x8(%rax,%rbp), %rsi
movq (%rax,%rbp), %rdx
movq %rbx, %rdi
callq 0x30b0
addq $0x20, %rbp
decq %r13
jne 0xcd27
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcd68
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0xcd7f
movq (%r12), %rsi
incq %rsi
callq 0x3230
movq %r14, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/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 0xdef9
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 0x1a3e(%rip), %rax      # 0xf904
leaq 0x1a38(%rip), %rsi      # 0xf905
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 0xdf11
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1a08(%rip), %rsi      # 0xf90f
leaq 0x1a07(%rip), %rdx      # 0xf915
movq %rbx, %rdi
callq 0x981e
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1843(%rip), %rdi      # 0xfa3f
callq 0x33d0
leaq 0x1879(%rip), %rdi      # 0xfa81
callq 0x33d0
leaq 0x189f(%rip), %rdi      # 0xfab3
callq 0x33d0
leaq 0x18d8(%rip), %rdi      # 0xfaf8
callq 0x33d0
leaq 0x1904(%rip), %rdi      # 0xfb30
callq 0x33d0
leaq 0x191c(%rip), %rdi      # 0xfb54
popq %rax
jmp 0x33d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x37ba
leaq 0x16b3(%rip), %rdi      # 0xf916
xorl %eax, %eax
callq 0x3040
movq %r14, %rdi
callq 0x3b16
cmpb $0x1, 0x6006(%rip)      # 0x1427f
jne 0xe292
movzbl 0x5ff6(%rip), %edx      # 0x14278
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x89aa
jmp 0xe33c
movq %rsp, %rdi
callq 0x3ce0
leaq 0x1686(%rip), %rdi      # 0xf927
xorl %eax, %eax
callq 0x3040
movq %rsp, %rdi
callq 0x3e72
leaq 0x167e(%rip), %rdi      # 0xf935
xorl %eax, %eax
callq 0x3040
movq %rsp, %rdi
callq 0x5eb6
leaq 0x167a(%rip), %rdi      # 0xf947
xorl %eax, %eax
callq 0x3040
movzbl 0x5f9d(%rip), %edx      # 0x14278
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x62f8
leaq 0x1668(%rip), %rdi      # 0xf955
xorl %eax, %eax
callq 0x3040
movzbl 0x5f7d(%rip), %edx      # 0x14278
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x69d2
leaq 0x165d(%rip), %rdi      # 0xf96a
xorl %eax, %eax
callq 0x3040
movzbl 0x5f5d(%rip), %edx      # 0x14278
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x71d6
leaq 0x1650(%rip), %rdi      # 0xf97d
xorl %eax, %eax
callq 0x3040
movq %rsp, %rdi
callq 0x77e6
movq %rsp, %rdi
callq 0x374c
addq $0xf8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x374c
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2d61
movq %rsi, %rbx
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 0x2da2
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 0x2ee0
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x2d4b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2110
incl %ebp
cmpl 0x20(%rbx), %ebp
jl 0x2cfd
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1305(%rip), %rdi      # 0x406d
leaq 0x1310(%rip), %rsi      # 0x407f
leaq 0x1314(%rip), %rcx      # 0x408a
movl $0xd, %edx
callq 0x20a0
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x2d9a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2110
movq %rbx, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O3/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 0x12f7(%rip), %rdx      # 0x40ae
leaq 0x10(%rsp), %rdi
movl $0x80, %esi
xorl %eax, %eax
callq 0x2170
testl %eax, %eax
jle 0x2ded
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rbx
movl %eax, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x318c
movl (%rbx), %eax
addq $0x90, %rsp
popq %rbx
retq
leaq 0x12c0(%rip), %rdi      # 0x40b4
leaq 0x1284(%rip), %rsi      # 0x407f
leaq 0x12ba(%rip), %rcx      # 0x40bc
movl $0x2f, %edx
callq 0x20a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x41f6
callq 0x2110
xorl %eax, %eax
movq %rax, (%rbx)
movq %rax, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4223
movq (%rbx), %rcx
movq 0x8(%rbx), %rdi
movl $0x1, %esi
movl $0x100000, %edx         # imm = 0x100000
callq 0x21b0
movl %eax, 0x14(%rbx)
xorl %ecx, %ecx
testl %eax, %eax
jle 0x4235
movq 0x8(%rbx), %rax
leal 0x1(%rcx), %edx
movl %edx, 0x10(%rbx)
movslq %ecx, %rcx
movb (%rax,%rcx), %al
popq %rbx
retq
movl $0x4, %edi
callq 0x20a0
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq 0x3d7c(%rip), %rsi      # 0x7fc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x41f8
movzbl %al, %eax
shll $0x8, %ebp
orl %eax, %ebp
decl %r14d
jne 0x4263
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
decl %edx
cmpl %edx, %esi
cmovgl %esi, %edx
xorl %eax, %eax
testl %edx, %edx
cmovnsl %edx, %eax
movl 0x38(%rdi), %ecx
cmpl %eax, %ecx
je 0x42c2
movl %eax, 0x38(%rdi)
cmpl %eax, %ecx
setne %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4300
movl %eax, 0x38(%rdi)
cmpl %eax, %ecx
setne %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4338
cmpl %edx, 0x40(%rdi)
je 0x434d
movl %edx, 0x40(%rdi)
jmp 0x435a
testl %esi, %esi
movl $0xf, %eax
cmovel %esi, %eax
cmpl %eax, 0x38(%rdi)
jne 0x4350
cmpl $0x0, 0x40(%rdi)
jne 0x4350
xorl %eax, %eax
retq
movl $0x0, 0x40(%rdi)
movl %eax, 0x38(%rdi)
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4391
movl %eax, 0x38(%rdi)
cmpl %eax, %ecx
setne %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x43cd
movl %eax, 0x38(%rdi)
cmpl %eax, %ecx
setne %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0xf, %eax
cmovel %esi, %eax
movl 0x38(%rdi), %ecx
cmpl %eax, %ecx
je 0x440e
movl %eax, 0x38(%rdi)
cmpl %eax, %ecx
setne %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
subq $0x20, %rsp
leaq 0xdd0(%rip), %rdi       # 0x2020
leaq -0x10(%rbp), %rsi
leaq -0x8(%rbp), %rdx
leaq -0x18(%rbp), %rcx
callq 0x116c
testq %rax, %rax
je 0x1280
leaq 0xda3(%rip), %rdi       # 0x2010
leaq 0xdae(%rip), %rsi       # 0x2022
movq %rax, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1050
movq -0x8(%rbp), %rax
testq %rax, %rax
jne 0x1299
leaq 0xda5(%rip), %rdi       # 0x2035
callq 0x1040
movq -0x8(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x12af
leaq 0xda9(%rip), %rdi       # 0x204f
callq 0x1040
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq %rcx, %rax
jae 0x12c8
leaq 0xdb8(%rip), %rdi       # 0x2077
callq 0x1040
movq -0x10(%rbp), %rcx
cmpq %rcx, -0x18(%rbp)
jae 0x12da
leaq 0xdcf(%rip), %rdi       # 0x20a4
callq 0x1040
leaq 0xdf2(%rip), %rdi       # 0x20d3
leaq -0x10(%rbp), %rsi
leaq -0x8(%rbp), %rdx
leaq -0x18(%rbp), %rcx
callq 0x116c
movq %rax, %rdi
callq 0x11cc
testb %al, %al
jne 0x130a
leaq 0xdd0(%rip), %rdi       # 0x20d5
callq 0x1040
movq -0x10(%rbp), %rsi
leaq 0xdde(%rip), %rdi       # 0x20f3
xorl %eax, %eax
callq 0x1050
movq -0x18(%rbp), %rsi
leaq 0xdd8(%rip), %rdi       # 0x20ff
xorl %eax, %eax
callq 0x1050
movq -0x8(%rbp), %rsi
leaq 0xdd2(%rip), %rdi       # 0x210b
xorl %eax, %eax
callq 0x1050
leaq 0xdd4(%rip), %rdi       # 0x211b
callq 0x1040
leaq 0xdb3(%rip), %rdi       # 0x2106
movq $-0x7fe, %rsi           # imm = 0xF802
xorl %eax, %eax
callq 0x1050
leaq 0xdaf(%rip), %rdi       # 0x2117
movsd 0xc98(%rip), %xmm0      # 0x2008
movb $0x1, %al
callq 0x1050
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2994
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movb (%rax), %cl
cmpb $0x30, %cl
jl 0x2990
cmpb $0x3a, %cl
setb %dl
addb $-0x41, %cl
cmpb $0x6, %cl
setb %cl
orb %dl, %cl
cmpb $0x1, %cl
jne 0x2990
movb 0x1(%rax), %al
cmpb $0x30, %al
jl 0x2990
cmpb $0x3a, %al
setb %cl
addb $-0x41, %al
cmpb $0x6, %al
setb %al
orb %cl, %al
movb $0x1, %al
jne 0x2992
xorl %eax, %eax
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x29ce
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rcx
xorl %edx, %edx
movb (%rcx,%rdx), %al
cmpb $0x30, %al
jl 0x29c1
cmpb $0x3a, %al
setb %sil
addb $-0x41, %al
cmpb $0x6, %al
setb %al
orb %sil, %al
movb $0x1, %al
jne 0x29c3
xorl %eax, %eax
incq %rdx
cmpq $0x4, %rdx
jne 0x29a6
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8(%rdi), %r13
cmpl 0x8(%rsi), %r13d
jne 0x33ea
movq %rsi, %rbx
movq %rdi, %r12
leal 0x1(%r13), %eax
movslq %eax, %rdi
callq 0x2030
movq %rax, %r15
testl %r13d, %r13d
jle 0x33d5
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
incq %r13
movq %rbx, -0x30(%rbp)
xorl %ebx, %ebx
movq %r12, -0x38(%rbp)
movq (%r12), %rax
movsbl -0x2(%rax,%r13), %edi
callq 0x341c
movl %eax, %r12d
movq -0x30(%rbp), %rax
movq (%rax), %rax
movsbl -0x2(%rax,%r13), %edi
callq 0x341c
addl %ebx, %r12d
leal (%r12,%rax), %r14d
xorl %ebx, %ebx
cmpl $0xe, %r14d
setae %bl
leal -0xe(%rax,%r12), %edi
movq -0x38(%rbp), %r12
cmovbl %r14d, %edi
callq 0x345e
movb %al, -0x1(%r15,%r13)
decq %r13
cmpq $0x1, %r13
ja 0x3375
cmpl $0xd, %r14d
jbe 0x33d5
movb $0x31, (%r15)
jmp 0x33d8
incq %r15
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xebdf(%rip), %rdi      # 0x11fd0
leaq 0xacb2(%rip), %rsi      # 0xe0aa
callq 0x21f0
leaq 0xade7(%rip), %rdi      # 0xe1eb
leaq 0xad2d(%rip), %rsi      # 0xe138
leaq 0xad3c(%rip), %rcx      # 0xe14e
movl $0x1a, %edx
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0xffffffd0, %ecx       # imm = 0xFFFFFFD0
cmpb $0xa, %al
jb 0x3434
leal -0x41(%rdi), %eax
movl $0xffffffc9, %ecx       # imm = 0xFFFFFFC9
cmpb $0x4, %al
jae 0x343b
movsbl %dil, %eax
addl %ecx, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0xada5(%rip), %rdi      # 0xe1eb
leaq 0xaceb(%rip), %rsi      # 0xe138
leaq 0xad1a(%rip), %rcx      # 0xe16e
movl $0x3e, %edx
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3469
orb $0x30, %dil
jmp 0x3475
leal -0xa(%rdi), %eax
cmpl $0x4, %eax
ja 0x3478
addb $0x37, %dil
movl %edi, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0xad68(%rip), %rdi      # 0xe1eb
leaq 0xacae(%rip), %rsi      # 0xe138
leaq 0xacf7(%rip), %rcx      # 0xe188
movl $0x46, %edx
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0xa163(%rip), %rdx      # 0xe202
movq %rdx, %rsi
callq 0x328a
movq 0x8(%r14), %r12
testl %r12d, %r12d
jle 0x416c
leal -0x1(%r12), %eax
movq (%r14), %rcx
movl %eax, %edx
incq %rdx
movsbl -0x1(%rcx,%rdx), %esi
cmpl $0x41, %esi
jl 0x40e3
movl $0xffffffc9, %edi       # imm = 0xFFFFFFC9
cmpb $0x47, %sil
jae 0x40dc
addl %esi, %edi
movl %edi, -0x44(%rbp,%rdx,4)
decq %rdx
jg 0x40c1
jmp 0x40f4
leal -0x30(%rsi), %r8d
movl $0xffffffd0, %edi       # imm = 0xFFFFFFD0
cmpb $0x9, %r8b
jbe 0x40d6
jmp 0x40dc
cltq
incl -0x40(%rbp,%rax,4)
testl %r12d, %r12d
jle 0x416c
movl %r12d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
decq %rax
movl -0x40(%rbp,%rax,4), %ecx
cmpl $0x10, %ecx
jb 0x4132
jl 0x4126
andl $0xf, %ecx
movl %ecx, -0x40(%rbp,%rax,4)
leaq -0x1(%rax), %rcx
incl -0x44(%rbp,%rax,4)
jmp 0x412a
leaq -0x1(%rax), %rcx
testq %rax, %rax
movq %rcx, %rax
jg 0x410a
testl %r12d, %r12d
jle 0x416c
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r14d, %r14d
movl -0x40(%rbp,%r14,4), %eax
cmpl $0x9, %eax
ja 0x414f
orb $0x30, %al
jmp 0x4159
leal -0xa(%rax), %ecx
cmpl $0x5, %ecx
ja 0x4164
addb $0x37, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x21b0
incq %r14
cmpq %r14, %r12
jne 0x4141
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x4192
movq (%r15), %rsi
incq %rsi
callq 0x2210
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x8(%rsi), %r12
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0xa042(%rip), %rdx      # 0xe202
movq %rdx, %rsi
callq 0x328a
testl %r12d, %r12d
jle 0x422b
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movq (%r14), %rax
movb (%rax,%r13), %al
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x4205
leal -0x36(%rax), %edx
movl $0x6f, %ecx
cmpb $0xa, %dl
jb 0x41f8
movl $0x76, %ecx
subb %al, %cl
movzbl %cl, %esi
movq %rbx, %rdi
callq 0x21b0
movq (%r14), %rax
movb (%rax,%r13), %al
leal -0x41(%rax), %ecx
cmpb $0x6, %cl
jae 0x4223
movb $-0x79, %cl
subb %al, %cl
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x21b0
incq %r13
cmpq %r13, %r12
jne 0x41d7
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x423f
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x4255
movq (%r15), %rsi
incq %rsi
callq 0x2210
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
leaq 0x9f7c(%rip), %rdx      # 0xe202
movq %rdx, %rsi
callq 0x328a
movb $0x1, %r12b
xorl %eax, %eax
leaq -0x50(%rbp), %r15
movl (%r14,%rax,4), %r13d
cmpl $0x9, %r13d
ja 0x42fc
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x31ec
orb $0x30, %r13b
movq -0x48(%rbp), %rsi
movsbl %r13b, %r8d
movl $0x1, %ecx
movq %r15, %rdi
xorl %edx, %edx
callq 0x2360
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2270
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x4315
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2210
jmp 0x4315
leal -0xa(%r13), %eax
cmpl $0x5, %eax
ja 0x4315
addb $0x37, %r13b
movsbl %r13b, %esi
movq %rbx, %rdi
callq 0x21b0
movl $0x1, %eax
testb $0x1, %r12b
movl $0x0, %r12d
jne 0x4297
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x433e
movq %rax, %r14
jmp 0x435f
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x435f
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2210
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x4377
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2210
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/sthapliyal37[P]Microprocessor_8085_Updated/Essential.cpp
// Function: hexAdd16bit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool*, bool)
string hexAdd16bit (string arg1,string arg2,bool* flag,bool check)
{
	int l1=arg1.length();
	int l2=arg2.length();
	string hex="";
	if(l1==1&&l2==4)
	{
		int value1[4]={0,0,0,0};
		for(int i=0;i<l1;i++)
		{
			if(arg1[i]>='0'&&arg1[i]<='9')
				value1[i]=(int)(arg1[i]-'0');
			else if(arg1[i]>='A'&&arg1[i]<='Z')
				value1[i]=(int)(arg1[i]-'A');
		}
		int i=l1-1;
		value1[l1-1]++;
		while(value1[i]>=16)
		{
			value1[i]=value1[i]%16;
			if(i==0)
			{
				flag[0]=true;
				break;
			}
			else
				value1[--i]++;
		}
		int value=value1[0]*16*16*16+value1[1]*16*16+value1[2]*16+value1[3];
		bitset<16>str(value);
		flag[7]=str[15];
		int parity=str.count();
		if(parity==0)
			flag[6]=true;
		else if(parity%2==0)
			flag[2]=true;
		else if(parity%2==1)
			flag[2]=false;
		for(int i=0;i<l1;i++)
		{
			if(value1[i]>=0&&value1[i]<=9)
				hex+=(char)value1[i];
			else if(value1[i]>=10&&value1[i]<=15)
				hex+=(char)('A'+(value1[i]-10));
		}
	}
	return hex;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rsi), %r12d
movl 0x8(%rdx), %r13d
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
leaq 0x9e52(%rip), %rdx      # 0xe202
movq %rdx, %rsi
callq 0x328a
cmpl $0x1, %r12d
jne 0x4452
cmpl $0x4, %r13d
jne 0x4452
movq (%r15), %rax
movsbl (%rax), %eax
movl $0x1, %ecx
cmpl $0x30, %eax
jl 0x4416
cmpb $0x39, %al
ja 0x43e7
addl $-0x2f, %eax
movl %eax, %ecx
jmp 0x4416
leal -0x41(%rax), %edx
cmpb $0x19, %dl
ja 0x4416
leal -0x50(%rax), %ecx
cmpl $-0xf, %ecx
jae 0x4464
andl $0xf, %eax
movb $0x1, (%r14)
movl %eax, %ecx
shrb $0x3, %cl
movb %cl, 0x7(%r14)
movl %eax, %ecx
testl %eax, %eax
jne 0x4421
movb $0x1, 0x6(%r14)
xorl %eax, %eax
jmp 0x4447
movl %ecx, %eax
shrb $0x3, %al
movb %al, 0x7(%r14)
movl %ecx, %eax
movl %eax, %edx
shll $0xc, %edx
movl %edx, %esi
shrl $0x10, %esi
xorl %esi, %edx
shrl $0x8, %edx
xorb %dl, %sil
setp 0x2(%r14)
leal 0x37(%rcx), %edx
cmpl $0xa, %eax
movzbl %cl, %ecx
movzbl %dl, %eax
cmovbl %ecx, %eax
movsbl %al, %esi
movq %rbx, %rdi
callq 0x21b0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addl $-0x40, %eax
jmp 0x43e3
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x4487
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2210
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/sthapliyal37[P]Microprocessor_8085_Updated/arithmetic.cpp
// Function: ADI(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, bool*)
void ADI(string instruction,string* registers,bool* flag)
{
		int length = instruction.length();
	if(length == 2){
	
		if(validityData(instruction)){
			registers[0] = hexAdd(instruction,registers[0],flag,true);
		}
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq 0x8(%rdi), %rdx
cmpl $0x2, %edx
jne 0x77dd
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x78(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rdi), %rsi
addq %rsi, %rdx
leaq -0x88(%rbp), %r12
movq %r12, %rdi
callq 0x31ec
movq %r12, %rdi
callq 0x294d
movl %eax, %r12d
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0x7726
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x2210
testb %r12b, %r12b
je 0x77dd
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x31ec
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x31ec
leaq -0xa8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x48(%rbp), %rdx
movq %r14, %rcx
movl $0x1, %r8d
callq 0x448f
leaq -0xa8(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2270
movq (%r14), %rdi
leaq -0x98(%rbp), %rax
cmpq %rax, %rdi
je 0x77b3
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x2210
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x77c8
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x77dd
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2210
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x780c
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
jmp 0x780c
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x7836
movq -0x58(%rbp), %rsi
jmp 0x782e
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0x7836
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x2210
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/sthapliyal37[P]Microprocessor_8085_Updated/arithmetic.cpp
// Function: SUI(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, bool*)
void SUI(string instruction,string* registers,bool* flag)
{
	int length = instruction.length();
	if(length == 2){
	
		if(validityData(instruction)){		
				registers[0] = hexSub(instruction,registers[0],flag,true);
		}
		else{
			
			cout<<"Error: \n";
			exit(0);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq 0x8(%rdi), %rdx
cmpl $0x2, %edx
jne 0xa105
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x78(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rdi), %rsi
addq %rsi, %rdx
leaq -0x88(%rbp), %r12
movq %r12, %rdi
callq 0x31ec
movq %r12, %rdi
callq 0x294d
movl %eax, %r12d
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0xa04e
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x2210
testb %r12b, %r12b
je 0xa117
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x31ec
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x31ec
leaq -0xa8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x48(%rbp), %rdx
movq %r14, %rcx
movl $0x1, %r8d
callq 0x4986
leaq -0xa8(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2270
movq (%r14), %rdi
leaq -0x98(%rbp), %rax
cmpq %rax, %rdi
je 0xa0db
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x2210
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xa0f0
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0xa105
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2210
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x7eb2(%rip), %rdi      # 0x11fd0
leaq 0x40d5(%rip), %rsi      # 0xe1fa
callq 0x21f0
xorl %edi, %edi
callq 0x2260
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xa14e
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
jmp 0xa14e
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0xa178
movq -0x58(%rbp), %rsi
jmp 0xa170
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0xa178
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x2210
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/sthapliyal37[P]Microprocessor_8085_Updated/Logical.cpp
// Function: CMA(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, bool*)
void CMA(string instruction,string registers[],bool flags[])
{
string complment = complement(registers[0]);
	registers[0] = complment;
		
	if(registers[0]=="00")
    {
        flags[6] = true;
        flags[2] = true;
    }
    else
    {
        string temp = registers[0];
		int array[2];
		hexToDecimal(temp,array);
		int value=array[1]*16+array[0];
		bitset<8> dataInBinary(value);
		int parity = dataInBinary.count();
		if(parity%2 == 0 && parity!=0)
			flags[2] = true;
		else
			flags[2] = false;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq -0x78(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %r15
movq %r15, %rdi
callq 0x31ec
leaq -0xa8(%rbp), %rdi
movq %r15, %rsi
callq 0x419a
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0xa984
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x2210
leaq -0xa8(%rbp), %rsi
movq %r14, %rdi
callq 0x2110
leaq 0x3850(%rip), %rsi      # 0xe1ea
movq %r14, %rdi
callq 0x20a0
testl %eax, %eax
je 0xaa32
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x31ec
leaq -0x58(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x31ec
leaq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x46ea
movq -0x68(%rbp), %rdi
cmpq %r14, %rdi
je 0xaa03
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2210
movl -0x24(%rbp), %eax
shll $0x4, %eax
addl -0x28(%rbp), %eax
testb %al, %al
setp %cl
testb $-0x1, %al
setne %al
andb %cl, %al
movb %al, 0x2(%rbx)
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xaa3a
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
jmp 0xaa3a
movb $0x1, %al
movb %al, 0x6(%rbx)
movb %al, 0x2(%rbx)
leaq -0x98(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaa59
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x2210
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r14, %rdi
je 0xaa86
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2210
jmp 0xaa86
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xaaa2
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
jmp 0xaaa2
jmp 0xaa9f
movq %rax, %rbx
leaq -0x98(%rbp), %r12
movq -0x10(%r12), %rdi
jmp 0xaaba
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0xaacb
movq (%r12), %rsi
incq %rsi
callq 0x2210
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O3/sthapliyal37[P]Microprocessor_8085_Updated/DataTransfer.cpp
// Function: LDA(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, bool*, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
void LDA(string instruction,string* registers,bool* flag,map<string,string>&memory){
		int length=instruction.length();
	if(length==4)
		if(validityAddress(instruction))
			registers[0] = memory[instruction];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x8(%rdi), %rdx
cmpl $0x4, %edx
jne 0xc149
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rdi), %rsi
addq %rsi, %rdx
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0x31ec
movq %r12, %rdi
callq 0x2997
movl %eax, %r12d
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0xc12e
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
testb %r12b, %r12b
je 0xc149
movq %r14, %rdi
movq %r15, %rsi
callq 0xa1e4
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2110
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0xc170
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/sthapliyal37[P]Microprocessor_8085_Updated/DataTransfer.cpp
// Function: STA(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, bool*, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
void STA(string instruction,string* registers,bool* flag,map<string,string> &memory){

int length=instruction.length();
	//cout<<length<<endl;
	if(length==4)
	{
		if(validityAddress(instruction))
		{	memory[instruction]=registers[0];
			//cout<<memory[instruction]<<endl;
		}	
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x8(%rdi), %rdx
cmpl $0x4, %edx
jne 0xc71c
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rdi), %rsi
addq %rsi, %rdx
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0x31ec
movq %r12, %rdi
callq 0x2997
movl %eax, %r12d
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0xc701
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
testb %r12b, %r12b
je 0xc71c
movq %r14, %rdi
movq %r15, %rsi
callq 0xa1e4
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2110
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0xc743
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/sthapliyal37[P]Microprocessor_8085_Updated/DataTransfer.cpp
// Function: SET(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
void SET(string instruction,string instruction2,map<string,string>& memory){
int length1=instruction.length();
	int length2=instruction2.length();
	if(length1==4&&length2==2)
		if(validityAddress(instruction)&&validityData(instruction2))
			memory[instruction]=instruction2;		
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq 0x8(%rdi), %rdx
cmpl $0x4, %edx
jne 0xca4b
movq %rsi, %rbx
movl 0x8(%rsi), %eax
cmpl $0x2, %eax
jne 0xca4b
movq %rdi, %r15
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%rdi), %rsi
addq %rsi, %rdx
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0x31ec
movq %r12, %rdi
callq 0x2997
testb %al, %al
je 0xca14
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x31ec
leaq -0x68(%rbp), %rdi
callq 0x294d
movl %eax, %r12d
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0xca17
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2210
jmp 0xca17
xorl %r12d, %r12d
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xca30
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
testb %r12b, %r12b
je 0xca4b
movq %r14, %rdi
movq %r15, %rsi
callq 0xa1e4
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2110
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0xca77
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2210
jmp 0xca77
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xca90
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/pngdetail.cpp
// Function: colorTypeString[abi:cxx11](LodePNGColorType)
std::string colorTypeString(LodePNGColorType type) {
  std::string name;
  switch(type) {
    case LCT_GREY: name = "grey"; break;
    case LCT_RGB: name = "RGB"; break;
    case LCT_PALETTE: name = "palette"; break;
    case LCT_GREY_ALPHA: name = "grey+alpha"; break;
    case LCT_RGBA: name = "RGBA"; break;
    default: name = "invalid"; break;
  }
  std::stringstream ss;
  ss << type << " (" << name << ")";
  return ss.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
cmpl $0x7, %esi
jae 0x162fd
movl %ebp, %eax
leaq 0xcff7(%rip), %rdx      # 0x232e0
movslq (%rdx,%rax,4), %rcx
addq %rdx, %rcx
leaq 0xd009(%rip), %rdx      # 0x23300
movq (%rdx,%rax,8), %r8
jmp 0x1630a
movl $0x7, %r8d
leaq 0xc474(%rip), %rcx      # 0x2277e
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2310
leaq 0x20(%rsp), %rdi
callq 0x2190
leaq 0x30(%rsp), %rdi
movl %ebp, %esi
callq 0x2390
movq %rax, %r14
leaq 0xdf77(%rip), %rsi      # 0x242ad
movl $0x2, %edx
movq %rax, %rdi
callq 0x2290
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x2290
leaq 0xcd7b(%rip), %rsi      # 0x230d6
movl $0x1, %edx
movq %rax, %rdi
callq 0x2290
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x2320
leaq 0x20(%rsp), %rdi
callq 0x21b0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1638d
callq 0x2210
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x163a0
movq %rax, %rbx
jmp 0x163b2
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x21b0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x163c0
callq 0x2210
movq %rbx, %rdi
callq 0x23a0
movq %rax, %rdi
callq 0x14c96
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/pngdetail.cpp
// Function: RGBtoHSL(unsigned char, unsigned char, unsigned char, unsigned char*, unsigned char*, unsigned char*)
void RGBtoHSL(unsigned char r, unsigned char g, unsigned char b, unsigned char* h, unsigned char* s, unsigned char* l) {
  int cmax = std::max<int>(r, std::max<int>(g, b));
  int cmin = std::min<int>(r, std::min<int>(g, b));
  if(cmin == cmax) {
    *h = *s = 0;
    *l = r;
  } else {
    int sum = cmin + cmax;
    int diff = cmax - cmin;
    *l = sum / 2;
    *s = 255 * diff / ((*l < 128) ? sum : (512 - sum));
    int hi = (r == cmax) ? (255 * (g - b) / diff) : ((g == cmax) ? (512 + 255 * (b - r) / diff) : (1024 + 255 * (r - g) / diff));
    *h = ((hi / 6) & 255);
  }
}

// Assembly:
pushq %rbp
pushq %rbx
movl %edx, %r10d
cmpb %r10b, %sil
movl %edx, %ebx
cmoval %esi, %ebx
cmpb %bl, %dil
movl %ebx, %ebp
cmoval %edi, %ebp
cmpb %sil, %r10b
movl %esi, %eax
cmovbl %edx, %eax
cmpb %dil, %al
cmovael %edi, %eax
cmpb %bpl, %al
jne 0x16abe
xorl %eax, %eax
movb %al, (%r8)
movb %al, (%rcx)
movb %dil, (%r9)
jmp 0x16b51
movzbl %bpl, %r11d
movzbl %al, %eax
leal (%rax,%r11), %edx
subl %eax, %r11d
movl %edx, %eax
shrl %eax
movb %al, (%r9)
movl %r11d, %eax
shll $0x8, %eax
subl %r11d, %eax
movl $0x200, %r9d            # imm = 0x200
subl %edx, %r9d
cmpl $0x100, %edx            # imm = 0x100
cmovbl %edx, %r9d
cltd
idivl %r9d
movb %al, (%r8)
cmpb %dil, %bl
jbe 0x16b17
cmpb %sil, %bpl
jne 0x16b27
subl %edi, %r10d
movl %r10d, %eax
shll $0x8, %eax
subl %r10d, %eax
cltd
idivl %r11d
addl $0x200, %eax            # imm = 0x200
jmp 0x16b39
subl %r10d, %esi
movl %esi, %eax
shll $0x8, %eax
subl %esi, %eax
cltd
idivl %r11d
jmp 0x16b39
subl %esi, %edi
movl %edi, %eax
shll $0x8, %eax
subl %edi, %eax
cltd
idivl %r11d
addl $0x400, %eax            # imm = 0x400
cltq
imulq $0x2aaaaaab, %rax, %rax # imm = 0x2AAAAAAB
movq %rax, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rax
addl %edx, %eax
movb %al, (%rcx)
popq %rbx
popq %rbp
retq