LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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), %r13d
movl 0x8(%rdx), %r12d
leaq 0x6742(%rip), %rsi      # 0xa202
leaq -0x29(%rbp), %rdx
callq 0x2f1e
cmpl $0x1, %r13d
jne 0x3b4c
cmpl $0x4, %r12d
jne 0x3b4c
movq (%r15), %rax
movsbl (%rax), %ecx
pushq $0x1
popq %rax
cmpl $0x30, %ecx
jl 0x3b08
cmpb $0x39, %cl
ja 0x3aef
addl $-0x2f, %ecx
movl %ecx, %eax
jmp 0x3b08
leal -0x41(%rcx), %edx
cmpb $0x19, %dl
ja 0x3b08
leal -0x50(%rcx), %eax
cmpl $-0x10, %eax
ja 0x3b5e
andl $0xf, %ecx
movb $0x1, (%r14)
jmp 0x3aeb
movl %eax, %ecx
shrb $0x3, %cl
movb %cl, 0x7(%r14)
testl %eax, %eax
je 0x3b3c
movl %eax, %ecx
shll $0xc, %ecx
movl %ecx, %edx
shrl $0x10, %edx
xorl %edx, %ecx
shrl $0x8, %ecx
xorb %cl, %dl
setp 0x2(%r14)
leal 0x37(%rax), %ecx
cmpl $0xa, %eax
movzbl %al, %edx
movzbl %cl, %eax
cmovbl %edx, %eax
jmp 0x3b41
movb $0x1, 0x6(%r14)
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, %ecx
jmp 0x3aeb
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/sthapliyal37[P]Microprocessor_8085_Updated/Essential.cpp
// Function: hexToDecimal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int*)
void hexToDecimal(string pc,int arr[]){
 
	int l = pc.length();
	int p = 0;
	for(int i =0 ;i<l;i++){
	
		if(pc[i]>='0' && pc[i]<='9')
			arr[i] = pc[i] - '0';
		else 
			arr[i] = 10 + (pc[i] - 'A'); 
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x8(%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rcx, %rax
je 0x3d37
movq (%rdi), %rdx
movsbl (%rdx,%rcx), %edx
leal -0x30(%rdx), %r8d
leal -0x37(%rdx), %r9d
addl $-0x30, %edx
cmpb $0xa, %r8b
cmovael %r9d, %edx
movl %edx, (%rsi,%rcx,4)
incq %rcx
jmp 0x3d10
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sthapliyal37[P]Microprocessor_8085_Updated/Essential.cpp
// Function: hexSub(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 hexSub(string arg1,string arg2,bool* flag,bool carry){
	
	string resultant = "";
	int variable;
	int parity;
	int value1[2];
	int value2[2];
	int tempAnswer[2];
	hexToDecimal(arg1,value1);
	hexToDecimal(arg2,value2);

	if(value1[1] < value2[1]){
		
		tempAnswer[1] = (16+value1[1])-value2[1];
		--value1[0];
		}
	else{
		tempAnswer[1] = value1[1] - value2[1];
	}

	if(value1[0] < value2[0]){
	
		if(carry == true)
			flag[0] = true;
			
		tempAnswer[0] = (16+value1[0]-value2[0]);
		}
	else
		tempAnswer[0] = value1[0] - value2[0];
		
	 
	variable = tempAnswer[0]*16 + tempAnswer[1];
	bitset<8> dataInBinary(variable);
	parity = dataInBinary.count();
	if(parity%2 == 0 && parity!=0)
		flag[2] = true;
	else
		flag[2] = false;
	flag[7] = dataInBinary[7];
	if(parity == 0)
		flag[6] = true;
	else
		flag[6] = false;
		
	for(int i = 1;i>=0;--i){
		
		if(tempAnswer[i]>=0 && tempAnswer[i]<=9)
			resultant = char('0'+tempAnswer[i]) + resultant;
		else if(tempAnswer[i]>=10 && tempAnswer[i]<=15)
			resultant = (char)('A'+(tempAnswer[i] - 10)) + resultant;
		}
	//cout<<resultant<<endl;	
	return resultant;
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %r8d, %r15d
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x6321(%rip), %rsi      # 0xa202
leaq -0x60(%rbp), %rdx
callq 0x2f1e
leaq -0xa0(%rbp), %rdi
movq %r13, %rsi
callq 0x2280
leaq -0xa0(%rbp), %r13
leaq -0x38(%rbp), %rsi
movq %r13, %rdi
callq 0x3d02
movq %r13, %rdi
callq 0x20f0
leaq -0x80(%rbp), %rdi
movq %r12, %rsi
callq 0x2280
leaq -0x80(%rbp), %r12
leaq -0x40(%rbp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x3d02
movq %r12, %rdi
callq 0x20f0
movl -0x38(%rbp), %eax
movl -0x34(%rbp), %esi
movl (%r13), %edx
movl 0x4(%r13), %edi
leal 0x10(%rsi), %ecx
xorl %r8d, %r8d
cmpl %edi, %esi
setl %r8b
cmovgel %esi, %ecx
subl %r8d, %eax
subl %edi, %ecx
movl %ecx, -0x2c(%rbp)
cmpl %edx, %eax
jge 0x3f70
testb %r15b, %r15b
je 0x3f6d
movb $0x1, (%r14)
addl $0x10, %eax
subl %edx, %eax
movl %eax, -0x30(%rbp)
shll $0x4, %eax
addl %ecx, %eax
movzbl %al, %eax
testb %al, %al
setp %cl
testl %eax, %eax
sete 0x6(%r14)
setne %dl
andb %cl, %dl
movb %dl, 0x2(%r14)
cmpl $0x7f, %eax
seta 0x7(%r14)
pushq $0x1
popq %r15
leaq -0x60(%rbp), %r14
testl %r15d, %r15d
js 0x3ff5
movl %r15d, %eax
movl -0x30(%rbp,%rax,4), %eax
cmpl $0x9, %eax
ja 0x3fc5
orb $0x30, %al
movsbl %al, %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4059
jmp 0x3fdd
leal -0xa(%rax), %ecx
cmpl $0x5, %ecx
ja 0x3ff0
addb $0x37, %al
movsbl %al, %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4059
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2250
movq %r14, %rdi
callq 0x20f0
decl %r15d
jmp 0x3fa2
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x400b
jmp 0x400b
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/sthapliyal37[P]Microprocessor_8085_Updated/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 %r12
pushq %rbx
subq $0x80, %rsp
cmpl $0x2, 0x8(%rdi)
jne 0x5a28
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x80(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2280
movq %r12, %rdi
callq 0x28cb
movl %eax, %r12d
leaq -0x80(%rbp), %rdi
callq 0x20f0
testb %r12b, %r12b
je 0x5a28
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
callq 0x2280
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
callq 0x2280
leaq -0xa0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
pushq $0x1
popq %r8
movq %r14, %rcx
callq 0x3b76
leaq -0xa0(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2250
movq %r14, %rdi
callq 0x20f0
leaq -0x40(%rbp), %rdi
callq 0x20f0
leaq -0x60(%rbp), %rdi
callq 0x20f0
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20f0
jmp 0x5a49
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
jmp 0x5a56
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x80, %rsp
cmpl $0x2, 0x8(%rdi)
jne 0x7169
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x80(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2280
movq %r12, %rdi
callq 0x28cb
movl %eax, %r12d
leaq -0x80(%rbp), %rdi
callq 0x20f0
testb %r12b, %r12b
je 0x7179
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
callq 0x2280
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
callq 0x2280
leaq -0xa0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
pushq $0x1
popq %r8
movq %r14, %rcx
callq 0x3eba
leaq -0xa0(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2250
movq %r14, %rdi
callq 0x20f0
leaq -0x40(%rbp), %rdi
callq 0x20f0
leaq -0x60(%rbp), %rdi
callq 0x20f0
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x6e50(%rip), %rdi      # 0xdfd0
leaq 0x3073(%rip), %rsi      # 0xa1fa
callq 0x21e0
xorl %edi, %edi
callq 0x2240
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20f0
jmp 0x71a4
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
jmp 0x71b1
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
leaq -0xa0(%rbp), %rbx
movq %rbx, %rdi
callq 0x2280
leaq -0x80(%rbp), %rdi
movq %rbx, %rsi
callq 0x394d
leaq -0xa0(%rbp), %rdi
callq 0x20f0
leaq -0x80(%rbp), %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2120
leaq 0x2853(%rip), %rsi      # 0xa1ea
movq %r15, %rdi
callq 0x2f0d
testb %al, %al
je 0x79af
movb $0x1, %al
movb %al, 0x6(%r14)
movb %al, 0x2(%r14)
jmp 0x7a00
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
callq 0x2280
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2280
leaq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3d02
leaq -0x40(%rbp), %rdi
callq 0x20f0
movl -0x1c(%rbp), %eax
shll $0x4, %eax
addl -0x20(%rbp), %eax
testb %al, %al
setp %cl
testb $-0x1, %al
setne %al
andb %cl, %al
movb %al, 0x2(%r14)
leaq -0x60(%rbp), %rdi
callq 0x20f0
leaq -0x80(%rbp), %rdi
callq 0x20f0
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x20f0
jmp 0x7a28
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x20f0
jmp 0x7a3a
jmp 0x7a37
jmp 0x7a37
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/sthapliyal37[P]Microprocessor_8085_Updated/Branch.cpp
// Function: JC(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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, bool*)
string JC(string instruction,string pc,string* registers,bool* flag){
	if(flag[0] == true)
		return instruction;
	else{
		string resultant = "";
		int value16bit[4];
		int returnValue[] = {0,0,0,3};
		int carry = 0;
		hexToDecimal(pc,value16bit);	  
		for(int i = 3;i>=0;i--){
					
			int value = value16bit[i] + returnValue[i] + carry;
			carry = value / 16;
			value = value % 16;
			if(value>=0 && value<=9)
				resultant = (char)('0'+value) + resultant;
			else{
				resultant = (char)('A'+(value-10)) + resultant;
			}
		}
		if(validityAddress(resultant))
			return resultant;
		
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
cmpb $0x1, (%r8)
jne 0x7b10
movq %rbx, %rdi
callq 0x2270
jmp 0x7bee
movq %rdx, %r14
leaq 0x26e8(%rip), %rsi      # 0xa202
leaq -0xa0(%rbp), %rdx
movq %rbx, %rdi
callq 0x2f1e
leaq -0x80(%rbp), %rdi
movq %r14, %rsi
callq 0x2280
leaq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3d02
leaq -0x80(%rbp), %rdi
callq 0x20f0
pushq $0x3
popq %r12
xorl %r15d, %r15d
pushq $0x10
popq %r13
leaq -0xa0(%rbp), %r14
testl %r12d, %r12d
js 0x7bc0
movl %r12d, %eax
addl -0x40(%rbp,%rax,4), %r15d
leaq 0x26cf(%rip), %rcx      # 0xa240
addl (%rcx,%rax,4), %r15d
movl %r15d, %eax
cltd
idivl %r13d
movl %eax, %r15d
cmpl $0x9, %edx
ja 0x7b97
orb $0x30, %dl
movsbl %dl, %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4059
jmp 0x7ba8
addb $0x37, %dl
movsbl %dl, %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4059
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2250
movq %r14, %rdi
callq 0x20f0
decl %r12d
jmp 0x7b5d
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
callq 0x2280
leaq -0x60(%rbp), %rdi
callq 0x2915
movl %eax, %r14d
leaq -0x60(%rbp), %rdi
callq 0x20f0
testb %r14b, %r14b
jne 0x7bee
movq %rbx, %rdi
callq 0x20f0
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x60(%rbp), %rdi
jmp 0x7c10
movq %rax, %r14
leaq -0x80(%rbp), %rdi
callq 0x20f0
jmp 0x7c1e
jmp 0x7c1b
jmp 0x7c1b
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/sthapliyal37[P]Microprocessor_8085_Updated/Branch.cpp
// Function: JNC(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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, bool*)
string JNC(string instruction,string pc,string* registers,bool* flag){

	if(flag[0] == false)
		return instruction;
	else{
		
		string resultant = "";
		int value16bit[4];
		int returnValue[] = {0,0,0,3};
		int carry = 0;
		hexToDecimal(pc,value16bit);	  
		for(int i = 3;i>=0;i--){
					
			int value = value16bit[i] + returnValue[i] + carry;
			carry = value / 16;
			value = value % 16;
			if(value>=0 && value<=9)
				resultant = (char)('0' + value) + resultant;
			else{
				resultant = (char)('A' + (value-10)) + resultant;
			}
		}
		if(validityAddress(resultant))
			return resultant;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
cmpb $0x0, (%r8)
je 0x7d2c
movq %rdx, %r14
leaq 0x25ac(%rip), %rsi      # 0xa202
leaq -0xa0(%rbp), %rdx
movq %rbx, %rdi
callq 0x2f1e
leaq -0x80(%rbp), %rdi
movq %r14, %rsi
callq 0x2280
leaq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3d02
leaq -0x80(%rbp), %rdi
callq 0x20f0
pushq $0x3
popq %r12
xorl %r15d, %r15d
pushq $0x10
popq %r13
leaq -0xa0(%rbp), %r14
testl %r12d, %r12d
js 0x7cfc
movl %r12d, %eax
addl -0x40(%rbp,%rax,4), %r15d
leaq 0x2593(%rip), %rcx      # 0xa240
addl (%rcx,%rax,4), %r15d
movl %r15d, %eax
cltd
idivl %r13d
movl %eax, %r15d
cmpl $0x9, %edx
ja 0x7cd3
orb $0x30, %dl
movsbl %dl, %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4059
jmp 0x7ce4
addb $0x37, %dl
movsbl %dl, %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4059
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2250
movq %r14, %rdi
callq 0x20f0
decl %r12d
jmp 0x7c99
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
callq 0x2280
leaq -0x60(%rbp), %rdi
callq 0x2915
movl %eax, %r14d
leaq -0x60(%rbp), %rdi
callq 0x20f0
testb %r14b, %r14b
jne 0x7d34
movq %rbx, %rdi
callq 0x20f0
jmp 0x7d34
movq %rbx, %rdi
callq 0x2270
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x60(%rbp), %rdi
jmp 0x7d56
movq %rax, %r14
leaq -0x80(%rbp), %rdi
callq 0x20f0
jmp 0x7d64
jmp 0x7d61
jmp 0x7d61
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/sthapliyal37[P]Microprocessor_8085_Updated/Branch.cpp
// Function: JZ(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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, bool*)
string JZ(string instruction, string pc, string* registers,bool* flag){

	if(flag[6] == true)
		return instruction;
	else{
		string resultant = "";
		int value16bit[4];
		int returnValue[] = {0,0,0,3};
		int carry = 0;
		hexToDecimal(pc,value16bit);	  
		for(int i = 3;i>=0;i--){
					
			int value = value16bit[i] + returnValue[i] + carry;
			carry = value / 16;
			value = value % 16;
			if(value>=0 && value<=9)
				resultant = (char)('0' + value) + resultant;
			else{
				resultant = (char)('A'+(value-10)) + resultant;
			}
		}
		if(validityAddress(resultant))
			return resultant;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x6(%r8)
jne 0x7d9c
movq %rbx, %rdi
callq 0x2270
jmp 0x7e7a
movq %rdx, %r14
leaq 0x245c(%rip), %rsi      # 0xa202
leaq -0xa0(%rbp), %rdx
movq %rbx, %rdi
callq 0x2f1e
leaq -0x80(%rbp), %rdi
movq %r14, %rsi
callq 0x2280
leaq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3d02
leaq -0x80(%rbp), %rdi
callq 0x20f0
pushq $0x3
popq %r12
xorl %r15d, %r15d
pushq $0x10
popq %r13
leaq -0xa0(%rbp), %r14
testl %r12d, %r12d
js 0x7e4c
movl %r12d, %eax
addl -0x40(%rbp,%rax,4), %r15d
leaq 0x2443(%rip), %rcx      # 0xa240
addl (%rcx,%rax,4), %r15d
movl %r15d, %eax
cltd
idivl %r13d
movl %eax, %r15d
cmpl $0x9, %edx
ja 0x7e23
orb $0x30, %dl
movsbl %dl, %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4059
jmp 0x7e34
addb $0x37, %dl
movsbl %dl, %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4059
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2250
movq %r14, %rdi
callq 0x20f0
decl %r12d
jmp 0x7de9
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
callq 0x2280
leaq -0x60(%rbp), %rdi
callq 0x2915
movl %eax, %r14d
leaq -0x60(%rbp), %rdi
callq 0x20f0
testb %r14b, %r14b
jne 0x7e7a
movq %rbx, %rdi
callq 0x20f0
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x60(%rbp), %rdi
jmp 0x7e9c
movq %rax, %r14
leaq -0x80(%rbp), %rdi
callq 0x20f0
jmp 0x7eaa
jmp 0x7ea7
jmp 0x7ea7
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/sthapliyal37[P]Microprocessor_8085_Updated/Branch.cpp
// Function: JNZ(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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, bool*)
string JNZ(string instruction, string pc, string* registers,bool* flag){
	if(flag[6] == false){
		//cout<<"inside jnz::"<<" "<<instruction<<endl;	
		return instruction;
		}
		else{
		string resultant = "";
		int value16bit[4];
		int returnValue[] = {0,0,0,3};
		int carry = 0;
		hexToDecimal(pc,value16bit);	  
		for(int i = 3;i>=0;i--){
					
			int value = value16bit[i] + returnValue[i] + carry;
			carry = value / 16;
			value = value % 16;
			if(value>=0 && value<=9)
				resultant = (char)('0' + value) + resultant;
			else{
				resultant = (char)('A'+(value-10)) + resultant;
			}
		}
		if(validityAddress(resultant))
			return resultant;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x6(%r8)
je 0x7fb9
movq %rdx, %r14
leaq 0x231f(%rip), %rsi      # 0xa202
leaq -0xa0(%rbp), %rdx
movq %rbx, %rdi
callq 0x2f1e
leaq -0x80(%rbp), %rdi
movq %r14, %rsi
callq 0x2280
leaq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3d02
leaq -0x80(%rbp), %rdi
callq 0x20f0
pushq $0x3
popq %r12
xorl %r15d, %r15d
pushq $0x10
popq %r13
leaq -0xa0(%rbp), %r14
testl %r12d, %r12d
js 0x7f89
movl %r12d, %eax
addl -0x40(%rbp,%rax,4), %r15d
leaq 0x2306(%rip), %rcx      # 0xa240
addl (%rcx,%rax,4), %r15d
movl %r15d, %eax
cltd
idivl %r13d
movl %eax, %r15d
cmpl $0x9, %edx
ja 0x7f60
orb $0x30, %dl
movsbl %dl, %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4059
jmp 0x7f71
addb $0x37, %dl
movsbl %dl, %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4059
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2250
movq %r14, %rdi
callq 0x20f0
decl %r12d
jmp 0x7f26
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
callq 0x2280
leaq -0x60(%rbp), %rdi
callq 0x2915
movl %eax, %r14d
leaq -0x60(%rbp), %rdi
callq 0x20f0
testb %r14b, %r14b
jne 0x7fc1
movq %rbx, %rdi
callq 0x20f0
jmp 0x7fc1
movq %rbx, %rdi
callq 0x2270
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x60(%rbp), %rdi
jmp 0x7fe3
movq %rax, %r14
leaq -0x80(%rbp), %rdi
callq 0x20f0
jmp 0x7ff1
jmp 0x7fee
jmp 0x7fee
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2310
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x20, %rsp
cmpl $0x4, 0x8(%rdi)
jne 0x88ef
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2280
movq %r12, %rdi
callq 0x2915
movl %eax, %r12d
leaq -0x40(%rbp), %rdi
callq 0x20f0
testb %r12b, %r12b
je 0x88ef
movq %r14, %rdi
movq %r15, %rsi
callq 0x724c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2120
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/sthapliyal37[P]Microprocessor_8085_Updated/DataTransfer.cpp
// Function: SHLD(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 SHLD(string instruction,string* registers,bool* flag,map<string,string>&memory){
	
	int length=instruction.length();
	if(length==4)
	{
		if(validityAddress(instruction)&&validityAddress(increaseAddress(instruction)))
		{
			memory[instruction]=registers[6];
			memory[increaseAddress(instruction)]=registers[5];
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
cmpl $0x4, 0x8(%rdi)
jne 0x8a16
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq -0xa0(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2280
movq %r12, %rdi
callq 0x2915
testb %al, %al
je 0x8a0a
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
callq 0x2280
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x3864
leaq -0x80(%rbp), %rdi
callq 0x2915
movl %eax, %r12d
leaq -0x80(%rbp), %rdi
callq 0x20f0
leaq -0x60(%rbp), %rdi
callq 0x20f0
leaq -0xa0(%rbp), %rdi
callq 0x20f0
testb %r12b, %r12b
je 0x8a16
leaq 0xc0(%rbx), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x724c
movq %rax, %rdi
movq %r12, %rsi
callq 0x2120
leaq -0xc0(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2280
leaq -0x40(%rbp), %rdi
movq %r12, %rsi
callq 0x3864
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x8f10
addq $0xa0, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2120
leaq -0x40(%rbp), %rdi
callq 0x20f0
leaq -0xc0(%rbp), %rdi
jmp 0x8a11
leaq -0xa0(%rbp), %rdi
callq 0x20f0
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x8a37
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20f0
leaq -0xc0(%rbp), %rdi
jmp 0x8a66
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x20f0
jmp 0x8a51
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x20f0
jmp 0x8a5f
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/sthapliyal37[P]Microprocessor_8085_Updated/DataTransfer.cpp
// Function: STAX(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 STAX(string instruction,string* registers,bool* flag,map<string,string>& memory){
int length=instruction.length();
	if(length==1)
	{
		if(validityRegisterPair(instruction))
		{
			string address="";
			int index=registerNumber(instruction);
			address+=registers[index]+registers[index+1];
			if(validityAddress(address))
				memory[address]=registers[0];
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
cmpl $0x1, 0x8(%rdi)
jne 0x8b81
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq -0xc0(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2280
movq %r12, %rdi
callq 0x26da
movl %eax, %r12d
leaq -0xc0(%rbp), %rdi
callq 0x20f0
testb %r12b, %r12b
je 0x8b81
leaq 0x1731(%rip), %rsi      # 0xa202
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x2f1e
leaq -0xa0(%rbp), %rdi
movq %r15, %rsi
callq 0x2280
leaq -0xa0(%rbp), %rdi
callq 0x2740
movl %eax, %r15d
leaq -0xa0(%rbp), %rdi
callq 0x20f0
movslq %r15d, %rax
shlq $0x5, %rax
leaq (%rbx,%rax), %rsi
leaq (%rbx,%rax), %rdx
addq $0x20, %rdx
leaq -0x60(%rbp), %rdi
callq 0x71f4
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2350
leaq -0x60(%rbp), %rdi
callq 0x20f0
leaq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2280
leaq -0x80(%rbp), %rdi
callq 0x2915
movl %eax, %r15d
leaq -0x80(%rbp), %rdi
callq 0x20f0
testb %r15b, %r15b
je 0x8b78
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x724c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2120
leaq -0x40(%rbp), %rdi
callq 0x20f0
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
jmp 0x8baf
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
jmp 0x8baf
jmp 0x8bc7
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x20f0
jmp 0x8bca
movq %rax, %rbx
jmp 0x8bd3
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
jmp 0x8bce
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x60(%rdi), %r15
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x2280
leaq 0xa0(%rbx), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x2120
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0x2120
leaq 0x80(%rbx), %r14
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x2120
addq $0xc0, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2120
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x2120
leaq -0x38(%rbp), %rdi
callq 0x20f0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x20, %rsp
cmpl $0x4, 0x8(%rdi)
jne 0x8cce
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2280
movq %r12, %rdi
callq 0x2915
movl %eax, %r12d
leaq -0x40(%rbp), %rdi
callq 0x20f0
testb %r12b, %r12b
je 0x8cce
movq %r14, %rdi
movq %r15, %rsi
callq 0x724c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2120
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/sthapliyal37[P]Microprocessor_8085_Updated/DataTransfer.cpp
// Function: LHLD(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 LHLD(string instruction,string* registers,bool* flag,map<string,string>& memory){
int length=instruction.length();
	if(length==4)
	{
		if(validityAddress(instruction)&&validityAddress(increaseAddress(instruction)))
		{
			registers[6]=memory[instruction];
			registers[5]=memory[increaseAddress(instruction)];
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
cmpl $0x4, 0x8(%rdi)
jne 0x8df2
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq -0xa0(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2280
movq %r12, %rdi
callq 0x2915
testb %al, %al
je 0x8de6
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
callq 0x2280
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x3864
leaq -0x80(%rbp), %rdi
callq 0x2915
movl %eax, %r12d
leaq -0x80(%rbp), %rdi
callq 0x20f0
leaq -0x60(%rbp), %rdi
callq 0x20f0
leaq -0xa0(%rbp), %rdi
callq 0x20f0
testb %r12b, %r12b
je 0x8df2
movq %r14, %rdi
movq %r15, %rsi
callq 0x724c
leaq 0xc0(%rbx), %rdi
movq %rax, %rsi
callq 0x2120
leaq -0xc0(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2280
leaq -0x40(%rbp), %rdi
movq %r12, %rsi
callq 0x3864
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x8f10
addq $0xa0, %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2120
leaq -0x40(%rbp), %rdi
callq 0x20f0
leaq -0xc0(%rbp), %rdi
jmp 0x8ded
leaq -0xa0(%rbp), %rdi
callq 0x20f0
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x8e13
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20f0
leaq -0xc0(%rbp), %rdi
jmp 0x8e42
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x20f0
jmp 0x8e2d
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x20f0
jmp 0x8e3b
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x40, %rsp
cmpl $0x4, 0x8(%rdi)
jne 0x8ee0
movq %rsi, %rbx
movl 0x8(%rsi), %eax
cmpl $0x2, %eax
jne 0x8ee0
movq %rdx, %r14
movq %rdi, %r15
leaq -0x60(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2280
movq %r12, %rdi
callq 0x2915
testb %al, %al
je 0x8ed7
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
callq 0x2280
leaq -0x40(%rbp), %rdi
callq 0x28cb
movl %eax, %r12d
leaq -0x40(%rbp), %rdi
callq 0x20f0
leaq -0x60(%rbp), %rdi
callq 0x20f0
testb %r12b, %r12b
je 0x8ee0
movq %r14, %rdi
movq %r15, %rsi
callq 0x724c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2120
jmp 0x8ee0
leaq -0x60(%rbp), %rdi
callq 0x20f0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20f0
jmp 0x8efe
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x138b3
xorl %eax, %eax
movb %al, (%r8)
movb %al, (%rcx)
movb %dil, (%r9)
jmp 0x13932
movzbl %bpl, %r11d
movzbl %al, %eax
leal (%rax,%r11), %edx
subl %eax, %r11d
movl %edx, %eax
shrl %eax
movb %al, (%r9)
imull $0xff, %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 0x13908
cmpb %sil, %bpl
jne 0x13917
subl %edi, %r10d
imull $0xff, %r10d, %eax
cltd
idivl %r11d
addl $0x200, %eax            # imm = 0x200
jmp 0x13928
subl %r10d, %esi
imull $0xff, %esi, %eax
cltd
idivl %r11d
jmp 0x13928
subl %esi, %edi
imull $0xff, %edi, %eax
cltd
idivl %r11d
addl $0x400, %eax            # imm = 0x400
movl $0x6, %esi
cltd
idivl %esi
movb %al, (%rcx)
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
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, %ebp
cmovbl %edx, %ebp
cmpb %dil, %bpl
cmovael %edi, %ebp
callq 0x1387f
movl %r15d, %eax
subl %ebp, %eax
movb %al, (%r14)
cmpb $-0x1, %al
jne 0x13976
xorl %eax, %eax
jmp 0x1398a
imull $0xff, %ebp, %eax
subl %r15d, %ebp
addl $0xff, %ebp
xorl %edx, %edx
divw %bp
movb %al, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13a01
movb $0x4f, %al
cmpl $0x20, %edi
jb 0x13a01
movb $0x59, %al
cmpl $0x35, %edi
jb 0x13a01
movb $0x4c, %al
cmpl $0x4a, %edi
jb 0x13a01
movb $0x47, %al
cmpl $0x60, %edi
jb 0x13a01
movb $0x54, %al
cmpl $0x75, %edi
jb 0x13a01
movb $0x43, %al
cmpl $0x8a, %edi
jb 0x13a01
movb $0x41, %al
cmpl $0x9f, %edi
jb 0x13a01
movb $0x42, %al
cmpl $0xb5, %edi
jb 0x13a01
movb $0x56, %al
cmpl $0xca, %edi
jb 0x13a01
cmpl $0xdf, %edi
pushq $0x4d
popq %rcx
pushq $0x46
popq %rax
cmovbl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13a4b
movb $0x2e, %al
cmpl $0x30, %edi
jb 0x13a4b
movb $0x3a, %al
cmpl $0x50, %edi
jb 0x13a4b
movb $0x2d, %al
cmpl $0x70, %edi
jb 0x13a4b
movb $0x21, %al
cmpl $0x90, %edi
jb 0x13a4b
movb $0x2a, %al
cmpl $0xb0, %edi
jb 0x13a4b
movb $0x2b, %al
cmpl $0xd0, %edi
jb 0x13a4b
cmpl $0xf0, %edi
pushq $0x3d
popq %rcx
pushq $0x23
popq %rax
cmovbl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]lodepng/pngdetail.cpp
// Function: applyDither(int, int, int, int, bool)
static inline int applyDither(int v, int range, int x, int y, bool wrap) {
  // ordered dithering pattern; ranges from 0-15, so multiply with 17 to have 0-255
  static const int pattern[16] = {0,8,2,10,
                                  12,4,14,6,
                                  3,11,1,9,
                                  15,7,13,5};
  int d = pattern[(x & 3) + 4 * (y & 3)] * 17 - 128; // range: -128 to 127
  if(wrap) return (v + d * range / 256) & 255;
  else return std::max(0, std::min(255, v + d * range / 256));
}

// Assembly:
andl $0x3, %edx
andl $0x3, %ecx
leal (%rdx,%rcx,4), %eax
leaq 0xa4f5(%rip), %rcx      # 0x1e120
imull $0x11, (%rcx,%rax,4), %eax
addl $-0x80, %eax
imull %esi, %eax
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
addl %edi, %eax
testl %r8d, %r8d
je 0x13c48
movzbl %al, %eax
retq
movl $0xff, %ecx
cmpl %ecx, %eax
cmovll %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovgl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]lodepng/pngdetail.cpp
// Function: displayFilterTypes(Data&, Options const&)
void displayFilterTypes(Data& data, const Options& options) {
  std::cout << (options.use_hex ? std::hex: std::dec);
  data.loadFile();
  if(data.error) return;
  const std::vector<unsigned char>& buffer = data.buffer;
  std::vector<std::vector<unsigned char> > types;
  unsigned error = lodepng::getFilterTypesInterlaced(types, buffer);
  if(error) {
    std::cout << "Error getting filter types" << std::endl;
    return;
  }

  if(types.size() == 7) {
    std::cout << "Filter types (Adam7 interlaced):" << std::endl;
    for(int j = 0; j < 7; j++) {
      std::cout << " Pass " << (j + 1) << ": ";
      for(size_t i = 0; i < types[j].size(); i++) {
        std::cout << (int)(types[j][i]);
      }
      std::cout << std::endl;
    }
  } else {
    std::cout << "Filter types: ";
    for(size_t i = 0; i < types[0].size(); i++) {
      std::cout << (int)(types[0][i]);
    }
    std::cout << std::endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x4a49(%rip), %rax      # 0x190b2
leaq 0x4a52(%rip), %rcx      # 0x190c2
cmpb $0x0, 0x24(%rsi)
cmovneq %rax, %rcx
movq 0x12951(%rip), %rdi     # 0x26fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq *%rcx
movq %rbx, %rdi
callq 0x1908e
cmpl $0x0, 0x2d8(%rbx)
jne 0x146dd
addq $0x20, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rbx, %rsi
callq 0xf07a
testl %eax, %eax
je 0x146ec
movq 0x12912(%rip), %rdi     # 0x26fd0
leaq 0xa214(%rip), %rsi      # 0x1e8d9
callq 0x2210
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2100
movq %rsp, %rdi
callq 0x12308
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rax
subq (%rsp), %rax
cmpq $0xa8, %rax
jne 0x14798
movq 0x128c8(%rip), %rdi     # 0x26fd0
leaq 0xa1e5(%rip), %rsi      # 0x1e8f4
callq 0x2210
movq %rax, %rdi
callq 0x2100
xorl %r13d, %r13d
movq 0x128aa(%rip), %rbx     # 0x26fd0
leaq 0xa1e8(%rip), %r14      # 0x1e915
leaq 0xac28(%rip), %r15      # 0x1f35c
cmpq $0x7, %r13
je 0x146d5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2210
leaq 0x1(%r13), %r12
movq %rax, %rdi
movl %r12d, %esi
callq 0x2390
movq %rax, %rdi
movq %r15, %rsi
callq 0x2210
imulq $0x18, %r13, %r13
xorl %ebp, %ebp
movq (%rsp), %rcx
movq (%rcx,%r13), %rax
movq 0x8(%rcx,%r13), %rcx
subq %rax, %rcx
cmpq %rcx, %rbp
jae 0x1478b
movzbl (%rax,%rbp), %esi
movq %rbx, %rdi
callq 0x2390
incq %rbp
jmp 0x14765
movq %rbx, %rdi
callq 0x2100
movq %r12, %r13
jmp 0x14734
movq 0x12831(%rip), %rbx     # 0x26fd0
leaq 0xa176(%rip), %rsi      # 0x1e91c
movq %rbx, %rdi
callq 0x2210
xorl %r14d, %r14d
movq (%rsp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
cmpq %rcx, %r14
jae 0x146cd
movzbl (%rax,%r14), %esi
movq %rbx, %rdi
callq 0x2390
incq %r14
jmp 0x147b1
jmp 0x147e0
jmp 0x147e0
jmp 0x147e0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x12308
movq %rbx, %rdi
callq 0x23a0
movq %rax, %rdi
callq 0xe69c
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]lodepng/pngdetail.cpp
// Function: displayPalette(Data&, Options const&)
void displayPalette(Data& data, const Options& options) {
  data.loadInspect();
  if(data.error) return;
  std::cout << (options.use_hex ? std::hex: std::dec);

  const LodePNGInfo& info = data.state.info_png;
  const LodePNGColorMode& color = info.color;

  std::cout << "Palette size: " << color.palettesize << std::endl;
  std::cout << "Palette colors: ";
  std::ios_base::fmtflags flags = std::cout.flags();
  std::cout << std::hex << std::setfill('0');
  for(size_t i = 0; i < color.palettesize; i++) {
    unsigned char* p = &color.palette[i * 4];
    std::cout << "#" << std::setw(2) << (int)p[0] << std::setw(2) << (int)p[1] << std::setw(2) << (int)p[2] << std::setw(2) << (int)p[3] << " ";
  }
  std::cout.flags(flags);
  std::cout << std::endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x18e38
cmpl $0x0, 0x2d8(%rbx)
je 0x14829
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4882(%rip), %rax      # 0x190b2
leaq 0x488b(%rip), %rcx      # 0x190c2
cmpb $0x0, 0x24(%r14)
cmovneq %rax, %rcx
movq 0x12789(%rip), %r14     # 0x26fd0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
callq *%rcx
leaq 0xa0d1(%rip), %rsi      # 0x1e92b
movq %r14, %rdi
callq 0x2210
movq 0x148(%rbx), %rsi
movq %rax, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x2100
leaq 0xa0ba(%rip), %rsi      # 0x1e93a
movq %r14, %rdi
callq 0x2210
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x18(%r14,%rax), %ecx
movl %ecx, 0x4(%rsp)
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r14,%rax)
pushq $0x30
popq %rsi
movq %r14, %rdi
callq 0x2310
xorl %r13d, %r13d
leaq 0xa01f(%rip), %r15      # 0x1e8d7
pushq $0x2
popq %rbp
leaq 0xa88e(%rip), %r12      # 0x1f150
cmpq 0x148(%rbx), %r13
jae 0x1495f
movq 0x140(%rbx), %r14
movq 0x126f3(%rip), %rdi     # 0x26fd0
movq %r15, %rsi
callq 0x2210
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %rbp, 0x10(%rax,%rcx)
movzbl (%r14,%r13,4), %esi
movq %rax, %rdi
callq 0x2390
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %rbp, 0x10(%rax,%rcx)
movzbl 0x1(%r14,%r13,4), %esi
movq %rax, %rdi
callq 0x2390
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %rbp, 0x10(%rax,%rcx)
movzbl 0x2(%r14,%r13,4), %esi
movq %rax, %rdi
callq 0x2390
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %rbp, 0x10(%rax,%rcx)
movzbl 0x3(%r14,%r13,4), %esi
movq %rax, %rdi
callq 0x2390
movq %rax, %rdi
movq %r12, %rsi
callq 0x2210
incq %r13
jmp 0x148c2
movq 0x1266a(%rip), %rdi     # 0x26fd0
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x4(%rsp), %ecx
movl %ecx, 0x18(%rdi,%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100