LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq (%rdi), %r13
imulq $0x41a7, %r13, %rcx     # imm = 0x41A7
movabsq $0x200000005, %rdx      # imm = 0x200000005
movq %rcx, %rax
mulq %rdx
movq %rcx, %r12
subq %rdx, %r12
shrq %r12
addq %rdx, %r12
shrq $0x1e, %r12
movq %r12, %rax
shlq $0x1f, %rax
movq %r12, %rbx
subq %rax, %rbx
addq %rcx, %rbx
movq %rbx, (%rdi)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x21b0
movq 0x10(%r14), %rsi
movq %r15, %rdi
movl $0x8, %edx
callq 0x2100
imull $0x41a7, %r13d, %ecx    # imm = 0x41A7
shrq $0x3, %rbx
movabsq $0x20c49ba5e353f7cf, %rdx # imm = 0x20C49BA5E353F7CF
movq %rbx, %rax
mulq %rdx
shrq $0x4, %rdx
imull $0x3e8, %edx, %eax      # imm = 0x3E8
subl %eax, %ecx
movl %r12d, %eax
shll $0x1f, %eax
addl %r12d, %eax
leal (%rcx,%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_O1/ra101[P]Generic-BlockChain-container-cpp/./includes/rsa.hpp
// Function: bool ra::verify<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long, unsigned long long)
bool verify(Message message, std::size_t digest, unsigned long long int others_public_key)
    {
        std::hash<Message> hash_function;
        short int hash_output = hash_function(message);
        short int res = encrypt(digest, others_public_key);
        return (res == hash_output);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x7(%rsp), %rdi
callq 0x2ec4
movq %rax, %rcx
movabsq $-0x501400f434db5501, %rdx # imm = 0xAFEBFF0BCB24AAFF
movq %rbx, %rax
mulq %rdx
movq %rdx, %rsi
shrq $0x24, %rsi
imull $0x4876e800, %esi, %eax # imm = 0x4876E800
subl %eax, %ebx
movl $0x1, %edi
testl %ebx, %ebx
jle 0x30d0
movq %r14, %rax
cqto
idivq %rsi
movq %rdx, %r14
testb $0x1, %bl
je 0x30c1
imulq %r14, %rdi
movq %rdi, %rax
cqto
idivq %rsi
movq %rdx, %rdi
movl %ebx, %eax
shrl %eax
imulq %r14, %r14
cmpl $0x1, %ebx
movl %eax, %ebx
ja 0x30a2
xorw %cx, %di
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x38, %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
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x3968
movl 0x10(%rbx), %r8d
movb $0x1, %r13b
leaq 0x8(%rsp), %rcx
movq %r15, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x37fe
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3908
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2030
incq 0x10(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x36e6
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movb $0x1, %r13b
jmp 0x31ab
movq %rax, %r12
jmp 0x31bd
movq %rax, %r12
leaq 0x8(%rsp), %rdi
callq 0x36e6
testb %r13b, %r13b
je 0x31bd
movl $0x58, %esi
movq %r15, %rdi
callq 0x2170
movq %r14, %rdi
callq 0x36e6
movq %rbx, %rdi
callq 0x3736
movq %r12, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %r14
movq %rsi, (%rsp)
movq %rdx, 0x8(%rsp)
cmpq %rdx, (%rdi)
jne 0x324a
cmpq $0x0, 0x20(%r14)
jne 0x32a2
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4356
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x539a
movq %rax, 0x20(%r14)
movq (%rbx), %rdi
leaq 0x80(%rsp), %rax
cmpq %rax, %rdi
je 0x323c
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x2170
movb $0x1, %al
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
movq (%r14), %rsi
leaq 0x50(%rsp), %rdi
callq 0x483f
movq 0x8(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x483f
movb $0x1, %bpl
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x4a8c
xorl %ebp, %ebp
leaq 0x5a4f(%rip), %rsi      # 0x8ce0
movq 0x5d18(%rip), %rdx      # 0x8fb0
movq %rbx, %rdi
callq 0x2280
jmp 0x32e4
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x4cba
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x531a
xorl %ebp, %ebp
leaq 0x5a23(%rip), %rsi      # 0x8cf8
movq 0x5d04(%rip), %rdx      # 0x8fe0
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x330a
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2170
jmp 0x330a
movq %rax, %r14
movb $0x1, %bpl
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3347
movq 0x60(%rsp), %rsi
jmp 0x3335
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3347
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2170
jmp 0x3347
jmp 0x3341
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x3354
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x552e
testb %al, %al
je 0x3391
addq $0x18, %rbx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x5648
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x4cba
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x55b0
xorl %ebp, %ebp
leaq 0x59a0(%rip), %rsi      # 0x8d60
movq 0x5c19(%rip), %rdx      # 0x8fe0
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x33f5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2170
jmp 0x33f5
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x3402
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x342b
jnp 0x345c
xorl %r15d, %r15d
leaq 0x8(%rsp), %r14
movq %r15, 0x18(%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 0x335c
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 0x3968
movl 0x10(%rbx), %r8d
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r15, %rcx
callq 0x37fe
leaq 0x60(%rsp), %rdi
callq 0x36e6
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3908
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2030
incq 0x10(%rbx)
movq %r14, %rdi
callq 0x586e
leaq 0x30(%rsp), %rdi
callq 0x36e6
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %r15
jmp 0x34e6
movq %rax, %rbx
movq %r15, %rdi
callq 0x36e6
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x352a
leaq 0x2c96(%rip), %rsi      # 0x61a6
movl $0x10, %edx
movq %rbx, %rdi
callq 0x21c0
movl (%r14), %esi
movq %rbx, %rdi
callq 0x2290
jmp 0x353e
leaq 0x2c62(%rip), %rsi      # 0x6193
movl $0x12, %edx
movq %rbx, %rdi
callq 0x21c0
leaq 0x2c72(%rip), %rsi      # 0x61b7
movl $0x11, %edx
movq %rbx, %rdi
callq 0x21c0
movq 0x50(%r14), %rsi
movq %rbx, %rdi
callq 0x2110
movq %rax, %r15
leaq 0x2c61(%rip), %rsi      # 0x61c9
movl $0x7, %edx
movq %rax, %rdi
callq 0x21c0
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x2110
movq %rax, %r15
leaq 0x2c46(%rip), %rsi      # 0x61d1
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 0x35f5
movl $0x1, %ebp
leaq 0x2c25(%rip), %r12      # 0x61e2
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 0x589b
movq %r15, %rdi
callq 0x21d0
movq %rax, %r15
incl %ebp
cmpq %r14, %rax
jne 0x35bd
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x364e
leaq 0x10(%r15), %r14
movq %r14, %rdi
callq 0x5910
testb %al, %al
je 0x364e
cmpq (%rbx), %r15
je 0x363b
movq 0x18(%r15), %rax
cmpq 0x20(%r12), %rax
jne 0x364e
movq 0x50(%rbx), %rsi
movq %r14, %rdi
callq 0x5a78
movq %r15, %r12
testb %al, %al
jne 0x3613
cmpq %rbx, %r15
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
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 0x4050
cmpl $0x3, %ebp
movl $0x3, %r15d
cmovll %ebp, %r15d
cmpl $0x2, %r15d
movl $0x1, %r12d
cmovll %r12d, %r15d
movl $0x0, 0x24(%r14)
callq 0x2200
movq %rax, 0x18(%r14)
movq %rsp, %rdi
movq %r14, %rsi
callq 0x3e16
addl %r12d, %r12d
leal (%r12,%r12,4), %r12d
decl %r15d
jne 0x387d
movl %r12d, %ecx
movabsq $0x5af3107a4000, %rax   # imm = 0x5AF3107A4000
xorl %edx, %edx
divq %rcx
movq %rsp, %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x3b2a
movq %rax, 0x10(%r14)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x38c8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2170
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x38f8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2170
jmp 0x38f8
movq %rax, %r14
movq %rbx, %rdi
callq 0x36e6
movq %r14, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x557c
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4356
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 0x557e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2170
jmp 0x557e
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 0x55a8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O1/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
sete %bpl
je 0x5ac3
movq %rsi, %rbx
leaq 0x20(%r15), %rdi
movq %rbx, %rsi
callq 0x552e
testb %al, %al
je 0x5ac3
movq %r15, %rdi
callq 0x21d0
cmpq %r14, %rax
sete %bpl
je 0x5ac3
movq %rax, %r15
movq %rax, %rdi
addq $0x20, %rdi
jmp 0x5a9a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5b31
movq %rsi, %rbx
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
cmpq %rbx, 0x28(%rax)
jne 0x5afd
movss 0x30(%rax), %xmm0
jmp 0x5b12
xorps %xmm0, %xmm0
cmpq %rbx, 0x20(%rax)
jne 0x5b12
movss 0x30(%rax), %xmm0
xorps 0x50e(%rip), %xmm0      # 0x6020
movss 0x4(%rsp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x4(%rsp)
movq %rax, %rdi
callq 0x21d0
cmpq %r14, %rax
jne 0x5af0
jmp 0x5b3a
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_O1/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 0x1be81(%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 0xd45e
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1427e
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd293
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8170
leaq 0x1be4c(%rip), %rsi     # 0x290e6
leaq 0x9b(%rip), %rdx        # 0xd33c
movq %r15, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x82a0
leaq 0x1be36(%rip), %rsi     # 0x290ee
leaq 0x703b(%rip), %rdx      # 0x142fa
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 0xd327
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8170
jmp 0xd327
movq %rax, %r14
movl $0x50, %esi
movq %rbx, %rdi
callq 0x8170
movq %r14, %rdi
callq 0x87b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b67a(%rip), %rsi     # 0x29041
callq 0x8c00
testl %eax, %eax
je 0xd9e0
movq 0x60(%rbx), %rdi
xorl %esi, %esi
callq 0x8370
movq %rax, %r14
jmp 0xda30
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd93c
movq (%r14), %rdi
movq 0x29576(%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 0xda30
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8170
movl 0xa0(%rbx), %edx
cmpl $-0x1, %edx
je 0xda56
movl 0xa4(%rbx), %esi
cmpl $-0x1, %esi
je 0xda56
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 0xda7f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8170
movq %rbx, %rdi
callq 0x87b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe124
leaq 0x38(%rsp), %rbx
movq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x8630
movq (%rbx), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0xe07e
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 0xe08f
movq %rax, %r13
movq (%rbp), %rdi
cmpq %r12, %rdi
je 0xe0a7
movq (%r12), %rsi
incq %rsi
callq 0x8170
movq 0x20(%rsp), %rax
movq (%rax), %rdi
cmpq (%rsp), %rdi
je 0xe0c4
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x8170
movq 0x28(%rsp), %rax
movq (%rax), %rdi
cmpq 0x8(%rsp), %rdi
je 0xe0e3
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x8170
movq 0x30(%rsp), %rax
movq (%rax), %rdi
cmpq 0x10(%rsp), %rdi
je 0xe102
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x8170
movq (%rbx), %rdi
cmpq 0x18(%rsp), %rdi
je 0xe11c
movq 0x18(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x8170
movq %r13, %rdi
callq 0x87b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd524
movq %r15, %rdi
callq 0x8300
leaq 0x29e5b(%rip), %rsi     # 0x37fc0
leaq 0x8(%rsp), %rdi
callq 0xe3b2
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x8570
cmpl $0x3, 0x48(%rsp)
je 0xe1ac
leaq 0x8(%rsp), %rdi
callq 0x8300
leaq 0x8(%rsp), %rdi
callq 0x8300
leaq 0x29e1e(%rip), %rsi     # 0x37fc0
leaq 0x8(%rsp), %rdi
callq 0xe3b2
leaq 0x80(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0xe432
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0xd524
leaq 0x1c500(%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 0xe225
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0xe22c
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 0xe3b2
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0xe269
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x8170
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xe280
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 0xd524
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xe2b3
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 0xe2e3
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x8170
jmp 0xe2e3
jmp 0xe2e0
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xe301
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x8170
jmp 0xe301
jmp 0xe2fe
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xe318
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8170
movq %rbx, %rdi
callq 0x87b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xfb5d
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 0xd45e
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 0xfb7f
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0xfb8b
movl (%r15), %ecx
cmpl $0x22, %ecx
je 0xfb8b
testl %ecx, %ecx
jne 0xfb06
movl %ebp, (%r15)
leaq 0x1c(%rsp), %rsi
movl %eax, (%rsi)
movq %rbx, %rdi
callq 0x26864
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfb30
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8170
movq %rbx, %rdi
callq 0x173ee
movq %r14, %rdi
movq %rbx, %rsi
callq 0xfbde
movq 0x8(%rsp), %rdi
callq 0x90c8
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movl $0x1, %ebx
jmp 0xfb65
movq %r14, %rdi
callq 0x10088
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 0x197a8(%rip), %rdi     # 0x2932e
callq 0x81d0
leaq 0x1979c(%rip), %rdi     # 0x2932e
callq 0x8770
movq %rax, %r14
jmp 0xfbad
movq %rax, %r14
jmp 0xfbc8
movq %rax, %r14
cmpl $0x0, (%r15)
jne 0xfbad
movl %ebp, (%r15)
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfbc8
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_O1/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 0x11bb6
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 0x1056c
movq %rbx, %rdi
callq 0x10994
movq %rbx, %rdi
callq 0x10bea
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 0x10088
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 0x18ce3(%rip), %rsi     # 0x2921e
leaq -0xb01(%rip), %rdx      # 0xfa41
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 0x11bba
movq %r14, %rdi
callq 0x87b0
// File: /workspace/github_cpp_makefile_star2_O1/eiskalteschatten[P]developersnotebook/src/views/ProjectsView.cpp
// Function: ProjectsView::setup_list_store()
void ProjectsView::setup_list_store() {
    GtkTreeIter tree_iter;
    ProjectsModel all_projects;

    list_store = gtk_list_store_new(N_COLUMNS,
                                    G_TYPE_STRING,
                                    G_TYPE_STRING,
                                    G_TYPE_STRING,
                                    G_TYPE_STRING,
                                    G_TYPE_STRING,
                                    G_TYPE_STRING,
                                    G_TYPE_BOOLEAN,
                                    G_TYPE_STRING,
                                    G_TYPE_STRING);


    all_projects.select_all();
    const tableVector &contents = all_projects.get_full_table();

    for (auto const &row_map : contents) {
        ProjectsModel *row = new ProjectsModel(row_map);
        row->truncate_notes();
        append_to_list_store(&tree_iter);
        set_list_store(row, &tree_iter);
        delete row;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x170, %rsp            # imm = 0x170
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x26784
movl $0x40, %r10d
movl $0x40, %esi
movl $0x40, %edx
movl $0x40, %ecx
movl $0x40, %r8d
movl $0x40, %r9d
movl $0x9, %edi
xorl %eax, %eax
pushq %r10
pushq %r10
pushq $0x14
pushq %r10
callq 0x88e0
addq $0x20, %rsp
movq %rax, 0x38(%rbx)
leaq 0x28(%rsp), %rdi
callq 0x1792a
movq 0x68(%rsp), %r14
movq 0x70(%rsp), %r13
cmpq %r13, %r14
je 0x115aa
leaq 0x8(%rsp), %r15
movl $0x148, %edi            # imm = 0x148
callq 0x81a0
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x26938
movq %r12, %rdi
callq 0x2792c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x115ee
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xf020
movq (%r12), %rax
movq %r12, %rdi
callq *0x10(%rax)
addq $0x30, %r14
cmpq %r13, %r14
jne 0x1155e
leaq 0x28(%rsp), %rdi
callq 0x26dba
addq $0x170, %rsp            # imm = 0x170
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x115d9
movq %rax, %rbx
movl $0x148, %esi            # imm = 0x148
movq %r12, %rdi
callq 0x8170
jmp 0x115dc
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x26dba
movq %rbx, %rdi
callq 0x87b0
// File: /workspace/github_cpp_makefile_star2_O1/eiskalteschatten[P]developersnotebook/src/views/ProjectsView.cpp
// Function: ProjectsView::select_row_in_list_view(char const*)
void ProjectsView::select_row_in_list_view(const gchar *id) {
    GtkTreeIter tree_iter;
    gboolean has_next = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(list_store), &tree_iter);

    while (has_next) {
        gchar *id_col;

        gtk_tree_model_get(GTK_TREE_MODEL(list_store), &tree_iter,
                           ID_COLUMN, &id_col,
                           -1);

        if (strcmp(id_col, id) == 0) {
            select_row_in_list_view(&tree_iter);
            break;
        }

        g_free(id_col);

        has_next = gtk_tree_model_iter_next(GTK_TREE_MODEL(list_store), &tree_iter);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
movq 0x38(%rdi), %rbx
callq 0x8520
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8150
leaq 0x18(%rsp), %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0x8160
movl %eax, %ebp
testl %ebp, %ebp
je 0x116d1
movq 0x38(%r14), %rdi
movq %r15, %rsi
callq 0x8150
movq %rax, %rdi
movq %r12, %rsi
xorl %edx, %edx
leaq 0x10(%rsp), %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x8850
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0x8b00
movl %eax, %r13d
testl %eax, %eax
je 0x116c1
movq %rbx, %rdi
callq 0x90c8
movq 0x38(%r14), %rdi
movq %r15, %rsi
callq 0x8150
movq %rax, %rdi
movq %r12, %rsi
callq 0x8720
movl %eax, %ebp
jmp 0x116cc
movq %r14, %rdi
movq %r12, %rsi
callq 0xf4f4
testl %r13d, %r13d
jne 0x1165b
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/eiskalteschatten[P]developersnotebook/src/views/AbstractView.cpp
// Function: AbstractView::sort_by_string(_GtkTreeModel*, _GtkTreeIter*, _GtkTreeIter*, void*)
gint AbstractView::sort_by_string(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer user_data) {
    gint ret = 0;
    gchar *string1;
    gchar *string2;
    gint sortcol = GPOINTER_TO_INT(user_data);

    gtk_tree_model_get(model, a, sortcol, &string1, -1);
    gtk_tree_model_get(model, b, sortcol, &string2, -1);

    if (
        (string1 == NULL || string2 == NULL) &&
        !(string1 == NULL && string2 == NULL)
    ) {
        ret = (string1 == NULL) ? -1 : 1;
    }
    else if (!(string1 == NULL && string2 == NULL)) {
        ret = g_utf8_collate(string1, string2);
    }

    g_free(string1);
    g_free(string2);

    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
xorl %ebx, %ebx
leaq 0x10(%rsp), %r13
movl %r14d, %edx
movq %r13, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x8850
leaq 0x8(%rsp), %rbp
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movq %rbp, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x8850
movq (%r13), %r14
testq %r14, %r14
sete %al
movq (%rbp), %rsi
testq %rsi, %rsi
sete %cl
cmpb %cl, %al
je 0x11c4e
xorl %ebx, %ebx
cmpq $0x1, %r14
sbbl %ebx, %ebx
orl $0x1, %ebx
jmp 0x11c60
movq %r14, %rax
orq %rsi, %rax
je 0x11c60
movq %r14, %rdi
callq 0x9040
movl %eax, %ebx
movq %r14, %rdi
callq 0x90c8
movq 0x8(%rsp), %rdi
callq 0x90c8
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/eiskalteschatten[P]developersnotebook/src/views/AbstractView.cpp
// Function: AbstractView::sort_by_boolean(_GtkTreeModel*, _GtkTreeIter*, _GtkTreeIter*, void*)
gint AbstractView::sort_by_boolean(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer user_data) {
    gboolean bool1;
    gboolean bool2;
    gint sortcol = GPOINTER_TO_INT(user_data);

    gtk_tree_model_get(model, a, sortcol, &bool1, -1);
    gtk_tree_model_get(model, b, sortcol, &bool2, -1);

    if (!bool1 && bool2) {
        return -1;
    }
    else if (bool1 && !bool2) {
        return 1;
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
xorl %ebx, %ebx
leaq 0x4(%rsp), %r13
movl %r14d, %edx
movq %r13, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x8850
movq %rsp, %rbp
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movq %rbp, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x8850
movl (%r13), %eax
testl %eax, %eax
sete %cl
movl (%rbp), %edx
testl %edx, %edx
setne %sil
orb %cl, %sil
xorb $0x1, %sil
movzbl %sil, %ecx
negl %edx
sbbl %ebx, %ebx
orl %ecx, %ebx
testl %eax, %eax
cmovnel %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/eiskalteschatten[P]developersnotebook/src/views/AbstractView.cpp
// Function: AbstractView::sort_by_date(_GtkTreeModel*, _GtkTreeIter*, _GtkTreeIter*, void*)
gint AbstractView::sort_by_date(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer user_data) {
    gchar *string_char1;
    gchar *string_char2;
    gint sortcol = GPOINTER_TO_INT(user_data);

    gtk_tree_model_get(model, a, sortcol, &string_char1, -1);
    gtk_tree_model_get(model, b, sortcol, &string_char2, -1);

    std::string string1 = std::string(string_char1);
    std::string string2 = std::string(string_char2);

    g_free(string_char1);
    g_free(string_char2);

    std::tm tm1 = get_date_from_string(&string1);
    std::tm tm2 = get_date_from_string(&string2);

    return difftime(mktime(&tm1), mktime(&tm2)) < 0 ? -1 : 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movl %ebx, %edx
movq %r12, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x8850
movq %rsp, %r13
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
movq %r13, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x8850
movq (%r12), %rsi
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0xd45e
movq (%r13), %rsi
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0xd45e
movq 0x8(%rsp), %rdi
callq 0x90c8
movq (%rsp), %rdi
callq 0x90c8
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x11e7a
leaq 0x88(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x11e7a
leaq 0x50(%rsp), %rdi
callq 0x84f0
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x84f0
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11de5
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x8170
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11e00
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x8170
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8400
xorpd %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm0, %xmm1
setbe %al
leal -0x1(,%rax,2), %eax
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x11e39
jmp 0x11e39
movq %rax, %rbx
jmp 0x11e57
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11e57
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x8170
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11e72
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x8170
movq %rbx, %rdi
callq 0x87b0
// File: /workspace/github_cpp_makefile_star2_O1/eiskalteschatten[P]developersnotebook/src/views/AbstractView.cpp
// Function: AbstractView::get_date_from_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
std::tm AbstractView::get_date_from_string(std::string *date_str) {
    std::tm date_tm = {};
    std::stringstream ss(*date_str);
    ss >> std::get_time(&date_tm, Constants::default_date_format.c_str());
    return date_tm;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq $0x0, 0x30(%rdi)
movq %rsp, %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0x90a0
movq 0x263ac(%rip), %rdx     # 0x38260
movq %r14, %rdi
movq %rbx, %rsi
callq 0x122a5
movq 0x250ea(%rip), %rsi     # 0x36fb0
movq %rsp, %rdi
callq 0x89a0
leaq 0x80(%rsp), %rdi
callq 0x88d0
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x250bd(%rip), %rsi     # 0x36fb0
movq %rsp, %rdi
callq 0x89a0
leaq 0x80(%rsp), %rdi
callq 0x88d0
movq %rbx, %rdi
callq 0x87b0
// File: /workspace/github_cpp_makefile_star2_O1/eiskalteschatten[P]developersnotebook/src/views/AbstractView.cpp
// Function: AbstractView::format_date[abi:cxx11](unsigned int const*, unsigned int const*, unsigned int const*)
std::string AbstractView::format_date(const guint *year, const guint *month, const guint *day) {
    std::tm date_tm = {};

    date_tm.tm_year = *year - 1900;
    date_tm.tm_mon  = *month;
    date_tm.tm_mday = *day;

    std::time_t time_temp   = std::mktime(&date_tm);
    const std::tm *time_out = std::localtime(&time_temp);

    return format_date(time_out);
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq $0x0, 0x30(%rdi)
movl $0xfffff894, %eax       # imm = 0xFFFFF894
addl (%rsi), %eax
movl %eax, 0x14(%rdi)
movl (%rdx), %eax
movl %eax, 0x10(%rdi)
movl (%rcx), %eax
movl %eax, 0xc(%rdi)
callq 0x84f0
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x87e0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11f6e
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/eiskalteschatten[P]developersnotebook/src/views/AbstractView.cpp
// Function: AbstractView::reset_calender(_GtkWidget*)
void AbstractView::reset_calender(GtkWidget *calendar) {
    auto now               = std::time(nullptr);
    struct std::tm *now_tm = std::localtime(&now);
    guint year             = now_tm->tm_year + 1900;

    gtk_calendar_select_month(GTK_CALENDAR(calendar), now_tm->tm_mon, year);
    gtk_calendar_select_day(GTK_CALENDAR(calendar), now_tm->tm_mday);

    gtk_calendar_select_day(GTK_CALENDAR(calendar), 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
xorl %edi, %edi
callq 0x8910
movq %rsp, %rdi
movq %rax, (%rdi)
callq 0x87e0
movq %rax, %r14
movl $0x76c, %ebp            # imm = 0x76C
addl 0x14(%rax), %ebp
callq 0x8540
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8150
movl 0x10(%r14), %esi
movq %rax, %rdi
movl %ebp, %edx
callq 0x9020
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8150
movl 0xc(%r14), %esi
movq %rax, %rdi
callq 0x8c90
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8150
movq %rax, %rdi
xorl %esi, %esi
callq 0x8c90
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq