LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf310
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf53a
cmpb $0x1, 0x1d0(%rbx)
jne 0xf30a
leaq 0x170(%rbx), %rdi
leaq 0x188(%rbx), %rsi
callq 0xf608
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 0xf33c
testq %rdi, %rdi
sete %cl
movq 0x10(%r15), %rax
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xf35b
movq %rax, %rdi
jmp 0xf37a
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf2b0
movq 0x8(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xf53a
testq %rdi, %rdi
sete %cl
testq %rax, %rax
sete %al
orb %cl, %al
jne 0xf30a
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf2b0
movq 0x10(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xf632
// File: /workspace/github_cpp_makefile_star2_O1/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 0x106b0
leaq 0x2883f(%rip), %rsi     # 0x37c1e
leaq 0x8(%rsp), %rdi
movq %r12, %rdx
callq 0x107e2
leaq 0x460(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0xc5f0
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0xf418
cmpq $0x0, 0x8(%r15)
jne 0xf418
movq %r14, %rsi
movq %rbx, %rdx
callq 0x21f38
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0xf433
cmpq $0x0, 0x10(%r15)
jne 0xf433
movq %r14, %rsi
movq %rbx, %rdx
callq 0x21f7a
cmpq $0x0, 0x8(%r15)
je 0xf45d
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0xf45d
movq %r14, %rsi
movq %rbx, %rdx
callq 0x21f38
movq 0x8(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x21f7a
movq 0x468(%rbx), %rax
cmpq 0x460(%rbx), %rax
je 0xf48c
leaq -0x20(%rax), %rcx
movq %rcx, 0x468(%rbx)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0xf4d2
callq 0x72e0
jmp 0xf4d2
movq 0x36b1d(%rip), %rbx     # 0x45fb0
leaq 0x2878a(%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 0x36aeb(%rip), %rdi     # 0x45fb0
callq 0x7040
movq %rax, %rdi
callq 0x7220
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf4e5
callq 0x72e0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf4f8
callq 0x72e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0xf51f
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf51f
callq 0x72e0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf532
callq 0x72e0
movq %rbx, %rdi
callq 0x75f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf5a0
movq %rdx, %rbx
leaq 0x280d1(%rip), %rsi     # 0x37625
callq 0x70c0
testl %eax, %eax
je 0xf5a8
movq 0x8(%r14), %rdi
leaq 0x280c4(%rip), %rsi     # 0x3762c
callq 0x70c0
testl %eax, %eax
je 0xf5bf
movq 0x8(%r14), %rdi
leaq 0x280b7(%rip), %rsi     # 0x37633
callq 0x70c0
testl %eax, %eax
je 0xf5eb
movq 0x8(%r14), %rdi
leaq 0x280ac(%rip), %rsi     # 0x3763c
callq 0x70c0
testl %eax, %eax
jne 0xf5a0
movb $0x1, 0x1d0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x2d8(%rbx), %rdx
addq $0x2d0, %rbx            # imm = 0x2D0
leaq 0x28068(%rip), %rcx     # 0x37625
jmp 0xf5d4
movq 0x2d8(%rbx), %rdx
addq $0x2d0, %rbx            # imm = 0x2D0
leaq 0x28058(%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 0x28033(%rip), %rcx     # 0x37633
movl $0x8, %r8d
jmp 0xf5da
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1003a
cmpq $0x0, 0x8(%r15)
je 0x1008e
cmpb $0x1, 0x218(%rbx)
jne 0x10058
leaq 0x220(%rbx), %rsi
leaq 0xd8(%rbx), %rdi
callq 0x71c0
jmp 0x1007a
leaq 0xd8(%rbx), %rdi
movq 0xe0(%rbx), %rdx
leaq 0x275f1(%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 0x1011e
leaq 0x260(%rbx), %rdi
callq 0x71c0
leaq 0x2b0(%rbx), %rdi
movq 0x2b8(%rbx), %rdx
leaq 0x280dd(%rip), %rcx     # 0x3818c
movl $0x3, %r8d
xorl %esi, %esi
callq 0x7520
movl $0x4, 0x258(%rbx)
cmpb $0x1, 0x218(%rbx)
jne 0x100e4
leaq 0x220(%rbx), %rsi
leaq 0x288(%rbx), %rdi
callq 0x71c0
jmp 0x10106
leaq 0x288(%rbx), %rdi
movq 0x290(%rbx), %rdx
leaq 0x27565(%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_O1/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 0x10149
cmpb $0x0, 0x21b(%rbx)
jne 0x10149
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1011e
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x1016c
cmpb $0x0, 0x21b(%rbx)
jne 0x1016c
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10172
incl 0x148(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
testq %rax, %rax
je 0x10198
cmpb $0x0, 0x21b(%rbx)
je 0x101e3
testq %rax, %rax
jne 0x1026f
cmpb $0x0, 0x21b(%rbx)
jne 0x1026f
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 0x10276
movb $0x1, 0x14d(%rbx)
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x101fb
movq %rbx, %rdx
callq 0x102a0
movb $0x0, 0x14d(%rbx)
movq 0x158(%rbx), %rax
cmpq 0x150(%rbx), %rax
je 0x1026f
movl -0x4(%rax), %ecx
movl %ecx, 0x148(%rbx)
cvtsi2sdl -0x4(%rax), %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 0x10276
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
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1777d
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x177c4
cmpq $0x0, 0x18(%r15)
je 0x177be
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x177be
movb $0x1, 0x90(%rbx)
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x177a8
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2092e
movq 0x18(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x17756
movb $0x0, 0x90(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1933c
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1931a
movq 0x498(%rbx), %rax
incl -0x4(%rax)
movq 0x10(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1aaac
// File: /workspace/github_cpp_makefile_star2_O1/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 0x209b5
testq %rdi, %rdi
sete %dl
testq %rax, %rax
setne %sil
testq %rcx, %rcx
setne %r8b
andb %sil, %r8b
andb %dl, %r8b
cmpb $0x1, %r8b
jne 0x20995
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf632
movq 0x10(%r15), %r15
jmp 0x2093c
testq %rax, %rax
jne 0x209c8
testq %rcx, %rcx
je 0x209c8
testq %rdi, %rdi
je 0x209c8
movq %r14, %rsi
movq %rbx, %rdx
callq 0x209ee
movq 0x10(%r15), %r15
jmp 0x2093c
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xf632
testq %rdi, %rdi
sete %dl
orq %rcx, %rax
setne %al
orb %dl, %al
je 0x209de
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x209ee
// File: /workspace/github_cpp_makefile_star2_O1/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 0x20a32
cmpb $0x1, 0x39e56(%rip)     # 0x5a858
jne 0x20a32
leaq 0x17190(%rip), %rsi     # 0x37b9b
callq 0x70c0
testl %eax, %eax
je 0x20a28
movq 0x8(%rbx), %rdi
leaq 0x17182(%rip), %rsi     # 0x37ba1
callq 0x70c0
testl %eax, %eax
jne 0x20a32
movl $0x4, 0x39e2a(%rip)     # 0x5a85c
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10(%rdi), %rax
movq 0x8(%rdi), %rdi
movq %rdi, %rcx
orq %rax, %rcx
je 0x20e3b
testq %rdi, %rdi
je 0x20e48
testq %rax, %rax
jne 0x20e48
incl 0x20(%rdx)
movl $0x4, 0x258(%rdx)
jmp 0x20e12
incl 0x20(%rdx)
movl $0x4, 0x258(%rdx)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x216ba
movq %r14, %rsi
movq %rbx, %rdx
callq 0x21698
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x21777
movb $0x1, 0x4a8(%rbx)
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x216e2
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf2b0
movq 0x10(%r15), %r15
testq %r15, %r15
je 0x21770
addl $0x4, 0x2a8(%rbx)
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x21751
cmpq $0x0, 0x10(%r15)
je 0x21751
movb $0x1, 0x2f4(%rbx)
movq %r14, %rsi
movq %rbx, %rdx
callq 0x20e12
movl 0x20(%rbx), %eax
movl %eax, 0x2f8(%rbx)
movl %eax, 0x2fc(%rbx)
movq 0x10(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x20e4a
movl $0x0, 0x20(%rbx)
movb $0x0, 0x2f4(%rbx)
movq $0x0, 0x2f8(%rbx)
jmp 0x21770
testq %rdi, %rdi
setne %al
movq 0x10(%r15), %rdi
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x21770
movq %r14, %rsi
movq %rbx, %rdx
callq 0x20e4a
movb $0x0, 0x4a8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: 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 0x21f5a
movq %r14, %rsi
movq %rbx, %rdx
callq 0x21f38
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x21f73
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xf1b0
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: 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 0x21fd0
cmpb $0x0, 0x21b(%rbx)
je 0x21fe6
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x21ff1
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf3b4
jmp 0x21ff1
movq %r14, %rsi
movq %rbx, %rdx
callq 0x22080
cmpb $0x0, 0x3d1(%rbx)
jne 0x22025
movq 0x18(%r15), %rax
testq %rax, %rax
je 0x2202b
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x22025
movb $0x1, 0x1d1(%rbx)
movq %r14, %rsi
movq %rbx, %rdx
callq 0x11e3c
movb $0x0, 0x1d1(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x2203d
cmpb $0x0, 0x21b(%rbx)
je 0x22056
movq 0x28(%r15), %rdi
testq %rdi, %rdi
je 0x22066
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x23b50
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x226f0
movq 0x30(%r15), %rdi
testq %rdi, %rdi
je 0x22025
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2431e
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x25006
movq %r14, %rsi
movq %rbx, %rdx
callq 0x24fe4
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x2501f
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x25026
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: 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 0x25d2c
movq %r14, %rsi
movq %rbx, %rdx
callq 0x25d0a
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x25d45
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x259a4
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movq 0x2ddf(%rip), %rbx      # 0x3fd8
leaq 0xe04(%rip), %rsi       # 0x2004
movl $0x4, %edx
movq %rbx, %rdi
callq 0x1070
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1090
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1090
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq %rbx, %rdi
movl $0xf, %esi
callq 0x10a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1090
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1090
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x28, %rsp
callq 0x3b76
testq %rax, %rax
je 0x25f3
movups 0x18(%rax), %xmm0
movaps %xmm0, -0x30(%rbp)
movb $0x1, %bl
jmp 0x25f5
xorl %ebx, %ebx
movb %bl, -0x20(%rbp)
testb %bl, %bl
je 0x2653
leaq -0x30(%rbp), %rax
leaq -0x10(%rbp), %rdi
movq %rax, (%rdi)
leaq 0x576a(%rip), %rsi      # 0x7d78
callq 0x3a0c
testb %al, %al
jne 0x2653
leaq 0x5762(%rip), %rsi      # 0x7d80
leaq -0x10(%rbp), %rdi
callq 0x3a0c
testb %al, %al
jne 0x2653
leaq 0x5756(%rip), %rsi      # 0x7d88
leaq -0x10(%rbp), %rdi
callq 0x3a0c
testb %al, %al
jne 0x2653
leaq 0x574a(%rip), %rsi      # 0x7d90
leaq -0x10(%rbp), %rdi
callq 0x3a0c
testb %al, %al
je 0x2667
xorl %eax, %eax
movzbl %bl, %ecx
shll $0x8, %ecx
movzwl %ax, %eax
orl %ecx, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
leaq 0x572a(%rip), %rsi      # 0x7d98
leaq -0x10(%rbp), %rdi
callq 0x3a0c
xorb $0x1, %al
movzbl %al, %eax
jmp 0x2655
// File: /workspace/github_cpp_makefile_star2_O1/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 0x27d8
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 0x3a5c
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 0x285e
leaq -0x228(%rbp), %rdi
callq 0x2070
movq %rbx, %rax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x5811(%rip), %rdi      # 0x7ff0
leaq 0x2840(%rip), %rsi      # 0x5026
movl $0x22, %edx
callq 0x21d0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x57f2(%rip), %rdi      # 0x7ff0
callq 0x21d0
leaq 0x2aa5(%rip), %rsi      # 0x52af
movl $0x1, %edx
movq %rax, %rdi
callq 0x21d0
movq 0x57d2(%rip), %rdi      # 0x7ff0
leaq 0x2824(%rip), %rsi      # 0x5049
movl $0x7, %edx
callq 0x21d0
callq 0x2030
movl (%rax), %edi
callq 0x20b0
movq 0x57ae(%rip), %rdi      # 0x7ff0
movq %rax, %rsi
callq 0x2170
leaq 0x2a5e(%rip), %rsi      # 0x52af
movq %rax, %rdi
callq 0x2170
jmp 0x28df
movq 0x578b(%rip), %rdi      # 0x7ff0
leaq 0x27e5(%rip), %rsi      # 0x5051
movl $0x24, %edx
callq 0x21d0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x576c(%rip), %rdi      # 0x7ff0
callq 0x21d0
leaq 0x2a1f(%rip), %rsi      # 0x52af
movl $0x1, %edx
movq %rax, %rdi
callq 0x21d0
movq 0x574c(%rip), %rdi      # 0x7ff0
leaq 0x279e(%rip), %rsi      # 0x5049
movl $0x7, %edx
callq 0x21d0
callq 0x2030
movl (%rax), %edi
callq 0x20b0
movq 0x5728(%rip), %rdi      # 0x7ff0
movq %rax, %rsi
callq 0x2170
leaq 0x29d8(%rip), %rsi      # 0x52af
movq %rax, %rdi
callq 0x2170
movl $0x1, %edi
callq 0x21f0
jmp 0x2906
jmp 0x2906
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2909
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2190
jmp 0x2909
movq %rax, %r14
leaq -0x228(%rbp), %rdi
callq 0x2070
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
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 0x3e21
movq %rdx, %r14
movl %esi, %r13d
movl $0x1, %r15d
movq (%r14,%r15,8), %r12
movq %r12, %rdi
callq 0x20e0
movq %rax, -0x40(%rbp)
movq %r12, -0x38(%rbp)
movq %rbx, %rdi
leaq -0x40(%rbp), %rsi
callq 0x3e74
incq %r15
cmpq %r15, %r13
jne 0x3df9
cmpb $0x1, 0x10(%rbx)
jne 0x3e37
leaq -0x40(%rbp), %rsi
movb $0x0, 0x10(%rsi)
movq %rbx, %rdi
callq 0x3f9a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3e48
movq %rax, %r14
leaq 0x18(%rbx), %r15
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x3e64
movq 0x60(%rbx), %rsi
subq %rdi, %rsi
callq 0x2190
movq %r15, %rdi
callq 0x4434
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpb $0x1, 0x10(%rdi)
jne 0x3ee9
leaq -0x30(%rbp), %rsi
movb $0x0, 0x10(%rsi)
movq %rbx, %rdi
callq 0x3f9a
movups (%r14), %xmm0
movups %xmm0, (%rbx)
cmpb $0x0, 0x10(%rbx)
jne 0x3efa
movb $0x1, 0x10(%rbx)
movq (%rbx), %r14
movq $-0x1, %rcx
movq $-0x1, %rax
testq %r14, %r14
je 0x3f2b
movq 0x8(%rbx), %rdx
xorl %eax, %eax
cmpb $0x2d, (%rdx,%rax)
jne 0x3f2b
incq %rax
cmpq %rax, %r14
jne 0x3f16
movq $-0x1, %rax
movq 0x8(%rbx), %r15
addq %rax, %r15
movq %r15, 0x8(%rbx)
subq %rax, %r14
movq %r14, (%rbx)
je 0x3f60
movq %r15, %rdi
movl $0x3d, %esi
movq %r14, %rdx
callq 0x21b0
movq %rax, %rdx
subq %r15, %rdx
xorl %ecx, %ecx
cmpq $0x1, %rax
sbbq %rcx, %rcx
orq %rdx, %rcx
cmpq $-0x1, %rcx
je 0x3f8e
leaq 0x1(%rcx), %rax
leaq (%r15,%rcx), %rdx
incq %rdx
subq %rax, %r14
movq %rcx, (%rbx)
leaq -0x30(%rbp), %rsi
movq %r14, (%rsi)
movq %rdx, 0x8(%rsi)
movb $0x1, 0x10(%rsi)
movq %rbx, %rdi
callq 0x3f9a
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3fc4
leaq 0x18(%rbx), %rdi
movq %rbx, %rsi
callq 0x4140
cmpb $0x1, 0x10(%rbx)
jne 0x3fd9
movb $0x0, 0x10(%rbx)
jmp 0x3fd9
movq 0x58(%rbx), %rsi
cmpq 0x60(%rbx), %rsi
je 0x3fe0
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 0x3ff2
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3b76
testq %rax, %rax
je 0x46b4
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rsi
jmp 0x46b4
testq %rax, %rax
je 0x473f
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
addq %rsi, %rdx
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x4556
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 0x38b4(%rip), %rsi      # 0x7fc8
callq 0x2240
leaq -0x140(%rbp), %rdi
callq 0x20a0
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x473a
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2190
testb $0x5, %bl
je 0x4745
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x4752
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 0x385d(%rip), %rsi      # 0x7fc8
leaq -0x1b8(%rbp), %rdi
callq 0x2240
leaq -0x140(%rbp), %rdi
callq 0x20a0
jmp 0x4788
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x479d
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3ce9(%rip), %al       # 0x61c0
testb %al, %al
je 0x24f0
cmpb $0x1, 0x3c7e(%rip)      # 0x6160
je 0x24f7
leaq 0x3c7d(%rip), %rax      # 0x6168
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2290
jmp 0x24db
movl $0x10, %edi
callq 0x20b0
movq %rax, %rbx
leaq 0x1af9(%rip), %rsi      # 0x4004
movq %rax, %rdi
callq 0x2090
movq 0x3ad6(%rip), %rsi      # 0x5ff0
movq 0x3aa7(%rip), %rdx      # 0x5fc8
movq %rbx, %rdi
callq 0x2240
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2200
testl %eax, %eax
jne 0x25c9
movq %r12, %rdi
movq %r15, %rsi
callq 0x2900
leaq 0x8(%r12), %rcx
cmpq %rcx, %rax
je 0x259f
movq %r12, %rdi
movq %r15, %rsi
callq 0x2752
incq 0x8(%rax)
movq %r12, %rdi
movq %r15, %rsi
callq 0x2752
addq %r14, (%rax)
movq %r12, %rdi
movq %r15, %rsi
callq 0x2752
jmp 0x25b5
movq %r12, %rdi
movq %r15, %rsi
callq 0x2752
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 0x2130
movl %eax, %edi
callq 0x20d0
jmp 0x25d4
jmp 0x25d4
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2900
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
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2200
testl %eax, %eax
jne 0x2728
movq %r12, %rdi
movq %r15, %rsi
callq 0x2900
leaq 0x8(%r12), %rcx
cmpq %rcx, %rax
je 0x2705
movq %r12, %rdi
movq %r15, %rsi
callq 0x2752
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r14)
movups (%rax), %xmm0
movups %xmm0, (%r14)
jmp 0x2714
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq %rbx, %rdi
callq 0x2130
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x20d0
jmp 0x2731
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x50, %rsp
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1359(%rip), %rsi      # 0x404f
leaq 0x1357(%rip), %rdx      # 0x4054
leaq -0x38(%rbp), %rdi
callq 0x32ec
leaq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x242c
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x2d21
callq 0x2170
xorps %xmm0, %xmm0
movl $0x186a0, %ebx          # imm = 0x186A0
movss %xmm0, -0x14(%rbp)
callq 0x2060
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
callq 0x2120
movss -0x14(%rbp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, -0x14(%rbp)
movss -0x14(%rbp), %xmm0
decl %ebx
jne 0x2d29
movq 0x3273(%rip), %rbx      # 0x5fd0
leaq 0x12f1(%rip), %rsi      # 0x4055
movl $0xd, %edx
movq %rbx, %rdi
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl $0xfffffefb, %edx       # imm = 0xFFFFFEFB
andl 0x18(%rbx,%rcx), %edx
orl $0x4, %edx
movl %edx, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
movq $0x2, 0x8(%rbx,%rax)
xorps %xmm0, %xmm0
cvtss2sd -0x14(%rbp), %xmm0
movq %rbx, %rdi
callq 0x2220
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq -0x60(%rbp), %rdi
callq 0x2466
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x2e05
callq 0x2170
jmp 0x2e05
movq %rax, %rbx
jmp 0x2e05
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x2466
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x50, %rsp
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x123c(%rip), %rsi      # 0x4063
leaq 0x123a(%rip), %rdx      # 0x4068
leaq -0x38(%rbp), %rdi
callq 0x32ec
leaq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x242c
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x2e52
callq 0x2170
xorps %xmm0, %xmm0
movl $0x7a120, %ebx          # imm = 0x7A120
movss %xmm0, -0x14(%rbp)
callq 0x2060
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
callq 0x2120
movss -0x14(%rbp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, -0x14(%rbp)
movss -0x14(%rbp), %xmm0
decl %ebx
jne 0x2e5a
movq 0x3142(%rip), %rbx      # 0x5fd0
leaq 0x11d4(%rip), %rsi      # 0x4069
movl $0xd, %edx
movq %rbx, %rdi
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl $0xfffffefb, %edx       # imm = 0xFFFFFEFB
andl 0x18(%rbx,%rcx), %edx
orl $0x4, %edx
movl %edx, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
movq $0x2, 0x8(%rbx,%rax)
xorps %xmm0, %xmm0
cvtss2sd -0x14(%rbp), %xmm0
movq %rbx, %rdi
callq 0x2220
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
callq 0x2cdc
leaq -0x60(%rbp), %rdi
callq 0x2466
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x2f3b
callq 0x2170
jmp 0x2f3b
movq %rax, %rbx
jmp 0x2f3b
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x2466
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/ahmadsalim[P]qsort-inline/benchmark_cinline.cpp
// Function: main
int main() {
    int ary[LARGE_SIZE];
    // generate random data
    std::generate( ary, ary + LARGE_SIZE, rnd() );
    QSORTD(int) ( ary, LARGE_SIZE );
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x61a88, %rsp          # imm = 0x61A88
xorl %ebx, %ebx
movabsq $0xa7c5ac471b47843, %r14 # imm = 0xA7C5AC471B47843
callq 0x1030
movslq %eax, %rcx
movq %rcx, %rax
shrq $0x5, %rax
mulq %r14
shrq $0x7, %rdx
imull $0x186a0, %edx, %eax    # imm = 0x186A0
subl %eax, %ecx
movl %ecx, (%rsp,%rbx)
addq $0x4, %rbx
cmpq $0x61a80, %rbx          # imm = 0x61A80
jne 0x1162
movq %rsp, %rdi
movl $0x186a0, %esi          # imm = 0x186A0
callq 0x14d3
xorl %eax, %eax
addq $0x61a88, %rsp          # imm = 0x61A88
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/pixlark[P]Badge/src/string-builder.cc
// Function: String_Builder::final_string()
char * String_Builder::final_string()
{
	char * str = (char*) malloc(sizeof(char) * (builder.size + 1));
	strncpy(str, builder.arr, builder.size);
	str[builder.size] = '\0';
	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
leaq 0x1(%r14), %rdi
callq 0x1200
movq %rax, %r15
movq (%rbx), %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x10b0
movb $0x0, (%r15,%r14)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq