LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4433
movl %eax, 0x38(%rdi)
cmpl %eax, %ecx
setne %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4474
movl %eax, 0x38(%rdi)
cmpl %eax, %ecx
setne %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq 0x2def(%rip), %rbx      # 0x3fd8
leaq 0xe14(%rip), %rsi       # 0x2004
movl $0x9, %edx
movq %rbx, %rdi
callq 0x1080
movl $0xa, %esi
movq %rbx, %rdi
callq 0x1040
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1070
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq $0x0, -0x8(%rbp)
jne 0x1293
leaq 0xda7(%rip), %rdi       # 0x2035
callq 0x1040
movq -0x8(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x12a9
leaq 0xdab(%rip), %rdi       # 0x204f
callq 0x1040
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x12bf
leaq 0xdbd(%rip), %rdi       # 0x2077
callq 0x1040
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x12d5
leaq 0xdd4(%rip), %rdi       # 0x20a4
callq 0x1040
leaq 0xdf7(%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 0x1305
leaq 0xdd5(%rip), %rdi       # 0x20d5
callq 0x1040
movq -0x10(%rbp), %rsi
leaq 0xde3(%rip), %rdi       # 0x20f3
xorl %eax, %eax
callq 0x1050
movq -0x18(%rbp), %rsi
leaq 0xddd(%rip), %rdi       # 0x20ff
xorl %eax, %eax
callq 0x1050
movq -0x8(%rbp), %rsi
leaq 0xdd7(%rip), %rdi       # 0x210b
xorl %eax, %eax
callq 0x1050
leaq 0xdd9(%rip), %rdi       # 0x211b
callq 0x1040
leaq 0xdb8(%rip), %rdi       # 0x2106
movq $-0x7fe, %rsi           # imm = 0xF802
xorl %eax, %eax
callq 0x1050
leaq 0xdb4(%rip), %rdi       # 0x2117
movsd 0xc9d(%rip), %xmm0      # 0x2008
movb $0x1, %al
callq 0x1050
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sthapliyal37[P]Microprocessor_8085_Updated/Validation.cpp
// Function: validityRegisters(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool validityRegisters(string reg)
{
	if(reg=="A"||reg=="B"||reg=="C"||reg=="D"||reg=="E"||reg=="H"||reg=="L")
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0xb9f5(%rip), %rsi      # 0xe062
callq 0x20a0
movb $0x1, %bl
testl %eax, %eax
je 0x26eb
leaq 0xb9a1(%rip), %rsi      # 0xe020
movq %r14, %rdi
callq 0x20a0
testl %eax, %eax
je 0x26eb
leaq 0xb982(%rip), %rsi      # 0xe014
movq %r14, %rdi
callq 0x20a0
testl %eax, %eax
je 0x26eb
leaq 0xb98f(%rip), %rsi      # 0xe034
movq %r14, %rdi
callq 0x20a0
testl %eax, %eax
je 0x26eb
leaq 0xb94c(%rip), %rsi      # 0xe004
movq %r14, %rdi
callq 0x20a0
testl %eax, %eax
je 0x26eb
leaq 0xb93b(%rip), %rsi      # 0xe006
movq %r14, %rdi
callq 0x20a0
testl %eax, %eax
je 0x26eb
leaq 0xb92a(%rip), %rsi      # 0xe008
movq %r14, %rdi
callq 0x20a0
testl %eax, %eax
sete %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sthapliyal37[P]Microprocessor_8085_Updated/Validation.cpp
// Function: validityRegisterPair(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool validityRegisterPair(string reg)
{
	if(reg=="B"||reg=="D"||reg=="H"||reg=="M")
		return true;
	else 
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xb900(%rip), %rsi      # 0xe020
callq 0x20a0
movb $0x1, %r14b
testl %eax, %eax
je 0x2767
leaq 0xb901(%rip), %rsi      # 0xe034
movq %rbx, %rdi
callq 0x20a0
testl %eax, %eax
je 0x2767
leaq 0xb8c0(%rip), %rsi      # 0xe006
movq %rbx, %rdi
callq 0x20a0
testl %eax, %eax
je 0x2767
leaq 0xb8b7(%rip), %rsi      # 0xe010
movq %rbx, %rdi
callq 0x20a0
testl %eax, %eax
sete %r14b
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb8da(%rip), %rsi      # 0xe062
callq 0x20a0
testl %eax, %eax
je 0x280d
leaq 0xb888(%rip), %rsi      # 0xe020
movq %rbx, %rdi
callq 0x20a0
testl %eax, %eax
je 0x2811
leaq 0xb869(%rip), %rsi      # 0xe014
movq %rbx, %rdi
callq 0x20a0
testl %eax, %eax
je 0x2818
leaq 0xb876(%rip), %rsi      # 0xe034
movq %rbx, %rdi
callq 0x20a0
testl %eax, %eax
je 0x281f
leaq 0xb833(%rip), %rsi      # 0xe004
movq %rbx, %rdi
callq 0x20a0
testl %eax, %eax
je 0x2826
leaq 0xb822(%rip), %rsi      # 0xe006
movq %rbx, %rdi
callq 0x20a0
testl %eax, %eax
je 0x282d
leaq 0xb811(%rip), %rsi      # 0xe008
movq %rbx, %rdi
callq 0x20a0
xorl %ecx, %ecx
testl %eax, %eax
movl $0x6, %eax
cmovnel %ecx, %eax
jmp 0x2832
xorl %eax, %eax
jmp 0x2832
movl $0x1, %eax
jmp 0x2832
movl $0x2, %eax
jmp 0x2832
movl $0x3, %eax
jmp 0x2832
movl $0x4, %eax
jmp 0x2832
movl $0x5, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x1a0(%rbp), %rdi
callq 0x2160
leaq -0x190(%rbp), %rdi
movl %r14d, %esi
callq 0x2300
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq -0x1a0(%rbp), %rdi
movq %rbx, %rsi
callq 0x2280
movq 0xf725(%rip), %rsi      # 0x11fb8
leaq -0x1a0(%rbp), %rdi
callq 0x2180
leaq -0x120(%rbp), %rdi
callq 0x20c0
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x28d7
movq (%r15), %rsi
incq %rsi
callq 0x2210
jmp 0x28d7
movq %rax, %r14
movq 0xf6da(%rip), %rsi      # 0x11fb8
leaq -0x1a0(%rbp), %rdi
callq 0x2180
leaq -0x120(%rbp), %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq 0xb6f9(%rip), %rsi      # 0xe012
leaq 0xb6f5(%rip), %rdx      # 0xe015
callq 0x32be
xorl %eax, %eax
movq (%r14), %rcx
movzbl (%rcx,%rax), %ecx
testb $-0x21, %cl
je 0x293e
movq (%rbx), %rdx
movb %cl, (%rdx,%rax)
incq %rax
jmp 0x2927
movq (%rbx), %rcx
movb $0x0, (%rcx,%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x298a
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movb (%rax), %cl
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
setae %dl
addb $-0x41, %cl
cmpb $0x6, %cl
setae %cl
testb %cl, %dl
jne 0x298d
movb 0x1(%rax), %cl
leal -0x30(%rcx), %edx
movb $0x1, %al
cmpb $0xa, %dl
jb 0x298f
addb $-0x41, %cl
cmpb $0x6, %cl
setb %al
jmp 0x298f
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x341a
movq %rsi, %rbx
movq %rdi, %r12
leal 0x1(%r13), %eax
movslq %eax, %rdi
callq 0x2030
movq %rax, %r15
testl %r13d, %r13d
jle 0x3405
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 0x344c
movl %eax, %r12d
movq -0x30(%rbp), %rax
movq (%rax), %rax
movsbl -0x2(%rax,%r13), %edi
callq 0x344c
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 0x348e
movb %al, -0x1(%r15,%r13)
decq %r13
cmpq $0x1, %r13
jg 0x33a5
cmpl $0xd, %r14d
jbe 0x3405
movb $0x31, (%r15)
jmp 0x3408
incq %r15
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xebaf(%rip), %rdi      # 0x11fd0
leaq 0xac82(%rip), %rsi      # 0xe0aa
callq 0x21f0
leaq 0xadb7(%rip), %rdi      # 0xe1eb
leaq 0xacfd(%rip), %rsi      # 0xe138
leaq 0xad0c(%rip), %rcx      # 0xe14e
movl $0x1a, %edx
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3464
leal -0x41(%rdi), %eax
movl $0xffffffc9, %ecx       # imm = 0xFFFFFFC9
cmpb $0x4, %al
jae 0x346b
movsbl %dil, %eax
addl %ecx, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0xad75(%rip), %rdi      # 0xe1eb
leaq 0xacbb(%rip), %rsi      # 0xe138
leaq 0xacea(%rip), %rcx      # 0xe16e
movl $0x3e, %edx
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3499
orb $0x30, %dil
jmp 0x34a5
leal -0xa(%rdi), %eax
cmpl $0x4, %eax
ja 0x34a8
addb $0x37, %dil
movl %edi, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0xad38(%rip), %rdi      # 0xe1eb
leaq 0xac7e(%rip), %rsi      # 0xe138
leaq 0xacc7(%rip), %rcx      # 0xe188
movl $0x46, %edx
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa0d7(%rip), %rdx      # 0xe202
movq %rdx, %rsi
callq 0x32be
movq 0x8(%r14), %r12
leal -0x1(%r12), %eax
testl %r12d, %r12d
jle 0x4173
movq (%r14), %rcx
movl %eax, %edx
incq %rdx
movzbl -0x1(%rcx,%rdx), %esi
leal -0x41(%rsi), %edi
cmpb $0x5, %dil
ja 0x415e
leal -0x37(%rsi), %edi
movl %edi, -0x44(%rbp,%rdx,4)
leal -0x30(%rsi), %edi
cmpb $0x9, %dil
ja 0x416e
addl $-0x30, %esi
movl %esi, -0x44(%rbp,%rdx,4)
decq %rdx
jg 0x4149
cltq
incl -0x40(%rbp,%rax,4)
testl %r12d, %r12d
jle 0x41a8
movl %r12d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
incq %rax
movl -0x48(%rbp,%rax,4), %ecx
cmpl $0x10, %ecx
jb 0x41a8
jl 0x419f
andl $0xf, %ecx
movl %ecx, -0x48(%rbp,%rax,4)
incl -0x4c(%rbp,%rax,4)
decq %rax
cmpq $0x1, %rax
jg 0x4189
testl %r12d, %r12d
jle 0x41e2
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r14d, %r14d
movl -0x40(%rbp,%r14,4), %eax
cmpl $0x9, %eax
ja 0x41c5
orb $0x30, %al
jmp 0x41cf
leal -0xa(%rax), %ecx
cmpl $0x5, %ecx
ja 0x41da
addb $0x37, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x21b0
incq %r14
cmpq %r14, %r12
jne 0x41b7
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 0x4208
movq (%r15), %rsi
incq %rsi
callq 0x2210
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9fcc(%rip), %rdx      # 0xe202
movq %rdx, %rsi
callq 0x32be
testl %r12d, %r12d
jle 0x42b1
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movq (%r14), %rax
movb (%rax,%r13), %al
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x427b
leal -0x36(%rax), %esi
movb $0x6f, %dl
cmpb $0xa, %sil
jb 0x426e
movb $0x76, %dl
cmpb $0x5, %cl
ja 0x427b
subb %al, %dl
movzbl %dl, %esi
movq %rbx, %rdi
callq 0x21b0
movq (%r14), %rax
movb (%rax,%r13), %al
leal -0x41(%rax), %ecx
cmpb $0x5, %cl
ja 0x42a9
leal -0x47(%rax), %esi
movb $-0x80, %dl
cmpb $0xa, %sil
jb 0x429c
movb $-0x79, %dl
cmpb $0x5, %cl
ja 0x42a9
subb %al, %dl
movsbl %dl, %esi
movq %rbx, %rdi
callq 0x21b0
incq %r13
cmpq %r13, %r12
jne 0x424d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x42c5
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x42db
movq (%r15), %rsi
incq %rsi
callq 0x2210
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9ef6(%rip), %rdx      # 0xe202
movq %rdx, %rsi
callq 0x32be
xorl %r12d, %r12d
leaq -0x50(%rbp), %r15
movl (%r14,%r12,4), %r13d
cmpl $0x9, %r13d
ja 0x4380
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x3224
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 0x4399
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2210
jmp 0x4399
leal -0xa(%r13), %eax
cmpl $0x5, %eax
ja 0x4399
addb $0x37, %r13b
movsbl %r13b, %esi
movq %rbx, %rdi
callq 0x21b0
incq %r12
cmpq $0x1, %r12
je 0x431b
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x43ba
movq %rax, %r14
jmp 0x43db
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x43db
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2210
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x43f3
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2210
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9dd6(%rip), %rdx      # 0xe202
movq %rdx, %rsi
callq 0x32be
cmpl $0x1, %r12d
jne 0x44ca
cmpl $0x4, %r13d
jne 0x44ca
movq (%r15), %rax
movzbl (%rax), %eax
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x445b
addl $-0x30, %eax
jmp 0x4468
leal -0x41(%rax), %edx
xorl %ecx, %ecx
cmpb $0x19, %dl
ja 0x446a
addl $-0x41, %eax
movl %eax, %ecx
leal 0x1(%rcx), %eax
cmpl $0xf, %ecx
jl 0x4479
andl $0xf, %eax
movb $0x1, (%r14)
movl %eax, %ecx
shll $0xc, %ecx
movl %ecx, %edx
andl $0xffff, %edx           # imm = 0xFFFF
cmpl $0x8000, %edx           # imm = 0x8000
setae 0x7(%r14)
andl $0xffff, %ecx           # imm = 0xFFFF
je 0x44a4
xorb %ch, %cl
jnp 0x44ab
movb $0x1, 0x2(%r14)
jmp 0x44b0
movb $0x1, 0x6(%r14)
jmp 0x44b0
movb $0x0, 0x2(%r14)
cmpl $0x9, %eax
jbe 0x44bf
leal -0xa(%rax), %ecx
cmpl $0x5, %ecx
ja 0x44ca
addb $0x37, %al
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
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x44f7
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2210
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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 0x782d
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 0x3224
movq %r12, %rdi
callq 0x294d
movl %eax, %r12d
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0x7776
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x2210
testb %r12b, %r12b
je 0x782d
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x3224
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x3224
leaq -0xa8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x48(%rbp), %rdx
movq %r14, %rcx
movl $0x1, %r8d
callq 0x44ff
leaq -0xa8(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2270
movq (%r14), %rdi
leaq -0x98(%rbp), %rax
cmpq %rax, %rdi
je 0x7803
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x2210
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x7818
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x782d
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 0x785c
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
jmp 0x785c
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x7886
movq -0x58(%rbp), %rsi
jmp 0x787e
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0x7886
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x2210
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa19b
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 0x3224
movq %r12, %rdi
callq 0x294d
movl %eax, %r12d
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0xa0e4
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x2210
testb %r12b, %r12b
je 0xa1ad
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x3224
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x3224
leaq -0xa8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x48(%rbp), %rdx
movq %r14, %rcx
movl $0x1, %r8d
callq 0x49e6
leaq -0xa8(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2270
movq (%r14), %rdi
leaq -0x98(%rbp), %rax
cmpq %rax, %rdi
je 0xa171
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x2210
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xa186
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0xa19b
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 0x7e1c(%rip), %rdi      # 0x11fd0
leaq 0x403f(%rip), %rsi      # 0xe1fa
callq 0x21f0
xorl %edi, %edi
callq 0x2260
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xa1e4
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
jmp 0xa1e4
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0xa20e
movq -0x58(%rbp), %rsi
jmp 0xa206
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0xa20e
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x2210
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3224
leaq -0xa8(%rbp), %rdi
movq %r15, %rsi
callq 0x4210
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0xaa24
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x2210
leaq -0xa8(%rbp), %rsi
movq %r14, %rdi
callq 0x2110
leaq 0x37b0(%rip), %rsi      # 0xe1ea
movq %r14, %rdi
callq 0x20a0
testl %eax, %eax
je 0xaad2
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x3224
leaq -0x58(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x3224
leaq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x475e
movq -0x68(%rbp), %rdi
cmpq %r14, %rdi
je 0xaaa3
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 0xaada
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
jmp 0xaada
movb $0x1, %al
movb %al, 0x6(%rbx)
movb %al, 0x2(%rbx)
leaq -0x98(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaaf9
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 0xab26
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2210
jmp 0xab26
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xab42
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
jmp 0xab42
jmp 0xab3f
movq %rax, %rbx
leaq -0x98(%rbp), %r12
movq -0x10(%r12), %rdi
jmp 0xab5a
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0xab6b
movq (%r12), %rsi
incq %rsi
callq 0x2210
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc1e2
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 0x3224
movq %r12, %rdi
callq 0x2991
movl %eax, %r12d
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0xc1c7
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
testb %r12b, %r12b
je 0xc1e2
movq %r14, %rdi
movq %r15, %rsi
callq 0xa27a
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 0xc209
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/sthapliyal37[P]Microprocessor_8085_Updated/DataTransfer.cpp
// Function: XCHG(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, bool*)
void XCHG(string* registers,bool* flag){
string temp=registers[3];
	registers[3]=registers[5];
	registers[5]=temp;
	temp=registers[4];
	registers[4]=registers[6];
	registers[6]=temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x60(%rdi), %r15
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x60(%rdi), %rsi
movq 0x68(%rdi), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x3224
leaq 0xa0(%rbx), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x2110
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x2110
leaq 0x80(%rbx), %r14
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x2110
addq $0xc0, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2110
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x2110
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xc723
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2210
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xc748
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2210
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc7c8
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 0x3224
movq %r12, %rdi
callq 0x2991
movl %eax, %r12d
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0xc7ad
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
testb %r12b, %r12b
je 0xc7c8
movq %r14, %rdi
movq %r15, %rsi
callq 0xa27a
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 0xc7ef
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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 0xcb16
movq %rsi, %rbx
movl 0x8(%rsi), %eax
cmpl $0x2, %eax
jne 0xcb16
movq %rdi, %r15
leaq -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%rdi), %rsi
addq %rsi, %rdx
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x3224
movq %r12, %rdi
callq 0x2991
movl %eax, %r13d
testb %al, %al
je 0xcac1
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x3224
leaq -0x48(%rbp), %rdi
callq 0x294d
movl %eax, %r12d
jmp 0xcac4
xorl %r12d, %r12d
testb %r13b, %r13b
je 0xcae2
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xcae2
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0xcafb
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2210
testb %r12b, %r12b
je 0xcb16
movq %r14, %rdi
movq %r15, %rsi
callq 0xa27a
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 -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xcb46
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2210
jmp 0xcb46
movq %rax, %rbx
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0xcb5f
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2210
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1651d
movl %ebp, %eax
leaq 0xcbb7(%rip), %rdx      # 0x230c0
movslq (%rdx,%rax,4), %rcx
addq %rdx, %rcx
leaq 0xcbc9(%rip), %rdx      # 0x230e0
movq (%rdx,%rax,8), %r8
jmp 0x1652a
movl $0x7, %r8d
leaq 0xc130(%rip), %rcx      # 0x2265a
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2300
leaq 0x20(%rsp), %rdi
callq 0x2180
leaq 0x30(%rsp), %rdi
movl %ebp, %esi
callq 0x2380
movq %rax, %r14
leaq 0xdb6d(%rip), %rsi      # 0x240c3
movl $0x2, %edx
movq %rax, %rdi
callq 0x2280
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x2280
leaq 0xc973(%rip), %rsi      # 0x22eee
movl $0x1, %edx
movq %rax, %rdi
callq 0x2280
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x2310
leaq 0x20(%rsp), %rdi
callq 0x21a0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x165ad
callq 0x2200
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x165c0
movq %rax, %rbx
jmp 0x165d2
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x21a0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x165e0
callq 0x2200
movq %rbx, %rdi
callq 0x2390
movq %rax, %rdi
callq 0x14eb9
// File: /workspace/github_cpp_makefile_star2_O1/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 0x16ccd
xorl %eax, %eax
movb %al, (%r8)
movb %al, (%rcx)
movb %dil, (%r9)
jmp 0x16d60
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 0x16d26
cmpb %sil, %bpl
jne 0x16d36
subl %edi, %r10d
movl %r10d, %eax
shll $0x8, %eax
subl %r10d, %eax
cltd
idivl %r11d
addl $0x200, %eax            # imm = 0x200
jmp 0x16d48
subl %r10d, %esi
movl %esi, %eax
shll $0x8, %eax
subl %esi, %eax
cltd
idivl %r11d
jmp 0x16d48
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
// File: /workspace/github_cpp_makefile_star2_O1/lvandeve[P]lodepng/pngdetail.cpp
// Function: RGBtoHCT(unsigned char, unsigned char, unsigned char, unsigned char*, unsigned char*, unsigned char*)
void RGBtoHCT(unsigned char r, unsigned char g, unsigned char b, unsigned char* h, unsigned char* c, unsigned char* t) {
  int cmax = std::max<int>(r, std::max<int>(g, b));
  int cmin = std::min<int>(r, std::min<int>(g, b));
  RGBtoHSL(r, g, b, h, c, t);
  *c = cmax - cmin;
  *t = *c == 255 ? 0 : 255 * cmin / (255 + cmin - cmax);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
cmpb %dl, %sil
movl %edx, %r15d
cmoval %esi, %r15d
cmpb %r15b, %dil
cmoval %edi, %r15d
cmpb %sil, %dl
movl %esi, %r12d
cmovbl %edx, %r12d
cmpb %dil, %r12b
cmovael %edi, %r12d
callq 0x16c96
movl %r15d, %eax
subl %r12d, %eax
movb %al, (%r14)
cmpb $-0x1, %al
jne 0x16da9
xorl %eax, %eax
jmp 0x16dc3
movl %r12d, %eax
shll $0x8, %eax
subl %r12d, %eax
negl %r15d
leal (%r12,%r15), %ecx
addl $0xff, %ecx
xorl %edx, %edx
divl %ecx
movb %al, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/lvandeve[P]lodepng/pngdetail.cpp
// Function: HueToLetter(int)
char HueToLetter(int h) {
  char hl = 'R';
  // 12 unique hue letters for 30 degree increment hues.
  if(h < 11 || h >= 244) hl = 'R';  // red
  else if(h >= 11 && h < 32) hl = 'O';  // orange
  else if(h >= 32 && h < 53) hl = 'Y';  // yellow
  else if(h >= 53 && h < 74) hl = 'L';  // lime (officialy "chartreuse" but c is for cyan)
  else if(h >= 74 && h < 96) hl = 'G';  // green
  else if(h >= 96 && h < 117) hl = 'T';  // turquoise (officially "spring green" but that name overlaps green)
  else if(h >= 117 && h < 138) hl = 'C';  // cyan
  else if(h >= 138 && h < 159) hl = 'A';  // azure
  else if(h >= 159 && h < 181) hl = 'B';  // blue
  else if(h >= 181 && h < 202) hl = 'V';  // violet
  else if(h >= 202 && h < 223) hl = 'M';  // magenta
  else if(h >= 223 && h < 244) hl = 'F';  // fuchsia (officially "rose" but r is for red)
  return hl;
}

// Assembly:
leal -0xf4(%rdi), %ecx
movb $0x52, %al
cmpl $0xffffff17, %ecx       # imm = 0xFFFFFF17
jb 0x16e3f
movb $0x4f, %al
cmpl $0x20, %edi
jl 0x16e3f
movb $0x59, %al
cmpl $0x35, %edi
jl 0x16e3f
movb $0x4c, %al
cmpl $0x4a, %edi
jl 0x16e3f
movb $0x47, %al
cmpl $0x60, %edi
jl 0x16e3f
movb $0x54, %al
cmpl $0x75, %edi
jl 0x16e3f
movb $0x43, %al
cmpl $0x8a, %edi
jl 0x16e3f
movb $0x41, %al
cmpl $0x9f, %edi
jl 0x16e3f
movb $0x42, %al
cmpl $0xb5, %edi
jl 0x16e3f
movb $0x56, %al
cmpl $0xca, %edi
jl 0x16e3f
cmpl $0xdf, %edi
movl $0x4d, %ecx
movl $0x46, %eax
cmovll %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/lvandeve[P]lodepng/pngdetail.cpp
// Function: lightnessToLetter(int)
char lightnessToLetter(int l) {
  int c = ' ';
  if(l < 16) c = ' ';
  else if(l < 48) c = '.';
  else if(l < 80) c = ':';
  else if(l < 112) c = '-';
  else if(l < 144) c = '!';
  else if(l < 176) c = '*';
  else if(l < 208) c = '+'; // The + looks denser than the * in a terminal...
  else if(l < 240) c = '=';
  else c = '#';
  return c;
}

// Assembly:
movb $0x20, %al
cmpl $0x10, %edi
jl 0x16e8d
movb $0x2e, %al
cmpl $0x30, %edi
jl 0x16e8d
movb $0x3a, %al
cmpl $0x50, %edi
jl 0x16e8d
movb $0x2d, %al
cmpl $0x70, %edi
jl 0x16e8d
movb $0x21, %al
cmpl $0x90, %edi
jl 0x16e8d
movb $0x2a, %al
cmpl $0xb0, %edi
jl 0x16e8d
movb $0x2b, %al
cmpl $0xd0, %edi
jl 0x16e8d
cmpl $0xf0, %edi
movl $0x3d, %ecx
movl $0x23, %eax
cmovll %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/lvandeve[P]lodepng/pngdetail.cpp
// Function: showError(Data&, Options const&)
void showError(Data& data, const Options& options) {
  std::cout << (options.use_hex ? std::hex: std::dec);
  std::string prefix = (options.use_hex ? "0x": "");
  if(!data.error) {
    std::cout << "No error" << std::endl;
  }
  std::cout << "Decoding error " << prefix << data.error << ": " << lodepng_error_text(data.error) << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x566c(%rip), %rax      # 0x1e2ff
leaq 0x5675(%rip), %rcx      # 0x1e30f
cmpb $0x0, 0x24(%rsi)
cmovneq %rax, %rcx
movq 0x12327(%rip), %rdi     # 0x2afd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq *%rcx
movzbl 0x24(%r14), %eax
leaq 0xad5e(%rip), %rcx      # 0x23a1c
leaq 0xb531(%rip), %rsi      # 0x241f6
testl %eax, %eax
cmovneq %rcx, %rsi
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq (%rsi,%rax,2), %rdx
movq %rsp, %rdi
callq 0x150da
cmpl $0x0, 0x2d8(%rbx)
jne 0x18d2f
movq 0x122e0(%rip), %r14     # 0x2afd0
leaq 0xad28(%rip), %rsi      # 0x23a1f
movl $0x8, %edx
movq %r14, %rdi
callq 0x2280
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq 0x122ae(%rip), %rdi     # 0x2afd0
callq 0x2040
movq %rax, %rdi
callq 0x2160
movq 0x1229a(%rip), %rdi     # 0x2afd0
leaq 0xaceb(%rip), %rsi      # 0x23a28
movl $0xf, %edx
callq 0x2280
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x12279(%rip), %rdi     # 0x2afd0
callq 0x2280
movl 0x2d8(%rbx), %esi
movq %rax, %rdi
callq 0x2150
movq %rax, %r14
leaq 0xb5ba(%rip), %rsi      # 0x2432e
movl $0x2, %edx
movq %rax, %rdi
callq 0x2280
movl 0x2d8(%rbx), %edi
callq 0xce4e
movq %rax, %rbx
testq %rax, %rax
je 0x18dac
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2280
jmp 0x18dc6
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2370
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2160
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x18dfb
callq 0x2200
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x18e16
callq 0x2200
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O1/lvandeve[P]lodepng/pngdetail.cpp
// Function: printableICCWord[abi:cxx11](unsigned char const*, unsigned long, unsigned long)
static std::string printableICCWord(const unsigned char* icc, size_t size, size_t pos) {
  if (pos + 4 > size) {
    return "out of range";
  }
  std::string result;
  for (int i = 0; i < 4; i++) {
    char c = icc[pos + i];
    result += ((c >= 32 && c < 127) ? c : '?');
  }
  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rcx), %rax
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
cmpq %rdx, %rax
jbe 0x1a8d5
leaq 0x9b4f(%rip), %rsi      # 0x24413
leaq 0x9b54(%rip), %rdx      # 0x2441f
movq %rbx, %rdi
callq 0x150da
jmp 0x1a910
movq %rsi, %r14
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
addq %rcx, %r14
xorl %r12d, %r12d
movzbl (%r14,%r12), %eax
leal -0x20(%rax), %ecx
cmpb $0x5f, %cl
jb 0x1a8fc
movl $0x3f, %eax
movsbl %al, %esi
movq %rbx, %rdi
callq 0x21d0
incq %r12
cmpq $0x4, %r12
jne 0x1a8ea
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1a92f
callq 0x2200
movq %r14, %rdi
callq 0x2390