LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2cb8
movq %rax, 0x8(%rbx)
testb %r14b, %r14b
jne 0x2cc3
movapd %xmm0, %xmm2
jmp 0x2ccb
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 0x2cf7
callq 0x2a90
jmp 0x2cfc
callq 0x2960
movq %rax, %r15
testq %rax, %rax
je 0x2da4
leaq -0x48(%rbp), %r12
movsd 0x8(%r15), %xmm0
testb %r14b, %r14b
je 0x2d33
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 0x2d52
jmp 0x2da4
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 0x2da4
movl 0x10(%r15), %eax
movsd 0x8(%r15), %xmm0
movl %eax, -0x48(%rbp)
movsd %xmm0, -0x40(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2d7e
movupd -0x48(%rbp), %xmm0
movupd %xmm0, (%rsi)
addq $0x10, 0x8(%rbx)
jmp 0x2d89
movq %rbx, %rdi
movq %r12, %rdx
callq 0x281a
testb %r14b, %r14b
je 0x2d94
addq $0x18, %r15
jmp 0x2d98
movq 0x20(%r15), %r15
movq (%r15), %r15
testq %r15, %r15
jne 0x2d0c
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2e20
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 0x2e10
addq %r8, %r10
movl 0x8(%r10), %r10d
addq %r13, %r10
cmpq %rsi, %r10
jb 0x2dee
movq %rax, -0x140(%rbp,%rcx,8)
cmpq $0x1, %rdi
jg 0x2ddb
jmp 0x2e23
xorl %r13d, %r13d
movq 0x20(%rax), %rax
movq (%rax), %r14
xorl %eax, %eax
testq %r14, %r14
je 0x2e9d
movl %edx, %ecx
movq %rcx, -0x38(%rbp)
cmpq %rcx, %r13
jae 0x2e9d
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 0x2296
leaq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x2eb0
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x2e7d
callq 0x1150
movq %r14, %rdi
callq 0x1110
leaq 0x1(%rbx), %rax
testq %r12, %r12
je 0x2e9d
addq %r13, %rbx
movq %r12, %r14
cmpq -0x38(%rbp), %rbx
movq %rax, %rbx
jb 0x2e49
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_O1/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 0x36dd
movq %rdi, %r14
movl 0x4(%rdi), %ebp
testl %ebp, %ebp
jle 0x36dd
leaq 0x5e16(%rip), %rax      # 0x940d
movq %rsi, %rdi
movq %rax, %rsi
callq 0x21e0
testq %rax, %rax
je 0x36dd
movq %rax, %r15
imull %r12d, %ebp
movl 0x4(%r14), %eax
imull (%r14), %eax
testl %eax, %eax
je 0x3663
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 0x3640
addq $-0x8, %rax
cmpq 0x8(%r14), %rcx
ja 0x362f
movq 0x8(%r14), %rdi
movl %ebp, %r12d
movl $0x8, %esi
movq %r12, %rdx
movq %r15, %rcx
callq 0x2330
movq %rax, %r13
movq %r15, %rdi
callq 0x2170
cmpq %r12, %r13
jne 0x36dd
movl 0x4(%r14), %eax
imull (%r14), %eax
xorl %ebx, %ebx
testl %eax, %eax
je 0x36dd
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 0x36ba
addq $-0x8, %rax
cmpq 0x8(%r14), %rcx
ja 0x36a9
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d0e
subq %r12, %r15
sarq $0x3, %r15
leaq 0x18(%rsp), %rdx
leaq 0xe(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2d98
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2636
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x2bdc
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 0x2c76
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 0x19ad(%rip), %xmm1     # 0x4060
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 0x2c76
jmp 0x270c
movq %rax, %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x270c
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
jmp 0x270c
movq %rax, %r14
movq %r14, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x10, %edi
callq 0x10e0
movq %rax, %r14
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
addq $0x10, %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq %rax, 0x8(%rbx)
movq (%r12), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
leaq 0x20(%rsp), %rsi
movsd %xmm0, (%rsi)
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rsi)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rcx
movl $0x2, %edx
callq 0x2a94
movq (%r12), %rax
movq 0x18(%rax), %rax
movsd (%rax), %xmm0
leaq 0x38(%rsp), %rsi
movsd %xmm0, (%rsi)
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rsi)
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0x2, %edx
callq 0x2a94
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdx
movq (%r15), %rax
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
cmpq %rdx, %rcx
je 0x27f8
movq %rax, %rsi
movsd (%rcx), %xmm2
mulsd (%rsi), %xmm2
addsd %xmm2, %xmm1
addq $0x8, %rcx
addq $0x8, %rsi
cmpq %rdx, %rcx
jne 0x27df
movsd %xmm1, (%r14)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rcx
cmpq %rcx, %rdi
je 0x282c
xorpd %xmm0, %xmm0
movq %rdi, %rdx
movsd (%rdx), %xmm1
mulsd (%rax), %xmm1
addsd %xmm1, %xmm0
addq $0x8, %rdx
addq $0x8, %rax
cmpq %rcx, %rdx
jne 0x2813
movsd %xmm0, 0x8(%r14)
testq %rdi, %rdi
je 0x2844
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x285b
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2889
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
jmp 0x2889
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x10f0
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ada
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
je 0x290c
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 0x28f1
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ada
movq (%r15), %rax
movq 0x8(%r15), %rcx
cmpq %rcx, %rax
je 0x2981
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 0x2960
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ada
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
movq (%r14), %rdx
cmpq %rax, %rcx
je 0x29ef
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 0x29d6
movq 0x20(%rsp), %rsi
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
cmpq %rsi, %rdx
je 0x2a0b
addsd (%rdx), %xmm0
addq $0x8, %rdx
jmp 0x29fc
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, %xmm2
punpckldq 0x1611(%rip), %xmm2 # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
subpd 0x1619(%rip), %xmm2     # 0x4040
movapd %xmm2, %xmm3
unpckhpd %xmm2, %xmm3            # xmm3 = xmm3[1],xmm2[1]
addsd %xmm2, %xmm3
divsd %xmm3, %xmm0
ucomisd %xmm1, %xmm0
jb 0x2a43
sqrtsd %xmm0, %xmm0
jmp 0x2a48
callq 0x10b0
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2a6b
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_O1/dcdolson[P]nsh-sf-devkit/examples/count/PacketCounter.cpp
// Function: PacketCounter::Receive(nshdev::PacketRef&, nshdev::NetInterface&)
void PacketCounter::Receive(nshdev::PacketRef& packetRef, nshdev::NetInterface& interface)
{
    m_packets += 1;
    m_bytes += packetRef.Length();
    Display();

    // Forward packets, not black-hole them.
    interface.ReturnToSender(packetRef);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
incq 0x8(%rdi)
movl 0x8(%rsi), %eax
addq %rax, 0x10(%rdi)
callq 0x27c0
movq (%rbx), %rax
movq 0x20(%rax), %rax
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18b8(%rip), %rsi      # 0x40a2
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 0x1876(%rip), %rsi      # 0x40ac
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_O1/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 0x1600
incq %rbx
cmpq %rbx, %rbp
jne 0x132c
movq 0x20(%rsp), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
movq 0x18(%rsp), %rbx
je 0x13fb
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 %rdx, %rsi
movq (%rdi,%rdx,8), %rdx
movl $0x0, %eax
testq %rdx, %rdx
je 0x13cd
movq (%rdx), %r9
movq %rdx, %rax
cmpb 0x8(%r9), %cl
je 0x13cd
movq %r9, %r10
movq (%r9), %r9
testq %r9, %r9
je 0x13cb
movsbq 0x8(%r9), %rdi
movq %rdi, %rax
xorl %edx, %edx
divq %r8
movl $0x0, %eax
cmpq %rsi, %rdx
jne 0x13cd
movq %r10, %rax
cmpb %dil, %cl
jne 0x139f
jmp 0x13cd
xorl %eax, %eax
testq %rax, %rax
je 0x13d8
cmpq $0x0, (%rax)
jne 0x13ef
movq 0x8(%rbx), %rsi
movsbl %cl, %r8d
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1170
incq %r14
cmpq %r15, %r14
jne 0x136c
leaq 0x30(%rsp), %rdi
callq 0x1586
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1419
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x1586
movq 0x18(%rsp), %rax
movq (%rax), %rdi
cmpq 0x10(%rsp), %rdi
je 0x1445
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x10f0
movq %r14, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpl $0x0, 0x9d9f(%rip)      # 0xe660
jle 0x490f
xorl %r15d, %r15d
movq 0x9ce3(%rip), %rax      # 0xe5b0
movq (%rax,%r15,8), %rbx
testq %rbx, %rbx
je 0x4900
movq %rbx, %rdi
movl $0xa, %esi
callq 0x40b0
movq %rax, %r14
testq %rax, %rax
je 0x48ef
movb $0x0, (%r14)
movq %rbx, %rdi
callq 0x4b87
leaq 0x1(%r14), %rbx
testq %r14, %r14
jne 0x48d6
incq %r15
movslq 0x9d56(%rip), %rax      # 0xe660
cmpq %rax, %r15
jl 0x48c6
cmpl $0x0, 0x9e02(%rip)      # 0xe718
jle 0x498c
xorl %r15d, %r15d
leaq 0x4e78(%rip), %rbx      # 0x979a
movq 0x9d3f(%rip), %rax      # 0xe668
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x41b0
movq %rax, %r14
testq %rax, %rax
jne 0x495e
cmpl $0x0, 0x9c5c(%rip)      # 0xe5a0
je 0x499b
movl $0x2, 0x9820(%rip)      # 0xe170
jmp 0x4975
movq 0xa0ff(%rip), %rdi      # 0xea58
callq 0x4b87
movq 0x9d03(%rip), %rax      # 0xe668
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x4c2a
testl %eax, %eax
jns 0x4952
movq %r14, %rdi
callq 0x4160
incq %r15
movslq 0x9d91(%rip), %rax      # 0xe718
cmpq %rax, %r15
jl 0x4922
cmpl $0x0, 0xa0bd(%rip)      # 0xea50
je 0x49bc
popq %rbx
popq %r14
popq %r15
retq
movq 0x9cc6(%rip), %rax      # 0xe668
movq (%rax,%r15,8), %rsi
leaq 0x4780(%rip), %rdi      # 0x912d
callq 0x42d0
movl $0x2, %edi
callq 0x41c0
leaq 0x4733(%rip), %rdi      # 0x90f6
leaq 0x472b(%rip), %rsi      # 0x90f5
jmp 0x49ad
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %ebp
movl $0x0, 0xc(%rsp)
movq %rdi, 0x10(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x4c2a
movb $0x1, %r12b
testl %eax, %eax
js 0x4a95
cmpl $0x0, 0xa041(%rip)      # 0xea50
jle 0x4a69
movl %eax, %r13d
xorl %r15d, %r15d
xorl %ebx, %ebx
movq 0x9d00(%rip), %rdi      # 0xe720
addq %r15, %rdi
movq 0xa02e(%rip), %rsi      # 0xea58
movq %r13, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x6601
cmpl $0x1, %eax
je 0x4a4f
testl %eax, %eax
je 0x4a62
movl %eax, %edi
movq %r14, %rsi
movl %ebp, %edx
callq 0x4cdc
incq %rbx
movslq 0x9ff7(%rip), %rax      # 0xea50
addq $0x28, %r15
cmpq %rax, %rbx
jl 0x4a19
movq 0x10(%rsp), %r15
jmp 0x4a6b
xorl %ebx, %ebx
xorl %eax, %eax
cmpl 0x9fdd(%rip), %ebx      # 0xea50
setl %al
cmpl %eax, 0x9b28(%rip)      # 0xe5a4
jne 0x4a83
xorl %r12d, %r12d
jmp 0x4a95
incl 0xc(%rsp)
movl 0x9b07(%rip), %eax      # 0xe594
orl 0x9b05(%rip), %eax      # 0xe598
je 0x4aa2
incl %ebp
testb %r12b, %r12b
je 0x49f2
jmp 0x4af5
cmpl $0x0, 0x9ae7(%rip)      # 0xe590
jne 0x4a7e
cmpl $0x2, 0x9fce(%rip)      # 0xea80
jl 0x4ace
cmpl $0x0, 0x9aed(%rip)      # 0xe5a8
jne 0x4ace
leaq 0x46b2(%rip), %rdi      # 0x9176
movq %r14, %rsi
xorl %eax, %eax
callq 0x4050
cmpl $0x0, 0x9ac7(%rip)      # 0xe59c
je 0x4ae7
leaq 0x469c(%rip), %rdi      # 0x917a
movl %ebp, %esi
xorl %eax, %eax
callq 0x4050
movq 0x9f6a(%rip), %rdi      # 0xea58
callq 0x4230
jmp 0x4a7e
movl 0xc(%rsp), %ebx
testl %ebx, %ebx
je 0x4b07
movl $0x1, 0x9f75(%rip)      # 0xea7c
cmpl $0x0, 0x9a8a(%rip)      # 0xe598
je 0x4b1f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %ebx, %ebx
je 0x4b34
cmpl $0x0, 0x9a6a(%rip)      # 0xe594
je 0x4b34
movq %r14, %rdi
callq 0x4230
cmpl $0x0, 0x9a59(%rip)      # 0xe594
jne 0x4b10
cmpl $0x0, 0x9a4c(%rip)      # 0xe590
je 0x4b10
cmpl $0x2, 0x9f33(%rip)      # 0xea80
jl 0x4b69
cmpl $0x0, 0x9a52(%rip)      # 0xe5a8
jne 0x4b69
leaq 0x4617(%rip), %rdi      # 0x9176
movq %r14, %rsi
xorl %eax, %eax
callq 0x4050
leaq 0x461c(%rip), %rdi      # 0x918c
movl %ebx, %esi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4050
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9ebf(%rip), %esi      # 0xea50
cmpl %esi, 0x9b91(%rip)      # 0xe728
jg 0x4ba9
leaq 0x9b80(%rip), %rdi      # 0xe720
callq 0x4dc2
testl %eax, %eax
jne 0x4c11
movslq 0x9ea0(%rip), %rax      # 0xea50
leaq (%rax,%rax,4), %rdi
shlq $0x3, %rdi
addq 0x9b61(%rip), %rdi      # 0xe720
movl 0x95af(%rip), %edx      # 0xe174
movq %rbx, %rsi
callq 0x761a
testl %eax, %eax
je 0x4bdd
movl %eax, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x4cdc
movslq 0x9e6c(%rip), %rax      # 0xea50
testq %rax, %rax
je 0x4c09
movq 0x9b30(%rip), %rcx      # 0xe720
leaq (%rax,%rax,4), %rax
leaq (%rcx,%rax,8), %rsi
leaq (%rcx,%rax,8), %rdi
addq $-0x28, %rdi
callq 0x7a84
testl %eax, %eax
jne 0x4c0f
incl 0x9e41(%rip)            # 0xea50
popq %rbx
retq
leaq 0x4521(%rip), %rdi      # 0x9139
movq %rbx, %rsi
callq 0x42d0
movl $0x2, %edi
callq 0x41c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9e17(%rip), %r12      # 0xea58
movslq 0x9e18(%rip), %rax      # 0xea60
cmpq %rax, %rbx
jl 0x4c5b
movq %r12, %rdi
movl %ebx, %esi
callq 0x4e3a
testl %eax, %eax
jne 0x4cc3
movq %r15, %rdi
callq 0x4090
cmpl $-0x1, %eax
je 0x4c7c
cmpl $0xa, %eax
je 0x4ca8
movq 0x9de4(%rip), %rcx      # 0xea58
movb %al, (%rcx,%rbx)
incq %rbx
jmp 0x4c41
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rbx, %rbx
je 0x4cb7
movq 0x9343(%rip), %rax      # 0xdfd0
movq (%rax), %rdi
leaq 0x44f9(%rip), %rsi      # 0x9190
leaq 0x44c3(%rip), %rdx      # 0x9161
movq %r14, %rcx
xorl %eax, %eax
callq 0x4200
movq 0x9da9(%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 0x4481(%rip), %rdi      # 0x914b
movq %r14, %rsi
callq 0x42d0
movl $0x2, %edi
callq 0x41c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x44b0
jmp 0x2439
movq %rbx, %rdi
callq 0x79aa
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 0x812c
jmp 0x24a1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x41b2
jmp 0x24a1
movsd (%r14), %xmm0
movsd %xmm0, (%rbx)
jmp 0x24a1
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x847a
jmp 0x24a1
movb (%r14), %al
movb %al, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x699d
// File: /workspace/github_cpp_makefile_star2_O1/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 0x42df
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6a1c
movl $0x28, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x516b(%rip), %rsi      # 0x9467
leaq 0x5179(%rip), %rdx      # 0x947c
leaq 0x8(%rsp), %rdi
callq 0x81bc
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x69a8
xorl %ebp, %ebp
leaq 0x9932(%rip), %rsi      # 0xdc58
leaq 0x26c5(%rip), %rdx      # 0x69f2
movq %rbx, %rdi
callq 0x2230
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x434f
callq 0x2170
jmp 0x434f
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x435c
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4393
cmpl $0x2, %eax
je 0x438c
cmpl $0x1, %eax
jne 0x4391
movq (%rdi), %rax
addq $0x10, %rdi
cmpq %rdi, %rax
je 0x4391
movq %rax, %rdi
popq %rax
jmp 0x2170
callq 0x79aa
popq %rax
retq
popq %rax
jmp 0x44b0
movq %rax, %rdi
callq 0x699d
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x43d0
movq %rdx, %rbx
callq 0x71ee
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 0x507a(%rip), %rsi      # 0x9467
leaq 0x5088(%rip), %rdx      # 0x947c
leaq 0x8(%rsp), %rdi
callq 0x81bc
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x69a8
xorl %ebp, %ebp
leaq 0x9841(%rip), %rsi      # 0xdc58
leaq 0x25d4(%rip), %rdx      # 0x69f2
movq %rbx, %rdi
callq 0x2230
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4440
callq 0x2170
jmp 0x4440
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x444d
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/benjibc[P]json-universal-container/./json.h
// Function: JSON::JSON(JSON const&)
inline
JSON::JSON(const JSON & rhs)
{
    this->m_type = rhs.m_type;
    switch(m_type)
    {
        // for classes that copies memory dynamically, make a deep copy
        // using placement new instead of using memcpy otherwise things will
        // be deallocated as expected when the last object dies
        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;
    }
}

// Assembly:
movl 0x28(%rsi), %eax
movl %eax, 0x28(%rdi)
decl %eax
cmpl $0x3, %eax
ja 0x44aa
leaq 0x4bee(%rip), %rcx      # 0x9058
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
jmp 0x812c
jmp 0x41b2
movsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
retq
pushq %rax
leaq 0x7(%rsp), %rdx
callq 0x847a
addq $0x8, %rsp
retq
movb (%rsi), %al
movb %al, (%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/benjibc[P]json-universal-container/./json.h
// Function: JSON::operator[](char const*)
inline
JSON & JSON::operator[](const char *key)
{
    //turn itself into an array 
    if(m_type != type_obj)
    {
        this->clear();
        m_type = type_obj;
        new (&(m_data.u_map)) Map_t();
    }
    auto it = m_data.u_map.find(key);
    if(it == m_data.u_map.end())
        m_data.u_map[key] = JSON();
    return m_data.u_map[key];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x28(%rdi), %eax
cmpl $0x1, %eax
je 0x4534
cmpl $0x2, %eax
je 0x456c
cmpl $0x3, %eax
jne 0x4545
movq %rbx, %rdi
callq 0x44b0
jmp 0x4545
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
je 0x4545
callq 0x2170
movl $0x2, 0x28(%rbx)
xorl %eax, %eax
movq %rax, (%rbx)
movq $0x10, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movb $0x0, 0x19(%rbx)
movl $0x3f800000, 0x1c(%rbx) # imm = 0x3F800000
movq %rax, 0x20(%rbx)
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %r14, %rsi
callq 0x20b0
leaq 0x10(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x7a76
movq %rax, %r15
leaq 0x20(%rsp), %rbp
movq -0x10(%rbp), %rdi
cmpq %rbp, %rdi
je 0x45a4
callq 0x2170
testq %r15, %r15
je 0x45f0
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %r14, %rsi
callq 0x20b0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x71ee
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x45da
callq 0x2170
addq $0x20, %rbx
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x0, 0x38(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x20b0
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x71ee
movq %rax, %r15
leaq 0x20(%rax), %r12
cmpq %r13, %r12
je 0x4698
movl 0x48(%r15), %eax
cmpl $0x1, %eax
je 0x464a
cmpl $0x2, %eax
je 0x4640
cmpl $0x3, %eax
jne 0x465f
movq %r12, %rdi
callq 0x44b0
jmp 0x465f
movq %r12, %rdi
callq 0x79aa
jmp 0x465f
movq 0x20(%r15), %rdi
movq %r15, %rax
addq $0x30, %rax
cmpq %rax, %rdi
je 0x465f
callq 0x2170
movq 0x30(%rsp), %rax
movq %rax, 0x20(%r12)
movaps 0x10(%rsp), %xmm0
movaps 0x20(%rsp), %xmm1
movups %xmm1, 0x10(%r12)
movups %xmm0, (%r12)
movl 0x38(%rsp), %eax
movl %eax, 0x48(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x2c(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x46ab
callq 0x2170
movl 0x38(%rsp), %eax
cmpl $0x3, %eax
je 0x46e9
cmpl $0x2, %eax
je 0x46da
cmpl $0x1, %eax
jne 0x45a9
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x45a9
callq 0x2170
jmp 0x45a9
leaq 0x10(%rsp), %rdi
callq 0x79aa
jmp 0x45a9
leaq 0x10(%rsp), %rdi
callq 0x44b0
jmp 0x45a9
jmp 0x46fa
movq %rax, %rdi
callq 0x699d
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x471d
callq 0x2170
jmp 0x471d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4364
jmp 0x4755
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
jne 0x474b
jmp 0x4755
jmp 0x4752
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4755
callq 0x2170
jmp 0x4755
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/benjibc[P]json-universal-container/./json.h
// Function: JSON::operator[](int)
inline
JSON & JSON::operator[](int i)
{
    //turn itself into an array 
    if(m_type != type_array)
    {
        this->clear();
        m_type = type_array;
        new (&(m_data.u_arr)) Arr_t(); 
    }
    //need to return the element at the given index
    int arrayOldSize = m_data.u_arr.size(); 
    //make sure the size of the arrray is big enough 
    if(i >= arrayOldSize) 
    {
        Arr_t append ( i-arrayOldSize +1);
        m_data.u_arr.insert(m_data.u_arr.end(),append.begin(),append.end()); 
    }
    return m_data.u_arr[i];
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl 0x28(%rdi), %eax
cmpl $0x1, %eax
je 0x4787
cmpl $0x3, %eax
je 0x47ad
cmpl $0x2, %eax
jne 0x4798
movq %rbx, %rdi
callq 0x79aa
jmp 0x4798
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
je 0x4798
callq 0x2170
movl $0x3, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movl 0x8(%rbx), %eax
cmpl %ebp, %eax
jg 0x481f
movl %ebp, %ecx
subl %eax, %ecx
incl %ecx
movslq %ecx, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x7ab0
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x4815
movq 0x8(%rsp), %rax
leaq (%rdx,%rdx,2), %rdi
shlq $0x4, %rdi
addq %rax, %rdi
movq 0x8(%rbx), %rcx
leaq (%rcx,%rcx,2), %rsi
shlq $0x4, %rsi
addq (%rbx), %rsi
leaq 0x956f(%rip), %r8       # 0xdd68
leaq 0x20(%rsp), %rcx
movq %r8, (%rcx)
movq %rbx, 0x8(%rcx)
movq %rax, 0x10(%rcx)
movq %rdi, 0x18(%rcx)
movq %rbx, %rdi
callq 0x6aee
leaq 0x8(%rsp), %rdi
callq 0x44b0
movslq %ebp, %rax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq (%rbx), %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0x699d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x44b0
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/benjibc[P]json-universal-container/./boost_file/boost/container/vector.hpp
// Function: void boost::container::vector<JSON, std::allocator<JSON>>::priv_push_back<JSON const&>(JSON const&)
void priv_push_back(BOOST_MOVE_CATCH_FWD(U) x)
   {
      if (this->members_.m_size < this->members_.m_capacity){
         //There is more memory, just construct a new object at the end
         allocator_traits_type::construct
            ( this->alloc()
            , container_detail::to_raw_pointer(this->members_.m_start + this->members_.m_size)
            , ::boost::forward<U>(x) );
         ++this->members_.m_size;
      }
      else{
         this->insert(this->cend(), ::boost::forward<U>(x));
      }
   }

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
leaq (%rax,%rax,2), %rsi
shlq $0x4, %rsi
addq (%rdi), %rsi
cmpq 0x10(%rdi), %rax
jae 0x6a4a
movq %rbx, %rdi
callq 0x6a82
incq 0x8(%rbx)
jmp 0x6a7b
leaq 0x722f(%rip), %rax      # 0xdc80
movq %rsp, %rcx
movq %rax, (%rcx)
movq %rbx, 0x8(%rcx)
movq %rdx, 0x10(%rcx)
movq $0x1, 0x18(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rcx)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x6aee
addq $0x30, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/benjibc[P]json-universal-container/./boost_file/boost/container/detail/advanced_insert_int.hpp
// Function: boost::container::container_detail::advanced_insert_aux_proxy<std::allocator<JSON>, boost::container::constant_iterator<JSON, long>, JSON*>::uninitialized_copy_some_and_update(JSON*, long, bool)
virtual void uninitialized_copy_some_and_update(Iterator pos, difference_type division_count, bool first_n)
   {
      FwdIt mid = this->first_;
      std::advance(mid, division_count);
      if(first_n){
         ::boost::container::uninitialized_copy_or_move_alloc(this->a_, this->first_, mid, pos);
         this->first_ = mid;
      }
      else{
         ::boost::container::uninitialized_copy_or_move_alloc(this->a_, mid, this->last_, pos);
         this->last_ = mid;
      }
   }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %r12
movq 0x10(%rdi), %r15
movq 0x18(%rdi), %rax
movq %rax, %r13
subq %rdx, %r13
testl %ecx, %ecx
je 0x6c83
movq 0x18(%rbx), %rbp
cmpq %r13, %rbp
je 0x6c79
addq %rdx, %rbp
subq %rax, %rbp
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6a82
addq $0x30, %r14
decq %rbp
jne 0x6c62
movq %r15, 0x10(%rbx)
addq $0x18, %rbx
jmp 0x6cb1
movq 0x28(%rbx), %rbp
cmpq %rbp, %r13
je 0x6ca9
addq %rdx, %rbp
subq %rax, %rbp
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6a82
addq $0x30, %r14
incq %rbp
jne 0x6c92
movq %r15, 0x20(%rbx)
addq $0x28, %rbx
movq %r13, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/benjibc[P]json-universal-container/./boost_file/boost/container/detail/advanced_insert_int.hpp
// Function: boost::container::container_detail::advanced_insert_aux_proxy<std::allocator<JSON>, boost::container::container_detail::vector_iterator<JSON*>, JSON*>::copy_some_and_update(JSON*, long, bool)
virtual void copy_some_and_update(Iterator pos, difference_type division_count, bool first_n)
   {
      FwdIt mid = this->first_;
      std::advance(mid, division_count);
      if(first_n){
         ::boost::copy_or_move(this->first_, mid, pos);
         this->first_ = mid;
      }
      else{
         ::boost::copy_or_move(mid, this->last_, pos);
         this->last_ = mid;
      }
   }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq (%rdx,%rdx,2), %r13
shlq $0x4, %r13
addq 0x10(%rdi), %r13
testl %ecx, %ecx
je 0x7eeb
movq 0x10(%rbx), %r15
movq %r13, %rax
subq %r15, %rax
testq %rax, %rax
jle 0x7ee5
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
movq %rdx, %r12
shrq $0x5, %r12
incq %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x23f8
addq $0x30, %r15
addq $0x30, %r14
decq %r12
cmpq $0x1, %r12
jg 0x7ec9
movq %r13, 0x10(%rbx)
jmp 0x7f31
movq 0x18(%rbx), %rax
subq %r13, %rax
testq %rax, %rax
jle 0x7f2d
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
movq %rdx, %r15
shrq $0x5, %r15
incq %r15
movq %r13, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x23f8
addq $0x30, %r12
addq $0x30, %r14
decq %r15
cmpq $0x1, %r15
jg 0x7f11
movq %r13, 0x18(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/benjibc[P]json-universal-container/./boost_file/boost/move/move.hpp
// Function: JSON* boost::move_backward<JSON*, JSON*>(JSON*, JSON*, JSON*)
O move_backward(I f, I l, O result)
   {
      while (f != l) {
         --l; --result;
         *result = ::boost::move(*l);
      }
      return result;
   }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
cmpq %rdi, %rsi
je 0x717f
movq %rsi, %r15
movq %rdi, %r14
addq $-0x30, %rbx
leaq 0x30(%rbx), %rax
leaq -0x30(%r15), %r12
cmpq %rax, %r15
je 0x716b
movl 0x28(%rbx), %eax
cmpl $0x1, %eax
je 0x7124
cmpl $0x2, %eax
je 0x711a
cmpl $0x3, %eax
jne 0x7135
movq %rbx, %rdi
callq 0x44b0
jmp 0x7135
movq %rbx, %rdi
callq 0x79aa
jmp 0x7135
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rdi, %rax
je 0x7135
callq 0x2170
movq 0x20(%r12), %rax
movq %rax, 0x20(%rbx)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movl -0x8(%r15), %eax
movl %eax, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1c(%r12)
movups %xmm0, 0x10(%r12)
movups %xmm0, (%r12)
addq $-0x30, %rbx
movq %r12, %r15
cmpq %r14, %r12
jne 0x70f1
addq $0x30, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x699d
// File: /workspace/github_cpp_makefile_star2_O1/benjibc[P]json-universal-container/./boost_file/boost/unordered/detail/buckets.hpp
// Function: boost::unordered::detail::node_constructor<std::allocator<boost::unordered::detail::ptr_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, JSON>>>>::construct_node()
void node_constructor<Alloc>::construct_node()
    {
        if(!node_) {
            constructed_ = false;
            node_ = node_allocator_traits::allocate(alloc_, 1);
        }
        else if (constructed_) {
            boost::unordered::detail::destroy_node(alloc_,
                boost::addressof(*node_));
            constructed_ = false;
        }
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x74e9
cmpb $0x1, 0x10(%rbx)
jne 0x74fb
movq (%rbx), %rdi
callq 0x762c
movb $0x0, 0x10(%rbx)
jmp 0x74fb
movb $0x0, 0x10(%rbx)
movl $0x60, %edi
callq 0x2190
movq %rax, 0x8(%rbx)
popq %rbx
retq
nop