LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ra101[P]Generic-BlockChain-container-cpp/./includes/rsa.hpp
// Function: ra::encrypt_with_padding[abi:cxx11](unsigned long, unsigned long long)
std::string encrypt_with_padding(std::size_t digest, unsigned long long int others_public_key)
    {
        std::string output;
        while (digest != 0)
        {
            // encrypt one digit at a time and pad it
            output = padding(std::to_string(encrypt((digest % 10), others_public_key))) + output;
            digest /= 10;
        }
        return output;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %r12
leaq 0x28(%rsp), %r13
leaq 0x48(%rsp), %rbp
testq %r15, %r15
je 0x37ab
movq %r15, %rax
xorl %edx, %edx
pushq $0xa
popq %rcx
divq %rcx
movq %rdx, %rdi
movq %rax, %r15
movq %r14, %rsi
callq 0x3618
movq %r12, %rdi
movq %rax, %rsi
callq 0x3bf5
movq %r13, %rdi
movq %r12, %rsi
callq 0x36b4
movq %rbp, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x3bd6
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3240
movq %rbp, %rdi
callq 0x30f0
movq %r13, %rdi
callq 0x30f0
movq %r12, %rdi
callq 0x30f0
jmp 0x3744
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x37de
movq %rax, %r14
jmp 0x37d4
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x30f0
leaq 0x8(%rsp), %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x30f0
movq %r14, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O2/ra101[P]Generic-BlockChain-container-cpp/./includes/rsa.hpp
// Function: ra::rsa_key_pair::decrypt_with_padding(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::size_t rsa_key_pair::decrypt_with_padding(std::string encrypted_data)
    {
        int digit = 0;
        std::size_t res = 0;
        int i, n = encrypted_data.length();
        for (i = 0; i < n; digit = 0)
        {
            while (i < n - 1 && encrypted_data.at(i) == '0') // let all zeros pass and n-1 'cuz of i+=1
            {
                i += 1;
                if (i % PAD_SIZE == 0)
                {
                    // if we pass a PAD_SIZEgth of '0's (encryption of zero is zero)
                    res = res * 10;
                }
            }
            while (i % PAD_SIZE != 0) // change loop after each PAD_SIZEgth
            {
                digit = digit * 10 + (encrypted_data.at(i) - '0'); // create digit
                i += 1;
            }
            res = res * 10 + decrypt(digit);
        }
        return res;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
movl 0x8(%rsi), %eax
movq %rax, 0x10(%rsp)
decl %eax
cltq
movq %rax, (%rsp)
xorl %r15d, %r15d
pushq $0xa
popq %r14
xorl %ebp, %ebp
cmpl 0x10(%rsp), %ebp
jge 0x38bc
movslq %ebp, %r13
movq %r13, %r12
shlq $0x20, %r12
incl %ebp
cmpq (%rsp), %r13
jge 0x386b
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3330
cmpb $0x30, (%rax)
jne 0x3871
incq %r13
movl %ebp, %eax
cltd
idivl %r14d
imulq $0xa, %r15, %rax
testl %edx, %edx
cmoveq %rax, %r15
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %r12
jmp 0x3831
movq (%rsp), %r12
jmp 0x3875
sarq $0x20, %r12
xorl %esi, %esi
movl %r12d, %eax
cltd
idivl %r14d
testl %edx, %edx
je 0x38a0
imull $0xa, %esi, %r13d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3330
movsbl (%rax), %eax
leal (%rax,%r13), %esi
addl $-0x30, %esi
incq %r12
jmp 0x3877
imulq $0xa, %r15, %r13
movq 0x8(%rsp), %rdi
callq 0x3664
movq %rax, %r15
addq %r13, %r15
movl %r12d, %ebp
jmp 0x381d
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdi, %r14
imulq $0x41a7, (%rdi), %rax   # imm = 0x41A7
xorl %r12d, %r12d
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
divq %rcx
movq %rdx, %rax
movq %rdx, (%rdi)
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
movl %edx, %ebx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x3210
movq 0x10(%r14), %rsi
pushq $0x8
popq %rdx
movq %r15, %rdi
callq 0x3120
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %r15
cmpl %ebx, %r12d
ja 0x3b39
movq %r14, %rdi
movq %r15, %rsi
callq 0x3110
incl %r12d
jmp 0x3b24
leaq 0x10(%rsp), %rdi
callq 0x3080
movl 0xc(%rsp), %ebx
leaq 0x10(%rsp), %rdi
callq 0x30a0
movl %ebx, %eax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x3b64
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %rax
andl $0x0, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movq %rax, 0x38(%rdi)
andq $0x0, 0x40(%rdi)
leaq 0x18(%rdi), %r14
movl %esi, 0x48(%rdi)
movss %xmm0, 0x4c(%rdi)
movq %rdx, 0x50(%rdi)
pushq $0x58
popq %rdi
callq 0x31c0
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x457c
movl 0x10(%rbx), %r8d
movb $0x1, %r13b
leaq 0x8(%rsp), %rcx
movq %r15, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x43c6
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x43ba
leaq 0x8(%rsp), %rdi
callq 0x428c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
jmp 0x3d6a
movq %rax, %r12
jmp 0x3d75
movq %rax, %r12
leaq 0x8(%rsp), %rdi
callq 0x428c
testb %r13b, %r13b
je 0x3d75
pushq $0x58
popq %rsi
movq %r15, %rdi
callq 0x31d0
movq %r14, %rdi
callq 0x428c
movq %rbx, %rdi
callq 0x42e4
movq %r12, %rdi
callq 0x3300
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
cmpq %rdx, (%rdi)
jne 0x3df1
cmpq $0x0, 0x20(%r14)
jne 0x3e48
leaq 0x78(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4d1a
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x5428
movq %rax, 0x20(%r14)
movq %rbx, %rdi
callq 0x30f0
movb $0x1, %al
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
pushq $0x10
popq %rdi
callq 0x3100
movq %rax, %rbx
movq (%r14), %rsi
leaq 0x58(%rsp), %rdi
callq 0x4eb1
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
callq 0x4eb1
movb $0x1, %bpl
leaq 0x58(%rsp), %rsi
leaq 0x38(%rsp), %rdx
movq %rbx, %rdi
callq 0x50fc
xorl %ebp, %ebp
leaq 0x5ea9(%rip), %rsi      # 0x9ce0
movq 0x6172(%rip), %rdx      # 0x9fb0
movq %rbx, %rdi
callq 0x32e0
jmp 0x3e88
pushq $0x10
popq %rdi
callq 0x3100
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x51e8
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x53ca
xorl %ebp, %ebp
leaq 0x5e7f(%rip), %rsi      # 0x9cf8
movq 0x6160(%rip), %rdx      # 0x9fe0
movq %rbx, %rdi
callq 0x32e0
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x30f0
jmp 0x3e9d
movq %rax, %r14
movb $0x1, %bpl
leaq 0x58(%rsp), %rdi
jmp 0x3eac
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x30f0
testb %bpl, %bpl
jne 0x3ebd
jmp 0x3ec5
jmp 0x3eba
movq %rax, %r14
movq %rbx, %rdi
callq 0x3150
movq %r14, %rdi
callq 0x3300
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5568
testb %al, %al
je 0x3f03
addq $0x18, %rbx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x5638
pushq $0x10
popq %rdi
callq 0x3100
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x51e8
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x55c4
xorl %ebp, %ebp
leaq 0x5e30(%rip), %rsi      # 0x9d60
movq 0x60a9(%rip), %rdx      # 0x9fe0
movq %rbx, %rdi
callq 0x32e0
movq %rax, %r14
movq %rsp, %rdi
callq 0x30f0
testb %bpl, %bpl
jne 0x3f54
jmp 0x3f5c
movq %rax, %r14
movq %rbx, %rdi
callq 0x3150
movq %r14, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3f85
jnp 0x3fb1
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
movq %rsi, 0x8(%r14)
movss %xmm0, 0x10(%r14)
callq 0x3260
movq %rax, 0x18(%r14)
andq $0x0, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ece
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 0x457c
movl 0x10(%rbx), %r8d
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r15, %rcx
callq 0x43c6
leaq 0x60(%rsp), %rdi
callq 0x428c
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x43ba
movq %r14, %rdi
callq 0x57e4
leaq 0x30(%rsp), %rdi
callq 0x428c
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %r15
jmp 0x402c
movq %rax, %rbx
movq %r15, %rdi
callq 0x428c
movq %rbx, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O2/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 0x406b
leaq 0x20fc(%rip), %rsi      # 0x6152
movq %rbx, %rdi
callq 0x31b0
movl (%r14), %esi
movq %rax, %rdi
callq 0x32f0
jmp 0x407a
leaq 0x20cd(%rip), %rsi      # 0x613f
movq %rbx, %rdi
callq 0x31b0
leaq 0x20e2(%rip), %rsi      # 0x6163
movq %rbx, %rdi
callq 0x31b0
movq 0x50(%r14), %rsi
movq %rax, %rdi
callq 0x3130
leaq 0x20d9(%rip), %rsi      # 0x6175
movq %rax, %rdi
callq 0x31b0
movq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x3130
leaq 0x20c6(%rip), %rsi      # 0x617d
movq %rax, %rdi
callq 0x31b0
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x3130
movq 0x40(%r14), %r15
addq $0x30, %r14
pushq $0x1
popq %rbp
leaq 0x20b1(%rip), %r12      # 0x618e
cmpq %r14, %r15
je 0x4112
movq %rbx, %rdi
movq %r12, %rsi
callq 0x31b0
movq %rax, %rdi
movl %ebp, %esi
callq 0x32f0
leaq 0x20(%r15), %rsi
movq %rax, %rdi
callq 0x5811
movq %r15, %rdi
callq 0x3220
movq %rax, %r15
incl %ebp
jmp 0x40dd
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x416a
leaq 0x10(%r15), %r14
movq %r14, %rdi
callq 0x5860
testb %al, %al
je 0x416a
cmpq (%rbx), %r15
je 0x4157
movq 0x18(%r15), %rax
cmpq 0x20(%r12), %rax
jne 0x416a
movq 0x50(%rbx), %rsi
movq %r14, %rdi
callq 0x58ee
movq %r15, %r12
testb %al, %al
jne 0x412f
cmpq %rbx, %r15
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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>>>>::get_balance(unsigned long long)
float get_balance(const unsigned long long int address)
        {
            float balance = 0;
            for (iterator current_block = begin(); current_block != end(); ++current_block)
                balance += (*current_block).get_balance(address);

            return balance;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rdi, %r15
movq (%r15), %r15
cmpq %r14, %r15
je 0x41c3
leaq 0x10(%r15), %rdi
movq %rbx, %rsi
movss %xmm0, 0xc(%rsp)
callq 0x5930
movss 0xc(%rsp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp)
movss 0xc(%rsp), %xmm0
jmp 0x4191
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x18(%rdi)
leaq 0x30(%rdi), %rax
andl $0x0, 0x30(%rdi)
andq $0x0, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movq %rax, 0x48(%rdi)
andq $0x0, 0x50(%rdi)
leaq 0x28(%rdi), %rbx
movl %r8d, (%rdi)
movq %rsi, 0x8(%rdi)
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x492a
andl $0x0, 0x24(%r14)
callq 0x3260
movq %rax, 0x18(%r14)
movq %rsp, %rdi
movq %r14, %rsi
callq 0x484a
cmpl $0x3, %ebp
pushq $0x3
popq %rax
cmovll %ebp, %eax
cmpl $0x2, %eax
pushq $0x1
popq %rsi
cmovgel %eax, %esi
movq %r14, %rdi
callq 0x4904
movq %rsp, %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x477e
movq %rax, 0x10(%r14)
movq %rsp, %rdi
callq 0x30f0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x30f0
jmp 0x446e
movq %rax, %r14
movq %rbx, %rdi
callq 0x428c
movq %r14, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O2/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>>>>::mine_block(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, long long)
std::size_t mine_block(std::string hash_input, long long int hash_length)
        {
            std::size_t hash_output = hash_function(hash_input + std::to_string(nonce));
            while (hash_output / hash_length != 0) // own time of proof of work
            {
                nonce += 1;
                hash_output = hash_function(hash_input + std::to_string(nonce));
            }
            return hash_output;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, (%rsp)
movq %rsi, %r14
movq %rdi, %r15
movl 0x24(%rdi), %esi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x4bc7
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4ba3
leaq 0x20(%r15), %r12
leaq 0x28(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x3aac
movq %rax, %rbx
movq %r13, %rdi
callq 0x30f0
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x30f0
cmpq (%rsp), %rbx
jb 0x4820
movl 0x24(%r15), %esi
incl %esi
movl %esi, 0x24(%r15)
movq %rbp, %rdi
callq 0x4bc7
movq %r13, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x4ba3
movq %r12, %rdi
movq %r13, %rsi
callq 0x3aac
movq %rax, %rbx
movq %r13, %rdi
callq 0x30f0
jmp 0x47da
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4834
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x3300
nop
// File: /workspace/github_cpp_makefile_star2_O2/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>>>>::generate_hash_input()
std::string generate_hash_input()
        {
            std::string hash_input = std::to_string((std::chrono::duration_cast<std::chrono::microseconds>(timestamp.time_since_epoch()).count()));
            for (typename std::set<Transaction>::iterator trans_elem = transaction_set.begin(); trans_elem != transaction_set.end(); trans_elem++)
            {
                hash_input += trans_elem->generate_hash_input();
            }
            hash_input += std::to_string(previous_hash);
            return hash_input;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
movq %rax, %rsi
callq 0x4cb9
movq 0x40(%r14), %r12
leaq 0x30(%r14), %r13
movq %rsp, %r15
cmpq %r13, %r12
je 0x48b0
leaq 0x20(%r12), %rsi
movq %r15, %rdi
callq 0x4d1a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3340
movq %r15, %rdi
callq 0x30f0
movq %r12, %rdi
callq 0x3220
movq %rax, %r12
jmp 0x487e
movq 0x8(%r14), %rsi
movq %rsp, %rdi
callq 0x3bf5
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3340
movq %rsp, %rdi
callq 0x30f0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x48e9
jmp 0x48e4
movq %rax, %r14
jmp 0x48f4
movq %rax, %r14
movq %rsp, %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x30f0
movq %r14, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O2/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>>>>::find_hash_length(int)
long long int find_hash_length(int difficulty)
        {
            int factor = 1;
            for (int i = 0; i < difficulty; i++)
            {
                factor *= 10;
            }

            // hash functor produces a number of 10 or 9 digits
            return (100000000000000 / factor);
        }

// Assembly:
xorl %eax, %eax
testl %esi, %esi
cmovgl %esi, %eax
pushq $0x1
popq %rcx
subl $0x1, %eax
jb 0x4918
imull $0xa, %ecx, %ecx
jmp 0x490e
movl %ecx, %ecx
movabsq $0x5af3107a4000, %rax   # imm = 0x5AF3107A4000
xorl %edx, %edx
divq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ra101[P]Generic-BlockChain-container-cpp/main.cpp
// Function: ZNK18custom_transactioncvNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEv
operator std::string() const
  {

    std::string from_address_str = "\nfrom_address: " + std::to_string(from_address);
    std::string to_address_str = "\nto_address: " + std::to_string(to_address);
    std::string transfer_amount_str = "\ntransfer_amount: " + std::to_string(transfer_amount);
    std::string signature_str = "\nsignature: " + std::to_string(signature);

    return from_address_str + to_address_str + transfer_amount_str + signature_str;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
leaq 0x60(%rsp), %r15
movq %r15, %rdi
callq 0x4eb1
leaq 0xec4(%rip), %rsi       # 0x60d5
leaq 0xa0(%rsp), %rdi
movq %r15, %rdx
callq 0x54f5
leaq 0x60(%rsp), %rdi
callq 0x30f0
movq 0x8(%r14), %rsi
leaq 0x40(%rsp), %rdi
callq 0x4eb1
leaq 0xea5(%rip), %rsi       # 0x60e5
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x54f5
leaq 0x40(%rsp), %rdi
callq 0x30f0
movss 0x10(%r14), %xmm0
leaq 0x20(%rsp), %rdi
callq 0x4ef3
leaq 0xe83(%rip), %rsi       # 0x60f3
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x54f5
leaq 0x20(%rsp), %rdi
callq 0x30f0
movq 0x20(%r14), %rsi
movq %rsp, %rdi
callq 0x3bf5
leaq 0xe6a(%rip), %rsi       # 0x6106
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x54f5
movq %rsp, %rdi
callq 0x30f0
leaq 0x80(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x5519
movq %rsp, %rdi
leaq 0x80(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x3bd6
movq %rsp, %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x3bd6
movq %rsp, %rdi
callq 0x30f0
leaq 0x80(%rsp), %rdi
callq 0x30f0
leaq 0x20(%rsp), %rdi
callq 0x30f0
leaq 0x40(%rsp), %rdi
callq 0x30f0
leaq 0x60(%rsp), %rdi
callq 0x30f0
leaq 0xa0(%rsp), %rdi
callq 0x30f0
movq %rbx, %rax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x30f0
jmp 0x5350
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x30f0
jmp 0x5362
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x536f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x30f0
jmp 0x5379
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x30f0
leaq 0x60(%rsp), %rdi
callq 0x30f0
leaq 0xa0(%rsp), %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x3300
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x537e
movq %rax, %rbx
jmp 0x5383
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
jmp 0x5388
movq %rax, %rbx
jmp 0x538d
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
jmp 0x5395
// File: /workspace/github_cpp_makefile_star2_O2/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 0x55a3
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4d1a
movq (%r14), %rdx
movq 0x20(%r14), %rsi
movq %r15, %rdi
callq *%rbx
movl %eax, %ebx
movq %rsp, %rdi
callq 0x30f0
jmp 0x55a5
movb $0x1, %bl
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x40(%rdi), %r15
addq $0x30, %rbx
cmpq %rbx, %r15
je 0x5923
leaq 0x20(%r15), %rdi
movq %r14, %rsi
callq 0x5568
testb %al, %al
je 0x5923
movq %r15, %rdi
callq 0x3220
movq %rax, %r15
jmp 0x5901
cmpq %rbx, %r15
sete %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x40(%rdi), %r15
addq $0x30, %r14
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
cmpq %r14, %r15
je 0x597e
leaq 0x20(%r15), %rdi
movq %rbx, %rsi
callq 0x598e
movss 0xc(%rsp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp)
movq %r15, %rdi
callq 0x3220
movq %rax, %r15
jmp 0x5950
movss 0xc(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ra101[P]Generic-BlockChain-container-cpp/main.cpp
// Function: custom_transaction::get_balance(unsigned long long) const
float get_balance(unsigned long long int address) const
  {
    if (address == this->to_address)
      return transfer_amount;

    if (address == this->from_address)
      return (-transfer_amount);

    return 0;
  }

// Assembly:
cmpq %rsi, 0x8(%rdi)
jne 0x599a
movss 0x10(%rdi), %xmm0
retq
xorps %xmm0, %xmm0
cmpq %rsi, (%rdi)
jne 0x5999
movss 0x10(%rdi), %xmm0
xorps 0x662(%rip), %xmm0      # 0x6010
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movl %edi, %ebp
leaq 0x17201(%rip), %rdi     # 0x220c3
xorl %esi, %esi
callq 0x8c10
movq %rax, %r14
pushq $0x50
popq %rdi
callq 0x81c0
movq %rax, %r15
movq (%rbx), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xb078
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x10662
leaq 0x8(%rsp), %rdi
callq 0x9120
leaq 0x171df(%rip), %rsi     # 0x220e6
leaq 0x88(%rip), %rdx        # 0xaf96
movq %r14, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x82b0
leaq 0x171c9(%rip), %rsi     # 0x220ee
leaq 0x5796(%rip), %rdx      # 0x106c2
movq %r14, %rdi
movq %r15, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x82b0
callq 0x85b0
movq %r14, %rdi
movq %rax, %rsi
callq 0x8150
movq %rax, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x8070
movl %eax, %ebx
movq %r14, %rdi
callq 0x8d50
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x9120
jmp 0xaf83
movq %rax, %rbx
pushq $0x50
popq %rsi
movq %r15, %rdi
callq 0x8190
movq %rbx, %rdi
callq 0x87f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x16bf0(%rip), %rsi     # 0x22041
callq 0xb504
testb %al, %al
je 0xb497
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb3ce
movq (%r14), %rdi
movq 0x26b0c(%rip), %rdx     # 0x31f80
pushq $-0x1
popq %rsi
callq 0x8560
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x81b0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x9120
jmp 0xb4a5
movq 0x60(%rbx), %rdi
xorl %esi, %esi
callq 0x8380
movq %rax, %r14
movl 0xa0(%rbx), %edx
cmpl $-0x1, %edx
je 0xb4c9
movl 0xa4(%rbx), %esi
cmpl $-0x1, %esi
je 0xb4c9
pushq $0x2
popq %rcx
movq %r14, %rdi
callq 0x8a70
movq %rax, %r14
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x9120
movq %rbx, %rdi
callq 0x87f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movq %r8, %r13
movq %rcx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, %r15
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
addq $0x20, %rdi
movb %al, 0x30(%rbx)
leaq 0x50(%rbx), %rcx
movq %rcx, 0x40(%rbx)
andq $0x0, 0x48(%rbx)
leaq 0x40(%rbx), %rcx
movq %rcx, 0x8(%rsp)
movb %al, 0x50(%rbx)
leaq 0x60(%rbx), %r12
leaq 0x70(%rbx), %rcx
movq %rcx, 0x60(%rbx)
andq $0x0, 0x68(%rbx)
movb %al, 0x70(%rbx)
leaq 0x80(%rbx), %rbp
leaq 0x90(%rbx), %rcx
movq %rcx, 0x80(%rbx)
andq $0x0, 0x88(%rbx)
movb %al, 0x90(%rbx)
movq %rdi, 0x10(%rsp)
callq 0x8f00
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x8f00
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8f00
movq %rbp, %rdi
movq %r13, %rsi
callq 0x8f00
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0xb8d0
leaq 0x18(%rsp), %rbx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x8660
movq %rbx, %rdi
callq 0x9120
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb898
movq %rax, %r14
movq %rbp, %rdi
callq 0x9120
movq %r12, %rdi
callq 0x9120
movq 0x8(%rsp), %rdi
callq 0x9120
movq 0x10(%rsp), %rdi
callq 0x9120
movq %rbx, %rdi
callq 0x9120
movq %r14, %rdi
callq 0x87f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x86e0
movq %r15, %rdi
callq 0x8310
leaq 0x276f7(%rip), %rsi     # 0x32ff0
movq %rsp, %rdi
callq 0xba1c
movq %rsp, %rdi
callq 0xb0eb
testb %al, %al
jne 0xb92c
movq %rsp, %rdi
callq 0x8310
movq %rsp, %rdi
callq 0x8310
leaq 0x276cc(%rip), %rsi     # 0x32ff0
movq %rsp, %rdi
callq 0xba1c
leaq 0x80(%r14), %rsi
movq %rsp, %rdi
callq 0xba6c
leaq 0x20(%r14), %rsi
leaq 0x17daa(%rip), %rdx     # 0x236f0
leaq 0x20(%rsp), %rdi
callq 0xb0b3
addq $0x40, %r14
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %r14, %rdx
callq 0xbabb
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0xba1c
leaq 0x40(%rsp), %rdi
callq 0x9120
leaq 0x20(%rsp), %rdi
callq 0x9120
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x86e0
movq %rsp, %rdi
callq 0x9120
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x9120
jmp 0xb9b9
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9120
jmp 0xb9ca
jmp 0xb9c7
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9120
movq %rbx, %rdi
callq 0x87f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
leaq 0x10(%rsp), %rsi
andq $0x0, (%rsi)
andq $0x0, 0x8(%rsp)
leaq 0x40(%rsp), %rdx
callq 0x8dd0
testl %eax, %eax
je 0xc9d3
movq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %r15
pushq $-0x1
popq %r8
xorl %edx, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x8890
movl $0x148, %edi            # imm = 0x148
callq 0x81c0
movq %rax, %r14
movq (%r15), %rsi
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xb078
leaq 0x20(%rsp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0xe20f
leaq 0x1c(%rsp), %rsi
movl %eax, (%rsi)
movq %r14, %rdi
callq 0x1f966
leaq 0x20(%rsp), %rdi
callq 0x9120
movq %r14, %rdi
callq 0x126aa
movq %rbx, %rdi
movq %r14, %rsi
callq 0xca18
movq 0x8(%rsp), %rdi
callq 0x9118
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
pushq $0x1
popq %rsi
jmp 0xc9dd
movq %rbx, %rdi
callq 0xcd90
xorl %esi, %esi
movq 0x58(%rbx), %rdi
callq 0x9010
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0xca02
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9120
movl $0x148, %esi            # imm = 0x148
movq %r14, %rdi
callq 0x8190
movq %rbx, %rdi
callq 0x87f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe892
xorl %edi, %edi
callq 0x84e0
movq %rax, 0x8(%rbx)
movq %rax, %rdi
xorl %esi, %esi
callq 0x8d60
movq 0x8(%rbx), %rdi
xorl %esi, %esi
callq 0x8ec0
movq %rbx, %rdi
callq 0xd184
movq %rbx, %rdi
callq 0xd592
movq %rbx, %rdi
callq 0xd7ca
movq 0x8(%rbx), %r15
callq 0x8b20
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0x8150
movq 0x10(%rbx), %rsi
pushq $0x1
popq %rdx
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x89a0
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 0xcd90
movq 0x20(%rbx), %r14
callq 0x8e20
movq %r14, %rdi
movq %rax, %rsi
callq 0x8150
movq %rax, %rdi
callq 0x8ed0
movq %rax, 0x40(%rbx)
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x8a60
movq 0x40(%rbx), %rdi
pushq $0x50
popq %rsi
callq 0x8150
leaq 0x150cb(%rip), %rsi     # 0x2221e
leaq -0x845(%rip), %rdx      # 0xc915
movq %rax, %rdi
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x82b0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xe896
movq %r14, %rdi
callq 0x87f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1f880
pushq $0x40
popq %rcx
pushq $0x9
popq %rdi
movq %rcx, %rsi
movq %rcx, %rdx
movq %rcx, %r8
movq %rcx, %r9
xorl %eax, %eax
pushq %rcx
pushq %rcx
pushq $0x14
pushq %rcx
callq 0x8920
addq $0x20, %rsp
movq %rax, 0x38(%rbx)
leaq 0x28(%rsp), %rdi
callq 0x1294e
movq 0x68(%rsp), %r14
movq 0x70(%rsp), %r13
leaq 0x8(%rsp), %r15
cmpq %r13, %r14
je 0xe0ea
movl $0x148, %edi            # imm = 0x148
callq 0x81c0
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x1fa40
movq %r12, %rdi
callq 0x20598
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe12e
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xc284
movq (%r12), %rax
movq %r12, %rdi
callq *0x10(%rax)
addq $0x30, %r14
jmp 0xe09c
leaq 0x28(%rsp), %rdi
callq 0x1fd0a
addq $0x170, %rsp            # imm = 0x170
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xe119
movq %rax, %rbx
movl $0x148, %esi            # imm = 0x148
movq %r12, %rdi
callq 0x8190
jmp 0xe11c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1fd0a
movq %rbx, %rdi
callq 0x87f0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rdi), %r12
callq 0x8550
movq %rax, %r15
movq %r12, %rdi
movq %rax, %rsi
callq 0x8150
leaq 0x8(%rsp), %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0x8160
pushq $-0x1
popq %rbp
testl %eax, %eax
je 0xe200
movq 0x38(%rbx), %rdi
movq %r15, %rsi
callq 0x8150
movq %rax, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %rsp, %rcx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x8890
movq (%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x8b50
testl %eax, %eax
je 0xe1f3
movq %r13, %rdi
callq 0x9118
movq 0x38(%rbx), %rdi
movq %r15, %rsi
callq 0x8150
movq %rax, %rdi
movq %r12, %rsi
callq 0x8760
jmp 0xe19a
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xc572
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %rcx
pushq $-0x1
popq %rbp
movl %r14d, %edx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x8890
leaq 0x8(%rsp), %r13
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movq %r13, %rcx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x8890
leaq 0x10(%rsp), %rax
movq (%rax), %r14
testq %r14, %r14
sete %al
movq (%r13), %rsi
testq %rsi, %rsi
sete %cl
cmpb %cl, %al
je 0xe928
xorl %ebx, %ebx
cmpq $0x1, %r14
sbbl %ebx, %ebx
orl $0x1, %ebx
jmp 0xe93a
movq %r14, %rax
orq %rsi, %rax
je 0xe93a
movq %r14, %rdi
callq 0x9090
movl %eax, %ebx
movq %r14, %rdi
callq 0x9118
movq 0x8(%rsp), %rdi
callq 0x9118
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_O2/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
movq %rsp, %rcx
pushq $-0x1
popq %rbp
movl %r14d, %edx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x8890
leaq 0x4(%rsp), %r13
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movq %r13, %rcx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x8890
movq %rsp, %rax
movl (%rax), %eax
testl %eax, %eax
sete %cl
movl (%r13), %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