LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: TranslationUnit::print_py(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
inline void TranslationUnit::print_py(std::string file_name) const {
			
				
				std::ofstream file;
				file.open(file_name.c_str());
				if(TranslationUnitPtr != NULL){
					TranslationUnitPtr->print_py(file);
				}
				if( ExternalDecl != NULL){
					ExternalDecl->print_py(file);
				}

			if(main_){
				file << std::endl << std::endl << "if __name__ == " << "\"__main__\"" << ":"; 
   				file <<  std::endl << "\t\timport sys";
    				file <<  std::endl << "\t\tret=main()";
    				file << std::endl << "\t\tsys.exit(ret)";

			}

				file.close();
				

			}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x75a0
movq (%r15), %rsi
movq %rbx, %rdi
movl $0x10, %edx
callq 0x7070
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xbac0
movq %rsp, %rsi
callq 0xbc86
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xbad1
movq %rsp, %rsi
callq 0xbcc2
cmpb $0x1, 0x62a28(%rip)     # 0x6e500
jne 0xbc2c
movq (%rsp), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %r14, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
movq %rax, %r14
leaq 0x2b873(%rip), %rsi     # 0x373b0
movl $0xf, %edx
movq %rax, %rdi
callq 0x73a0
leaq 0x2b86f(%rip), %rsi     # 0x373c0
movl $0xa, %edx
movq %r14, %rdi
callq 0x73a0
leaq 0x2b8b1(%rip), %rsi     # 0x37416
movl $0x1, %edx
movq %r14, %rdi
callq 0x73a0
movq (%rsp), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
leaq 0x2b827(%rip), %rsi     # 0x373cb
movl $0xc, %edx
movq %rax, %rdi
callq 0x73a0
movq (%rsp), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
leaq 0x2b7f5(%rip), %rsi     # 0x373d8
movl $0xc, %edx
movq %rax, %rdi
callq 0x73a0
movq (%rsp), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rsp, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
leaq 0x2b7c6(%rip), %rsi     # 0x373e5
movl $0xf, %edx
movq %rax, %rdi
callq 0x73a0
movq %rsp, %rdi
callq 0x7490
movq 0x3a34d(%rip), %rax     # 0x45f88
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x8(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, (%rsp,%rcx)
callq 0x72a0
leaq 0xf8(%rsp), %rdi
callq 0x7100
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x74e0
movq %rbx, %rdi
callq 0x75f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: TranslationUnit::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void TranslationUnit::print_py(std::ofstream& file)  {

				if(TranslationUnitPtr != NULL){
					TranslationUnitPtr->print_py(file);
				}
				if( ExternalDecl != NULL){
					ExternalDecl->print_py(file);
				}

				

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xbca1
movq %rbx, %rsi
callq 0xbc86
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xbcb9
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbcc2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: ExternalDeclaration::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void ExternalDeclaration::print_py(std::ofstream& file) {
		
			if( ExternalDeclarationPtr != NULL ) {
				ExternalDeclarationPtr->print_py(file);

			}

			if ( DecLaration  == NULL && FunctionDef != NULL){
				function = true;
				file << std::endl;
				FunctionDef->print_py(file);
				file << std::endl;
				function = false;
			}

			if ( FunctionDef  == NULL && DecLaration != NULL){
				file << std::endl;
				DecLaration->print_py(file);
				file << std::endl;
			}

				
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xbcdd
movq %rbx, %rsi
callq 0xbcc2
cmpq $0x0, 0x10(%r14)
jne 0xbd53
cmpq $0x0, 0x8(%r14)
je 0xbd53
movb $0x1, 0x6282e(%rip)     # 0x6e520
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xc118
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
movb $0x0, 0x627cd(%rip)     # 0x6e520
cmpq $0x0, 0x8(%r14)
jne 0xbdcb
cmpq $0x0, 0x10(%r14)
je 0xbdcb
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
movq 0x10(%r14), %rax
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0xbd9d
movq %rbx, %rsi
callq 0xdc22
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7220
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: FunctionDefinition::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void FunctionDefinition::print_py(std::ofstream& file) {
		
			if( DeclarationSpecifiersPtr != NULL ) {
										//do-nothing because it is not significant in our case (only int/void)
			}

			if( DeclaratorPtr != NULL ) {				//handles global variables after printing function name
				
				DeclaratorPtr->print_py(file,false,true);
				if(DeclarationListPtr == NULL) {
					file << "):" << std::endl;					

					for( int i= 0; i < GlobalVars.size(); i++) {
						file << "\tglobal " << GlobalVars[i] << std::endl;
					}					
				}
			}

			if( DeclarationListPtr != NULL ) {   			//( functions having parameters )
				ParametrizedFunction = true;
				DeclarationListPtr->print_py(file);
			}

			if( CompoundStatementPtr != NULL ) {
			
				CompoundStatementPtr->print_py(file,false,true);
			}
			
				
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xc21a
movq %rbx, %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xc260
cmpq $0x0, 0x18(%r14)
jne 0xc21a
leaq 0x2b2be(%rip), %rsi     # 0x37415
movl $0x2, %edx
movq %rbx, %rdi
callq 0x73a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
movq 0x4e4be(%rip), %rax     # 0x5a650
cmpq 0x4e4af(%rip), %rax     # 0x5a648
je 0xc21a
movl $0x8, %r13d
xorl %ebp, %ebp
leaq 0x2b26e(%rip), %r15     # 0x37418
movl $0x8, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73a0
movq 0x4e487(%rip), %rax     # 0x5a648
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
movq %rbx, %rdi
callq 0x73a0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %r12, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
movq 0x4e44d(%rip), %rax     # 0x5a650
subq 0x4e43e(%rip), %rax     # 0x5a648
incq %rbp
sarq $0x5, %rax
addq $0x20, %r13
cmpq %rbp, %rax
ja 0xc1aa
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xc22b
movq %rbx, %rsi
callq 0xc2b6
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0xc251
movq %rbx, %rsi
xorl %edx, %edx
movl $0x1, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc302
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: Declarator::print_py(std::basic_ofstream<char, std::char_traits<char>>&, bool, bool)
inline void Declarator::print_py(std::ofstream& file, bool initialized, bool function) {

			if( DeclaratorPtr != NULL) {
				DeclaratorPtr->print_py(file,initialized,function);
			}
			if(DirectDecLarator != NULL){
				DirectDecLarator->print_py(file,initialized,function);
			}
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rdi), %rdi
movzbl %dl, %ebp
movzbl %cl, %r14d
testq %rdi, %rdi
je 0xc28a
movq %rbx, %rsi
movl %ebp, %edx
movl %r14d, %ecx
callq 0xc260
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0xc2aa
movq %rbx, %rsi
movl %ebp, %edx
movl %r14d, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc3ec
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: DeclarationList::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void DeclarationList::print_py(std::ofstream& file) {

				if( DeclarationListPtr != NULL) {
					
					DeclarationListPtr->print_py(file);

				}
				function = false;
				if(DeclarationPtr != NULL){
					DeclarationPtr->print_py(file);
				}

			}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xc2d1
movq %rbx, %rsi
callq 0xc2b6
movb $0x0, 0x62248(%rip)     # 0x6e520
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xc2f9
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0xc2f9
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xdc22
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: CompoundStatement::print_py(std::basic_ofstream<char, std::char_traits<char>>&, bool, bool)
inline void CompoundStatement::print_py(std::ofstream& file, bool initialized, bool function) {
			
			counter_py++;
	
			
			if( StatementListPtr == NULL && DeclarationListPtr == NULL ) {
				for( int i(0); i<counter_py; i++) { file << "\t"; }
				file << "pass" << std::endl;
			}
			else if( StatementListPtr == NULL && DeclarationListPtr != NULL ) {
				DeclarationListPtr->print_py(file);
			}
			else if( StatementListPtr != NULL && DeclarationListPtr == NULL ) {
				StatementListPtr->print_py(file);
			}
			else if( StatementListPtr != NULL && DeclarationListPtr != NULL ) {
				DeclarationListPtr->print_py(file);
				StatementListPtr->print_py(file);
				
			}

			counter_py--;
			
		
			
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
incl 0x62212(%rip)           # 0x6e524
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdi
movq %rax, %rcx
orq %rdi, %rcx
jne 0xc38b
cmpl $0x0, 0x621fb(%rip)     # 0x6e524
jle 0xc34e
xorl %ebp, %ebp
leaq 0x2b3c8(%rip), %r14     # 0x376fc
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73a0
incl %ebp
cmpl 0x621d8(%rip), %ebp     # 0x6e524
jl 0xc334
leaq 0x2b0f3(%rip), %rsi     # 0x37448
movl $0x4, %edx
movq %rbx, %rdi
callq 0x73a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
jmp 0xc3e1
testq %rdi, %rdi
sete %cl
testq %rax, %rax
setne %dl
orb %cl, %dl
je 0xc3b3
testq %rdi, %rdi
sete %cl
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xc3bd
movq %rax, %rdi
jmp 0xc3d9
movq %rbx, %rsi
callq 0xc2b6
jmp 0xc3e1
testq %rdi, %rdi
sete %cl
testq %rax, %rax
sete %al
orb %cl, %al
jne 0xc3e1
movq %rbx, %rsi
callq 0xc2b6
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xc926
decl 0x6213d(%rip)           # 0x6e524
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: IdentifierList::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void IdentifierList::print_py(std::ofstream& file) {

			if( IdentifierListPtr != NULL) {
				IdentifierListPtr->print_py(file);
				file << ",";
			}
			if(IDENTIFIER != NULL){
				file << *IDENTIFIER;
			}				
		
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xc65d
movq %rbx, %rsi
callq 0xc62e
leaq 0x2b02e(%rip), %rsi     # 0x3767e
movl $0x1, %edx
movq %rbx, %rdi
callq 0x73a0
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xc67c
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x73a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: ParameterList::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void ParameterList::print_py(std::ofstream& file) {

			if( ParameterListPtr != NULL) {
				ParameterListPtr->print_py(file);
				file << ",";
			}
			if(ParameterDeclarationPtr != NULL){
				ParameterDeclarationPtr->print_py(file);
			}						
			
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xc8f1
movq %rbx, %rsi
callq 0xc8c2
leaq 0x2ad9a(%rip), %rsi     # 0x3767e
movl $0x1, %edx
movq %rbx, %rdi
callq 0x73a0
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xc91d
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0xc91d
movb $0x1, 0x61c1e(%rip)     # 0x6e528
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc260
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: StatementList::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void StatementList::print_py(std::ofstream& file) {

			if( StatementListPtr != NULL) {
				StatementListPtr->print_py(file);

			}
			if(StatementPtr != NULL){
				StatementPtr->print_py(file);
			}

				

		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xc941
movq %rbx, %rsi
callq 0xc926
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xc970
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0xc969
movq %rbx, %rsi
xorl %edx, %edx
movl $0x1, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc302
cmpq $0x0, 0x8(%rax)
je 0xc978
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0xc9c0
movq 0x8(%rcx), %rdi
testq %rdi, %rdi
je 0xc992
movq %rbx, %rsi
callq 0xd254
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7220
movq 0x30(%rax), %rdi
testq %rdi, %rdi
je 0xc9da
movq %rbx, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xcab8
movq 0x20(%rax), %rdi
testq %rdi, %rdi
je 0xc9f2
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd032
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0xc970
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd1c8
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: Statement::print_py(std::basic_ofstream<char, std::char_traits<char>>&, bool)
inline void Statement::print_py(std::ofstream& file, bool elseif) {

			if( CompoundStatementPtr != NULL ) { 
				
				CompoundStatementPtr->print_py(file);
				

			}

			
			else if( LabeledStatementPtr != NULL ) { 
			
				LabeledStatementPtr->print_py(file);
			}

			else if( ExpressionStatementPtr != NULL ) { 
					
				ExpressionStatementPtr->print_py(file);
				
			}

			else if( SelectionStatementPtr != NULL ) {
					
				SelectionStatementPtr->print_py(file,elseif);
					

			}

			else if( IterationStatementPtr != NULL ) {
					
				IterationStatementPtr->print_py(file);
					

			}

			else if( JumpStatementPtr != NULL ) {
				
				JumpStatementPtr->print_py(file);
					

			}		

			
	}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xca2e
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movl $0x1, %ecx
popq %rbx
jmp 0xc302
cmpq $0x0, 0x8(%rdi)
je 0xca37
popq %rbx
retq
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0xca79
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0xca51
movq %rbx, %rsi
callq 0xd254
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
popq %rbx
jmp 0x7220
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0xca91
movzbl %dl, %edx
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0xcab8
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0xcaa6
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0xd032
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0xca35
movq %rbx, %rsi
popq %rbx
jmp 0xd1c8
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: IterationStatement::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void IterationStatement::print_py(std::ofstream& file) {

			if( *ITERATIVE_TYPE == "while" && AssignmentExpressionPtr != NULL && StatementPtr != NULL) {
				file << std::endl;
				is_while = true;				// This is to not print an endline in function assignmentExpression
				for( int i(0); i<counter_py; i++) { file << "\t"; }
				file << "while(";
				AssignmentExpressionPtr->print_py(file);
				file << "):" << std::endl;
				
				Indent_Generator(StatementPtr,file);
					
				is_while = false;			
			}			
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rdi
leaq 0x2a41c(%rip), %rsi     # 0x37466
callq 0x70c0
testl %eax, %eax
je 0xd05e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x8(%r14)
je 0xd053
cmpq $0x0, 0x10(%r14)
je 0xd053
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
movb $0x1, 0x6148f(%rip)     # 0x6e529
cmpl $0x0, 0x61483(%rip)     # 0x6e524
jle 0xd0c6
xorl %ebp, %ebp
leaq 0x2a650(%rip), %r15     # 0x376fc
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73a0
incl %ebp
cmpl 0x61460(%rip), %ebp     # 0x6e524
jl 0xd0ac
leaq 0x2a39f(%rip), %rsi     # 0x3746c
movl $0x6, %edx
movq %rbx, %rdi
callq 0x73a0
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xd254
leaq 0x2a328(%rip), %rsi     # 0x37415
movl $0x2, %edx
movq %rbx, %rdi
callq 0x73a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0xd165
leaq 0x2a317(%rip), %rsi     # 0x37448
movl $0x4, %edx
movq %rbx, %rdi
callq 0x73a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
cmpq $0x0, 0x10(%r14)
je 0xd17b
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xca0e
jmp 0xd194
incl 0x613a3(%rip)           # 0x6e524
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xca0e
decl 0x61390(%rip)           # 0x6e524
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
movb $0x0, 0x61367(%rip)     # 0x6e529
jmp 0xd053
nop
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: JumpStatement::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void JumpStatement::print_py(std::ofstream& file) {
			
			for( int i(0); i<counter_py; i++) { file << "\t"; }
			if(JUMP_TYPE != NULL){
				file << *JUMP_TYPE << " ";
			}
			if(AssignmentExpressionPtr != NULL) {
				AssignmentExpressionPtr->print_py(file);
			}

		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x61348(%rip)     # 0x6e524
jle 0xd201
xorl %ebp, %ebp
leaq 0x2a515(%rip), %r15     # 0x376fc
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73a0
incl %ebp
cmpl 0x61325(%rip), %ebp     # 0x6e524
jl 0xd1e7
movq 0x18(%r14), %rax
testq %rax, %rax
je 0xd22d
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x73a0
leaq 0x2a9de(%rip), %rsi     # 0x37bfe
movl $0x1, %edx
movq %rax, %rdi
callq 0x73a0
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xd248
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd254
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: AssignmentExpression::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void AssignmentExpression::print_py(std::ofstream& file)  {

			
			if(UnaryExpressionPtr != NULL) {
		
				for( int i(0); i<counter_py; i++) { file << "\t"; }
				UnaryExpressionPtr->print_py(file);
				file << "=";

			}
	
			if(ConditionalExpressionPtr != NULL) {

				ConditionalExpressionPtr->print_py(file);

			}

			if(AssignmentExpressionPtr != NULL) {

				AssignmentExpressionPtr->print_py(file);
			}


			
			if(!function && !is_while && !is_Selective && (parentheses==0) ){		//In the case we are inside a condition for one of the precedings then dont endline
				file << std::endl;
				
			}
			

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
je 0xd2ca
cmpl $0x0, 0x6129f(%rip)     # 0x6e524
jle 0xd2aa
xorl %ebp, %ebp
leaq 0x2a46c(%rip), %r15     # 0x376fc
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73a0
incl %ebp
cmpl 0x6127c(%rip), %ebp     # 0x6e524
jl 0xd290
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xd35c
leaq 0x2a496(%rip), %rsi     # 0x37753
movl $0x1, %edx
movq %rbx, %rdi
callq 0x73a0
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xd2eb
cmpq $0x0, 0x10(%rax)
jne 0xd2eb
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0xd2eb
movq %rbx, %rsi
callq 0xd768
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0xd2fc
movq %rbx, %rsi
callq 0xd26a
cmpb $0x0, 0x6121d(%rip)     # 0x6e520
jne 0xd30e
cmpb $0x0, 0x6121d(%rip)     # 0x6e529
je 0xd319
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x0, 0x6120a(%rip)     # 0x6e52a
jne 0xd30e
cmpl $0x0, 0x61203(%rip)     # 0x6e52c
jne 0xd30e
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7220
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: UnaryExpression::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void UnaryExpression::print_py(std::ofstream& file) {
			if(PostFixExpressionPtr != NULL) {
				PostFixExpressionPtr->print_py(file);
			}
			else if ( CastExpressionPtr != NULL) {
				if(OPERATOR != NULL) {
					file << " " << *OPERATOR << " ";
				}

				else if(UnaryOperatorPtr != NULL){
					file << " " << *(UnaryOperatorPtr->print_py()) << " ";
				}
				CastExpressionPtr->print_py(file);
			}

			

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x2a88d(%rip), %r14     # 0x37bfe
movq 0x8(%r15), %rdi
testq %rdi, %rdi
jne 0xd3f9
cmpq $0x0, 0x18(%r15)
je 0xd3ed
cmpq $0x0, 0x10(%r15)
je 0xd39e
leaq 0x10(%r15), %r12
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73a0
jmp 0xd3bd
cmpq $0x0, 0x28(%r15)
je 0xd3e0
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73a0
movq 0x28(%r15), %r12
addq $0x8, %r12
movq (%r12), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x73a0
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x73a0
movq 0x18(%r15), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
jne 0xd371
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd40c
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: PrimaryExpression::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void PrimaryExpression::print_py(std::ofstream& file) {

			if( AssignmentExpressionPtr != NULL ) {
				file << "(";
				parentheses++;
				AssignmentExpressionPtr->print_py(file);
				file << ")";
				parentheses--;
			}

			if(IDENTIFIER != NULL) {
		
				file << *IDENTIFIER;

			}
			else if( CONSTANT != NULL ) {
				file << *CONSTANT; 

			}
		
			else if( STRING_LITERAL != NULL) {
	
				file << " " << '"' << *STRING_LITERAL << '"' << " ";
			}
		
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x20(%rdi)
je 0xd66e
leaq 0x29e3c(%rip), %rsi     # 0x37471
movl $0x1, %edx
movq %rbx, %rdi
callq 0x73a0
incl 0x60ee4(%rip)           # 0x6e52c
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0xd254
leaq 0x2afb4(%rip), %rsi     # 0x3860f
movl $0x1, %edx
movq %rbx, %rdi
callq 0x73a0
decl 0x60ebe(%rip)           # 0x6e52c
movq 0x8(%r14), %rax
testq %rax, %rax
jne 0xd680
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xd699
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x73a0
cmpq $0x0, 0x18(%r14)
je 0xd707
leaq 0x2a557(%rip), %r15     # 0x37bfe
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73a0
movb $0x22, %bpl
leaq 0x6(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x73a0
movq 0x18(%r14), %rcx
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
movq %rax, %rdi
callq 0x73a0
leaq 0x7(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x73a0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x73a0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: ArgumentExpressionList::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void ArgumentExpressionList::print_py(std::ofstream& file) {

		function = true;
		if( ArgumentExpressionListPtr != NULL) {
			ArgumentExpressionListPtr->print_py(file);
			file << ",";
		}
		if(AssignmentExpressionPtr != NULL){
			AssignmentExpressionPtr->print_py(file);
		}
		

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb $0x1, 0x60dfd(%rip)     # 0x6e520
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xd748
movq %rbx, %rsi
callq 0xd712
leaq 0x29f43(%rip), %rsi     # 0x3767e
movl $0x1, %edx
movq %rbx, %rdi
callq 0x73a0
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xd760
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd26a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: LogicalOrExpression::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void LogicalOrExpression::print_py(std::ofstream& file) {
			if(OR_OP==NULL && LogicalAndExpressionPtr != NULL){
				LogicalAndExpressionPtr->print_py(file);
			}
			else{ 
				if(LogicalOrExpressionPtr != NULL){
					LogicalOrExpressionPtr->print_py(file);
				}
				if(OR_OP != NULL){
					file << " or ";
				}
				if(LogicalAndExpressionPtr != NULL){
					LogicalAndExpressionPtr->print_py(file);
				}
				
			}
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
setne %al
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xd7c0
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xd79c
movq %rbx, %rsi
callq 0xd768
cmpq $0x0, 0x10(%r14)
je 0xd7b7
leaq 0x29ca3(%rip), %rsi     # 0x3744d
movl $0x4, %edx
movq %rbx, %rdi
callq 0x73a0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xd7cf
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd7d8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: LogicalAndExpression::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void LogicalAndExpression::print_py(std::ofstream& file) {
			if(AND_OP==NULL && INclusiveOrExpression != NULL){
				INclusiveOrExpression->print_py(file);
			}
			else{ 
				if(LogicalAndExpressionPtr != NULL){
					LogicalAndExpressionPtr->print_py(file);
				}
				if(AND_OP != NULL){
					file << " and ";
				}
				if(INclusiveOrExpression != NULL){
					INclusiveOrExpression->print_py(file);
				}
				
			}

		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x18(%rdi)
setne %al
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xd830
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xd80c
movq %rbx, %rsi
callq 0xd7d8
cmpq $0x0, 0x18(%r14)
je 0xd827
leaq 0x29c38(%rip), %rsi     # 0x37452
movl $0x5, %edx
movq %rbx, %rdi
callq 0x73a0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xd83f
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd848
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: InclusiveOrExpression::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void InclusiveOrExpression::print_py(std::ofstream& file) {

			if(INC_OR==NULL && EXclusiveOrExpression != NULL){
				EXclusiveOrExpression->print_py(file);
			}
			else{ 
				if(InclusiveOrExpressionPtr != NULL){
					InclusiveOrExpressionPtr->print_py(file);
				}
				if(INC_OR != NULL){
					file << " " << "|" << " ";
				}
				if(EXclusiveOrExpression != NULL){
					EXclusiveOrExpression->print_py(file);
				}
				
			}

		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
setne %al
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xd8c8
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xd87d
movq %rbx, %rsi
callq 0xd848
cmpq $0x0, 0x10(%r14)
je 0xd8bf
leaq 0x2a373(%rip), %r15     # 0x37bfe
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73a0
leaq 0x2a516(%rip), %rsi     # 0x37db8
movl $0x1, %edx
movq %rbx, %rdi
callq 0x73a0
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73a0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xd8d5
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xd8dc
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: ExclusiveOrExpression::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void ExclusiveOrExpression::print_py(std::ofstream& file) {

			if(EXCL_OR==NULL && ANDexpression != NULL){
				ANDexpression->print_py(file);
			}
			else{ 
				if(ExclusiveOrExpressionPtr != NULL){
					ExclusiveOrExpressionPtr->print_py(file);
				}
				if(EXCL_OR != NULL){
					file << " " << "^" << " ";
				}
				if(ANDexpression != NULL){
					ANDexpression->print_py(file);
				}
				
			}

		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
setne %al
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xd95c
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xd911
movq %rbx, %rsi
callq 0xd8dc
cmpq $0x0, 0x10(%r14)
je 0xd953
leaq 0x2a2df(%rip), %r15     # 0x37bfe
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73a0
leaq 0x29b22(%rip), %rsi     # 0x37458
movl $0x1, %edx
movq %rbx, %rdi
callq 0x73a0
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73a0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xd969
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xd970
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: AndExpression::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void AndExpression::print_py(std::ofstream& file) {

			if(BIT_AND==NULL && EqualitYExpression != NULL){
				EqualitYExpression->print_py(file);
			}
			else{ 
				if(AndExpressionPtr != NULL){
					AndExpressionPtr->print_py(file);
				}
				if(BIT_AND != NULL){
					file << " " << "&" << " ";
				}
				if(EqualitYExpression != NULL){
					EqualitYExpression->print_py(file);
				}
				
			}

		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
setne %al
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xd9f0
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xd9a5
movq %rbx, %rsi
callq 0xd970
cmpq $0x0, 0x10(%r14)
je 0xd9e7
leaq 0x2a24b(%rip), %r15     # 0x37bfe
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73a0
leaq 0x29a2b(%rip), %rsi     # 0x373f5
movl $0x1, %edx
movq %rbx, %rdi
callq 0x73a0
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73a0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xd9fd
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xda04
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: EqualityExpression::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void EqualityExpression::print_py(std::ofstream& file) {

			if(OPERATOR==NULL && RElationalExpression != NULL){
				RElationalExpression->print_py(file);
			}
			else{ 
				if(EqualityExpressionPtr != NULL){
					EqualityExpressionPtr->print_py(file);
				}
				if(OPERATOR != NULL){
					file <<*OPERATOR;
				}
				if(RElationalExpression != NULL){
					RElationalExpression->print_py(file);
				}
				
			}

		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
setne %al
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xda59
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xda38
movq %rbx, %rsi
callq 0xda04
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xda50
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x73a0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xda68
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xda70
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: RelationalExpression::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void RelationalExpression::print_py(std::ofstream& file) {

			if(OPERATOR==NULL && SHiftExpression != NULL){
				SHiftExpression->print_py(file);
			}
			else{ 
				if(RelationalExpressionPtr != NULL){
					RelationalExpressionPtr->print_py(file);
				}
				if(OPERATOR != NULL){
					file << *OPERATOR;
				}
				if(SHiftExpression != NULL){
					SHiftExpression->print_py(file);
				}
				
			}


		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
setne %al
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xdac5
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xdaa4
movq %rbx, %rsi
callq 0xda70
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xdabc
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x73a0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xdad4
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xdadc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: ShiftExpression::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void ShiftExpression::print_py(std::ofstream& file) {

			if(OPERATOR==NULL && AdditiVeExpression != NULL){
				AdditiVeExpression->print_py(file);
			}
			else{ 
				if(ShiftExpressionPtr != NULL){
					ShiftExpressionPtr->print_py(file);
				}
				if(OPERATOR != NULL){
					file << *OPERATOR;
				}
				if(AdditiVeExpression != NULL){
					AdditiVeExpression->print_py(file);
				}
				
			}

		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
setne %al
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xdb31
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xdb10
movq %rbx, %rsi
callq 0xdadc
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xdb28
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x73a0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xdb40
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xdb48
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: AdditiveExpression::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void AdditiveExpression::print_py(std::ofstream& file) {

			if(OPERATOR==NULL && MultiplicativeExpressioN != NULL){
				MultiplicativeExpressioN->print_py(file);
			}
			else{ 
				if(AdditiveExpressionPtr != NULL){
					AdditiveExpressionPtr->print_py(file);
				}
				if(OPERATOR != NULL){
					file << *OPERATOR;
				}
				if(MultiplicativeExpressioN != NULL){
					MultiplicativeExpressioN->print_py(file);
				}
				
			}

		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
setne %al
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xdb9d
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xdb7c
movq %rbx, %rsi
callq 0xdb48
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xdb94
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x73a0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xdbac
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xdbb4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: MultiplicativeExpression::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void MultiplicativeExpression::print_py(std::ofstream& file) {

			if(OPERATOR==NULL && CaStExpression != NULL){
				CaStExpression->print_py(file);
			}
			else{ 
				if(MultiplicativeExpressionPtr != NULL){
					MultiplicativeExpressionPtr->print_py(file);
				}
				if(OPERATOR != NULL){
					file <<*OPERATOR;
				}
				if(CaStExpression != NULL){
					CaStExpression->print_py(file);
				}
				
			}

		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
je 0xdbf9
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xdbd6
movq %rbx, %rsi
callq 0xdbb4
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xdbee
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x73a0
movq 0x8(%r14), %rax
testq %rax, %rax
jne 0xdc02
jmp 0xdc1a
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xdbc5
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0xdc1a
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd35c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: InitDeclaratorList::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void InitDeclaratorList::print_py(std::ofstream& file) {
			if( InitDeclaratorListPtr != NULL){
				InitDeclaratorListPtr->print_py(file);
			}
			if(InitDecLarator != NULL){
				InitDecLarator->print_py(file);
			}
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xdc3d
movq %rbx, %rsi
callq 0xdc22
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xdc55
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xdc5e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: InitDeclarator::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void InitDeclarator::print_py(std::ofstream& file) {
			if( InitiaLizer == NULL && DecLarator != NULL ) {		
				DecLarator->print_py(file,false);
				file << std::endl;
			}			
			else{
				if(DecLarator != NULL){
					DecLarator->print_py(file,true);
				}
				if(InitiaLizer != NULL){
					InitiaLizer->print_py(file);
				}
				file << std::endl;
			}
				
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
je 0xdcb4
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xdc87
movq %rbx, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0xc260
movq 0x10(%r14), %r14
testq %r14, %r14
je 0xdcc9
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xdca1
movq %rbx, %rsi
callq 0xdcf8
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xdcc9
movq %rbx, %rsi
callq 0xd26a
jmp 0xdcc9
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xdc6f
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xc260
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7220
nop
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: InitializerList::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void InitializerList::print_py(std::ofstream& file){

			if( InitializerListPtr != NULL){
			
				InitializerListPtr->print_py(file);
			}

			if( InitializerPtr != NULL) {
	
				InitializerPtr->print_py(file);
			
			}

		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xdd13
movq %rbx, %rsi
callq 0xdcf8
movq 0x10(%r14), %r14
testq %r14, %r14
je 0xdd45
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xdd2d
movq %rbx, %rsi
callq 0xdcf8
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xdd45
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd26a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: TranslationUnit::render_asm(std::basic_ofstream<char, std::char_traits<char>>&, Context&)
void render_asm(std::ofstream& file, Context& contxt) {

			if(TranslationUnitPtr != NULL){
				TranslationUnitPtr->render_asm(file,contxt);
			}
			if( ExternalDecl != NULL){
				ExternalDecl->render_asm(file,contxt);
			}
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xdede
movq %r14, %rsi
movq %rbx, %rdx
callq 0xdebc
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0xdef7
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xdefe
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: ExternalDeclaration::render_asm(std::basic_ofstream<char, std::char_traits<char>>&, Context&)
void render_asm(std::ofstream& file,Context& contxt) {

			if( ExternalDeclarationPtr != NULL ) {
				//std::cout << "\nExternalDec!" << std::endl;; 
				ExternalDeclarationPtr->render_asm(file,contxt);
			}

			if ( DecLaration  == NULL && FunctionDef != NULL){
				contxt.function = true;
				file << std::endl;
				contxt.StackOffset = 0;
				contxt.protect=true; 
				//std::cout << "\nFunctDef" << std::endl;
				FunctionDef->render_asm(file,contxt);
				contxt.protect=false;
				contxt.StackOffset = 0; 				//reset the stack offset for other functions
				file << std::endl;
				contxt.function = false;
			}

			if ( FunctionDef  == NULL && DecLaration != NULL){
				contxt.function = false;
				file << std::endl;
				//std::cout << "\nDeclaration" << std::endl;
				DecLaration->render_asm(file,contxt);			// This path is taken for global declarations that are not functions
				file << std::endl;
			}
			//std::cout << "\nhow?" << std::endl;
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xdf23
movq %rbx, %rsi
movq %r14, %rdx
callq 0xdefe
cmpq $0x0, 0x10(%r15)
jne 0xdfc5
cmpq $0x0, 0x8(%r15)
je 0xdfc5
movb $0x1, %r12b
movb %r12b, 0x218(%r14)
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
xorl %ebp, %ebp
movl %ebp, 0x30c(%r14)
movb %r12b, 0x21a(%r14)
movq 0x8(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xe04a
movb %bpl, 0x21a(%r14)
movl %ebp, 0x30c(%r14)
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
movb %bpl, 0x218(%r14)
cmpq $0x0, 0x8(%r15)
jne 0xe040
cmpq $0x0, 0x10(%r15)
je 0xe040
movb $0x0, 0x218(%r14)
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
movq 0x10(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xf1b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7220
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: Declaration::render_asm(std::basic_ofstream<char, std::char_traits<char>>&, Context&)
void render_asm(std::ofstream& file,Context& contxt) {

			DeclSpec->render_asm(file,contxt);  // Obtain size of the data type of the variable

			if( DeclList != NULL) {
				DeclList->render_asm(file,contxt);  // Obtain name and value of the variable
			}
			if(contxt.function_dec)
			{
				contxt.funcion_temp.returnType=contxt.functionReturnTypetemp; 
				contxt.funcion_temp.name=contxt.funct_id;
				contxt.functions_declared.push_back(contxt.funcion_temp);
				contxt.funcion_temp.paramters_size=0;
				contxt.function_dec=false;
				contxt.function=false;
				file << std::endl << "# function declaration";
				if(contxt.Scopes.size()>0){
					contxt.Scopes.pop_back(); //assign the variable the scope it is in
				}
				else 
				{
					//std::cout << "PROBLEMS with Scopes" << std::endl;
				}
			}

			
			
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdi
callq 0xf2b0
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0xf1db
movq %r14, %rsi
movq %rbx, %rdx
callq 0x24fe4
cmpb $0x1, 0x13e7c(%rbx)
jne 0xf2a9
leaq 0x368(%rbx), %rsi
leaq 0x418(%rbx), %r15
leaq 0x440(%rbx), %rdi
callq 0x71c0
leaq 0x220(%rbx), %rsi
leaq 0x420(%rbx), %rdi
callq 0x71c0
leaq 0x400(%rbx), %rdi
movq %r15, %rsi
callq 0xf38a
movl $0x0, 0x418(%rbx)
xorl %eax, %eax
movb %al, 0x13e7c(%rbx)
movb %al, 0x218(%rbx)
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %r14, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
leaq 0x28a98(%rip), %rsi     # 0x37d02
movl $0x16, %edx
movq %rax, %rdi
callq 0x73a0
movq 0x468(%rbx), %rax
cmpq 0x460(%rbx), %rax
je 0xf2a9
leaq -0x20(%rax), %rcx
movq %rcx, 0x468(%rbx)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0xf2a9
popq %rbx
popq %r14
popq %r15
jmp 0x72e0
popq %rbx
popq %r14
popq %r15
retq
nop