LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0xe2cd
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe2cd
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xe330
jmp 0xe323
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xe2e9
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xe290
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xe305
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x10(%rax), %rsi
callq 0x83c0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe321
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xe330
jmp 0xe323
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0xe36d
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe36d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xdb70
jmp 0xe3c3
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xe389
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xe330
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xe3a5
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x10(%rax), %rsi
callq 0x83c0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe3c1
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xdb70
jmp 0xe3c3
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xe411
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x55e08(%rip), %rsi     # 0x64205
callq 0x8400
movq %rax, %rdi
movq 0x79b64(%rip), %rsi     # 0x87f70
callq 0x8450
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xe465
movl 0x8e30a(%rip), %eax     # 0x9c72c
addl $0x1, %eax
movl %eax, 0x8e301(%rip)     # 0x9c72c
movb $0x0, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0xcf70
movl 0x8e2e2(%rip), %eax     # 0x9c72c
addl $-0x1, %eax
movl %eax, 0x8e2d9(%rip)     # 0x9c72c
movq -0x10(%rbp), %rdi
movq 0x79b12(%rip), %rsi     # 0x87f70
callq 0x8450
jmp 0xe48e
movb $0x0, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0xcf70
movq -0x10(%rbp), %rdi
movq 0x79ae7(%rip), %rsi     # 0x87f70
callq 0x8450
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
je 0xe4d0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xe4a0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe4ec
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xe500
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0xe551
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe551
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0xbe60
movq -0x10(%rbp), %rdi
movq 0x79a26(%rip), %rsi     # 0x87f70
callq 0x8450
jmp 0xe5a0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe574
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0xbe60
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xe590
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xe5b0
movq -0x10(%rbp), %rdi
movq 0x799d5(%rip), %rsi     # 0x87f70
callq 0x8450
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
je 0xe5e0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xe610
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe5fc
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xd690
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x8(%rax)
je 0xe640
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xe610
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xe65c
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xe5b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x10(%rax)
je 0xe6b8
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xe680
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe6d8
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xe6e0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x18(%rax)
je 0xe718
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xe6e0
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xe7af
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe7af
movq -0x18(%rbp), %rax
movb $0x1, 0x218(%rax)
movq -0x10(%rbp), %rdi
movq 0x79828(%rip), %rsi     # 0x87f70
callq 0x8450
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl $0x0, 0x30c(%rcx)
movq -0x18(%rbp), %rcx
movb $0x1, 0x21a(%rcx)
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xe810
movq -0x18(%rbp), %rax
movb $0x0, 0x21a(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x30c(%rax)
movq -0x10(%rbp), %rdi
movq 0x797d1(%rip), %rsi     # 0x87f70
callq 0x8450
movq -0x18(%rbp), %rax
movb $0x0, 0x218(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xe805
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xe805
movq -0x18(%rbp), %rax
movb $0x0, 0x218(%rax)
movq -0x10(%rbp), %rdi
movq 0x79795(%rip), %rsi     # 0x87f70
callq 0x8450
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf770
movq -0x10(%rbp), %rdi
movq 0x79770(%rip), %rsi     # 0x87f70
callq 0x8450
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf8a0
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xf7bd
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x304d0
movq -0x18(%rbp), %rax
testb $0x1, 0x13e7c(%rax)
je 0xf896
movq -0x18(%rbp), %rsi
addq $0x368, %rsi            # imm = 0x368
movq -0x18(%rbp), %rdi
addq $0x418, %rdi            # imm = 0x418
addq $0x28, %rdi
callq 0x8060
movq -0x18(%rbp), %rsi
addq $0x220, %rsi            # imm = 0x220
movq -0x18(%rbp), %rdi
addq $0x418, %rdi            # imm = 0x418
addq $0x8, %rdi
callq 0x8060
movq -0x18(%rbp), %rdi
addq $0x400, %rdi            # imm = 0x400
movq -0x18(%rbp), %rsi
addq $0x418, %rsi            # imm = 0x418
callq 0xfb00
movq -0x18(%rbp), %rax
movl $0x0, 0x418(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x13e7c(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x218(%rax)
movq -0x10(%rbp), %rdi
movq 0x7871a(%rip), %rsi     # 0x87f70
callq 0x8450
movq %rax, %rdi
leaq 0x5525c(%rip), %rsi     # 0x64ac1
callq 0x8400
movq -0x18(%rbp), %rdi
addq $0x460, %rdi            # imm = 0x460
callq 0xbef0
cmpq $0x0, %rax
jbe 0xf892
movq -0x18(%rbp), %rdi
addq $0x460, %rdi            # imm = 0x460
callq 0xfe00
jmp 0xf894
jmp 0xf894
jmp 0xf896
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x8(%rax)
je 0xf91b
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xf91b
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xfe30
movq -0x18(%rbp), %rax
testb $0x1, 0x1d0(%rax)
je 0xf916
movq -0x18(%rbp), %rdi
addq $0x170, %rdi            # imm = 0x170
movq -0x18(%rbp), %rsi
addq $0x188, %rsi            # imm = 0x188
callq 0xff40
movq -0x18(%rbp), %rax
movb $0x0, 0x1d0(%rax)
jmp 0xf9ef
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xf960
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xf960
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf8a0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xfe30
jmp 0xf9ed
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xf98d
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xf98d
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xffb0
jmp 0xf9eb
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xf9cf
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xf9cf
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf8a0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xffb0
jmp 0xf9e9
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xf9e7
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xf9e7
jmp 0xf9e7
jmp 0xf9e9
jmp 0xf9eb
jmp 0xf9ed
jmp 0xf9ef
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x8(%rax)
je 0xfac1
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xfac1
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x1, 0x2f4(%rcx)
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x29e90
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x20(%rcx), %edx
movq -0x18(%rbp), %rcx
movl %edx, 0x2f8(%rcx)
movq -0x18(%rbp), %rcx
movl 0x20(%rcx), %edx
movq -0x18(%rbp), %rcx
movl %edx, 0x2fc(%rcx)
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x29f30
movq -0x18(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x2f4(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x2f8(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x2fc(%rax)
jmp 0xfaee
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xfaec
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xfaec
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x29f30
jmp 0xfaee
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x8(%rax)
je 0xff2c
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x5457e(%rip), %rsi     # 0x643e4
callq 0x9e30
testb $0x1, %al
jne 0xfe71
jmp 0xfe91
movq -0x18(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
addq $0x78, %rdi
leaq 0x5455d(%rip), %rsi     # 0x643e4
callq 0x8590
jmp 0xff2a
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x5454b(%rip), %rsi     # 0x643eb
callq 0x9e30
testb $0x1, %al
jne 0xfeab
jmp 0xfec8
movq -0x18(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
addq $0x78, %rdi
leaq 0x5452a(%rip), %rsi     # 0x643eb
callq 0x8590
jmp 0xff28
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x5451b(%rip), %rsi     # 0x643f2
callq 0x9e30
testb $0x1, %al
jne 0xfee2
jmp 0xfeff
movq -0x18(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
addq $0x78, %rdi
leaq 0x544fa(%rip), %rsi     # 0x643f2
callq 0x8590
jmp 0xff26
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x544ed(%rip), %rsi     # 0x643fb
callq 0x9e30
testb $0x1, %al
jne 0xff19
jmp 0xff24
movq -0x18(%rbp), %rax
movb $0x1, 0x1d0(%rax)
jmp 0xff26
jmp 0xff28
jmp 0xff2a
jmp 0xff2c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: EnumeratorList::render_asm(std::basic_ofstream<char, std::char_traits<char>>&, Context&)
void render_asm(std::ofstream& file, Context& contxt){ 

			if(EnumeratorListPtr != NULL && !contxt.reading){
				EnumeratorListPtr->render_asm(file,contxt);
				
			}
			
			if( EnumeratorPtr != NULL && !contxt.reading){
				
				EnumeratorPtr->render_asm(file,contxt);
				//std::cout << "\n" << contxt.EnumCounter << "\n";
				contxt.EnumCounter++;
							
			}
			
			
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x117d5
movq -0x18(%rbp), %rax
testb $0x1, 0x21b(%rax)
jne 0x117d5
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x11790
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x11815
movq -0x18(%rbp), %rax
testb $0x1, 0x21b(%rax)
jne 0x11815
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x11820
movq -0x18(%rbp), %rax
movl 0x148(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x148(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: Expression::render_asm(std::basic_ofstream<char, std::char_traits<char>>&, Context&)
void render_asm(std::ofstream& file,Context& contxt) {

			if(ExpressionPtr != NULL) {

				ExpressionPtr->render_asm(file,contxt);
			}

			else{
				AssignmentExpressionPtr->render_asm(file,contxt);
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x13a7a
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x13a40
jmp 0x13a8f
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x219c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: gioannides[P]Language_Processors/src/../include/ast/ast_Expressions.cpp
// Function: CastExpression::render_asm(std::basic_ofstream<char, std::char_traits<char>>&, Context&)
inline void CastExpression::render_asm(std::ofstream& file,Context& contxt) {

			if( UNaryExpression != NULL){
				UNaryExpression->render_asm(file,contxt);
			}
			else if(CastExpressionPtr != NULL && TYpeName != NULL && UNaryExpression == NULL){

				contxt.Cast = true;
				TYpeName->render_asm(file,contxt);				
				CastExpressionPtr->render_asm(file,contxt);
				contxt.Cast = false;

			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x1d13a
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1d1b0
jmp 0x1d19d
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1d19b
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1d19b
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1d19b
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x1, 0x90(%rcx)
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1ec80
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1d100
movq -0x18(%rbp), %rax
movb $0x0, 0x90(%rax)
jmp 0x1d19d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_Expressions.cpp
// Function: ArgumentExpressionList::render_asm(std::basic_ofstream<char, std::char_traits<char>>&, Context&)
inline void ArgumentExpressionList::render_asm(std::ofstream& file,Context& contxt)
{
	if(ArgumentExpressionListPtr!=NULL)
			{
				ArgumentExpressionListPtr->render_asm(file, contxt);
			}
			contxt.argument_no[contxt.argument_no.size()-1]++;
			//contxt.rhs_of_expression=true;
			AssignmentExpressionPtr->render_asm(file, contxt);
			//contxt.rhs_of_expression=false;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x1f888
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1f850
movq -0x18(%rbp), %rax
addq $0x490, %rax            # imm = 0x490
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x490, %rdi            # imm = 0x490
callq 0x11a60
movq -0x28(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x11a80
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl (%rcx), %edx
addl $0x1, %edx
movl %edx, (%rcx)
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x219c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: SpecifierQualifierList::render_asm(std::basic_ofstream<char, std::char_traits<char>>&, Context&)
inline void SpecifierQualifierList::render_asm(std::ofstream& file, Context& contxt) {

			if(TypeSpecifierPtr != NULL && SpecifierQualifierListPtr == NULL && TypeQualifierPtr == NULL){
				TypeSpecifierPtr->render_asm(file,contxt);
			}
			else if(TypeSpecifierPtr != NULL && SpecifierQualifierListPtr != NULL && TypeQualifierPtr == NULL){
				TypeSpecifierPtr->render_asm(file,contxt);
				SpecifierQualifierListPtr->render_asm(file,contxt);				
			}
			else if(TypeSpecifierPtr == NULL && SpecifierQualifierListPtr != NULL && TypeQualifierPtr != NULL){		
				TypeQualifierPtr->render_asm(file,contxt);
				SpecifierQualifierListPtr->render_asm(file,contxt);				
			}
			else if(TypeSpecifierPtr == NULL && SpecifierQualifierListPtr == NULL && TypeQualifierPtr != NULL){
				TypeQualifierPtr->render_asm(file,contxt);				
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x291d3
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x291d3
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x291d3
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xffb0
jmp 0x292ac
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x29223
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x29223
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x29223
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xffb0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x29180
jmp 0x292aa
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x29270
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x29270
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x29270
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x292c0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x29180
jmp 0x292a8
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x292a6
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x292a6
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x292a6
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x292c0
jmp 0x292a8
jmp 0x292aa
jmp 0x292ac
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: TypeQualifier::render_asm(std::basic_ofstream<char, std::char_traits<char>>&, Context&)
void render_asm(std::ofstream& file, Context& Contxt) {

			if(TYPES != NULL && contxt.sizeof_){

				if(*TYPES == "const"){
					contxt.SizeOf = 4;
				}
				else if(*TYPES == "volatile"){
					contxt.SizeOf = 4;
				}
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x2933a
testb $0x1, 0x5f796(%rip)     # 0x88a80
je 0x2933a
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x3b65f(%rip), %rsi     # 0x6495a
callq 0x9e30
testb $0x1, %al
jne 0x29306
jmp 0x29312
movl $0x4, 0x5f774(%rip)     # 0x88a84
jmp 0x29338
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x3b63f(%rip), %rsi     # 0x64960
callq 0x9e30
testb $0x1, %al
jne 0x2932c
jmp 0x29336
movl $0x4, 0x5f74e(%rip)     # 0x88a84
jmp 0x29338
jmp 0x2933a
addq $0x20, %rsp
popq %rbp
retq
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: Pointer::render_asm(std::basic_ofstream<char, std::char_traits<char>>&, Context&)
void render_asm(std::ofstream& file, Context& contxt){

			if(PointerPtr == NULL && TypeQualifierListPtr == NULL){

				contxt.PointerCounter++;
				contxt.variable.word_size = 4;

			}

			else if(PointerPtr != NULL && TypeQualifierListPtr == NULL){

				contxt.PointerCounter++;
				contxt.variable.word_size = 4;
				PointerPtr->render_asm(file,contxt);
			}

		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x29edb
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x29edb
movq -0x18(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x18(%rbp), %rax
movl $0x4, 0x258(%rax)
jmp 0x29f23
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x29f21
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x29f21
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x20(%rcx), %edx
addl $0x1, %edx
movl %edx, 0x20(%rcx)
movq -0x18(%rbp), %rcx
movl $0x4, 0x258(%rcx)
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x29e90
jmp 0x29f23
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: ParameterTypeList::render_asm(std::basic_ofstream<char, std::char_traits<char>>&, Context&)
void render_asm(std::ofstream& file,Context& contxt) {
			contxt.variable.offset = 0;
			if( ParameterListPtr != NULL) {
				//std::cout << " go to parameter list" << std::endl;
				 // reset the offset before you enter another parameter list
				ParameterListPtr->render_asm(file,contxt);
				contxt.funcion_temp.paramters_size = contxt.variable.offset;
				//std:: cout <<"\t\t\t" << 	contxt.variable.offset;
			}
			 			
		
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movl $0x0, 0x2a8(%rcx)
cmpq $0x0, 0x8(%rax)
je 0x2ab1a
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2abc0
movq -0x18(%rbp), %rax
movl 0x2a8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x418(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: ParameterList::render_asm(std::basic_ofstream<char, std::char_traits<char>>&, Context&)
void render_asm(std::ofstream& file,Context& contxt) {

			if( ParameterListPtr != NULL) {
				//std::cout << "parameter type list detected" << std::endl;
				ParameterListPtr->render_asm(file,contxt);	
			}
			if(ParameterDeclarationPtr!=NULL){
				contxt.parameter = true;
				ParameterDeclarationPtr->render_asm(file,contxt);
				contxt.parameter = false;
			}
			//contxt.variable.offset = 0; // reset the offset before you enter another parameter list
			
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x2abf8
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2abc0
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2ac2e
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x1, 0x4a8(%rcx)
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2ac40
movq -0x18(%rbp), %rax
movb $0x0, 0x4a8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: ParameterDeclaration::render_asm(std::basic_ofstream<char, std::char_traits<char>>&, Context&)
inline void ParameterDeclaration::render_asm(std::ofstream& file, Context& contxt)  {
			//std::cout << "parameter declaration" << std::endl;
			if( DeclarationSpecifiersPtr != NULL) {
				
				DeclarationSpecifiersPtr->render_asm(file,contxt);
				
			}

			if( DeclaratorPtr != NULL) {
				contxt.variable.offset += 4;//contxt.variable.word_size;
				DeclaratorPtr->render_asm(file,contxt);
			}
			
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x2ac78
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf8a0
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2acab
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x2a8(%rcx), %edx
addl $0x4, %edx
movl %edx, 0x2a8(%rcx)
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xfa00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: DeclarationList::render_asm(std::basic_ofstream<char, std::char_traits<char>>&, Context&)
inline void DeclarationList::render_asm(std::ofstream& file,Context& contxt) {
				
			if(DeclarationListPtr != NULL) {
				DeclarationListPtr->render_asm(file,contxt);
			}
			if(DeclarationPtr != NULL){
				DeclarationPtr->render_asm(file,contxt);
			}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x2c088
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2c050
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2c0a8
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf770
addq $0x20, %rsp
popq %rbp
retq
nop
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: Statement::render_asm(std::basic_ofstream<char, std::char_traits<char>>&, Context&)
inline void Statement::render_asm(std::ofstream& file,Context& contxt) {
		
			if( LabeledStatementPtr != NULL && !contxt.reading) {				//TODO: DO IT
				LabeledStatementPtr->render_asm(file,contxt);
			}
			else if( CompoundStatementPtr != NULL) {
				CompoundStatementPtr->render_asm(file,contxt);
			}
		if( !contxt.ReadingSwitch){
			if( ExpressionStatementPtr != NULL) {		
				ExpressionStatementPtr->render_asm(file,contxt);
			}
			else if( IterationStatementPtr != NULL && !contxt.reading) {
				IterationStatementPtr->render_asm(file,contxt);
			}
			else if( JumpStatementPtr != NULL) {
				JumpStatementPtr->render_asm(file,contxt);
			}
			else if( SelectionStatementPtr != NULL ) {			//TODO: SWITCH / CASE
				SelectionStatementPtr->render_asm(file,contxt);
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x2c157
movq -0x18(%rbp), %rax
testb $0x1, 0x21b(%rax)
jne 0x2c157
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2c230
jmp 0x2c179
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2c177
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xfb70
jmp 0x2c179
movq -0x18(%rbp), %rax
testb $0x1, 0x3d1(%rax)
jne 0x2c225
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x2c1ac
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2cb70
jmp 0x2c223
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x2c1db
movq -0x18(%rbp), %rax
testb $0x1, 0x21b(%rax)
jne 0x2c1db
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2cbd0
jmp 0x2c221
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x2c1fd
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2e410
jmp 0x2c21f
movq -0x20(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x2c21d
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2ee60
jmp 0x2c21f
jmp 0x2c221
jmp 0x2c223
jmp 0x2c225
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_Expressions.cpp
// Function: ExpressionStatement::render_asm(std::basic_ofstream<char, std::char_traits<char>>&, Context&)
inline void ExpressionStatement::render_asm(std::ofstream& file,Context& contxt){
			if( AssignmentExpressionPtr != NULL){
				contxt.rhs_of_expression=true;
				AssignmentExpressionPtr->render_asm(file,contxt);
				contxt.rhs_of_expression=false;
				
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x2cbbe
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x1, 0x1d1(%rcx)
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x13a40
movq -0x18(%rbp), %rax
movb $0x0, 0x1d1(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: InitDeclaratorList::render_asm(std::basic_ofstream<char, std::char_traits<char>>&, Context&)
void render_asm(std::ofstream& file,Context& contxt) {		//Traversing through all of the declarations in the program sequentially as they appear in source code

			if( InitDeclaratorListPtr != NULL) {
				InitDeclaratorListPtr->render_asm(file,contxt);
				
			}
			if(InitDecLarator != NULL){
				InitDecLarator->render_asm(file,contxt);
			}
			

		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x30508
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x304d0
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x30528
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x30530
addq $0x20, %rsp
popq %rbp
retq
nop
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: InitializerList::render_asm(std::basic_ofstream<char, std::char_traits<char>>&, Context&)
inline void InitializerList::render_asm(std::ofstream& file,Context& contxt) {

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

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

		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x31188
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x31150
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x311a8
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x30d50
addq $0x20, %rsp
popq %rbp
retq
nop
// File: gioannides[P]Language_Processors/src/C_lexer.yy.cpp
// Function: yy_try_NUL_trans(int)
static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
{
	int yy_is_jam;
    	char *yy_cp = (yy_c_buf_p);

	YY_CHAR yy_c = 1;
	if ( yy_accept[yy_current_state] )
		{
		(yy_last_accepting_state) = yy_current_state;
		(yy_last_accepting_cpos) = yy_cp;
		}
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = (int) yy_def[yy_current_state];
		if ( yy_current_state >= 292 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 291);

		return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0x62132(%rip), %rax     # 0xc4570
movq %rax, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x617f(%rip), %rax      # 0x685d0
cmpw $0x0, (%rax,%rcx,2)
je 0x6246c
movl -0x4(%rbp), %eax
movl %eax, 0x6211b(%rip)     # 0xc457c
movq -0x10(%rbp), %rax
movq %rax, 0x62114(%rip)     # 0xc4580
jmp 0x6246e
movslq -0x4(%rbp), %rcx
leaq 0x6997(%rip), %rax      # 0x68e10
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x6393(%rip), %rax      # 0x68820
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rbp), %eax
je 0x624c6
movslq -0x4(%rbp), %rcx
leaq 0x6bcf(%rip), %rax      # 0x69070
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x124, -0x4(%rbp)      # imm = 0x124
jl 0x624c4
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0x6e12(%rip), %rax      # 0x692d0
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
jmp 0x6246e
movslq -0x4(%rbp), %rcx
leaq 0x693f(%rip), %rax      # 0x68e10
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x6e3b(%rip), %rax      # 0x69320
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x123, -0x4(%rbp)      # imm = 0x123
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x6250b
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x62511
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nyorain[P]bintoheader/./flags.hpp
// Function: std::optional<bool> flags::detail::get<bool>(std::unordered_map<std::basic_string_view<char, std::char_traits<char>>, std::optional<std::basic_string_view<char, std::char_traits<char>>>, std::hash<std::basic_string_view<char, std::char_traits<char>>>, std::equal_to<std::basic_string_view<char, std::char_traits<char>>>, std::allocator<std::pair<std::basic_string_view<char, std::char_traits<char>> const, std::optional<std::basic_string_view<char, std::char_traits<char>>>>>> const&, std::basic_string_view<char, std::char_traits<char>> const&)
std::optional<bool> get(const argument_map& options,
                        const std::string_view& option) {
  if (const auto value = get_value(options, option)) {
    return std::none_of(falsities.begin(), falsities.end(),
                        [&value](auto falsity) { return *value == falsity; });
  }
  return std::nullopt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x52f0
leaq -0x30(%rbp), %rdi
callq 0x5370
testb $0x1, %al
jne 0x3780
jmp 0x37c8
leaq 0xd601(%rip), %rdi      # 0x10d88
callq 0x5470
movq %rax, -0x50(%rbp)
leaq 0xd5f1(%rip), %rdi      # 0x10d88
callq 0x5490
movq -0x50(%rbp), %rdi
movq %rax, %rsi
leaq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdx
callq 0x37e0
andb $0x1, %al
movb %al, -0x31(%rbp)
leaq -0x2(%rbp), %rdi
leaq -0x31(%rbp), %rsi
callq 0x54b0
jmp 0x37d1
leaq -0x2(%rbp), %rdi
callq 0x54e0
movw -0x2(%rbp), %ax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: nyorain[P]bintoheader/bintoheader.cpp
// Function: replace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void replace(std::string& str, const std::string& from, const std::string& to)
{
    if(from.empty()) return;
    size_t start_pos = 0;
    while((start_pos = str.find(from, start_pos)) != std::string::npos) {
        str.replace(start_pos, from.length(), to);
        start_pos += to.length(); // In case 'to' contains 'from', like replacing 'x' with 'yx'
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3430
testb $0x1, %al
jne 0x3853
jmp 0x3855
jmp 0x38b8
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3500
movq %rax, -0x20(%rbp)
cmpq $-0x1, %rax
je 0x38b8
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x33c0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
callq 0x30e0
movq -0x18(%rbp), %rdi
callq 0x33c0
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x385d
addq $0x30, %rsp
popq %rbp
retq
nop
// File: nyorain[P]bintoheader/./flags.hpp
// Function: flags::detail::parser::parser(int, char**)
parser(const int argc, char** argv) {
    for (int i = 1; i < argc; ++i) {
      churn(argv[i]);
    }
    // If the last token was an option, it needs to be drained.
    flush();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x7040
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x58(%rbp)
callq 0x7060
movq -0x50(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x48(%rbp)
callq 0x7080
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x7026
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x5af0
movq -0x50(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x70a0
jmp 0x6ff9
jmp 0x6ffb
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6fc9
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x7140
movq -0x58(%rbp), %rdi
callq 0x71a0
jmp 0x7037
movq -0x50(%rbp), %rdi
callq 0x7100
jmp 0x7031
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3470