LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/nurseiit[P]cpp-server/./include/asio/impl/read_until.hpp
// Function: std::pair<asio::buffers_iterator<asio::const_buffers_1, char>, bool> asio::detail::partial_search<asio::buffers_iterator<asio::const_buffers_1, char>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(asio::buffers_iterator<asio::const_buffers_1, char>, asio::buffers_iterator<asio::const_buffers_1, char>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
std::pair<Iterator1, bool> partial_search(
      Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterator2 last2)
  {
    for (Iterator1 iter1 = first1; iter1 != last1; ++iter1)
    {
      Iterator1 test_iter1 = iter1;
      Iterator2 test_iter2 = first2;
      for (;; ++test_iter1, ++test_iter2)
      {
        if (test_iter2 == last2)
          return std::make_pair(iter1, true);
        if (test_iter1 == last1)
        {
          if (test_iter2 != first2)
            return std::make_pair(iter1, false);
          else
            break;
        }
        if (*test_iter1 != *test_iter2)
          break;
      }
    }
    return std::make_pair(last1, false);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xe8(%rsp), %rcx
movq 0xe0(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x30(%rdx)
movaps 0xb0(%rsp), %xmm0
movaps 0xc0(%rsp), %xmm1
movaps 0xd0(%rsp), %xmm2
movaps %xmm2, 0x20(%rdx)
movaps %xmm1, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq 0x30(%rcx), %rbp
leaq 0x40(%rsp), %r13
cmpq %rbp, 0x30(%rsp)
je 0xb971
movq 0x30(%rsp), %rax
movq %rax, 0x70(%rsp)
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movaps %xmm2, 0x60(%rsp)
movaps %xmm1, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
xorl %r12d, %r12d
leaq (%r15,%r12), %rax
cmpq %r14, %rax
je 0xb938
cmpq %rbp, 0x70(%rsp)
je 0xb929
movq 0x40(%rsp), %rcx
movq 0x50(%rsp), %rdx
movb (%rcx,%rdx), %cl
cmpb (%rax), %cl
jne 0xb92e
movq %r13, %rdi
callq 0xbb38
incq %r12
jmp 0xb8fb
testq %r12, %r12
jne 0xb99d
movq %rsp, %rdi
callq 0xbb38
jmp 0xb8c6
movb $0x1, %al
movq 0x30(%rsp), %rcx
movq %rcx, 0x30(%rbx)
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movb %al, 0x38(%rbx)
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe8(%rsp), %rcx
movq 0x30(%rcx), %rax
movq %rax, 0x30(%rbx)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movb $0x0, 0x38(%rbx)
jmp 0xb95f
xorl %eax, %eax
jmp 0xb93a
nop
// File: /workspace/github_cpp_makefile_star2_O2/nurseiit[P]cpp-server/./include/asio/buffers_iterator.hpp
// Function: asio::buffers_iterator<asio::const_buffers_1, char>::increment()
void increment()
  {
    ASIO_ASSERT(current_ != end_ && "iterator out of bounds");
    ++position_;

    // Check if the increment can be satisfied by the current buffer.
    ++current_buffer_position_;
    if (current_buffer_position_ != current_buffer_.size())
      return;

    // Find the next non-empty buffer.
    ++current_;
    current_buffer_position_ = 0;
    while (current_ != end_)
    {
      current_buffer_ = *current_;
      if (current_buffer_.size() > 0)
        return;
      ++current_;
    }
  }

// Assembly:
pushq %rax
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rcx
cmpq %rcx, %rax
je 0xbb86
incq 0x30(%rdi)
movq 0x10(%rdi), %rdx
incq %rdx
movq %rdx, 0x10(%rdi)
cmpq 0x8(%rdi), %rdx
jne 0xbb84
addq $0x10, %rax
movq %rax, 0x20(%rdi)
andq $0x0, 0x10(%rdi)
cmpq %rcx, %rax
je 0xbb84
movups (%rax), %xmm0
movups %xmm0, (%rdi)
cmpq $0x0, 0x8(%rdi)
jne 0xbb84
addq $0x10, %rax
movq %rax, 0x20(%rdi)
jmp 0xbb68
popq %rax
retq
leaq 0xadc(%rip), %rdi       # 0xc669
leaq 0xb02(%rip), %rsi       # 0xc696
leaq 0xbfb(%rip), %rcx       # 0xc796
movl $0x164, %edx            # imm = 0x164
callq 0x5240
nop
// File: /workspace/github_cpp_makefile_star2_O2/chiku[P]cmatrix/src/exception.h
// Function: cmatrix::ExceptionBody::AccessOutOfBound[abi:cxx11](cmatrix::Size, long, long)
static std::basic_string<char> AccessOutOfBound(Size bounds, long int row, long int column)
        {
            std::stringstream message;
            message << "Invalid attempt to access (" << row << ", " << column << ") which lies "
                    <<  "outside bounds [" << bounds.getRows() << ", " << bounds.getColumns() << "]";
            return message.str();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5270
leaq 0x18(%rsp), %rdi
leaq 0x26b4e(%rip), %rsi     # 0x319d5
callq 0x5390
movq %rax, %rdi
movq %r13, %rsi
callq 0x5370
leaq 0x2ac44(%rip), %rsi     # 0x35ae2
movq %rax, %rdi
callq 0x5390
movq %rax, %rdi
movq %r12, %rsi
callq 0x5370
leaq 0x26b39(%rip), %rsi     # 0x319f1
movq %rax, %rdi
callq 0x5390
leaq 0x26b38(%rip), %rsi     # 0x319ff
movq %rax, %rdi
callq 0x5390
movq %rax, %rdi
movq %r15, %rsi
callq 0x5370
leaq 0x2ac01(%rip), %rsi     # 0x35ae2
movq %rax, %rdi
callq 0x5390
movq %rax, %rdi
movq %r14, %rsi
callq 0x5370
leaq 0x28c44(%rip), %rsi     # 0x33b3f
movq %rax, %rdi
callq 0x5390
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x5580
leaq 0x8(%rsp), %rdi
callq 0x52b0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x52b0
movq %rbx, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O2/chiku[P]cmatrix/src/impl/matrix/assignment.cpp
// Function: cmatrix::Matrix<double>::operator=(cmatrix::Matrix<double> const&)
Matrix<Type>& Matrix<Type>::operator = (const Matrix& otherMatrix)
{
    setSize(otherMatrix.rows(), otherMatrix.columns());

    for (long int i = 0; i < rows(); i++) {
        for (long int j = 0; j < columns(); j++) {
            access(i, j) = otherMatrix.access(i, j);
        }
    }

    return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
callq 0xac5e
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
xorl %edx, %edx
testq %rcx, %rcx
cmovleq %rdx, %rcx
testq %rax, %rax
cmovleq %rdx, %rax
xorl %esi, %esi
cmpq %rax, %rsi
je 0xb47f
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %r8
movq 0x20(%rbx), %r9
imulq %rdx, %r9
movq 0x20(%r14), %r10
imulq %rdx, %r10
movq %rcx, %r11
subq $0x1, %r11
jb 0xb476
movq (%rdi), %r15
movsd (%r15,%r10), %xmm0
movq (%r8), %r15
movsd %xmm0, (%r15,%r9)
addq $0x8, %r9
addq $0x8, %r10
jmp 0xb454
incq %rsi
addq $0x8, %rdx
jmp 0xb434
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chiku[P]cmatrix/src/impl/matrix/base.cpp
// Function: cmatrix::Matrix<double>::Matrix(cmatrix::Matrix<double> const&)
Matrix<Type>::Matrix(const Matrix& otherMatrix)
{
    setMatrixAsUnassigned();
    setSize(otherMatrix.rows(), otherMatrix.columns());

    for (long int i = 0; i < rows(); i++) {
        for (long int j = 0; j < columns(); j++) {
            access(i, j) = otherMatrix.access(i, j);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
andq $0x0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
callq 0xac5e
movq (%r14), %rax
movq 0x8(%r14), %rcx
xorl %edx, %edx
testq %rcx, %rcx
cmovleq %rdx, %rcx
testq %rax, %rax
cmovleq %rdx, %rax
xorl %esi, %esi
cmpq %rax, %rsi
je 0xb9e4
movq 0x10(%rbx), %rdi
movq 0x10(%r14), %r8
movq 0x20(%r14), %r9
imulq %rdx, %r9
movq 0x20(%rbx), %r10
imulq %rdx, %r10
movq %rcx, %r11
subq $0x1, %r11
jb 0xb9db
movq (%rdi), %r15
movsd (%r15,%r10), %xmm0
movq (%r8), %r15
movsd %xmm0, (%r15,%r9)
addq $0x8, %r9
addq $0x8, %r10
jmp 0xb9b9
incq %rsi
addq $0x8, %rdx
jmp 0xb999
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chiku[P]cmatrix/src/impl/matrix/functionoid.cpp
// Function: cmatrix::Matrix<double> cmatrix::Matrix<double>::map<cmatrix::FunctionoidWithOneParameter*>(cmatrix::FunctionoidWithOneParameter*)
Matrix<Type> Matrix<Type>::map(FunctObj function)
{
    Matrix<Type> result(rows(), columns());
    for(int i = 0; i < rows(); i++) {
        for(int j = 0; j < columns(); j++) {
            result.access(i, j) = (*function)(access(i, j));
        }
    }

    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
callq 0xa9d6
movq (%r14), %rax
movq 0x8(%r14), %rcx
xorl %edx, %edx
testq %rcx, %rcx
cmovleq %rdx, %rcx
testq %rax, %rax
cmovleq %rdx, %rax
movsd 0x21a9a(%rip), %xmm0    # 0x324e0
xorl %esi, %esi
cmpq %rax, %rsi
je 0x10a97
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %r8
movq 0x20(%r14), %r9
imulq %rdx, %r9
movq 0x20(%rbx), %r10
imulq %rdx, %r10
movq %rcx, %r11
subq $0x1, %r11
jb 0x10a8e
movq (%rdi), %r15
movsd (%r15,%r9), %xmm1
addsd %xmm0, %xmm1
movq (%r8), %r15
movsd %xmm1, (%r15,%r10)
addq $0x8, %r9
addq $0x8, %r10
jmp 0x10a68
incq %rsi
addq $0x8, %rdx
jmp 0x10a48
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chiku[P]cmatrix/src/impl/matrix/functionoid.cpp
// Function: cmatrix::Matrix<double>& cmatrix::Matrix<double>::fillByPosition<cmatrix::FunctionoidWithTwoParameters*>(cmatrix::FunctionoidWithTwoParameters*, long, long)
Matrix<Type>& Matrix<Type>::fillByPosition(FunctObj function, long int xShift, long int yShift)
{
    for (int i = 0; i < rows(); i++) {
        for (int j = 0; j < columns(); j++) {
            access(i, j) = (*function)(i - xShift, j - yShift);
        }
    }

    return (*this);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rax
movq (%rdi), %rsi
movq 0x8(%rdi), %rdi
xorl %r8d, %r8d
testq %rdi, %rdi
cmovleq %r8, %rdi
testq %rsi, %rsi
cmovleq %r8, %rsi
negq %rcx
xorl %r9d, %r9d
cmpq %rsi, %r9
je 0x10b12
movq %r9, %r10
subq %rdx, %r10
cvtsi2sd %r10, %xmm0
movq 0x10(%rax), %r10
movq 0x20(%rax), %r11
imulq %r8, %r11
movq %rcx, %rbx
movq %rdi, %r14
subq $0x1, %r14
jb 0x10b09
cvtsi2sd %rbx, %xmm1
addsd %xmm0, %xmm1
movq (%r10), %r15
movsd %xmm1, (%r15,%r11)
incq %rbx
addq $0x8, %r11
jmp 0x10ae8
incq %r9
addq $0x8, %r8
jmp 0x10ac6
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chiku[P]cmatrix/src/impl/matrix/numerical.cpp
// Function: cmatrix::Matrix<double> cmatrix::operator*<double>(cmatrix::Matrix<double>, cmatrix::Matrix<double>)
Matrix<Type> operator * (const Matrix<Type> firstMatrix, const Matrix<Type> secondMatrix)
{
    if (firstMatrix.columns() != secondMatrix.rows()) {
        throw Exception::IncompatibleMultiplication(ExceptionBody::IncompatibleMultiplication(firstMatrix.size, secondMatrix.size));
    }

    Matrix<Type> product(firstMatrix.rows(), secondMatrix.columns());

    for (int i = 0; i < firstMatrix.rows(); i++) {
        for (int j = 0; j < secondMatrix.columns(); j++) {
            product(i, j) = 0;
            for (int k = 0; k < firstMatrix.columns(); k++) {
                product(i, j) += firstMatrix(i, k) * secondMatrix(k, j);
            }
        }
    }

    return product;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq 0x8(%rsi), %rax
cmpq (%rdx), %rax
jne 0x12891
movq %rdi, %rbx
movq (%r15), %rsi
movq 0x8(%r14), %rdx
callq 0xa9d6
xorl %r12d, %r12d
cmpq %r12, (%r15)
jle 0x1287f
xorl %r13d, %r13d
cmpq %r13, 0x8(%r14)
jle 0x12877
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xaad2
andq $0x0, (%rax)
xorl %ebp, %ebp
cmpq %rbp, 0x8(%r15)
jle 0x12872
movq %r15, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x1303a
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x1303a
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xaad2
movsd 0x10(%rsp), %xmm0
mulsd 0x8(%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
incq %rbp
jmp 0x1281d
incq %r13
jmp 0x12803
incq %r12
jmp 0x127fb
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %rbx
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq (%r14), %rcx
movq 0x8(%r14), %r8
leaq 0x18(%rsp), %rdi
callq 0x12f32
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x13024
xorl %ebp, %ebp
leaq 0x35f03(%rip), %rsi     # 0x487d0
movq 0x366e4(%rip), %rdx     # 0x48fb8
movq %rbx, %rdi
callq 0x55e0
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x5180
testb %bpl, %bpl
jne 0x128f3
jmp 0x1290a
movq %rax, %r14
movq %rbx, %rdi
callq 0x5290
jmp 0x1290a
jmp 0x128ff
movq %rax, %r14
movq %rbx, %rdi
callq 0xac4e
movq %r14, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O2/chiku[P]cmatrix/src/exception.h
// Function: cmatrix::ExceptionBody::IncompatibleMultiplication[abi:cxx11](cmatrix::Size, cmatrix::Size)
static std::basic_string<char> IncompatibleMultiplication(Size first, Size second)
        {
            std::stringstream message;
            message << "Cannot multiply [" << first.getRows() << ", " << first.getColumns() << "] "
                    <<  "with [" << second.getRows() << ", " << second.getColumns() << "]";
            return message.str();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5270
leaq 0x18(%rsp), %rdi
leaq 0x1fbff(%rip), %rsi     # 0x32b66
callq 0x5390
movq %rax, %rdi
movq %r13, %rsi
callq 0x5370
leaq 0x22b64(%rip), %rsi     # 0x35ae2
movq %rax, %rdi
callq 0x5390
movq %rax, %rdi
movq %r12, %rsi
callq 0x5370
leaq 0x23536(%rip), %rsi     # 0x364ce
movq %rax, %rdi
callq 0x5390
leaq 0x1fbd1(%rip), %rsi     # 0x32b78
movq %rax, %rdi
callq 0x5390
movq %rax, %rdi
movq %r15, %rsi
callq 0x5370
leaq 0x22b21(%rip), %rsi     # 0x35ae2
movq %rax, %rdi
callq 0x5390
movq %rax, %rdi
movq %r14, %rsi
callq 0x5370
leaq 0x20b64(%rip), %rsi     # 0x33b3f
movq %rax, %rdi
callq 0x5390
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x5580
leaq 0x8(%rsp), %rdi
callq 0x52b0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x52b0
movq %rbx, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O2/chiku[P]cmatrix/src/impl/matrix/mutators.cpp
// Function: cmatrix::Matrix<double>::mutateToInclude(double, long, long)
void Matrix<Type>::mutateToInclude(Type value, long int row, long int column)
{
	if (row < 0 || column < 0) {
		throw Exception::InvalidSizeReset(ExceptionBody::BadSizeOnMutate(size, row, column));
	}

	if (size.contains(row, column)) {
		access(row, column) = value;
		return;
	}

	Size newSize(std::max(rows(), row + 1), std::max(columns(), column + 1));
	StorageEngine<Type> newEngine;
	newEngine.allocateMemory(newSize);

	for (long int i = 0; i < rows(); i++) {
		for (long int j = 0; j < columns(); j++) {
			newEngine.access(i, j) = engine.access(i, j);
		}
	}

	engine.markMemoryAsUnused();
	engine = newEngine;
	size = newSize;

	access(row, column) = value;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rax
orq %rsi, %rax
js 0x160c6
movq (%r15), %rax
testq %r14, %r14
js 0x15fda
cmpq %r14, %rax
setg %cl
testq %rbx, %rbx
setns %dl
andb %cl, %dl
movq 0x8(%r15), %rcx
cmpq %rbx, %rcx
setg %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x15fde
movq 0x10(%r15), %rax
imulq 0x20(%r15), %r14
shlq $0x3, %r14
addq (%rax), %r14
jmp 0x160b1
movq 0x8(%r15), %rcx
movsd %xmm0, 0x8(%rsp)
leaq 0x1(%r14), %r12
cmpq %r12, %rax
cmovgq %rax, %r12
leaq 0x1(%rbx), %r13
cmpq %r13, %rcx
cmovgq %rcx, %r13
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movups %xmm0, 0x8(%rdi)
movq %r12, %rsi
movq %r13, %rdx
callq 0xb254
movq (%r15), %rcx
movq 0x8(%r15), %rdx
leaq 0x10(%r15), %rax
movq %rax, (%rsp)
xorl %esi, %esi
testq %rdx, %rdx
cmovleq %rsi, %rdx
testq %rcx, %rcx
cmovleq %rsi, %rcx
xorl %edi, %edi
cmpq %rcx, %rdi
je 0x1607f
movq 0x10(%r15), %r8
movq 0x10(%rsp), %r9
movq 0x20(%rsp), %r10
imulq %rsi, %r10
movq 0x20(%r15), %r11
imulq %rsi, %r11
movq %rdx, %rbp
subq $0x1, %rbp
jb 0x16076
movq (%r8), %rax
movsd (%rax,%r11), %xmm0
movq (%r9), %rax
movsd %xmm0, (%rax,%r10)
addq $0x8, %r10
addq $0x8, %r11
jmp 0x16054
incq %rdi
addq $0x8, %rsi
jmp 0x16032
movq 0x20(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movups 0x10(%rsp), %xmm0
movups %xmm0, (%rax)
movq %r12, (%r15)
movq %r13, 0x8(%r15)
movq 0x10(%r15), %rax
imulq 0x20(%r15), %r14
shlq $0x3, %r14
addq (%rax), %r14
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%r14,%rbx,8)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %r12
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x28(%rsp), %rdi
movq %r14, %rcx
movq %rbx, %r8
callq 0x16138
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %r12, %rdi
callq 0xb196
xorl %ebp, %ebp
leaq 0x325e7(%rip), %rsi     # 0x486e8
movq 0x32eb0(%rip), %rdx     # 0x48fb8
movq %r12, %rdi
callq 0x55e0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5180
testb %bpl, %bpl
jne 0x16127
jmp 0x1612f
movq %rax, %rbx
movq %r12, %rdi
callq 0x5290
movq %rbx, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O2/chiku[P]cmatrix/src/exception.h
// Function: cmatrix::ExceptionBody::BadSizeOnMutate[abi:cxx11](cmatrix::Size, long, long)
static std::basic_string<char> BadSizeOnMutate(Size bounds, long int rows, long int columns)
        {
            std::stringstream message;
            message << "Invalid attempt to add element at negative row (" << rows << ") or column (" << columns
                    << ") to matrix [" << bounds.getRows() << ", " << bounds.getColumns() << "]";
            return message.str();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5270
leaq 0x18(%rsp), %rdi
leaq 0x1ceac(%rip), %rsi     # 0x33019
callq 0x5390
movq %rax, %rdi
movq %r13, %rsi
callq 0x5370
leaq 0x1cec6(%rip), %rsi     # 0x3304a
movq %rax, %rdi
callq 0x5390
movq %rax, %rdi
movq %r12, %rsi
callq 0x5370
leaq 0x1ceba(%rip), %rsi     # 0x33058
movq %rax, %rdi
callq 0x5390
movq %rax, %rdi
movq %r15, %rsi
callq 0x5370
leaq 0x1f92a(%rip), %rsi     # 0x35ae2
movq %rax, %rdi
callq 0x5390
movq %rax, %rdi
movq %r14, %rsi
callq 0x5370
leaq 0x1d96d(%rip), %rsi     # 0x33b3f
movq %rax, %rdi
callq 0x5390
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x5580
leaq 0x8(%rsp), %rdi
callq 0x52b0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x52b0
movq %rbx, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O2/chiku[P]cmatrix/src/impl/matrix/numerical.cpp
// Function: cmatrix::Matrix<cmatrix::Matrix<double>> cmatrix::operator+<cmatrix::Matrix<double>>(cmatrix::Matrix<cmatrix::Matrix<double>>, cmatrix::Matrix<cmatrix::Matrix<double>>)
Matrix<Type> operator + (const Matrix<Type> firstMatrix, const Matrix<Type> secondMatrix)
{
    if (firstMatrix.size != secondMatrix.size) {
        throw Exception::IncompatibleAddition(ExceptionBody::IncompatibleAddition(firstMatrix.size, secondMatrix.size));
    }

    Matrix<Type> sum(firstMatrix.rows(), firstMatrix.columns());

    for (int i = 0; i < firstMatrix.rows(); i++) {
        for (int j = 0; j < firstMatrix.columns(); j++) {
            sum.access(i, j) = firstMatrix.access(i, j) + secondMatrix.access(i, j);
        }
    }

    return sum;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
movq (%rdx), %rsi
cmpq %rsi, (%r12)
jne 0x1b6ba
movq 0x8(%r14), %rdx
cmpq %rdx, 0x8(%r12)
jne 0x1b6ba
movq 0x8(%rsp), %rdi
callq 0xbf66
leaq 0x10(%r12), %rax
movq %rax, 0x28(%rsp)
addq $0x10, %r14
movq %r14, 0x20(%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x78(%rsp), %r13
leaq 0x50(%rsp), %rbp
leaq 0xa0(%rsp), %r14
xorl %r15d, %r15d
movq %r12, 0x18(%rsp)
cmpq %r15, (%r12)
jle 0x1b6a3
xorl %ebx, %ebx
xorl %r12d, %r12d
movq 0x18(%rsp), %rax
cmpq %r12, 0x8(%rax)
jle 0x1b690
movq %r13, %rdi
movq 0x28(%rsp), %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0xe4d4
movq %rbp, %rdi
movq 0x20(%rsp), %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0xe4d4
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x1adc3
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rax
movq 0x20(%rcx), %rdi
imulq 0x10(%rsp), %rdi
addq (%rax), %rdi
addq %rbx, %rdi
movq %r14, %rsi
callq 0xb404
movq %r14, %rdi
callq 0xac4e
movq %rbp, %rdi
callq 0xac4e
movq %r13, %rdi
callq 0xac4e
incq %r12
addq $0x28, %rbx
jmp 0x1b60c
incq %r15
addq $0x28, 0x10(%rsp)
movq 0x18(%rsp), %r12
jmp 0x1b5fd
movq 0x8(%rsp), %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %rbx
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq (%r14), %rcx
movq 0x8(%r14), %r8
leaq 0x30(%rsp), %rdi
callq 0x1afee
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x1b0e0
xorl %ebp, %ebp
leaq 0x2d118(%rip), %rsi     # 0x48810
movq 0x2d8b9(%rip), %rdx     # 0x48fb8
movq %rbx, %rdi
callq 0x55e0
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x5180
testb %bpl, %bpl
jne 0x1b71e
jmp 0x1b765
movq %rax, %r14
movq %rbx, %rdi
callq 0x5290
jmp 0x1b765
movq %rax, %r14
leaq 0xa0(%rsp), %rdi
callq 0xac4e
jmp 0x1b73d
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0xac4e
jmp 0x1b751
movq %rax, %r14
jmp 0x1b75b
movq %rax, %r14
leaq 0x78(%rsp), %rdi
callq 0xac4e
movq 0x8(%rsp), %rdi
callq 0xc03a
movq %r14, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O2/chiku[P]cmatrix/src/impl/matrix/numerical.cpp
// Function: cmatrix::Matrix<double>::operator+=(cmatrix::Matrix<double>)
Matrix<Type>& Matrix<Type>::operator += (const Matrix<Type> secondMatrix)
{
    if (size != secondMatrix.size) {
        throw Exception::IncompatibleAddition(ExceptionBody::IncompatibleAddition(size, secondMatrix.size));
    }

    for (int i = 0; i < rows(); i++) {
        for (int j = 0; j < columns(); j++) {
            access(i, j) = access(i, j) + secondMatrix.access(i, j);
        }
    }

    return (*this);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
cmpq %rax, (%rdi)
jne 0x1af7c
movq 0x8(%rbx), %rcx
cmpq %rcx, 0x8(%r14)
jne 0x1af7c
xorl %edx, %edx
testq %rcx, %rcx
cmovleq %rdx, %rcx
testq %rax, %rax
cmovleq %rdx, %rax
xorl %esi, %esi
cmpq %rax, %rsi
je 0x1af6e
movq 0x10(%r14), %rdi
movq 0x20(%r14), %r8
imulq %rdx, %r8
xorl %r9d, %r9d
cmpq %r9, %rcx
je 0x1af65
movq (%rdi), %r10
addq %r8, %r10
movsd (%r10,%r9,8), %xmm0
movq 0x10(%rbx), %r11
movq 0x20(%rbx), %r15
imulq %rdx, %r15
addq (%r11), %r15
addsd (%r15,%r9,8), %xmm0
movsd %xmm0, (%r10,%r9,8)
incq %r9
jmp 0x1af34
incq %rsi
addq $0x8, %rdx
jmp 0x1af20
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %r15
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq (%rbx), %rcx
movq 0x8(%rbx), %r8
leaq 0x8(%rsp), %rdi
callq 0x1afee
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x1b0e0
xorl %ebp, %ebp
leaq 0x2d858(%rip), %rsi     # 0x48810
movq 0x2dff9(%rip), %rdx     # 0x48fb8
movq %r15, %rdi
callq 0x55e0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5180
testb %bpl, %bpl
jne 0x1afde
jmp 0x1afe6
movq %rax, %rbx
movq %r15, %rdi
callq 0x5290
movq %rbx, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O2/chiku[P]cmatrix/src/exception.h
// Function: cmatrix::ExceptionBody::IncompatibleAddition[abi:cxx11](cmatrix::Size, cmatrix::Size)
static std::basic_string<char> IncompatibleAddition(Size first, Size second)
        {
            std::stringstream message;
            message << "Cannot add [" << first.getRows() << ", " << first.getColumns() << "] "
                    <<  "and [" << second.getRows() << ", " << second.getColumns() << "]";
            return message.str();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5270
leaq 0x18(%rsp), %rdi
leaq 0x18593(%rip), %rsi     # 0x335b6
callq 0x5390
movq %rax, %rdi
movq %r13, %rsi
callq 0x5370
leaq 0x1aaa8(%rip), %rsi     # 0x35ae2
movq %rax, %rdi
callq 0x5390
movq %rax, %rdi
movq %r12, %rsi
callq 0x5370
leaq 0x1b47a(%rip), %rsi     # 0x364ce
movq %rax, %rdi
callq 0x5390
leaq 0x18560(%rip), %rsi     # 0x335c3
movq %rax, %rdi
callq 0x5390
movq %rax, %rdi
movq %r15, %rsi
callq 0x5370
leaq 0x1aa65(%rip), %rsi     # 0x35ae2
movq %rax, %rdi
callq 0x5390
movq %rax, %rdi
movq %r14, %rsi
callq 0x5370
leaq 0x18aa8(%rip), %rsi     # 0x33b3f
movq %rax, %rdi
callq 0x5390
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x5580
leaq 0x8(%rsp), %rdi
callq 0x52b0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x52b0
movq %rbx, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O2/chiku[P]cmatrix/src/impl/matrix/numerical.cpp
// Function: cmatrix::Matrix<double> cmatrix::operator-<double>(cmatrix::Matrix<double>, cmatrix::Matrix<double>)
Matrix<Type> operator - (const Matrix<Type> firstMatrix, const Matrix<Type> secondMatrix)
{
    if (firstMatrix.size != secondMatrix.size) {
        throw Exception::IncompatibleSubtraction(ExceptionBody::IncompatibleSubtraction(firstMatrix.size, secondMatrix.size));
    }

    Matrix<Type> difference(firstMatrix.rows(), firstMatrix.columns());

    for (int i = 0; i < firstMatrix.rows(); i++) {
        for (int j = 0; j < firstMatrix.columns(); j++) {
            difference.access(i, j) = firstMatrix.access(i, j) - secondMatrix.access(i, j);
        }
    }

    return difference;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdx), %rsi
cmpq %rsi, (%r14)
jne 0x1b1c7
movq 0x8(%rbx), %rdx
cmpq %rdx, 0x8(%r14)
jne 0x1b1c7
movq %rdi, %r15
callq 0xa9d6
movq (%r14), %rax
xorl %ecx, %ecx
testq %rax, %rax
cmovleq %rcx, %rax
xorl %edx, %edx
xorl %esi, %esi
cmpq %rax, %rsi
je 0x1b1b7
movq 0x8(%r14), %rdi
testq %rdi, %rdi
cmovleq %rcx, %rdi
movq 0x10(%r15), %r8
movq 0x20(%r15), %r9
imulq %rdx, %r9
xorl %r10d, %r10d
cmpq %r10, %rdi
je 0x1b1ae
movq 0x10(%r14), %r11
movq 0x20(%r14), %r12
imulq %rdx, %r12
addq (%r11), %r12
movsd (%r12,%r10,8), %xmm0
movq 0x10(%rbx), %r11
movq 0x20(%rbx), %r12
imulq %rdx, %r12
addq (%r11), %r12
movq (%r8), %r11
addq %r9, %r11
subsd (%r12,%r10,8), %xmm0
movsd %xmm0, (%r11,%r10,8)
incq %r10
jmp 0x1b16e
incq %rsi
addq $0x8, %rdx
jmp 0x1b14f
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %r15
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq (%rbx), %rcx
movq 0x8(%rbx), %r8
movq %rsp, %rdi
callq 0x1b3cc
movb $0x1, %bpl
movq %rsp, %rsi
movq %r15, %rdi
callq 0x1b4be
xorl %ebp, %ebp
leaq 0x2d651(%rip), %rsi     # 0x48850
movq 0x2ddb2(%rip), %rdx     # 0x48fb8
movq %r15, %rdi
callq 0x55e0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5180
testb %bpl, %bpl
jne 0x1b223
jmp 0x1b22b
movq %rax, %rbx
movq %r15, %rdi
callq 0x5290
movq %rbx, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O2/chiku[P]cmatrix/src/impl/matrix/numerical.cpp
// Function: cmatrix::Matrix<double>::operator-=(cmatrix::Matrix<double>)
Matrix<Type>& Matrix<Type>::operator -= (const Matrix<Type> secondMatrix)
{
    if (size != secondMatrix.size) {
        throw Exception::IncompatibleSubtraction(ExceptionBody::IncompatibleSubtraction(size, secondMatrix.size));
    }

    for (int i = 0; i < rows(); i++) {
        for (int j = 0; j < columns(); j++) {
            access(i, j) = access(i, j) - secondMatrix.access(i, j);
        }
    }

    return (*this);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
cmpq %rax, (%rdi)
jne 0x1b2c4
movq 0x8(%rbx), %rcx
cmpq %rcx, 0x8(%r14)
jne 0x1b2c4
xorl %edx, %edx
testq %rcx, %rcx
cmovleq %rdx, %rcx
testq %rax, %rax
cmovleq %rdx, %rax
xorl %esi, %esi
cmpq %rax, %rsi
je 0x1b2b6
movq 0x10(%r14), %rdi
movq 0x20(%r14), %r8
imulq %rdx, %r8
xorl %r9d, %r9d
cmpq %r9, %rcx
je 0x1b2ad
movq (%rdi), %r10
addq %r8, %r10
movsd (%r10,%r9,8), %xmm0
movq 0x10(%rbx), %r11
movq 0x20(%rbx), %r15
imulq %rdx, %r15
addq (%r11), %r15
subsd (%r15,%r9,8), %xmm0
movsd %xmm0, (%r10,%r9,8)
incq %r9
jmp 0x1b27c
incq %rsi
addq $0x8, %rdx
jmp 0x1b268
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %r15
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq (%rbx), %rcx
movq 0x8(%rbx), %r8
leaq 0x8(%rsp), %rdi
callq 0x1b3cc
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x1b4be
xorl %ebp, %ebp
leaq 0x2d550(%rip), %rsi     # 0x48850
movq 0x2dcb1(%rip), %rdx     # 0x48fb8
movq %r15, %rdi
callq 0x55e0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5180
testb %bpl, %bpl
jne 0x1b326
jmp 0x1b32e
movq %rax, %rbx
movq %r15, %rdi
callq 0x5290
movq %rbx, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O2/chiku[P]cmatrix/src/impl/matrix/numerical.cpp
// Function: cmatrix::Matrix<double>::operator-()
Matrix<Type> Matrix<Type>::operator - ()
{
    Matrix<Type> result(rows(), columns());

    for (int i = 0; i < rows(); i++) {
        for (int j = 0; j < columns(); j++) {
            result.access(i, j) = -access(i, j);
        }
    }

    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
callq 0xa9d6
movq (%r14), %rax
movq 0x8(%r14), %rcx
xorl %edx, %edx
testq %rcx, %rcx
cmovleq %rdx, %rcx
testq %rax, %rax
cmovleq %rdx, %rax
movaps 0x17d02(%rip), %xmm0    # 0x33070
xorl %esi, %esi
cmpq %rax, %rsi
je 0x1b3bd
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %r8
movq 0x20(%r14), %r9
imulq %rdx, %r9
movq 0x20(%rbx), %r10
imulq %rdx, %r10
movq %rcx, %r11
subq $0x1, %r11
jb 0x1b3b4
movq (%rdi), %r15
movq (%r8), %r12
movsd (%r15,%r9), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%r12,%r10)
addq $0x8, %r9
addq $0x8, %r10
jmp 0x1b390
incq %rsi
addq $0x8, %rdx
jmp 0x1b370
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chiku[P]cmatrix/src/exception.h
// Function: cmatrix::ExceptionBody::IncompatibleSubtraction[abi:cxx11](cmatrix::Size, cmatrix::Size)
static std::basic_string<char> IncompatibleSubtraction(Size first, Size second)
        {
            std::stringstream message;
            message << "Cannot subtract [" << second.getRows() << ", " << second.getColumns() << "] "
                    <<  "from [" << first.getRows() << ", " << first.getColumns() << "]";
            return message.str();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5270
leaq 0x18(%rsp), %rdi
leaq 0x18563(%rip), %rsi     # 0x33964
callq 0x5390
movq %rax, %rdi
movq %r13, %rsi
callq 0x5370
leaq 0x1a6ca(%rip), %rsi     # 0x35ae2
movq %rax, %rdi
callq 0x5390
movq %rax, %rdi
movq %r12, %rsi
callq 0x5370
leaq 0x1b09c(%rip), %rsi     # 0x364ce
movq %rax, %rdi
callq 0x5390
leaq 0x16603(%rip), %rsi     # 0x31a44
movq %rax, %rdi
callq 0x5390
movq %rax, %rdi
movq %r15, %rsi
callq 0x5370
leaq 0x1a687(%rip), %rsi     # 0x35ae2
movq %rax, %rdi
callq 0x5390
movq %rax, %rdi
movq %r14, %rsi
callq 0x5370
leaq 0x186ca(%rip), %rsi     # 0x33b3f
movq %rax, %rdi
callq 0x5390
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x5580
leaq 0x8(%rsp), %rdi
callq 0x52b0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x52b0
movq %rbx, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O2/chiku[P]cmatrix/src/impl/matrix/numerical.cpp
// Function: cmatrix::Matrix<double>::scale(double)
Matrix<Type> Matrix<Type>::scale(Type value)
{
    Matrix<Type> result(rows(), columns());

    for (int i = 0; i < rows(); i++) {
        for (int j = 0; j < columns(); j++) {
            result.access(i, j) = value * access(i, j);
        }
    }

    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
callq 0xa9d6
movsd (%rsp), %xmm1
movq (%r14), %rax
movq 0x8(%r14), %rcx
xorl %edx, %edx
testq %rcx, %rcx
cmovleq %rdx, %rcx
testq %rax, %rax
cmovleq %rdx, %rax
xorl %esi, %esi
cmpq %rax, %rsi
je 0x1b576
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %r8
movq 0x20(%r14), %r9
imulq %rdx, %r9
movq 0x20(%rbx), %r10
imulq %rdx, %r10
movq %rcx, %r11
subq $0x1, %r11
jb 0x1b56d
movq (%rdi), %r15
movq (%r8), %r12
movsd (%r15,%r9), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, (%r12,%r10)
addq $0x8, %r9
addq $0x8, %r10
jmp 0x1b547
incq %rsi
addq $0x8, %rdx
jmp 0x1b527
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chiku[P]cmatrix/src/impl/matrix/properties.cpp
// Function: cmatrix::Matrix<double>::isZero() const
bool Matrix<Type>::isZero() const
{
    for (int i = 0; i < rows(); i++) {
        for (int j = 0; j < columns(); j++) {
            if (access(i, j) != 0) {
                return false;
            }
        }
    }

    return true;
}

// Assembly:
pushq %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdx
xorl %esi, %esi
testq %rcx, %rcx
cmovleq %rsi, %rcx
testq %rax, %rax
movl $0x0, %r8d
cmovgq %rax, %r8
movq 0x20(%rdi), %rdi
shlq $0x3, %rdi
xorpd %xmm0, %xmm0
xorl %r9d, %r9d
cmpq %r8, %r9
je 0x1df3b
movq %rsi, %r10
movq %rcx, %r11
subq $0x1, %r11
jb 0x1df33
movq (%rdx), %rbx
movsd (%rbx,%r10), %xmm1
addq $0x8, %r10
ucomisd %xmm0, %xmm1
jne 0x1df3b
jnp 0x1df16
jmp 0x1df3b
incq %r9
addq %rdi, %rsi
jmp 0x1df0b
cmpq %r9, %rax
setle %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/chiku[P]cmatrix/test/doctest.h
// Function: doctest::skipPathFromFilename(char const*)
const char* skipPathFromFilename(const char* file) {
#ifndef DOCTEST_CONFIG_DISABLE
    if(getContextOptions()->no_path_in_filenames) {
        auto back    = std::strrchr(file, '\\');
        auto forward = std::strrchr(file, '/');
        if(back || forward) {
            if(back > forward)
                forward = back;
            return forward + 1;
        }
    } else {
        const auto prefixes = getContextOptions()->strip_file_prefixes;
        const char separator = DOCTEST_CONFIG_OPTIONS_FILE_PREFIX_SEPARATOR;
        String::size_type longest_match = 0U;
        for(String::size_type pos = 0U; pos < prefixes.size(); ++pos)
        {
            const auto prefix_start = pos;
            pos = std::min(prefixes.find(separator, prefix_start), prefixes.size());
            
            const auto prefix_size = pos - prefix_start;
            if(prefix_size > longest_match)
            {
                // TODO under DOCTEST_MSVC: does the comparison need strnicmp() to work with drive letter capitalization?
                if(0 == std::strncmp(prefixes.c_str() + prefix_start, file, prefix_size))
                {
                    longest_match = prefix_size;
                }
            }
        }
        return &file[longest_match];
    }
#endif // DOCTEST_CONFIG_DISABLE
    return file;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x27873(%rip), %rsi     # 0x494a8
cmpb $0x1, 0x7c(%rsi)
jne 0x21c6d
pushq $0x5c
popq %rsi
movq %rbx, %rdi
callq 0x53f0
movq %rax, %r14
pushq $0x2f
popq %rsi
movq %rbx, %rdi
callq 0x53f0
movq %rax, %rcx
cmpq %rax, %r14
cmovaq %r14, %rax
incq %rax
orq %rcx, %r14
cmoveq %rbx, %rax
jmp 0x21d11
movq %rbx, 0x8(%rsp)
subq $-0x80, %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x21084
movq %rbx, (%rsp)
movzbl 0x17(%rbx), %eax
testb %al, %al
jns 0x21c9e
movl 0x18(%rsp), %ebx
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
jmp 0x21ca6
andl $0x1f, %eax
pushq $0x17
popq %rbx
subl %eax, %ebx
xorl %r14d, %r14d
pushq $0x3a
popq %rbp
xorl %r13d, %r13d
cmpl %ebx, %r13d
jae 0x21cf9
leaq 0x10(%rsp), %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x21442
movl %eax, %r12d
cmpl %eax, %ebx
cmovbl %ebx, %r12d
movl %r12d, %r15d
subl %r13d, %r15d
cmpl %r14d, %r15d
jbe 0x21cf1
movl %r13d, %edi
addq (%rsp), %rdi
movl %r15d, %edx
movq 0x8(%rsp), %rsi
callq 0x5190
testl %eax, %eax
cmovel %r15d, %r14d
incl %r12d
movl %r12d, %r13d
jmp 0x21caf
movl %r14d, %eax
movq 0x8(%rsp), %rbx
addq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x210be
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chiku[P]cmatrix/test/doctest.h
// Function: doctest::Approx::operator()(double) const
Approx Approx::operator()(double value) const {
    Approx approx(value);
    approx.epsilon(m_epsilon);
    approx.scale(m_scale);
    return approx;
}

// Assembly:
movq %rdi, %rax
movsd %xmm0, 0x10(%rdi)
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH07_Classes/examples/useDebug.cc
// Function: main
int main()
{
	constexpr Debug io_sub(false, true, false);  // debugging IO    
	if (io_sub.any())  // equivalent to if(true)
		cerr << "print appropriate error messages" << endl;

	constexpr Debug prod(false); // no debugging during production
	if (prod.any())    // equivalent to if(false)
		cerr << "print an error message" << endl;

	IO_Subsystem ioErrs;        // by default, don't print any debugging
	// no debugging here
	if (ioErrs.default_debug()) // if (false || debug.any())
		cerr << "print message 3" << endl;
	ioErrs.set_debug(true);     // turn on debugging
	if (ioErrs.default_debug()) // if (false || debug.any())
		cerr << "print message 4" << endl;
	ioErrs.set_debug(false);    // okay, debugging section complete

	HW_Subsystem hw;
	hw.set_debug(true);
	if (ioErrs.default_debug() || hw.default_debug()) // if (false || debug.any())
		cerr << "print message 5" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x2e37(%rip), %rbx      # 0x3ff0
leaq 0xe4a(%rip), %rsi       # 0x200a
movq %rbx, %rdi
callq 0x1050
movq %rax, %rdi
callq 0x1030
leaq 0xe54(%rip), %rsi       # 0x202b
movq %rbx, %rdi
callq 0x1050
movq %rax, %rdi
callq 0x1030
leaq 0xe4d(%rip), %rsi       # 0x203b
movq %rbx, %rdi
callq 0x1050
movq %rax, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ccf19881030[P]UDP_Chat/client.cpp
// Function: main
int main(void)
{
	int sock;
	if ((sock = socket(PF_INET,SOCK_DGRAM,0)) < 0)
		ERR_EXIT("socket");
 
	chat_cli(sock);
 
	return 0;
}

// Assembly:
pushq %rax
pushq $0x2
popq %rdi
movl %edi, %esi
xorl %edx, %edx
callq 0x1060
testl %eax, %eax
js 0x1328
movl %eax, %edi
callq 0x133c
xorl %eax, %eax
popq %rcx
retq
leaq 0xcf1(%rip), %rdi       # 0x2020
callq 0x10f0
pushq $0x1
popq %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/ccf19881030[P]UDP_Chat/client.cpp
// Function: do_someone_login(message&)
void do_someone_login(MESSAGE &msg)
{
	USER_INFO *user = (USER_INFO*)msg.body;
	in_addr tmp;
	tmp.s_addr = user->ip;
	printf("%s <->%s:%d has logined server\n",user->username,inet_ntoa(tmp),ntohs(user->port));
	client_list.push_back(*user);		
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rdi), %r14
movl 0x14(%rdi), %edi
callq 0x10a0
movzwl 0x18(%rbx), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
leaq 0x99a(%rip), %rdi       # 0x20e5
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1030
leaq 0x29c1(%rip), %rdi      # 0x4120
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1c48
// File: /workspace/github_cpp_makefile_star2_O2/ccf19881030[P]UDP_Chat/client.cpp
// Function: do_someone_logout(message&)
void do_someone_logout(MESSAGE &msg)
{
	USER_LIST::iterator it;
	//�ҵ��˳��Ŀͻ���
	for(it=client_list.begin(); it != client_list.end(); it++)
	{
		//�ҵ���ֹѭ��
		if(strcmp(it->username,msg.body) == 0)
		{
			break;
		}
	}
 
	if (it != client_list.end())	
	{
		client_list.erase(it);
	}
 
	printf("user %s has logout server\n",msg.body);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0x4, %rbx
leaq 0x299f(%rip), %r15      # 0x4120
movq %r15, %r14
movq (%r14), %r14
cmpq %r15, %r14
je 0x17ab
leaq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x11a0
testl %eax, %eax
jne 0x1784
leaq 0x297d(%rip), %rdi      # 0x4120
movq %r14, %rsi
callq 0x1c54
leaq 0x953(%rip), %rdi       # 0x2105
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_cpp_makefile_star2_O2/ccf19881030[P]UDP_Chat/client.cpp
// Function: do_getlist(int)
void do_getlist(int sock)
{
	int count;
        recvfrom(sock,&count,sizeof(int),0,NULL,NULL);
        //���ܵ�¼�б�
        int n = ntohl(count);
        printf("has %d users logined server\n",n);
	client_list.clear();
        //���ܵ�¼�û�����ip���˿�
        for(int i=0; i<n;i++)
        {
                USER_INFO user;
                recvfrom(sock,&user,sizeof(USER_INFO),0,NULL,NULL);
                client_list.push_back(user);
                in_addr tmp;
                tmp.s_addr = user.ip;
 
                printf("%d %s <-> %s:%d\n",i,user.username,inet_ntoa(tmp),ntohs(user.port));
        }
 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
xorl %r15d, %r15d
leaq 0xc(%rsp), %r14
pushq $0x4
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x10c0
movl (%r14), %ebp
bswapl %ebp
leaq 0x8b0(%rip), %rdi       # 0x20a8
movl %ebp, %esi
xorl %eax, %eax
callq 0x1030
leaq 0x2918(%rip), %rdi      # 0x4120
callq 0x1c62
testl %ebp, %ebp
cmovlel %r15d, %ebp
leaq 0x10(%rsp), %r15
pushq $0x18
popq %r12
leaq 0x8a2(%rip), %r13       # 0x20c5
xorl %r14d, %r14d
cmpl %r14d, %ebp
je 0x187d
movl %ebx, %edi
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x10c0
leaq 0x28d9(%rip), %rdi      # 0x4120
movq %r15, %rsi
callq 0x1c48
movl 0x20(%rsp), %edi
callq 0x10a0
movzwl 0x24(%rsp), %ecx
rolw $0x8, %cx
movzwl %cx, %r8d
movq %r13, %rdi
movl %r14d, %esi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1030
incl %r14d
jmp 0x1826
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ccf19881030[P]UDP_Chat/client.cpp
// Function: sendmsgto(int, char*, char*)
bool sendmsgto(int sock,char *name,char *msg)
{
	if(strcmp(name,username) == 0)
	{
		printf("can't send message to self\n");
		return false;
	}
 
	 USER_LIST::iterator it;
        //�ҵ��˳��Ŀͻ���
        for(it=client_list.begin(); it != client_list.end(); it++)
        {
                //�ҵ���ֹѭ��
                if(strcmp(it->username,name) == 0)
                {
                        break;
                }
        }
 
 
	if(it == client_list.end())
	{
		printf("user %s has not logined server\n",name);
		return false;
	}
 
	MESSAGE m;
	memset(&m,0,sizeof(m));
	m.cmd = htonl(C2C_CHAT);
 
	CHAT_MSG cm;
	strcpy(cm.username,username);
	strcpy(cm.msg,msg);
 
	memcpy(m.body,&cm,sizeof(cm));
	
	struct sockaddr_in peeraddr;
	memset(&peeraddr,0,sizeof(peeraddr));
	peeraddr.sin_family = AF_INET;
	peeraddr.sin_addr.s_addr = it->ip;
	peeraddr.sin_port = it->port;
 
	in_addr tmp;
	tmp.s_addr = it->ip;
 
	printf("sending message [%s] to user [%s] <->%s:%d\n",msg,name,inet_ntoa(tmp),ntohs(it->port));
 
 
	sendto(sock,(const char*)&m,sizeof(m),0,(struct sockaddr *)&peeraddr, sizeof(peeraddr));
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x290, %rsp            # imm = 0x290
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %ebx
leaq 0x25ff(%rip), %rsi      # 0x4110
movq %r14, %rdi
callq 0x11a0
testl %eax, %eax
je 0x1c0c
leaq 0x25f8(%rip), %r12      # 0x4120
movq %r12, %r13
movq (%r13), %r13
cmpq %r12, %r13
je 0x1c1c
leaq 0x10(%r13), %rdi
movq %r14, %rsi
callq 0x11a0
testl %eax, %eax
jne 0x1b2b
leaq 0x104(%rsp), %r12
movl $0x18c, %edx            # imm = 0x18C
movq %r12, %rdi
xorl %esi, %esi
callq 0x10b0
movl $0x10000000, -0x78(%r12) # imm = 0x10000000
leaq 0x25a1(%rip), %rsi      # 0x4110
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x1110
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x1110
leaq 0x90(%rsp), %rdi
pushq $0x74
popq %rdx
movq %r12, %rsi
callq 0x10e0
leaq 0x8(%rsp), %r12
andq $0x0, 0x8(%r12)
movw $0x2, (%r12)
movl 0x20(%r13), %edi
movl %edi, 0x4(%r12)
movzwl 0x24(%r13), %eax
movw %ax, 0x2(%r12)
callq 0x10a0
movzwl 0x24(%r13), %ecx
rolw $0x8, %cx
movzwl %cx, %r8d
leaq 0x571(%rip), %rdi       # 0x214c
movq %r15, %rsi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1030
leaq 0x8c(%rsp), %rsi
pushq $0x10
popq %r9
movl $0x204, %edx            # imm = 0x204
movl %ebx, %edi
xorl %ecx, %ecx
movq %r12, %r8
callq 0x1040
movb $0x1, %bl
jmp 0x1c2f
leaq 0x695(%rip), %rdi       # 0x22a8
callq 0x11b0
xorl %ebx, %ebx
jmp 0x1c2f
leaq 0x509(%rip), %rdi       # 0x212c
xorl %ebx, %ebx
movq %r14, %rsi
xorl %eax, %eax
callq 0x1030
movl %ebx, %eax
addq $0x290, %rsp            # imm = 0x290
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/dnegovan[P]Intruder-On-Donnar-V/Backpack.cpp
// Function: Backpack::printContents()
void Backpack::printContents()
{
    std::cout << NARRATOR_COLOR;
    if (contents.empty())
    {
        std::cout << "\nYour pack is empty." << RESET << std::endl;
    }
    else
    {
        //cast from unsigned int to avoid compiler warnings
        int size = static_cast<int>(contents.size());

        std::cout << "\nYour pack contains: \n" << ITEM_COLOR;
        for (int i = 0; i < size; i++)
        {
            std::cout << contents[i] << "\n";
        }
        std::cout << RESET << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0xcd04(%rip), %rbx      # 0x15fc8
leaq 0x6dcd(%rip), %rsi      # 0x10098
movq %rbx, %rdi
callq 0x31d0
movq (%r14), %rax
movq 0x8(%r14), %r12
cmpq %r12, %rax
je 0x933d
subq %rax, %r12
shrq $0x5, %r12
leaq 0x6dcb(%rip), %rsi      # 0x100b8
movq %rbx, %rdi
callq 0x31d0
leaq 0x6dd3(%rip), %rsi      # 0x100cf
movq %rax, %rdi
callq 0x31d0
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
shlq $0x5, %r12
leaq 0x760b(%rip), %r15      # 0x10924
cmpq %r13, %r12
je 0x9353
movq (%r14), %rsi
addq %r13, %rsi
movq %rbx, %rdi
callq 0x31b0
movq %rax, %rdi
movq %r15, %rsi
callq 0x31d0
addq $0x20, %r13
jmp 0x9319
movq 0xcc84(%rip), %rdi      # 0x15fc8
leaq 0x6d53(%rip), %rsi      # 0x1009e
callq 0x31d0
movq %rax, %rbx
leaq 0x6d59(%rip), %rsi      # 0x100b3
movq %rbx, %rdi
callq 0x31d0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x30f0