LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq (%rdi), %r12
movq %r14, %rbx
movq %r12, %r15
movq 0x8(%r12), %rdx
cmpq 0x8(%r14), %rdx
jne 0x551a
testq %rdx, %rdx
je 0x558e
movq (%rbx), %rsi
movq (%r15), %rdi
callq 0x2180
testl %eax, %eax
je 0x558e
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x5590
movq 0x28(%rbx), %r13
testq %r13, %r13
je 0x5590
movq 0x20(%r15), %r12
movq 0x8(%r12), %rdx
cmpq 0x8(%r14), %rdx
jne 0x54f1
testq %rdx, %rdx
je 0x5550
movq (%r14), %rsi
movq (%r12), %rdi
callq 0x2180
testl %eax, %eax
jne 0x54f1
movq 0x28(%r15), %r12
movq 0x8(%r12), %rdx
movb $0x1, %al
cmpq 0x8(%r13), %rdx
jne 0x557c
testq %rdx, %rdx
je 0x557a
movq (%r13), %rsi
movq (%r12), %rdi
callq 0x2180
testl %eax, %eax
setne %al
jmp 0x557c
xorl %eax, %eax
testb %al, %al
jne 0x5586
movq %r15, %r12
movq %rbx, %r13
movq %r13, %r14
jmp 0x54f1
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x5316
movl $0x30, %edi
callq 0x2160
movq %rax, %r15
leaq 0x48(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x38(%rsp), %rdi
callq 0x45d2
movb $0x1, %bpl
leaq 0x38(%rsp), %rsi
movq %r15, %rdi
callq 0x6bb4
leaq 0x58(%rsp), %rsi
movq %r15, (%rsi)
xorl %ebp, %ebp
leaq 0x8(%rsp), %rdi
callq 0x6314
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x5623
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x2170
movq (%r14), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x5116
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x5ef2
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x4d5a
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x5663
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq 0x596e(%rip), %r15      # 0xafd8
leaq 0x204a(%rip), %rsi      # 0x76bb
movl $0x10, %edx
movq %r15, %rdi
callq 0x2190
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq 0x593c(%rip), %rdi      # 0xafd8
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5790
movq 0x591d(%rip), %rbx      # 0xafd8
leaq 0x200a(%rip), %rsi      # 0x76cc
movl $0xe, %edx
movq %rbx, %rdi
callq 0x2190
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq 0x58eb(%rip), %rdi      # 0xafd8
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x5711
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x5770
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
jmp 0x5766
movq %rax, %rbx
movb $0x1, %bpl
jmp 0x5759
jmp 0x576d
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x5759
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x2170
testb %bpl, %bpl
je 0x5770
movl $0x30, %esi
movq %r15, %rdi
callq 0x2170
jmp 0x5770
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x5787
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/zhjw1998[P]Merkle-Tree/src/merkle_tree.cpp
// Function: MerkleTree::Insert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void MerkleTree::Insert(const std::string& word){
    TrieTreeNode *p = this->trieroot;
    for (unsigned int i = 0; i < word.size(); i++){
        // std::cout <<"i=" << i << " word[i]=" << word[i] <<" " << word << std::endl;
        if(p->child[GETINDEX(word[i])] == nullptr){
            p->child[GETINDEX(word[i])] = new TrieTreeNode(word[i]);
            p->childCnt++;
        }
        //notice!!this line need to be optimized to handle with duplicated insertion
        p->child[GETINDEX(word[i])]->prefixCnt++;
        p = p->child[GETINDEX(word[i])];
    }
    p->isEnd = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r15
cmpq $0x0, 0x8(%rsi)
je 0x585b
movq %rsi, %rbx
movl $0x1, %ebp
xorl %r12d, %r12d
movq (%rbx), %r13
movsbq (%r13,%r12), %rax
leaq -0x30(%rax), %rcx
leaq -0x57(%rax), %rdx
cmpq $0x3a, %rax
cmovgeq %rdx, %rcx
cmpq $0x0, 0x10(%r15,%rcx,8)
jne 0x5812
movl $0x90, %edi
callq 0x2160
movq %rax, %r14
movsbl (%r13,%r12), %esi
movq %rax, %rdi
callq 0x6c00
movq (%rbx), %rax
movsbq (%rax,%r12), %rax
leaq -0x30(%rax), %rcx
leaq -0x57(%rax), %rdx
cmpq $0x3a, %rax
cmovgeq %rdx, %rcx
movq %r14, 0x10(%r15,%rcx,8)
incl 0x4(%r15)
movq (%rbx), %rax
movsbq (%rax,%r12), %rcx
leaq -0x30(%rcx), %rdx
leaq -0x57(%rcx), %rsi
cmpq $0x3a, %rcx
cmovgeq %rsi, %rdx
movq 0x10(%r15,%rdx,8), %rcx
incl 0x8(%rcx)
movsbq (%rax,%r12), %rax
leaq -0x30(%rax), %rcx
leaq -0x57(%rax), %rdx
cmpq $0x3a, %rax
cmovgeq %rdx, %rcx
movq 0x10(%r15,%rcx,8), %r15
movl %ebp, %r12d
incl %ebp
cmpq %r12, 0x8(%rbx)
ja 0x57b5
movb $0x1, 0x1(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x90, %esi
movq %r14, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, (%rsp)
movq %rdi, %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rsi, 0x20(%rsp)
callq 0x5316
movq (%r15), %rbp
movq 0x8(%r15), %rbx
subq %rbp, %rbx
je 0x595f
sarq $0x3, %rbx
movq (%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x8(%rax), %r14
movl $0x1, %r12d
xorl %r13d, %r13d
movq (%rbp,%r13,8), %r15
movq 0x8(%r15), %rdx
cmpq %r14, %rdx
jne 0x5900
testq %rdx, %rdx
je 0x590d
movq (%r15), %rdi
movq 0x28(%rsp), %rsi
callq 0x2180
testl %eax, %eax
je 0x590d
movl %r12d, %r13d
incl %r12d
cmpq %r13, %rbx
ja 0x58dc
jmp 0x595f
testq %r15, %r15
je 0x5936
movq (%r15), %rdi
leaq 0x10(%r15), %rax
cmpq %rax, %rdi
je 0x5929
movq (%rax), %rsi
incq %rsi
callq 0x2170
movl $0x30, %esi
movq %r15, %rdi
callq 0x2170
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdx
leaq (%rax,%r13,8), %rsi
addq $0x8, %rsi
cmpq %rdx, %rsi
je 0x5959
leaq (%rax,%r13,8), %rdi
subq %rsi, %rdx
callq 0x2210
addq $-0x8, 0x10(%rsp)
movq 0x20(%rsp), %rbx
movq (%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5116
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x5ef2
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x4d5a
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x59a4
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq 0x8(%rbx), %rsi
movq (%rsp), %rdx
movl 0x8(%rdx), %r8d
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x5a1e
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x59d1
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x59ff
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
jmp 0x59ff
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x5a16
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/zhjw1998[P]Merkle-Tree/src/merkle_tree.cpp
// Function: MerkleTree::Remove(TrieTreeNode*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int)
bool MerkleTree::Remove(TrieTreeNode *treeNode, const std::string& word,int pos, int n) {
    if (pos == n){
        treeNode->isEnd = false;//set the node not to be an end
        //if the last node contains the last char is a leaf,return true to delete it
        return treeNode->childCnt == 0;
    }
    //not found, not delete this node
    if (treeNode->child[GETINDEX(word[pos])] == nullptr) 
        return false;
    //if true, the child is a leaf, delete the child
    if ( Remove( treeNode->child[GETINDEX(word[pos])], word, pos+1, n)){ 
        delete treeNode->child[GETINDEX(word[pos])];
        treeNode->child[GETINDEX(word[pos])] = nullptr;
 
        treeNode->prefixCnt--;
        //if the node becomes a leaf and is not an end,return true to delete it
        if (--treeNode->childCnt == 0 && treeNode->isEnd == false)
            return true;
    }
 
    //other not delete
    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpl %r8d, %ecx
jne 0x5a3b
movb $0x0, 0x1(%rbx)
cmpl $0x0, 0x4(%rbx)
sete %al
jmp 0x5adb
movq %rdx, %r14
movslq %ecx, %r15
movq (%rdx), %rax
movsbq (%rax,%r15), %rdx
leaq -0x30(%rdx), %rax
leaq -0x57(%rdx), %rsi
cmpq $0x3a, %rdx
movq %rax, %r9
cmovgeq %rsi, %r9
cmpq $0x0, 0x10(%rbx,%r9,8)
je 0x5ad9
cmpb $0x3a, %dl
cmovgeq %rsi, %rax
movq 0x10(%rbx,%rax,8), %rsi
incl %ecx
movq %r14, %rdx
callq 0x5a1e
testb %al, %al
je 0x5ad9
movq (%r14), %rax
movsbq (%rax,%r15), %rax
leaq -0x30(%rax), %rcx
leaq -0x57(%rax), %rdx
cmpq $0x3a, %rax
cmovgeq %rdx, %rcx
movq 0x10(%rbx,%rcx,8), %rdi
testq %rdi, %rdi
je 0x5aaa
movl $0x90, %esi
callq 0x2170
movq (%r14), %rax
movsbq (%rax,%r15), %rax
leaq -0x30(%rax), %rcx
leaq -0x57(%rax), %rdx
cmpq $0x3a, %rax
cmovgeq %rdx, %rcx
movq $0x0, 0x10(%rbx,%rcx,8)
decl 0x8(%rbx)
decl 0x4(%rbx)
jne 0x5ad9
cmpb $0x0, 0x1(%rbx)
je 0x5ae1
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movb $0x1, %al
jmp 0x5adb
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x8(%rsi), %rcx
movq 0x8(%rdi), %rax
testq %rcx, %rcx
je 0x5b33
movq (%rsi), %rdx
movl $0x1, %esi
xorl %edi, %edi
movsbq (%rdx,%rdi), %r8
leaq -0x30(%r8), %rdi
leaq -0x57(%r8), %r9
cmpq $0x3a, %r8
movq %rdi, %r10
cmovgeq %r9, %r10
cmpq $0x0, 0x10(%rax,%r10,8)
je 0x5b37
cmpb $0x3a, %r8b
cmovgeq %r9, %rdi
movq 0x10(%rax,%rdi,8), %rax
movl %esi, %edi
incl %esi
cmpq %rdi, %rcx
ja 0x5afd
movb 0x1(%rax), %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
cmpq $0x0, 0x8(%rdi)
je 0x5ce6
movq %rdi, %rbx
addq $0x8, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, 0x40(%r14)
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movq %r14, %rdi
xorl %esi, %esi
callq 0x6828
movq 0x30(%r14), %rax
movq 0x40(%r14), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x5ba3
movq (%rbx), %rcx
movq %rcx, (%rax)
addq $0x8, 0x40(%rsp)
jmp 0x5bb0
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x699e
movq 0x20(%rsp), %rax
cmpq %rax, 0x40(%rsp)
je 0x5cc4
leaq 0xf(%rsp), %r14
leaq 0x1b0f(%rip), %r15      # 0x76db
leaq 0x1b0a(%rip), %r12      # 0x76dd
leaq 0x10(%rsp), %r13
movq (%rax), %rbx
movb (%rbx), %al
movb %al, 0xf(%rsp)
movl $0x1, %edx
movq 0x53eb(%rip), %rdi      # 0xafd8
movq %r14, %rsi
callq 0x2190
movq %rax, %rbp
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2190
movl 0x4(%rbx), %esi
movq %rbp, %rdi
callq 0x2230
movl $0x2, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2190
addq $0x10, %rbx
xorl %ebp, %ebp
movq (%rbx,%rbp), %rax
testq %rax, %rax
je 0x5c5c
movq 0x40(%rsp), %rcx
movq 0x50(%rsp), %rdx
addq $-0x8, %rdx
cmpq %rdx, %rcx
je 0x5c50
movq %rax, (%rcx)
addq $0x8, 0x40(%rsp)
jmp 0x5c5c
leaq (%rbx,%rbp), %rsi
movq %r13, %rdi
callq 0x699e
addq $0x8, %rbp
cmpq $0x80, %rbp
jne 0x5c29
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x5c82
addq $0x8, %rax
jmp 0x5cb4
movq 0x28(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x2170
movq 0x38(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x38(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
leaq 0x200(%rax), %rcx
movq %rcx, 0x30(%rsp)
movq %rax, 0x20(%rsp)
cmpq %rax, 0x40(%rsp)
jne 0x5bd8
movq 0x530d(%rip), %rdi      # 0xafd8
leaq 0x19e7(%rip), %rsi      # 0x76b9
movl $0x1, %edx
callq 0x2190
leaq 0x10(%rsp), %rdi
callq 0x62c4
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5cf9
jmp 0x5cf9
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x62c4
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/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:
testq %rsi, %rsi
je 0x5dd2
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb (%rsi), %al
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
movq 0x5268(%rip), %rdi      # 0xafd8
movl $0x1, %edx
callq 0x2190
movq %rax, %r15
leaq 0x1957(%rip), %rsi      # 0x76db
movl $0x1, %edx
movq %rax, %rdi
callq 0x2190
movl 0x4(%rbx), %esi
movq %r15, %rdi
callq 0x2230
leaq 0x193a(%rip), %rsi      # 0x76dd
movl $0x2, %edx
movq %rax, %rdi
callq 0x2190
xorl %r15d, %r15d
movq 0x10(%rbx,%r15,8), %rsi
movq %r14, %rdi
callq 0x5d48
incq %r15
cmpq $0x10, %r15
jne 0x5db3
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
testq %rsi, %rsi
je 0x5e9a
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x2, %r15d
movq (%rbx,%r15,8), %rsi
movq %r14, %rdi
callq 0x5e0e
incq %r15
cmpq $0x12, %r15
jne 0x5e2c
movb (%rbx), %al
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
movq 0x5187(%rip), %rdi      # 0xafd8
movl $0x1, %edx
callq 0x2190
movq %rax, %r14
leaq 0x1876(%rip), %rsi      # 0x76db
movl $0x1, %edx
movq %rax, %rdi
callq 0x2190
movl 0x4(%rbx), %esi
movq %r14, %rdi
callq 0x2230
leaq 0x1859(%rip), %rsi      # 0x76dd
movl $0x2, %edx
movq %rax, %rdi
callq 0x2190
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x8(%rsi), %rdx
movq 0x8(%rdi), %rcx
testq %rdx, %rdx
je 0x5eed
movq (%rsi), %rsi
movl $0x1, %edi
xorl %eax, %eax
xorl %r8d, %r8d
movsbq (%rsi,%r8), %r9
leaq -0x30(%r9), %r8
leaq -0x57(%r9), %r10
cmpq $0x3a, %r9
movq %r8, %r11
cmovgeq %r10, %r11
cmpq $0x0, 0x10(%rcx,%r11,8)
je 0x5ef0
cmpb $0x3a, %r9b
cmovgeq %r10, %r8
movq 0x10(%rcx,%r8,8), %rcx
movl %edi, %r8d
incl %edi
cmpq %r8, %rdx
ja 0x5eb6
movl 0x8(%rcx), %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x6265
movq %rax, %r15
leaq 0x15122(%rip), %rsi     # 0x1b2e8
movl $0x2, %edx
movq %rax, %rdi
callq 0x5410
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %r12
cmpb $0x0, 0xe1(%r15,%rax)
jne 0x6207
movq %r12, %rdi
movl $0x20, %esi
callq 0x5390
movb %al, 0xe0(%r12)
movb $0x1, 0xe1(%r12)
movb $0x30, 0xe0(%r12)
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0x18(%r15,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r15,%rax)
testl %ebp, %ebp
je 0x6251
movslq %ebp, %r12
movq (%r15), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x10(%r15,%rax)
movzbl -0x1(%r14,%r12), %esi
movq %r15, %rdi
callq 0x5250
decq %r12
jne 0x622e
movq %rbx, %rdi
callq 0x62d7
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::$_0::~$_0()
DOCTEST_THREAD_LOCAL class
    {
        std::vector<std::streampos> stack;
        std::stringstream           ss;

    public:
        std::ostream* push() {
            stack.push_back(ss.tellp());
            return &ss;
        }

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x18, %rdi
movq 0x1fbcf(%rip), %rsi     # 0x25f90
callq 0x52c0
leaq 0x98(%rbx), %rdi
callq 0x5120
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x63e7
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0x53d0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
cmpl $0x17, %esi
ja 0x642c
movl %r14d, %eax
movb $0x0, (%rbx,%rax)
movb $0x17, %al
subb %r14b, %al
movb %al, 0x17(%rbx)
jmp 0x644d
movb $-0x80, 0x17(%rbx)
movl %r14d, 0x8(%rbx)
leal 0x1(%r14), %edi
movl %edi, 0xc(%rbx)
callq 0x5030
movq %rax, (%rbx)
movl %r14d, %ecx
movb $0x0, (%rax,%rcx)
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rsi, %rbx
cmpb $0x0, 0x17(%rsi)
js 0x647e
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rdi)
movups (%rbx), %xmm0
movups %xmm0, (%rdi)
popq %rbx
retq
movl 0x8(%rbx), %esi
callq 0x640c
movq (%rbx), %rsi
movl 0x8(%rbx), %edx
movq %rax, %rdi
popq %rbx
jmp 0x5300
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x65b5
movq %rsi, %r14
cmpb $0x0, 0x17(%rbx)
jns 0x6582
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6582
callq 0x5480
cmpb $0x0, 0x17(%r14)
js 0x659a
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
jmp 0x65b5
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x640c
movq (%r14), %rsi
movl 0x8(%r14), %edx
movq %rax, %rdi
callq 0x5300
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x676e
movq %rsi, %r14
cmpb $0x0, 0x17(%rbx)
jns 0x6756
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6756
callq 0x5480
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movb $0x0, (%r14)
movb $0x17, 0x17(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movb $0x1, %al
testb $0x4, %dil
jne 0x7da0
testb $0x2, %dil
je 0x7d9e
movq 0x1e650(%rip), %rcx     # 0x263b8
cmpl $0x0, 0x64(%rcx)
jle 0x7d9e
movl 0x9c(%rcx), %esi
xorl %edx, %edx
xorl %edi, %edi
movl 0x8b8(%rcx,%rdi), %r8d
addl %r8d, %edx
addq $0x40, %rdi
cmpq $0x800, %rdi            # imm = 0x800
jne 0x7d78
addl %esi, %edx
movq 0x1e61f(%rip), %rcx     # 0x263b8
cmpl 0x64(%rcx), %edx
jge 0x7da0
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::Subcase::~Subcase()
Subcase::~Subcase() {
        if(m_entered) {
            // only mark the subcase stack as passed if no subcases have been skipped
            if(g_cs->should_reenter == false)
                g_cs->subcasesPassed.insert(g_cs->subcasesStack);
            g_cs->subcasesStack.pop_back();

#if defined(__cpp_lib_uncaught_exceptions) && __cpp_lib_uncaught_exceptions >= 201411L && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101200)
            if(std::uncaught_exceptions() > 0
#else
            if(std::uncaught_exception()
#endif
            && g_cs->shouldLogCurrentException) {
                DOCTEST_ITERATE_THROUGH_REPORTERS(
                        test_case_exception, {"exception thrown in subcase - will translate later "
                                              "when the whole test case has been exited (cannot "
                                              "translate while there is an active exception)",
                                              false});
                g_cs->shouldLogCurrentException = false;
            }
            DOCTEST_ITERATE_THROUGH_REPORTERS(subcase_end, DOCTEST_EMPTY);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x28(%rdi)
jne 0x827a
movq 0x1e258(%rip), %rsi     # 0x263b8
cmpb $0x0, 0x115c(%rsi)
jne 0x817c
leaq 0x1128(%rsi), %rdi
addq $0x1110, %rsi           # imm = 0x1110
callq 0x1767e
movq 0x1e235(%rip), %rcx     # 0x263b8
movq 0x1118(%rcx), %rdx
leaq -0x28(%rdx), %rax
movq %rax, 0x1118(%rcx)
cmpb $0x0, -0x11(%rdx)
jns 0x81a8
movq (%rax), %rdi
testq %rdi, %rdi
je 0x81a8
callq 0x5480
callq 0x5440
testl %eax, %eax
jle 0x8251
movq 0x1e1fc(%rip), %rax     # 0x263b8
movb 0x115d(%rax), %al
testb $0x1, %al
je 0x8251
movq 0x1e1e7(%rip), %rax     # 0x263b8
movq 0x10d0(%rax), %r13
movq 0x10d8(%rax), %rbp
cmpq %rbp, %r13
je 0x8242
leaq 0x8(%rsp), %r14
leaq 0x13369(%rip), %r15     # 0x1b559
movq (%r13), %r12
movq %r14, %rdi
movl $0x91, %esi
callq 0x640c
movl $0x91, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x5300
movb $0x0, 0x20(%rsp)
movq (%r12), %rax
movq %r12, %rdi
movq %r14, %rsi
callq *0x30(%rax)
cmpb $0x0, 0x1f(%rsp)
jns 0x8239
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x8239
callq 0x5480
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x81f0
movq 0x1e16f(%rip), %rax     # 0x263b8
xorl %ecx, %ecx
xchgb %cl, 0x115d(%rax)
movq 0x1e160(%rip), %rax     # 0x263b8
movq 0x10d0(%rax), %r14
movq 0x10d8(%rax), %r15
cmpq %r15, %r14
je 0x827a
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
addq $0x8, %r14
jmp 0x8266
cmpb $0x0, 0x17(%rbx)
jns 0x828d
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x828d
callq 0x5480
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x82a0
jmp 0x82a0
movq %rax, %rdi
callq 0x161ef
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x20(%rsp)
movq %r8, %r15
movl %ecx, %ebp
movq %rdx, %r13
movq %rsi, 0x18(%rsp)
movq %rdi, %rbx
xorl %eax, %eax
movb %al, (%rdi)
movb $0x17, %cl
movb %cl, 0x17(%rdi)
movb %al, 0x68(%rdi)
movb %cl, 0x7f(%rdi)
movq %rdx, %rdi
callq 0x5170
movq %rax, %r12
movq %rsp, %r14
movq %r14, %rdi
movl %r12d, %esi
callq 0x640c
movl %r12d, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x5300
cmpq %rbx, %r14
je 0x8372
cmpb $0x0, 0x17(%rbx)
jns 0x8359
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8359
callq 0x5480
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movups (%rsp), %xmm0
movups %xmm0, (%rbx)
movb $0x0, (%rsp)
movb $0x17, 0x17(%rsp)
movl 0x60(%rsp), %r14d
cmpb $0x0, 0x17(%rsp)
jns 0x838c
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x838c
callq 0x5480
movl %ebp, 0x18(%rbx)
movq $0x0, 0x20(%rbx)
movq (%r15), %rax
movq %rax, 0x28(%rbx)
movq 0x8(%r15), %rax
movq %rax, 0x30(%rbx)
movb 0x10(%r15), %al
movb %al, 0x38(%rbx)
movb 0x11(%r15), %al
movb %al, 0x39(%rbx)
movb 0x12(%r15), %al
movb %al, 0x3a(%rbx)
movb 0x13(%r15), %al
movb %al, 0x3b(%rbx)
movb 0x14(%r15), %al
movb %al, 0x3c(%rbx)
movl 0x18(%r15), %eax
movl %eax, 0x40(%rbx)
movsd 0x20(%r15), %xmm0
movsd %xmm0, 0x48(%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x50(%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x58(%rbx)
movl %r14d, 0x60(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
cmpb $0x0, 0x7f(%rbx)
jns 0x8417
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x8417
callq 0x5480
cmpb $0x0, 0x17(%rbx)
jns 0x842a
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x842a
callq 0x5480
movq %r14, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq 0x6560
movups 0x18(%r15), %xmm0
movups 0x28(%r15), %xmm1
movups 0x38(%r15), %xmm2
movups %xmm0, 0x18(%rbx)
movups %xmm1, 0x28(%rbx)
movups %xmm2, 0x38(%rbx)
movq 0x48(%r15), %rax
movq %rax, 0x48(%rbx)
movq 0x50(%r15), %rax
movq %rax, 0x50(%rbx)
movq 0x58(%r15), %rax
movq %rax, 0x58(%rbx)
movl 0x60(%r15), %eax
movl %eax, 0x60(%rbx)
addq $0x68, %r15
leaq 0x68(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x6560
cmpl $-0x1, 0x60(%rbx)
je 0x850b
cmpb $0x0, 0x7f(%rbx)
jns 0x8507
movq 0x68(%rbx), %r14
movq %r14, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl 0x18(%rsi), %eax
cmpl %eax, 0x18(%rdi)
jne 0x8692
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
movq 0x20(%rsi), %rsi
callq 0x54d0
testl %eax, %eax
je 0x8696
shrl $0x1f, %eax
jmp 0x86cc
setb %al
retq
cmpb $0x0, 0x17(%rbx)
movq %rbx, %rsi
jns 0x86a2
movq (%rbx), %rsi
cmpb $0x0, 0x17(%r14)
movq %r14, %rdi
jns 0x86af
movq (%r14), %rdi
callq 0x54d0
movl %eax, %ecx
movl 0x60(%r14), %edx
xorl %eax, %eax
cmpl 0x60(%rbx), %edx
setl %al
xorl %edx, %edx
testl %ecx, %ecx
sets %dl
cmovnel %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1d177(%rip), %rax     # 0x25b30
movq %rax, (%rdi)
movb $0x1, 0x8(%rdi)
cmpb $0x1, 0x8(%rsi)
jne 0x89ce
movq %r14, %rdi
callq 0x89fc
movb $0x0, 0x8(%r14)
callq 0x161d8
movq %fs:0x0, %rax
leaq -0x30(%rax), %rdi
movq %rsp, %rsi
movq %rbx, (%rsi)
callq 0x17ccc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x8(%rsp), %rax
xorl %r10d, %r10d
movb %r10b, 0x30(%rdi)
movw $0x17, 0x47(%rdi)
movb $0x17, 0x5f(%rdi)
movq 0x1d84b(%rip), %r11     # 0x263b8
movq 0x20(%r11), %r11
movq %r11, (%rdi)
movl %esi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movl %ecx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movw $0x1, 0x28(%rdi)
movb %r10b, 0x60(%rdi)
movq %r9, 0x68(%rdi)
movq %rax, 0x70(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::translateActiveException()
String translateActiveException() {
#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
        String res;
        auto&  translators = getExceptionTranslators();
        for(auto& curr : translators)
            if(curr->translate(res))
                return res;
        // clang-format off
        DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wcatch-value")
        try {
            throw;
        } catch(std::exception& ex) {
            return ex.what();
        } catch(std::string& msg) {
            return msg.c_str();
        } catch(const char* msg) {
            return msg;
        } catch(...) {
            return "unknown exception";
        }
        DOCTEST_GCC_SUPPRESS_WARNING_POP
// clang-format on
#else  // DOCTEST_CONFIG_NO_EXCEPTIONS
        return "";
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movb $0x0, (%rsp)
movb $0x17, 0x17(%rsp)
callq 0x88ac
movq 0x1dd42(%rip), %r15     # 0x26998
movq 0x1dd43(%rip), %r12     # 0x269a0
cmpq %r12, %r15
je 0x8c7e
movq %rsp, %r14
movq (%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
testb %al, %al
jne 0x8c83
addq $0x8, %r15
cmpq %r12, %r15
jne 0x8c65
callq 0x5510
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movups (%rsp), %xmm0
movups %xmm0, (%rbx)
movb $0x0, (%rsp)
movb $0x17, 0x17(%rsp)
cmpb $0x0, 0x17(%rsp)
jns 0x8cb1
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8cb1
callq 0x5480
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
cmpb $0x0, 0x17(%rsp)
jns 0x8cd8
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8cd8
callq 0x5480
movq %rbx, %rdi
callq 0x5620
movq %rdx, %r14
movq %rax, %rdi
cmpl $0x4, %r14d
jne 0x8d0c
callq 0x5160
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x64b2
callq 0x55a0
jmp 0x8c9c
cmpl $0x3, %r14d
jne 0x8d2c
callq 0x5160
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x64b2
callq 0x55a0
jmp 0x8c9c
callq 0x5160
cmpl $0x2, %r14d
jne 0x8d4c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x64b2
callq 0x55a0
jmp 0x8c9c
leaq 0x12f6d(%rip), %rsi     # 0x1bcc0
movq %rbx, %rdi
callq 0x64b2
callq 0x55a0
jmp 0x8c9c
jmp 0x8cc0
movq %rax, %rbx
callq 0x55a0
jmp 0x8cc3
movq %rax, %rbx
callq 0x55a0
jmp 0x8cc3
jmp 0x8cc0
movq %rax, %rbx
callq 0x55a0
jmp 0x8cc3
jmp 0x8cc0
movq %rax, %rbx
callq 0x55a0
jmp 0x8cc3
movq %rax, %rdi
callq 0x161ef
// File: /workspace/github_cpp_makefile_star2_O1/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::decomp_assert(doctest::assertType::Enum, char const*, int, char const*, doctest::detail::Result)
bool decomp_assert(assertType::Enum at, const char* file, int line, const char* expr,
                       Result result) {
        bool failed = !result.m_passed;

        // ###################################################################################
        // IF THE DEBUGGER BREAKS HERE - GO 1 LEVEL UP IN THE CALLSTACK FOR THE FAILING ASSERT
        // THIS IS THE EFFECT OF HAVING 'DOCTEST_CONFIG_SUPER_FAST_ASSERTS' DEFINED
        // ###################################################################################
        DOCTEST_ASSERT_OUT_OF_TESTS(result.m_decomp);
        DOCTEST_ASSERT_IN_TESTS(result.m_decomp);
        // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
        return !failed;
    }

// Assembly:
pushq %rbp
pushq %rbx
subq $0x78, %rsp
movl %edi, %ebp
movb (%r8), %bl
movl %ebx, %eax
xorb $0x1, %al
cmpb $0x0, 0x1d205(%rip)     # 0x263b5
je 0x9251
xorl %r9d, %r9d
movb %r9b, 0x30(%rsp)
movw $0x17, 0x47(%rsp)
movb $0x17, 0x5f(%rsp)
movq 0x1d1e7(%rip), %rdi     # 0x263b8
movq 0x20(%rdi), %r10
movq %r10, (%rsp)
movl %ebp, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movb %r9b, 0x29(%rsp)
movb %r9b, 0x60(%rsp)
leaq 0x1240c(%rip), %rcx     # 0x1b608
movq %rcx, 0x68(%rsp)
movq %rcx, 0x70(%rsp)
movb %al, 0x28(%rsp)
testb %bl, %bl
je 0x9214
cmpb $0x1, 0x6c(%rdi)
jne 0x9225
leaq 0x48(%rsp), %rdi
addq $0x8, %r8
movq %r8, %rsi
callq 0x6560
movq %rsp, %rdi
callq 0x8db0
testb %al, %al
je 0x9232
int3
cmpb $0x1, 0x28(%rsp)
jne 0x92ec
movl %ebp, %edi
callq 0x7d53
testb %al, %al
je 0x92ec
callq 0x7da1
testb %bl, %bl
jne 0x9318
xorl %r9d, %r9d
leaq 0x48(%rsp), %rdi
movb %r9b, -0x18(%rdi)
movw $0x17, -0x1(%rdi)
movb $0x17, 0x17(%rdi)
movq 0x1d142(%rip), %r10     # 0x263b8
movq 0x20(%r10), %r10
movq %r10, -0x48(%rdi)
movl %ebp, -0x40(%rdi)
movq %rsi, -0x38(%rdi)
movl %edx, -0x30(%rdi)
movq %rcx, -0x28(%rdi)
movb %r9b, -0x1f(%rdi)
movb %r9b, 0x18(%rdi)
leaq 0x1236d(%rip), %rcx     # 0x1b608
movq %rcx, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movb %al, -0x20(%rdi)
addq $0x8, %r8
movq %r8, %rsi
callq 0x6560
movq 0x1d0ff(%rip), %rax     # 0x263b8
movq 0x10e8(%rax), %rax
testq %rax, %rax
je 0x9321
movq %rsp, %rdi
callq *%rax
callq 0x870e
testb %al, %al
je 0x92e1
movq 0x1d0de(%rip), %rax     # 0x263b8
cmpb $0x0, 0x79(%rax)
jne 0x92e1
int3
movl %ebp, %edi
callq 0x7d53
testb %al, %al
jne 0x9326
cmpb $0x0, 0x5f(%rsp)
jns 0x9302
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x9302
callq 0x5480
cmpb $0x0, 0x47(%rsp)
jns 0x9318
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x9318
callq 0x5480
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
callq 0x5200
callq 0x7da1
jmp 0x932d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x162a2
movq %rbx, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
xorl %eax, %eax
movb %al, (%rdi)
movb $0x17, 0x17(%rdi)
movb %al, 0x30(%rdi)
callq 0x6265
movq %rax, 0x28(%rbx)
movq %r15, 0x18(%rbx)
movl %r14d, 0x20(%rbx)
movl %ebp, 0x24(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
cmpb $0x0, 0x17(%rbx)
jns 0x9392
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x9392
callq 0x5480
movq %r14, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O1/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::MessageBuilder::log()
bool MessageBuilder::log() {
        if (!logged) {
            m_string = tlssPop();
            logged = true;
        }
        
        DOCTEST_ITERATE_THROUGH_REPORTERS(log_message, *this);

        const bool isWarn = m_severity & assertType::is_warn;

        // warn is just a message in this context so we don't treat it as an assert
        if(!isWarn) {
            addAssert(m_severity);
            addFailedAssert(m_severity);
        }

        return isDebuggerActive() && !getContextOptions()->no_breaks && !isWarn &&
            (g_cs->currentTest == nullptr || !g_cs->currentTest->m_no_breaks); // break into debugger
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x30(%rdi)
jne 0x9462
movq %rsp, %r14
movq %r14, %rdi
callq 0x62d7
cmpq %rbx, %r14
je 0x9449
cmpb $0x0, 0x17(%rbx)
jns 0x9430
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x9430
callq 0x5480
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movups (%rsp), %xmm0
movups %xmm0, (%rbx)
movb $0x0, (%rsp)
movb $0x17, 0x17(%rsp)
cmpb $0x0, 0x17(%rsp)
jns 0x945e
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x945e
callq 0x5480
movb $0x1, 0x30(%rbx)
movq 0x1cf4f(%rip), %rax     # 0x263b8
movq 0x10d0(%rax), %r14
movq 0x10d8(%rax), %r15
cmpq %r15, %r14
je 0x948e
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x50(%rax)
addq $0x8, %r14
jmp 0x9477
movl 0x24(%rbx), %ebp
testb $0x1, %bpl
jne 0x94ef
movl $0xb8, %r14d
addq 0x1cf14(%rip), %r14     # 0x263b8
cmpb $0x0, %fs:-0x8
je 0x952e
movq %fs:-0x10, %rax
shlq $0x6, %rax
lock
incl (%r14,%rax)
testb $0x1, 0x24(%rbx)
jne 0x94ef
movl $0x8b8, %ebx            # imm = 0x8B8
addq 0x1cee5(%rip), %rbx     # 0x263b8
cmpb $0x0, %fs:-0x8
je 0x9538
movq %fs:-0x10, %rax
shlq $0x6, %rax
lock
incl (%rbx,%rax)
callq 0x870e
testb %al, %al
je 0x951d
xorl %eax, %eax
testb $0x1, %bpl
jne 0x951f
movq 0x1ceb1(%rip), %rcx     # 0x263b8
cmpb $0x0, 0x79(%rcx)
jne 0x951f
movq 0x20(%rcx), %rax
testq %rax, %rax
je 0x952a
movb 0x39(%rax), %al
xorb $0x1, %al
jmp 0x951f
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
jmp 0x951f
callq 0x57c8
jmp 0x94af
callq 0x57ea
jmp 0x94de
nop
// File: /workspace/github_cpp_makefile_star2_O1/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::parseOption(int, char const* const*, char const*, doctest::String*, doctest::String const&)
bool parseOption(int argc, const char* const* argv, const char* pattern, String* value = nullptr,
                     const String& defaultVal = String()) {
        if(value)
            *value = defaultVal;
#ifndef DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS
        // offset (normally 3 for "dt-") to skip prefix
        if(parseOptionImpl(argc, argv, pattern + strlen(DOCTEST_CONFIG_OPTIONS_PREFIX), value))
            return true;
#endif // DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS
        return parseOptionImpl(argc, argv, pattern, value);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
testq %rcx, %rcx
je 0xadfa
movq %rbx, %rdi
movq %r8, %rsi
callq 0x6560
leaq 0x3(%r14), %rdx
movl %ebp, %edi
movq %r15, %rsi
movq %rbx, %rcx
callq 0xdcb7
testb %al, %al
je 0xae1c
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %edi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xdcb7
// File: /workspace/github_cpp_makefile_star2_O1/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::parseIntOption(int, char const* const*, char const*, doctest::(anonymous namespace)::optionType, int&)
bool parseIntOption(int argc, const char* const* argv, const char* pattern, optionType type,
                        int& res) {
        String parsedValue;
        if(!parseOption(argc, argv, pattern, &parsedValue))
            return false;

        if(type == 0) {
            // boolean
            const char positive[][5] = {"1", "true", "on", "yes"};  // 5 - strlen("true") + 1
            const char negative[][6] = {"0", "false", "off", "no"}; // 6 - strlen("false") + 1

            // if the value matches any of the positive/negative possibilities
            for(unsigned i = 0; i < 4; i++) {
                if(parsedValue.compare(positive[i], true) == 0) {
                    res = 1; //!OCLINT parameter reassignment
                    return true;
                }
                if(parsedValue.compare(negative[i], true) == 0) {
                    res = 0; //!OCLINT parameter reassignment
                    return true;
                }
            }
        } else {
            // integer
            // TODO: change this to use std::stoi or something else! currently it uses undefined behavior - assumes '0' on failed parse...
            int theInt = std::atoi(parsedValue.c_str()); // NOLINT
            if(theInt != 0) {
                res = theInt; //!OCLINT parameter reassignment
                return true;
            }
        }
        return false;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rbx
movl %ecx, %ebp
xorl %eax, %eax
leaq 0x8(%rsp), %r14
movb %al, (%r14)
movb $0x17, %cl
movb %cl, 0x17(%r14)
leaq 0x20(%rsp), %r8
movb %al, (%r8)
movb %cl, 0x17(%r8)
movq %r14, %rcx
callq 0xadd8
movl %eax, %r15d
cmpb $0x0, 0x37(%rsp)
jns 0xae86
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xae86
callq 0x5480
testb %r15b, %r15b
je 0xaefd
testl %ebp, %ebp
je 0xaeab
cmpb $0x0, 0x1f(%rsp)
jns 0xae9b
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5550
movl %eax, %ebp
testl %eax, %eax
jne 0xaf03
jmp 0xaefd
leaq 0x101ee(%rip), %r14     # 0x1b0a0
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
leaq 0x101ff(%rip), %r13     # 0x1b0c0
movl $0x1, %ebp
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x67ac
testl %eax, %eax
je 0xaf03
leaq (%r12,%r13), %rsi
movq %r15, %rdi
movl $0x1, %edx
callq 0x67ac
testl %eax, %eax
je 0xaf01
addq $0x5, %r14
addq $0x6, %r12
cmpq $0x18, %r12
jne 0xaec6
xorl %ebx, %ebx
jmp 0xaf07
xorl %ebp, %ebp
movl %ebp, (%rbx)
movb $0x1, %bl
cmpb $0x0, 0x1f(%rsp)
jns 0xaf1d
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xaf1d
callq 0x5480
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
cmpb $0x0, 0x37(%rsp)
jns 0xaf47
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xaf47
callq 0x5480
cmpb $0x0, 0x1f(%rsp)
jns 0xaf5d
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xaf5d
callq 0x5480
movq %rbx, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O1/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::fileOrderComparator(doctest::detail::TestCase const*, doctest::detail::TestCase const*)
bool fileOrderComparator(const TestCase* lhs, const TestCase* rhs) {
        // this is needed because MSVC gives different case for drive letters
        // for __FILE__ when evaluated in a header and a source file
        const int res = lhs->m_file.compare(rhs->m_file, bool(DOCTEST_MSVC));
        if(res != 0)
            return res < 0;
        if(lhs->m_line != rhs->m_line)
            return lhs->m_line < rhs->m_line;
        return lhs->m_template_id < rhs->m_template_id;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x17(%rsi)
jns 0xc18a
movq (%rbx), %rsi
cmpb $0x0, 0x17(%r14)
movq %r14, %rdi
jns 0xc197
movq (%r14), %rdi
callq 0x54d0
testl %eax, %eax
je 0xc1a5
shrl $0x1f, %eax
jmp 0xc1bd
movl 0x18(%rbx), %eax
cmpl %eax, 0x18(%r14)
jne 0xc1ba
movl 0x60(%r14), %eax
cmpl 0x60(%rbx), %eax
setl %al
jmp 0xc1bd
setb %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq