LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::private_delete(double, int)
bool private_delete(double score, KeyType key) 
    {
        SkipListNode *update[SKIPLIST_MAXLEVEL], *x;
        int i;
        x = mHeader;
        for (i = mLevel-1; i >= 0; i--) {
            while (x->mLevel[i].mForward && x->mLevel[i].mForward->mScore < score)
                x = x->mLevel[i].mForward;
            update[i] = x;
        }
        /* We may have multiple elements with the same score, what we need
         * is to find the element with both the right score and key. */
        x = x->mLevel[0].mForward;
        if (x && score == x->mScore && x->mKey == key) {
            private_delete_node(x, update);
            delete x;
            return true;
        } 
        else {
            return false; /* not found */
        }
        return false; /* not found */
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq (%rdi), %rax
movslq 0x18(%rdi), %rcx
testq %rcx, %rcx
jle 0x1f66
movq %rcx, %rdx
decq %rcx
movq %rcx, %r8
shlq $0x4, %r8
movq %rax, %r9
movq %r9, %rax
movq 0x20(%r9), %r9
movq (%r9,%r8), %r9
testq %r9, %r9
je 0x1f58
ucomisd 0x8(%r9), %xmm0
ja 0x1f40
movq %rax, -0x110(%rbp,%rcx,8)
cmpq $0x1, %rdx
jg 0x1f30
movq 0x20(%rax), %rax
movq (%rax), %rbx
testq %rbx, %rbx
je 0x1fad
movsd 0x8(%rbx), %xmm1
ucomisd %xmm0, %xmm1
jne 0x1fad
jp 0x1fad
cmpl %esi, 0x10(%rbx)
jne 0x1fad
leaq -0x110(%rbp), %rdx
movq %rbx, %rsi
callq 0x2234
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1fa1
callq 0x1150
movq %rbx, %rdi
callq 0x1110
movb $0x1, %al
jmp 0x1faf
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::private_delete_node(SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::SkipListNode*, SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::SkipListNode**)
void private_delete_node(SkipListNode *x, SkipListNode **update) 
    {
        int i;
        for (i = 0; i < mLevel; i++) {
            if (update[i]->mLevel[i].mForward == x) {
                update[i]->mLevel[i].mSpan += x->mLevel[i].mSpan - 1;
                update[i]->mLevel[i].mForward = x->mLevel[i].mForward;
            } else {
                update[i]->mLevel[i].mSpan -= 1;
            }
        }
        if (x->mLevel[0].mForward) {
            x->mLevel[0].mForward->mBackward = x->mBackward;
        } else {
            mTail = x->mBackward;
        }
        while(mLevel > 1 && mHeader->mLevel[mLevel-1].mForward == NULL)
            mLevel--;
        mLength--;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movslq 0x18(%rdi), %rax
testq %rax, %rax
jle 0x228b
movq %rax, %rcx
shlq $0x3, %rcx
xorl %r8d, %r8d
movq (%rdx,%r8), %r9
movq 0x20(%r9), %r9
cmpq %rsi, (%r9,%r8,2)
je 0x2261
decl 0x8(%r9,%r8,2)
jmp 0x2282
movq 0x20(%rsi), %r10
movl 0x8(%r10,%r8,2), %r11d
movl 0x8(%r9,%r8,2), %ebx
addl %ebx, %r11d
decl %r11d
movl %r11d, 0x8(%r9,%r8,2)
movq (%r10,%r8,2), %r10
movq %r10, (%r9,%r8,2)
addq $0x8, %r8
cmpq %r8, %rcx
jne 0x224c
movq 0x18(%rsi), %rcx
movq 0x20(%rsi), %rdx
movq (%rdx), %rdx
leaq 0x8(%rdi), %rsi
leaq 0x18(%rdx), %r8
testq %rdx, %rdx
cmoveq %rsi, %r8
movq %rcx, (%r8)
cmpl $0x2, %eax
jl 0x22d2
movq (%rdi), %rcx
movq 0x20(%rcx), %rcx
addq $-0x10, %rcx
movl %eax, %edx
shlq $0x4, %rdx
cmpq $0x0, (%rcx,%rdx)
jne 0x22d2
leal -0x1(%rax), %edx
movl %edx, 0x18(%rdi)
cmpl $0x2, %eax
movl %edx, %eax
jg 0x22b8
decq 0x10(%rdi)
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::first_in_range(SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::RangeSpec const&)
SkipListNode* first_in_range(const RangeSpec &range) {
        SkipListNode *x;
        int i;
    
        /* If everything is out of range, return early. */
        if (!is_in_range(range)) return NULL;
    
        x = mHeader;
        for (i = mLevel-1; i >= 0; i--) {
            /* Go forward while *OUT* of range. */
            while (x->mLevel[i].mForward && !score_gte_min(x->mLevel[i].mForward->mScore, range))
                x = x->mLevel[i].mForward;
        }
    
        /* This is an inner range, so the next node cannot be NULL. */
        x = x->mLevel[0].mForward;
        assert(x != NULL);

        /* Check if score <= max. */
        if (!score_lte_max(x->mScore, range)) return NULL;
        return x;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2aee
testb %al, %al
je 0x2974
movq (%r14), %rax
movslq 0x18(%r14), %rcx
testq %rcx, %rcx
jle 0x2978
movb 0x10(%rbx), %dl
movsd (%rbx), %xmm0
movq %rcx, %rdi
decq %rcx
movq %rcx, %r8
shlq $0x4, %r8
movq %rax, %r9
movq %r9, %rax
movq 0x20(%r9), %rsi
movq (%rsi,%r8), %r9
testq %r9, %r9
je 0x296c
movsd 0x8(%r9), %xmm1
xorl %r10d, %r10d
xorl %r11d, %r11d
ucomisd %xmm0, %xmm1
seta %r10b
setae %r11b
testb $0x1, %dl
cmovnel %r10d, %r11d
cmpb $0x1, %r11b
jne 0x2937
cmpq $0x1, %rdi
jg 0x2927
jmp 0x297c
xorl %eax, %eax
jmp 0x29a7
movq 0x20(%rax), %rsi
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x29ac
movsd 0x8(%rbx), %xmm0
xorl %eax, %eax
xorl %edx, %edx
ucomisd 0x8(%rcx), %xmm0
seta %al
setae %dl
cmpb $0x0, 0x11(%rbx)
cmovnel %eax, %edx
xorl %eax, %eax
testb %dl, %dl
cmovneq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x775(%rip), %rdi       # 0x3128
leaq 0x6a3(%rip), %rsi       # 0x305d
leaq 0x771(%rip), %rcx       # 0x3132
movl $0xd8, %edx
callq 0x10c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::get_rank(double, int)
unsigned long get_rank(double score, KeyType key) {
        SkipListNode *x;
        unsigned long rank = 0;
        int i;

        x = mHeader;
        for (i = mLevel-1; i >= 0; i--) {
            while (x->mLevel[i].mForward && x->mLevel[i].mForward->mScore <= score) {
                rank += x->mLevel[i].mSpan;
                x = x->mLevel[i].mForward;
            }

            /* x might be equal to mHeader, so test if is header */
            if (not x->mIsHeader && x->mKey == key) {
                return rank;
            }
        }
        return 0;
    }

// Assembly:
movslq 0x18(%rdi), %rcx
testq %rcx, %rcx
jle 0x2a29
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdx
xorl %eax, %eax
leaq -0x1(%rcx), %rdi
movq 0x20(%rdx), %r9
movq %rdi, %r8
shlq $0x4, %r8
movq (%r9,%r8), %r10
testq %r10, %r10
je 0x2a12
ucomisd 0x8(%r10), %xmm0
jb 0x2a12
movq %r10, %rdx
movq %rax, %r10
movl 0x8(%r9,%r8), %eax
addq %r10, %rax
movq 0x20(%rdx), %r9
jmp 0x29ed
cmpb $0x0, (%rdx)
jne 0x2a1c
cmpl %esi, 0x10(%rdx)
je 0x2a27
cmpq $0x1, %rcx
movq %rdi, %rcx
jg 0x29de
xorl %eax, %eax
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::last_in_range(SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::RangeSpec const&)
SkipListNode* last_in_range(const RangeSpec &range) {
        SkipListNode *x;
        int i;
    
        /* If everything is out of range, return early. */
        if (!is_in_range(range)) return NULL;
    
        x = mHeader;
        for (i = mLevel-1; i >= 0; i--) {
            /* Go forward while *IN* range. */
            while (x->mLevel[i].mForward && score_lte_max(x->mLevel[i].mForward->mScore, range))
                x = x->mLevel[i].mForward;
        }
    
        /* This is an inner range, so this node cannot be NULL. */
        assert(x != NULL);
    
        /* Check if score >= min. */
        if (!score_gte_min(x->mScore, range)) return NULL;
        return x;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2aee
testb %al, %al
je 0x2a9e
movq (%r14), %rcx
movslq 0x18(%r14), %rax
testq %rax, %rax
jle 0x2aa2
movb 0x11(%rbx), %dl
movsd 0x8(%rbx), %xmm0
movq %rax, %rsi
decq %rax
movq %rax, %rdi
shlq $0x4, %rdi
movq %rcx, %r8
movq %r8, %rcx
movq 0x20(%r8), %r8
movq (%r8,%rdi), %r8
testq %r8, %r8
je 0x2a96
xorl %r9d, %r9d
xorl %r10d, %r10d
ucomisd 0x8(%r8), %xmm0
seta %r9b
setae %r10b
testb $0x1, %dl
cmovnel %r9d, %r10d
testb %r10b, %r10b
jne 0x2a66
cmpq $0x1, %rsi
jg 0x2a56
jmp 0x2aa7
xorl %eax, %eax
jmp 0x2ac9
testq %rcx, %rcx
je 0x2ace
movsd 0x8(%rcx), %xmm0
xorl %eax, %eax
xorl %edx, %edx
ucomisd (%rbx), %xmm0
seta %al
setae %dl
cmpb $0x0, 0x10(%rbx)
cmovnel %eax, %edx
xorl %eax, %eax
testb %dl, %dl
cmovneq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x653(%rip), %rdi       # 0x3128
leaq 0x581(%rip), %rsi       # 0x305d
leaq 0x6dc(%rip), %rcx       # 0x31bf
movl $0xf0, %edx
callq 0x10c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::is_in_range(SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::RangeSpec const&)
bool is_in_range(const RangeSpec &range) {
        SkipListNode *x;
        /* Test for ranges that will always be empty. */
        if (range.mMin > range.mMax || (range.mMin == range.mMax && (range.mMinex || range.mMaxex)))
            return false;
        x = mTail;
        if (x == NULL || !score_gte_min(x->mScore, range))
            return false;
        x = mHeader->mLevel[0].mForward;
        if (x == NULL || !score_lte_max(x->mScore, range))
            return false;
        return true;
    }

// Assembly:
movsd (%rsi), %xmm1
movsd 0x8(%rsi), %xmm0
ucomisd %xmm0, %xmm1
ja 0x2b60
jne 0x2b0d
jp 0x2b0d
cmpb $0x0, 0x10(%rsi)
jne 0x2b60
cmpb $0x0, 0x11(%rsi)
jne 0x2b60
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x2b60
pushq %rbp
movq %rsp, %rbp
movsd 0x8(%rax), %xmm2
xorl %eax, %eax
xorl %ecx, %ecx
ucomisd %xmm1, %xmm2
seta %al
setae %cl
cmpb $0x0, 0x10(%rsi)
cmovnel %eax, %ecx
cmpb $0x1, %cl
jne 0x2b63
movq (%rdi), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0x2b63
xorl %edx, %edx
xorl %eax, %eax
ucomisd 0x8(%rcx), %xmm0
seta %dl
setae %al
cmpb $0x0, 0x11(%rsi)
cmovnel %edx, %eax
jmp 0x2b65
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::zrank_generic(int, bool, unsigned long&)
bool zrank_generic(KeyType key, bool reverse, unsigned long &rank) {
        unsigned long llen = length();
        DictTypeIterator it = mDict.find(key);
        if (it != mDict.end()) {
            double score = it->second;
            rank = get_rank(score, key);
            if (reverse) {
                rank = llen - rank;
            }
            else {
                rank -= 1;
            }
            return true;
        }
        else {
            return false;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r14d
movq 0x28(%rdi), %r8
movslq %esi, %rax
movq 0x30(%rdi), %r9
xorl %ecx, %ecx
xorl %edx, %edx
divq %r9
movq (%r8,%rdx,8), %rax
testq %rax, %rax
je 0x2c32
movq 0x10(%rdi), %r15
cmpl %esi, (%rax)
je 0x2c0c
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x2bfd
jmp 0x2c30
cmpq (%r8,%r9,8), %rax
je 0x2c30
movsd 0x8(%rax), %xmm0
callq 0x29cc
subq %rax, %r15
decq %rax
testb %r14b, %r14b
cmovneq %r15, %rax
movq %rax, (%rbx)
movb $0x1, %cl
jmp 0x2c32
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::zrangebyscore_withscores_generic(double, double, bool, std::vector<std::pair<int, double>, std::allocator<std::pair<int, double>>>&, bool, bool)
void zrangebyscore_withscores_generic(double min, double max, bool reverse, KeyScoreVecType &result, 
                                          bool minex = false, bool maxex = false) {
        result.clear();
        RangeSpec range((reverse?max:min), (reverse?min:max), (reverse?maxex:minex), (reverse?minex:maxex));
        SkipListNode *ln;

        /* If reversed, get the last node in range as starting point. */
        if (reverse) {
            ln = last_in_range(range);
        } else {
            ln = first_in_range(range);
        }

        /* No "first" element in the specified interval. */
        if (ln == NULL) {
            return;
        }
        while (ln) {
            /* Abort when the node is no longer in range. */
            if (reverse) {
                if (!score_gte_min(ln->mScore,range)) break;
            } else {
                if (!score_lte_max(ln->mScore,range)) break;
            }

            result.push_back(std::make_pair(ln->mKey, ln->mScore));

            /* Move to next node */
            if (reverse) {
                ln = ln->mBackward;
            } else {
                ln = ln->mLevel[0].mForward;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movl %esi, %r14d
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x2c62
movq %rax, 0x8(%rbx)
testb %r14b, %r14b
jne 0x2c6d
movapd %xmm0, %xmm2
jmp 0x2c75
movapd %xmm1, %xmm2
movapd %xmm0, %xmm1
movzbl %r8b, %eax
movzbl %cl, %ecx
movl %ecx, %edx
cmovnel %eax, %edx
cmovnel %ecx, %eax
movsd %xmm2, -0x38(%rbp)
movsd %xmm1, -0x30(%rbp)
movb %dl, -0x28(%rbp)
movb %al, -0x27(%rbp)
leaq -0x38(%rbp), %rsi
je 0x2ca1
callq 0x2a2c
jmp 0x2ca6
callq 0x28fe
movq %rax, %r15
testq %rax, %rax
je 0x2d48
leaq -0x48(%rbp), %r12
movsd 0x8(%r15), %xmm0
testb %r14b, %r14b
je 0x2cdd
xorl %eax, %eax
xorl %ecx, %ecx
ucomisd -0x38(%rbp), %xmm0
seta %al
setae %cl
cmpb $0x0, -0x28(%rbp)
cmovnel %eax, %ecx
testb %cl, %cl
jne 0x2cfc
jmp 0x2d48
movsd -0x30(%rbp), %xmm1
xorl %eax, %eax
xorl %ecx, %ecx
ucomisd %xmm0, %xmm1
seta %al
setae %cl
cmpb $0x0, -0x27(%rbp)
cmovnel %eax, %ecx
cmpb $0x1, %cl
jne 0x2d48
movl 0x10(%r15), %eax
movl %eax, -0x48(%rbp)
movsd %xmm0, -0x40(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2d22
movupd -0x48(%rbp), %xmm0
movupd %xmm0, (%rsi)
addq $0x10, 0x8(%rbx)
jmp 0x2d2d
movq %rbx, %rdi
movq %r12, %rdx
callq 0x27b8
testb %r14b, %r14b
je 0x2d38
addq $0x18, %r15
jmp 0x2d3c
movq 0x20(%r15), %r15
movq (%r15), %r15
testq %r15, %r15
jne 0x2cb6
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::private_delete_range_by_rank(unsigned int, unsigned int)
unsigned long private_delete_range_by_rank(unsigned int start, unsigned int end) {
        SkipListNode *update[SKIPLIST_MAXLEVEL], *x;
        unsigned long traversed = 0, removed = 0;
        int i;

        x = mHeader;
        for (i = mLevel-1; i >= 0; i--) {
            while (x->mLevel[i].mForward && (traversed + x->mLevel[i].mSpan) < start) {
                traversed += x->mLevel[i].mSpan;
                x = x->mLevel[i].mForward;
            }
            update[i] = x;
        }

        traversed++;
        x = x->mLevel[0].mForward;
        while (x && traversed <= end) {
            SkipListNode *next = x->mLevel[0].mForward;
            private_delete_node(x, update);
            mDict.erase(x->mKey);
            delete x;
            removed++;
            traversed++;
            x = next;
        }
        return removed;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq (%rdi), %rax
movq %rdi, -0x30(%rbp)
movslq 0x18(%rdi), %rcx
testq %rcx, %rcx
jle 0x2dc4
movl %esi, %esi
xorl %r13d, %r13d
movq %rcx, %rdi
decq %rcx
movq %rcx, %r8
shlq $0x4, %r8
movq %r13, %r10
movq %rax, %r9
movq %r9, %rax
movq %r10, %r13
movq 0x20(%r9), %r10
movq (%r10,%r8), %r9
testq %r9, %r9
je 0x2db4
addq %r8, %r10
movl 0x8(%r10), %r10d
addq %r13, %r10
cmpq %rsi, %r10
jb 0x2d92
movq %rax, -0x140(%rbp,%rcx,8)
cmpq $0x1, %rdi
jg 0x2d7f
jmp 0x2dc7
xorl %r13d, %r13d
movq 0x20(%rax), %rax
movq (%rax), %r14
xorl %eax, %eax
testq %r14, %r14
je 0x2e41
movl %edx, %ecx
movq %rcx, -0x38(%rbp)
cmpq %rcx, %r13
jae 0x2e41
movq -0x30(%rbp), %rax
leaq 0x20(%rax), %r15
incq %r13
xorl %ebx, %ebx
movq 0x20(%r14), %rax
movq (%rax), %r12
movq -0x30(%rbp), %rdi
movq %r14, %rsi
leaq -0x140(%rbp), %rdx
callq 0x2234
leaq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x2e54
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x2e21
callq 0x1150
movq %r14, %rdi
callq 0x1110
leaq 0x1(%rbx), %rax
testq %r12, %r12
je 0x2e41
addq %r13, %rbx
movq %r12, %r14
cmpq -0x38(%rbp), %rbx
movq %rax, %rbx
jb 0x2ded
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/devernay[P]vlpovutils/./vlpov.hpp
// Function: VLPovImage<double>::save(char const*)
int save(const char *filename) { // should be const, but no because of endianness stuff
        if (_width <= 0 || _height <= 0) {
            return -1;
        }
        unsigned int siz = _width*_height;
        std::FILE *const nfile = std::fopen(filename,"wb");
        if (!nfile) {
            return -1;
        }
        if (!endianness()) {
            invert_endianness();
        }
        size_t nw = std::fwrite(_data,sizeof(T),siz,nfile);
        std::fclose(nfile);
        if (nw != siz) {
            return -1;
        }
        if (!endianness()) {
            invert_endianness();
        }
        return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %r12d
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %r12d, %r12d
jle 0x36d0
movq %rdi, %r14
movl 0x4(%rdi), %ebp
testl %ebp, %ebp
jle 0x36d0
leaq 0x5e22(%rip), %rax      # 0x940d
movq %rsi, %rdi
movq %rax, %rsi
callq 0x21d0
testq %rax, %rax
je 0x36d0
movq %rax, %r15
imull %r12d, %ebp
movl 0x4(%r14), %eax
imull (%r14), %eax
movq 0x8(%r14), %rdi
testl %eax, %eax
je 0x365a
movl %eax, %eax
leaq (%rdi,%rax,8), %rcx
leaq (%rdi,%rax,8), %rax
decq %rax
movq %rcx, %rdx
addq $-0x8, %rcx
movq $-0x8, %rsi
movq %rax, %rdi
movb (%rdx,%rsi), %r8b
movb (%rdi), %r9b
movb %r9b, (%rdx,%rsi)
movb %r8b, (%rdi)
incq %rsi
decq %rdi
cmpl $-0x4, %esi
jne 0x3634
movq 0x8(%r14), %rdi
addq $-0x8, %rax
cmpq %rdi, %rcx
ja 0x3623
movl %ebp, %r12d
movl $0x8, %esi
movq %r12, %rdx
movq %r15, %rcx
callq 0x2320
movq %rax, %r13
movq %r15, %rdi
callq 0x2160
cmpq %r12, %r13
jne 0x36d0
movl 0x4(%r14), %eax
imull (%r14), %eax
xorl %ebx, %ebx
testl %eax, %eax
je 0x36d0
movq 0x8(%r14), %rdx
movl %eax, %eax
leaq (%rdx,%rax,8), %rcx
leaq (%rdx,%rax,8), %rax
decq %rax
movq %rcx, %rdx
addq $-0x8, %rcx
movq $-0x8, %rsi
movq %rax, %rdi
movb (%rdx,%rsi), %r8b
movb (%rdi), %r9b
movb %r9b, (%rdx,%rsi)
movb %r8b, (%rdi)
incq %rsi
decq %rdi
cmpl $-0x4, %esi
jne 0x36ad
addq $-0x8, %rax
cmpq 0x8(%r14), %rcx
ja 0x369c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jamesgrimmett[P]orbital_determination/ex10-2_linear_least_squares.cc
// Function: inverse(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>)
std::vector<std::vector<double> > inverse(std::vector<std::vector<double> > arr) {
  // Calculate the inverse of a 2x2 matrix

  std::vector<std::vector<double> > inv(arr[0].size(), std::vector<double>(arr[1].size()));
  
  double det = determinant(arr);

  inv[0][0] = arr[1][1]  / det;
  inv[1][1] = arr[0][0]  / det;
  inv[0][1] = -arr[1][0] / det;
  inv[1][0] = -arr[0][1] / det;

  return inv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rax), %r12
movq 0x8(%rax), %r15
movq 0x20(%rax), %rsi
subq 0x18(%rax), %rsi
sarq $0x3, %rsi
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2cfc
subq %r12, %r15
sarq $0x3, %r15
leaq 0x18(%rsp), %rdx
leaq 0xe(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2d8a
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x259d
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x2bc4
leaq 0x30(%rsp), %rdi
movq (%rdi), %rax
movq (%rax), %rcx
movq 0x18(%rax), %rax
movsd (%rax), %xmm0
mulsd 0x8(%rcx), %xmm0
movsd (%rcx), %xmm1
mulsd 0x8(%rax), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
callq 0x2c5e
movq (%r14), %rax
movq 0x18(%rax), %rcx
movsd 0x8(%rcx), %xmm0
movsd 0x10(%rsp), %xmm2
divsd %xmm2, %xmm0
movq (%rbx), %rdx
movq (%rdx), %rsi
movsd %xmm0, (%rsi)
movq (%rax), %rax
movsd (%rax), %xmm0
divsd %xmm2, %xmm0
movq 0x18(%rdx), %rdx
movsd %xmm0, 0x8(%rdx)
movsd (%rcx), %xmm0
movapd 0x1a66(%rip), %xmm1     # 0x4080
xorpd %xmm1, %xmm0
divsd %xmm2, %xmm0
movsd %xmm0, 0x8(%rsi)
movsd 0x8(%rax), %xmm0
xorpd %xmm1, %xmm0
divsd %xmm2, %xmm0
movsd %xmm0, (%rdx)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2c5e
jmp 0x2673
movq %rax, %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2673
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
jmp 0x2673
movq %rax, %r14
movq %r14, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O3/jamesgrimmett[P]orbital_determination/ex10-2_linear_least_squares.cc
// Function: dot_product(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>, std::vector<double, std::allocator<double>>)
std::vector<double> dot_product(std::vector<std::vector<double> > a, 
                                  std::vector<double> b) {
  // calculate the dot production of a 2x2 matrix with a 1x2 vector
                          
  std::vector<double> result(2, 0.0);
  std::vector<double> a0 = {a[0][0], a[0][1]};
  std::vector<double> a1 = {a[1][0], a[1][1]};

  result[0] = std::inner_product(a0.begin(),a0.end(),b.begin(),0.0);
  result[1] = std::inner_product(a1.begin(),a1.end(),b.begin(),0.0);

  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x10, %edi
callq 0x10e0
movq %rax, %r14
movq %rax, (%rbx)
addq $0x10, %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq %rax, 0x8(%rbx)
movq (%r12), %rax
movq (%rax), %rax
movupd (%rax), %xmm0
leaq 0x20(%rsp), %rsi
movapd %xmm0, (%rsi)
leaq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rcx
movl $0x2, %edx
callq 0x29dc
movq (%r12), %rax
movq 0x18(%rax), %rax
movupd (%rax), %xmm0
leaq 0x40(%rsp), %rsi
movapd %xmm0, (%rsi)
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0x2, %edx
callq 0x29dc
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%r15), %rcx
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
cmpq %rax, %rdi
je 0x273c
movq %rcx, %rdx
movq %rdi, %rsi
movsd (%rsi), %xmm2
mulsd (%rdx), %xmm2
addsd %xmm2, %xmm1
addq $0x8, %rsi
addq $0x8, %rdx
cmpq %rax, %rsi
jne 0x2723
movsd %xmm1, (%r14)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rdx
cmpq %rdx, %rax
je 0x2770
xorpd %xmm0, %xmm0
movq %rax, %rsi
movsd (%rsi), %xmm1
mulsd (%rcx), %xmm1
addsd %xmm1, %xmm0
addq $0x8, %rsi
addq $0x8, %rcx
cmpq %rdx, %rsi
jne 0x2757
movsd %xmm0, 0x8(%r14)
testq %rax, %rax
je 0x2790
movq 0x30(%rsp), %rsi
subq %rax, %rsi
movq %rax, %rdi
callq 0x10f0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x27a2
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x27d0
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
jmp 0x27d0
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x10f0
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O3/jamesgrimmett[P]orbital_determination/ex10-2_linear_least_squares.cc
// Function: propagate(std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>>)
std::vector<double> propagate(std::vector<double> state_, 
                                   std::vector<double> xobs_) {
  // Propagate the observed x value using the state vector
  // to calculate the expected y values.

  int i;
  std::vector<double> yexp_(xobs_.size(), 0.0);

  for (i = 0; i < xobs_.size(); i++) {
    yexp_[i] = state_[0] + state_[1] * xobs_[i];   
  }

  return yexp_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq 0x8(%rdx), %rsi
subq (%rdx), %rsi
movq %rdi, %rbx
sarq $0x3, %rsi
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
leaq 0x7(%rsp), %rcx
callq 0x2a22
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
je 0x2853
sarq $0x3, %rcx
movq (%r14), %rdx
movq (%rbx), %rsi
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edi, %edi
movsd 0x8(%rdx), %xmm0
mulsd (%rax,%rdi,8), %xmm0
addsd (%rdx), %xmm0
movsd %xmm0, (%rsi,%rdi,8)
incq %rdi
cmpq %rdi, %rcx
jne 0x2838
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/jamesgrimmett[P]orbital_determination/ex10-2_linear_least_squares.cc
// Function: residuals(std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>>)
std::vector<double> residuals(std::vector<double> yobs_, 
                                 std::vector<double> yexp_) {
  // calculate the residuals (observed  - expected)

  // residuals vector
  std::vector<double> res_(yobs_.size(), 0.0);

  std::transform(yobs_.cbegin(), yobs_.cend(), 
                   yexp_.cbegin(), res_.begin(), std::minus<double>());

  return res_;  
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq 0x8(%rsi), %rsi
subq (%r15), %rsi
movq %rdi, %rbx
sarq $0x3, %rsi
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
leaq 0x7(%rsp), %rcx
callq 0x2a22
movq (%r15), %rax
movq 0x8(%r15), %rcx
cmpq %rcx, %rax
je 0x28c8
movq (%rbx), %rdx
movq (%r14), %rsi
xorl %edi, %edi
leaq (%rax,%rdi), %r8
addq $0x8, %r8
movsd -0x8(%r8), %xmm0
subsd (%rsi,%rdi), %xmm0
movsd %xmm0, (%rdx,%rdi)
addq $0x8, %rdi
cmpq %rcx, %r8
jne 0x28a7
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/jamesgrimmett[P]orbital_determination/ex10-2_linear_least_squares.cc
// Function: root_mean_sq(std::vector<double, std::allocator<double>>)
double root_mean_sq(std::vector<double> res_) {
  // Calculate the square root of the mean expected squared value
  double rms_;
  std::vector<double> ressq(res_.size(), 0.0);
  std::transform(res_.cbegin(), res_.cend(),
                   res_.cbegin(), ressq.begin(), std::multiplies<double>());
  rms_ = std::accumulate(ressq.begin(), ressq.end(), 0.0) / res_.size();
  rms_ = std::sqrt(rms_);

  return rms_;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
subq (%rdi), %rsi
sarq $0x3, %rsi
leaq 0x30(%rsp), %rdx
movq $0x0, (%rdx)
leaq 0x18(%rsp), %r14
leaq 0xf(%rsp), %rcx
movq %r14, %rdi
callq 0x2a22
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
movq (%r14), %rdx
cmpq %rax, %rcx
je 0x2936
movq %rdx, %rsi
movq %rcx, %rdi
movsd (%rdi), %xmm0
mulsd %xmm0, %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rdi
addq $0x8, %rsi
cmpq %rax, %rdi
jne 0x291d
movq 0x20(%rsp), %rsi
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
cmpq %rsi, %rdx
je 0x2952
addsd (%rdx), %xmm0
addq $0x8, %rdx
jmp 0x2943
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, %xmm2
punpckldq 0x16ca(%rip), %xmm2 # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
subpd 0x16d2(%rip), %xmm2     # 0x4040
movapd %xmm2, %xmm3
unpckhpd %xmm2, %xmm3            # xmm3 = xmm3[1],xmm2[1]
addsd %xmm2, %xmm3
divsd %xmm3, %xmm0
ucomisd %xmm1, %xmm0
jb 0x298a
sqrtsd %xmm0, %xmm0
jmp 0x298f
callq 0x10b0
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x29b2
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
movsd %xmm0, 0x10(%rsp)
callq 0x10f0
movsd 0x10(%rsp), %xmm0
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/dcdolson[P]nsh-sf-devkit/examples/count/main.cpp
// Function: main
int main(int argc, char** argv)
{
    try
    {
        auto interface = nshdev::NetInterfaceFactory::CreateInterfaceFromArgs(argc, argv);
        if(interface == nullptr)
        {
            std::cerr << "Failed to create interface" << std::endl;
            return 2;
        }

        nshdev::Demux demux;
        interface->SetConsumer(&demux);

        PacketCounter packetCounter;
        demux.SetConsumer(&packetCounter);

        nshdev::Scheduler scheduler(*interface);

        scheduler.SchedulePackets();

	}
    catch(const std::exception& e)
    {
        std::cerr << "Caught exception (aborting)" << std::endl << e.what() << std::endl;
    }

    return 1;  // can only get here by exception
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
leaq 0x2c(%rsp), %rax
movl %edi, (%rax)
leaq 0x40(%rsp), %rdx
movq %rsi, (%rdx)
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x29b8
movq 0x8(%rsp), %r14
testq %r14, %r14
je 0x2625
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x35e0
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2694
movq %rbx, 0x8(%rax)
leaq 0x4603(%rip), %rax      # 0x6bc8
addq $0x10, %rax
leaq 0x48(%rsp), %rbx
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
xorl %edi, %edi
callq 0x21d0
movq %rax, 0x18(%rbx)
movq %rbx, 0x20(%rsp)
movq 0x8(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x36e4
leaq 0x30(%rsp), %rdi
callq 0x36f6
leaq 0x4700(%rip), %rax      # 0x6d08
addq $0x10, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2621
movq (%rdi), %rax
callq *0x8(%rax)
xorl %ebx, %ebx
jmp 0x2670
movq 0x49bc(%rip), %rbx      # 0x6fe8
leaq 0x19d1(%rip), %rsi      # 0x4004
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x2220
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq 0x498a(%rip), %rdi      # 0x6fe8
callq 0x2030
movl $0x2, %ebx
movq %rax, %rdi
callq 0x2150
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2680
movq (%rdi), %rax
callq *0x8(%rax)
testq %r14, %r14
je 0x268a
movl $0x1, %ebx
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0x19a0(%rip), %rdi      # 0x403b
leaq 0x19a5(%rip), %rsi      # 0x4047
leaq 0x19c6(%rip), %rcx      # 0x406f
movl $0x1b, %edx
callq 0x2130
jmp 0x26e5
movq %rdx, %r14
movq %rax, %rbx
jmp 0x26fb
movq %rdx, %r14
movq %rax, %rbx
leaq 0x463e(%rip), %rax      # 0x6d08
addq $0x10, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x26eb
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x26eb
movq %rdx, %r14
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x26fb
movq (%rdi), %rax
callq *0x8(%rax)
cmpl $0x1, %r14d
jne 0x2761
movq %rbx, %rdi
callq 0x20f0
movq %rax, %rbx
movq 0x48d5(%rip), %rdi      # 0x6fe8
leaq 0x1905(%rip), %rsi      # 0x401f
movl $0x1b, %edx
callq 0x2220
movq 0x48bd(%rip), %rdi      # 0x6fe8
callq 0x2110
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x21f0
movq %rax, %rdi
callq 0x2110
callq 0x22a0
jmp 0x2685
movq %rax, %rbx
callq 0x22a0
movq %rbx, %rdi
callq 0x2300
movq %rax, %rdi
callq 0x2771
// File: /workspace/github_cpp_makefile_star2_O3/dcdolson[P]nsh-sf-devkit/examples/count/PacketCounter.cpp
// Function: PacketCounter::Display()
void PacketCounter::Display()
{
    // very primitive: display counts, but no more than once per second.
    std::time_t now = std::time(nullptr);
    if( now - m_lastDisplayTime > 0 )
    {
        std::cout << "Packets: " << std::right << std::setw(12) << m_packets
	    << "  Bytes: " << m_bytes << std::endl;
	m_lastDisplayTime = now;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %edi, %edi
callq 0x21d0
cmpq 0x18(%rbx), %rax
jle 0x287d
movq %rax, %r14
movq 0x47d5(%rip), %r15      # 0x6fb8
leaq 0x18d6(%rip), %rsi      # 0x40c0
movl $0x9, %edx
movq %r15, %rdi
callq 0x2220
movq (%r15), %rax
movq -0x18(%rax), %rcx
movl $0xffffff4f, %edx       # imm = 0xFFFFFF4F
andl 0x18(%r15,%rcx), %edx
orl $0x80, %edx
movl %edx, 0x18(%r15,%rcx)
movq -0x18(%rax), %rax
movq $0xc, 0x10(%r15,%rax)
movq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0x2140
movq %rax, %r15
leaq 0x1894(%rip), %rsi      # 0x40ca
movl $0x9, %edx
movq %rax, %rdi
callq 0x2220
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x2140
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq %r14, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/eschwabe[P]interview-practice/src/removechars.cpp
// Function: remove_chars(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string remove_chars(string str, string remove) {
    string output;
    unordered_set<char> remove_set;
    for(char c : remove) {
        remove_set.insert(c);
    }
    for(char c : str) {
        if( remove_set.find(c) == remove_set.end() ) {
            output.append(1, c);
        }
    }

    return output;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, 0x20(%rsp)
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movq %rdi, 0x18(%rsp)
movb $0x0, 0x10(%rdi)
leaq 0x60(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movq 0x8(%rdx), %rbp
testq %rbp, %rbp
je 0x134f
movq (%rdx), %r14
xorl %ebx, %ebx
leaq 0x30(%rsp), %r15
leaq 0xf(%rsp), %r12
leaq 0x28(%rsp), %r13
movb (%r14,%rbx), %al
movb %al, 0xf(%rsp)
movq %r15, 0x28(%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x15d8
incq %rbx
cmpq %rbx, %rbp
jne 0x132c
movq 0x20(%rsp), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
movq 0x18(%rsp), %rbx
je 0x13d3
movq (%rax), %r14
addq %r14, %r15
movsbq (%r14), %rcx
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %r8
movq %rcx, %rax
xorl %edx, %edx
divq %r8
movq (%rdi,%rdx,8), %rax
testq %rax, %rax
je 0x13b4
movq %rdx, %rsi
movq (%rax), %r9
cmpb 0x8(%r9), %cl
je 0x13cb
movq (%r9), %r9
testq %r9, %r9
je 0x13b4
movsbq 0x8(%r9), %rdi
movq %rdi, %rax
xorl %edx, %edx
divq %r8
cmpq %rsi, %rdx
jne 0x13b4
cmpb %dil, %cl
jne 0x1393
jmp 0x13cb
movq 0x8(%rbx), %rsi
movsbl %cl, %r8d
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1170
incq %r14
cmpq %r15, %r14
jne 0x1368
leaq 0x30(%rsp), %rdi
callq 0x155e
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13f1
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x155e
movq 0x18(%rsp), %rax
movq (%rax), %rdi
cmpq 0x10(%rsp), %rdi
je 0x141d
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x10f0
movq %r14, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/grep.cpp
// Function: grepcomp()
void
grepcomp()
{
	int i;
	char *s, *t;	
	for(i=0; i<nargpat; i++) {
		for(t=s=argpat[i]; t; s = t+1) {	/*see above*/
			t = strchr(s, '\n');
			if(t)
				*t = 0;
			docomp(s);
		}	
	}

	for(i=0; i<nfilepat; i++) {
		FILE *patfile = fopen(filepat[i], "r");
		if(patfile)
			while(getline(patfile, filepat[i]) >= 0)
				docomp(&line[0]);
		else if(!sflag)
			error("cannot open", filepat[i]);
		else
			retval = 2;
		fclose(patfile);
	}
	if(nre == 0)
		error("no pattern", "");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x9daa(%rip), %eax      # 0xe660
testl %eax, %eax
jle 0x4922
xorl %r15d, %r15d
movq 0x9cec(%rip), %rcx      # 0xe5b0
movq (%rcx,%r15,8), %rbx
testq %rbx, %rbx
je 0x4917
movq %rbx, %rdi
movl $0xa, %esi
callq 0x40b0
testq %rax, %rax
je 0x4909
movq %rax, %r14
movb $0x0, (%r14)
movq %rbx, %rdi
callq 0x4b95
movq %r14, %rbx
incq %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x40b0
movq %rax, %r14
testq %rax, %rax
jne 0x48e2
movq %rbx, %rdi
callq 0x4b95
movl 0x9d49(%rip), %eax      # 0xe660
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0x48bd
cmpl $0x0, 0x9def(%rip)      # 0xe718
jle 0x499f
xorl %r15d, %r15d
leaq 0x4e75(%rip), %rbx      # 0x97aa
movq 0x9d2c(%rip), %rax      # 0xe668
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x41b0
movq %rax, %r14
testq %rax, %rax
jne 0x4971
cmpl $0x0, 0x9c49(%rip)      # 0xe5a0
je 0x49ae
movl $0x2, 0x980d(%rip)      # 0xe170
jmp 0x4988
movq 0xa0ec(%rip), %rdi      # 0xea58
callq 0x4b95
movq 0x9cf0(%rip), %rax      # 0xe668
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x4c49
testl %eax, %eax
jns 0x4965
movq %r14, %rdi
callq 0x4160
incq %r15
movslq 0x9d7e(%rip), %rax      # 0xe718
cmpq %rax, %r15
jl 0x4935
cmpl $0x0, 0xa0aa(%rip)      # 0xea50
je 0x49cf
popq %rbx
popq %r14
popq %r15
retq
movq 0x9cb3(%rip), %rax      # 0xe668
movq (%rax,%r15,8), %rsi
leaq 0x476d(%rip), %rdi      # 0x912d
callq 0x42d0
movl $0x2, %edi
callq 0x41c0
leaq 0x4720(%rip), %rdi      # 0x90f6
leaq 0x4718(%rip), %rsi      # 0x90f5
jmp 0x49c0
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/grep.cpp
// Function: execute(_IO_FILE*, char const*)
void
execute(FILE *input, const char *name)
{
	int i, lineno;
	int hits = 0;
	for(lineno=1; ; lineno++) {
		int n = getline(input, name);
		if(n < 0)
			break;
		for(i=0; i<nre; i++) {
			int result = regnexec(&re[i], &line[0], n, 0, 0, 0);
			if(result == 0) 
				break;
			if(result != REG_NOMATCH)
				doregerror(result, name, lineno);
		}
		if((i<nre) ^ vflag) {
			hits++;
			if(qflag | lflag)
				break;
			if(cflag)
				continue;
			if(nfiles>1 && !hflag)
				printf("%s:", name);
			if(nflag)
				printf("%d:", lineno);
			printf("%s\n", line.bytes());
		}
	}
	if(hits)
		anyhits = 1;
	if(qflag)
		return;
	if(lflag && hits)
		printf("%s\n", name);
	if(!lflag && cflag) {
		if(nfiles>1 && !hflag)
			printf("%s:", name);
		printf("%d\n", hits);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, (%rsp)
callq 0x4c49
testl %eax, %eax
js 0x4b0c
movl $0x1, %r15d
xorl %ebp, %ebp
movl 0xa044(%rip), %ecx      # 0xea50
movl $0x0, %r12d
testl %ecx, %ecx
jle 0x4a71
movl %eax, %r13d
xorl %r14d, %r14d
xorl %r12d, %r12d
movq 0x9cfa(%rip), %rdi      # 0xe720
addq %r14, %rdi
movq 0xa028(%rip), %rsi      # 0xea58
movq %r13, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x65eb
cmpl $0x1, %eax
je 0x4a56
testl %eax, %eax
je 0x4a6b
movl %eax, %edi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x4cfb
incq %r12
movslq 0x9ff0(%rip), %rcx      # 0xea50
addq $0x28, %r14
cmpq %rcx, %r12
jl 0x4a1f
jmp 0x4a71
movl 0x9fdf(%rip), %ecx      # 0xea50
xorl %eax, %eax
cmpl %ecx, %r12d
setl %al
cmpl %eax, 0x9b25(%rip)      # 0xe5a4
je 0x4ae3
incl %ebp
movl 0x9b0b(%rip), %eax      # 0xe594
orl 0x9b09(%rip), %eax      # 0xe598
jne 0x4afa
cmpl $0x0, 0x9af8(%rip)      # 0xe590
jne 0x4ae3
cmpl $0x2, 0x9fdf(%rip)      # 0xea80
jl 0x4abd
cmpl $0x0, 0x9afe(%rip)      # 0xe5a8
jne 0x4abd
leaq 0x46c3(%rip), %rdi      # 0x9176
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4050
cmpl $0x0, 0x9ad8(%rip)      # 0xe59c
je 0x4ad7
leaq 0x46ad(%rip), %rdi      # 0x917a
movl %r15d, %esi
xorl %eax, %eax
callq 0x4050
movq 0x9f7a(%rip), %rdi      # 0xea58
callq 0x4230
incl %r15d
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0x4c49
testl %eax, %eax
jns 0x4a06
testl %ebp, %ebp
je 0x4b0c
movl $0x1, 0x9f74(%rip)      # 0xea7c
movb $0x1, %al
jmp 0x4b10
xorl %eax, %eax
xorl %ebp, %ebp
cmpl $0x0, 0x9a81(%rip)      # 0xe598
je 0x4b28
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x9a66(%rip), %ecx      # 0xe594
testl %ecx, %ecx
sete %dl
xorb $0x1, %al
orb %dl, %al
jne 0x4b47
movq %rbx, %rdi
callq 0x4230
movl 0x9a4d(%rip), %ecx      # 0xe594
testl %ecx, %ecx
jne 0x4b19
cmpl $0x0, 0x9a3e(%rip)      # 0xe590
je 0x4b19
cmpl $0x2, 0x9f25(%rip)      # 0xea80
jl 0x4b77
cmpl $0x0, 0x9a44(%rip)      # 0xe5a8
jne 0x4b77
leaq 0x4609(%rip), %rdi      # 0x9176
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4050
leaq 0x460e(%rip), %rdi      # 0x918c
movl %ebp, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4050
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/grep.cpp
// Function: docomp(char*)
void
docomp(char *s)
{
	if(re.assure(nre))
		error("out of space at--", s);
	int result = regcomp(&re[nre], s, options);
	if(result)
		doregerror(result, s, 0);
	if(!nre || !regcomb(&re[nre-1], &re[nre]))
		nre++;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x9eb1(%rip), %esi      # 0xea50
cmpl %esi, 0x9b83(%rip)      # 0xe728
jg 0x4bbd
leaq 0x9b72(%rip), %rdi      # 0xe720
callq 0x4de0
testl %eax, %eax
jne 0x4c30
movl 0x9e93(%rip), %esi      # 0xea50
movslq %esi, %rax
leaq (%rax,%rax,4), %rdi
shlq $0x3, %rdi
addq 0x9b51(%rip), %rdi      # 0xe720
movl 0x959f(%rip), %edx      # 0xe174
movq %rbx, %rsi
callq 0x766a
testl %eax, %eax
je 0x4bed
movl %eax, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x4cfb
movslq 0x9e5c(%rip), %rax      # 0xea50
testq %rax, %rax
je 0x4c23
movq 0x9b20(%rip), %rcx      # 0xe720
leaq (%rax,%rax,4), %rax
leaq (%rcx,%rax,8), %rsi
leaq (%rcx,%rax,8), %rdi
addq $-0x28, %rdi
callq 0x7ac4
testl %eax, %eax
jne 0x4c2e
movl 0x9e31(%rip), %eax      # 0xea50
incl %eax
jmp 0x4c28
movl $0x1, %eax
movl %eax, 0x9e22(%rip)      # 0xea50
popq %rbx
retq
leaq 0x4502(%rip), %rdi      # 0x9139
movq %rbx, %rsi
callq 0x42d0
movl $0x2, %edi
callq 0x41c0
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/grep.cpp
// Function: getline(_IO_FILE*, char const*)
int
getline(FILE *input, const char *name)
{
	int c, j;
	for(j=0; ; j++) {
		if(line.assure(j))
			error("out of space reading ", name);
		switch(c = getc(input)) {
		default:
			line[j] = c;
			continue;
		case EOF:
			if(j == 0)
				return -1;
			warn("newline appended to ", name);
		case '\n':
			line[j] = 0;
			return j;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
leaq 0x9df8(%rip), %r12      # 0xea58
movslq 0x9df9(%rip), %rax      # 0xea60
cmpq %rax, %rbx
jl 0x4c7a
movq %r12, %rdi
movl %ebx, %esi
callq 0x4e58
testl %eax, %eax
jne 0x4ce2
movq %r15, %rdi
callq 0x4090
cmpl $-0x1, %eax
je 0x4c9b
cmpl $0xa, %eax
je 0x4cc7
movq 0x9dc5(%rip), %rcx      # 0xea58
movb %al, (%rcx,%rbx)
incq %rbx
jmp 0x4c60
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rbx, %rbx
je 0x4cd6
movq 0x9324(%rip), %rax      # 0xdfd0
movq (%rax), %rdi
leaq 0x44da(%rip), %rsi      # 0x9190
leaq 0x44a4(%rip), %rdx      # 0x9161
movq %r14, %rcx
xorl %eax, %eax
callq 0x4200
movq 0x9d8a(%rip), %rax      # 0xea58
movl %ebx, %ecx
movb $0x0, (%rax,%rcx)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4462(%rip), %rdi      # 0x914b
movq %r14, %rsi
callq 0x42d0
movl $0x2, %edi
callq 0x41c0
// File: /workspace/github_cpp_makefile_star2_O3/benjibc[P]json-universal-container/./json.h
// Function: JSON::operator=(JSON const&)
JSON & JSON::operator=(const JSON & rhs)
{
    this->clear();
    this->m_type = rhs.m_type;
    switch(m_type)
    {
        case type_array:
            new (&(m_data.u_arr)) Arr_t(rhs.m_data.u_arr);
            break;
        case type_obj:
            new (&(m_data.u_map)) Map_t(rhs.m_data.u_map);
            break;
        case type_str:
            new (&(m_data.u_str)) std::string(rhs.m_data.u_str);
            break;
        case type_double:
            m_data.u_double = rhs.m_data.u_double;
            break;
        default:
            m_data.u_bool = rhs.m_data.u_bool; 
            break;
    }
    return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x28(%rdi), %eax
cmpl $0x1, %eax
je 0x2428
cmpl $0x2, %eax
je 0x241e
cmpl $0x3, %eax
jne 0x2439
movq %rbx, %rdi
callq 0x447c
jmp 0x2439
movq %rbx, %rdi
callq 0x798c
jmp 0x2439
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
je 0x2439
callq 0x2170
movl 0x28(%r14), %eax
movl %eax, 0x28(%rbx)
decl %eax
cmpl $0x3, %eax
ja 0x249c
leaq 0x6bb6(%rip), %rcx      # 0x9004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x8128
jmp 0x24a1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4184
jmp 0x24a1
movsd (%r14), %xmm0
movsd %xmm0, (%rbx)
jmp 0x24a1
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x847e
jmp 0x24a1
movb (%r14), %al
movb %al, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x696f
// File: /workspace/github_cpp_makefile_star2_O3/benjibc[P]json-universal-container/./json.h
// Function: JSON::push_back(JSON)
inline
void JSON::push_back(JSON rhs)
{
    if(m_type == type_array)
        m_data.u_arr.push_back(rhs);
    else
        throw JSONOperationException();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x3, 0x28(%rdi)
jne 0x42b1
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x69ee
movl $0x28, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5199(%rip), %rsi      # 0x9467
leaq 0x51a7(%rip), %rdx      # 0x947c
leaq 0x8(%rsp), %rdi
callq 0x81be
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x697a
xorl %ebp, %ebp
leaq 0x9960(%rip), %rsi      # 0xdc58
leaq 0x26c5(%rip), %rdx      # 0x69c4
movq %rbx, %rdi
callq 0x2230
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4319
callq 0x2170
testb %bpl, %bpl
jne 0x4323
jmp 0x432b
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O3/benjibc[P]json-universal-container/./json.h
// Function: JSON::~JSON()
inline
JSON::~JSON()
{
    switch(m_type)
    {
        case type_str:
            m_data.u_str.~string();
            break;
        case type_array:
            m_data.u_arr.~Arr_t();
            break;
        case type_obj:
            m_data.u_map.~Map_t();
            break;
    }
}

// Assembly:
pushq %rax
movl 0x28(%rdi), %eax
cmpl $0x3, %eax
je 0x4363
cmpl $0x2, %eax
je 0x435c
cmpl $0x1, %eax
jne 0x4361
movq (%rdi), %rax
addq $0x10, %rdi
cmpq %rdi, %rax
je 0x4361
movq %rax, %rdi
popq %rax
jmp 0x2170
callq 0x798c
popq %rax
retq
popq %rax
jmp 0x447c
movq %rax, %rdi
callq 0x696f
nop
// File: /workspace/github_cpp_makefile_star2_O3/benjibc[P]json-universal-container/./json.h
// Function: JSON::push_back(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, JSON&)
inline
void JSON::push_back(const string & key, JSON & rhs)
{
    if(m_type == type_obj)
        m_data.u_map[key] = rhs;
    else
        throw JSONOperationException();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x2, 0x28(%rdi)
jne 0x43a0
movq %rdx, %rbx
callq 0x71e4
leaq 0x20(%rax), %rdi
movq %rbx, %rsi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x23f8
movl $0x28, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x50aa(%rip), %rsi      # 0x9467
leaq 0x50b8(%rip), %rdx      # 0x947c
leaq 0x8(%rsp), %rdi
callq 0x81be
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x697a
xorl %ebp, %ebp
leaq 0x9871(%rip), %rsi      # 0xdc58
leaq 0x25d6(%rip), %rdx      # 0x69c4
movq %rbx, %rdi
callq 0x2230
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4408
callq 0x2170
testb %bpl, %bpl
jne 0x4412
jmp 0x441a
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2240