LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/implementation.cc
// Function: delete_commands(std::__cxx11::list<instruction*, std::allocator<instruction*>>*)
void delete_commands(std::list<instruction*>* commands) {
    if(!commands) {
        return;
    }
    
    std::list<instruction*>::iterator it;
    for(it = commands->begin(); it != commands->end(); ++it) {
        delete (*it);
    }
    delete commands;
}

// Assembly:
testq %rdi, %rdi
je 0x7987
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
cmpq %rbx, %r14
je 0x7959
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x7954
movq (%rdi), %rax
callq *0x8(%rax)
movq (%r14), %r14
jmp 0x7940
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x7976
movq (%rdi), %r14
movl $0x18, %esi
callq 0x3240
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x7961
movl $0x18, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3240
retq
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/type_checker_implementation.cc
// Function: operand_type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
type operand_type(std::string op) {
    if(op == "+" || op == "-" || op == "*" || op == "/" || op == "%" ||
       op == "<" || op == ">" || op == "<=" || op == ">=") {
           return natural;
    } else {
        return boolean;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x50f8(%rip), %rsi      # 0xce01
callq 0x30b0
movl $0x1, %ebx
testl %eax, %eax
je 0x7dba
leaq 0x50e1(%rip), %rsi      # 0xce03
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x7dba
leaq 0x50cc(%rip), %rsi      # 0xce05
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x7dba
leaq 0x50bb(%rip), %rsi      # 0xce07
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x7dba
leaq 0x50aa(%rip), %rsi      # 0xce09
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x7dba
leaq 0x5099(%rip), %rsi      # 0xce0b
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x7dba
leaq 0x5088(%rip), %rsi      # 0xce0d
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x7dba
leaq 0x5077(%rip), %rsi      # 0xce0f
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x7dba
leaq 0x5067(%rip), %rsi      # 0xce12
movq %r14, %rdi
callq 0x30b0
xorl %ebx, %ebx
testl %eax, %eax
sete %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/type_checker_implementation.cc
// Function: return_type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
type return_type(std::string op) {
    if(op == "+" || op == "-" || op == "*" || op == "/" || op == "%") {
           return natural;
    } else {
        return boolean;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x502f(%rip), %rsi      # 0xce01
callq 0x30b0
movl $0x1, %ebx
testl %eax, %eax
je 0x7e2f
leaq 0x501c(%rip), %rsi      # 0xce03
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x7e2f
leaq 0x500b(%rip), %rsi      # 0xce05
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x7e2f
leaq 0x4ffa(%rip), %rsi      # 0xce07
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x7e2f
leaq 0x4fe9(%rip), %rsi      # 0xce09
movq %r14, %rdi
callq 0x30b0
xorl %ebx, %ebx
testl %eax, %eax
sete %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/type_checker_implementation.cc
// Function: assign_instruction::type_check()
void assign_instruction::type_check() {
    if(symbol_table.count(left) == 0) {
        error(line, std::string("Undefined variable: ") + left);
    }
    if(symbol_table[left].symbol_type != right->get_type()) {
        error(line, "Left and right hand sides of assignment are of different types.");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
leaq 0x9ee7(%rip), %rdi      # 0x12250
movq %r14, %rsi
callq 0x8a8a
leaq 0x9ee0(%rip), %rcx      # 0x12258
cmpq %rcx, %rax
jne 0x842f
movl 0x8(%rbx), %r15d
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x4b8e(%rip), %rsi      # 0xcf23
leaq 0x4b9b(%rip), %rdx      # 0xcf37
leaq -0x68(%rbp), %rdi
callq 0x525a
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
leaq -0x68(%rbp), %rdi
callq 0x30c0
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x83da
movq %rdx, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
jmp 0x83e2
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
leaq -0x48(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl %r15d, %edi
callq 0x73ec
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x841a
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3240
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x842f
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x3240
leaq 0x9e1a(%rip), %rdi      # 0x12250
movq %r14, %rsi
callq 0x87fe
movl 0x28(%rax), %r14d
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl %eax, %r14d
je 0x849a
movl 0x8(%rbx), %ebx
leaq -0x78(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x4b68(%rip), %rsi      # 0xcfca
leaq 0x4ba0(%rip), %rdx      # 0xd009
leaq -0x88(%rbp), %r14
movq %r14, %rdi
callq 0x525a
movl %ebx, %edi
movq %r14, %rsi
callq 0x73ec
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x849a
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x3240
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x84c6
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3240
jmp 0x84c6
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x84f5
movq -0x58(%rbp), %rsi
jmp 0x84ed
movq %rax, %rbx
jmp 0x84f5
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x84f5
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x3240
movq %rbx, %rdi
callq 0x3380
nop
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/type_checker_implementation.cc
// Function: if_instruction::type_check()
void if_instruction::type_check() {
    if(condition->get_type() != boolean) {
        error(line, "Condition of 'if' instruction is not boolean.");
    }
    type_check_commands(true_branch);
    type_check_commands(false_branch);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
testl %eax, %eax
je 0x86a8
movl 0x8(%rbx), %r14d
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x4995(%rip), %rsi      # 0xd00a
leaq 0x49bb(%rip), %rdx      # 0xd037
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x525a
movl %r14d, %edi
movq %r15, %rsi
callq 0x73ec
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x86a8
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3240
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x86c8
movq (%r14), %r15
cmpq %r14, %r15
je 0x86c8
movq 0x10(%r15), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r15), %r15
jmp 0x86b4
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
je 0x86e8
movq (%rbx), %r14
cmpq %rbx, %r14
je 0x86e8
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r14), %r14
jmp 0x86d4
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x870d
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3240
movq %rbx, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/type_checker_implementation.cc
// Function: type_check_commands(std::__cxx11::list<instruction*, std::allocator<instruction*>>*)
void type_check_commands(std::list<instruction*>* commands) {
    if(!commands) {
        return;
    }

    std::list<instruction*>::iterator it;
    for(it = commands->begin(); it != commands->end(); ++it) {
        (*it)->type_check();
    }
}

// Assembly:
testq %rdi, %rdi
je 0x873f
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
cmpq %rbx, %r14
je 0x873b
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r14), %r14
jmp 0x8727
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/code_generator_implementation.cc
// Function: get_register[abi:cxx11](type)
std::string get_register(type t) {
    if(t == boolean) {
        return "al";
    } else {
    return "eax";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
testl %esi, %esi
je 0x92a4
leaq 0x3f35(%rip), %rsi      # 0xd1d0
leaq 0x3f31(%rip), %rdx      # 0xd1d3
jmp 0x92b2
leaq 0x3fbb(%rip), %rsi      # 0xd266
leaq 0x3fb6(%rip), %rdx      # 0xd268
movq %rbx, %rdi
callq 0x525a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/code_generator_implementation.cc
// Function: eq_code[abi:cxx11](type)
std::string eq_code(type t) {
    std::stringstream ss;
    if(t == natural) {
        ss << "cmp eax,ecx" << std::endl;
    } else {
        ss << "cmp al,cl" << std::endl;
    }
    ss << "mov al,0" << std::endl;
    ss << "mov cx,1" << std::endl;
    ss << "cmove ax,cx" << std::endl;
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x198(%rbp), %rdi
callq 0x3190
xorl %eax, %eax
cmpl $0x1, %r14d
sete %al
leaq -0x188(%rbp), %r14
leaq 0x3527(%rip), %rcx      # 0xd130
leaq 0x35b1(%rip), %rsi      # 0xd1c1
cmoveq %rcx, %rsi
leaq 0x9(,%rax,2), %rdx
movq %r14, %rdi
callq 0x3270
movq -0x188(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
leaq 0x34e6(%rip), %rsi      # 0xd13c
movl $0x8, %edx
movq %r14, %rdi
callq 0x3270
movq -0x188(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
leaq 0x34b0(%rip), %rsi      # 0xd145
movl $0x8, %edx
movq %r14, %rdi
callq 0x3270
movq -0x188(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
leaq 0x34b5(%rip), %rsi      # 0xd189
movl $0xb, %edx
movq %r14, %rdi
callq 0x3270
movq -0x188(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
leaq -0x180(%rbp), %rsi
movq %rbx, %rdi
callq 0x3320
movq 0x8286(%rip), %rsi      # 0x11fa8
leaq -0x198(%rbp), %rdi
callq 0x31b0
leaq -0x118(%rbp), %rdi
callq 0x30d0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x8255(%rip), %rsi      # 0x11fa8
leaq -0x198(%rbp), %rdi
callq 0x31b0
leaq -0x118(%rbp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x3380
nop
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/code_generator_implementation.cc
// Function: not_expression::get_code[abi:cxx11]() const
std::string not_expression::get_code() const {
    std::stringstream ss;
    ss << operand->get_code();
    ss << "xor al,1" << std::endl;
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1b8(%rbp), %rdi
callq 0x3190
movq 0x30(%r14), %rsi
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *0x18(%rax)
leaq -0x1a8(%rbp), %r14
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq %r14, %rdi
callq 0x3270
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa09c
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x3240
leaq 0x3145(%rip), %rsi      # 0xd1e8
movl $0x8, %edx
movq %r14, %rdi
callq 0x3270
movq -0x1a8(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
leaq -0x1a0(%rbp), %rsi
movq %rbx, %rdi
callq 0x3320
movq 0x7eb7(%rip), %rsi      # 0x11fa8
leaq -0x1b8(%rbp), %rdi
callq 0x31b0
leaq -0x138(%rbp), %rdi
callq 0x30d0
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa13b
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x3240
jmp 0xa13b
jmp 0xa138
movq %rax, %rbx
movq 0x7e66(%rip), %rsi      # 0x11fa8
leaq -0x1b8(%rbp), %rdi
callq 0x31b0
leaq -0x138(%rbp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/code_generator_implementation.cc
// Function: get_type_name[abi:cxx11](type)
std::string get_type_name(type t) {
    if(t == boolean) {
        return "boolean";
    } else {
        return "natural";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
testl %esi, %esi
je 0xa3ee
leaq 0x2e7c(%rip), %rsi      # 0xd261
leaq 0x2e7c(%rip), %rdx      # 0xd268
jmp 0xa3fc
leaq 0x2e95(%rip), %rsi      # 0xd28a
leaq 0x2e95(%rip), %rdx      # 0xd291
movq %rbx, %rdi
callq 0x525a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/code_generator_implementation.cc
// Function: read_instruction::get_code[abi:cxx11]()
std::string read_instruction::get_code() {
    type t = symbol_table[id].symbol_type;
    std::stringstream ss;
    ss << "call read_" << get_type_name(t) << std::endl;
    ss << "mov [" << symbol_table[id].label << "]," << get_register(t) << std::endl;
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r15
movq %rdi, %rbx
addq $0x10, %r15
leaq 0x7e1d(%rip), %rdi      # 0x12250
movq %r15, %rsi
callq 0x87fe
movl 0x28(%rax), %r14d
leaq -0x1d0(%rbp), %rdi
callq 0x3190
leaq -0x1c0(%rbp), %r12
leaq 0x2da1(%rip), %rsi      # 0xd1fa
movl $0xa, %edx
movq %r12, %rdi
callq 0x3270
leaq -0x48(%rbp), %rdi
movl %r14d, %esi
callq 0xa3ca
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r12, %rdi
callq 0x3270
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %esi
movq %r13, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
leaq -0x38(%rbp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0xa4c5
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3240
leaq 0x2d25(%rip), %rsi      # 0xd1f1
movl $0x5, %edx
movq %r12, %rdi
callq 0x3270
leaq 0x7d70(%rip), %rdi      # 0x12250
movq %r15, %rsi
callq 0x87fe
movq 0x30(%rax), %rsi
movq 0x38(%rax), %rdx
movq %r12, %rdi
callq 0x3270
movq %rax, %r15
leaq 0x2cf5(%rip), %rsi      # 0xd1f7
movl $0x2, %edx
movq %rax, %rdi
callq 0x3270
leaq -0x48(%rbp), %rdi
movl %r14d, %esi
callq 0x9280
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x3270
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0xa56a
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3240
leaq -0x1b8(%rbp), %rsi
movq %rbx, %rdi
callq 0x3320
movq 0x7a28(%rip), %rsi      # 0x11fa8
leaq -0x1d0(%rbp), %rdi
callq 0x31b0
leaq -0x150(%rbp), %rdi
callq 0x30d0
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa5dd
jmp 0xa5dd
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
jne 0xa5cf
jmp 0xa5e0
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa5e0
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3240
jmp 0xa5e0
movq %rax, %rbx
movq 0x79c1(%rip), %rsi      # 0x11fa8
leaq -0x1d0(%rbp), %rdi
callq 0x31b0
leaq -0x150(%rbp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x3380
nop
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/code_generator_implementation.cc
// Function: write_instruction::get_code[abi:cxx11]()
std::string write_instruction::get_code() {
    std::stringstream ss;
    ss << exp->get_code();
    if(exp_type == boolean) {
        ss << "and eax,1" << std::endl;
    }
    ss << "push eax" << std::endl;
    ss << "call write_" << get_type_name(exp_type) << std::endl;
    ss << "add esp,4" << std::endl;
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x1c8(%rbp), %rdi
callq 0x3190
movq 0x10(%r15), %rsi
movq (%rsi), %rax
leaq -0x40(%rbp), %rdi
callq *0x18(%rax)
leaq -0x1b8(%rbp), %r14
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %r14, %rdi
callq 0x3270
leaq -0x30(%rbp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0xa66b
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3240
cmpl $0x0, 0x18(%r15)
jne 0xa6b1
leaq 0x2b8c(%rip), %rsi      # 0xd205
movl $0x9, %edx
movq %r14, %rdi
callq 0x3270
movq -0x1b8(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
leaq 0x2b13(%rip), %rsi      # 0xd1cb
movl $0x8, %edx
movq %r14, %rdi
callq 0x3270
movq -0x1b8(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
leaq 0x2b18(%rip), %rsi      # 0xd20f
movl $0xb, %edx
movq %r14, %rdi
callq 0x3270
movl 0x18(%r15), %esi
leaq -0x40(%rbp), %rdi
callq 0xa3ca
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %r14, %rdi
callq 0x3270
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xa760
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3240
leaq 0x2ab4(%rip), %rsi      # 0xd21b
movl $0x9, %edx
movq %r14, %rdi
callq 0x3270
movq -0x1b8(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
leaq -0x1b0(%rbp), %rsi
movq %rbx, %rdi
callq 0x3320
movq 0x77f3(%rip), %rsi      # 0x11fa8
leaq -0x1c8(%rbp), %rdi
callq 0x31b0
leaq -0x148(%rbp), %rdi
callq 0x30d0
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa810
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0xa802
jmp 0xa813
jmp 0xa810
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xa813
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3240
jmp 0xa813
movq %rax, %rbx
movq 0x778e(%rip), %rsi      # 0x11fa8
leaq -0x1c8(%rbp), %rdi
callq 0x31b0
leaq -0x148(%rbp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/code_generator_implementation.cc
// Function: generate_code_of_commands(std::ostream&, std::__cxx11::list<instruction*, std::allocator<instruction*>>*)
void generate_code_of_commands(std::ostream& out, std::list<instruction*>* commands) {
    if(!commands) {
        return;
    }

    std::list<instruction*>::iterator it;
    for(it = commands->begin(); it != commands->end(); ++it) {
        out << (*it)->get_code();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rsi, %rsi
je 0xab9e
movq %rsi, %rbx
movq (%rsi), %r13
cmpq %rsi, %r13
je 0xab9e
movq %rdi, %r14
leaq -0x38(%rbp), %r12
leaq -0x48(%rbp), %r15
movq 0x10(%r13), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x18(%rax)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r14, %rdi
callq 0x3270
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xab95
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3240
movq (%r13), %r13
cmpq %rbx, %r13
jne 0xab63
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xabc5
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3240
movq %rbx, %rdi
callq 0x3380
nop
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/interpreter_implementation.cc
// Function: read_instruction::execute()
void read_instruction::execute() {
    std::string input_line;
    getline(std::cin, input_line);
    if(symbol_table[id].symbol_type == natural) {
        std::stringstream ss(input_line);
        unsigned input;
        ss >> input;
        value_table[id] = input;
    } else if(symbol_table[id].symbol_type == boolean) {
        if(input_line == "true") {
            value_table[id] = 1;
        } else {
            value_table[id] = 0;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, %rbx
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq 0x689c(%rip), %rdi      # 0x11fd8
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %edx
movq 0x6881(%rip), %rdi      # 0x11fd8
leaq -0x40(%rbp), %rsi
callq 0x33b0
addq $0x10, %rbx
leaq 0x6ae5(%rip), %rdi      # 0x12250
movq %rbx, %rsi
callq 0x87fe
cmpl $0x1, 0x28(%rax)
jne 0xb7d5
leaq -0x1c8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x18, %edx
callq 0x3330
leaq -0x1c8(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x3370
movl -0x1c(%rbp), %r15d
leaq 0x6ae7(%rip), %rdi      # 0x12290
movq %rbx, %rsi
callq 0xba0c
movl %r15d, (%rax)
movq 0x67ed(%rip), %rsi      # 0x11fa8
leaq -0x1c8(%rbp), %rdi
callq 0x31b0
leaq -0x148(%rbp), %rdi
callq 0x30d0
jmp 0xb82a
leaq 0x6a74(%rip), %rdi      # 0x12250
movq %rbx, %rsi
callq 0x87fe
cmpl $0x0, 0x28(%rax)
jne 0xb82a
leaq 0x1b09(%rip), %rsi      # 0xd2fa
leaq -0x40(%rbp), %rdi
callq 0x30b0
testl %eax, %eax
je 0xb815
leaq 0x6a8b(%rip), %rdi      # 0x12290
movq %rbx, %rsi
callq 0xba0c
movl $0x0, (%rax)
jmp 0xb82a
leaq 0x6a74(%rip), %rdi      # 0x12290
movq %rbx, %rsi
callq 0xba0c
movl $0x1, (%rax)
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0xb83f
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3240
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb873
movq %rax, %rbx
movq 0x674f(%rip), %rsi      # 0x11fa8
leaq -0x1c8(%rbp), %rdi
callq 0x31b0
leaq -0x148(%rbp), %rdi
callq 0x30d0
jmp 0xb876
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0xb88b
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3240
movq %rbx, %rdi
callq 0x3380
nop
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/interpreter_implementation.cc
// Function: write_instruction::execute()
void write_instruction::execute() {
    if(exp_type == natural) {
        std::cout << exp->get_value() << std::endl;
    } else if(exp_type == boolean) {
        if(exp->get_value()) {
            std::cout << "true" << std::endl;
        } else {
            std::cout << "false" << std::endl;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0x18(%rdi), %eax
testl %eax, %eax
je 0xb8c3
cmpl $0x1, %eax
jne 0xb8e6
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movl %eax, %esi
movq 0x6707(%rip), %rdi      # 0x11fc0
callq 0x3160
movq %rax, %rbx
jmp 0xb901
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x66ec(%rip), %rbx      # 0x11fc0
testl %eax, %eax
je 0xb8ed
leaq 0x1a1b(%rip), %rsi      # 0xd2fa
movl $0x4, %edx
jmp 0xb8f9
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1a0b(%rip), %rsi      # 0xd2ff
movl $0x5, %edx
movq %rbx, %rdi
callq 0x3270
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3210
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3170
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/interpreter_implementation.cc
// Function: if_instruction::execute()
void if_instruction::execute() {
    if(condition->get_value()) {
        execute_commands(true_branch);
    } else {
        execute_commands(false_branch);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testl %eax, %eax
je 0xb966
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
je 0xb986
movq (%rbx), %r14
cmpq %rbx, %r14
je 0xb986
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq (%r14), %r14
jmp 0xb952
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
je 0xb986
movq (%rbx), %r14
cmpq %rbx, %r14
je 0xb986
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq (%r14), %r14
jmp 0xb972
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/devaigergely81[P]flex-bison-example/interpreter_implementation.cc
// Function: execute_commands(std::__cxx11::list<instruction*, std::allocator<instruction*>>*)
void execute_commands(std::list<instruction*>* commands) {
    if(!commands) {
        return;
    }

    std::list<instruction*>::iterator it;
    for(it = commands->begin(); it != commands->end(); ++it) {
        (*it)->execute();
    }
}

// Assembly:
testq %rdi, %rdi
je 0xb9b5
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
cmpq %rbx, %r14
je 0xb9b1
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq (%r14), %r14
jmp 0xb99d
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/lipiji[P]PG_DEEP/deep.cpp
// Function: sample_from_gaussian(double, double)
double sample_from_gaussian(double miu, double sigma)
{
    //std::default_random_engine generator;
    //std::normal_distribution<double> distribution(miu, sigma);
    //reutrn distribution(generator);

    static double V1, V2, S;
    static int phase = 0;
    double X;

    if (phase == 0)
    {
        do
        {
            double U1 = (double)rand() / RAND_MAX;
            double U2 = (double)rand() / RAND_MAX;

            V1 = 2 * U1 - 1;
            V2 = 2 * U2 - 1;
            S = V1 * V1 + V2 * V2;
        } while(S >= 1 || S == 0);

        X = V1 * sqrt(-2 * log(S) / S);
    } else
        X = V2 * sqrt(-2 * log(S) / S);

    phase = 1 - phase;

    return X * sigma + miu;
}

// Assembly:
subq $0x18, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
cmpl $0x0, 0x6dad(%rip)      # 0xa1b8
je 0x3427
movsd 0x6d93(%rip), %xmm0     # 0xa1a8
movsd %xmm0, (%rsp)
movsd 0x6d8e(%rip), %xmm0     # 0xa1b0
jmp 0x34b4
callq 0x2080
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movsd 0x3c85(%rip), %xmm0     # 0x70c0
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
callq 0x2080
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd 0x3c68(%rip), %xmm1     # 0x70c0
movsd (%rsp), %xmm2
addsd %xmm2, %xmm2
movsd 0x3c5f(%rip), %xmm0     # 0x70c8
addsd %xmm0, %xmm2
addsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x6d2b(%rip)     # 0xa1a8
mulsd %xmm1, %xmm1
movsd %xmm2, (%rsp)
movapd %xmm2, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x6d16(%rip)     # 0xa1b0
ucomisd 0x3b76(%rip), %xmm0     # 0x7018
jae 0x3427
ucomisd 0x3c2c(%rip), %xmm0     # 0x70d8
jne 0x34b4
jnp 0x3427
callq 0x2150
mulsd 0x3c0f(%rip), %xmm0     # 0x70d0
divsd 0x6ce7(%rip), %xmm0     # 0xa1b0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x34d9
sqrtsd %xmm0, %xmm0
jmp 0x34de
callq 0x2140
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
movl $0x1, %eax
subl 0x6cc6(%rip), %eax      # 0xa1b8
movl %eax, 0x6cc0(%rip)      # 0xa1b8
mulsd 0x8(%rsp), %xmm1
addsd 0x10(%rsp), %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/lipiji[P]PG_DEEP/deep.cpp
// Function: binomial(int, double)
int binomial(int n, double p) 
{
    if(p < 0 || p > 1) return 0;

    int c = 0;
    double r;

    for(int i=0; i<n; i++) {
        r = rand() / (RAND_MAX + 1.0);
        if (r < p) c++;
    }

    return c;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movsd 0x3ad9(%rip), %xmm3     # 0x7018
cmpltpd %xmm0, %xmm3
xorpd %xmm1, %xmm1
movapd %xmm0, %xmm2
cmpltpd %xmm1, %xmm2
orpd %xmm3, %xmm2
movd %xmm2, %eax
testl %edi, %edi
setle %cl
xorl %ebp, %ebp
orb %al, %cl
testb $0x1, %cl
jne 0x3598
movl %edi, %ebx
xorl %ebp, %ebp
movapd %xmm0, (%rsp)
callq 0x2080
movapd (%rsp), %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
mulsd 0x3b57(%rip), %xmm1     # 0x70e0
xorl %eax, %eax
ucomisd %xmm1, %xmm0
seta %al
addl %eax, %ebp
decl %ebx
jne 0x3570
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/lipiji[P]PG_DEEP/deep.cpp
// Function: square_error(double*, double*, int)
double square_error(double *v1, double *v2, int size)
{
    double error = 0;
    for(int i=0; i<size; i++)
        error += pow((v1[i] - v2[i]), 2);

    return error;
}

// Assembly:
testl %edx, %edx
jle 0x35c8
movl %edx, %eax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
movsd (%rdi,%rcx,8), %xmm1
subsd (%rsi,%rcx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x35ad
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/lipiji[P]PG_DEEP/deep.cpp
// Function: max_i_(double*, int)
int max_i_(double *x, int l)
{
    double max_v = x[0];
    double max_i = 0;
    for(int i=0; i<l; i++)
    {
        if(x[i] > max_v)
        {
            max_v = x[i];
            max_i = i;
        }
    }
    return max_i;
}

// Assembly:
testl %esi, %esi
jle 0x3616
movsd (%rdi), %xmm1
movl %esi, %eax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
movsd (%rdi,%rcx,8), %xmm2
xorps %xmm3, %xmm3
cvtsi2sd %ecx, %xmm3
movapd %xmm2, %xmm4
maxsd %xmm1, %xmm4
cmpltsd %xmm2, %xmm1
andpd %xmm1, %xmm3
andnpd %xmm0, %xmm1
orpd %xmm3, %xmm1
movapd %xmm1, %xmm0
incq %rcx
movapd %xmm4, %xmm1
cmpq %rcx, %rax
jne 0x35dc
cvttsd2si %xmm0, %eax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/lipiji[P]PG_DEEP/deep.cpp
// Function: Conf::Conf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, int*, int, double, int, int, double)
Conf::Conf(string ftx, string fty, int epc, int bs, int *hls, int k, double lr, int n_ly, int n_lb, double lbd)
{
    f_train_x = ftx;
    f_train_y = fty;
    epoch = epc;
    batch_size = bs;
    hidden_layer_size = hls;
    cd_k = k;
    learning_rate = lr;
    n_layers = n_ly;
    n_labels = n_lb;
    lamda = lbd;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm1, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movq %r9, 0x20(%rsp)
movl %r8d, %ebp
movl %ecx, %r12d
movq %rdx, %r13
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x30(%rdi), %rcx
movq %rcx, 0x10(%rsp)
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x50(%rdi), %rcx
movq %rcx, 0x8(%rsp)
movq %rcx, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x70(%rdi), %r15
movq %r15, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movb %al, 0x70(%rdi)
callq 0x20f0
movq %r14, %rdi
movq %r13, %rsi
callq 0x20f0
movl 0x80(%rsp), %eax
movl 0x78(%rsp), %ecx
movl 0x70(%rsp), %edx
movl %r12d, 0x80(%rbx)
movl %ebp, 0x84(%rbx)
movq 0x20(%rsp), %rsi
movq %rsi, 0x88(%rbx)
movl %edx, 0x90(%rbx)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x98(%rbx)
movl %ecx, 0xa0(%rbx)
movl %eax, 0xa4(%rbx)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0xa8(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq 0x60(%rbx), %rdi
cmpq %r15, %rdi
je 0x3721
movq (%r15), %rsi
incq %rsi
callq 0x21c0
movq 0x40(%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x373c
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21c0
movq (%r14), %rdi
cmpq 0x10(%rsp), %rdi
je 0x3756
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21c0
movq (%rbx), %rdi
cmpq 0x18(%rsp), %rdi
je 0x3770
movq 0x18(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21c0
movq %r12, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/lipiji[P]PG_DEEP/deep.cpp
// Function: RBM::RBM(int, int, int, double**, double*, double*, double, double)
RBM::RBM(int N, int n_f, int n_h, double **w, double *hb, double *vb, double lbd, double mmt)
{
    n_samples = N;
    n_visible = n_f;
    n_hidden = n_h;
    error = 0.0;
    lamda = lbd;
    momentum = mmt;

    if(w == NULL)
    {
        W = new double*[n_hidden];
        for(int i=0; i<n_hidden; i++)
            W[i] = new double[n_visible];
        for(int i=0; i<n_hidden; i++)
            for(int j=0; j<n_visible; j++)
                W[i][j] = sample_from_gaussian(0, 0.01);
    }
    else
    {
        W = w;
    }

    if(hb == NULL)
    {
        hbias = new double[n_hidden];
        for(int i=0; i<n_hidden; i++)
            hbias[i] = 0;
    }
    else
        hbias = hb;

    if(vb == NULL)
    {
        vbias = new double[n_visible];
        for(int i=0; i<n_visible; i++)
            vbias[i] = 0;
    }
    else
        vbias = vb;


}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %rdi, %rbx
movq 0x40(%rsp), %r13
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
movq $0x0, 0x28(%rdi)
movsd %xmm0, 0x30(%rdi)
movsd %xmm1, 0x38(%rdi)
testq %r8, %r8
je 0x43ba
movq %r8, 0x10(%rbx)
jmp 0x445a
movl %ecx, %ebp
movl %edx, %r15d
movslq %ecx, %rdi
shlq $0x3, %rdi
testl %ecx, %ecx
movq $-0x1, %rax
cmovsq %rax, %rdi
callq 0x2030
movq %rax, 0x10(%rbx)
testl %ebp, %ebp
jle 0x4412
movq $-0x1, %rax
movslq %r15d, %r12
shlq $0x3, %r12
testl %r15d, %r15d
cmovsq %rax, %r12
movl %ebp, %r15d
xorl %ebp, %ebp
movq %r12, %rdi
callq 0x2030
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%rbp,8)
incq %rbp
cmpq %rbp, %r15
jne 0x43fa
cmpl $0x0, 0x8(%rbx)
jle 0x445a
xorl %r15d, %r15d
cmpl $0x0, 0x4(%rbx)
jle 0x444e
xorl %r12d, %r12d
xorps %xmm0, %xmm0
movsd 0x2cb9(%rip), %xmm1     # 0x70e8
callq 0x33f4
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jl 0x4424
incq %r15
movslq 0x8(%rbx), %rax
cmpq %rax, %r15
jl 0x441b
testq %r14, %r14
je 0x4465
movq %r14, 0x18(%rbx)
jmp 0x449a
movslq 0x8(%rbx), %r15
leaq (,%r15,8), %r14
testq %r15, %r15
movq $-0x1, %rdi
cmovnsq %r14, %rdi
callq 0x2030
movq %rax, 0x18(%rbx)
testq %r15, %r15
jle 0x449a
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2100
testq %r13, %r13
je 0x44b2
movq %r13, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq 0x4(%rbx), %r15
leaq (,%r15,8), %r14
testq %r15, %r15
movq $-0x1, %rdi
cmovnsq %r14, %rdi
callq 0x2030
movq %rax, 0x20(%rbx)
testq %r15, %r15
jle 0x44a3
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O1/lipiji[P]PG_DEEP/deep.cpp
// Function: RBM::activate_hidden(double*, double*, int*, int, int)
void RBM::activate_hidden(double *v_prob, double *h_prob, int *h_state, int n_visible, int n_hidden)
{	
    //v->h
    for(int i=0; i<n_hidden; i++)
    {
        double vh_prob = 0;
        for(int j=0; j<n_visible; j++)
        {
            // prob or state?
            vh_prob += v_prob[j] * W[i][j];
        }
        vh_prob += hbias[i];
        h_prob[i] = sigmoid(vh_prob);
        if(h_state != NULL)
            h_state[i] = binomial(1, h_prob[i]);
    }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, 0xc(%rsp)
movq %rdx, 0x10(%rsp)
testl %r9d, %r9d
jle 0x45af
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %r13
movl %r9d, %ebp
movl 0xc(%rsp), %r15d
xorl %ebx, %ebx
cmpl $0x0, 0xc(%rsp)
jle 0x4558
movq 0x10(%r13), %rax
movq (%rax,%rbx,8), %rax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
movsd (%r12,%rcx,8), %xmm1
mulsd (%rax,%rcx,8), %xmm1
addsd %xmm1, %xmm0
incq %rcx
cmpq %rcx, %r15
jne 0x453f
jmp 0x455c
xorpd %xmm0, %xmm0
movq 0x18(%r13), %rax
addsd (%rax,%rbx,8), %xmm0
xorpd 0x2b93(%rip), %xmm0     # 0x7100
callq 0x22c0
movapd %xmm0, %xmm1
movsd 0x2a9a(%rip), %xmm0     # 0x7018
addsd %xmm0, %xmm1
divsd %xmm1, %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax,%rbx,8)
testq %r14, %r14
je 0x45a3
movl $0x1, %edi
callq 0x3531
movl %eax, (%r14,%rbx,4)
incq %rbx
cmpq %rbp, %rbx
jne 0x452a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/lipiji[P]PG_DEEP/deep.cpp
// Function: RBM::activate_visible(int*, double*, int*, int, int)
void RBM::activate_visible(int *h_state, double *v_prob, int *v_state, int n_hidden, int n_visible)
{	
    //h->v
    for(int i=0; i<n_visible; i++)
    {
        double hv_prob = 0;
        for(int j=0; j<n_hidden; j++)
        {
            hv_prob += h_state[j] * W[j][i];
        }
        hv_prob += vbias[i];
        v_prob[i] = sigmoid(hv_prob);
        v_state[i] = binomial(1, v_prob[i]);
    }	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
testl %r9d, %r9d
jle 0x4679
movl %r8d, %ebx
movq %rsi, %r12
movq %rdi, %r13
movl %r9d, %ebp
movl %r8d, %r14d
xorl %r15d, %r15d
testl %ebx, %ebx
jle 0x4620
movq 0x10(%r13), %rax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
xorps %xmm1, %xmm1
cvtsi2sdl (%r12,%rcx,4), %xmm1
movq (%rax,%rcx,8), %rdx
mulsd (%rdx,%r15,8), %xmm1
addsd %xmm1, %xmm0
incq %rcx
cmpq %rcx, %r14
jne 0x45ff
jmp 0x4624
xorpd %xmm0, %xmm0
movq 0x20(%r13), %rax
addsd (%rax,%r15,8), %xmm0
xorpd 0x2aca(%rip), %xmm0     # 0x7100
callq 0x22c0
movsd 0x29d5(%rip), %xmm1     # 0x7018
addsd %xmm1, %xmm0
divsd %xmm0, %xmm1
movq 0x8(%rsp), %rax
movsd %xmm1, (%rax,%r15,8)
movl $0x1, %edi
movapd %xmm1, %xmm0
callq 0x3531
movq 0x10(%rsp), %rcx
movl %eax, (%rcx,%r15,4)
incq %r15
cmpq %rbp, %r15
jne 0x45f1
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/lipiji[P]PG_DEEP/deep.cpp
// Function: RBM::~RBM()
RBM::~RBM()
{
    for(int i=0; i < n_hidden; i++)
        delete[] W[i];
    delete[] W;
    delete[] hbias;
    delete[] vbias;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
jle 0x4934
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x4928
callq 0x2210
incq %r14
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
jl 0x4916
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x4942
callq 0x2210
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x4950
callq 0x2210
movq 0x20(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x4965
popq %rbx
popq %r14
jmp 0x2210
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/lipiji[P]PG_DEEP/deep.cpp
// Function: LR::LR(Dataset, Conf)
LR::LR(Dataset data, Conf conf)
{
    n_samples = data.N;
    n_features = data.n_f;
    n_labels = conf.n_labels;
    lamda = conf.lamda;

    W = new double*[n_labels];
    for(int i=0; i<n_labels; i++)
        W[i] = new double[n_features];
    b = new double[n_labels];

    for(int i=0; i<n_labels; i++)
    {
        for(int j=0; j<n_features; j++)
            W[i][j] = 0;
        b[i] = 0;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %eax
movl %eax, (%rdi)
movslq 0x4(%rsi), %r12
movl %r12d, 0x4(%rdi)
movslq 0xa4(%rdx), %r13
leaq (,%r13,8), %r14
testq %r13, %r13
movl %r13d, 0x8(%rdi)
movsd 0xa8(%rdx), %xmm0
movsd %xmm0, 0x10(%rdi)
movq $-0x1, %rbp
cmovsq %rbp, %r14
movq %r14, %rdi
callq 0x2030
movq %rax, 0x18(%rbx)
testq %r13, %r13
jle 0x49ec
leaq (,%r12,8), %r15
testl %r12d, %r12d
cmovsq %rbp, %r15
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x2030
movq 0x18(%rbx), %rcx
movq %rax, (%rcx,%rbp,8)
incq %rbp
cmpq %rbp, %r13
jne 0x49d4
movq %r14, %rdi
callq 0x2030
movq %rax, 0x20(%rbx)
testl %r13d, %r13d
jle 0x4a30
movq %rax, %r14
movq 0x18(%rbx), %r15
movl %r12d, %ebx
shlq $0x3, %rbx
xorl %ebp, %ebp
testl %r12d, %r12d
jle 0x4a20
movq (%r15,%rbp,8), %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x2100
movq $0x0, (%r14,%rbp,8)
incq %rbp
cmpq %rbp, %r13
jne 0x4a0d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/lipiji[P]PG_DEEP/deep.cpp
// Function: LR::LR(int, int, int, double)
LR::LR(int N, int n_f, int n_lb, double lbd)
{
    n_samples = N;
    n_features = n_f;
    n_labels = n_lb;
    lamda = lbd;

    W = new double*[n_labels];
    for(int i=0; i<n_labels; i++)
        W[i] = new double[n_features];
    b = new double[n_labels];

    for(int i=0; i<n_labels; i++)
    {
        for(int j=0; j<n_features; j++)
            W[i][j] = 0;
        b[i] = 0;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %ebx
movq %rdi, %r14
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
movsd %xmm0, 0x10(%rdi)
movslq %ecx, %r12
leaq (,%r12,8), %r15
testl %r12d, %r12d
movq $-0x1, %rax
cmovsq %rax, %r15
movq %r15, %rdi
callq 0x2030
movq %rax, 0x18(%r14)
movl %ebp, 0x4(%rsp)
movl %ebp, %r13d
testl %r12d, %r12d
jle 0x4abe
movslq %ebx, %r12
shlq $0x3, %r12
testl %ebx, %ebx
movq $-0x1, %rax
cmovsq %rax, %r12
xorl %ebp, %ebp
movq %r12, %rdi
callq 0x2030
movq 0x18(%r14), %rcx
movq %rax, (%rcx,%rbp,8)
incq %rbp
cmpq %rbp, %r13
jne 0x4aa6
movq %r15, %rdi
callq 0x2030
movq %rax, 0x20(%r14)
cmpl $0x0, 0x4(%rsp)
jle 0x4b03
movq %rax, %r15
movq 0x18(%r14), %r12
movl %ebx, %r14d
shlq $0x3, %r14
xorl %ebp, %ebp
testl %ebx, %ebx
jle 0x4af3
movq (%r12,%rbp,8), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2100
movq $0x0, (%r15,%rbp,8)
incq %rbp
cmpq %rbp, %r13
jne 0x4ae1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/lipiji[P]PG_DEEP/deep.cpp
// Function: LR::~LR()
LR::~LR()
{
    for(int i=0; i<n_labels; i++)
        delete[] W[i];
    delete[] W;
    delete[] b;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
jle 0x4b40
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x4b34
callq 0x2210
incq %r14
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
jl 0x4b22
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x4b4e
callq 0x2210
movq 0x20(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x4b63
popq %rbx
popq %r14
jmp 0x2210
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/lipiji[P]PG_DEEP/deep.cpp
// Function: LR::train(double*, int*, double)
void LR::train(double *x, int *y, double gamma)
{
    double *h_theta_x = new double[n_labels];
    double *dy = new double[n_labels];

    for(int i=0; i<n_labels; i++) 
    {
        h_theta_x[i] = 0;
        for(int j=0; j<n_features; j++) 
        {
            h_theta_x[i] += W[i][j] * x[j];
        }
        h_theta_x[i] += b[i];
    }
    softmax(h_theta_x);

    for(int i=0; i<n_labels; i++) 
    {
        dy[i] = (y[i]==1 ? 1:0) - h_theta_x[i];

        for(int j=0; j<n_features; j++) 
        {
            W[i][j] -= gamma * (-1*dy[i] * x[j] + lamda * W[i][j]);
        }

        b[i] += gamma * dy[i];
    }
    delete[] h_theta_x;
    delete[] dy;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movapd %xmm0, (%rsp)
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movslq 0x8(%rdi), %rbp
leaq (,%rbp,8), %rax
testq %rbp, %rbp
movq $-0x1, %r13
cmovnsq %rax, %r13
movq %r13, %rdi
callq 0x2030
movq %rax, %r12
movq %r13, %rdi
callq 0x2030
movq %rax, %r13
testq %rbp, %rbp
jle 0x4c17
movl 0x4(%r15), %eax
movq 0x18(%r15), %rcx
movq 0x20(%r15), %rdx
xorl %esi, %esi
movq $0x0, (%r12,%rsi,8)
testl %eax, %eax
jle 0x4bfe
movq (%rcx,%rsi,8), %rdi
movsd (%r12,%rsi,8), %xmm0
xorl %r8d, %r8d
movsd (%rdi,%r8,8), %xmm1
mulsd (%r14,%r8,8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%r12,%rsi,8)
incq %r8
cmpq %r8, %rax
jne 0x4be0
movsd (%rdx,%rsi,8), %xmm0
addsd (%r12,%rsi,8), %xmm0
movsd %xmm0, (%r12,%rsi,8)
incq %rsi
cmpq %rbp, %rsi
jne 0x4bc7
movq %r15, %rdi
movq %r12, %rsi
callq 0x4cee
movslq 0x8(%r15), %rax
testq %rax, %rax
movapd (%rsp), %xmm5
jle 0x4cd0
movl 0x4(%r15), %ecx
movq 0x18(%r15), %rdx
movapd 0x24bc(%rip), %xmm0     # 0x7100
xorpd %xmm5, %xmm0
movq 0x20(%r15), %rsi
xorl %edi, %edi
movsd 0x23c2(%rip), %xmm1     # 0x7018
cmpl $0x1, (%rbx,%rdi,4)
movapd %xmm1, %xmm2
je 0x4c64
xorpd %xmm2, %xmm2
subsd (%r12,%rdi,8), %xmm2
movsd %xmm2, (%r13,%rdi,8)
testl %ecx, %ecx
jle 0x4cb3
movq (%rdx,%rdi,8), %r8
xorl %r9d, %r9d
movsd (%r13,%rdi,8), %xmm2
movsd (%r8,%r9,8), %xmm3
movsd 0x10(%r15), %xmm4
mulsd %xmm3, %xmm4
mulsd (%r14,%r9,8), %xmm2
subsd %xmm2, %xmm4
mulsd %xmm0, %xmm4
addsd %xmm3, %xmm4
movsd %xmm4, (%r8,%r9,8)
incq %r9
cmpq %r9, %rcx
jne 0x4c7c
movsd (%r13,%rdi,8), %xmm2
mulsd %xmm5, %xmm2
addsd (%rsi,%rdi,8), %xmm2
movsd %xmm2, (%rsi,%rdi,8)
incq %rdi
cmpq %rax, %rdi
jne 0x4c56
movq %r12, %rdi
callq 0x2210
movq %r13, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/lipiji[P]PG_DEEP/deep.cpp
// Function: LR::softmax(double*)
void LR::softmax(double *x)
{
    double sum = 0.0;
    for(int i=0; i<n_labels; i++) 
    {
        x[i] = exp(x[i]);
        sum += x[i];
    } 

    for(int i=0; i<n_labels; i++) 
        x[i] /= sum;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl 0x8(%rdi), %eax
testl %eax, %eax
jle 0x4d3a
movq %rdi, %r14
xorpd %xmm1, %xmm1
xorl %r15d, %r15d
movsd %xmm1, 0x8(%rsp)
movsd (%rbx,%r15,8), %xmm0
callq 0x22c0
movsd 0x8(%rsp), %xmm1
movsd %xmm0, (%rbx,%r15,8)
addsd %xmm0, %xmm1
incq %r15
movslq 0x8(%r14), %rax
cmpq %rax, %r15
jl 0x4d0b
jmp 0x4d3e
xorpd %xmm1, %xmm1
testl %eax, %eax
jle 0x4d5c
movl %eax, %eax
xorl %ecx, %ecx
movsd (%rbx,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x4d46
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/lipiji[P]PG_DEEP/deep.cpp
// Function: LR::predict(double*, double*)
void LR::predict(double *x, double *y)
{
    for(int i=0; i<n_labels; i++) 
    {
        y[i] = 0;
        for(int j=0; j<n_features; j++) 
        {
            y[i] += W[i][j] * x[j];
        }
        y[i] += b[i];
    }
    softmax(y);
}

// Assembly:
movslq 0x8(%rdi), %rax
testq %rax, %rax
jle 0x4dce
pushq %rbx
movl 0x4(%rdi), %ecx
movq 0x18(%rdi), %r8
movq 0x20(%rdi), %r9
xorl %r10d, %r10d
movq $0x0, (%rdx,%r10,8)
testl %ecx, %ecx
jle 0x4db3
movq (%r8,%r10,8), %r11
movsd (%rdx,%r10,8), %xmm0
xorl %ebx, %ebx
movsd (%r11,%rbx,8), %xmm1
mulsd (%rsi,%rbx,8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rdx,%r10,8)
incq %rbx
cmpq %rbx, %rcx
jne 0x4d96
movsd (%r9,%r10,8), %xmm0
addsd (%rdx,%r10,8), %xmm0
movsd %xmm0, (%rdx,%r10,8)
incq %r10
cmpq %rax, %r10
jne 0x4d7e
popq %rbx
movq %rdx, %rsi
jmp 0x4cee