LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, 0x148(%rdx)
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rsi
testq %rsi, %rsi
je 0xd54b
cmpq $0x0, 0x8(%r15)
je 0xd590
cmpb $0x1, 0x218(%rbx)
jne 0xd569
leaq 0x220(%rbx), %rsi
leaq 0xd8(%rbx), %rdi
callq 0x71e0
jmp 0xd57c
leaq 0xd8(%rbx), %rdi
leaq 0x200f1(%rip), %rsi     # 0x2d668
callq 0x7630
movq 0x8(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xd600
leaq 0x260(%rbx), %rdi
callq 0x71e0
leaq 0x2b0(%rbx), %rdi
leaq 0x20bec(%rip), %rsi     # 0x2e196
callq 0x7630
movl $0x4, 0x258(%rbx)
cmpb $0x1, 0x218(%rbx)
jne 0xd5d7
leaq 0x220(%rbx), %rsi
leaq 0x288(%rbx), %rdi
callq 0x71e0
jmp 0xd5ea
leaq 0x288(%rbx), %rdi
leaq 0x20083(%rip), %rsi     # 0x2d668
callq 0x7630
andq $0x0, 0x280(%rbx)
movb $0x0, 0x2f4(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: 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 0xd62b
cmpb $0x0, 0x21b(%rbx)
jne 0xd62b
movq %r14, %rsi
movq %rbx, %rdx
callq 0xd600
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0xd64e
cmpb $0x0, 0x21b(%rbx)
jne 0xd64e
movq %r14, %rsi
movq %rbx, %rdx
callq 0xd654
incl 0x148(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: 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), %rdi
movb 0x21b(%rdx), %al
testq %rdi, %rdi
je 0xd703
testb %al, %al
jne 0xd707
movb $0x1, 0x14d(%rbx)
movq %rbx, %rdx
callq 0xd74c
movb $0x0, 0x14d(%rbx)
movq 0x158(%rbx), %rax
cmpq 0x150(%rbx), %rax
je 0xd707
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 0x71e0
leaq 0xc0(%rbx), %rdi
movq %r15, %rsi
callq 0xd75a
movq 0x150(%rbx), %rax
movq 0x158(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
incq %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0xd707
andl $0x0, (%rax,%rdx,4)
incq %rdx
jmp 0xd6f5
testb %al, %al
je 0xd70d
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%r14), %rsi
leaq 0xd8(%rbx), %r14
leaq 0xf8(%rbx), %rdi
callq 0x71e0
cvtsi2sdl 0x148(%rbx), %xmm0
movsd %xmm0, 0x118(%rbx)
addq $0xc0, %rbx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xd75a
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x13017
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x13056
cmpq $0x0, 0x18(%r15)
je 0x1304f
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x1304f
movb $0x1, 0x90(%rbx)
movq %r14, %rsi
movq %rbx, %rdx
callq 0x13e7a
movq 0x18(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x12ff0
movb $0x0, 0x90(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1465c
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1463a
movq 0x498(%rbx), %rax
incl -0x4(%rax)
movq 0x10(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1579e
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
testq %rax, %rax
setne %dl
movq 0x18(%r15), %rdi
movq %rcx, %rsi
orq %rdi, %rsi
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0x1981b
testq %rax, %rax
je 0x19800
testq %rcx, %rcx
je 0x19843
testq %rdi, %rdi
jne 0x19843
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xccce
jmp 0x19815
testq %rcx, %rcx
je 0x1982e
testq %rdi, %rdi
je 0x19843
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1984a
movq 0x10(%r15), %r15
jmp 0x197bc
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xccce
testq %rdi, %rdi
je 0x19843
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1984a
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: 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 0x1988e
cmpb $0x1, 0x39ffa(%rip)     # 0x53858
jne 0x1988e
leaq 0x1433e(%rip), %rsi     # 0x2dba5
callq 0x820e
testb %al, %al
jne 0x19884
movq 0x8(%rbx), %rdi
leaq 0x14330(%rip), %rsi     # 0x2dbab
callq 0x820e
testb %al, %al
je 0x1988e
movl $0x4, 0x39fce(%rip)     # 0x5385c
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl 0x20(%rdx), %eax
incl %eax
movq 0x10(%rdi), %rcx
movq 0x8(%rdi), %rdi
movq %rdi, %rsi
orq %rcx, %rsi
je 0x19bd2
testq %rdi, %rdi
je 0x19bdf
testq %rcx, %rcx
jne 0x19bdf
movl %eax, 0x20(%rdx)
movl $0x4, 0x258(%rdx)
jmp 0x19ba7
movl %eax, 0x20(%rdx)
movl $0x4, 0x258(%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
andl $0x0, 0x2a8(%rdx)
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x1a246
pushq %rbx
movq %rdx, %rbx
callq 0x1a282
movl 0x2a8(%rbx), %eax
movl %eax, 0x418(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1a2a4
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1a282
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x1a2c6
movb $0x1, 0x4a8(%rbx)
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1a2cc
movb $0x0, 0x4a8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: 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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x1a2ee
movq %r14, %rsi
movq %rbx, %rdx
callq 0xc8fa
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x1a30e
addl $0x4, 0x2a8(%rbx)
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xc9d4
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: 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 0x1a8be
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1a89c
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x1a8d7
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xc830
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: 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 0x1a934
cmpb $0x0, 0x21b(%rbx)
je 0x1a94a
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x1a955
movq %r14, %rsi
movq %rbx, %rdx
callq 0xca84
jmp 0x1a955
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1a9d2
cmpb $0x0, 0x3d1(%rbx)
je 0x1a964
popq %rbx
popq %r14
popq %r15
retq
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0x1a97d
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1ae7e
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x1a98f
cmpb $0x0, 0x21b(%rbx)
je 0x1a9a8
movq 0x28(%r15), %rdi
testq %rdi, %rdi
je 0x1a9b8
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1bb4e
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1aea0
movq 0x30(%r15), %rdi
testq %rdi, %rdi
je 0x1a95e
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1c172
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x1ae9f
pushq %rbx
movq %rdx, %rbx
movb $0x1, 0x1d1(%rdx)
callq 0xe864
movb $0x0, 0x1d1(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1ca2c
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1ca0a
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x1ca45
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1ca4c
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: 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 0x1d24c
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1d22a
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x1d265
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1cf96
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH04_Expressions/examples/shift-prec.cc
// Function: main
int main()
{
	int grade = 75;
	cout << ((grade < 60) ?  "fail" : "pass"); // prints pass or fail
	cout << endl;

	cout << (grade < 60) ?  "fail" : "pass";   // prints 1 or 0!
	cout << endl;

	// previous expression is equivalent to the following
	cout << (grade < 60);    // prints 1 or 0
	cout ?  "fail" : "pass"; // test cout and then yield one of the two literals
	                         // depending on whether cout is true or false
	cout << endl;
	int i = 15, j = 20;
	cout << (i < j ? i : j);  // ok: prints smaller of i and j
	cout << endl;

	cout << (i < j) ? i : j;  // ok: prints 1 or 0!
	cout << endl;
	
	// previous expression is equivalent to the following
	cout << (i < j); // prints 1 or 0
	cout ? i : j;    // test cout and then evaluate i or j
	                 // depending on whether cout evaluates to true or false
	cout << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x2dfe(%rip), %rbx      # 0x3fd8
leaq 0xe23(%rip), %rsi       # 0x2004
movq %rbx, %rdi
callq 0x1050
movq %rbx, %rdi
callq 0x1030
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1070
movq %rbx, %rdi
callq 0x1030
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1070
movq %rbx, %rdi
callq 0x1030
pushq $0xf
popq %rsi
movq %rbx, %rdi
callq 0x1080
movq %rbx, %rdi
callq 0x1030
pushq $0x1
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1070
movq %rbx, %rdi
callq 0x1030
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1070
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rdx
movq %rdi, %rsi
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
callq 0x33ec
movzbl 0x10(%rbx), %r12d
testw %r12w, %r12w
je 0x25ee
leaq -0x30(%rbp), %r14
movq %rbx, (%r14)
leaq 0x57fe(%rip), %rbx      # 0x7d88
pushq $0x28
popq %r13
cmpq $0x8, %r13
je 0x25f2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x33b2
testb %al, %al
jne 0x262c
leaq 0x8(%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x33b2
testb %al, %al
jne 0x264f
leaq 0x10(%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x33b2
testb %al, %al
jne 0x264f
leaq 0x18(%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x33b2
testb %al, %al
jne 0x264f
addq $0x20, %rbx
addq $-0x20, %r13
jmp 0x258e
xorl %eax, %eax
jmp 0x2667
sarq $0x3, %r13
cmpq $0x1, %r13
je 0x2635
cmpq $0x2, %r13
je 0x261c
cmpq $0x3, %r13
jne 0x2648
leaq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x33b2
testb %al, %al
jne 0x262c
addq $0x8, %rbx
leaq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x33b2
testb %al, %al
je 0x2631
movq %rbx, %r15
jmp 0x264f
addq $0x8, %rbx
leaq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x33b2
movq %rbx, %r15
testb %al, %al
jne 0x264f
leaq 0x5761(%rip), %r15      # 0x7db0
leaq 0x575a(%rip), %rcx      # 0x7db0
xorl %eax, %eax
cmpq %rcx, %r15
sete %al
movzwl %r12w, %ecx
shll $0x8, %ecx
orl %ecx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x6
popq %rdx
callq 0x22d0
leaq -0x1b0(%rbp), %rdi
callq 0x2060
testb %al, %al
je 0x27ab
leaq -0x228(%rbp), %rdi
callq 0x2310
movq %rax, %r15
leaq -0x228(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2260
leaq -0x19(%rbp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3452
movq (%rbx), %rsi
leaq -0x228(%rbp), %rdi
movq %r15, %rdx
callq 0x2220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2816
leaq -0x228(%rbp), %rdi
callq 0x2080
movq %rbx, %rax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x583e(%rip), %rdi      # 0x7ff0
leaq 0x286d(%rip), %rsi      # 0x5026
callq 0x21b0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2190
leaq 0x2adf(%rip), %rsi      # 0x52af
movq %rax, %rdi
callq 0x21b0
movq 0x5811(%rip), %rdi      # 0x7ff0
leaq 0x2863(%rip), %rsi      # 0x5049
callq 0x21b0
movq %rax, %rbx
callq 0x2030
movl (%rax), %edi
callq 0x20a0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x21b0
leaq 0x2aa3(%rip), %rsi      # 0x52af
movq %rax, %rdi
callq 0x21b0
jmp 0x287f
movq 0x57d3(%rip), %rdi      # 0x7ff0
leaq 0x282d(%rip), %rsi      # 0x5051
callq 0x21b0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2190
leaq 0x2a74(%rip), %rsi      # 0x52af
movq %rax, %rdi
callq 0x21b0
movq 0x57a6(%rip), %rdi      # 0x7ff0
leaq 0x27f8(%rip), %rsi      # 0x5049
callq 0x21b0
movq %rax, %r14
callq 0x2030
movl (%rax), %edi
callq 0x20a0
movq %r14, %rdi
movq %rax, %rsi
callq 0x21b0
leaq 0x2a38(%rip), %rsi      # 0x52af
movq %rax, %rdi
callq 0x21b0
pushq $0x1
popq %rdi
callq 0x2200
jmp 0x2898
jmp 0x2898
movq %rax, %r14
movq %rbx, %rdi
callq 0x43f6
jmp 0x289b
movq %rax, %r14
leaq -0x228(%rbp), %rdi
callq 0x2080
movq %r14, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x18, %rsp
movq %rdx, %r15
movq %rdi, %r14
movb $0x0, 0x10(%rdi)
leaq 0x18(%rdi), %rax
movq %rax, -0x30(%rbp)
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
movslq %esi, %rbx
andq $0x0, 0x60(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
pushq $0x1
popq %r12
cmpq %rbx, %r12
jge 0x3a71
movq (%r15,%r12,8), %r13
movq %r13, %rdi
callq 0x20e0
movq %rax, -0x40(%rbp)
movq %r13, -0x38(%rbp)
movq %r14, %rdi
leaq -0x40(%rbp), %rsi
callq 0x3aaa
incq %r12
jmp 0x3a47
movq %r14, %rdi
callq 0x3afe
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a8a
movq %rax, %r15
addq $0x50, %r14
movq %r14, %rdi
callq 0x41fc
movq -0x30(%rbp), %rdi
callq 0x421e
movq %r15, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3afe
movups (%r14), %xmm0
movups %xmm0, (%rbx)
cmpb $0x0, 0x10(%rbx)
jne 0x3b69
movb $0x1, 0x10(%rbx)
pushq $0x2d
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3c08
addq %rax, 0x8(%rbx)
subq %rax, (%rbx)
pushq $0x3d
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3c32
cmpq $-0x1, %rax
je 0x3bba
movq (%rbx), %rcx
movq %rax, %rdx
incq %rdx
subq %rdx, %rcx
addq 0x8(%rbx), %rdx
movq %rax, (%rbx)
leaq -0x28(%rbp), %rsi
movq %rcx, (%rsi)
movq %rdx, 0x8(%rsi)
movb $0x1, 0x10(%rsi)
movq %rbx, %rdi
callq 0x3bc4
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3bf3
leaq 0x18(%rbx), %rdi
movq %rbx, %rsi
callq 0x3e58
cmpb $0x1, 0x10(%rbx)
jne 0x3bec
movb $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addq $0x50, %rbx
movq %rbx, %rdi
movq %rdx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3ca4
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rsi, %rdx
movq %rdi, %rsi
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
callq 0x33ec
cmpb $0x1, 0x10(%rbx)
jne 0x4569
leaq -0x30(%rbp), %rbx
leaq -0x48(%rbp), %rsi
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0x3420
leaq -0x1c8(%rbp), %rdi
pushq $0x8
popq %rdx
movq %rbx, %rsi
callq 0x22f0
leaq -0x1c8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x2320
leaq -0x1c8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movb -0x1a8(%rbp,%rax), %bl
callq 0x2110
leaq -0x30(%rbp), %rdi
callq 0x2100
testb $0x5, %bl
je 0x4575
xorl %eax, %eax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %rbp
retq
movl -0x10(%rbp), %eax
btsq $0x20, %rax
jmp 0x456b
movq %rax, %rbx
leaq -0x1c8(%rbp), %rdi
callq 0x2110
jmp 0x4593
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/sonnyit[P]profiler/profiler.cpp
// Function: Profiler::getInstance()
Profiler& Profiler::getInstance() {
    static Profiler instance;
    if (_destroyed) {
        throw std::runtime_error("Profiler: Dead reference access");
    }
    return instance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movb 0x3d89(%rip), %al       # 0x61c0
testb %al, %al
je 0x2454
cmpb $0x1, 0x3d1e(%rip)      # 0x6160
je 0x24cb
leaq 0x3d19(%rip), %rax      # 0x6168
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3d65(%rip), %rdi      # 0x61c0
callq 0x2270
testl %eax, %eax
je 0x243b
andl $0x0, 0x3d05(%rip)      # 0x6170
andq $0x0, 0x3d05(%rip)      # 0x6178
leaq 0x3cee(%rip), %rsi      # 0x6168
leaq 0x3cef(%rip), %rax      # 0x6170
movq %rax, 0x3cf8(%rip)      # 0x6180
movq %rax, 0x3cf9(%rip)      # 0x6188
xorps %xmm0, %xmm0
movups %xmm0, 0x3cf7(%rip)     # 0x6190
movups %xmm0, 0x3d00(%rip)     # 0x61a0
movups %xmm0, 0x3d09(%rip)     # 0x61b0
leaq 0x12a(%rip), %rdi       # 0x25d8
leaq 0x3c93(%rip), %rdx      # 0x6148
callq 0x2170
leaq 0x3cff(%rip), %rdi      # 0x61c0
callq 0x20f0
jmp 0x243b
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x1b27(%rip), %rsi      # 0x4004
movq %rax, %rdi
callq 0x2090
movq 0x3b04(%rip), %rsi      # 0x5ff0
movq 0x3ad5(%rip), %rdx      # 0x5fc8
movq %rbx, %rdi
callq 0x2250
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/sonnyit[P]profiler/profiler.cpp
// Function: Profiler::addProfiler(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long)
void Profiler::addProfiler(const std::string& task_name, long ms) {
    lock_guard<mutex> lock(_mutex);
    if (_map_table.find(task_name) != _map_table.end()) {
        ++_map_table[task_name].count;
        _map_table[task_name].time_pass += ms;
        _map_table[task_name].last_time_pass = ms;
    } else {
        ProfilerTask task;
        ++task.count;
        task.time_pass += ms;
        task.last_time_pass = ms;
        _map_table[task_name] = task;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x30(%rdi), %rbx
movq %rbx, %rdi
callq 0x27d8
movq %r12, %rdi
movq %r15, %rsi
callq 0x27ee
leaq 0x8(%r12), %rcx
cmpq %rcx, %rax
je 0x256d
movq %r12, %rdi
movq %r15, %rsi
callq 0x26f6
incq 0x8(%rax)
movq %r12, %rdi
movq %r15, %rsi
callq 0x26f6
addq %r14, (%rax)
movq %r12, %rdi
movq %r15, %rsi
callq 0x26f6
jmp 0x2583
movq %r12, %rdi
movq %r15, %rsi
callq 0x26f6
movq %r14, (%rax)
movq $0x1, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2150
jmp 0x259b
jmp 0x259b
movq %rax, %r14
movq %rbx, %rdi
callq 0x2150
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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 0x27d8
movq %r15, %rdi
movq %r14, %rsi
callq 0x27ee
leaq 0x8(%r15), %rcx
cmpq %rcx, %rax
je 0x2630
movq %r15, %rdi
movq %r14, %rsi
callq 0x26f6
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2150
jmp 0x2644
movq %rax, %r14
movq %rbx, %rdi
callq 0x2150
movq %r14, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/sonnyit[P]profiler/profiler.cpp
// Function: Profiler::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
ProfilerTask Profiler::get(const std::string& task_name) {
    lock_guard<mutex> lock(_mutex);
    if (_map_table.find(task_name) != _map_table.end()) {
        return _map_table[task_name];
    }
    return ProfilerTask();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x30(%rsi), %rbx
movq %rbx, %rdi
callq 0x27d8
movq %r12, %rdi
movq %r15, %rsi
callq 0x27ee
leaq 0x8(%r12), %rcx
cmpq %rcx, %rax
je 0x26b3
movq %r12, %rdi
movq %r15, %rsi
callq 0x26f6
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r14)
movups (%rax), %xmm0
movups %xmm0, (%r14)
jmp 0x26bf
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq %rbx, %rdi
callq 0x2150
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26d5
movq %rax, %r14
movq %rbx, %rdi
callq 0x2150
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/sonnyit[P]profiler/example.cpp
// Function: func1()
void func1() {
  PROFILER_TASK(func1);

  float f = 0;
  for (int i = 0; i < 100000; ++i) {
    f += cosf(static_cast<float>(rand()));
  }
  cout << "fun1 output: " << fixed << setprecision(2) << f << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
leaq 0x13d5(%rip), %rsi      # 0x4025
leaq -0x30(%rbp), %rdi
leaq -0xd(%rbp), %rdx
callq 0x20a0
leaq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x23bc
leaq -0x30(%rbp), %rdi
callq 0x20c0
xorps %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
movl $0x186a0, %ebx          # imm = 0x186A0
subl $0x1, %ebx
jb 0x2ca3
callq 0x2050
cvtsi2ss %eax, %xmm0
callq 0x2130
movss -0xc(%rbp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, -0xc(%rbp)
jmp 0x2c80
movq 0x3326(%rip), %rdi      # 0x5fd0
leaq 0x137a(%rip), %rsi      # 0x402b
callq 0x21c0
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movl $0xfffffefb, %esi       # imm = 0xFFFFFEFB
andl 0x18(%rax,%rdx), %esi
orl $0x4, %esi
movl %esi, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
movq $0x2, 0x8(%rax,%rcx)
movq %rax, %rdi
movss -0xc(%rbp), %xmm0
callq 0x2140
movq %rax, %rdi
callq 0x20d0
leaq -0x58(%rbp), %rdi
callq 0x23e0
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x20c0
jmp 0x2d1e
movq %rax, %rbx
jmp 0x2d1e
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x23e0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/sonnyit[P]profiler/example.cpp
// Function: func2()
void func2() {
  PROFILER_TASK(func2);

  float f = 0;
  for (int i = 0; i < 500000; ++i) {
    f += cosf(static_cast<float>(rand()));
  }
  cout << "fun2 output: " << fixed << setprecision(2) << f << endl;

  func1();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
leaq 0x1303(%rip), %rsi      # 0x4039
leaq -0x30(%rbp), %rdi
leaq -0xd(%rbp), %rdx
callq 0x20a0
leaq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x23bc
leaq -0x30(%rbp), %rdi
callq 0x20c0
xorps %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
movl $0x7a120, %ebx          # imm = 0x7A120
subl $0x1, %ebx
jb 0x2d89
callq 0x2050
cvtsi2ss %eax, %xmm0
callq 0x2130
movss -0xc(%rbp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, -0xc(%rbp)
jmp 0x2d66
movq 0x3240(%rip), %rdi      # 0x5fd0
leaq 0x12a8(%rip), %rsi      # 0x403f
callq 0x21c0
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movl $0xfffffefb, %esi       # imm = 0xFFFFFEFB
andl 0x18(%rax,%rdx), %esi
orl $0x4, %esi
movl %esi, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
movq $0x2, 0x8(%rax,%rcx)
movq %rax, %rdi
movss -0xc(%rbp), %xmm0
callq 0x2140
movq %rax, %rdi
callq 0x20d0
callq 0x2c40
leaq -0x58(%rbp), %rdi
callq 0x23e0
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x20c0
jmp 0x2e09
movq %rax, %rbx
jmp 0x2e09
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x23e0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH02_VariablesAndBasicTypes/examples/decl-ex.cc
// Function: main
int main()
{
	int a = 0;
	decltype(a) c = a;   // c is an int
	decltype((a)) d = a; // d is a reference to a
	++c;                 // increments c, a (and d) unchanged
	cout << "a: " << a << " c: " << c << " d: " << d << endl;
	++d;                 // increments a through the reference d
	cout << "a: " << a << " c: " << c << " d: " << d << endl;
	
	int A = 0, B = 0;
	decltype((A)) C = A;   // C is a reference to A
	decltype(A = B) D = A; // D is also a reference to A
	++C;
	cout << "A: " << A << " C: " << C << " D: " << D << endl;
	++D;
	cout << "A: " << A << " C: " << C << " D: " << D << endl;
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x2e07(%rip), %rbx      # 0x3fd8
leaq 0xe2c(%rip), %r15       # 0x2004
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1050
movq %rax, %rdi
xorl %esi, %esi
callq 0x1070
leaq 0xe14(%rip), %r12       # 0x2008
movq %rax, %rdi
movq %r12, %rsi
callq 0x1050
pushq $0x1
popq %r14
movq %rax, %rdi
movl %r14d, %esi
callq 0x1070
leaq 0xdf8(%rip), %r13       # 0x200d
movq %rax, %rdi
movq %r13, %rsi
callq 0x1050
movq %rax, %rdi
xorl %esi, %esi
callq 0x1070
movq %rax, %rdi
callq 0x1030
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1050
movq %rax, %rdi
movl %r14d, %esi
callq 0x1070
movq %rax, %rdi
movq %r12, %rsi
callq 0x1050
movq %rax, %rdi
movl %r14d, %esi
callq 0x1070
movq %rax, %rdi
movq %r13, %rsi
callq 0x1050
movq %rax, %rdi
movl %r14d, %esi
callq 0x1070
movq %rax, %rdi
callq 0x1030
leaq 0xd8f(%rip), %r15       # 0x2012
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1050
movq %rax, %rdi
movl %r14d, %esi
callq 0x1070
leaq 0xd76(%rip), %r12       # 0x2016
movq %rax, %rdi
movq %r12, %rsi
callq 0x1050
movq %rax, %rdi
movl %r14d, %esi
callq 0x1070
leaq 0xd5e(%rip), %r13       # 0x201b
movq %rax, %rdi
movq %r13, %rsi
callq 0x1050
movq %rax, %rdi
movl %r14d, %esi
callq 0x1070
movq %rax, %rdi
callq 0x1030
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1050
pushq $0x2
popq %rbx
movq %rax, %rdi
movl %ebx, %esi
callq 0x1070
movq %rax, %rdi
movq %r12, %rsi
callq 0x1050
movq %rax, %rdi
movl %ebx, %esi
callq 0x1070
movq %rax, %rdi
movq %r13, %rsi
callq 0x1050
movq %rax, %rdi
movl %ebx, %esi
callq 0x1070
movq %rax, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ahmadsalim[P]qsort-inline/./qsort-inline.h
// Function: swapfunc(char*, char*, int, int)
static inline void
swapfunc(char *a, char *b, int n, int swaptype)
{
  if(swaptype <= 1) 
    swapcode(long, a, b, n)
  else
    swapcode(char, a, b, n)
}

// Assembly:
cmpl $0x1, %ecx
jg 0x1537
shrl $0x3, %edx
incq %rdx
xorl %eax, %eax
movq (%rdi,%rax), %rcx
movq (%rsi,%rax), %r8
movq %r8, (%rdi,%rax)
movq %rcx, (%rsi,%rax)
addq $0x8, %rax
decq %rdx
cmpq $0x1, %rdx
ja 0x1518
jmp 0x1558
movl %edx, %eax
incq %rax
xorl %ecx, %ecx
movb (%rdi,%rcx), %dl
movb (%rsi,%rcx), %r8b
movb %r8b, (%rdi,%rcx)
movb %dl, (%rsi,%rcx)
decq %rax
incq %rcx
cmpq $0x1, %rax
ja 0x153e
retq
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/intern.cc
// Function: Intern::intern(char const*)
Symbol intern(const char * s)
	{
		for (int i = 0; i < interns.size; i++) {
			if (strcmp(s, interns[i]) == 0) {
				return interns[i];
			}
		}
		interns.push(strdup(s));
		return interns[interns.size - 1];
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $-0x1
popq %rbx
leaq 0xdbce(%rip), %r15      # 0xf198
incq %rbx
cmpq %rbx, 0xdbcc(%rip)      # 0xf1a0
jbe 0x15f2
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4838
movq (%rax), %rsi
movq %r14, %rdi
callq 0x1160
testl %eax, %eax
jne 0x15ca
jmp 0x1613
movq %r14, %rdi
callq 0x11d0
leaq 0xdb97(%rip), %rdi      # 0xf198
movq %rax, %rsi
callq 0x486a
movq 0xdb90(%rip), %rbx      # 0xf1a0
decq %rbx
leaq 0xdb7e(%rip), %rdi      # 0xf198
movq %rbx, %rsi
callq 0x4838
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/utility.cc
// Function: load_string_from_file(char const*)
char * load_string_from_file(const char * path)
{
	FILE * file = fopen(path, "r");
	if (file == NULL) return NULL;
	defer { fclose(file); };
	
	int file_len = 0;
	while (fgetc(file) != EOF) file_len++;
	char * str = (char*) Global_Alloc::alloc(file_len + 1);
	str[file_len] = '\0';
	fseek(file, 0, SEEK_SET);
	for (int i = 0; i < file_len; i++) str[i] = fgetc(file);

	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x8054(%rip), %rsi      # 0x96a4
callq 0x1120
movq %rax, -0x20(%rbp)
testq %rax, %rax
je 0x16be
leaq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
pushq $-0x1
popq %r14
movq -0x20(%rbp), %rdi
callq 0x1190
incq %r14
cmpl $-0x1, %eax
jne 0x166a
leaq 0x1(%r14), %rdi
callq 0x138d
movq %rax, %rbx
movb $0x0, (%rax,%r14)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1110
movq %rbx, %r15
subq $0x1, %r14
jb 0x16b3
movq -0x20(%rbp), %rdi
callq 0x1190
movb %al, (%r15)
incq %r15
jmp 0x169c
leaq -0x28(%rbp), %rdi
callq 0x16e2
jmp 0x16c0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x16e2
movq %rbx, %rdi
callq 0x11c0
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/utility.cc
// Function: itoa(int)
char * itoa(int integer)
{
	size_t size = snprintf(NULL, 0, "%d", integer);
	char * buf = (char*) malloc(sizeof(char) * (size + 1));
	sprintf(buf, "%d", integer);
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x85a5(%rip), %r14      # 0x9caa
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x11a0
movslq %eax, %rdi
incq %rdi
callq 0x1200
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1050
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/error.cc
// Function: error(char const*, ...)
void error(const char * fmt, ...)
{
	va_list args;
	va_start(args, fmt);

	fprintf(stderr, RED(BOLD("encountered error")) ":\n");
	vfprintf(stderr, fmt, args);
	printf("\n");

	va_end(args);
	abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
leaq -0xe0(%rbp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x18d4
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
leaq -0x30(%rbp), %r14
movq %rdi, 0x10(%r14)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movq 0xd6e0(%rip), %r15      # 0xefd8
movq (%r15), %rcx
leaq 0x79d5(%rip), %rdi      # 0x92d7
pushq $0x24
popq %rsi
pushq $0x1
popq %rdx
callq 0x11e0
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1140
pushq $0xa
popq %rdi
callq 0x1150
callq 0x10c0
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/error.cc
// Function: fatal(char const*, ...)
void fatal(const char * fmt, ...)
{
	va_list args;
	va_start(args, fmt);

	fprintf(stderr, RED(BOLD("encountered error")) ":\n");
	vfprintf(stderr, fmt, args);
	printf("\n");

	va_end(args);
	//exit(1);
	abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
leaq -0xe0(%rbp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x1983
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
leaq -0x30(%rbp), %r14
movq %rdi, 0x10(%r14)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movq 0xd631(%rip), %r15      # 0xefd8
movq (%r15), %rcx
leaq 0x7926(%rip), %rdi      # 0x92d7
pushq $0x24
popq %rsi
pushq $0x1
popq %rdx
callq 0x11e0
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1140
pushq $0xa
popq %rdi
callq 0x1150
callq 0x10c0