LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa553
movq %rbx, %rsi
callq 0xa538
cmpq $0x0, 0x10(%r14)
je 0xa55e
xorl %eax, %eax
jmp 0xa597
cmpq $0x0, 0x8(%r14)
je 0xa5c5
movb $0x1, 0x5cfb4(%rip)     # 0x67520
movq %rbx, %rdi
callq 0x7190
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xa798
movq %rbx, %rdi
callq 0x7190
movb $0x0, 0x5cf91(%rip)     # 0x67520
cmpq $0x0, 0x10(%r14)
sete %al
cmpq $0x0, 0x8(%r14)
jne 0xa5c5
testb %al, %al
jne 0xa5c5
movq %rbx, %rdi
callq 0x7190
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xa868
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7190
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xa7c4
pushq $0x1
popq %rcx
movq %rbx, %rsi
xorl %edx, %edx
callq 0xa876
cmpq $0x0, 0x18(%r14)
je 0xa7fe
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xa7d5
movq %rbx, %rsi
callq 0xa8cc
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0xa7f4
pushq $0x1
popq %rcx
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xa90e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x22bf0(%rip), %rsi     # 0x2d3f5
movq %rbx, %rdi
callq 0x7310
movq %rax, %rdi
callq 0x7190
xorl %r12d, %r12d
leaq 0x22bd9(%rip), %r15     # 0x2d3f8
xorl %r13d, %r13d
movq 0x48e27(%rip), %rax     # 0x53650
subq 0x48e18(%rip), %rax     # 0x53648
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0xa7c4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7310
movq 0x48dfd(%rip), %rsi     # 0x53648
addq %r12, %rsi
movq %rax, %rdi
callq 0x72d0
movq %rax, %rdi
callq 0x7190
incq %r13
addq $0x20, %r12
jmp 0xa822
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa8a0
movq %rbx, %rsi
movl %ebp, %edx
movl %r14d, %ecx
callq 0xa876
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0xa8c0
movq %rbx, %rsi
movl %ebp, %edx
movl %r14d, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa9ae
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa8e7
movq %rbx, %rsi
callq 0xa8cc
movb $0x0, 0x5cc32(%rip)     # 0x67520
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xa906
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa868
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl 0x5cc06(%rip), %ecx     # 0x67524
incl %ecx
movl %ecx, 0x5cbfe(%rip)     # 0x67524
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdi
movq %rax, %rdx
orq %rdi, %rdx
jne 0xa971
xorl %ebp, %ebp
leaq 0x22dc7(%rip), %r14     # 0x2d706
cmpl %ecx, %ebp
jge 0xa958
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7310
incl %ebp
movl 0x5cbce(%rip), %ecx     # 0x67524
jmp 0xa93f
leaq 0x22af3(%rip), %rsi     # 0x2d452
movq %rbx, %rdi
callq 0x7310
movq %rax, %rdi
callq 0x7190
jmp 0xa9a3
testq %rax, %rax
je 0xa989
testq %rdi, %rdi
je 0xa998
movq %rbx, %rsi
callq 0xa8cc
movq 0x8(%r14), %rdi
jmp 0xa99b
testq %rdi, %rdi
je 0xa9a3
movq %rbx, %rsi
callq 0xa8cc
jmp 0xa9a3
movq %rax, %rdi
movq %rbx, %rsi
callq 0xae84
decl 0x5cb7b(%rip)           # 0x67524
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xaba0
movq %rbx, %rsi
callq 0xab76
leaq 0x22af0(%rip), %rsi     # 0x2d688
movq %rbx, %rdi
callq 0x7310
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0xabb8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x72d0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xae4a
movq %rbx, %rsi
callq 0xae20
leaq 0x22846(%rip), %rsi     # 0x2d688
movq %rbx, %rdi
callq 0x7310
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xae62
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xae6a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xae9f
movq %rbx, %rsi
callq 0xae84
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xaeb9
movq %rbx, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xaec2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x222b2(%rip), %rsi     # 0x2d470
callq 0x820e
testb %al, %al
je 0xb24f
cmpq $0x0, 0x8(%r14)
je 0xb24f
cmpq $0x0, 0x10(%r14)
je 0xb24f
movq %rbx, %rdi
callq 0x7190
movb $0x1, 0x5c341(%rip)     # 0x67529
xorl %ebp, %ebp
leaq 0x22515(%rip), %r15     # 0x2d706
cmpl 0x5c32d(%rip), %ebp     # 0x67524
jge 0xb208
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7310
incl %ebp
jmp 0xb1f1
leaq 0x22267(%rip), %rsi     # 0x2d476
movq %rbx, %rdi
callq 0x7310
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xb2ce
leaq 0x221cb(%rip), %rsi     # 0x2d3f5
movq %rbx, %rdi
callq 0x7310
movq %rax, %rdi
callq 0x7190
movq 0x10(%r14), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xbb7b
movb $0x0, 0x5c2da(%rip)     # 0x67529
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %ebp, %ebp
leaq 0x22496(%rip), %r15     # 0x2d706
cmpl 0x5c2ae(%rip), %ebp     # 0x67524
jge 0xb287
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7310
incl %ebp
jmp 0xb270
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0xb2a7
movq %rbx, %rdi
callq 0x72d0
leaq 0x22969(%rip), %rsi     # 0x2dc08
movq %rax, %rdi
callq 0x7310
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xb2c2
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb2ce
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb333
xorl %ebp, %ebp
leaq 0x22405(%rip), %r15     # 0x2d706
cmpl 0x5c21d(%rip), %ebp     # 0x67524
jge 0xb318
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7310
incl %ebp
jmp 0xb301
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xb396
leaq 0x22432(%rip), %rsi     # 0x2d75d
movq %rbx, %rdi
callq 0x7310
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xb344
movq %rbx, %rsi
callq 0xb42a
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0xb355
movq %rbx, %rsi
callq 0xb2e4
cmpb $0x0, 0x5c1c4(%rip)     # 0x67520
jne 0xb367
cmpb $0x0, 0x5c1c4(%rip)     # 0x67529
je 0xb372
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x0, 0x5c1b1(%rip)     # 0x6752a
jne 0xb367
cmpl $0x0, 0x5c1aa(%rip)     # 0x6752c
jne 0xb367
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7190
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xb3b7
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xb440
cmpq $0x0, 0x18(%r14)
je 0xb3da
cmpq $0x0, 0x10(%r14)
je 0xb3e0
leaq 0x10(%r14), %r15
leaq 0x22838(%rip), %rsi     # 0x2dc08
movq %rbx, %rdi
callq 0x7310
jmp 0xb3fe
popq %rbx
popq %r14
popq %r15
retq
cmpq $0x0, 0x28(%r14)
je 0xb418
leaq 0x2281a(%rip), %rsi     # 0x2dc08
movq %rbx, %rdi
callq 0x7310
movq 0x28(%r14), %r15
addq $0x8, %r15
movq (%r15), %rsi
movq %rax, %rdi
callq 0x72d0
leaq 0x227f8(%rip), %rsi     # 0x2dc08
movq %rax, %rdi
callq 0x7310
movq 0x18(%r14), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xb5d6
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0xb62e
leaq 0x21e7c(%rip), %rsi     # 0x2d47b
movq %r14, %rdi
callq 0x7310
incl 0x5bf1f(%rip)           # 0x6752c
movq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0xb2ce
leaq 0x22ff9(%rip), %rsi     # 0x2e619
movq %r14, %rdi
callq 0x7310
decl 0x5befe(%rip)           # 0x6752c
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
jne 0xb640
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0xb652
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x72d0
cmpq $0x0, 0x18(%rbx)
je 0xb6a3
leaq 0x225a8(%rip), %r15     # 0x2dc08
movq %r14, %rdi
movq %r15, %rsi
callq 0x7310
pushq $0x22
popq %rbp
movq %rax, %rdi
movl %ebp, %esi
callq 0x73c0
movq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0x72d0
movq %rax, %rdi
movl %ebp, %esi
callq 0x73c0
movq %rax, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7310
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x5be61(%rip)     # 0x67520
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xb6df
movq %rbx, %rsi
callq 0xb6ae
leaq 0x21fb1(%rip), %rsi     # 0x2d688
movq %rbx, %rdi
callq 0x7310
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xb6f7
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb2e4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rax
testq %rax, %rax
setne %cl
testq %rdi, %rdi
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0xb757
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xb73a
movq %rbx, %rsi
callq 0xb700
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xb74e
leaq 0x21d11(%rip), %rsi     # 0x2d457
movq %rbx, %rdi
callq 0x7310
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xb766
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb76e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x8(%rdi), %rdi
movq 0x18(%r14), %rax
testq %rax, %rax
setne %cl
testq %rdi, %rdi
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0xb7c5
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xb7a8
movq %rbx, %rsi
callq 0xb76e
movq 0x18(%r14), %rax
testq %rax, %rax
je 0xb7bc
leaq 0x21ca8(%rip), %rsi     # 0x2d45c
movq %rbx, %rdi
callq 0x7310
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xb7d4
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb7dc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rax
testq %rax, %rax
setne %cl
testq %rdi, %rdi
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0xb851
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xb817
movq %rbx, %rsi
callq 0xb7dc
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xb848
leaq 0x223e5(%rip), %r15     # 0x2dc08
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7310
leaq 0x2258d(%rip), %rsi     # 0x2ddc2
movq %rax, %rdi
callq 0x7310
movq %rax, %rdi
movq %r15, %rsi
callq 0x7310
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xb85e
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xb864
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rax
testq %rax, %rax
setne %cl
testq %rdi, %rdi
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0xb8d9
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xb89f
movq %rbx, %rsi
callq 0xb864
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xb8d0
leaq 0x2235d(%rip), %r15     # 0x2dc08
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7310
leaq 0x21ba5(%rip), %rsi     # 0x2d462
movq %rax, %rdi
callq 0x7310
movq %rax, %rdi
movq %r15, %rsi
callq 0x7310
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xb8e6
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xb8ec
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rax
testq %rax, %rax
setne %cl
testq %rdi, %rdi
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0xb961
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xb927
movq %rbx, %rsi
callq 0xb8ec
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xb958
leaq 0x222d5(%rip), %r15     # 0x2dc08
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7310
leaq 0x21a90(%rip), %rsi     # 0x2d3d5
movq %rax, %rdi
callq 0x7310
movq %rax, %rdi
movq %r15, %rsi
callq 0x7310
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xb96e
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xb974
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rsi
testq %rsi, %rsi
setne %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xb9c4
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xb9ae
movq %rbx, %rsi
callq 0xb974
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0xb9bb
movq %rbx, %rdi
callq 0x72d0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xb9d3
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb9dc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rsi
testq %rsi, %rsi
setne %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xba2c
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xba16
movq %rbx, %rsi
callq 0xb9dc
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0xba23
movq %rbx, %rdi
callq 0x72d0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xba3b
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xba44
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rsi
testq %rsi, %rsi
setne %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xba94
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xba7e
movq %rbx, %rsi
callq 0xba44
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0xba8b
movq %rbx, %rdi
callq 0x72d0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xbaa3
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbaac
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rsi
testq %rsi, %rsi
setne %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xbafc
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xbae6
movq %rbx, %rsi
callq 0xbaac
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0xbaf3
movq %rbx, %rdi
callq 0x72d0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xbb0b
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbb14
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rsi
testq %rsi, %rsi
setne %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xbb64
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xbb4e
movq %rbx, %rsi
callq 0xbb14
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0xbb5b
movq %rbx, %rdi
callq 0x72d0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xbb73
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb5d6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: Indent_Generator(Statement*, std::basic_ofstream<char, std::char_traits<char>>&, bool)
inline void Indent_Generator(Statement* StatementPointer, std::ofstream& file,bool elseif=false) {


	if( StatementPointer == NULL ) {
		elseif = false;
		file << "pass" << std::endl;
	}

	if(StatementPointer->CompoundStatementPtr == NULL) {	//if the next thing is not a compound statement since we are in an if/elif/while then indent
		counter_py++;
		elseif = false;
		StatementPointer->print_py(file,elseif);
		counter_py--;
		file << std:: endl;
	}

	else{
		elseif = false;
		StatementPointer->print_py(file,elseif);		//if the next thing is a compound statement then dont indent yet
		file << std:: endl;
					
	}
	
		
	
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
jne 0xbba1
leaq 0x218c1(%rip), %rsi     # 0x2d452
movq %rbx, %rdi
callq 0x7310
movq %rax, %rdi
callq 0x7190
cmpq $0x0, 0x10(%r14)
je 0xbbb7
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xaec2
jmp 0xbbd0
incl 0x5b967(%rip)           # 0x67524
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xaec2
decl 0x5b954(%rip)           # 0x67524
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7190
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xbbfb
movq %rbx, %rsi
callq 0xbbe0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xbc13
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbc1c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xbc5b
testq %rdi, %rdi
je 0xbc4e
pushq $0x1
popq %rdx
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0xa876
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xbc6c
movq %rax, %rdi
movq %rbx, %rsi
callq 0xbc7c
jmp 0xbc6c
testq %rdi, %rdi
je 0xbc6c
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xa876
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7190
nop
// File: /workspace/github_cpp_makefile_star2_O2/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: Initializer::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void Initializer::print_py(std::ofstream& file) {
	
			if(InitializerListPtr!=NULL){
				InitializerListPtr->print_py(file);
			}
			if(AssignmentExpressionPtr != NULL){
				AssignmentExpressionPtr->print_py(file);
			}

		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xbc97
movq %rbx, %rsi
callq 0xbcb8
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xbcaf
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb2e4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xbcd3
movq %rbx, %rsi
callq 0xbcb8
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xbceb
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbc7c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xbe84
movq %r14, %rsi
movq %rbx, %rdx
callq 0xbe62
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0xbe9d
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xbea4
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xbec8
movq %rbx, %rsi
movq %r14, %rdx
callq 0xbea4
cmpq $0x0, 0x10(%r15)
je 0xbed3
xorl %eax, %eax
jmp 0xbf36
cmpq $0x0, 0x8(%r15)
je 0xbf72
movb $0x1, %bpl
movb %bpl, 0x218(%r14)
movq %rbx, %rdi
callq 0x7190
andl $0x0, 0x30c(%r14)
movb %bpl, 0x21a(%r14)
movq 0x8(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xbf7e
xorl %ebp, %ebp
movb %bpl, 0x21a(%r14)
andl $0x0, 0x30c(%r14)
movq %rbx, %rdi
callq 0x7190
movb %bpl, 0x218(%r14)
cmpq $0x0, 0x10(%r15)
sete %al
cmpq $0x0, 0x8(%r15)
jne 0xbf72
testb %al, %al
jne 0xbf72
movb $0x0, 0x218(%r14)
movq %rbx, %rdi
callq 0x7190
movq 0x10(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xc830
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7190
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc8fa
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0xc85b
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1ca0a
cmpb $0x1, 0x13e7c(%rbx)
jne 0xc8f4
leaq 0x368(%rbx), %rsi
leaq 0x418(%rbx), %r15
leaq 0x440(%rbx), %rdi
callq 0x71e0
leaq 0x220(%rbx), %rsi
leaq 0x420(%rbx), %rdi
callq 0x71e0
leaq 0x400(%rbx), %rdi
movq %r15, %rsi
callq 0xca58
andl $0x0, 0x418(%rbx)
xorl %eax, %eax
movb %al, 0x13e7c(%rbx)
movb %al, 0x218(%rbx)
movq %r14, %rdi
callq 0x7190
leaq 0x21444(%rip), %rsi     # 0x2dd0c
movq %rax, %rdi
callq 0x7310
movq 0x468(%rbx), %rax
cmpq 0x460(%rbx), %rax
je 0xc8f4
addq $0x460, %rbx            # imm = 0x460
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xcbde
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: DeclarationSpecifiers::render_asm(std::basic_ofstream<char, std::char_traits<char>>&, Context&)
void render_asm(std::ofstream& file,Context& contxt) {

			if(StorageClassSpec != NULL && DeclarationSpecifiersPtr == NULL) {
				StorageClassSpec->render_asm(file,contxt);	 //TODO: may have to implement this
				if(contxt.typedefs_){
					contxt.TypeAssoc.push_back(contxt.TypeDef);
					contxt.typedefs_ = false;
				}		
			}
			else if(StorageClassSpec != NULL && DeclarationSpecifiersPtr != NULL) {
				
				DeclarationSpecifiersPtr->render_asm(file,contxt);
				StorageClassSpec->render_asm(file,contxt);				
					
			}			
			else if(TypeSpec != NULL && DeclarationSpecifiersPtr == NULL) {
				
				TypeSpec->render_asm(file,contxt);
			}
			else if(TypeSpec != NULL && DeclarationSpecifiersPtr != NULL) {
				
				DeclarationSpecifiersPtr->render_asm(file,contxt);
					
				TypeSpec->render_asm(file,contxt); 
				
			}
			else if(TypeQuaLifier != NULL && DeclarationSpecifiersPtr == NULL) {
				//TypeQuaLifier->render_asm(file,contxt); //TODO: may have to implement this
			}

				
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rax
movq 0x20(%rdi), %rdi
testq %rax, %rax
setne %cl
testq %rdi, %rdi
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xc95a
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xcbf2
cmpb $0x1, 0x1d0(%rbx)
jne 0xc954
leaq 0x170(%rbx), %rdi
leaq 0x188(%rbx), %rsi
callq 0xcca2
movb $0x0, 0x1d0(%rbx)
popq %rbx
popq %r14
popq %r15
retq
testq %rdi, %rdi
sete %cl
testq %rax, %rax
sete %al
orb %cl, %al
je 0xc986
testq %rdi, %rdi
sete %cl
movq 0x10(%r15), %rax
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xc9a5
movq %rax, %rdi
jmp 0xc9c4
movq %r14, %rsi
movq %rbx, %rdx
callq 0xc8fa
movq 0x8(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xcbf2
testq %rdi, %rdi
sete %cl
testq %rax, %rax
sete %al
orb %cl, %al
jne 0xc954
movq %r14, %rsi
movq %rbx, %rdx
callq 0xc8fa
movq 0x10(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xccce
// File: /workspace/github_cpp_makefile_star2_O2/gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: Declarator::render_asm(std::basic_ofstream<char, std::char_traits<char>>&, Context&)
inline void Declarator::render_asm(std::ofstream& file,Context& contxt) {
			if(  PointerPtr != NULL && DirectDecLarator != NULL){
				
				contxt.variable.Pointer = true;
				PointerPtr->render_asm(file,contxt);

				contxt.variable.PointerLevels = contxt.PointerCounter;
				contxt.variable.PointerLevelsTemp = contxt.PointerCounter;
				
				
				DirectDecLarator->render_asm(file,contxt);
				contxt.PointerCounter = 0;
				contxt.variable.Pointer = false;
				contxt.variable.PointerLevels = 0;
				contxt.variable.PointerLevelsTemp = 0;
				
			}
			
			else if( DirectDecLarator != NULL && PointerPtr == NULL){
						
				DirectDecLarator->render_asm(file,contxt);
			}
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdi
movq 0x10(%r15), %rax
testq %rdi, %rdi
je 0xca39
testq %rax, %rax
je 0xca51
movb $0x1, 0x2f4(%rbx)
movq %r14, %rsi
movq %rbx, %rdx
callq 0x19ba4
movl 0x20(%rbx), %eax
movl %eax, 0x2f8(%rbx)
movl %eax, 0x2fc(%rbx)
movq 0x10(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x19be0
andl $0x0, 0x20(%rbx)
movb $0x0, 0x2f4(%rbx)
andq $0x0, 0x2f8(%rbx)
jmp 0xca51
testq %rax, %rax
je 0xca51
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x19be0
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: CompoundStatement::render_asm(std::basic_ofstream<char, std::char_traits<char>>&, Context&)
void render_asm(std::ofstream& file,Context& contxt) {
			std::string label_id = labelGen(contxt);
			std::string scope = "SCOPE" + label_id;
			contxt.Scopes.push_back(scope);
			//std::cout << "where are the scopes?";
			//print_scopes(contxt, file);
			if(DeclarationListPtr != NULL && StatementListPtr == NULL) {

				DeclarationListPtr->render_asm(file,contxt);
			}
			if(StatementListPtr != NULL && DeclarationListPtr == NULL ) {
				//if(!contxt.reading){
					StatementListPtr->render_asm(file,contxt);
				//}
			}
			if(StatementListPtr != NULL && DeclarationListPtr != NULL ) {
				
				DeclarationListPtr->render_asm(file,contxt);
				//if(!contxt.reading){
					StatementListPtr->render_asm(file,contxt);
				//}
			}	
			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 %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0xda27
leaq 0x21179(%rip), %rsi     # 0x2dc28
leaq 0x8(%rsp), %rdi
movq %r12, %rdx
callq 0xdaa7
leaq 0x460(%rbx), %r12
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0xab3c
movq 0x8(%r15), %rdi
movq 0x10(%r15), %rax
testq %rax, %rax
setne %cl
testq %rdi, %rdi
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xcb01
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1a89c
movq 0x8(%r15), %rdi
movq 0x10(%r15), %rax
testq %rdi, %rdi
je 0xcb1a
testq %rax, %rax
jne 0xcb1a
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1a8de
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0xcb42
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0xcb42
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1a89c
movq 0x8(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1a8de
movq 0x468(%rbx), %rax
cmpq 0x460(%rbx), %rax
je 0xcb5c
movq %r12, %rdi
callq 0xcbde
jmp 0xcb77
movq 0x32445(%rip), %rdi     # 0x3efa8
leaq 0x210c4(%rip), %rsi     # 0x2dc2e
callq 0x7310
movq %rax, %rdi
callq 0x7190
leaq 0x8(%rsp), %rdi
callq 0x7170
leaq 0x28(%rsp), %rdi
callq 0x7170
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0xcba9
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7170
leaq 0x28(%rsp), %rdi
callq 0x7170
movq %rbx, %rdi
callq 0x75c0
// File: /workspace/github_cpp_makefile_star2_O2/gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: StorageClassSpecifiers::render_asm(std::basic_ofstream<char, std::char_traits<char>>&, Context&)
void render_asm(std::ofstream& file,Context& contxt) {
			if(TYPES != NULL){

				if(*TYPES == "extern"){
					contxt.variable.StorageClass = "extern";	
				}

				else if( *TYPES == "static"){
					contxt.variable.StorageClass = "static";

				}
				
				else if(*TYPES == "register"){
					contxt.variable.StorageClass = "register";
				}

				else if(*TYPES == "typedef"){
					contxt.typedefs_ = true;
				}

			}
		

		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xcc99
movq %rdx, %rbx
leaq 0x20a1f(%rip), %rsi     # 0x2d62f
callq 0x820e
testb %al, %al
je 0xcc29
addq $0x2d0, %rbx            # imm = 0x2D0
leaq 0x20a08(%rip), %rsi     # 0x2d62f
jmp 0xcc6f
movq 0x8(%r14), %rdi
leaq 0x20a02(%rip), %rsi     # 0x2d636
callq 0x820e
testb %al, %al
je 0xcc4d
addq $0x2d0, %rbx            # imm = 0x2D0
leaq 0x209eb(%rip), %rsi     # 0x2d636
jmp 0xcc6f
movq 0x8(%r14), %rdi
leaq 0x209e5(%rip), %rsi     # 0x2d63d
callq 0x820e
testb %al, %al
je 0xcc7e
addq $0x2d0, %rbx            # imm = 0x2D0
leaq 0x209ce(%rip), %rsi     # 0x2d63d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7630
movq 0x8(%r14), %rdi
leaq 0x209bd(%rip), %rsi     # 0x2d646
callq 0x820e
testb %al, %al
je 0xcc99
movb $0x1, 0x1d0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop