LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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), %rax
testq %rax, %rax
setne %cl
testq %rdi, %rdi
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0xd1d9
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xd1bc
movq %rbx, %rsi
callq 0xd182
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xd1d0
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x73a0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xd1e8
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd1f0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xd243
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xd21c
movq %rbx, %rsi
callq 0xd1f0
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xd230
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x73a0
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xd2e6
movq 0x8(%rax), %r15
jmp 0xd250
movq 0x8(%r14), %rcx
testq %rcx, %rcx
je 0xd207
movq 0x8(%rcx), %r15
testq %r15, %r15
je 0xd2e6
leaq 0x2a99e(%rip), %r14     # 0x37bfe
movq 0x8(%r15), %rdi
testq %rdi, %rdi
jne 0xd2f2
movq 0x18(%r15), %rax
testq %rax, %rax
je 0xd2e6
cmpq $0x0, 0x10(%r15)
je 0xd293
leaq 0x10(%r15), %r12
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73a0
jmp 0xd2b2
cmpq $0x0, 0x28(%r15)
je 0xd2d9
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73a0
movq 0x28(%r15), %r12
addq $0x8, %r12
movq (%r12), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x73a0
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x73a0
movq 0x18(%r15), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
jne 0xd260
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xca5a
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd321
movq %rbx, %rsi
callq 0xd306
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xd339
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd342
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %r15
testq %r15, %r15
je 0xd39b
testq %rdi, %rdi
je 0xd377
movq %rbx, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0xb98c
movq 0x10(%r14), %r15
testq %r15, %r15
je 0xd3ac
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0xd388
movq %rbx, %rsi
callq 0xd3d8
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0xd3ac
movq %rbx, %rsi
callq 0xc8c0
jmp 0xd3ac
testq %rdi, %rdi
je 0xd3ac
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xb98c
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x7220
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd3f3
movq %rbx, %rsi
callq 0xd3d8
movq 0x10(%r14), %r14
testq %r14, %r14
je 0xd425
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xd40d
movq %rbx, %rsi
callq 0xd3d8
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xd425
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc8c0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd5be
movq %r14, %rsi
movq %rbx, %rdx
callq 0xd59c
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0xd5d7
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xd5de
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: ExternalDeclaration::render_asm(std::basic_ofstream<char, std::char_traits<char>>&, Context&)
void render_asm(std::ofstream& file,Context& contxt) {

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xd603
movq %rbx, %rsi
movq %r14, %rdx
callq 0xd5de
cmpq $0x0, 0x10(%r15)
je 0xd611
xorl %eax, %eax
jmp 0xd6b0
cmpq $0x0, 0x8(%r15)
je 0xd728
movb $0x1, %r12b
movb %r12b, 0x218(%r14)
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
xorl %ebp, %ebp
movl %ebp, 0x30c(%r14)
movb %r12b, 0x21a(%r14)
movq 0x8(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xd732
movb %bpl, 0x21a(%r14)
movl %ebp, 0x30c(%r14)
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
movb %bpl, 0x218(%r14)
cmpq $0x0, 0x10(%r15)
sete %al
cmpq $0x0, 0x8(%r15)
jne 0xd728
testb %al, %al
jne 0xd728
movb $0x0, 0x218(%r14)
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
movq 0x10(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xe8ac
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7220
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe9ac
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0xe8d7
movq %r14, %rsi
movq %rbx, %rdx
callq 0x24906
cmpb $0x1, 0x13e7c(%rbx)
jne 0xe9a5
leaq 0x368(%rbx), %rsi
leaq 0x418(%rbx), %r15
leaq 0x440(%rbx), %rdi
callq 0x71c0
leaq 0x220(%rbx), %rsi
leaq 0x420(%rbx), %rdi
callq 0x71c0
leaq 0x400(%rbx), %rdi
movq %r15, %rsi
callq 0xea86
movl $0x0, 0x418(%rbx)
xorl %eax, %eax
movb %al, 0x13e7c(%rbx)
movb %al, 0x218(%rbx)
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %r14, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
leaq 0x2939c(%rip), %rsi     # 0x37d02
movl $0x16, %edx
movq %rax, %rdi
callq 0x73a0
movq 0x468(%rbx), %rax
cmpq 0x460(%rbx), %rax
je 0xe9a5
leaq -0x20(%rax), %rcx
movq %rcx, 0x468(%rbx)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0xe9a5
popq %rbx
popq %r14
popq %r15
jmp 0x72e0
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xea0c
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xec48
cmpb $0x1, 0x1d0(%rbx)
jne 0xea06
leaq 0x170(%rbx), %rdi
leaq 0x188(%rbx), %rsi
callq 0xed16
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 0xea38
testq %rdi, %rdi
sete %cl
movq 0x10(%r15), %rax
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xea57
movq %rax, %rdi
jmp 0xea76
movq %r14, %rsi
movq %rbx, %rdx
callq 0xe9ac
movq 0x8(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xec48
testq %rdi, %rdi
sete %cl
testq %rax, %rax
sete %al
orb %cl, %al
jne 0xea06
movq %r14, %rsi
movq %rbx, %rdx
callq 0xe9ac
movq 0x10(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xed40
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfdc2
leaq 0x29143(%rip), %rsi     # 0x37c1e
leaq 0x8(%rsp), %rdi
movq %r12, %rdx
callq 0xfef4
leaq 0x460(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0xbcf4
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 0xeb2a
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x217dc
movq 0x8(%r15), %rdi
movq 0x10(%r15), %rax
testq %rdi, %rdi
je 0xeb43
testq %rax, %rax
jne 0xeb43
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2181e
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0xeb6b
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0xeb6b
movq %r14, %rsi
movq %rbx, %rdx
callq 0x217dc
movq 0x8(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2181e
movq 0x468(%rbx), %rax
cmpq 0x460(%rbx), %rax
je 0xeb9a
leaq -0x20(%rax), %rcx
movq %rcx, 0x468(%rbx)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0xebe0
callq 0x72e0
jmp 0xebe0
movq 0x3740f(%rip), %rbx     # 0x45fb0
leaq 0x2907c(%rip), %rsi     # 0x37c24
movl $0x14, %edx
movq %rbx, %rdi
callq 0x73a0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq 0x373dd(%rip), %rdi     # 0x45fb0
callq 0x7040
movq %rax, %rdi
callq 0x7220
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xebf3
callq 0x72e0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xec06
callq 0x72e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0xec2d
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xec2d
callq 0x72e0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xec40
callq 0x72e0
movq %rbx, %rdi
callq 0x75f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xecae
movq %rdx, %rbx
leaq 0x289c3(%rip), %rsi     # 0x37625
callq 0x70c0
testl %eax, %eax
je 0xecb6
movq 0x8(%r14), %rdi
leaq 0x289b6(%rip), %rsi     # 0x3762c
callq 0x70c0
testl %eax, %eax
je 0xeccd
movq 0x8(%r14), %rdi
leaq 0x289a9(%rip), %rsi     # 0x37633
callq 0x70c0
testl %eax, %eax
je 0xecf9
movq 0x8(%r14), %rdi
leaq 0x2899e(%rip), %rsi     # 0x3763c
callq 0x70c0
testl %eax, %eax
jne 0xecae
movb $0x1, 0x1d0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x2d8(%rbx), %rdx
addq $0x2d0, %rbx            # imm = 0x2D0
leaq 0x2895a(%rip), %rcx     # 0x37625
jmp 0xece2
movq 0x2d8(%rbx), %rdx
addq $0x2d0, %rbx            # imm = 0x2D0
leaq 0x2894a(%rip), %rcx     # 0x3762c
movl $0x6, %r8d
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7520
movq 0x2d8(%rbx), %rdx
addq $0x2d0, %rbx            # imm = 0x2D0
leaq 0x28925(%rip), %rcx     # 0x37633
movl $0x8, %r8d
jmp 0xece8
// File: /workspace/github_cpp_makefile_star2_O3/gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: EnumSpecifier::render_asm(std::basic_ofstream<char, std::char_traits<char>>&, Context&)
void render_asm(std::ofstream& file, Context& contxt){ 
			contxt.EnumCounter = 0;
			if( IDENTIFIER == NULL )
			{
				if(contxt.function)
				{
					contxt.EnumTemp.ScopeID = contxt.funct_id;
				}
				else
				{	
					contxt.EnumTemp.ScopeID = "global";
				}
				ENumeratorList->render_asm(file,contxt);
			//	contxt.Enum.push_back(contxt.EnumTemp);				
			}
			else if( IDENTIFIER != NULL && ENumeratorList == NULL){
				contxt.variable.id = *IDENTIFIER;
				contxt.variable.DataType = "int";
				contxt.variable.word_size = 4;
				if(contxt.function){
					contxt.variable.scope = contxt.funct_id;
				}
				else{
					contxt.variable.scope = "global";
				}
				contxt.variable.value = 0;
				contxt.variable.Pointer = false;
			}
			else if( IDENTIFIER != NULL && ENumeratorList != NULL)
			{
				if(contxt.function){
					contxt.EnumTemp.ScopeID = contxt.funct_id;
				}
				else{	
					contxt.EnumTemp.ScopeID = "global";
				}
				ENumeratorList->render_asm(file,contxt);
				
				//std::cout << contxt.EnumValuesTemp.IDENTIFIER << " " << contxt.EnumValuesTemp.value << std::endl;
			}
			
			
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x0, 0x148(%rdx)
movq 0x10(%rdi), %rsi
testq %rsi, %rsi
je 0xf746
cmpq $0x0, 0x8(%r15)
je 0xf79a
cmpb $0x1, 0x218(%rbx)
jne 0xf764
leaq 0x220(%rbx), %rsi
leaq 0xd8(%rbx), %rdi
callq 0x71c0
jmp 0xf786
leaq 0xd8(%rbx), %rdi
movq 0xe0(%rbx), %rdx
leaq 0x27ee5(%rip), %rcx     # 0x3765e
movl $0x6, %r8d
xorl %esi, %esi
callq 0x7520
movq 0x8(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xf82a
leaq 0x260(%rbx), %rdi
callq 0x71c0
leaq 0x2b0(%rbx), %rdi
movq 0x2b8(%rbx), %rdx
leaq 0x289d1(%rip), %rcx     # 0x3818c
movl $0x3, %r8d
xorl %esi, %esi
callq 0x7520
movl $0x4, 0x258(%rbx)
cmpb $0x1, 0x218(%rbx)
jne 0xf7f0
leaq 0x220(%rbx), %rsi
leaq 0x288(%rbx), %rdi
callq 0x71c0
jmp 0xf812
leaq 0x288(%rbx), %rdi
movq 0x290(%rbx), %rdx
leaq 0x27e59(%rip), %rcx     # 0x3765e
movl $0x6, %r8d
xorl %esi, %esi
callq 0x7520
movq $0x0, 0x280(%rbx)
movb $0x0, 0x2f4(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xf855
cmpb $0x0, 0x21b(%rbx)
jne 0xf855
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf82a
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0xf878
cmpb $0x0, 0x21b(%rbx)
jne 0xf878
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf87e
incl 0x148(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: Enumerator::render_asm(std::basic_ofstream<char, std::char_traits<char>>&, Context&)
void render_asm(std::ofstream& file, Context& contxt){
			if(ConstantExpressionPtr != NULL && !contxt.reading){
				
				
				contxt.enum_constant = true;
				ConstantExpressionPtr->render_asm(file,contxt);
				contxt.enum_constant = false;
				if(contxt.EnumOperands.size())
				{
					contxt.EnumCounter = contxt.EnumOperands[contxt.EnumOperands.size()-1];
					contxt.EnumTemp.value = contxt.EnumOperands[contxt.EnumOperands.size()-1];
					contxt.EnumTemp.IDENTIFIER = *IDENTIFIER;
					contxt.Enum.push_back(contxt.EnumTemp);	
					
					//std::cout << "\n" << contxt.EnumCounter << "\n";
					//std::cout << contxt.EnumTemp.value << " " <<  contxt.EnumTemp.IDENTIFIER   << std::endl;
					for (int i=0; i<=contxt.EnumOperands.size(); i++){
						contxt.EnumOperands[i]=0;
					}
				}				
			}
			else if( ConstantExpressionPtr == NULL && !contxt.reading)
			{	

				contxt.EnumTemp.IDENTIFIER = *IDENTIFIER;
				contxt.EnumTemp.value = contxt.EnumCounter;
				//std::cout << contxt.EnumCounter << std::endl;
				//contxt.EnumCounter++;
				contxt.Enum.push_back(contxt.EnumTemp);	
			}
			//contxt.EnumTemp.EnumList.push_back(contxt.EnumValuesTemp);			
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
movb 0x21b(%rdx), %cl
testq %rax, %rax
je 0xf92f
testb %cl, %cl
jne 0xf933
movb $0x1, 0x14d(%rbx)
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0xf8bc
movq %rbx, %rdx
callq 0xf9a2
movb $0x0, 0x14d(%rbx)
movq 0x158(%rbx), %rax
cmpq 0x150(%rbx), %rax
je 0xf933
movl -0x4(%rax), %eax
movl %eax, 0x148(%rbx)
cvtsi2sd %eax, %xmm0
leaq 0xd8(%rbx), %r15
movsd %xmm0, 0x118(%rbx)
movq 0x8(%r14), %rsi
leaq 0xf8(%rbx), %rdi
callq 0x71c0
leaq 0xc0(%rbx), %rdi
movq %r15, %rsi
callq 0xf978
movq 0x150(%rbx), %rdi
movq 0x158(%rbx), %rdx
subq %rdi, %rdx
addq $0x4, %rdx
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x71d0
testb %cl, %cl
je 0xf939
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%r14), %rsi
leaq 0xd8(%rbx), %r14
leaq 0xf8(%rbx), %rdi
callq 0x71c0
cvtsi2sdl 0x148(%rbx), %xmm0
movsd %xmm0, 0x118(%rbx)
addq $0xc0, %rbx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xf978
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x16e38
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x16f40
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0x16f1e
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x16f1e
movb $0x1, 0x90(%rbx)
movq 0x8(%rax), %r12
testq %r12, %r12
je 0x16f0c
movq 0x8(%r12), %rdi
movq 0x10(%r12), %rcx
testq %rdi, %rdi
setne %r8b
testq %rcx, %rcx
sete %dl
andb %dl, %r8b
movq 0x18(%r12), %rax
testq %rax, %rax
sete %sil
testb %sil, %r8b
jne 0x16efd
addq $0x10, %r12
testq %rdi, %rdi
je 0x16eb4
testq %rcx, %rcx
setne %al
andb %sil, %al
cmpb $0x1, %al
jne 0x16f08
movq %r14, %rsi
movq %rbx, %rdx
callq 0xed40
jmp 0x16ecd
testb $0x1, %dl
jne 0x16f2a
testb $0x1, %sil
jne 0x16f08
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x20268
movq (%r12), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rcx
testq %rdi, %rdi
setne %r8b
leaq 0x10(%rax), %r12
testq %rcx, %rcx
sete %dl
andb %dl, %r8b
movq 0x18(%rax), %rax
testq %rax, %rax
sete %sil
testb %sil, %r8b
je 0x16e95
movq %r14, %rsi
movq %rbx, %rdx
callq 0xed40
movq 0x18(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x16e08
movb $0x0, 0x90(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testb $0x1, %sil
jne 0x16f08
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x20268
jmp 0x16f08
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x18b8c
movq %r14, %rsi
movq %rbx, %rdx
callq 0x18b6a
movq 0x498(%rbx), %rax
incl -0x4(%rax)
movq 0x10(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1a310
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x202ac
cmpb $0x1, 0x3a5dc(%rip)     # 0x5a858
jne 0x202ac
leaq 0x17916(%rip), %rsi     # 0x37b9b
callq 0x70c0
testl %eax, %eax
je 0x202a2
movq 0x8(%rbx), %rdi
leaq 0x17908(%rip), %rsi     # 0x37ba1
callq 0x70c0
testl %eax, %eax
jne 0x202ac
movl $0x4, 0x3a5b0(%rip)     # 0x5a85c
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
sete %al
cmpq $0x0, 0x10(%rdi)
sete %sil
andb %sil, %al
cmpb $0x1, %al
jne 0x206ab
movl 0x20(%rdx), %eax
jmp 0x206e4
movl 0x20(%rdx), %eax
testq %rcx, %rcx
je 0x206f3
testb $0x1, %sil
je 0x206f3
incl %eax
movl %eax, 0x20(%rdx)
movl $0x4, 0x258(%rdx)
movq 0x8(%rcx), %rdi
testq %rdi, %rdi
sete %r8b
cmpq $0x0, 0x10(%rcx)
sete %sil
movq %rdi, %rcx
testb %sil, %r8b
je 0x206ae
incl %eax
movl %eax, 0x20(%rdx)
movl $0x4, 0x258(%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x20f6c
movq %r14, %rsi
movq %rbx, %rdx
callq 0x20f4a
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x2101b
movb $0x1, 0x4a8(%rbx)
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x20f94
movq %r14, %rsi
movq %rbx, %rdx
callq 0xe9ac
movq 0x10(%r15), %r15
testq %r15, %r15
je 0x21014
addl $0x4, 0x2a8(%rbx)
movq 0x8(%r15), %rdi
movq 0x10(%r15), %rax
testq %rdi, %rdi
je 0x21001
testq %rax, %rax
je 0x21014
movb $0x1, 0x2f4(%rbx)
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2068c
movl 0x20(%rbx), %eax
movl %eax, 0x2f8(%rbx)
movl %eax, 0x2fc(%rbx)
movq 0x10(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x206f4
movl $0x0, 0x20(%rbx)
movb $0x0, 0x2f4(%rbx)
movq $0x0, 0x2f8(%rbx)
jmp 0x21014
testq %rax, %rax
je 0x21014
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x206f4
movb $0x0, 0x4a8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x217fe
movq %r14, %rsi
movq %rbx, %rdx
callq 0x217dc
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x21817
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xe8ac
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x21874
cmpb $0x0, 0x21b(%rbx)
je 0x2188a
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x21895
movq %r14, %rsi
movq %rbx, %rdx
callq 0xeab0
jmp 0x21895
movq %r14, %rsi
movq %rbx, %rdx
callq 0x21934
cmpb $0x0, 0x3d1(%rbx)
jne 0x218d9
movq 0x18(%r15), %rax
testq %rax, %rax
je 0x218df
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x218d9
movb $0x1, 0x1d1(%rbx)
movq %rax, %rcx
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x218b7
movq 0x8(%rcx), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1a310
movb $0x0, 0x1d1(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x218f1
cmpb $0x0, 0x21b(%rbx)
je 0x2190a
movq 0x28(%r15), %rdi
testq %rdi, %rdi
je 0x2191a
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x23478
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x21fba
movq 0x30(%r15), %rdi
testq %rdi, %rdi
je 0x218d9
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x23c4c
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x24928
movq %r14, %rsi
movq %rbx, %rdx
callq 0x24906
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x24941
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x24948
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x2563a
movq %r14, %rsi
movq %rbx, %rdx
callq 0x25618
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x25653
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x252ae
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x3b5a
testq %rax, %rax
je 0x262e
movq 0x18(%rax), %rbx
movq 0x20(%rax), %r14
leaq 0x2f6c(%rip), %rdx      # 0x5540
movq %rbx, %rdi
movq %r14, %rsi
callq 0x39f8
movw $0x100, %r15w           # imm = 0x100
testb %al, %al
jne 0x262a
leaq 0x2bf5(%rip), %rdx      # 0x51e4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x39f8
testb %al, %al
jne 0x262a
leaq 0x2f3d(%rip), %rdx      # 0x5542
movq %rbx, %rdi
movq %r14, %rsi
callq 0x39f8
testb %al, %al
jne 0x262a
leaq 0x2f2a(%rip), %rdx      # 0x5545
movq %rbx, %rdi
movq %r14, %rsi
callq 0x39f8
testb %al, %al
je 0x2647
xorl %eax, %eax
jmp 0x2633
xorl %eax, %eax
xorl %r15d, %r15d
movzwl %ax, %ecx
movzwl %r15w, %eax
orl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ef9(%rip), %rdx      # 0x5547
movq %rbx, %rdi
movq %r14, %rsi
callq 0x39f8
xorb $0x1, %al
movzbl %al, %eax
jmp 0x2633
// File: /workspace/github_cpp_makefile_star2_O3/nyorain[P]bintoheader/bintoheader.cpp
// Function: loadFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::vector<std::uint8_t> loadFile(const std::string& file)
{
	auto openmode = std::ios::ate | std::ios::binary;

	std::ifstream ifs(file, openmode);
	if(!ifs.is_open()) {
		std::cerr << "loadFile: couldnt open input file " << file << "\n";
		std::cerr << "error: " << std::strerror(errno) << "\n";
		exit(EXIT_FAILURE);
	}

	auto size = ifs.tellg();
	ifs.seekg(0, std::ios::beg);

	std::vector<std::uint8_t> buffer(size);
	auto data = reinterpret_cast<char*>(buffer.data());
	if(!ifs.read(data, size)) {
		std::cerr << "loadFile: failed to read input file " << file << "\n";
		std::cerr << "error: " << std::strerror(errno) << "\n";
		exit(EXIT_FAILURE);
	}

	return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x228(%rbp), %rdi
movl $0x6, %edx
callq 0x22b0
leaq -0x1b0(%rbp), %rdi
callq 0x2060
testb %al, %al
je 0x27b8
leaq -0x228(%rbp), %rdi
callq 0x22f0
movq %rax, %r15
leaq -0x228(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2230
leaq -0x19(%rbp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3a40
movq (%rbx), %rsi
leaq -0x228(%rbp), %rdi
movq %r15, %rdx
callq 0x2210
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x283e
leaq -0x228(%rbp), %rdi
callq 0x2070
movq %rbx, %rax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x5831(%rip), %rdi      # 0x7ff0
leaq 0x2860(%rip), %rsi      # 0x5026
movl $0x22, %edx
callq 0x21d0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x5812(%rip), %rdi      # 0x7ff0
callq 0x21d0
leaq 0x2ac5(%rip), %rsi      # 0x52af
movl $0x1, %edx
movq %rax, %rdi
callq 0x21d0
movq 0x57f2(%rip), %rdi      # 0x7ff0
leaq 0x2844(%rip), %rsi      # 0x5049
movl $0x7, %edx
callq 0x21d0
callq 0x2030
movl (%rax), %edi
callq 0x20b0
movq 0x57ce(%rip), %rdi      # 0x7ff0
movq %rax, %rsi
callq 0x2170
leaq 0x2a7e(%rip), %rsi      # 0x52af
movq %rax, %rdi
callq 0x2170
jmp 0x28bf
movq 0x57ab(%rip), %rdi      # 0x7ff0
leaq 0x2805(%rip), %rsi      # 0x5051
movl $0x24, %edx
callq 0x21d0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x578c(%rip), %rdi      # 0x7ff0
callq 0x21d0
leaq 0x2a3f(%rip), %rsi      # 0x52af
movl $0x1, %edx
movq %rax, %rdi
callq 0x21d0
movq 0x576c(%rip), %rdi      # 0x7ff0
leaq 0x27be(%rip), %rsi      # 0x5049
movl $0x7, %edx
callq 0x21d0
callq 0x2030
movl (%rax), %edi
callq 0x20b0
movq 0x5748(%rip), %rdi      # 0x7ff0
movq %rax, %rsi
callq 0x2170
leaq 0x29f8(%rip), %rsi      # 0x52af
movq %rax, %rdi
callq 0x2170
movl $0x1, %edi
callq 0x21f0
jmp 0x28e6
jmp 0x28e6
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x28e9
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2190
jmp 0x28e9
movq %rax, %r14
leaq -0x228(%rbp), %rdi
callq 0x2070
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movb $0x0, 0x10(%rdi)
leaq 0x48(%rdi), %rax
movq %rax, 0x18(%rdi)
movq $0x1, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movl $0x3f800000, 0x38(%rdi) # imm = 0x3F800000
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movq $0x0, 0x60(%rdi)
cmpl $0x2, %esi
jl 0x3e0f
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, -0x30(%rbp)
movl %esi, %r14d
movl $0x1, %r12d
movq (%r15,%r12,8), %r13
movq %r13, %rdi
callq 0x20e0
movq %rax, -0x48(%rbp)
movq %r13, -0x40(%rbp)
movq %rbx, %rdi
leaq -0x48(%rbp), %rsi
callq 0x3e4a
incq %r12
cmpq %r12, %r14
jne 0x3dd1
testb $0x1, 0x10(%rbx)
je 0x3e0f
leaq -0x48(%rbp), %rsi
movb $0x0, 0x10(%rsi)
movq %rbx, %rdi
callq 0x3f72
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3e20
movq %rax, %r15
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x3e38
movq 0x60(%rbx), %rsi
subq %rdi, %rsi
callq 0x2190
movq -0x30(%rbp), %rdi
callq 0x43fa
movq %r15, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O3/nyorain[P]bintoheader/./flags.hpp
// Function: flags::detail::parser::on_option(std::basic_string_view<char, std::char_traits<char>> const&)
void on_option(const std::string_view& option) {
    // Consume the current_option and reassign it to the new option while
    // removing all leading dashes.
    flush();
    current_option_ = option;
    current_option_->remove_prefix(current_option_->find_first_not_of('-'));

    // Handle a packed argument (--arg_name=value).
    const auto delimiter = current_option_->find_first_of('=');
    if (delimiter != std::string_view::npos) {
      auto value = *current_option_;
      value.remove_prefix(delimiter + 1 /* skip '=' */);
      current_option_->remove_suffix(current_option_->size() - delimiter);
      on_value(value);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movb 0x10(%rdi), %al
cmpb $0x1, %al
jne 0x3ec3
leaq -0x30(%rbp), %rsi
movb $0x0, 0x10(%rsi)
movq %rbx, %rdi
callq 0x3f72
movb 0x10(%rbx), %al
movups (%r14), %xmm0
movups %xmm0, (%rbx)
testb $0x1, %al
jne 0x3ed2
movb $0x1, 0x10(%rbx)
movq (%rbx), %r14
movq 0x8(%rbx), %r15
testq %r14, %r14
je 0x3f07
xorl %eax, %eax
cmpb $0x2d, (%r15,%rax)
jne 0x3ef6
incq %rax
cmpq %rax, %r14
jne 0x3ee0
movq $-0x1, %rax
addq %rax, %r15
movq %r15, 0x8(%rbx)
subq %rax, %r14
movq %r14, (%rbx)
jne 0x3f1b
jmp 0x3f67
decq %r15
movq %r15, 0x8(%rbx)
movq $0x1, (%rbx)
movl $0x1, %r14d
movq %r15, %rdi
movl $0x3d, %esi
movq %r14, %rdx
callq 0x21b0
testq %rax, %rax
sete %cl
subq %r15, %rax
cmpq $-0x1, %rax
sete %dl
orb %cl, %dl
jne 0x3f67
leaq 0x1(%rax), %rcx
leaq (%r15,%rax), %rdx
incq %rdx
subq %rcx, %r14
movq %rax, (%rbx)
leaq -0x30(%rbp), %rsi
movq %r14, (%rsi)
movq %rdx, 0x8(%rsi)
movb $0x1, 0x10(%rsi)
movq %rbx, %rdi
callq 0x3f72
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nyorain[P]bintoheader/./flags.hpp
// Function: flags::detail::parser::on_value(std::optional<std::basic_string_view<char, std::char_traits<char>>> const&)
void on_value(const std::optional<std::string_view>& value = std::nullopt) {
    // If there's not an option preceding the value, it's a positional argument.
    if (!current_option_) {
      positional_arguments_.emplace_back(*value);
      return;
    }
    // Consume the preceding option and assign its value.
    options_.emplace(*current_option_, value);
    current_option_.reset();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
cmpb $0x0, 0x10(%rdi)
je 0x3f9c
leaq 0x18(%rbx), %rdi
movq %rbx, %rsi
callq 0x4118
cmpb $0x1, 0x10(%rbx)
jne 0x3fb1
movb $0x0, 0x10(%rbx)
jmp 0x3fb1
movq 0x58(%rbx), %rsi
cmpq 0x60(%rbx), %rsi
je 0x3fb8
movups (%rdx), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addq $0x50, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3fca
// File: /workspace/github_cpp_makefile_star2_O3/nyorain[P]bintoheader/./flags.hpp
// Function: std::optional<unsigned int> flags::detail::get<unsigned int>(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<T> get(const argument_map& options,
                     const std::string_view& option) {
  if (const auto view = get_value(options, option)) {
    T value;
    if (std::istringstream(std::string(*view)) >> value) return value;
  }
  return std::nullopt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
callq 0x3b5a
testq %rax, %rax
je 0x4706
movq 0x20(%rax), %rsi
movq 0x18(%rax), %rdx
addq %rsi, %rdx
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x4520
leaq -0x1b8(%rbp), %rdi
movq %rbx, %rsi
movl $0x8, %edx
callq 0x22d0
leaq -0x1b8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x2310
leaq -0x1b8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl -0x198(%rbp,%rax), %ebx
movq 0x38ed(%rip), %rsi      # 0x7fc8
callq 0x2240
leaq -0x140(%rbp), %rdi
callq 0x20a0
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x4701
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2190
testb $0x5, %bl
je 0x470c
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x4719
movl -0x14(%rbp), %eax
movabsq $0x100000000, %rcx      # imm = 0x100000000
orq %rcx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x3896(%rip), %rsi      # 0x7fc8
leaq -0x1b8(%rbp), %rdi
callq 0x2240
leaq -0x140(%rbp), %rdi
callq 0x20a0
jmp 0x474f
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x4764
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/sonnyit[P]profiler/profiler.cpp
// Function: Profiler::reset(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Profiler::reset(const std::string& task_name) {
    lock_guard<mutex> lock(_mutex);
    if (_map_table.find(task_name) != _map_table.end()) { /* found -> reset task */
        ProfilerTask task;
        _map_table[task_name] = task;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x30(%rdi), %rbx
movq %rbx, %rdi
callq 0x2200
testl %eax, %eax
jne 0x2689
movq %r15, %rdi
movq %r14, %rsi
callq 0x2904
leaq 0x8(%r15), %rcx
cmpq %rcx, %rax
je 0x2677
movq %r15, %rdi
movq %r14, %rsi
callq 0x2752
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2130
movl %eax, %edi
callq 0x20d0
jmp 0x2692
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2250
nop