LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: zhjw1998[P]Merkle-Tree/src/merkle_tree.cpp
// Function: MerkleTree::containsNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool MerkleTree::containsNode(const std::string& data){
    std::vector<Node*> leaves = getLeaves();
    for(auto leaf : leaves){
        if(leaf->hash == data) return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x9300
leaq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xa6e0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0xa710
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xa740
testb $0x1, %al
jne 0x92a2
jmp 0x92df
leaq -0x40(%rbp), %rdi
callq 0xa780
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa7a0
testb $0x1, %al
jne 0x92c5
jmp 0x92d2
movb $0x1, -0x1(%rbp)
movl $0x1, -0x54(%rbp)
jmp 0x92ea
jmp 0x92d4
leaq -0x40(%rbp), %rdi
callq 0xa830
jmp 0x928f
movb $0x0, -0x1(%rbp)
movl $0x1, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa660
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nop
// File: zhjw1998[P]Merkle-Tree/src/merkle_tree.cpp
// Function: MerkleTree::getLeaves()
std::vector<Node*> MerkleTree::getLeaves(){
    std::deque<Node*> dq;
    Node* front = this->root;
    dq.push_back(front);
    while(!dq.empty()){
        Node* front = dq.front();
        if(!(front->left) && !(front->right)) break;
        dq.pop_front();
        if(front->left) dq.push_back(front->left);
        if(front->right) dq.push_back(front->right);
    }
    return std::vector<Node*>(dq.begin(), dq.end());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0xa880
movq -0xd8(%rbp), %rax
movq -0xd0(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x68(%rbp)
leaq -0x68(%rbp), %rsi
callq 0xa8a0
jmp 0x935f
jmp 0x9361
leaq -0x60(%rbp), %rdi
callq 0xa900
xorb $-0x1, %al
testb $0x1, %al
jne 0x9375
jmp 0x93fc
leaq -0x60(%rbp), %rdi
callq 0xa930
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x93ae
movq -0x80(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x93ae
jmp 0x93fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x94a7
leaq -0x60(%rbp), %rdi
callq 0xa960
movq -0x80(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x93d7
movq -0x80(%rbp), %rsi
addq $0x20, %rsi
leaq -0x60(%rbp), %rdi
callq 0xa8a0
jmp 0x93d5
jmp 0x93d7
movq -0x80(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x93f7
movq -0x80(%rbp), %rsi
addq $0x28, %rsi
leaq -0x60(%rbp), %rdi
callq 0xa8a0
jmp 0x93f5
jmp 0x93f7
jmp 0x9361
leaq -0xa0(%rbp), %rdi
movq %rdi, -0x100(%rbp)
leaq -0x60(%rbp), %rsi
movq %rsi, -0x108(%rbp)
callq 0xa9d0
movq -0x108(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0xaa00
leaq -0xc1(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0xaa30
movq -0xe8(%rbp), %rdi
movq -0x100(%rbp), %rsi
movq -0xf8(%rbp), %rdx
movq -0xf0(%rbp), %rcx
callq 0xaa50
jmp 0x946a
leaq -0xc1(%rbp), %rdi
callq 0xab00
leaq -0x60(%rbp), %rdi
callq 0xab20
movq -0xe0(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xc1(%rbp), %rdi
callq 0xab00
leaq -0x60(%rbp), %rdi
callq 0xab20
movq -0x70(%rbp), %rdi
callq 0x2340
nopl (%rax)
// File: zhjw1998[P]Merkle-Tree/src/merkle_tree.cpp
// Function: MerkleTree::getErrorNode(Node*)
Node* MerkleTree::getErrorNode(Node* root2){
    Node* node1 = this->root;
    Node* node2 = root2;
    while(node1->hash != node2->hash){
        if(!(node2->left) || !(node2->right)) return node2;
        if(node1->left->hash != node2->left->hash){
            node1 = node1->left;
            node2 = node2->left;
        }
        else if(node1->right->hash != node2->right->hash){
            node1 = node1->right;
            node2 = node2->right;
        }
    }
    return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xa850
testb $0x1, %al
jne 0x94f9
jmp 0x9588
movq -0x28(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x950f
movq -0x28(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x9519
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9590
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0xa850
testb $0x1, %al
jne 0x9534
jmp 0x954e
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x9583
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0xa850
testb $0x1, %al
jne 0x9569
jmp 0x9581
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x9583
jmp 0x94e3
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: zhjw1998[P]Merkle-Tree/src/merkle_tree.cpp
// Function: MerkleTree::insertNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void MerkleTree::insertNode(const std::string& data){
    std::vector<Node*> leaves = getLeaves();
    leaves.push_back(new Node(data));
    deleteTree(this->root, false);
    createMerkleTree(leaves);
    std::cout << "merkle insert OK" << std::endl;

    // trietree
    Insert(data);
    std::cout << "trie insert OK" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x90(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9300
movl $0x30, %edi
callq 0x21c0
movq %rax, -0x88(%rbp)
jmp 0x95da
movb $0x1, -0x61(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x2090
jmp 0x95ed
movq -0x88(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xf1c0
jmp 0x95ff
movq -0x88(%rbp), %rax
movb $0x0, -0x61(%rbp)
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa4e0
jmp 0x961d
leaq -0x60(%rbp), %rdi
callq 0x20f0
movq -0x90(%rbp), %rdi
movq (%rdi), %rsi
xorl %edx, %edx
callq 0x9020
jmp 0x9639
leaq -0x80(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa570
jmp 0x9648
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x8b40
jmp 0x965a
leaq -0x80(%rbp), %rdi
callq 0xa660
movq 0xe96e(%rip), %rdi      # 0x17fd8
leaq 0x70ba(%rip), %rsi      # 0x1072b
callq 0x21b0
movq %rax, -0x98(%rbp)
jmp 0x967f
movq -0x98(%rbp), %rdi
movq 0xe93b(%rip), %rsi      # 0x17fc8
callq 0x2200
jmp 0x9694
movq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9760
jmp 0x96a6
movq 0xe92b(%rip), %rdi      # 0x17fd8
leaq 0x7088(%rip), %rsi      # 0x1073c
callq 0x21b0
movq %rax, -0xa0(%rbp)
jmp 0x96c2
movq -0xa0(%rbp), %rdi
movq 0xe8f8(%rip), %rsi      # 0x17fc8
callq 0x2200
jmp 0x96d7
leaq -0x28(%rbp), %rdi
callq 0xa660
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x974a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x971a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x20f0
testb $0x1, -0x61(%rbp)
jne 0x9722
jmp 0x9733
movq -0x88(%rbp), %rdi
movl $0x30, %esi
callq 0x21e0
jmp 0x974a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xa660
leaq -0x28(%rbp), %rdi
callq 0xa660
movq -0x38(%rbp), %rdi
callq 0x2340
nopl (%rax)
// File: zhjw1998[P]Merkle-Tree/src/merkle_tree.cpp
// Function: MerkleTree::deleteNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void MerkleTree::deleteNode(const std::string& data){
    std::vector<Node*> leaves = getLeaves();
    for(unsigned int i = 0; i < leaves.size(); i++){
        if(leaves[i]->hash == data){
            delete leaves[i];
            leaves.erase(leaves.begin() + i);
            break;
        }
    }
    deleteTree(this->root, false);
    createMerkleTree(leaves);

    // trietree
    // 有待商榷
    Remove(this->trieroot, data, 0, data.size());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x80(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9300
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq %rax, -0x88(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xab90
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jae 0x9b09
movl -0x2c(%rbp), %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0xac30
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xa7a0
testb $0x1, %al
jne 0x9a54
jmp 0x9af9
movl -0x2c(%rbp), %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0xac30
movq (%rax), %rax
movq %rax, -0x90(%rbp)
cmpq $0x0, %rax
je 0x9a8f
movq -0x90(%rbp), %rdi
callq 0xa6c0
movq -0x90(%rbp), %rdi
movl $0x30, %esi
callq 0x21e0
leaq -0x28(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xa6e0
movq %rax, -0x48(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, %esi
leaq -0x48(%rbp), %rdi
callq 0xaf30
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xaf70
movq -0xa0(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xaec0
movq %rax, -0x98(%rbp)
jmp 0x9adb
movq -0x98(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x9b09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x9ba4
jmp 0x9afb
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9a0b
movq -0x80(%rbp), %rdi
movq (%rdi), %rsi
xorl %edx, %edx
callq 0x9020
jmp 0x9b19
leaq -0x78(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa570
jmp 0x9b28
movq -0x80(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x8b40
jmp 0x9b37
leaq -0x78(%rbp), %rdi
callq 0xa660
movq -0x80(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x2130
movq -0x80(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movl %eax, %r8d
xorl %ecx, %ecx
callq 0x9bc0
jmp 0x9b7d
leaq -0x28(%rbp), %rdi
callq 0xa660
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xa660
leaq -0x28(%rbp), %rdi
callq 0xa660
movq -0x50(%rbp), %rdi
callq 0x2340
nopw %cs:(%rax,%rax)
// File: zhjw1998[P]Merkle-Tree/src/merkle_tree.cpp
// Function: MerkleTree::Find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool MerkleTree::Find(const std::string& word){
    TrieTreeNode *p = this->trieroot;
    for (unsigned int i = 0; i < word.size(); i++){ 
        if (p->child[GETINDEX(word[i])] == nullptr)
            return false;
        p = p->child[GETINDEX(word[i])];
    }
    return p->isEnd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2130
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x9f47
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x2250
movsbl (%rax), %eax
cmpl $0x39, %eax
jle 0x9ea1
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x2250
movsbl (%rax), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0x3c(%rbp)
jmp 0x9eb8
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x2250
movsbl (%rax), %eax
subl $0x30, %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rax
movl -0x3c(%rbp), %ecx
movslq %ecx, %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x9ed2
movb $0x0, -0x1(%rbp)
jmp 0x9f53
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x2250
movsbl (%rax), %eax
cmpl $0x39, %eax
jle 0x9f10
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x2250
movsbl (%rax), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0x4c(%rbp)
jmp 0x9f27
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x2250
movsbl (%rax), %eax
subl $0x30, %eax
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rax
movl -0x4c(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x9e43
movq -0x20(%rbp), %rax
movb 0x1(%rax), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nop
// File: zhjw1998[P]Merkle-Tree/src/merkle_tree.cpp
// Function: MerkleTree::LevelOrderTraverse()
void MerkleTree::LevelOrderTraverse(){
    if(this->trieroot == nullptr)
        return;
    std::queue<TrieTreeNode *> Q;
    Q.push(this->trieroot);
    while (!Q.empty()){
        TrieTreeNode *p = Q.front();
        std::cout << p->val << "(" << p->childCnt << ") ";
        for (int i = 0; i < SIZE; i++){
            if(p->child[i] != nullptr)
                Q.push(p->child[i]);
        }
        Q.pop();
    }
    std::cout << "\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x9f83
jmp 0xa0df
leaq -0x58(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xafd0
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdi
addq $0x8, %rsi
callq 0xb000
jmp 0x9fa9
jmp 0x9fab
leaq -0x58(%rbp), %rdi
callq 0xb030
movb %al, -0x89(%rbp)
jmp 0x9fbc
movb -0x89(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x9fcd
jmp 0xa0c1
leaq -0x58(%rbp), %rdi
callq 0xb050
movq %rax, -0x98(%rbp)
jmp 0x9fdf
movq -0x98(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movsbl (%rax), %esi
movq 0xdfdd(%rip), %rdi      # 0x17fd8
callq 0x2290
movq %rax, -0xa0(%rbp)
jmp 0xa009
movq -0xa0(%rbp), %rdi
leaq 0x6734(%rip), %rsi      # 0x1074b
callq 0x21b0
movq %rax, -0xa8(%rbp)
jmp 0xa025
movq -0xa8(%rbp), %rdi
movq -0x70(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x2330
movq %rax, -0xb0(%rbp)
jmp 0xa041
movq -0xb0(%rbp), %rdi
leaq 0x66fe(%rip), %rsi      # 0x1074d
callq 0x21b0
jmp 0xa056
movl $0x0, -0x74(%rbp)
cmpl $0x10, -0x74(%rbp)
jge 0xa0b1
movq -0x70(%rbp), %rax
movslq -0x74(%rbp), %rcx
cmpq $0x0, 0x10(%rax,%rcx,8)
je 0xa0a4
movq -0x70(%rbp), %rax
movslq -0x74(%rbp), %rcx
leaq 0x10(%rax,%rcx,8), %rsi
leaq -0x58(%rbp), %rdi
callq 0xb000
jmp 0xa08b
jmp 0xa0a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xb090
jmp 0xa0e8
jmp 0xa0a6
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0xa05d
leaq -0x58(%rbp), %rdi
callq 0xb070
jmp 0xa0bc
jmp 0x9fab
movq 0xdf10(%rip), %rdi      # 0x17fd8
leaq 0x665a(%rip), %rsi      # 0x10729
callq 0x21b0
jmp 0xa0d6
leaq -0x58(%rbp), %rdi
callq 0xb090
addq $0xb0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x2340
nopw %cs:(%rax,%rax)
// File: zhjw1998[P]Merkle-Tree/src/merkle_tree.cpp
// Function: MerkleTree::PreTraverse(TrieTreeNode*)
void MerkleTree::PreTraverse(TrieTreeNode *treeNode){
    if (treeNode != nullptr){
        std::cout << treeNode->val << "(" << treeNode->childCnt << ") ";
        for (int i = 0; i < SIZE; i++){
            PreTraverse(treeNode->child[i]);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xa1cf
movq -0x10(%rbp), %rax
movq 0xde6e(%rip), %rdi      # 0x17fd8
movsbl (%rax), %esi
callq 0x2290
movq %rax, %rdi
leaq 0x65cf(%rip), %rsi      # 0x1074b
callq 0x21b0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x2330
movq %rax, %rdi
leaq 0x65b3(%rip), %rsi      # 0x1074d
callq 0x21b0
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0xa1cd
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rsi
callq 0xa140
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa1a6
jmp 0xa1cf
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zhjw1998[P]Merkle-Tree/src/merkle_tree.cpp
// Function: MerkleTree::PostTraverse(TrieTreeNode*)
void MerkleTree::PostTraverse(TrieTreeNode *treeNode){
    if (treeNode != nullptr){
        for (int i = 0; i < SIZE; i++){
            PostTraverse(treeNode->child[i]);
        }
        std::cout << treeNode->val << "(" << treeNode->childCnt << ") ";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xa2ad
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0xa26d
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rsi
callq 0xa220
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa246
movq -0x10(%rbp), %rax
movq 0xdd60(%rip), %rdi      # 0x17fd8
movsbl (%rax), %esi
callq 0x2290
movq %rax, %rdi
leaq 0x64c1(%rip), %rsi      # 0x1074b
callq 0x21b0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x2330
movq %rax, %rdi
leaq 0x64a5(%rip), %rsi      # 0x1074d
callq 0x21b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zhjw1998[P]Merkle-Tree/src/merkle_tree.cpp
// Function: MerkleTree::CountWordsWithPrefix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int MerkleTree::CountWordsWithPrefix(const std::string& prefix){
    TrieTreeNode *p = this->trieroot;
    for (unsigned int i = 0; i < prefix.size(); i++){
        if(p->child[GETINDEX(prefix[i])] == nullptr)
            return 0;
        
        p = p->child[GETINDEX(prefix[i])];
    }
    return p->prefixCnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2130
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0xa3e7
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x2250
movsbl (%rax), %eax
cmpl $0x39, %eax
jle 0xa341
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x2250
movsbl (%rax), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0x3c(%rbp)
jmp 0xa358
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x2250
movsbl (%rax), %eax
subl $0x30, %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rax
movl -0x3c(%rbp), %ecx
movslq %ecx, %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0xa372
movl $0x0, -0x4(%rbp)
jmp 0xa3f1
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x2250
movsbl (%rax), %eax
cmpl $0x39, %eax
jle 0xa3b0
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x2250
movsbl (%rax), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0x4c(%rbp)
jmp 0xa3c7
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x2250
movsbl (%rax), %eax
subl $0x30, %eax
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rax
movl -0x4c(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xa2e3
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::rawMemoryToString(void const*, unsigned int)
String rawMemoryToString(const void* object, unsigned size) {
        // Reverse order for little endian architectures
        int i = 0, end = static_cast<int>(size), inc = 1;
        if(Endianness::which() == Endianness::Little) {
            i   = end - 1;
            end = inc = -1;
        }

        unsigned const char* bytes = static_cast<unsigned const char*>(object);
        std::ostream*        oss   = tlssPush();
        *oss << "0x" << std::setfill('0') << std::hex;
        for(; i != end; i += inc)
            *oss << std::setw(2) << static_cast<unsigned>(bytes[i]);
        return tlssPop();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
callq 0x7450
cmpl $0x1, %eax
jne 0x73a3
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x7490
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x30fa9(%rip), %rsi     # 0x38368
callq 0x6450
movq %rax, -0x50(%rbp)
movl $0x30, %edi
callq 0x20c30
movq -0x50(%rbp), %rdi
movb %al, -0x31(%rbp)
movzbl -0x31(%rbp), %esi
callq 0x6710
movq %rax, %rdi
leaq 0x19864(%rip), %rsi     # 0x20c50
callq 0x6140
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0x7439
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x2, %edi
callq 0x20c80
movq -0x58(%rbp), %rdi
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %esi
callq 0x6540
movq %rax, %rdi
movq -0x28(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %esi
callq 0x6630
movl -0x20(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x73f1
movq -0x48(%rbp), %rdi
callq 0x74b0
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::Endianness::which()
static Arch which() {
            int x = 1;
            // casting any data pointer to char* is allowed
            auto ptr = reinterpret_cast<char*>(&x);
            if(*ptr)
                return Little;
            return Big;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, -0x8(%rbp)
leaq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x7475
movl $0x1, -0x4(%rbp)
jmp 0x747c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::$_0::pop()
String pop() {
            if (stack.empty())
                DOCTEST_INTERNAL_ERROR("TLSS was empty when trying to pop!");

            std::streampos pos = stack.back();
            stack.pop_back();
            unsigned sz = static_cast<unsigned>(ss.tellp() - pos);
            ss.rdbuf()->pubseekpos(pos, std::ios::in | std::ios::out);
            return String(ss, sz);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x23620
testb $0x1, %al
jne 0x7637
jmp 0x7676
leaq 0x3167d(%rip), %rsi     # 0x38cbb
leaq -0x20(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x6690
movq -0x98(%rbp), %rdi
callq 0x113b0
jmp 0x765c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6918
jmp 0x7738
movq -0x80(%rbp), %rdi
callq 0x22f90
movq -0x80(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x23660
movq -0x80(%rbp), %rdi
addq $0x18, %rdi
addq $0x10, %rdi
callq 0x6390
movq %rax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x23690
movq -0x80(%rbp), %rdi
movl %eax, -0x44(%rbp)
addq $0x18, %rdi
callq 0x67f0
movq %rax, -0xa0(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x8, %edi
movl $0x10, %esi
callq 0x236b0
movq -0xa0(%rbp), %rdi
movl %eax, %ecx
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0x68a0
movq -0x80(%rbp), %rsi
movq -0x90(%rbp), %rdi
movq %rax, -0x78(%rbp)
movq %rdx, -0x70(%rbp)
addq $0x18, %rsi
movl -0x44(%rbp), %edx
callq 0x79e0
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x6800
nopw %cs:(%rax,%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::String::allocate(unsigned int)
char* String::allocate(unsigned sz) {
    if (sz <= last) {
        buf[sz] = '\0';
        setLast(last - sz);
        return buf;
    } else {
        setOnHeap();
        data.size = sz;
        data.capacity = data.size + 1;
        data.ptr = new char[data.capacity];
        data.ptr[sz] = '\0';
        return data.ptr;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x17, -0x14(%rbp)
ja 0x77bf
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movb $0x0, (%rdi,%rax)
movl $0x17, %esi
subl -0x14(%rbp), %esi
callq 0x7810
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7800
movq -0x20(%rbp), %rdi
callq 0x7830
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movl 0xc(%rax), %eax
movl %eax, %edi
callq 0x6030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rcx
movl -0x14(%rbp), %edx
movb $0x0, (%rcx,%rdx)
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::String::copy(doctest::String const&)
void String::copy(const String& other) {
    if(other.isOnStack()) {
        memcpy(buf, other.buf, len);
    } else {
        memcpy(allocate(other.data.size), other.data.ptr, other.data.size);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20ca0
testb $0x1, %al
jne 0x7877
jmp 0x7897
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
jmp 0x78bf
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x7780
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %edx
callq 0x6370
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::String::operator=(doctest::String const&)
String& String::operator=(const String& other) {
    if(this != &other) {
        if(!isOnStack())
            delete[] data.ptr;

        copy(other);
    }

    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0x7aa4
movq -0x18(%rbp), %rdi
callq 0x20ca0
testb $0x1, %al
jne 0x7a97
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x7a95
movq -0x20(%rbp), %rdi
callq 0x6600
jmp 0x7a97
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7850
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::String::operator=(doctest::String&&)
String& String::operator=(String&& other) {
    if(this != &other) {
        if(!isOnStack())
            delete[] data.ptr;
        memcpy(buf, other.buf, len);
        other.buf[0] = '\0';
        other.setLast();
    }
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0x7dca
movq -0x18(%rbp), %rdi
callq 0x20ca0
testb $0x1, %al
jne 0x7d97
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x7d95
movq -0x20(%rbp), %rdi
callq 0x6600
jmp 0x7d97
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
movl $0x17, %esi
callq 0x7810
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::stricmp(char const*, char const*)
int stricmp(const char* a, const char* b) {
        for(;; a++, b++) {
            const int d = tolower(*a) - tolower(*b);
            if(d != 0 || !*a)
                return d;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x66a0
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x66a0
movl %eax, %ecx
movl -0x18(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x7f44
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x7f4d
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
jmp 0x7f4f
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7f10
nopl (%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::failureString(doctest::assertType::Enum)
const char* failureString(assertType::Enum at) {
    if(at & assertType::is_warn) //!OCLINT bitwise operator in conditional
        return "WARNING";
    if(at & assertType::is_check) //!OCLINT bitwise operator in conditional
        return "ERROR";
    if(at & assertType::is_require) //!OCLINT bitwise operator in conditional
        return "FATAL ERROR";
    return "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x88ff
leaq 0x2fca9(%rip), %rax     # 0x385a2
movq %rax, -0x8(%rbp)
jmp 0x893a
movl -0xc(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x8917
leaq 0x2fc9f(%rip), %rax     # 0x385b0
movq %rax, -0x8(%rbp)
jmp 0x893a
movl -0xc(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x892f
leaq 0x2fc81(%rip), %rax     # 0x385aa
movq %rax, -0x8(%rbp)
jmp 0x893a
leaq 0x2fd63(%rip), %rax     # 0x38699
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::String doctest::(anonymous namespace)::fpToString<float>(float, int)
String fpToString(T value, int precision) {
        std::ostringstream oss;
        oss << std::setprecision(precision) << std::fixed << value;
        std::string d = oss.str();
        size_t      i = d.find_last_not_of('0');
        if(i != std::string::npos && i != d.size() - 1) {
            if(d[i] == '.')
                i++;
            d = d.substr(0, i + 1);
        }
        return d.c_str();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x200(%rbp)
movq %rdi, %rax
movq %rax, -0x1f8(%rbp)
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movl %esi, -0x10(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x6640
movl -0x10(%rbp), %edi
callq 0x28080
movl %eax, -0x1ec(%rbp)
jmp 0x8bf4
movl -0x1ec(%rbp), %eax
movl %eax, -0x18c(%rbp)
movl -0x18c(%rbp), %esi
leaq -0x188(%rbp), %rdi
callq 0x6730
movq %rax, -0x208(%rbp)
jmp 0x8c1b
movq -0x208(%rbp), %rdi
leaq 0x1f477(%rip), %rsi     # 0x280a0
callq 0x6140
movq %rax, -0x210(%rbp)
jmp 0x8c37
movq -0x210(%rbp), %rdi
movss -0xc(%rbp), %xmm0
callq 0x6310
jmp 0x8c4a
leaq -0x1c0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x6490
jmp 0x8c5f
leaq -0x1c0(%rbp), %rdi
movl $0x30, %esi
movq $-0x1, %rdx
callq 0x62a0
movq %rax, -0x1c8(%rbp)
cmpq $-0x1, -0x1c8(%rbp)
je 0x8d78
movq -0x1c8(%rbp), %rax
movq %rax, -0x218(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x62d0
movq %rax, %rcx
movq -0x218(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
je 0x8d78
movq -0x1c8(%rbp), %rsi
leaq -0x1c0(%rbp), %rdi
callq 0x68f0
movq %rax, -0x220(%rbp)
jmp 0x8cd9
movq -0x220(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x8d36
movq -0x1c8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x1c8(%rbp)
jmp 0x8d36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x8dbd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x6260
jmp 0x8dbd
movq -0x1c8(%rbp), %rcx
incq %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x1e8(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x64a0
jmp 0x8d59
leaq -0x1c0(%rbp), %rdi
leaq -0x1e8(%rbp), %rsi
callq 0x65a0
leaq -0x1e8(%rbp), %rdi
callq 0x6260
leaq -0x1c0(%rbp), %rdi
callq 0x6190
movq -0x200(%rbp), %rdi
movq %rax, %rsi
callq 0x7960
jmp 0x8d95
leaq -0x1c0(%rbp), %rdi
callq 0x6260
leaq -0x188(%rbp), %rdi
callq 0x60f0
movq -0x1f8(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
leaq -0x188(%rbp), %rdi
callq 0x60f0
movq -0x198(%rbp), %rdi
callq 0x6800
nopw %cs:(%rax,%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::checkIfShouldThrow(doctest::assertType::Enum)
bool checkIfShouldThrow(assertType::Enum at) {
        if(at & assertType::is_require) //!OCLINT bitwise operator in conditional
            return true;

        if((at & assertType::is_check) //!OCLINT bitwise operator in conditional
           && getContextOptions()->abort_after > 0 &&
           (g_cs->numAssertsFailed + g_cs->numAssertsFailedCurrentTest_atomic) >=
                   getContextOptions()->abort_after)
            return true;

        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x9c5c
movb $0x1, -0x1(%rbp)
jmp 0x9cb9
movl -0x8(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x9cb5
callq 0x89c0
cmpl $0x0, 0x64(%rax)
jle 0x9cb5
movq 0x478cf(%rip), %rax     # 0x51548
movl 0x9c(%rax), %eax
movl %eax, -0x10(%rbp)
movq 0x478bf(%rip), %rdi     # 0x51548
addq $0x8b8, %rdi            # imm = 0x8B8
callq 0x20d40
movl %eax, %ecx
movl -0x10(%rbp), %eax
addl %ecx, %eax
movl %eax, -0xc(%rbp)
callq 0x89c0
movq %rax, %rcx
movl -0xc(%rbp), %eax
cmpl 0x64(%rcx), %eax
jl 0x9cb5
movb $0x1, -0x1(%rbp)
jmp 0x9cb9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::matchesAny(char const*, std::vector<doctest::String, std::allocator<doctest::String>> const&, bool, bool)
bool matchesAny(const char* name, const std::vector<String>& filters, bool matchEmpty,
                    bool caseSensitive) {
        if(filters.empty() && matchEmpty)
            return true;
        for(auto& curr : filters)
            if(wildcmp(name, curr.c_str(), caseSensitive))
                return true;
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %cl
movb %cl, -0x19(%rbp)
andb $0x1, %al
movb %al, -0x1a(%rbp)
movq -0x18(%rbp), %rdi
callq 0x21a20
testb $0x1, %al
jne 0x9f9e
jmp 0x9fad
testb $0x1, -0x19(%rbp)
je 0x9fad
movb $0x1, -0x1(%rbp)
jmp 0xa030
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x23860
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x23890
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x238c0
testb $0x1, %al
jne 0x9fe2
jmp 0xa02c
leaq -0x30(%rbp), %rdi
callq 0x23900
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x20cd0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movb -0x1a(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x113f0
cmpl $0x0, %eax
je 0xa01f
movb $0x1, -0x1(%rbp)
jmp 0xa030
jmp 0xa021
leaq -0x30(%rbp), %rdi
callq 0x23920
jmp 0x9fcf
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::TestCase::TestCase(void (*)(), char const*, unsigned int, doctest::detail::TestSuite const&, char const*, int)
TestCase::TestCase(funcType test, const char* file, unsigned line, const TestSuite& test_suite,
                       const char* type, int template_id) {
        m_file              = file;
        m_line              = line;
        m_name              = nullptr; // will be later overridden in operator*
        m_test_suite        = test_suite.m_test_suite;
        m_description       = test_suite.m_description;
        m_skip              = test_suite.m_skip;
        m_no_breaks         = test_suite.m_no_breaks;
        m_no_output         = test_suite.m_no_output;
        m_may_fail          = test_suite.m_may_fail;
        m_should_fail       = test_suite.m_should_fail;
        m_expected_failures = test_suite.m_expected_failures;
        m_timeout           = test_suite.m_timeout;

        m_test        = test;
        m_type        = type;
        m_template_id = template_id;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x21110
movq -0x68(%rbp), %rdi
addq $0x68, %rdi
movq %rdi, -0x60(%rbp)
callq 0x78d0
jmp 0xa2f2
movq -0x18(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x7960
jmp 0xa301
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x7d50
jmp 0xa310
leaq -0x58(%rbp), %rdi
callq 0x7900
movq -0x68(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq -0x28(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rcx
movb 0x10(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x38(%rax)
movq -0x28(%rbp), %rcx
movb 0x11(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x39(%rax)
movq -0x28(%rbp), %rcx
movb 0x12(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x3a(%rax)
movq -0x28(%rbp), %rcx
movb 0x13(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x3b(%rax)
movq -0x28(%rbp), %rcx
movb 0x14(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x3c(%rax)
movq -0x28(%rbp), %rcx
movl 0x18(%rcx), %ecx
movl %ecx, 0x40(%rax)
movq -0x28(%rbp), %rcx
movsd 0x20(%rcx), %xmm0
movsd %xmm0, 0x48(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x50(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x58(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x60(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xa3f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xa3e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x7900
movq -0x60(%rbp), %rdi
callq 0x7900
movq -0x68(%rbp), %rdi
callq 0x21130
movq -0x38(%rbp), %rdi
callq 0x6800
nopw %cs:(%rax,%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::TestCase::operator=(doctest::detail::TestCase const&)
TestCase& TestCase::operator=(const TestCase& other) {
        static_cast<TestCaseData&>(*this) = static_cast<const TestCaseData&>(other);

        m_test        = other.m_test;
        m_type        = other.m_type;
        m_template_id = other.m_template_id;
        m_full_name   = other.m_full_name;

        if(m_template_id != -1)
            m_name = m_full_name.c_str();
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x21150
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, 0x50(%rdi)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, 0x58(%rdi)
movq -0x10(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, 0x60(%rdi)
movq -0x10(%rbp), %rsi
addq $0x68, %rsi
addq $0x68, %rdi
callq 0x7a50
movq -0x18(%rbp), %rax
cmpl $-0x1, 0x60(%rax)
je 0xa51a
movq -0x18(%rbp), %rdi
addq $0x68, %rdi
callq 0x20dc0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::TestCase::operator<(doctest::detail::TestCase const&) const
bool TestCase::operator<(const TestCase& other) const {
        // this will be used only to differentiate between test cases - not relevant for sorting
        if(m_line != other.m_line)
            return m_line < other.m_line;
        const int name_cmp = strcmp(m_name, other.m_name);
        if(name_cmp != 0)
            return name_cmp < 0;
        const int file_cmp = m_file.compare(other.m_file);
        if(file_cmp != 0)
            return file_cmp < 0;
        return m_template_id < other.m_template_id;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x18(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
je 0xa67c
movq -0x28(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
setb %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xa6e4
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x6670
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xa6a8
cmpl $0x0, -0x1c(%rbp)
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xa6e4
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x7f70
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0xa6ce
cmpl $0x0, -0x20(%rbp)
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xa6e4
movq -0x28(%rbp), %rax
movl 0x60(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x60(%rcx), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::isDebuggerActive()
bool isDebuggerActive() {
        ErrnoGuard guard;
        std::ifstream in("/proc/self/status");
        for(std::string line; std::getline(in, line);) {
            static const int PREFIX_LEN = 11;
            if(line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0) {
                return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
            }
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
leaq -0x8(%rbp), %rdi
callq 0x21230
leaq 0x2dee1(%rip), %rsi     # 0x3867c
leaq -0x210(%rbp), %rdi
movl $0x8, %edx
callq 0x6870
jmp 0xa7ae
leaq -0x240(%rbp), %rdi
callq 0x6660
leaq -0x210(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x60b0
movq %rax, -0x250(%rbp)
jmp 0xa7d6
movq -0x250(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x65d0
movb %al, -0x251(%rbp)
jmp 0xa7f4
movb -0x251(%rbp), %al
testb $0x1, %al
jne 0xa855
jmp 0xa800
movl $0x2, -0x244(%rbp)
jmp 0xa8ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
jmp 0xa937
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x6260
leaq -0x210(%rbp), %rdi
callq 0x6100
jmp 0xa937
leaq 0x2de32(%rip), %rcx     # 0x3868e
xorl %eax, %eax
movl %eax, %esi
leaq -0x240(%rbp), %rdi
movl $0xb, %edx
callq 0x6620
movl %eax, -0x258(%rbp)
jmp 0xa879
movl -0x258(%rbp), %eax
cmpl $0x0, %eax
jne 0xa8e8
leaq -0x240(%rbp), %rdi
callq 0x66d0
movq %rax, %rcx
xorl %eax, %eax
cmpq $0xb, %rcx
movb %al, -0x259(%rbp)
jbe 0xa8d1
leaq -0x240(%rbp), %rdi
movl $0xb, %esi
callq 0x68f0
movq %rax, -0x268(%rbp)
jmp 0xa8bb
movq -0x268(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
setne %al
movb %al, -0x259(%rbp)
movb -0x259(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl $0x1, -0x244(%rbp)
jmp 0xa8ed
jmp 0xa7ba
leaq -0x240(%rbp), %rdi
callq 0x6260
movl -0x244(%rbp), %eax
subl $0x2, %eax
jne 0xa914
jmp 0xa906
movb $0x0, -0x1(%rbp)
movl $0x1, -0x244(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x6100
leaq -0x8(%rbp), %rdi
callq 0x21260
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
leaq -0x8(%rbp), %rdi
callq 0x21260
movq -0x218(%rbp), %rdi
callq 0x6800
nopl (%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::ContextScopeBase::ContextScopeBase(doctest::detail::ContextScopeBase&&)
ContextScopeBase::ContextScopeBase(ContextScopeBase&& other) {
        if (other.need_to_destroy) {
            other.destroy();
        }
        other.need_to_destroy = false;
        g_infoContexts.push_back(this);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x8a70
movq -0x30(%rbp), %rax
leaq 0x45d50(%rip), %rcx     # 0x50b08
addq $0x10, %rcx
movq %rcx, (%rax)
movb $0x1, 0x8(%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0xadf1
movq -0x10(%rbp), %rdi
callq 0xae30
jmp 0xadd8
jmp 0xadf1
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8a90
jmp 0xae1a
movq -0x10(%rbp), %rax
movb $0x0, 0x8(%rax)
callq 0x214d0
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x214f0
jmp 0xae14
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x6800
nopw %cs:(%rax,%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::ResultBuilder::ResultBuilder(doctest::assertType::Enum, char const*, int, char const*, char const*, char const*)
ResultBuilder::ResultBuilder(assertType::Enum at, const char* file, int line, const char* expr,
                                 const char* exception_type, const char* exception_string) {
        m_test_case        = g_cs->currentTest;
        m_at               = at;
        m_file             = file;
        m_line             = line;
        m_expr             = expr;
        m_failed           = true;
        m_threw            = false;
        m_threw_as         = false;
        m_exception_type   = exception_type;
        m_exception_string = exception_string;
#if DOCTEST_MSVC
        if(m_expr[0] == ' ') // this happens when variadic macros are disabled under MSVC
            ++m_expr;
#endif // MSVC
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x21580
movq -0x38(%rbp), %rax
movq 0x4657e(%rip), %rcx     # 0x51548
movq 0x20(%rcx), %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x20(%rax)
movb $0x1, 0x28(%rax)
movb $0x0, 0x29(%rax)
movb $0x0, 0x60(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x68(%rax)
movq 0x10(%rbp), %rcx
movq %rcx, 0x70(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::failed_out_of_a_testing_context(doctest::AssertData const&)
void failed_out_of_a_testing_context(const AssertData& ad) {
        if(g_cs->ah)
            g_cs->ah(ad);
        else
            std::abort();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x45cd5(%rip), %rax     # 0x51548
cmpq $0x0, 0x10e8(%rax)
je 0xb893
movq 0x45cc4(%rip), %rax     # 0x51548
movq 0x10e8(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
jmp 0xb898
callq 0x6240
addq $0x10, %rsp
popq %rbp
retq
nop
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::MessageBuilder::MessageBuilder(char const*, int, doctest::assertType::Enum)
MessageBuilder::MessageBuilder(const char* file, int line, assertType::Enum severity) {
        m_stream   = tlssPush();
        m_file     = file;
        m_line     = line;
        m_severity = severity;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x21600
movq -0x38(%rbp), %rax
movb $0x0, 0x30(%rax)
callq 0x7490
movq %rax, -0x30(%rbp)
jmp 0xbb26
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x20(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x24(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21620
movq -0x20(%rbp), %rdi
callq 0x6800
nopw (%rax,%rax)