LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/sidscrazy[P]Paxos/paxos_node.cpp
// Function: PaxosNode::propose()
void propose (){

		if ((num_nodes % 2 == 0 ? num_nodes / 2 : 1 + (num_nodes / 2)) > prepare_acks.size ()){
			return;
		}

		proposed_v = true;

		state = PROPOSING;

		if (v == NO_VALUE){
			v = rand () % 250;
		}
		vote *vo = (vote *) malloc (sizeof (vote));
		vo->node = id;
		vo->n = n;
		vo->v = v;
		votes.push_back (vo);

		message m (id, -1, v, n, MSG_PROPOSE);
		network_lock.lock ();
		send_message (0, &m);
		network_lock.unlock ();
		timeout  = time(0);
		simulate_crash ();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl 0x4(%rdi), %eax
testb $0x1, %al
jne 0x3eaf
sarl %eax
jmp 0x3ebc
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
incl %ecx
movl %ecx, %eax
cltq
movq 0xe8(%rbx), %rcx
subq 0xe0(%rbx), %rcx
sarq $0x2, %rcx
cmpq %rax, %rcx
jb 0x3fbd
movb $0x1, 0x18(%rbx)
movl $0xfffffffb, 0x14(%rbx) # imm = 0xFFFFFFFB
movl 0xc(%rbx), %r14d
cmpl $-0x1, %r14d
jne 0x3f17
callq 0x2060
movslq %eax, %r14
imulq $0x10624dd3, %r14, %rax # imm = 0x10624DD3
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x24, %rax
addl %ecx, %eax
imull $0xfa, %eax, %eax
subl %eax, %r14d
movl %r14d, 0xc(%rbx)
movl $0xc, %edi
callq 0x2280
movq %rax, -0x18(%rbp)
movl (%rbx), %ecx
movl %ecx, (%rax)
movl 0x10(%rbx), %edx
movl %edx, 0x4(%rax)
movl %r14d, 0x8(%rax)
movq 0xd0(%rbx), %rsi
cmpq 0xd8(%rbx), %rsi
je 0x3f50
movq %rax, (%rsi)
addq $0x8, 0xd0(%rbx)
jmp 0x3f69
leaq 0xc8(%rbx), %rdi
leaq -0x18(%rbp), %rdx
callq 0x3c34
movl (%rbx), %ecx
movl 0xc(%rbx), %r14d
movl 0x10(%rbx), %edx
movl %ecx, -0x38(%rbp)
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movl %r14d, -0x30(%rbp)
movl %edx, -0x2c(%rbp)
movl $0x3, -0x28(%rbp)
leaq 0x28(%rbx), %r14
movq %r14, %rdi
callq 0x22b0
testl %eax, %eax
jne 0x3fc6
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x33b2
movq %r14, %rdi
callq 0x2160
xorl %edi, %edi
callq 0x21c0
movq %rax, 0x100(%rbx)
movq %rbx, %rdi
callq 0x3866
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl %eax, %edi
callq 0x2120
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/sidscrazy[P]Paxos/./plan/PaxosNodeLogger.cpp
// Function: PaxosNodeLogger::PaxosNodeLogger(int)
PaxosNodeLogger::PaxosNodeLogger(int nodeid)
{
    nodeuniqueid = nodeid;
    SetLogFileName(nodeid);
    OpenLogFile(logfilename);
    AddLogFileHeader();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x2300
leaq 0x210(%rbx), %r15
movq %r15, 0x200(%rbx)
movq $0x0, 0x208(%rbx)
movb $0x0, 0x210(%rbx)
movl %r14d, 0x220(%rbx)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x40b8
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x200(%rbx), %rsi
movq 0x208(%rbx), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x4b64
leaq 0x70(%rbx), %rdi
callq 0x2050
testb %al, %al
jne 0x405d
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
movl $0x10, %edx
callq 0x20f0
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x406b
callq 0x21d0
movq %rbx, %rdi
callq 0x42ce
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x4096
callq 0x21d0
jmp 0x4096
movq %rax, %r14
movq 0x200(%rbx), %rdi
cmpq %r15, %rdi
je 0x40a7
callq 0x21d0
movq %rbx, %rdi
callq 0x22c0
movq %r14, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O3/sidscrazy[P]Paxos/./plan/PaxosNodeLogger.cpp
// Function: PaxosNodeLogger::AddMsg(message*, int)
void PaxosNodeLogger::AddMsg (message *m, int role) {
    myfile << "\n"; // get to the new line for next entry.
    myfile << m->timestamp        << ",";         // get to the new line for next entry.
    myfile << m->sender     << ",";         // string: unique guid for the node which owns this log file, same as file name.
    myfile << m->receiver     << ",";         
    myfile << MSG_ENTRY         << ",";         // int: denotes if the node is alive is crashed state.
    myfile << m->round                 << ",";         // int: The value of N proposed or accepted by a node. In say Broadcast action, its value is redundant.
    myfile << m->value             << ",";         // string: Pick value v of highest proposal number -> this is the v we are talking about
    myfile << role          << ",";         // int: Proposer, Acceptor, Learner.
    myfile << m->round     << ",";         // int: Maximum Promised value of N so far for the node. Even leader can have a promised N
    if (m->type == MSG_CONSENSUS){
        myfile << m->value    << ","; 
    } else {
        myfile << ""    << ","; 
    }
    myfile << m->type     << ",";         // int Current action on the node as the logging is happening                              
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xb9a(%rip), %rsi       # 0x5277
movl $0x1, %edx
callq 0x2220
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x21e0
leaq 0xb26(%rip), %r15       # 0x5220
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2220
movl (%r14), %esi
movq %rbx, %rdi
callq 0x2310
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2220
movl 0x4(%r14), %esi
movq %rbx, %rdi
callq 0x2310
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2220
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2310
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2220
movl 0xc(%r14), %esi
movq %rbx, %rdi
callq 0x2310
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2220
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x2310
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2220
movq %rbx, %rdi
movl %r12d, %esi
callq 0x2310
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2220
movl 0xc(%r14), %esi
movq %rbx, %rdi
callq 0x2310
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2220
cmpl $0x6, 0x10(%r14)
jne 0x47e5
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x2310
movq %rax, %rdi
jmp 0x47f9
leaq 0xa8c(%rip), %rsi       # 0x5278
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2220
movq %rbx, %rdi
leaq 0xa20(%rip), %r15       # 0x5220
movl $0x1, %edx
movq %r15, %rsi
callq 0x2220
movl 0x10(%r14), %esi
movq %rbx, %rdi
callq 0x2310
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O3/sidscrazy[P]Paxos/./plan/PaxosNodeLogger.cpp
// Function: PaxosNodeLogger::CrashSequence(message*)
void PaxosNodeLogger::CrashSequence (message *m){
    myfile << "\n"; // get to the new line for next entry.
    myfile << m->timestamp        << ",";         // get to the new line for next entry.
    myfile << m->sender     << ",";         // string: unique guid for the node which owns this log file, same as file name.
    myfile << "-1" << ",";
    myfile << m->value         << ",";         // int: denotes if the node is alive is crashed state.
    myfile << "-1"                  << ",";         // int: The value of N proposed or accepted by a node. In say Broadcast action, its value is redundant.
    myfile << "-1"            << ",";         // string: Pick value v of highest proposal number -> this is the v we are talking about
    myfile << "-1"           << ",";         // int: Proposer, Acceptor, Learner.
    myfile << "-1"      << ",";         // int: Maximum Promised value of N so far for the node. Even leader can have a promised N
    myfile << "-1"     << ","; 
    myfile << "-1"      << ",";         // int Current action on the node as the logging is happening      
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %rbx
leaq 0xa2d(%rip), %rsi       # 0x5277
movl $0x1, %edx
callq 0x2220
movq 0x18(%r12), %rsi
movq %rbx, %rdi
callq 0x21e0
leaq 0x9b8(%rip), %r14       # 0x5220
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2220
movl (%r12), %esi
movq %rbx, %rdi
callq 0x2310
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2220
leaq 0x9e1(%rip), %r15       # 0x527c
movl $0x2, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2220
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2220
movl 0x8(%r12), %esi
movq %rbx, %rdi
callq 0x2310
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2220
movl $0x2, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2220
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2220
movl $0x2, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2220
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2220
movl $0x2, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2220
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2220
movl $0x2, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2220
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2220
movl $0x2, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2220
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2220
movl $0x2, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2220
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/exprtk_gnuplot.cpp
// Function: main
int main()
{
   exprtk_gnuplot_fx plotter;

   plotter
      .set_expression("clamp(-1.0,sin(2 * pi * x) + cos(x / 2 * pi),+1.0)")
      .set_domain(-5,+5)
      .set_title("ExprTk GNUPlot Example");

   plotter.plot();

   return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
leaq 0x58(%rsp), %rbx
movq %rbx, -0x10(%rbx)
xorl %eax, %eax
movq %rax, -0x8(%rbx)
movb %al, (%rbx)
leaq 0x78(%rsp), %r14
movq %r14, -0x10(%r14)
movq %rax, -0x8(%r14)
movb %al, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movups %xmm0, 0x20(%r14)
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x18e5ff(%rip), %rsi    # 0x2a5957
leaq 0x18e62a(%rip), %rdx    # 0x2a5989
leaq 0x28(%rsp), %rdi
callq 0x17f9d0
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x114570
movaps 0x189c91(%rip), %xmm0   # 0x2a1010
movups %xmm0, 0x88(%rsp)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x18e5f2(%rip), %rsi    # 0x2a598a
leaq 0x18e601(%rip), %rdx    # 0x2a59a0
leaq 0x8(%rsp), %rdi
callq 0x17f9d0
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x114570
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1173cf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x114080
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x1173e6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x114080
leaq 0x48(%rsp), %rdi
callq 0x117570
testb %al, %al
je 0x1173fe
leaq 0x48(%rsp), %rdi
callq 0x11793c
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x117415
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x114080
movq 0x48(%rsp), %rdi
cmpq %rbx, %rdi
je 0x11742c
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x114080
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x11745e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x114080
jmp 0x11745e
jmp 0x11745b
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x11747c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x114080
jmp 0x11747c
jmp 0x117479
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x11752e
movq %rbx, %rdi
callq 0x1142f0
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/exprtk_gnuplot.cpp
// Function: exprtk_gnuplot_fx::generate_gp_script()
bool generate_gp_script()
   {
      std::ofstream stream("plot.gp");

      if (!stream)
      {
         return false;
      }

      stream << "set term png\n";
      stream << "set output 'plot.png'\n";
      stream << "set xrange[" << min_x_ << ":" << max_x_ <<"]\n";
      stream << "set yrange[" << min_y_ << ":" << max_y_ <<"]\n";
      stream << "set xzeroaxis\n";
      stream << "set yzeroaxis\n";
      stream << "plot 'data.dat' using 1:2:(1.0) smooth unique title '" << title_ <<"'\n";

      return true;
   }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %rbx
leaq 0x192b02(%rip), %rsi    # 0x2aa453
movq %rsp, %r14
movq %r14, %rdi
movl $0x10, %edx
callq 0x114150
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x20(%rsp,%rax), %ebp
testb $0x5, %bpl
jne 0x117aaf
leaq 0x192ade(%rip), %rsi    # 0x2aa45b
movq %rsp, %rdi
movl $0xd, %edx
callq 0x1144f0
leaq 0x192ad8(%rip), %rsi    # 0x2aa469
movq %rsp, %rdi
movl $0x16, %edx
callq 0x1144f0
leaq 0x192adb(%rip), %rsi    # 0x2aa480
movq %rsp, %rdi
movl $0xb, %edx
callq 0x1144f0
movsd 0x40(%rbx), %xmm0
movq %rsp, %rdi
callq 0x1143a0
movq %rax, %r14
leaq 0x18e6e8(%rip), %rsi    # 0x2a60b1
movl $0x1, %edx
movq %rax, %rdi
callq 0x1144f0
movsd 0x48(%rbx), %xmm0
movq %r14, %rdi
callq 0x1143a0
leaq 0x192aa2(%rip), %rsi    # 0x2aa48c
movl $0x2, %edx
movq %rax, %rdi
callq 0x1144f0
leaq 0x192a91(%rip), %rsi    # 0x2aa48f
movq %rsp, %rdi
movl $0xb, %edx
callq 0x1144f0
movsd 0x50(%rbx), %xmm0
movq %rsp, %rdi
callq 0x1143a0
movq %rax, %r14
leaq 0x18e68f(%rip), %rsi    # 0x2a60b1
movl $0x1, %edx
movq %rax, %rdi
callq 0x1144f0
movsd 0x58(%rbx), %xmm0
movq %r14, %rdi
callq 0x1143a0
leaq 0x192a49(%rip), %rsi    # 0x2aa48c
movl $0x2, %edx
movq %rax, %rdi
callq 0x1144f0
leaq 0x192a44(%rip), %rsi    # 0x2aa49b
movq %rsp, %rdi
movl $0xe, %edx
callq 0x1144f0
leaq 0x192a3f(%rip), %rsi    # 0x2aa4aa
movq %rsp, %rdi
movl $0xe, %edx
callq 0x1144f0
leaq 0x192a3a(%rip), %rsi    # 0x2aa4b9
movq %rsp, %rdi
movl $0x35, %edx
callq 0x1144f0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %rsp, %rdi
callq 0x1144f0
leaq 0x1929db(%rip), %rsi    # 0x2aa47d
movl $0x2, %edx
movq %rax, %rdi
callq 0x1144f0
testb $0x5, %bpl
sete %bl
movq 0x2e950b(%rip), %rax    # 0x400fc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x8(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, (%rsp,%rcx)
callq 0x1142d0
leaq 0xf8(%rsp), %rdi
callq 0x114360
movl %ebx, %eax
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1143c0
movq %rbx, %rdi
callq 0x1142f0
// File: /workspace/github_cpp_makefile_star2_O3/ra101[P]Generic-BlockChain-container-cpp/./includes/prime.hpp
// Function: ra::random_prime_engine<std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>>::operator()()
int random_prime_engine<Engine>::operator()()
    {
        int idx = eng() % DB_SIZE; //to get a index within file
        int rand_prime;
        std::ifstream file;
        file.open(db_filepath);

        //update rand_prime till it gets the value at index
        for (int i = 0; i <= idx; i++)
            file >> rand_prime;

        file.close();
        return (rand_prime);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdi, %rbx
movq (%rdi), %r12
imulq $0x41a7, %r12, %rcx     # imm = 0x41A7
movabsq $0x200000005, %rdx      # imm = 0x200000005
movq %rcx, %rax
mulq %rdx
movq %rcx, %r15
subq %rdx, %r15
shrq %r15
addq %rdx, %r15
shrq $0x1e, %r15
movq %r15, %rax
shlq $0x1f, %rax
movq %r15, %r13
subq %rax, %r13
addq %rcx, %r13
movq %r13, (%rdi)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x21b0
movq 0x10(%rbx), %rsi
movq %r14, %rdi
movl $0x8, %edx
callq 0x2100
imull $0x41a7, %r12d, %eax    # imm = 0x41A7
movl %r13d, %ecx
imulq $0x10624dd3, %rcx, %rcx # imm = 0x10624DD3
shrq $0x26, %rcx
imull $0x3e8, %ecx, %ecx      # imm = 0x3E8
movl %r13d, %edx
subl %ecx, %edx
subl %r13d, %edx
addl %eax, %edx
movl %r15d, %eax
shll $0x1f, %eax
addl %r15d, %eax
leal (%rdx,%rax), %ebp
incl %ebp
leaq 0x10(%rsp), %rbx
leaq 0xc(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20f0
decl %ebp
jne 0x2f8e
leaq 0x10(%rsp), %rdi
callq 0x2070
movl 0xc(%rsp), %ebx
leaq 0x10(%rsp), %rdi
callq 0x2080
movl %ebx, %eax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2fcb
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/ra101[P]Generic-BlockChain-container-cpp/./block_chain.hpp
// Function: ra::block_chain<custom_transaction, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::block_chain(int, bool (*)(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long, unsigned long long), float)
block_chain(int difficulty, bool (*verfication_function)(std::string, std::size_t, unsigned long long int), float minning_reward = 0)
        {
            this->difficulty = difficulty;
            this->minning_reward = minning_reward;
            this->verfication_function = verfication_function;
            chain.push_back(*(new block_type(0, difficulty, pending_transaction, size())));
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
leaq 0x18(%rdi), %r14
leaq 0x20(%rdi), %rcx
movl $0x0, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
movq %rcx, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movl %esi, 0x48(%rdi)
movss %xmm0, 0x4c(%rdi)
movq %rdx, 0x50(%rdi)
movl $0x58, %edi
callq 0x2160
movq %rax, %r15
movq %rsp, %rdi
movq %r14, %rsi
callq 0x39aa
movl 0x10(%rbx), %r8d
movq %rsp, %rcx
movq %r15, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x380e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x394a
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2030
incq 0x10(%rbx)
movq %rsp, %rdi
callq 0x36f0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %rsp, %rdi
callq 0x36f0
jmp 0x31b0
movq %rax, %r12
movq %rsp, %rdi
callq 0x36f0
jmp 0x319e
movq %rax, %r12
movl $0x58, %esi
movq %r15, %rdi
callq 0x2170
jmp 0x31b0
movq %rax, %r12
movq %r14, %rdi
callq 0x36f0
movq %rbx, %rdi
callq 0x3740
movq %r12, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/ra101[P]Generic-BlockChain-container-cpp/main.cpp
// Function: bool custom_transaction::sign_transaction<ra::rsa_key_pair>(ra::rsa_key_pair)
bool sign_transaction(EncryptionAlgo key_pair)
  {
    if (from_address != key_pair.get_public_key())
    {
      throw ra::public_key_mismatch(std::to_string(from_address), std::to_string(key_pair.get_public_key()));
    }

    // already signed
    if (signature != 0)
      throw ra::resign_transaction_exception(*this);

    signature = key_pair.sign(generate_hash_input());
    return true;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %r14
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
cmpq %rdx, (%rdi)
jne 0x3243
cmpq $0x0, 0x20(%r14)
jne 0x329c
leaq 0x78(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4384
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x53ca
movq %rax, 0x20(%r14)
movq (%rbx), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0x3233
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x2170
movb $0x1, %al
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
movq (%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x486a
leaq 0x58(%rsp), %rdi
movq %r15, %rsi
callq 0x486a
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
leaq 0x58(%rsp), %rdx
movq %rbx, %rdi
callq 0x4abc
xorl %ebp, %ebp
leaq 0x5a55(%rip), %rsi      # 0x8ce0
movq 0x5d1e(%rip), %rdx      # 0x8fb0
movq %rbx, %rdi
callq 0x2280
jmp 0x32de
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x4cea
movb $0x1, %bpl
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x534a
xorl %ebp, %ebp
leaq 0x5a29(%rip), %rsi      # 0x8cf8
movq 0x5d0a(%rip), %rdx      # 0x8fe0
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32fc
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x2170
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x334f
movq 0x18(%rsp), %rsi
jmp 0x3347
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x335b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2170
jmp 0x335b
movq %rax, %r14
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x334f
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x2170
testb %bpl, %bpl
jne 0x335b
jmp 0x3363
jmp 0x3358
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ra101[P]Generic-BlockChain-container-cpp/./block_chain.hpp
// Function: ra::block_chain<custom_transaction, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::add_transaction(custom_transaction&)
void add_transaction(Transaction &temp)
        {
            // Signed?
            if (!temp.is_transaction_valid(verfication_function))
            {
                throw invalid_transaction_error(temp);
            }
            pending_transaction.insert(temp);
        }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x50(%rdi), %rsi
movq %r14, %rdi
callq 0x555e
testb %al, %al
je 0x33a1
addq $0x18, %rbx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x5678
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x4cea
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x55e0
xorl %ebp, %ebp
leaq 0x5990(%rip), %rsi      # 0x8d60
movq 0x5c09(%rip), %rdx      # 0x8fe0
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x33fd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2170
testb %bpl, %bpl
jne 0x3407
jmp 0x340f
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ra101[P]Generic-BlockChain-container-cpp/./block_chain.hpp
// Function: ra::block_chain<custom_transaction, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::mine_pending_transactions(unsigned long long)
void mine_pending_transactions(unsigned long long int minning_reward_address = 0)
        {
            if (minning_reward)
            {
                Transaction reward_transaction(0, minning_reward_address, minning_reward);
                add_transaction(reward_transaction);
            }

            block_type new_block((chain.back().get_hash()), difficulty, pending_transaction, size());
            chain.push_back(new_block);
            pending_transaction.clear();
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movss 0x4c(%rdi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3439
jnp 0x3466
xorl %r15d, %r15d
leaq 0x8(%rsp), %r14
movq %r15, (%r14)
movq %rsi, 0x8(%r14)
movss %xmm0, 0x10(%r14)
callq 0x2200
movq %rax, 0x18(%r14)
movq %r15, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x336c
movq 0x8(%rbx), %rax
movq 0x20(%rax), %r12
movl 0x48(%rbx), %ebp
leaq 0x18(%rbx), %r14
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x39aa
movl 0x10(%rbx), %r8d
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r15, %rcx
callq 0x380e
leaq 0x60(%rsp), %rdi
callq 0x36f0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x394a
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2030
incq 0x10(%rbx)
movq %r14, %rdi
callq 0x58a4
leaq 0x30(%rsp), %rdi
callq 0x36f0
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %r15
jmp 0x34f0
movq %rax, %rbx
movq %r15, %rdi
callq 0x36f0
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/ra101[P]Generic-BlockChain-container-cpp/./block.hpp
// Function: ra::operator<<(std::ostream&, ra::block<custom_transaction, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
std::ostream &operator<<(std::ostream &out, block<Transaction, HashFunctionClass> const &temp)
        {
            int i = 1;
            if (temp.id == 0)
                out << "...\nGenesis block\n";
            else
                out << "\n\n...\nBlock No. " << temp.id;

            out << "\n\nNo of Entries: " << temp.transaction_set.size() << "\nHash: " << temp.hash << "\nPrevious Hash: " << temp.previous_hash;
            for (typename std::set<Transaction>::const_iterator trans_elem = (temp.transaction_set).begin(); trans_elem != temp.transaction_set.end(); trans_elem++, i++)
                out << "\n\nEntry no: " << i << (*trans_elem);

            return out;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, (%rsi)
je 0x3534
leaq 0x2cac(%rip), %rsi      # 0x61c6
movl $0x10, %edx
movq %rbx, %rdi
callq 0x21c0
movl (%r14), %esi
movq %rbx, %rdi
callq 0x2290
jmp 0x3548
leaq 0x2c78(%rip), %rsi      # 0x61b3
movl $0x12, %edx
movq %rbx, %rdi
callq 0x21c0
leaq 0x2c88(%rip), %rsi      # 0x61d7
movl $0x11, %edx
movq %rbx, %rdi
callq 0x21c0
movq 0x50(%r14), %rsi
movq %rbx, %rdi
callq 0x2110
movq %rax, %r15
leaq 0x2c77(%rip), %rsi      # 0x61e9
movl $0x7, %edx
movq %rax, %rdi
callq 0x21c0
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x2110
movq %rax, %r15
leaq 0x2c5c(%rip), %rsi      # 0x61f1
movl $0x10, %edx
movq %rax, %rdi
callq 0x21c0
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x2110
movq 0x40(%r14), %r15
addq $0x30, %r14
cmpq %r14, %r15
je 0x35ff
movl $0x1, %ebp
leaq 0x2c3b(%rip), %r12      # 0x6202
movl $0xc, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x21c0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2290
leaq 0x20(%r15), %rsi
movq %rax, %rdi
callq 0x58d1
movq %r15, %rdi
callq 0x21d0
movq %rax, %r15
incl %ebp
cmpq %r14, %rax
jne 0x35c7
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ra101[P]Generic-BlockChain-container-cpp/./block_chain.hpp
// Function: ra::block_chain<custom_transaction, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::is_chain_valid()
bool is_chain_valid()
        {
            for (iterator previous_block, current_block = begin(); current_block != end(); ++current_block)
            {
                if (!(*current_block).is_hash_valid())
                    return false;

                // Connection of chains are valid?
                if (current_block != begin())
                    if ((*current_block).get_previous_hash() != (*previous_block).get_hash())
                        return false;

                // All sinature are valid?
                if (!((*current_block).is_block_valid(verfication_function)))
                    return false;

                previous_block = current_block;
            }
            return true;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r12d, %r12d
movq %rdi, %r15
movq (%r15), %r15
cmpq %rbx, %r15
je 0x3658
leaq 0x10(%r15), %r14
movq %r14, %rdi
callq 0x5946
testb %al, %al
je 0x3658
cmpq (%rbx), %r15
je 0x3645
movq 0x18(%r15), %rax
cmpq 0x20(%r12), %rax
jne 0x3658
movq 0x50(%rbx), %rsi
movq %r14, %rdi
callq 0x5aae
movq %r15, %r12
testb %al, %al
jne 0x361d
cmpq %rbx, %r15
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ra101[P]Generic-BlockChain-container-cpp/./block.hpp
// Function: ra::block<custom_transaction, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::block(unsigned long, int, std::set<custom_transaction, std::less<custom_transaction>, std::allocator<custom_transaction>>, int)
block(std::size_t previous_hash, int difficulty, std::set<Transaction> transaction_set, int id)
        {
            this->id = id;
            this->previous_hash = previous_hash;
            this->transaction_set = transaction_set;
            difficulty = std::max(std::min(difficulty, MAX_DIFFICULTY), MIN_DIFFICULTY);
            nonce = 0;
            timestamp = std::chrono::steady_clock::now();
            hash = mine_block(generate_hash_input(), find_hash_length(difficulty));
        }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rdi, %r14
xorl %eax, %eax
movq %rax, 0x18(%rdi)
leaq 0x28(%rdi), %rbx
leaq 0x30(%rdi), %rdx
movl $0x0, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movq %rdx, 0x40(%rdi)
movq %rdx, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movl %r8d, (%rdi)
movq %rsi, 0x8(%rdi)
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x4092
movl $0x0, 0x24(%r14)
callq 0x2200
movq %rax, 0x18(%r14)
movq %rsp, %rdi
movq %r14, %rsi
callq 0x3e58
cmpl $0x3, %ebp
movl $0x3, %eax
cmovll %ebp, %eax
cmpl $0x2, %eax
movl $0x1, %ecx
cmovgel %eax, %ecx
decl %ecx
movd %ecx, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
pxor 0x2779(%rip), %xmm0     # 0x6010
movdqa 0x2781(%rip), %xmm1     # 0x6020
pcmpgtd %xmm0, %xmm1
movdqa %xmm1, %xmm0
pandn 0x2781(%rip), %xmm0     # 0x6030
psubd %xmm1, %xmm0
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
pshufd $0xff, %xmm0, %xmm2     # xmm2 = xmm0[3,3,3,3]
pshufd $0xf5, %xmm0, %xmm3     # xmm3 = xmm0[1,1,3,3]
pmuludq %xmm2, %xmm3
pmuludq %xmm0, %xmm1
pmuludq %xmm3, %xmm1
movd %xmm1, %ecx
movabsq $0x5af3107a4000, %rax   # imm = 0x5AF3107A4000
xorl %edx, %edx
divq %rcx
movq %rsp, %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x3b6c
movq %rax, 0x10(%r14)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x390e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2170
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x393a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2170
jmp 0x393a
movq %rax, %r14
movq %rbx, %rdi
callq 0x36f0
movq %r14, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/ra101[P]Generic-BlockChain-container-cpp/main.cpp
// Function: custom_transaction::is_transaction_valid(bool (*)(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long, unsigned long long)) const
bool is_transaction_valid(bool (*verfication_function)(std::string, std::size_t, unsigned long long int)) const
  {
    // reward
    if (from_address == 0)
      return true;

    return verfication_function(generate_hash_input(), signature, from_address);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpq $0x0, (%rdi)
je 0x55ac
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4384
movq (%r14), %rdx
movq 0x20(%r14), %rsi
movq %r15, %rdi
callq *%rbx
movl %eax, %ebx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55ae
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2170
jmp 0x55ae
movb $0x1, %bl
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55d8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/ra101[P]Generic-BlockChain-container-cpp/./block.hpp
// Function: ra::block<custom_transaction, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::is_block_valid(bool (*)(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long, unsigned long long))
bool is_block_valid(bool (*verfication_function)(std::string, std::size_t, unsigned long long int))
        {

            for (typename std::set<Transaction>::iterator trans_elem = transaction_set.begin(); trans_elem != transaction_set.end(); trans_elem++)
                if (!((*trans_elem).is_transaction_valid(verfication_function)))
                    return false;
            return true;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x40(%rdi), %r15
addq $0x30, %r14
cmpq %r14, %r15
je 0x5aec
movq %rsi, %rbx
leaq 0x20(%r15), %rdi
movq %rbx, %rsi
callq 0x555e
movl %eax, %ebp
testb %al, %al
je 0x5aef
movq %r15, %rdi
callq 0x21d0
movq %rax, %r15
cmpq %r14, %rax
jne 0x5ac8
jmp 0x5aef
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ra101[P]Generic-BlockChain-container-cpp/./block.hpp
// Function: ra::block<custom_transaction, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::get_balance(unsigned long long)
float get_balance(const unsigned long long int address)
        {
            float balance = 0;
            for (typename std::set<Transaction>::iterator trans_elem = transaction_set.begin(); trans_elem != transaction_set.end(); trans_elem++)
                balance += (*trans_elem).get_balance(address);
            return balance;
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x40(%rdi), %rax
addq $0x30, %r14
cmpq %r14, %rax
je 0x5b5d
movq %rsi, %rbx
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
cmpq %rbx, 0x28(%rax)
jne 0x5b29
movss 0x30(%rax), %xmm0
jmp 0x5b3e
xorps %xmm0, %xmm0
cmpq %rbx, 0x20(%rax)
jne 0x5b3e
movss 0x30(%rax), %xmm0
xorps 0x4d2(%rip), %xmm0      # 0x6010
movss 0x4(%rsp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x4(%rsp)
movq %rax, %rdi
callq 0x21d0
cmpq %r14, %rax
jne 0x5b1c
jmp 0x5b66
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movss 0x4(%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/eiskalteschatten[P]developersnotebook/src/main.cpp
// Function: main
int main(int argc, char **argv) {
    GtkApplication *app     = gtk_application_new("com.alexseifert.developersnotebook", G_APPLICATION_FLAGS_NONE);
    MainWindow *main_window = new MainWindow(argv[0]);

    g_signal_connect(app, "startup", G_CALLBACK(initialize), NULL);
    g_signal_connect(app, "activate", G_CALLBACK(main_window->activate), main_window);

    int status = g_application_run(G_APPLICATION(app), argc, argv);
    g_object_unref(app);

    #ifdef __APPLE__
        GtkosxApplication *osx_app = gtkosx_application_get();
        gtkosx_application_ready(osx_app);
        g_object_unref(osx_app);
    #endif

    return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movl %edi, %ebp
leaq 0x1beb1(%rip), %rdi     # 0x290c3
xorl %esi, %esi
callq 0x8bc0
movq %rax, %r15
movl $0x50, %edi
callq 0x81a0
movq %rax, %rbx
movq (%r14), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd42c
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x142a2
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd263
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8170
leaq 0x1be7c(%rip), %rsi     # 0x290e6
leaq 0x9b(%rip), %rdx        # 0xd30c
movq %r15, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x82a0
leaq 0x1be66(%rip), %rsi     # 0x290ee
leaq 0x708f(%rip), %rdx      # 0x1431e
movq %r15, %rdi
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x82a0
callq 0x8580
movq %r15, %rdi
movq %rax, %rsi
callq 0x8150
movq %rax, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x8070
movl %eax, %ebx
movq %r15, %rdi
callq 0x8d00
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd2f7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8170
jmp 0xd2f7
movq %rax, %r14
movl $0x50, %esi
movq %rbx, %rdi
callq 0x8170
movq %r14, %rdi
callq 0x87b0
// File: /workspace/github_cpp_makefile_star2_O3/eiskalteschatten[P]developersnotebook/src/resources/Image.cpp
// Function: Image::get_pixbuf()
GdkPixbuf* Image::get_pixbuf() {
    GdkPixbuf *pixbuf;

    if (extension == "svg") {
        std::string svg_content = get_svg_content();
        GInputStream *stream    = g_memory_input_stream_new_from_data(svg_content.c_str(), -1, g_free);
        pixbuf                  = gdk_pixbuf_new_from_stream(stream, NULL, NULL);
    }
    else {
        pixbuf = gdk_pixbuf_new_from_file(path.c_str(), NULL);
    }

    if (height == -1 || width == -1) {
        return pixbuf;
    }

    return gdk_pixbuf_scale_simple(pixbuf, width, height, GDK_INTERP_BILINEAR);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0x40, %rdi
leaq 0x1b69e(%rip), %rsi     # 0x29041
callq 0x8c00
testl %eax, %eax
je 0xd9bc
movq 0x60(%rbx), %rdi
xorl %esi, %esi
callq 0x8370
movq %rax, %r14
jmp 0xda0c
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd918
movq (%r14), %rdi
movq 0x2959a(%rip), %rdx     # 0x36f70
movq $-0x1, %rsi
callq 0x8530
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x8190
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xda0c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8170
movl 0xa0(%rbx), %edx
cmpl $-0x1, %edx
je 0xda32
movl 0xa4(%rbx), %esi
cmpl $-0x1, %esi
je 0xda32
movq %r14, %rdi
movl $0x2, %ecx
callq 0x8a50
movq %rax, %r14
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xda5b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8170
movq %rbx, %rdi
callq 0x87b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/eiskalteschatten[P]developersnotebook/src/resources/Resource.cpp
// Function: Resource::Resource(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Resource::Resource(const std::string new_name, const std::string new_extension, const std::string new_path_to_exec, const std::string new_sub_folders) {
    name             = new_name;
    extension        = new_extension;
    path_to_exec_str = new_path_to_exec;
    sub_folders      = new_sub_folders;

    #ifdef __APPLE__
        path = get_resource_path_mac();
    #else
        path = get_resource_path();
    #endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %r15
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)
addq $0x20, %rdi
leaq 0x30(%rbx), %rcx
movq %rcx, 0x10(%rsp)
movq %rcx, 0x20(%rbx)
movq %rax, 0x28(%rbx)
movb %al, 0x30(%rbx)
leaq 0x40(%rbx), %rcx
movq %rcx, 0x28(%rsp)
leaq 0x50(%rbx), %rcx
movq %rcx, 0x8(%rsp)
movq %rcx, 0x40(%rbx)
movq %rax, 0x48(%rbx)
movb %al, 0x50(%rbx)
leaq 0x60(%rbx), %rcx
movq %rcx, 0x20(%rsp)
leaq 0x70(%rbx), %rcx
movq %rcx, (%rsp)
movq %rcx, 0x60(%rbx)
movq %rax, 0x68(%rbx)
movb %al, 0x70(%rbx)
leaq 0x80(%rbx), %rbp
leaq 0x90(%rbx), %r12
movq %r12, 0x80(%rbx)
movq %rax, 0x88(%rbx)
movb %al, 0x90(%rbx)
movq %rdi, 0x30(%rsp)
callq 0x8ed0
movq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x8ed0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8ed0
movq %rbp, %rdi
movq %r13, %rsi
callq 0x8ed0
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
callq 0xe140
leaq 0x38(%rsp), %rbx
movq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x8630
movq (%rbx), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0xe09a
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x8170
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe0ab
movq %rax, %r13
movq (%rbp), %rdi
cmpq %r12, %rdi
je 0xe0c3
movq (%r12), %rsi
incq %rsi
callq 0x8170
movq 0x20(%rsp), %rax
movq (%rax), %rdi
cmpq (%rsp), %rdi
je 0xe0e0
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x8170
movq 0x28(%rsp), %rax
movq (%rax), %rdi
cmpq 0x8(%rsp), %rdi
je 0xe0ff
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x8170
movq 0x30(%rsp), %rax
movq (%rax), %rdi
cmpq 0x10(%rsp), %rdi
je 0xe11e
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x8170
movq (%rbx), %rdi
cmpq 0x18(%rsp), %rdi
je 0xe138
movq 0x18(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x8170
movq %r13, %rdi
callq 0x87b0
// File: /workspace/github_cpp_makefile_star2_O3/eiskalteschatten[P]developersnotebook/src/resources/Resource.cpp
// Function: Resource::get_resource_path[abi:cxx11]()
std::string Resource::get_resource_path() {
    fs::path path_to_exec = path_to_exec_str;
    path_to_exec.remove_filename();
    path_to_exec /= Constants::path_to_resources;

    if (!fs::is_directory(path_to_exec)) {
        path_to_exec.remove_leaf();
        path_to_exec.remove_leaf();
        path_to_exec /= Constants::path_to_resources;
    }

    path_to_exec /= sub_folders;
    path_to_exec /= name + "." + extension;

    return path_to_exec.string();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xd4f2
movq %r15, %rdi
callq 0x8300
leaq 0x29e3f(%rip), %rsi     # 0x37fc0
leaq 0x8(%rsp), %rdi
callq 0xe3ce
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x8570
cmpl $0x3, 0x48(%rsp)
je 0xe1c8
leaq 0x8(%rsp), %rdi
callq 0x8300
leaq 0x8(%rsp), %rdi
callq 0x8300
leaq 0x29e02(%rip), %rsi     # 0x37fc0
leaq 0x8(%rsp), %rdi
callq 0xe3ce
leaq 0x80(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0xe44e
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0xd4f2
leaq 0x1c4e4(%rip), %rsi     # 0x2a6e2
leaq 0x28(%rsp), %rdi
callq 0x87f0
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
leaq 0x28(%rsp), %rdi
callq 0x8940
leaq 0x58(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xe241
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0xe248
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x8(%rsp), %rdi
callq 0xe3ce
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0xe285
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x8170
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xe29c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x8170
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xd4f2
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xe2cf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8170
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0xe2ff
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x8170
jmp 0xe2ff
jmp 0xe2fc
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xe31d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x8170
jmp 0xe31d
jmp 0xe31a
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xe334
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8170
movq %rbx, %rdi
callq 0x87b0
// File: /workspace/github_cpp_makefile_star2_O3/eiskalteschatten[P]developersnotebook/src/views/ProjectsView.cpp
// Function: list_selection_changed(_GtkTreeSelection*, ProjectsView*)
void list_selection_changed(GtkTreeSelection *selection, ProjectsView *pv) {
    GtkTreeIter tree_iter;
    GtkTreeModel *model   = nullptr;
    gchar *id             = nullptr;

    if (gtk_tree_selection_get_selected(selection, &model, &tree_iter)) {
        gtk_tree_model_get(model, &tree_iter, ID_COLUMN, &id, -1);

        ProjectsModel *projects_model = new ProjectsModel(std::stoi(id));
        projects_model->select_one();

        pv->fill_in_sidebar(projects_model);

        g_free(id);
        delete projects_model;

        gtk_widget_set_sensitive(pv->delete_toolbar_button, TRUE);
    }
    else {
        pv->empty_sidebar();
        gtk_widget_set_sensitive(pv->delete_toolbar_button, FALSE);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
xorl %ebx, %ebx
leaq 0x10(%rsp), %rsi
movq %rbx, (%rsi)
movq %rbx, 0x8(%rsp)
leaq 0x48(%rsp), %rdx
callq 0x8d90
testl %eax, %eax
je 0xfb89
movq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x8(%rsp), %r15
xorl %edx, %edx
movq %r15, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x8850
movl $0x148, %edi            # imm = 0x148
callq 0x81a0
movq %rax, %rbx
movq (%r15), %rsi
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd42c
movq 0x20(%rsp), %r12
callq 0x8cf0
movq %rax, %r15
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x40(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
movl $0xa, %edx
callq 0x8b70
cmpq %r12, (%r13)
je 0xfbab
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0xfbb7
movl (%r15), %ecx
cmpl $0x22, %ecx
je 0xfbb7
testl %ecx, %ecx
jne 0xfb32
movl %ebp, (%r15)
leaq 0x1c(%rsp), %rsi
movl %eax, (%rsi)
movq %rbx, %rdi
callq 0x2681c
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfb5c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8170
movq %rbx, %rdi
callq 0x173c4
movq %r14, %rdi
movq %rbx, %rsi
callq 0xfc0a
movq 0x8(%rsp), %rdi
callq 0x90c8
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movl $0x1, %ebx
jmp 0xfb91
movq %r14, %rdi
callq 0x100b4
movq 0x58(%r14), %rdi
movl %ebx, %esi
callq 0x8fc0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1977c(%rip), %rdi     # 0x2932e
callq 0x81d0
leaq 0x19770(%rip), %rdi     # 0x2932e
callq 0x8770
movq %rax, %r14
jmp 0xfbd9
movq %rax, %r14
jmp 0xfbf4
movq %rax, %r14
cmpl $0x0, (%r15)
jne 0xfbd9
movl %ebp, (%r15)
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfbf4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8170
movl $0x148, %esi            # imm = 0x148
movq %rbx, %rdi
callq 0x8170
movq %r14, %rdi
callq 0x87b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/eiskalteschatten[P]developersnotebook/src/views/ProjectsView.cpp
// Function: ProjectsView::ProjectsView(_GtkWidget*)
ProjectsView::ProjectsView(GtkWidget *window) : AbstractView(window) {
    main_widget = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
    gtk_widget_set_halign(main_widget, GTK_ALIGN_FILL);
    gtk_widget_set_valign(main_widget, GTK_ALIGN_FILL);

    setup_list_view();
    setup_list_view_toolbar();
    setup_form_sidebar();

    // Attach everything to the panes
    gtk_paned_pack1(GTK_PANED(main_widget), list_view_grid, TRUE, FALSE);
    gtk_paned_pack2(GTK_PANED(main_widget), form_scrolled_window, FALSE, FALSE);

    empty_sidebar();

    select = gtk_tree_view_get_selection(GTK_TREE_VIEW(list_view));
    gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE);
    g_signal_connect(G_OBJECT(select), "changed", G_CALLBACK(list_selection_changed), this);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x11bda
xorl %edi, %edi
callq 0x84c0
movq %rax, 0x8(%rbx)
movq %rax, %rdi
xorl %esi, %esi
callq 0x8d10
movq 0x8(%rbx), %rdi
xorl %esi, %esi
callq 0x8e90
movq %rbx, %rdi
callq 0x10598
movq %rbx, %rdi
callq 0x109c0
movq %rbx, %rdi
callq 0x10c16
movq 0x8(%rbx), %r15
callq 0x8ae0
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0x8150
movq 0x10(%rbx), %rsi
movq %rax, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x8970
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x8150
movq 0x30(%rbx), %rsi
movq %rax, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x8030
movq %rbx, %rdi
callq 0x100b4
movq 0x20(%rbx), %r14
callq 0x8de0
movq %r14, %rdi
movq %rax, %rsi
callq 0x8150
movq %rax, %rdi
callq 0x8ea0
movq %rax, 0x40(%rbx)
movq %rax, %rdi
movl $0x1, %esi
callq 0x8a40
movq 0x40(%rbx), %rdi
movl $0x50, %esi
callq 0x8150
leaq 0x18cb7(%rip), %rsi     # 0x2921e
leaq -0xb01(%rip), %rdx      # 0xfa6d
movq %rax, %rdi
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x82a0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x11bde
movq %r14, %rdi
callq 0x87b0