LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/wx-csy[P]librmq/./librmq/zkw.h
// Function: librmq::rmq_zkw<int>::rmq_zkw(unsigned long, int const*)
rmq_zkw(size_t n, const T *data) : n(n), data(data) {
        ntot = n;
        while (ntot & (ntot - 1)) ntot += ntot & -ntot;
        tr = new size_t[ntot << 1];
        std::iota(tr + ntot, tr + ntot + n, 0);
        std::fill(tr + ntot + n, tr + ntot + ntot, 0);
        for (size_t i = ntot - 1; i > 0; i--)
            tr[i] = data[tr[i<<1]] < data[tr[i<<1|1]] ? tr[i<<1] : tr[i<<1|1];
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq %rsi, (%rdi)
movq %rdx, 0x10(%rdi)
movq %rsi, %r13
leaq -0x1(%r13), %rax
testq %rax, %r13
je 0x229d
movq %r13, %rax
negq %rax
andq %r13, %rax
addq %rax, %r13
jmp 0x2286
movq %r13, 0x8(%r12)
movabsq $0x7000000000000000, %rax # imm = 0x7000000000000000
andq %r13, %rax
movq %r13, %rbp
shlq $0x4, %rbp
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rbp, %rdi
callq 0x1030
movq %rax, %r15
movq %rax, 0x18(%r12)
testq %r14, %r14
je 0x2384
movabsq $0x1fffffffffffffff, %rcx # imm = 0x1FFFFFFFFFFFFFFF
leaq (%r14,%rcx), %rax
andq %rax, %rcx
andl $0x1, %eax
negq %rax
addq %rcx, %rax
addq $0x2, %rax
movq %rcx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq (%r15,%r13,8), %rcx
addq $0x8, %rcx
movdqa 0xef341(%rip), %xmm1    # 0xf1650
xorl %edx, %edx
movdqa 0xef347(%rip), %xmm2    # 0xf1660
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0xef347(%rip), %xmm4    # 0xf1670
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0x2360
movq %rdx, -0x8(%rcx,%rdx,8)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x2377
leaq 0x1(%rdx), %rsi
movq %rsi, (%rcx,%rdx,8)
addq $0x2, %rdx
paddq %xmm4, %xmm1
cmpq %rdx, %rax
jne 0x2329
movq %r13, %rdx
subq %r14, %rdx
je 0x239f
leaq (%r15,%r13,8), %rax
leaq (%rax,%r14,8), %rdi
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x1080
decq %r13
je 0x23ca
leaq (%r15,%rbp), %rax
addq $-0x8, %rax
movq -0x8(%rax), %rcx
movq (%rax), %rdx
movl (%rbx,%rcx,4), %esi
cmpl (%rbx,%rdx,4), %esi
cmovlq %rcx, %rdx
movq %rdx, (%r15,%r13,8)
addq $-0x10, %rax
decq %r13
jne 0x23ac
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wx-csy[P]librmq/./librmq/zkw.h
// Function: librmq::rmq_zkw<int>::query(unsigned long, unsigned long)
size_t query(size_t l, size_t r) {
        size_t ret = l;
        l += ntot - 1;
        r += ntot;
        while (l ^ r ^ 1) {
            if ((~l & 1) && data[tr[l ^ 1]] < data[ret]) ret = tr[l ^ 1]; 
            if (( r & 1) && data[tr[r ^ 1]] < data[ret]) ret = tr[r ^ 1];
            l >>= 1;
            r >>= 1;
        }
        return ret;
    }

// Assembly:
movq %rsi, %rax
movq 0x8(%rdi), %rsi
leaq (%rax,%rsi), %rcx
decq %rcx
addq %rsi, %rdx
movq %rdx, %rsi
xorq %rcx, %rsi
cmpq $0x1, %rsi
je 0x2454
movq 0x10(%rdi), %rsi
movq 0x18(%rdi), %rdi
movabsq $0x1ffffffffffffffe, %r8 # imm = 0x1FFFFFFFFFFFFFFE
testb $0x1, %cl
jne 0x2423
movq 0x8(%rdi,%rcx,8), %r9
movl (%rsi,%r9,4), %r10d
cmpl (%rsi,%rax,4), %r10d
jl 0x2420
movq %rax, %r9
movq %r9, %rax
testb $0x1, %dl
je 0x2442
movq %rdx, %r9
andq %r8, %r9
movq (%rdi,%r9,8), %r9
movl (%rsi,%r9,4), %r10d
cmpl (%rsi,%rax,4), %r10d
jl 0x243f
movq %rax, %r9
movq %r9, %rax
shrq %rcx
shrq %rdx
movq %rdx, %r9
xorq %rcx, %r9
cmpq $0x1, %r9
jne 0x2409
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, (%rdi)
movq %rdx, 0x1e8(%rdi)
testq %rcx, %rcx
je 0x2485
movq %rcx, %rax
movq %rcx, 0x8(%r15)
jmp 0x2556
movq %r14, %rax
shrq $0x3d, %rax
leaq (,%r14,8), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x1030
movq %rax, 0x8(%r15)
testq %r14, %r14
je 0x25fe
movabsq $0x1fffffffffffffff, %rdx # imm = 0x1FFFFFFFFFFFFFFF
leaq (%r14,%rdx), %rcx
andq %rcx, %rdx
andl $0x1, %ecx
negq %rcx
addq %rdx, %rcx
addq $0x2, %rcx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0xef16f(%rip), %xmm1    # 0xf1650
xorl %edx, %edx
movdqa 0xef175(%rip), %xmm2    # 0xf1660
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0xef175(%rip), %xmm4    # 0xf1670
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0x2531
movq %rdx, (%rax,%rdx,8)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x2549
leaq 0x1(%rdx), %rsi
movq %rsi, 0x8(%rax,%rdx,8)
addq $0x2, %rdx
paddq %xmm4, %xmm1
cmpq %rdx, %rcx
jne 0x24fb
cmpq $0x2, %r14
jb 0x25fe
movl $0x2, %r13d
xorl %edx, %edx
movq %rdx, %r12
movq %rax, %rbp
movq %r14, %rax
subq %r13, %rax
leaq 0x1(%rax), %rcx
movabsq $0x1fffffffffffffff, %rdx # imm = 0x1FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
leaq 0x8(,%rax,8), %rdi
movq $-0x1, %rax
cmovaq %rax, %rdi
callq 0x1030
leaq 0x1(%r12), %rdx
movl $0x1, %esi
movl %r12d, %ecx
shll %cl, %esi
movq %rax, 0x10(%r15,%r12,8)
movslq %esi, %rcx
leaq (,%rcx,8), %rcx
addq %rbp, %rcx
xorl %esi, %esi
movq (%rbp,%rsi,8), %rdi
movq (%rcx,%rsi,8), %r8
movl (%rbx,%rdi,4), %r9d
cmpl (%rbx,%r8,4), %r9d
cmovlq %rdi, %r8
movq %r8, (%rax,%rsi,8)
leaq (%rsi,%r13), %rdi
incq %rdi
incq %rsi
cmpq %r14, %rdi
jbe 0x25c1
movl $0x2, %esi
movl %edx, %ecx
shll %cl, %esi
movslq %esi, %r13
cmpq %r14, %r13
jbe 0x2568
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq %rsi, %r9
shrq $0xa, %r9
movq %rdx, %r8
shrq $0xa, %r8
cmpq %r8, %r9
jne 0x321b
movq 0x10(%rdi), %rcx
leaq (%rcx,%rsi,4), %rax
leaq (%rcx,%rdx,4), %r8
cmpq %rdx, %rsi
sete %r9b
leaq (%rcx,%rsi,4), %rdi
addq $0x4, %rdi
cmpq %r8, %rdi
sete %r8b
orb %r9b, %r8b
jne 0x3213
movl (%rax), %r8d
shlq $0x2, %rdx
shlq $0x2, %rsi
subq %rsi, %rdx
addq $-0x4, %rdx
movl (%rdi), %esi
cmpl %r8d, %esi
cmovll %esi, %r8d
cmovlq %rdi, %rax
addq $0x4, %rdi
addq $-0x4, %rdx
jne 0x31fc
subq %rcx, %rax
sarq $0x2, %rax
retq
leaq 0x1(%r8), %rax
movq 0x8(%rdi), %r10
cmpq %r10, %rax
cmovbq %rax, %r10
movq %r10, %rax
subq %r9, %rax
bsrq %rax, %rcx
movl %ecx, %eax
movq 0x30(%rdi,%rax,8), %rax
movl $0x1, %r11d
shll %cl, %r11d
movq (%rax,%r9,8), %rcx
movslq %r11d, %r11
subq %r11, %r10
movq (%rax,%r10,8), %rax
movq 0x210(%rdi), %r10
movl (%r10,%rcx,4), %r11d
cmpl (%r10,%rax,4), %r11d
cmovlq %rcx, %rax
cmpq %rsi, %rax
setae %cl
cmpq %rdx, %rax
setb %r11b
testb %r11b, %cl
jne 0x32e6
movq 0x20(%rdi), %rax
movq (%rax,%rsi,8), %rax
movq %rdx, %rcx
shlq $0x36, %rcx
je 0x329f
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rsi
movq -0x8(%rsi,%rdx,8), %rdx
movl (%rcx,%rdx,4), %esi
cmpl (%rcx,%rax,4), %esi
cmovlq %rdx, %rax
leaq 0x1(%r9), %rdx
movq %r8, %rcx
subq %rdx, %rcx
je 0x32e6
bsrq %rcx, %rcx
movl %ecx, %edx
movl $0x1, %esi
shll %cl, %esi
movq 0x30(%rdi,%rdx,8), %rcx
movq 0x8(%rcx,%r9,8), %rdx
movslq %esi, %rsi
subq %rsi, %r8
movq (%rcx,%r8,8), %rcx
movl (%r10,%rdx,4), %esi
cmpl (%r10,%rcx,4), %esi
cmovlq %rdx, %rcx
movq 0x10(%rdi), %rdx
movl (%rdx,%rcx,4), %esi
cmpl (%rdx,%rax,4), %esi
cmovlq %rcx, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/wx-csy[P]librmq/./librmq/block.h
// Function: librmq::rmq_block<int>::init_block(int const*, unsigned long)
void init_block(const T *data, size_t si) {
        size_t ptr = si * BLOCKSZ;
        for (int i = 0; i < BLOCKSZ; i++) {
            if (i) {
                pref[ptr + i] = data[i] < data[pref[ptr + i - 1]] ? 
                    i : pref[ptr + i - 1];
            } else {
                pref[ptr + i] = i;
            }
        }
        for (int i = BLOCKSZ - 1; i >= 0; i--) {
            if (i == BLOCKSZ - 1) {
                suf[ptr + i] = i;
            } else {
                suf[ptr + i] = data[i] < data[suf[ptr + i + 1]] ?
                    i : suf[ptr + i + 1];
            }
        }
        for (int i = 0; i < BLOCKSZ; i++) pref[ptr + i] += ptr;
        for (int i = 0; i < BLOCKSZ; i++) suf[ptr + i] += ptr;
    }

// Assembly:
pushq %rbx
movq %rdx, %r8
shlq $0xa, %r8
movq 0x18(%rdi), %rcx
shlq $0xd, %rdx
leaq (%rcx,%rdx), %rax
xorl %r9d, %r9d
testq %r9, %r9
je 0x3365
movl (%rsi,%r9,4), %r10d
movq -0x8(%rax,%r9,8), %r11
cmpl (%rsi,%r11,4), %r10d
cmovlq %r9, %r11
movq %r11, (%rax,%r9,8)
jmp 0x336d
movq $0x0, (%rcx,%r8,8)
incq %r9
cmpq $0x400, %r9             # imm = 0x400
jne 0x3349
movq 0x20(%rdi), %rcx
leaq (%rcx,%r8,8), %rdi
movq %r8, %r9
orq $0x3ff, %r9             # imm = 0x3FF
movl $0x3ff, %r10d           # imm = 0x3FF
cmpq $0x3ff, %r10            # imm = 0x3FF
jne 0x33a4
movq $0x3ff, (%rcx,%r9,8)    # imm = 0x3FF
jmp 0x33b9
movl (%rsi,%r10,4), %r11d
movq 0x8(%rdi,%r10,8), %rbx
cmpl (%rsi,%rbx,4), %r11d
cmovlq %r10, %rbx
movq %rbx, (%rdi,%r10,8)
addq $-0x1, %r10
jb 0x3391
movq %r8, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
xorl %esi, %esi
movdqu (%rax,%rsi,8), %xmm1
paddq %xmm0, %xmm1
movdqu %xmm1, (%rax,%rsi,8)
addq $0x2, %rsi
cmpq $0x400, %rsi            # imm = 0x400
jne 0x33cb
addq %rdx, %rcx
xorl %eax, %eax
movdqu (%rcx,%rax,8), %xmm1
paddq %xmm0, %xmm1
movdqu %xmm1, (%rcx,%rax,8)
addq $0x2, %rax
cmpq $0x400, %rax            # imm = 0x400
jne 0x33eb
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x75a0
movq (%r15), %rsi
movq %rbx, %rdi
movl $0x10, %edx
callq 0x7070
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xb1e0
movq %rsp, %rsi
callq 0xb3a6
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xb1f1
movq %rsp, %rsi
callq 0xb3e2
cmpb $0x1, 0x63308(%rip)     # 0x6e500
jne 0xb34c
movq (%rsp), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %r14, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
movq %rax, %r14
leaq 0x2c153(%rip), %rsi     # 0x373b0
movl $0xf, %edx
movq %rax, %rdi
callq 0x73a0
leaq 0x2c14f(%rip), %rsi     # 0x373c0
movl $0xa, %edx
movq %r14, %rdi
callq 0x73a0
leaq 0x2c191(%rip), %rsi     # 0x37416
movl $0x1, %edx
movq %r14, %rdi
callq 0x73a0
movq (%rsp), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
leaq 0x2c107(%rip), %rsi     # 0x373cb
movl $0xc, %edx
movq %rax, %rdi
callq 0x73a0
movq (%rsp), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
leaq 0x2c0d5(%rip), %rsi     # 0x373d8
movl $0xc, %edx
movq %rax, %rdi
callq 0x73a0
movq (%rsp), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rsp, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
leaq 0x2c0a6(%rip), %rsi     # 0x373e5
movl $0xf, %edx
movq %rax, %rdi
callq 0x73a0
movq %rsp, %rdi
callq 0x7490
movq 0x3ac2d(%rip), %rax     # 0x45f88
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x8(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, (%rsp,%rcx)
callq 0x72a0
leaq 0xf8(%rsp), %rdi
callq 0x7100
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x74e0
movq %rbx, %rdi
callq 0x75f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xb3c1
movq %rbx, %rsi
callq 0xb3a6
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xb3d9
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb3e2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: 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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xb3fd
movq %rbx, %rsi
callq 0xb3e2
cmpq $0x0, 0x10(%r14)
je 0xb408
xorl %eax, %eax
jmp 0xb483
cmpq $0x0, 0x8(%r14)
je 0xb4f8
movb $0x1, 0x63106(%rip)     # 0x6e520
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xb844
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
movb $0x0, 0x630a5(%rip)     # 0x6e520
cmpq $0x0, 0x10(%r14)
sete %al
cmpq $0x0, 0x8(%r14)
jne 0xb4f8
testb %al, %al
jne 0xb4f8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
movq 0x10(%r14), %rax
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0xb4ca
movq %rbx, %rsi
callq 0xd306
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7220
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xb946
movq %rbx, %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xb98c
cmpq $0x0, 0x18(%r14)
jne 0xb946
leaq 0x2bb92(%rip), %rsi     # 0x37415
movl $0x2, %edx
movq %rbx, %rdi
callq 0x73a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
movq 0x4ed92(%rip), %rax     # 0x5a650
cmpq 0x4ed83(%rip), %rax     # 0x5a648
je 0xb946
movl $0x8, %r13d
xorl %ebp, %ebp
leaq 0x2bb42(%rip), %r15     # 0x37418
movl $0x8, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73a0
movq 0x4ed5b(%rip), %rax     # 0x5a648
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
movq %rbx, %rdi
callq 0x73a0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %r12, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
movq 0x4ed21(%rip), %rax     # 0x5a650
subq 0x4ed12(%rip), %rax     # 0x5a648
incq %rbp
sarq $0x5, %rax
addq $0x20, %r13
cmpq %rbp, %rax
ja 0xb8d6
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xb957
movq %rbx, %rsi
callq 0xb9e2
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0xb97d
movq %rbx, %rsi
xorl %edx, %edx
movl $0x1, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xba2e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rdi), %rdi
movzbl %dl, %ebp
movzbl %cl, %r14d
testq %rdi, %rdi
je 0xb9b6
movq %rbx, %rsi
movl %ebp, %edx
movl %r14d, %ecx
callq 0xb98c
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0xb9d6
movq %rbx, %rsi
movl %ebp, %edx
movl %r14d, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xbaf8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xb9fd
movq %rbx, %rsi
callq 0xb9e2
movb $0x0, 0x62b1c(%rip)     # 0x6e520
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xba25
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0xba25
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd306
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: 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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x62ae6(%rip), %ecx     # 0x6e524
leal 0x1(%rcx), %eax
movl %eax, 0x62add(%rip)     # 0x6e524
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdi
movq %rax, %rdx
orq %rdi, %rdx
jne 0xbabb
testl %ecx, %ecx
js 0xba7e
xorl %ebp, %ebp
leaq 0x2bc98(%rip), %r14     # 0x376fc
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73a0
incl %ebp
cmpl 0x62aa8(%rip), %ebp     # 0x6e524
jl 0xba64
leaq 0x2b9c3(%rip), %rsi     # 0x37448
movl $0x4, %edx
movq %rbx, %rdi
callq 0x73a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
jmp 0xbaed
testq %rax, %rax
je 0xbad3
testq %rdi, %rdi
je 0xbae2
movq %rbx, %rsi
callq 0xb9e2
movq 0x8(%r14), %rdi
jmp 0xbae5
testq %rdi, %rdi
je 0xbaed
movq %rbx, %rsi
callq 0xb9e2
jmp 0xbaed
movq %rax, %rdi
movq %rbx, %rsi
callq 0xbfec
decl 0x62a31(%rip)           # 0x6e524
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xbd61
movq %rbx, %rsi
callq 0xbd32
leaq 0x2b92a(%rip), %rsi     # 0x3767e
movl $0x1, %edx
movq %rbx, %rdi
callq 0x73a0
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xbd80
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x73a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: 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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xbfb7
movq %rbx, %rsi
callq 0xbf88
leaq 0x2b6d4(%rip), %rsi     # 0x3767e
movl $0x1, %edx
movq %rbx, %rdi
callq 0x73a0
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xbfe3
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0xbfe3
movb $0x1, 0x62558(%rip)     # 0x6e528
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb98c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: 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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xc007
movq %rbx, %rsi
callq 0xbfec
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xc036
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0xc02f
movq %rbx, %rsi
xorl %edx, %edx
movl $0x1, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xba2e
cmpq $0x0, 0x8(%rax)
je 0xc03e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0xc096
movq 0x8(%rcx), %rax
testq %rax, %rax
je 0xc068
movq %rax, %rcx
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xc050
movq 0x8(%rcx), %rdi
movq %rbx, %rsi
callq 0xc8c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7220
movq 0x30(%rax), %rdi
testq %rdi, %rdi
je 0xc0b0
movq %rbx, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc1a2
movq 0x20(%rax), %rdi
testq %rdi, %rdi
je 0xc0c8
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc67e
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0xc036
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc824
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rsi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xc104
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movl $0x1, %ecx
popq %rbx
jmp 0xba2e
cmpq $0x0, 0x8(%rdi)
je 0xc10d
popq %rbx
retq
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0xc15f
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xc137
movq %rax, %rcx
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xc11f
movq 0x8(%rcx), %rdi
movq %rbx, %rsi
callq 0xc8c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
popq %rbx
jmp 0x7220
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0xc177
movzbl %dl, %edx
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0xc1a2
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0xc18c
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0xc67e
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0xc10b
movq %rbx, %rsi
popq %rbx
jmp 0xc824
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rdi
leaq 0x2add0(%rip), %rsi     # 0x37466
callq 0x70c0
testl %eax, %eax
je 0xc6aa
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x8(%r14)
je 0xc69f
cmpq $0x0, 0x10(%r14)
je 0xc69f
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
movb $0x1, 0x61e43(%rip)     # 0x6e529
cmpl $0x0, 0x61e37(%rip)     # 0x6e524
jle 0xc712
xorl %ebp, %ebp
leaq 0x2b004(%rip), %r15     # 0x376fc
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73a0
incl %ebp
cmpl 0x61e14(%rip), %ebp     # 0x6e524
jl 0xc6f8
leaq 0x2ad53(%rip), %rsi     # 0x3746c
movl $0x6, %edx
movq %rbx, %rdi
callq 0x73a0
movq 0x8(%r14), %rax
movq %rax, %rcx
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xc72a
movq 0x8(%rcx), %rdi
movq %rbx, %rsi
callq 0xc8c0
leaq 0x2accc(%rip), %rsi     # 0x37415
movl $0x2, %edx
movq %rbx, %rdi
callq 0x73a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0xc7c1
leaq 0x2acbb(%rip), %rsi     # 0x37448
movl $0x4, %edx
movq %rbx, %rdi
callq 0x73a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
cmpq $0x0, 0x10(%r14)
je 0xc7d7
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xc0e4
jmp 0xc7f0
incl 0x61d47(%rip)           # 0x6e524
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xc0e4
decl 0x61d34(%rip)           # 0x6e524
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
callq 0x7220
movb $0x0, 0x61d0b(%rip)     # 0x6e529
jmp 0xc69f
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x61cec(%rip)     # 0x6e524
jle 0xc85d
xorl %ebp, %ebp
leaq 0x2aeb9(%rip), %r15     # 0x376fc
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73a0
incl %ebp
cmpl 0x61cc9(%rip), %ebp     # 0x6e524
jl 0xc843
movq 0x18(%r14), %rax
testq %rax, %rax
je 0xc889
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x73a0
leaq 0x2b382(%rip), %rsi     # 0x37bfe
movl $0x1, %edx
movq %rax, %rdi
callq 0x73a0
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xc8b4
movq %rax, %rcx
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xc892
movq 0x8(%rcx), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc8c0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r12
testq %r12, %r12
je 0xc9c0
cmpl $0x0, 0x61c3f(%rip)     # 0x6e524
jle 0xc90e
xorl %ebp, %ebp
leaq 0x2ae0c(%rip), %r15     # 0x376fc
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73a0
incl %ebp
cmpl 0x61c1c(%rip), %ebp     # 0x6e524
jl 0xc8f0
movq 0x10(%r14), %r12
leaq 0x2b2e9(%rip), %r15     # 0x37bfe
movq 0x8(%r12), %rdi
testq %rdi, %rdi
jne 0xc9a4
movq 0x18(%r12), %rax
testq %rax, %rax
je 0xc9ac
cmpq $0x0, 0x10(%r12)
je 0xc94c
leaq 0x10(%r12), %r13
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73a0
jmp 0xc96d
cmpq $0x0, 0x28(%r12)
je 0xc995
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73a0
movq 0x28(%r12), %r13
addq $0x8, %r13
movq (%r13), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x73a0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x73a0
movq 0x18(%r12), %rax
movq 0x8(%rax), %r12
testq %r12, %r12
jne 0xc915
jmp 0xc9ac
movq %rbx, %rsi
callq 0xca5a
leaq 0x2ada0(%rip), %rsi     # 0x37753
movl $0x1, %edx
movq %rbx, %rdi
callq 0x73a0
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xc9e1
cmpq $0x0, 0x10(%rax)
jne 0xc9e1
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0xc9e1
movq %rbx, %rsi
callq 0xcd88
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0xc9f2
movq %rbx, %rsi
callq 0xc8c0
cmpb $0x0, 0x61b27(%rip)     # 0x6e520
jne 0xca04
cmpb $0x0, 0x61b27(%rip)     # 0x6e529
je 0xca13
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x0, 0x61b10(%rip)     # 0x6e52a
jne 0xca04
cmpl $0x0, 0x61b09(%rip)     # 0x6e52c
jne 0xca04
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x7300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7220
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x20(%rdi)
je 0xcc8e
leaq 0x2a82c(%rip), %rsi     # 0x37471
movl $0x1, %edx
movq %rbx, %rdi
callq 0x73a0
incl 0x618d4(%rip)           # 0x6e52c
movq 0x20(%r14), %rax
movq %rax, %rcx
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xcc5c
movq 0x8(%rcx), %rdi
movq %rbx, %rsi
callq 0xc8c0
leaq 0x2b994(%rip), %rsi     # 0x3860f
movl $0x1, %edx
movq %rbx, %rdi
callq 0x73a0
decl 0x6189e(%rip)           # 0x6e52c
movq 0x8(%r14), %rax
testq %rax, %rax
jne 0xcca0
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xccb9
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x73a0
cmpq $0x0, 0x18(%r14)
je 0xcd27
leaq 0x2af37(%rip), %r15     # 0x37bfe
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73a0
movb $0x22, %bpl
leaq 0x6(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x73a0
movq 0x18(%r14), %rcx
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
movq %rax, %rdi
callq 0x73a0
leaq 0x7(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x73a0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x73a0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb $0x1, 0x617dd(%rip)     # 0x6e520
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xcd68
movq %rbx, %rsi
callq 0xcd32
leaq 0x2a923(%rip), %rsi     # 0x3767e
movl $0x1, %edx
movq %rbx, %rdi
callq 0x73a0
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xcd80
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc8c0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: 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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rax
testq %rax, %rax
setne %cl
testq %rdi, %rdi
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0xcde4
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xcdc2
movq %rbx, %rsi
callq 0xcd88
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xcddb
leaq 0x2a67f(%rip), %rsi     # 0x3744d
movl $0x4, %edx
movq %rbx, %rdi
callq 0x73a0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xcdf3
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xcdfc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: 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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x18(%r14), %rax
testq %rax, %rax
setne %cl
testq %rdi, %rdi
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0xce58
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xce36
movq %rbx, %rsi
callq 0xcdfc
movq 0x18(%r14), %rax
testq %rax, %rax
je 0xce4f
leaq 0x2a610(%rip), %rsi     # 0x37452
movl $0x5, %edx
movq %rbx, %rdi
callq 0x73a0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xce67
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xce70
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: 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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rax
testq %rax, %rax
setne %cl
testq %rdi, %rdi
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0xcef4
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xceab
movq %rbx, %rsi
callq 0xce70
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xceeb
leaq 0x2ad47(%rip), %r15     # 0x37bfe
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73a0
leaq 0x2aeea(%rip), %rsi     # 0x37db8
movl $0x1, %edx
movq %rbx, %rdi
callq 0x73a0
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73a0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xcf01
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xcf08
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rax
testq %rax, %rax
setne %cl
testq %rdi, %rdi
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0xcf8c
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xcf43
movq %rbx, %rsi
callq 0xcf08
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xcf83
leaq 0x2acaf(%rip), %r15     # 0x37bfe
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73a0
leaq 0x2a4f2(%rip), %rsi     # 0x37458
movl $0x1, %edx
movq %rbx, %rdi
callq 0x73a0
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73a0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xcf99
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xcfa0
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rax
testq %rax, %rax
setne %cl
testq %rdi, %rdi
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0xd024
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xcfdb
movq %rbx, %rsi
callq 0xcfa0
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xd01b
leaq 0x2ac17(%rip), %r15     # 0x37bfe
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73a0
leaq 0x2a3f7(%rip), %rsi     # 0x373f5
movl $0x1, %edx
movq %rbx, %rdi
callq 0x73a0
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73a0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xd031
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xd038
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rax
testq %rax, %rax
setne %cl
testq %rdi, %rdi
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0xd08f
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xd072
movq %rbx, %rsi
callq 0xd038
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xd086
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x73a0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xd09e
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd0a6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: 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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rax
testq %rax, %rax
setne %cl
testq %rdi, %rdi
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0xd0fd
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xd0e0
movq %rbx, %rsi
callq 0xd0a6
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xd0f4
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x73a0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xd10c
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd114
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/gioannides[P]Language_Processors/src/../include/ast/ast_node_python.cpp
// Function: 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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rax
testq %rax, %rax
setne %cl
testq %rdi, %rdi
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0xd16b
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xd14e
movq %rbx, %rsi
callq 0xd114
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xd162
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x73a0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xd17a
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd182
addq $0x8, %rsp
popq %rbx
popq %r14
retq