LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 2>::operator|(MRXADA002::Audio<signed char, 2> const&)
Audio<T, 2> operator|(const Audio<T,2> & rhs) {
            Audio<T, 2> a(*this);                       //use copy constructor on lhs audio
            for (int i = 0; i < rhs.data_vector.size(); ++i) {
                a.data_vector.push_back(rhs.data_vector[i]);         //append rhs's values onto data_vector
            }
            return a;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x7c38
movl 0x18(%r15), %eax
movl %eax, 0x18(%rbx)
movq (%r14), %rdx
cmpq %rdx, 0x8(%r14)
je 0x671e
xorl %r15d, %r15d
xorl %r12d, %r12d
addq %r15, %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x66fd
movzwl (%rdx), %eax
movw %ax, (%rsi)
addq $0x2, 0x8(%rbx)
jmp 0x6705
movq %rbx, %rdi
callq 0x808e
incq %r12
movq (%r14), %rdx
movq 0x8(%r14), %rax
subq %rdx, %rax
sarq %rax
addq $0x2, %r15
cmpq %r12, %rax
ja 0x66e3
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x673a
callq 0x2120
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 1>::operator*(std::pair<float, float>)
Audio<T, N> operator*( std::pair<float, float> rhs) {
            Audio<T, N> a(*this);               //use copy constructor
            for (int i = 0; i < a.data_vector.size(); ++i) {
                a.data_vector[i]*=rhs.first; //scale amplitude
            }
            return a;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movaps %xmm0, -0x20(%rbp)
movq %rsi, %r14
movq %rdi, %rbx
callq 0x7800
movaps -0x20(%rbp), %xmm1
movl 0x18(%r14), %eax
movl %eax, 0x18(%rbx)
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x6828
xorl %ecx, %ecx
movsbl (%rax,%rcx), %edx
xorps %xmm0, %xmm0
cvtsi2ss %edx, %xmm0
mulss %xmm1, %xmm0
cvttss2si %xmm0, %edx
movb %dl, (%rax,%rcx)
incq %rcx
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
subq %rax, %rdx
cmpq %rcx, %rdx
ja 0x6800
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 2>::operator*(std::pair<float, float>)
Audio<T, 2> operator*( std::pair<float, float> rhs) {
            Audio<T, 2> a(*this);                       //use copy constructor
            for (int i = 0; i < a.data_vector.size(); ++i) {
                a.data_vector[i].first*=rhs.first;  //scale amplitude
                a.data_vector[i].second*=rhs.second;
            }
            return a;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movaps %xmm0, -0x20(%rbp)
movq %rsi, %r14
movq %rdi, %rbx
callq 0x7c38
movaps -0x20(%rbp), %xmm2
movl 0x18(%r14), %eax
movl %eax, 0x18(%rbx)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
je 0x691b
sarq %rcx
movaps %xmm2, %xmm0
shufps $0x55, %xmm2, %xmm0     # xmm0 = xmm0[1,1],xmm2[1,1]
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
movsbl (%rax,%rdx,2), %esi
xorps %xmm1, %xmm1
cvtsi2ss %esi, %xmm1
mulss %xmm2, %xmm1
cvttss2si %xmm1, %esi
movb %sil, (%rax,%rdx,2)
movsbl 0x1(%rax,%rdx,2), %esi
xorps %xmm1, %xmm1
cvtsi2ss %esi, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %esi
movb %sil, 0x1(%rax,%rdx,2)
incq %rdx
cmpq %rdx, %rcx
jne 0x68e3
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 1>::operator^(std::pair<int, int>)
Audio<T, N> operator^(std::pair<int, int> rhs ) {
            Audio<T, N> a;
            for (int i = 0; i < rhs.first; ++i) {
                a.data_vector.push_back(this->data_vector[i]);
            }
            for (int i = rhs.second + 1; i < this->data_vector.size(); ++i) {
                a.data_vector.push_back(this->data_vector[i]);
            }
            return a;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x1, 0x18(%rdi)
testl %r14d, %r14d
jle 0x6a1a
movl %r14d, %r12d
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movq (%r15), %rdx
addq %r13, %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6a0a
movb (%rdx), %al
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x6a12
movq %rbx, %rdi
callq 0x7ec6
incq %r13
cmpq %r13, %r12
jne 0x69f0
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %r14
sarq $0x20, %r14
movq (%r15), %rdx
movq 0x8(%r15), %rax
subq %rdx, %rax
cmpq %r14, %rax
jbe 0x6a5e
addq %r14, %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6a51
movb (%rdx), %al
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x6a59
movq %rbx, %rdi
callq 0x7ec6
incq %r14
jmp 0x6a2b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6a72
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6a82
callq 0x2120
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 2>::operator^(std::pair<int, int>)
Audio<T, 2> operator^(std::pair<int, int> rhs ) {
            Audio<T, 2> a;
            for (int i = 0; i < rhs.first; ++i) {
                a.data_vector.push_back(this->data_vector[i]);
            }
            for (int i = rhs.second + 1; i < this->data_vector.size(); ++i) {
                a.data_vector.push_back(this->data_vector[i]);
            }
            return a;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x2, 0x18(%rdi)
testl %r14d, %r14d
jle 0x6bf6
movl %r14d, %r12d
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movq (%r15), %rdx
addq %r13, %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6be5
movzwl (%rdx), %eax
movw %ax, (%rsi)
addq $0x2, 0x8(%rbx)
jmp 0x6bed
movq %rbx, %rdi
callq 0x808e
addq $0x2, %r13
decq %r12
jne 0x6bc8
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %r14
sarq $0x20, %r14
movq (%r15), %rdx
movq 0x8(%r15), %rax
subq %rdx, %rax
sarq %rax
cmpq %r14, %rax
jbe 0x6c58
leaq (%r14,%r14), %r12
addq %r12, %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6c37
movzwl (%rdx), %eax
movw %ax, (%rsi)
addq $0x2, 0x8(%rbx)
jmp 0x6c3f
movq %rbx, %rdi
callq 0x808e
incq %r14
movq (%r15), %rdx
movq 0x8(%r15), %rax
subq %rdx, %rax
sarq %rax
addq $0x2, %r12
cmpq %r14, %rax
ja 0x6c1d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6c6c
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6c7c
callq 0x2120
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/adameier[P]/./audio.h
// Function: MRXADA002::Audio<short, 1>::ranged_add(MRXADA002::Audio<short, 1> const&, int, int)
Audio<T, N> ranged_add(const Audio<T,N> & rhs, int rangeStart, int rangeEnd) {
            Audio<T, N> range1;
            range1.data_vector.resize(rangeEnd-rangeStart);
            Audio<T, N> range2;
            range2.data_vector.resize(rangeEnd-rangeStart);
            std::copy(this->data_vector.begin()+rangeStart, this->data_vector.begin()+rangeEnd, range1.data_vector.begin());
            std::copy(rhs.data_vector.begin()+rangeStart, rhs.data_vector.begin()+rangeEnd, range2.data_vector.begin());
            Audio<T, N> out = range1 + range2;
            return out;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %r12d
movl %ecx, %r13d
movq %rdx, -0x30(%rbp)
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x70(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x1, 0x18(%rdi)
movl %r8d, %eax
subl %ecx, %eax
movslq %eax, %r14
movq %r14, %rsi
callq 0x788e
leaq -0x50(%rbp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x1, 0x18(%rdi)
movq %r14, %rsi
callq 0x788e
movslq %r13d, %r13
addq %r13, %r13
movslq %r12d, %r12
addq %r12, %r12
movq %r12, %rdx
subq %r13, %rdx
je 0x6f2a
movq (%r15), %rsi
addq %r13, %rsi
movq -0x70(%rbp), %rdi
callq 0x2210
subq %r13, %r12
je 0x6f45
movq -0x30(%rbp), %rax
addq (%rax), %r13
movq -0x50(%rbp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x2210
leaq -0x70(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movq %rbx, %rdi
callq 0x5e28
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x6f63
callq 0x2120
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x6f71
callq 0x2120
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x6f99
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x6f99
callq 0x2120
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x6fa7
callq 0x2120
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O1/adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 2>::ranged_add(MRXADA002::Audio<signed char, 2> const&, int, int)
Audio<T, 2> ranged_add(const Audio<T,2> & rhs, int rangeStart, int rangeEnd) {
            Audio<T, 2> range1;
            range1.data_vector.resize(rangeEnd-rangeStart);
            Audio<T, 2> range2;
            range2.data_vector.resize(rangeEnd-rangeStart);
            std::copy(this->data_vector.begin()+rangeStart, this->data_vector.begin()+rangeEnd, range1.data_vector.begin());
            std::copy(rhs.data_vector.begin()+rangeStart, rhs.data_vector.begin()+rangeEnd, range2.data_vector.begin());
            Audio<T, 2> out = range1 + range2;
            return out;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %r12d
movl %ecx, %r13d
movq %rdx, -0x30(%rbp)
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x70(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x2, 0x18(%rdi)
movl %r8d, %eax
subl %ecx, %eax
movslq %eax, %r14
movq %r14, %rsi
callq 0x7ab0
leaq -0x50(%rbp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x2, 0x18(%rdi)
movq %r14, %rsi
callq 0x7ab0
movslq %r13d, %rax
movslq %r12d, %rcx
movq %rcx, %rdx
subq %rax, %rdx
jle 0x7059
movq -0x70(%rbp), %rsi
leaq (%rax,%rax), %rdi
addq (%r15), %rdi
incq %rdx
xorl %r8d, %r8d
movb (%rdi,%r8), %r9b
movb %r9b, (%rsi,%r8)
movb 0x1(%rdi,%r8), %r9b
movb %r9b, 0x1(%rsi,%r8)
decq %rdx
addq $0x2, %r8
cmpq $0x1, %rdx
jg 0x703a
subq %rax, %rcx
jle 0x7090
movq -0x50(%rbp), %rdx
addq %rax, %rax
movq -0x30(%rbp), %rsi
addq (%rsi), %rax
incq %rcx
xorl %esi, %esi
movb (%rax,%rsi), %dil
movb %dil, (%rdx,%rsi)
movb 0x1(%rax,%rsi), %dil
movb %dil, 0x1(%rdx,%rsi)
decq %rcx
addq $0x2, %rsi
cmpq $0x1, %rcx
jg 0x7071
leaq -0x70(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movq %rbx, %rdi
callq 0x60e0
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x70ae
callq 0x2120
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x70bc
callq 0x2120
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x70e4
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x70e4
callq 0x2120
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x70f2
callq 0x2120
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 2>::rms()
std::pair<double, double> rms() {
            double left = sqrt(std::accumulate(this->data_vector.begin(), this->data_vector.end(), 0.0, [&](double a, std::pair<T,T> b){return a + pow(b.first, 2)/this->data_vector.size();}));
            double right = sqrt(std::accumulate(this->data_vector.begin(), this->data_vector.end(), 0.0, [&](double a, std::pair<T,T> b){return a + pow(b.second, 2)/this->data_vector.size();}));
            std::pair<double, double> ans (left, right);
            return ans;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
cmpq %rcx, %rax
je 0x72b8
movq %rcx, %rdx
subq %rax, %rdx
sarq %rdx
movq %rdx, %xmm0
punpckldq 0x1d8f(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1d97(%rip), %xmm0     # 0x9020
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addsd %xmm0, %xmm2
xorpd %xmm0, %xmm0
movsbl (%rax), %edx
xorps %xmm3, %xmm3
cvtsi2sd %edx, %xmm3
mulsd %xmm3, %xmm3
divsd %xmm2, %xmm3
addsd %xmm3, %xmm0
addq $0x2, %rax
cmpq %rcx, %rax
jne 0x7299
ucomisd %xmm1, %xmm0
jb 0x72c4
sqrtsd %xmm0, %xmm4
jmp 0x72cd
callq 0x20e0
movapd %xmm0, %xmm4
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
cmpq %rcx, %rax
je 0x732f
movq %rcx, %rdx
subq %rax, %rdx
sarq %rdx
movq %rdx, %xmm0
punpckldq 0x1d19(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1d21(%rip), %xmm0     # 0x9020
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addsd %xmm0, %xmm2
xorpd %xmm0, %xmm0
movsbl 0x1(%rax), %edx
xorps %xmm3, %xmm3
cvtsi2sd %edx, %xmm3
mulsd %xmm3, %xmm3
divsd %xmm2, %xmm3
addsd %xmm3, %xmm0
addq $0x2, %rax
cmpq %rcx, %rax
jne 0x730f
ucomisd %xmm1, %xmm0
jb 0x733e
xorps %xmm1, %xmm1
sqrtsd %xmm0, %xmm1
jmp 0x7351
movsd %xmm4, -0x10(%rbp)
callq 0x20e0
movsd -0x10(%rbp), %xmm4
movapd %xmm0, %xmm1
movapd %xmm4, %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 1>::normalize(std::pair<double, double>)
Audio<T, N> normalize(std::pair<double, double> rms) {
            Audio<T, N> a(*this);
            Normalize functor(rms.first);
            std::transform(this->data_vector.begin(), this->data_vector.end(), a.data_vector.begin(), functor);
            return a;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, -0x18(%rbp)
movq %rsi, %r14
movq %rdi, %rbx
callq 0x7800
movsd -0x18(%rbp), %xmm1
movl 0x18(%r14), %eax
movl %eax, 0x18(%rbx)
movq (%r14), %rax
movq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x74cc
movq (%rbx), %rdx
movsbl (%rax), %esi
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %esi
cmpl $0x7f, %esi
jl 0x74be
movl $0x7f, %esi
movb %sil, (%rdx)
incq %rax
incq %rdx
cmpq %rcx, %rax
jne 0x74a2
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/adameier[P]/./audio.h
// Function: MRXADA002::Audio<signed char, 2>::normalize(std::pair<double, double>)
Audio<T, 2> normalize(std::pair<double, double> rms) {
            Audio<T, 2> a(*this);
            Normalize functor(rms);
            std::transform(this->data_vector.begin(), this->data_vector.end(), a.data_vector.begin(), functor);
            return a;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movsd %xmm0, (%r15)
movsd %xmm1, 0x8(%r15)
callq 0x7c38
movl 0x18(%r14), %eax
movl %eax, 0x18(%rbx)
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq (%rbx), %rdx
movq %r15, %rcx
callq 0x823d
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x75a8
callq 0x2120
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/rksdna[P]json/main.cpp
// Function: main
int main(int argc, char *argv[])
{
    json::writer writer;
    auto read = [&writer](json::item item, const std::string &data, std::size_t row, std::size_t column)
    {
        writer.write(item, data, std::ostream_iterator<char>(std::cout));
    };

    try
    {
        std::ifstream input("sample.json");

        json::reader reader(read);
        reader.read(std::istream_iterator<char>(input), std::istream_iterator<char>());
    }
    catch(json::exception &e)
    {
        std::cerr << e.what() << " at " << e.row() << ":" << e.column() << std::endl;
    }

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x350, %rsp            # imm = 0x350
leaq 0xf8(%rsp), %rbx
movq $0x2, -0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x40(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2c9e
leaq 0x3a7b(%rip), %rsi      # 0x61ca
leaq 0x148(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x2250
movq %rsp, %rsi
xorps %xmm0, %xmm0
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
leaq 0xf0(%rsp), %rax
movq %rax, (%rsi)
leaq 0x1c3(%rip), %rax       # 0x2946
movq %rax, 0x18(%rsi)
leaq 0x1ea(%rip), %rax       # 0x2978
movq %rax, 0x10(%rsi)
leaq 0x40(%rsp), %rdi
callq 0x299e
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x27b3
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x20(%rsp), %rdi
movq %r14, (%rdi)
movb $0x1, 0x9(%rdi)
callq 0x4240
leaq 0x30(%rsp), %rdx
movq $0x0, (%rdx)
movw $0x0, 0x8(%rdx)
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2a3e
leaq 0xc8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2806
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x2180
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x2e14
movq -0x10(%r14), %rax
testq %rax, %rax
je 0x282b
leaq 0x40(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x148(%rsp), %rdi
callq 0x2050
movq %rbx, %rdi
callq 0x2e64
xorl %eax, %eax
addq $0x350, %rsp            # imm = 0x350
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2851
movq %rax, %rdi
callq 0x2c92
movq %rdx, %r15
movq %rax, %r14
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2892
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x2892
jmp 0x2851
movq %rdx, %r15
movq %rax, %r14
jmp 0x289f
movq %rdx, %r15
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x2c4a
leaq 0x148(%rsp), %rdi
callq 0x2050
cmpl $0x1, %r15d
jne 0x2931
movq %r14, %rdi
callq 0x2090
movq %rax, %r14
movq (%rax), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq 0x672c(%rip), %rdi      # 0x8ff0
movq %rax, %rsi
callq 0x2160
movq %rax, %r15
leaq 0x3900(%rip), %rsi      # 0x61d6
movl $0x4, %edx
movq %rax, %rdi
callq 0x2190
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x20f0
movq %rax, %r15
leaq 0x38e2(%rip), %rsi      # 0x61db
movl $0x1, %edx
movq %rax, %rdi
callq 0x2190
movq 0x18(%r14), %rsi
movq %r15, %rdi
callq 0x20f0
movq %rax, %rdi
callq 0x20b0
callq 0x2200
jmp 0x2838
movq %rax, %r14
jmp 0x2931
movq %rax, %r14
callq 0x2200
movq %rbx, %rdi
callq 0x2e64
movq %r14, %rdi
callq 0x2220
jmp 0x2851
// File: /workspace/github_cpp_makefile_star2_O1/wenleix[P]EdgePPR/src/GenCSRMatrix.cpp
// Function: main
int main(int argc, char **argv) {
	if (argc != 4) {
		fprintf(stderr, "Usage: %s [ParamGraph.txt] [CSC-Prefix] [CSC-Suffix]\n", argv[0]);
		return 1;
	}

	FILE *gfile = fopen(argv[1], "r");
	char *cscPrefix = argv[2];
    char *suffix = argv[3];

	ParamGraph *g = ParamGraph::ReadTextFile(gfile);
	for (int i = 0; i < ParamGraph_NumEdgeTypes; i++) {
		char fnameBuf[1000];
		sprintf(fnameBuf, "%s%d.%s", cscPrefix, i, suffix);
        if (strcmp(suffix, "txt") == 0) {
		    FILE *cscFile = fopen(fnameBuf, "w");
		    GenCscFile(g, i, cscFile);
            fclose(cscFile);
        } else if (strcmp(suffix, "bin") == 0) {
		    FILE *cscFile = fopen(fnameBuf, "wb");
		    GenBinCscFile(g, i, cscFile);
            fclose(cscFile);
        } else {
            fprintf(stderr, "Unsupported file format: %s !\n", suffix);
            assert(false);
        }
	}


	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3e8, %rsp            # imm = 0x3E8
movq %rsi, %rbx
cmpl $0x4, %edi
jne 0x1a7c
movq 0x8(%rbx), %rdi
leaq 0x1753(%rip), %rsi      # 0x3106
callq 0x1100
movq 0x10(%rbx), %r14
movq 0x18(%rbx), %rbx
movq %rax, %rdi
callq 0x1d74
movq %rax, %r15
movq %rsp, %r13
xorl %r12d, %r12d
movq %r13, %rdi
leaq 0x172d(%rip), %rsi      # 0x3108
movq %r14, %rdx
movl %r12d, %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
leaq 0x171b(%rip), %rsi      # 0x3110
callq 0x1140
testl %eax, %eax
je 0x1a33
movq %rbx, %rdi
leaq 0x170e(%rip), %rsi      # 0x3116
callq 0x1140
testl %eax, %eax
jne 0x1a8b
movq %r13, %rdi
leaq 0x16ff(%rip), %rsi      # 0x311a
callq 0x1100
movq %rax, %rbp
movq %r15, %rdi
movl %r12d, %esi
movq %rax, %rdx
callq 0x1678
jmp 0x1a53
movq %r13, %rdi
leaq 0x16d7(%rip), %rsi      # 0x3114
callq 0x1100
movq %rax, %rbp
movq %r15, %rdi
movl %r12d, %esi
movq %rax, %rdx
callq 0x139c
movq %rbp, %rdi
callq 0x10c0
incl %r12d
cmpl $0x7, %r12d
jne 0x19d1
xorl %eax, %eax
addq $0x3e8, %rsp            # imm = 0x3E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x11f0
movl $0x1, %eax
jmp 0x1a6a
movq %rbx, %rdi
callq 0x120e
nop
// File: /workspace/github_cpp_makefile_star2_O1/shijiajia[P]TinyMudo/./TcpConnection.h
// Function: TinyMuduo::TcpConnection::HandleEvent()
virtual void HandleEvent()
	{
		char buf[1024];
		memset(buf,0,sizeof(buf));
		int n=read(m_nConnFd,buf,1024);
		if (n<0)
		{
			std::cout<<"read error errno"<<errno<<std::endl;
			close(m_nConnFd);
		}else if (n==0)
		{
			std::cout<<"client close"<<std::endl;
			close(m_nConnFd);
		}else{
			if (write(m_nConnFd,buf,n)!=n)
				std::cout<<"write error errno:"<<errno<<std::endl;;
		}
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rbx
movq %rsp, %r14
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0x2100
movl 0xc(%rbx), %edi
movl $0x400, %edx            # imm = 0x400
movq %r14, %rsi
callq 0x21c0
movq %rax, %r14
testl %r14d, %r14d
js 0x2544
je 0x2576
movl 0xc(%rbx), %edi
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
movq %rsp, %rsi
movq %r14, %rdx
callq 0x2090
cmpq %r14, %rax
jne 0x25ca
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
retq
movq 0x2a8d(%rip), %r14      # 0x4fd8
leaq 0xb06(%rip), %rsi       # 0x3058
movl $0x10, %edx
movq %r14, %rdi
callq 0x21a0
callq 0x2040
movl (%rax), %esi
movq %r14, %rdi
callq 0x2200
movq %rax, %r14
movq (%rax), %rax
jmp 0x2594
movq 0x2a5b(%rip), %r14      # 0x4fd8
leaq 0xae5(%rip), %rsi       # 0x3069
movl $0xc, %edx
movq %r14, %rdi
callq 0x21a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2130
movl 0xc(%rbx), %edi
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
jmp 0x2240
movq 0x2a07(%rip), %rbx      # 0x4fd8
leaq 0xa9e(%rip), %rsi       # 0x3076
movl $0x12, %edx
movq %rbx, %rdi
callq 0x21a0
callq 0x2040
movl (%rax), %esi
movq %rbx, %rdi
callq 0x2200
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
jmp 0x2130
// File: /workspace/github_cpp_makefile_star2_O1/shijiajia[P]TinyMudo/Acceptor.cpp
// Function: TinyMuduo::Acceptor::Start()
void Acceptor::Start()
{
	SocketAndBind();
	m_pChannel=new Channel(m_nEpollfd,m_nListenFd);
	m_pChannel->SetCallBack(this);
	m_pChannel->EableReading();
	if (listen(m_nListenFd,BACKLOG)<0) std::cout<<"listen failed: errno"<<errno<<std::endl;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x26c6
movl $0x18, %edi
callq 0x2170
movl 0x18(%rbx), %ecx
movl 0x28(%rbx), %edx
movl %ecx, (%rax)
movl %edx, 0x4(%rax)
movq %rax, 0x30(%rbx)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x242c
movq 0x30(%rbx), %rdi
callq 0x2432
movl 0x28(%rbx), %edi
movl $0x5, %esi
callq 0x2190
testl %eax, %eax
js 0x2671
popq %rbx
retq
movq 0x2960(%rip), %rbx      # 0x4fd8
leaq 0xa0a(%rip), %rsi       # 0x3089
movl $0x14, %edx
movq %rbx, %rdi
callq 0x21a0
callq 0x2040
movl (%rax), %esi
movq %rbx, %rdi
callq 0x2200
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
jmp 0x2130
// File: /workspace/github_cpp_makefile_star2_O1/shijiajia[P]TinyMudo/Acceptor.cpp
// Function: TinyMuduo::Acceptor::SocketAndBind()
void Acceptor::SocketAndBind()
{
	int on=1;
	if ((m_nListenFd=socket(AF_INET, SOCK_STREAM, 0))<0) 
		std::cout<<"Socket Failed errno:"<<errno<<std::endl;
	setsockopt(m_nListenFd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
	fcntl(m_nListenFd,F_SETFL,O_NONBLOCK);
	m_sServerAddr.sin_family = AF_INET;
	m_sServerAddr.sin_addr.s_addr = htonl(INADDR_ANY);
	m_sServerAddr.sin_port = htons(PORT);
	if (bind(m_nListenFd,(struct sockaddr *)&m_sServerAddr,sizeof(m_sServerAddr))<0) 
		std::cout<<"Socket Failed errno:"<<errno<<std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, 0x4(%rsp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2060
movl %eax, 0x28(%rbx)
testl %eax, %eax
jns 0x2741
movq 0x28e4(%rip), %r14      # 0x4fd8
leaq 0x9a3(%rip), %rsi       # 0x309e
movl $0x14, %edx
movq %r14, %rdi
callq 0x21a0
callq 0x2040
movl (%rax), %esi
movq %r14, %rdi
callq 0x2200
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2130
movl 0x28(%rbx), %edi
leaq 0x4(%rsp), %rcx
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x2220
movl 0x28(%rbx), %edi
movl $0x4, %esi
movl $0x800, %edx            # imm = 0x800
xorl %eax, %eax
callq 0x2110
leaq 0x8(%rbx), %rsi
movq $0x53220002, 0x8(%rbx)  # imm = 0x53220002
movl 0x28(%rbx), %edi
movl $0x10, %edx
callq 0x2050
testl %eax, %eax
jns 0x27e3
movq 0x2842(%rip), %rbx      # 0x4fd8
leaq 0x901(%rip), %rsi       # 0x309e
movl $0x14, %edx
movq %rbx, %rdi
callq 0x21a0
callq 0x2040
movl (%rax), %esi
movq %rbx, %rdi
callq 0x2200
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2130
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/shijiajia[P]TinyMudo/TcpServer.cpp
// Function: TinyMuduo::TcpServer::Start()
void TcpServer::Start()
{
	m_pAcceptor=new Acceptor(m_nEpollFd);
	m_pAcceptor->SetCallBack(this);
	m_pAcceptor->Start();
	for(;;)
	{
		int nfds=epoll_wait(m_nEpollFd,m_aEpollEvents,MAXEPOLLEVENTS,-1);
		vector< Channel *> vChannel;
		for (int i=0;i<nfds;i++)
		{
			Channel * pTemp=static_cast<Channel *> (m_aEpollEvents[i].data.ptr);
			pTemp->SetRevent(m_aEpollEvents[i].events);
			vChannel.push_back(pTemp);
		}
		for (int i=0;i<vChannel.size();i++)
		{
			vChannel[i]->HandleEvent();
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl $0x38, %edi
callq 0x2170
movl 0x8(%rbx), %ecx
leaq 0x2507(%rip), %rdx      # 0x4d18
movq %rdx, (%rax)
movl %ecx, 0x18(%rax)
movq %rax, 0x2ef0(%rbx)
movq %rbx, 0x20(%rax)
movq %rax, %rdi
callq 0x2628
leaq 0xc(%rbx), %r14
movq %rsp, %r15
leaq 0x20(%rsp), %r12
movl 0x8(%rbx), %edi
movq %r14, %rsi
movl $0x3e8, %edx            # imm = 0x3E8
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x20e0
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
testl %eax, %eax
jle 0x28ae
movl %eax, %eax
shlq $0x2, %rax
leaq (%rax,%rax,2), %r13
xorl %ebp, %ebp
movq 0x10(%rbx,%rbp), %rdi
movq %rdi, 0x20(%rsp)
movl 0xc(%rbx,%rbp), %esi
callq 0x2498
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x289a
movq 0x20(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rsp)
jmp 0x28a5
movq %r15, %rdi
movq %r12, %rdx
callq 0x2b14
addq $0xc, %rbp
cmpq %rbp, %r13
jne 0x286b
movq (%rsp), %rdi
cmpq %rdi, 0x8(%rsp)
je 0x28dd
xorl %r13d, %r13d
movq (%rdi,%r13,8), %rdi
callq 0x2488
incq %r13
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %r13, %rax
ja 0x28bc
testq %rdi, %rdi
je 0x2836
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
jmp 0x2836
jmp 0x28fa
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2913
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O1/shijiajia[P]TinyMudo/./Acceptor.h
// Function: TinyMuduo::Acceptor::HandleEvent()
virtual void HandleEvent()
	{
		std::cout<<"Acceptor::HandleEvent()"<<std::endl;
		struct sockaddr_in cliaddr;
		socklen_t clilen=sizeof(cliaddr);
		memset(&cliaddr,0,sizeof(cliaddr));
		int connFd=accept(m_nListenFd,(struct sockaddr *)&cliaddr,&clilen);
		if(connFd<0) std::cout<<"Accept failed errno:"<<errno<<std::endl;
		else
		{
			std::cout << "new connection from " 
	                     << "[" << inet_ntoa(cliaddr.sin_addr) 
	                     << ":" << ntohs(cliaddr.sin_port) << "]" 
	                     << " accept socket fd:" << connFd 
	                     << std::endl;
	        fcntl(connFd,F_SETFL,O_NONBLOCK);
	        m_pIAcceptorCallBack->NewConnection(connFd);
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x26a8(%rip), %r14      # 0x4fd8
leaq 0x7af(%rip), %rsi       # 0x30e6
movl $0x17, %edx
movq %r14, %rdi
callq 0x21a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2130
leaq 0xc(%rsp), %rdx
movl $0x10, (%rdx)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movl 0x28(%rbx), %edi
callq 0x2080
testl %eax, %eax
js 0x29eb
movl %eax, %ebp
movq 0x2642(%rip), %r14      # 0x4fd8
leaq 0x776(%rip), %rsi       # 0x3113
movl $0x14, %edx
movq %r14, %rdi
callq 0x21a0
leaq 0x777(%rip), %rsi       # 0x3128
movl $0x1, %edx
movq %r14, %rdi
callq 0x21a0
movl 0x14(%rsp), %edi
callq 0x20d0
testq %rax, %rax
je 0x2a44
movq %rax, %r15
movq %rax, %rdi
callq 0x20c0
movq 0x25fa(%rip), %rdi      # 0x4fd8
movq %r15, %rsi
movq %rax, %rdx
callq 0x21a0
jmp 0x2a5c
movq 0x25e6(%rip), %rbx      # 0x4fd8
leaq 0x705(%rip), %rsi       # 0x30fe
movl $0x14, %edx
movq %rbx, %rdi
callq 0x21a0
callq 0x2040
movl (%rax), %esi
movq %rbx, %rdi
callq 0x2200
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2130
jmp 0x2b08
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x21f0
movq 0x2575(%rip), %r14      # 0x4fd8
leaq 0x6d3(%rip), %rsi       # 0x313d
movl $0x1, %edx
movq %r14, %rdi
callq 0x21a0
movzwl 0x12(%rsp), %eax
rolw $0x8, %ax
movzwl %ax, %esi
movq %r14, %rdi
callq 0x2120
movq %rax, %r14
leaq 0x695(%rip), %rsi       # 0x312a
movl $0x1, %edx
movq %rax, %rdi
callq 0x21a0
leaq 0x683(%rip), %rsi       # 0x312c
movl $0x12, %edx
movq %r14, %rdi
callq 0x21a0
movq %r14, %rdi
movl %ebp, %esi
callq 0x2200
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2130
movl %ebp, %edi
movl $0x4, %esi
movl $0x800, %edx            # imm = 0x800
xorl %eax, %eax
callq 0x2110
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/WilstonOreo[P]Log/./log/Log.hpp
// Function: Log::instance()
static Log* instance()
	{
		if (!_instance)
		{
			if (destroyed_) 
				onDeadReference();
			else 
				create();
		}
		return _instance;
	}

// Assembly:
cmpq $0x0, 0x420c(%rip)      # 0x7148
jne 0x2f76
pushq %rbx
movb 0x420b(%rip), %bl       # 0x7150
callq 0x31fc
cmpb $0x1, %bl
jne 0x2f75
movq 0x41f2(%rip), %rax      # 0x7148
movl $0x0, 0x8(%rax)
movl $0x1, (%rax)
movq 0x406e(%rip), %rcx      # 0x6fd8
movq %rcx, 0x20(%rax)
movb $0x0, 0x41db(%rip)      # 0x7150
popq %rbx
movq 0x41cb(%rip), %rax      # 0x7148
retq
// File: /workspace/github_cpp_makefile_star2_O1/WilstonOreo[P]Log/./log/Log.hpp
// Function: Log::log(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline Log& log(string file, string function, 
			int linenumber, int _level, string type)
	{
#ifdef LOGGING
		LOCK;
		curLevel = _level;
		if (curLevel > level_) return *this;  
#ifdef THREAD_SAFE
		if (threadBuffers.count(boost::this_thread::get_id()))
		{
			(*output_) << threadBuffers[boost::this_thread::get_id()];
		}
#endif
		(*output_) << endl;
		(*output_) << logHeader(file,function,linenumber,_level,type); 

#ifdef THREAD_SAFE
		threadBuffers.erase(boost::this_thread::get_id());
#endif
#endif
		return *this;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl %r8d, 0x4(%rdi)
cmpl %r8d, (%rdi)
jl 0x3028
movq %r9, %r13
movl %r8d, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq 0x20(%rbx), %r14
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
movl %ecx, 0x14(%rsp)
callq 0x2170
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq 0x20(%rbx), %r14
movq %r13, (%rsp)
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
movl 0x14(%rsp), %r8d
movl %ebp, %r9d
callq 0x3276
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r14, %rdi
callq 0x21c0
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3028
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3058
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/WilstonOreo[P]Log/./log/Log.hpp
// Function: fmt& fmt::operator%<int>(int const&)
fmt& operator%(const T &t) 
	{
		if (nParams < params.size())
		{
			stringstream ss; ss << t;
			params[nParams] = ss.str();
			nParams++;
		}
		return *this;
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
movq 0x28(%rdi), %rax
subq 0x20(%rdi), %rax
sarq $0x5, %rax
cmpq %rax, 0x38(%rdi)
jae 0x319b
movq %rsi, %r14
leaq 0x20(%rsp), %rdi
callq 0x20e0
leaq 0x30(%rsp), %rdi
movl (%r14), %esi
callq 0x2200
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x21f0
movq 0x38(%rbx), %rdi
shlq $0x5, %rdi
addq 0x20(%rbx), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0x21d0
movq (%r14), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x3179
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2190
incq 0x38(%rbx)
movq 0x3e3c(%rip), %rsi      # 0x6fc0
leaq 0x20(%rsp), %rdi
callq 0x2100
leaq 0xa0(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
jmp 0x31ab
movq %rax, %rbx
movq 0x3e0b(%rip), %rsi      # 0x6fc0
leaq 0x20(%rsp), %rdi
callq 0x2100
leaq 0xa0(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/WilstonOreo[P]Log/./log/Log.hpp
// Function: Log::~Log()
~Log()
	{
#ifdef THREAD_SAFE
		(*output_) << threadBuffers[boost::this_thread::get_id()];
#endif
		(*output_) << endl;

		_instance = 0;
		destroyed_ = true;
	}

// Assembly:
pushq %rbx
movq 0x20(%rdi), %rbx
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq $0x0, 0x3eef(%rip) # 0x7148
movb $0x1, 0x3ef0(%rip)      # 0x7150
popq %rbx
retq
movq %rax, %rdi
callq 0x326a
// File: /workspace/github_cpp_makefile_star2_O1/WilstonOreo[P]Log/./log/Log.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Log::colorStr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(int, int, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
string colorStr(int color, int bold, char delimiter, const T& t) const
	{
		stringstream ss;
#ifdef OUTPUT_COLOR
		if (output_ == &cout)
			ss << "\033[" << bold << ";" << color << "m";
#endif
		ss << t;
#ifdef OUTPUT_COLOR
		if (output_ == &cout) ss << "\033[0m";
#endif
		ss << delimiter;
		return ss.str();
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %r9, %r15
movl %r8d, %ebp
movl %ecx, %r13d
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20e0
movq 0x20(%r14), %rax
cmpq 0x34f6(%rip), %rax      # 0x6fd8
jne 0x3b3d
leaq 0x20(%rsp), %rdi
leaq 0x158f(%rip), %rsi      # 0x507f
movl $0x2, %edx
callq 0x21c0
leaq 0x20(%rsp), %rdi
movl %r13d, %esi
callq 0x2200
movq %rax, %r13
leaq 0x1571(%rip), %rsi      # 0x5082
movl $0x1, %edx
movq %rax, %rdi
callq 0x21c0
movq %r13, %rdi
movl %r12d, %esi
callq 0x2200
leaq 0x1557(%rip), %rsi      # 0x5087
movl $0x1, %edx
movq %rax, %rdi
callq 0x21c0
leaq 0x20(%rsp), %r12
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0x21c0
movq 0x20(%r14), %rax
cmpq 0x347c(%rip), %rax      # 0x6fd8
jne 0x3b72
leaq 0x151f(%rip), %rsi      # 0x5084
movl $0x4, %edx
movq %r12, %rdi
callq 0x21c0
leaq 0xf(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %r12, %rdi
callq 0x21c0
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x21f0
movq 0x3425(%rip), %rsi      # 0x6fc0
leaq 0x10(%rsp), %rdi
callq 0x2100
leaq 0x90(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x33ef(%rip), %rsi      # 0x6fc0
leaq 0x10(%rsp), %rdi
callq 0x2100
leaq 0x90(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/WilstonOreo[P]Log/./log/Log.hpp
// Function: void Log::appendThreadBuffer<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void appendThreadBuffer(const T& t)
	{
		stringstream ss; ss << t;
#ifdef THREAD_SAFE
		threadBuffers[boost::this_thread::get_id()] += ss.str();
#endif 
#ifndef THREAD_SAFE
		(*output_) << ss.str();
#endif
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x20e0
leaq 0x30(%rsp), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x21c0
movq 0x20(%rbx), %rbx
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x21f0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x21c0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ce8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2190
movq 0x32d1(%rip), %rsi      # 0x6fc0
leaq 0x20(%rsp), %rdi
callq 0x2100
leaq 0xa0(%rsp), %rdi
callq 0x2060
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d36
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2190
jmp 0x3d36
jmp 0x3d33
movq %rax, %rbx
movq 0x3283(%rip), %rsi      # 0x6fc0
leaq 0x20(%rsp), %rdi
callq 0x2100
leaq 0xa0(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/WilstonOreo[P]Log/./log/Log.hpp
// Function: fmt::str[abi:cxx11]() const
string str() const
	{ 
		stringstream ss; size_t n = 0; 
		for (size_t i = 0; i < buf.length(); i++)
		{
			char c = buf[i];
			switch (c)			{
				case '%':
					if (i > 0) 
						if (buf[i-1] == '\\') continue;
					if (n >= params.size()) continue;
					ss << params[n]; n++;
					break;
				case '\\':
					if (i < buf.length()-1)
						if (buf[i+1]=='%') 
						{ ss << '%'; continue; }
				default:
					ss << c;
			}
		}
		return ss.str(); 
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20e0
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x3e31
leaq 0x20(%rsp), %r15
xorl %r13d, %r13d
leaq 0xf(%rsp), %r12
xorl %ebp, %ebp
movq (%r14), %rcx
movzbl (%rcx,%rbp), %edx
cmpl $0x5c, %edx
je 0x3de7
cmpl $0x25, %edx
jne 0x3e0d
testq %rbp, %rbp
je 0x3db6
cmpb $0x5c, -0x1(%rcx,%rbp)
je 0x3e21
movq 0x20(%r14), %rax
movq 0x28(%r14), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
cmpq %rcx, %r13
jae 0x3e21
movq %r13, %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
movq %r15, %rdi
callq 0x21c0
incq %r13
jmp 0x3e21
decq %rax
cmpq %rax, %rbp
jae 0x3e0d
cmpb $0x25, 0x1(%rcx,%rbp)
jne 0x3e0d
movb $0x25, 0xf(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21c0
jmp 0x3e21
movb %dl, 0xf(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21c0
incq %rbp
movq 0x8(%r14), %rax
cmpq %rax, %rbp
jb 0x3d99
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x21f0
movq 0x317b(%rip), %rsi      # 0x6fc0
leaq 0x10(%rsp), %rdi
callq 0x2100
leaq 0x90(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3e73
movq %rax, %rbx
movq 0x3143(%rip), %rsi      # 0x6fc0
leaq 0x10(%rsp), %rdi
callq 0x2100
leaq 0x90(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/WilstonOreo[P]Log/./log/Log.hpp
// Function: fmt::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void operator()(const string& s) 
	{ 
		nParams = 0; buf = s; size_t n = 0;
		for (size_t i = 0; i < s.length(); i++)
			if (s[i] == '%')
			{
				if (i > 0) 
					if (s[i-1] == '\\') continue;
				n++;
			}
		params.resize(n);
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, 0x38(%rdi)
callq 0x20b0
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x3fae
movq (%r14), %rcx
xorl %edx, %edx
xorl %esi, %esi
cmpb $0x25, (%rcx,%rdx)
jne 0x3fa4
testq %rdx, %rdx
je 0x3fa1
cmpb $0x5c, -0x1(%rcx,%rdx)
je 0x3fa4
incq %rsi
incq %rdx
cmpq %rdx, %rax
jne 0x3f8f
jmp 0x3fb0
xorl %esi, %esi
addq $0x20, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3fc4
nop
// File: /workspace/github_cpp_makefile_star2_O1/ALSchwalm[P]cppEvolve/examples/traveling.cpp
// Function: fitness(std::array<char, 4ul> const&)
double fitness(const Genome& ind) {
    double total = 0;
    for(auto i= 0U; i < ind.size()-1; ++i) {
        if (ind[i] < ind[i+1]) {
            total += distances.at({ind[i], ind[i+1]});
        }
        else {
            total += distances.at({ind[i+1], ind[i]});
        }
    }
    return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movl $0x1, %r13d
leaq 0x5d10(%rip), %r14      # 0x8118
leaq -0x2c(%rbp), %r15
leaq -0x2a(%rbp), %r12
movsd %xmm0, -0x38(%rbp)
movb -0x1(%rbx,%r13), %al
movb (%rbx,%r13), %cl
cmpb %cl, %al
jge 0x2430
movb %al, -0x2c(%rbp)
movb %cl, -0x2b(%rbp)
movq %r14, %rdi
movq %r15, %rsi
jmp 0x243c
movb %cl, -0x2a(%rbp)
movb %al, -0x29(%rbp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x2784
movl (%rax), %eax
movl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd -0x38(%rbp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
incq %r13
cmpq $0x4, %r13
jne 0x2410
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]SMLA/src/Scheduler.h
// Function: ramulator::RowTable<ramulator::WideIO>::get_hits(std::vector<int, std::allocator<int>>&)
int get_hits(vector<int>& addr_vec)
    {
        auto begin = addr_vec.begin();
        auto end = begin + int(T::Level::Row);

        vector<int> rowgroup(begin, end);
        int row = *end;

        auto itr = table.find(rowgroup);
        auto entry = table[rowgroup];
        if (itr == table.end() || entry.row != row)
            return 0;

        return entry.hits;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rsi), %r14
leaq 0xc(%r14), %rdx
leaq 0x10(%rsp), %r12
leaq 0xf(%rsp), %rcx
movq %r12, %rdi
movq %r14, %rsi
callq 0x14a58
movl 0xc(%r14), %r13d
leaq 0x8(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x14be6
movq %rax, %r14
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x14a9a
movl (%rax), %r15d
movl 0x4(%rax), %ebp
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x14a11
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x52d0
addq $0x10, %rbx
xorl %eax, %eax
cmpl %r13d, %r15d
cmovnel %eax, %ebp
cmpq %rbx, %r14
cmovel %eax, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14a36
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x14a50
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x52d0
movq %rbx, %rdi
callq 0x54c0
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]SMLA/src/Refresh.h
// Function: ramulator::Refresh<ramulator::WideIO>::tick_ref()
void tick_ref() {
    clk++;

    int refresh_interval = ctrl->channel->spec->speed_entry.nREFI;

    // Time to schedule a refresh
    if ((clk - refreshed) >= refresh_interval) {
      inject_refresh(true);
    }
  }

// Assembly:
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
incq %rcx
movq %rcx, 0x10(%rdi)
movq 0x1000(%rax), %rax
movq 0x390(%rax), %rax
movslq 0x2750(%rax), %rax
subq 0x18(%rdi), %rcx
cmpq %rax, %rcx
jge 0x17f3e
retq
movl $0x1, %esi
jmp 0x1862c
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]SMLA/src/Processor.cpp
// Function: ramulator::Processor::tick()
void Processor::tick() {
  cpu_cycles++;
  if (!(no_core_caches && no_shared_cache)) {
    cachesys->tick();
  }
  for (unsigned int i = 0 ; i < cores.size() ; ++i) {
    Core* core = cores[i].get();
    core->tick();
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0x7a8(%rdi), %xmm0
addsd 0xedbe(%rip), %xmm0     # 0x4e068
movsd %xmm0, 0x7a8(%rdi)
cmpb $0x1, 0x39(%rdi)
jne 0x3f2be
cmpb $0x0, 0x3a(%rbx)
jne 0x3f2c7
movq 0x50(%rbx), %rdi
callq 0x3d308
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x3f2f7
movl $0x1, %ebp
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdi
callq 0x3f2fe
movl %ebp, %ecx
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x3f2d7
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]SMLA/src/SMLA_DIO.cpp
// Function: ramulator::SMLA_DIO::init_rowhit()
void SMLA_DIO::init_rowhit()
{
    // RD
    rowhit[int(Level::Bank)][int(Command::RD)] = [] (DRAM<SMLA_DIO>* node, Command cmd, int id) {
        switch (int(node->state)) {
            case int(State::Closed): return false;
            case int(State::Opened):
                if (node->row_state.find(id) != node->row_state.end())
                    return true;
                return false;
            default: assert(false);
        }};

    // WR
    rowhit[int(Level::Bank)][int(Command::WR)] = rowhit[int(Level::Bank)][int(Command::RD)];
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
leaq 0x1df2(%rip), %rcx      # 0x48488
movq %rcx, 0x18(%rsp)
leaq 0x1e68(%rip), %rdx      # 0x4850a
movq %rdx, 0x10(%rsp)
movups 0xcc0(%rdi), %xmm1
movaps %xmm1, (%rsp)
movups %xmm0, 0xcc0(%rdi)
movq 0xcd0(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rdx, 0xcd0(%rdi)
movq 0xcd8(%rdi), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, 0xcd8(%rdi)
testq %rax, %rax
je 0x466f1
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0xcc0(%rbx), %rsi
addq $0xce0, %rbx            # imm = 0xCE0
movq %rbx, %rdi
callq 0x48a46
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x7ce9
nop