LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: wx-csy[P]librmq/./librmq/st.h
// Function: librmq::rmq_st<int>::init(unsigned long, int const*, unsigned long*)
void init(size_t n, const T *data, size_t *first = nullptr) {
        this->n = n; this->data = data;
        if (first) {
            st[0] = first; 
        } else { 
            st[0] = new size_t[n]; std::iota(st[0], st[0] + n, size_t(0));
        }
        for (size_t lv = 0; (2 << lv) <= n; lv++) {
            st[lv+1] = new size_t[n - (2 << lv) + 1];
            for (size_t i = 0; i + (2 << lv) <= n; i++) {
                size_t p1 = st[lv][i], p2 = st[lv][i + (1 << lv)];
                st[lv+1][i] = (data[p1] < data[p2] ? p1 : p2);
            }
        }
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rcx
movq %rcx, (%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x1e8(%rax)
cmpq $0x0, 0x38(%rsp)
je 0x2f3e
movq 0x10(%rsp), %rax
movq 0x38(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x2f8d
movq 0x48(%rsp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rdi
movq 0x8(%rax), %rsi
movq 0x48(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3100
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
movl %eax, %ecx
movl $0x2, %eax
shll %cl, %eax
cltq
cmpq 0x48(%rsp), %rax
ja 0x30f3
movq 0x48(%rsp), %rax
movq 0x30(%rsp), %rcx
movl $0x2, %edx
shll %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
subq %rcx, %rax
addq $0x1, %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rdx, 0x10(%rax,%rcx,8)
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
movl $0x2, %edx
shll %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
cmpq 0x48(%rsp), %rax
ja 0x30de
movq 0x10(%rsp), %rax
movq 0x30(%rsp), %rcx
movq 0x8(%rax,%rcx,8), %rcx
movq 0x28(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, 0x20(%rsp)
movq 0x30(%rsp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x30(%rsp), %rcx
movl $0x1, %edx
shll %cl, %edx
movq 0x8(%rsp), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq 0x20(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq 0x40(%rsp), %rcx
movq 0x18(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x30a6
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
jmp 0x30af
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq (%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x10(%rax,%rcx,8), %rax
movq 0x28(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x300a
jmp 0x30e0
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x2f96
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: wx-csy[P]librmq/./librmq/ind.h
// Function: librmq::rmq_ind<int>::select_segment(int const*)
static inline int select_segment(const T data[]) {
        int ptr = 0;
        int crit;
        while ((crit = decision_tree_nodes[ptr].crit) > 0) { 
            ptr = decision_tree_nodes[ptr].son[data[crit / SEGLEN] < data[crit % SEGLEN]];
        }
        return decision_tree_nodes[ptr].tree;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
leaq 0xf300c(%rip), %rax     # 0xf6dc0
movq (%rax), %rax
movslq -0xc(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x10(%rsp)
cmpl $0x0, %eax
jle 0x3e4a
leaq 0xf2feb(%rip), %rax     # 0xf6dc0
movq (%rax), %rax
movslq -0xc(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movl -0x10(%rsp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x28(%rsp), %rax
movslq %ecx, %rcx
movl (%rax,%rcx,4), %ecx
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movl -0x10(%rsp), %eax
movl $0x8, %esi
cltd
idivl %esi
movq -0x20(%rsp), %rax
movl %edx, %esi
movq -0x18(%rsp), %rdx
movslq %esi, %rsi
cmpl (%rdx,%rsi,4), %ecx
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
movl 0x8(%rax,%rcx,4), %eax
movl %eax, -0xc(%rsp)
jmp 0x3dad
leaq 0xf2f6f(%rip), %rax     # 0xf6dc0
movq (%rax), %rax
movslq -0xc(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
retq
nopw %cs:(%rax,%rax)
nop
// File: wx-csy[P]librmq/./librmq/block.h
// Function: librmq::rmq_block<int>::query(unsigned long, unsigned long)
size_t query(size_t l, size_t r) {
        size_t lb = l / BLOCKSZ, rb = r / BLOCKSZ;
        if (lb != rb) { // speculative policy
            size_t ret = st.query(lb, std::min(nr_blocks, rb + 1));
            if (ret >= l and ret < r) return ret;
        } else {
            return std::min_element(data + l, data + r) - data;
        }
        size_t lbase = lb * BLOCKSZ, rbase = rb * BLOCKSZ;
        size_t v = suf[l];
        if (r != rbase) {
            size_t v2 = pref[r - 1];
            if (data[v2] < data[v]) v = v2;
        }
        if (lb + 1 == rb) return v;
        size_t vv = st.query(lb + 1, rb);
        return data[vv] < data[v] ? vv : v;
    }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x70(%rsp), %rax
shrq $0xa, %rax
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rax
shrq $0xa, %rax
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rax
cmpq 0x58(%rsp), %rax
je 0x4672
movq 0x18(%rsp), %rdi
movq %rdi, %rax
addq $0x28, %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x8, %rdi
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
leaq 0x48(%rsp), %rsi
callq 0x3f30
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq (%rax), %rdx
callq 0x2c50
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
cmpq 0x70(%rsp), %rax
jb 0x4670
movq 0x50(%rsp), %rax
cmpq 0x68(%rsp), %rax
jae 0x4670
movq 0x50(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0x47b8
jmp 0x46b9
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x70(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rdi
movq 0x10(%rax), %rsi
movq 0x68(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x3d60
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
sarq $0x2, %rax
movq %rax, 0x80(%rsp)
jmp 0x47b8
movq 0x18(%rsp), %rax
movq 0x60(%rsp), %rcx
shlq $0xa, %rcx
movq %rcx, 0x40(%rsp)
movq 0x58(%rsp), %rcx
shlq $0xa, %rcx
movq %rcx, 0x38(%rsp)
movq 0x20(%rax), %rax
movq 0x70(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x30(%rsp)
movq 0x68(%rsp), %rax
cmpq 0x38(%rsp), %rax
je 0x4739
movq 0x18(%rsp), %rcx
movq 0x18(%rcx), %rax
movq 0x68(%rsp), %rdx
subq $0x1, %rdx
movq (%rax,%rdx,8), %rax
movq %rax, 0x28(%rsp)
movq 0x10(%rcx), %rax
movq 0x28(%rsp), %rdx
movl (%rax,%rdx,4), %eax
movq 0x10(%rcx), %rcx
movq 0x30(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x4737
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x4739
movq 0x60(%rsp), %rax
addq $0x1, %rax
cmpq 0x58(%rsp), %rax
jne 0x4758
movq 0x30(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0x47b8
movq 0x18(%rsp), %rdi
addq $0x28, %rdi
movq 0x60(%rsp), %rsi
addq $0x1, %rsi
movq 0x58(%rsp), %rdx
callq 0x2c50
movq 0x18(%rsp), %rcx
movq %rax, 0x20(%rsp)
movq 0x10(%rcx), %rax
movq 0x20(%rsp), %rdx
movl (%rax,%rdx,4), %eax
movq 0x10(%rcx), %rcx
movq 0x30(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x47a3
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
jmp 0x47ac
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
addq $0x88, %rsp
retq
nopl (%rax,%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: TranslationUnit::print_py(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
inline void TranslationUnit::print_py(std::string file_name) const {
			
				
				std::ofstream file;
				file.open(file_name.c_str());
				if(TranslationUnitPtr != NULL){
					TranslationUnitPtr->print_py(file);
				}
				if( ExternalDecl != NULL){
					ExternalDecl->print_py(file);
				}

			if(main_){
				file << std::endl << std::endl << "if __name__ == " << "\"__main__\"" << ":"; 
   				file <<  std::endl << "\t\timport sys";
    				file <<  std::endl << "\t\tret=main()";
    				file << std::endl << "\t\tsys.exit(ret)";

			}

				file.close();
				

			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rsi, -0x230(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x238(%rbp)
leaq -0x210(%rbp), %rdi
movq %rdi, -0x228(%rbp)
callq 0x86f0
movq -0x230(%rbp), %rdi
callq 0x8180
movq -0x228(%rbp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0x8080
jmp 0x9b1a
movq -0x238(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x9b66
movq -0x238(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x210(%rbp), %rsi
callq 0x9cf0
jmp 0x9b41
jmp 0x9b66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x8630
jmp 0x9cd9
movq -0x238(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x9b8f
movq -0x238(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x210(%rbp), %rsi
callq 0x9d50
jmp 0x9b8d
jmp 0x9b8f
testb $0x1, 0x92b92(%rip)     # 0x9c728
je 0x9cb6
movq 0x7e3cd(%rip), %rsi     # 0x87f70
leaq -0x210(%rbp), %rdi
callq 0x8450
movq %rax, -0x240(%rbp)
jmp 0x9bb8
movq -0x240(%rbp), %rdi
movq 0x7e3aa(%rip), %rsi     # 0x87f70
callq 0x8450
movq %rax, -0x248(%rbp)
jmp 0x9bd4
movq -0x248(%rbp), %rdi
leaq 0x5a596(%rip), %rsi     # 0x64178
callq 0x8400
movq %rax, -0x250(%rbp)
jmp 0x9bf0
movq -0x250(%rbp), %rdi
leaq 0x5a58a(%rip), %rsi     # 0x64188
callq 0x8400
movq %rax, -0x258(%rbp)
jmp 0x9c0c
movq -0x258(%rbp), %rdi
leaq 0x5a5b9(%rip), %rsi     # 0x641d3
callq 0x8400
jmp 0x9c21
movq 0x7e348(%rip), %rsi     # 0x87f70
leaq -0x210(%rbp), %rdi
callq 0x8450
movq %rax, -0x260(%rbp)
jmp 0x9c3d
movq -0x260(%rbp), %rdi
leaq 0x5a548(%rip), %rsi     # 0x64193
callq 0x8400
jmp 0x9c52
movq 0x7e317(%rip), %rsi     # 0x87f70
leaq -0x210(%rbp), %rdi
callq 0x8450
movq %rax, -0x268(%rbp)
jmp 0x9c6e
movq -0x268(%rbp), %rdi
leaq 0x5a524(%rip), %rsi     # 0x641a0
callq 0x8400
jmp 0x9c83
movq 0x7e2e6(%rip), %rsi     # 0x87f70
leaq -0x210(%rbp), %rdi
callq 0x8450
movq %rax, -0x270(%rbp)
jmp 0x9c9f
movq -0x270(%rbp), %rdi
leaq 0x5a500(%rip), %rsi     # 0x641ad
callq 0x8400
jmp 0x9cb4
jmp 0x9cb6
leaq -0x210(%rbp), %rdi
callq 0x85e0
jmp 0x9cc4
leaq -0x210(%rbp), %rdi
callq 0x8630
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq -0x218(%rbp), %rdi
callq 0x8760
nopw %cs:(%rax,%rax)
nop
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: TranslationUnit::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void TranslationUnit::print_py(std::ofstream& file)  {

				if(TranslationUnitPtr != NULL){
					TranslationUnitPtr->print_py(file);
				}
				if( ExternalDecl != NULL){
					ExternalDecl->print_py(file);
				}

				

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x9d20
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x9cf0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x9d3c
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x9d50
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: ExternalDeclaration::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void ExternalDeclaration::print_py(std::ofstream& file) {
		
			if( ExternalDeclarationPtr != NULL ) {
				ExternalDeclarationPtr->print_py(file);

			}

			if ( DecLaration  == NULL && FunctionDef != NULL){
				function = true;
				file << std::endl;
				FunctionDef->print_py(file);
				file << std::endl;
				function = false;
			}

			if ( FunctionDef  == NULL && DecLaration != NULL){
				file << std::endl;
				DecLaration->print_py(file);
				file << std::endl;
			}

				
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x18(%rax)
je 0x9d80
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x9d50
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x9dd5
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x9dd5
movb $0x1, 0x9298c(%rip)     # 0x9c729
movq -0x10(%rbp), %rdi
movq 0x7e1c8(%rip), %rsi     # 0x87f70
callq 0x8450
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xbce0
movq -0x10(%rbp), %rdi
movq 0x7e1a7(%rip), %rsi     # 0x87f70
callq 0x8450
movb $0x0, 0x92954(%rip)     # 0x9c729
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x9e1c
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x9e1c
movq -0x10(%rbp), %rdi
movq 0x7e17a(%rip), %rsi     # 0x87f70
callq 0x8450
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xbe20
movq -0x10(%rbp), %rdi
movq 0x7e159(%rip), %rsi     # 0x87f70
callq 0x8450
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: FunctionDefinition::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void FunctionDefinition::print_py(std::ofstream& file) {
		
			if( DeclarationSpecifiersPtr != NULL ) {
										//do-nothing because it is not significant in our case (only int/void)
			}

			if( DeclaratorPtr != NULL ) {				//handles global variables after printing function name
				
				DeclaratorPtr->print_py(file,false,true);
				if(DeclarationListPtr == NULL) {
					file << "):" << std::endl;					

					for( int i= 0; i < GlobalVars.size(); i++) {
						file << "\tglobal " << GlobalVars[i] << std::endl;
					}					
				}
			}

			if( DeclarationListPtr != NULL ) {   			//( functions having parameters )
				ParametrizedFunction = true;
				DeclarationListPtr->print_py(file);
			}

			if( CompoundStatementPtr != NULL ) {
			
				CompoundStatementPtr->print_py(file,false,true);
			}
			
				
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x8(%rax)
je 0xbd01
jmp 0xbd01
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xbdcb
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xbe60
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xbdc9
movq -0x10(%rbp), %rdi
leaq 0x58490(%rip), %rsi     # 0x641d2
callq 0x8400
movq %rax, %rdi
movq 0x7c21f(%rip), %rsi     # 0x87f70
callq 0x8450
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x7cb04(%rip), %rdi     # 0x88870
callq 0xbef0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0xbdc7
movq -0x10(%rbp), %rdi
leaq 0x5844d(%rip), %rsi     # 0x641d5
callq 0x8400
movq %rax, -0x30(%rbp)
movslq -0x14(%rbp), %rsi
leaq 0x7cad4(%rip), %rdi     # 0x88870
callq 0xbf10
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x83c0
movq %rax, %rdi
movq 0x7c1b9(%rip), %rsi     # 0x87f70
callq 0x8450
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbd5d
jmp 0xbdc9
jmp 0xbdcb
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xbdee
movq -0x20(%rbp), %rax
movb $0x1, 0x90949(%rip)     # 0x9c72a
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xbf30
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xbe11
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xbf90
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: Declarator::print_py(std::basic_ofstream<char, std::char_traits<char>>&, bool, bool)
inline void Declarator::print_py(std::ofstream& file, bool initialized, bool function) {

			if( DeclaratorPtr != NULL) {
				DeclaratorPtr->print_py(file,initialized,function);
			}
			if(DirectDecLarator != NULL){
				DirectDecLarator->print_py(file,initialized,function);
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %cl
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x18(%rax)
je 0xbeb0
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %cl
movb -0x12(%rbp), %al
andb $0x1, %cl
andb $0x1, %al
movzbl %cl, %edx
movzbl %al, %ecx
callq 0xbe60
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xbedd
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %cl
movb -0x12(%rbp), %al
andb $0x1, %cl
andb $0x1, %al
movzbl %cl, %edx
movzbl %al, %ecx
callq 0xc0d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: DeclarationList::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void DeclarationList::print_py(std::ofstream& file) {

				if( DeclarationListPtr != NULL) {
					
					DeclarationListPtr->print_py(file);

				}
				function = false;
				if(DeclarationPtr != NULL){
					DeclarationPtr->print_py(file);
				}

			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
je 0xbf60
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xbf30
movq -0x18(%rbp), %rax
movb $0x0, 0x907be(%rip)     # 0x9c729
cmpq $0x0, 0x8(%rax)
je 0xbf83
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xbe20
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: CompoundStatement::print_py(std::basic_ofstream<char, std::char_traits<char>>&, bool, bool)
inline void CompoundStatement::print_py(std::ofstream& file, bool initialized, bool function) {
			
			counter_py++;
	
			
			if( StatementListPtr == NULL && DeclarationListPtr == NULL ) {
				for( int i(0); i<counter_py; i++) { file << "\t"; }
				file << "pass" << std::endl;
			}
			else if( StatementListPtr == NULL && DeclarationListPtr != NULL ) {
				DeclarationListPtr->print_py(file);
			}
			else if( StatementListPtr != NULL && DeclarationListPtr == NULL ) {
				StatementListPtr->print_py(file);
			}
			else if( StatementListPtr != NULL && DeclarationListPtr != NULL ) {
				DeclarationListPtr->print_py(file);
				StatementListPtr->print_py(file);
				
			}

			counter_py--;
			
		
			
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %cl
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x9076f(%rip), %ecx     # 0x9c72c
addl $0x1, %ecx
movl %ecx, 0x90766(%rip)     # 0x9c72c
cmpq $0x0, 0x8(%rax)
jne 0xc029
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xc029
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl 0x90744(%rip), %eax     # 0x9c72c
jge 0xc005
movq -0x10(%rbp), %rdi
leaq 0x584c6(%rip), %rsi     # 0x644bb
callq 0x8400
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xbfdf
movq -0x10(%rbp), %rdi
leaq 0x581f5(%rip), %rsi     # 0x64205
callq 0x8400
movq %rax, %rdi
movq 0x7bf51(%rip), %rsi     # 0x87f70
callq 0x8450
jmp 0xc0b9
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xc052
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xc052
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xbf30
jmp 0xc0b7
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xc07b
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xc07b
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xcf10
jmp 0xc0b5
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xc0b3
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xc0b3
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xbf30
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xcf10
jmp 0xc0b5
jmp 0xc0b7
jmp 0xc0b9
movl 0x9066d(%rip), %eax     # 0x9c72c
addl $-0x1, %eax
movl %eax, 0x90664(%rip)     # 0x9c72c
addq $0x20, %rsp
popq %rbp
retq
nop
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: IdentifierList::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void IdentifierList::print_py(std::ofstream& file) {

			if( IdentifierListPtr != NULL) {
				IdentifierListPtr->print_py(file);
				file << ",";
			}
			if(IDENTIFIER != NULL){
				file << *IDENTIFIER;
			}				
		
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
je 0xc3d0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xc390
movq -0x10(%rbp), %rdi
leaq 0x58072(%rip), %rsi     # 0x6443d
callq 0x8400
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xc3ec
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0x83c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: ParameterList::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void ParameterList::print_py(std::ofstream& file) {

			if( ParameterListPtr != NULL) {
				ParameterListPtr->print_py(file);
				file << ",";
			}
			if(ParameterDeclarationPtr != NULL){
				ParameterDeclarationPtr->print_py(file);
			}						
			
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
je 0xce90
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xce50
movq -0x10(%rbp), %rdi
leaq 0x575b2(%rip), %rsi     # 0x6443d
callq 0x8400
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xceac
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xcec0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: StatementList::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void StatementList::print_py(std::ofstream& file) {

			if( StatementListPtr != NULL) {
				StatementListPtr->print_py(file);

			}
			if(StatementPtr != NULL){
				StatementPtr->print_py(file);
			}

				

		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
je 0xcf40
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xcf10
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xcf5e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0xcf70
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: Statement::print_py(std::basic_ofstream<char, std::char_traits<char>>&, bool)
inline void Statement::print_py(std::ofstream& file, bool elseif) {

			if( CompoundStatementPtr != NULL ) { 
				
				CompoundStatementPtr->print_py(file);
				

			}

			
			else if( LabeledStatementPtr != NULL ) { 
			
				LabeledStatementPtr->print_py(file);
			}

			else if( ExpressionStatementPtr != NULL ) { 
					
				ExpressionStatementPtr->print_py(file);
				
			}

			else if( SelectionStatementPtr != NULL ) {
					
				SelectionStatementPtr->print_py(file,elseif);
					

			}

			else if( IterationStatementPtr != NULL ) {
					
				IterationStatementPtr->print_py(file);
					

			}

			else if( JumpStatementPtr != NULL ) {
				
				JumpStatementPtr->print_py(file);
					

			}		

			
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x10(%rax)
je 0xcfb3
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xbf90
jmp 0xd05c
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xcfd4
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xd070
jmp 0xd05a
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xcff2
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xd080
jmp 0xd058
movq -0x20(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xd018
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0xd0d0
jmp 0xd056
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xd036
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xd4a0
jmp 0xd054
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xd052
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xd5a0
jmp 0xd054
jmp 0xd056
jmp 0xd058
jmp 0xd05a
jmp 0xd05c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: IterationStatement::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void IterationStatement::print_py(std::ofstream& file) {

			if( *ITERATIVE_TYPE == "while" && AssignmentExpressionPtr != NULL && StatementPtr != NULL) {
				file << std::endl;
				is_while = true;				// This is to not print an endline in function assignmentExpression
				for( int i(0); i<counter_py; i++) { file << "\t"; }
				file << "while(";
				AssignmentExpressionPtr->print_py(file);
				file << "):" << std::endl;
				
				Indent_Generator(StatementPtr,file);
					
				is_while = false;			
			}			
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x28(%rax), %rdi
leaq 0x56d62(%rip), %rsi     # 0x64225
callq 0x9e30
testb $0x1, %al
jne 0xd4d1
jmp 0xd58d
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xd58d
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xd58d
movq -0x10(%rbp), %rdi
movq 0x7aa76(%rip), %rsi     # 0x87f70
callq 0x8450
movb $0x1, 0x8f22b(%rip)     # 0x9c731
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x8f216(%rip), %eax     # 0x9c72c
jge 0xd533
movq -0x10(%rbp), %rdi
leaq 0x56f98(%rip), %rsi     # 0x644bb
callq 0x8400
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd50d
movq -0x10(%rbp), %rdi
leaq 0x56ced(%rip), %rsi     # 0x6422b
callq 0x8400
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xd640
movq -0x10(%rbp), %rdi
leaq 0x56c73(%rip), %rsi     # 0x641d2
callq 0x8400
movq %rax, %rdi
movq 0x7aa02(%rip), %rsi     # 0x87f70
callq 0x8450
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0xe3d0
movb $0x0, 0x8f1a4(%rip)     # 0x9c731
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: JumpStatement::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void JumpStatement::print_py(std::ofstream& file) {
			
			for( int i(0); i<counter_py; i++) { file << "\t"; }
			if(JUMP_TYPE != NULL){
				file << *JUMP_TYPE << " ";
			}
			if(AssignmentExpressionPtr != NULL) {
				AssignmentExpressionPtr->print_py(file);
			}

		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x8f164(%rip), %eax     # 0x9c72c
jge 0xd5e5
movq -0x10(%rbp), %rdi
leaq 0x56ee6(%rip), %rsi     # 0x644bb
callq 0x8400
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd5bf
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xd610
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rsi
callq 0x83c0
movq %rax, %rdi
leaq 0x573b2(%rip), %rsi     # 0x649bd
callq 0x8400
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xd62c
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xd640
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node.hpp
// Function: Expression::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
void print_py(std::ofstream& file) {

			if(ExpressionPtr != NULL) {

				ExpressionPtr->print_py(file);
			}

			else{
				AssignmentExpressionPtr->print_py(file);
			}

		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
je 0xd672
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xd640
jmp 0xd683
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xd690
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: AssignmentExpression::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void AssignmentExpression::print_py(std::ofstream& file)  {

			
			if(UnaryExpressionPtr != NULL) {
		
				for( int i(0); i<counter_py; i++) { file << "\t"; }
				UnaryExpressionPtr->print_py(file);
				file << "=";

			}
	
			if(ConditionalExpressionPtr != NULL) {

				ConditionalExpressionPtr->print_py(file);

			}

			if(AssignmentExpressionPtr != NULL) {

				AssignmentExpressionPtr->print_py(file);
			}


			
			if(!function && !is_while && !is_Selective && (parentheses==0) ){		//In the case we are inside a condition for one of the precedings then dont endline
				file << std::endl;
				
			}
			

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x10(%rax)
je 0xd6fd
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x8f06d(%rip), %eax     # 0x9c72c
jge 0xd6dc
movq -0x10(%rbp), %rdi
leaq 0x56def(%rip), %rsi     # 0x644bb
callq 0x8400
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd6b6
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xd770
movq -0x10(%rbp), %rdi
leaq 0x56e1a(%rip), %rsi     # 0x64512
callq 0x8400
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xd719
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xd860
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xd735
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xd690
testb $0x1, 0x8efed(%rip)     # 0x9c729
jne 0xd769
testb $0x1, 0x8efec(%rip)     # 0x9c731
jne 0xd769
testb $0x1, 0x8efe4(%rip)     # 0x9c732
jne 0xd769
cmpl $0x0, 0x8efdd(%rip)     # 0x9c734
jne 0xd769
movq -0x10(%rbp), %rdi
movq 0x7a80c(%rip), %rsi     # 0x87f70
callq 0x8450
addq $0x20, %rsp
popq %rbp
retq
nop
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: UnaryExpression::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void UnaryExpression::print_py(std::ofstream& file) {
			if(PostFixExpressionPtr != NULL) {
				PostFixExpressionPtr->print_py(file);
			}
			else if ( CastExpressionPtr != NULL) {
				if(OPERATOR != NULL) {
					file << " " << *OPERATOR << " ";
				}

				else if(UnaryOperatorPtr != NULL){
					file << " " << *(UnaryOperatorPtr->print_py()) << " ";
				}
				CastExpressionPtr->print_py(file);
			}

			

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x8(%rax)
je 0xd7a5
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xd8b0
jmp 0xd84f
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xd84d
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xd7f0
movq -0x10(%rbp), %rdi
leaq 0x571f3(%rip), %rsi     # 0x649bd
callq 0x8400
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x83c0
movq %rax, %rdi
leaq 0x571d4(%rip), %rsi     # 0x649bd
callq 0x8400
jmp 0xd83c
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xd83a
movq -0x10(%rbp), %rdi
leaq 0x571b7(%rip), %rsi     # 0x649bd
callq 0x8400
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x28(%rax), %rdi
callq 0xdb40
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x83c0
movq %rax, %rdi
leaq 0x57188(%rip), %rsi     # 0x649bd
callq 0x8400
jmp 0xd83c
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xdb70
jmp 0xd84f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: ConditionalExpression::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void ConditionalExpression::print_py(std::ofstream& file) {

		if( ExpressioN == NULL  && LogicalORExpression != NULL) {
			LogicalORExpression->print_py(file);
		}
		else {
		       //.....
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0xd89d
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xd89d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xdd30
jmp 0xd89f
jmp 0xd89f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: PrimaryExpression::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void PrimaryExpression::print_py(std::ofstream& file) {

			if( AssignmentExpressionPtr != NULL ) {
				file << "(";
				parentheses++;
				AssignmentExpressionPtr->print_py(file);
				file << ")";
				parentheses--;
			}

			if(IDENTIFIER != NULL) {
		
				file << *IDENTIFIER;

			}
			else if( CONSTANT != NULL ) {
				file << *CONSTANT; 

			}
		
			else if( STRING_LITERAL != NULL) {
	
				file << " " << '"' << *STRING_LITERAL << '"' << " ";
			}
		
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x20(%rax)
je 0xdc1e
movq -0x10(%rbp), %rdi
leaq 0x56656(%rip), %rsi     # 0x64230
callq 0x8400
movq -0x18(%rbp), %rax
movl 0x8eb4b(%rip), %ecx     # 0x9c734
addl $0x1, %ecx
movl %ecx, 0x8eb42(%rip)     # 0x9c734
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xd640
movq -0x10(%rbp), %rdi
leaq 0x577ee(%rip), %rsi     # 0x653f8
callq 0x8400
movl 0x8eb1f(%rip), %eax     # 0x9c734
addl $-0x1, %eax
movl %eax, 0x8eb16(%rip)     # 0x9c734
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xdc3c
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0x83c0
jmp 0xdcb2
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xdc5a
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x10(%rax), %rsi
callq 0x83c0
jmp 0xdcb0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xdcae
movq -0x10(%rbp), %rdi
leaq 0x56d4d(%rip), %rsi     # 0x649bd
callq 0x8400
movq %rax, %rdi
movl $0x22, %esi
callq 0x84e0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x83c0
movq %rax, %rdi
movl $0x22, %esi
callq 0x84e0
movq %rax, %rdi
leaq 0x56d14(%rip), %rsi     # 0x649bd
callq 0x8400
jmp 0xdcb0
jmp 0xdcb2
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: ArgumentExpressionList::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void ArgumentExpressionList::print_py(std::ofstream& file) {

		function = true;
		if( ArgumentExpressionListPtr != NULL) {
			ArgumentExpressionListPtr->print_py(file);
			file << ",";
		}
		if(AssignmentExpressionPtr != NULL){
			AssignmentExpressionPtr->print_py(file);
		}
		

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x1, 0x8ea4a(%rip)     # 0x9c729
cmpq $0x0, 0x8(%rax)
je 0xdd07
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xdcc0
movq -0x10(%rbp), %rdi
leaq 0x5673b(%rip), %rsi     # 0x6443d
callq 0x8400
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xdd23
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xd690
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: LogicalOrExpression::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void LogicalOrExpression::print_py(std::ofstream& file) {
			if(OR_OP==NULL && LogicalAndExpressionPtr != NULL){
				LogicalAndExpressionPtr->print_py(file);
			}
			else{ 
				if(LogicalOrExpressionPtr != NULL){
					LogicalOrExpressionPtr->print_py(file);
				}
				if(OR_OP != NULL){
					file << " or ";
				}
				if(LogicalAndExpressionPtr != NULL){
					LogicalAndExpressionPtr->print_py(file);
				}
				
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0xdd6d
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xdd6d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xddd0
jmp 0xddc2
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xdd89
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xdd30
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xdda4
movq -0x10(%rbp), %rdi
leaq 0x5646b(%rip), %rsi     # 0x6420a
callq 0x8400
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xddc0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xddd0
jmp 0xddc2
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: LogicalAndExpression::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void LogicalAndExpression::print_py(std::ofstream& file) {
			if(AND_OP==NULL && INclusiveOrExpression != NULL){
				INclusiveOrExpression->print_py(file);
			}
			else{ 
				if(LogicalAndExpressionPtr != NULL){
					LogicalAndExpressionPtr->print_py(file);
				}
				if(AND_OP != NULL){
					file << " and ";
				}
				if(INclusiveOrExpression != NULL){
					INclusiveOrExpression->print_py(file);
				}
				
			}

		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x18(%rax)
jne 0xde0d
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xde0d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xde70
jmp 0xde62
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xde29
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xddd0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xde44
movq -0x10(%rbp), %rdi
leaq 0x563d0(%rip), %rsi     # 0x6420f
callq 0x8400
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xde60
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xde70
jmp 0xde62
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: InclusiveOrExpression::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void InclusiveOrExpression::print_py(std::ofstream& file) {

			if(INC_OR==NULL && EXclusiveOrExpression != NULL){
				EXclusiveOrExpression->print_py(file);
			}
			else{ 
				if(InclusiveOrExpressionPtr != NULL){
					InclusiveOrExpressionPtr->print_py(file);
				}
				if(INC_OR != NULL){
					file << " " << "|" << " ";
				}
				if(EXclusiveOrExpression != NULL){
					EXclusiveOrExpression->print_py(file);
				}
				
			}

		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0xdead
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xdead
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xdf30
jmp 0xdf20
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xdec9
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xde70
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xdf02
movq -0x10(%rbp), %rdi
leaq 0x56ade(%rip), %rsi     # 0x649bd
callq 0x8400
movq %rax, %rdi
leaq 0x56c89(%rip), %rsi     # 0x64b77
callq 0x8400
movq %rax, %rdi
leaq 0x56ac0(%rip), %rsi     # 0x649bd
callq 0x8400
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xdf1e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xdf30
jmp 0xdf20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: ExclusiveOrExpression::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void ExclusiveOrExpression::print_py(std::ofstream& file) {

			if(EXCL_OR==NULL && ANDexpression != NULL){
				ANDexpression->print_py(file);
			}
			else{ 
				if(ExclusiveOrExpressionPtr != NULL){
					ExclusiveOrExpressionPtr->print_py(file);
				}
				if(EXCL_OR != NULL){
					file << " " << "^" << " ";
				}
				if(ANDexpression != NULL){
					ANDexpression->print_py(file);
				}
				
			}

		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0xdf6d
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xdf6d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xdff0
jmp 0xdfe0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xdf89
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xdf30
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xdfc2
movq -0x10(%rbp), %rdi
leaq 0x56a1e(%rip), %rsi     # 0x649bd
callq 0x8400
movq %rax, %rdi
leaq 0x56267(%rip), %rsi     # 0x64215
callq 0x8400
movq %rax, %rdi
leaq 0x56a00(%rip), %rsi     # 0x649bd
callq 0x8400
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xdfde
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xdff0
jmp 0xdfe0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: AndExpression::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void AndExpression::print_py(std::ofstream& file) {

			if(BIT_AND==NULL && EqualitYExpression != NULL){
				EqualitYExpression->print_py(file);
			}
			else{ 
				if(AndExpressionPtr != NULL){
					AndExpressionPtr->print_py(file);
				}
				if(BIT_AND != NULL){
					file << " " << "&" << " ";
				}
				if(EqualitYExpression != NULL){
					EqualitYExpression->print_py(file);
				}
				
			}

		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0xe02d
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe02d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xe0b0
jmp 0xe0a0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xe049
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xdff0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xe082
movq -0x10(%rbp), %rdi
leaq 0x5695e(%rip), %rsi     # 0x649bd
callq 0x8400
movq %rax, %rdi
leaq 0x561a9(%rip), %rsi     # 0x64217
callq 0x8400
movq %rax, %rdi
leaq 0x56940(%rip), %rsi     # 0x649bd
callq 0x8400
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe09e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xe0b0
jmp 0xe0a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: EqualityExpression::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void EqualityExpression::print_py(std::ofstream& file) {

			if(OPERATOR==NULL && RElationalExpression != NULL){
				RElationalExpression->print_py(file);
			}
			else{ 
				if(EqualityExpressionPtr != NULL){
					EqualityExpressionPtr->print_py(file);
				}
				if(OPERATOR != NULL){
					file <<*OPERATOR;
				}
				if(RElationalExpression != NULL){
					RElationalExpression->print_py(file);
				}
				
			}

		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0xe0ed
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe0ed
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xe150
jmp 0xe143
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xe109
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xe0b0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xe125
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x10(%rax), %rsi
callq 0x83c0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe141
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xe150
jmp 0xe143
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: RelationalExpression::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void RelationalExpression::print_py(std::ofstream& file) {

			if(OPERATOR==NULL && SHiftExpression != NULL){
				SHiftExpression->print_py(file);
			}
			else{ 
				if(RelationalExpressionPtr != NULL){
					RelationalExpressionPtr->print_py(file);
				}
				if(OPERATOR != NULL){
					file << *OPERATOR;
				}
				if(SHiftExpression != NULL){
					SHiftExpression->print_py(file);
				}
				
			}


		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0xe18d
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe18d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xe1f0
jmp 0xe1e3
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xe1a9
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xe150
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xe1c5
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x10(%rax), %rsi
callq 0x83c0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe1e1
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xe1f0
jmp 0xe1e3
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: ShiftExpression::print_py(std::basic_ofstream<char, std::char_traits<char>>&)
inline void ShiftExpression::print_py(std::ofstream& file) {

			if(OPERATOR==NULL && AdditiVeExpression != NULL){
				AdditiVeExpression->print_py(file);
			}
			else{ 
				if(ShiftExpressionPtr != NULL){
					ShiftExpressionPtr->print_py(file);
				}
				if(OPERATOR != NULL){
					file << *OPERATOR;
				}
				if(AdditiVeExpression != NULL){
					AdditiVeExpression->print_py(file);
				}
				
			}

		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0xe22d
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe22d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xe290
jmp 0xe283
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xe249
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xe1f0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xe265
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x10(%rax), %rsi
callq 0x83c0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe281
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xe290
jmp 0xe283
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)