name string | code string | asm string | file string |
|---|---|---|---|
History::History(int, int, int, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | History::History(int numberOfAssignments, int numberOfWorkingWeekends, int numberOfConsecutiveAssignments,
int numberOfConsecutiveWorkingDays, int numberOfConsecutiveDaysOff,
const string &lastAssignedShiftType) : numberOfAssignments(numberOfAssignments),
... | movq 0x8(%rsp), %r10
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
movl %r8d, 0xc(%rdi)
movl %r9d, 0x10(%rdi)
leaq 0x18(%rdi), %rax
leaq 0x28(%rdi), %rcx
movq %rcx, 0x18(%rdi)
movq (%r10), %rsi
movq 0x8(%r10), %rdx
addq %rsi, %rdx
movq %rax, %rdi
jmp 0x7f78
nop
| /antonio-ramadas[P]nurse-rostering-solution/code/History.cpp |
History::History() | History::History() : History(0,0,0,0,0,"") {} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x11f1e(%rip), %rdx # 0x1d1d6
movq %rsp, %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x59b2
leaq 0x18(%rbx), %rdi
leaq 0x28(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movl $0x0, 0x10(%rbx)
mov... | /antonio-ramadas[P]nurse-rostering-solution/code/History.cpp |
WeekData::WeekData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int) | WeekData::WeekData(const string &path, int numberOfShifts, int numberOfSkills) {
json j;
this->numberOfShifts = numberOfShifts;
this->numberOfSkills = numberOfSkills;
try {
j = Reader::ReadJSONFile(path);
} catch (Exception exception) {
exception.printErr();
return;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movq %rax, 0x30(%rdi)
leaq 0x7... | /antonio-ramadas[P]nurse-rostering-solution/code/WeekData.cpp |
WeekData::parseShiftOffRequests(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer> const&) | void WeekData::parseShiftOffRequests(const json &j_arg) {
json shiftOffRequests_json = j_arg["shiftOffRequests"];
for (json j : shiftOffRequests_json) {
shiftOffRequests.push_back(ShiftOffRequest(j["nurse"], j["shiftType"], j["day"]));
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rsi, %rax
movq %rdi, (%rsp)
leaq 0x10bd1(%rip), %rsi # 0x1c9fa
movq %rax, %rdi
callq 0x7772
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7a4e
movq %rbx, 0x28(%rsp)
xorps %xmm0, %xmm0
m... | /antonio-ramadas[P]nurse-rostering-solution/code/WeekData.cpp |
WeekData::getMinimumCoverageRequirement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int const&) | int WeekData::getMinimumCoverageRequirement(const string &skill, const string &shift, const int &day) {
return requirements.at(skill).at(shift).at(day)->getMinimumCoverage();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
addq $0x40, %rdi
callq 0xc450
testq %rax, %rax
je 0xc19b
addq $0x28, %rax
movq %rax, %rdi
movq %r14, %rsi
callq 0xc918
testq %rax, %rax
je 0xc19b
movslq (%rbx), %rsi
movq 0x28(%rax), %rcx
movq 0x30(%rax), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rsi, %r... | /antonio-ramadas[P]nurse-rostering-solution/code/WeekData.cpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | reference operator[](const typename object_t::key_type& key)
{
// implicitly convert null value to an empty object
if (is_null())
{
m_type = value_t::object;
m_value.object = create<object_t>();
assert_invariant();
}
// operator[] only wor... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, (%rdi)
jne 0xc261
movb $0x1, (%r14)
movl $0x30, %edi
callq 0x4320
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq $... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
ShiftType::ShiftType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int const&, int const&) | ShiftType::ShiftType(const string &id, const int &min, const int &max) {
this->id = id;
minimumNumberOfConsecutiveAssignments = min;
maximumNumberOfConsecutiveAssignments = max;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x28(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movq %rax, 0x38(%rdi)
callq 0x41e0
movl (%r15), %eax... | /antonio-ramadas[P]nurse-rostering-solution/code/ShiftType.cpp |
Contract::Contract(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int const&, int const&, int const&, int const&, int const&, int const&, int const&, int const&) | Contract::Contract(const string &id, const int &minAssignments, const int &maxAssignments, const int &minWorkingDays,
const int &maxWorkingDays, const int &minDaysOff, const int &maxDaysOff, const int &WorkingWeekends,
const int &completeWeekends) {
this->id = id;
minimumNu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %rbx
leaq 0x10(%rdi), %rbp
movq %rbp, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x41e0
movq 0x58(%rsp), %rax
movq 0x50(%rsp), %rcx
movq 0x48(%rsp), %rdx
mov... | /antonio-ramadas[P]nurse-rostering-solution/code/Contract.cpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::parser::parse_internal(bool) | basic_json parse_internal(bool keep)
{
auto result = basic_json(value_t::discarded);
switch (last_token)
{
case lexer::token_type::begin_object:
{
if (keep and (not callback
or ((keep = cal... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movb $0x8, (%rdi)
callq 0x8d80
movl 0x28(%r14), %edx
leal -0x1(%rdx), %eax
cmpl $0x8, %eax
ja 0xe6af
leaq 0xe5f4(%rip), %rcx # 0x1ca1c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::parser::expect(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, st... | void expect(typename lexer::token_type t) const
{
if (t != last_token)
{
std::string error_msg = "parse error - unexpected ";
error_msg += (last_token == lexer::token_type::parse_error ? ("'" + m_lexer.get_token_string() +
"'... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
cmpl %esi, 0x28(%rdi)
jne 0xeade
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %esi, %ebx
movq %rdi, %r14
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xe37f(%rip), %rsi # 0x1ce72
leaq 0xe391(%rip), %rdx ... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::parser::unexpect(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, ... | void unexpect(typename lexer::token_type t) const
{
if (t == last_token)
{
std::string error_msg = "parse error - unexpected ";
error_msg += (last_token == lexer::token_type::parse_error ? ("'" + m_lexer.get_token_string() +
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
cmpl %esi, 0x28(%rdi)
je 0xf754
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
leaq 0x78(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xd70b(%rip), %rsi # 0x1ce72
leaq 0xd71d(%rip), %rdx # 0x1ce8b
leaq 0x68(%rsp), %rdi
call... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::lexer::get_string() const | string_t get_string() const
{
assert(m_cursor - m_start >= 2);
string_t result;
result.reserve(static_cast<size_t>(m_cursor - m_start - 2));
// iterate the result between the quotes
for (const lexer_char_t* i = m_start + 1; i < m_cursor - 1; ++i)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq 0x60(%rsi), %rsi
subq 0x50(%r14), %rsi
cmpq $0x1, %rsi
jle 0xfc16
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
addq $-0x2, %rsi
callq 0x44a0... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::push_back(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::al... | void push_back(basic_json&& val)
{
// push_back only works for null objects or arrays
if (not(is_null() or is_array()))
{
JSON_THROW(std::domain_error("cannot use push_back() with " + type_name()));
}
// transform null object into an array
if (is_null())
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
je 0xfd4e
cmpl $0x2, %eax
je 0xfd76
movl $0x10, %edi
callq 0x41b0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x8ff0
leaq 0xd539(%rip), %rsi # 0x1d252
leaq 0x20(%rsp), %rdi
movq %rsp, %r... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::lexer::get_number(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>,... | bool get_number(basic_json& result, const token_type token) const
{
assert(m_start != nullptr);
assert(m_start < m_cursor);
assert((token == token_type::value_unsigned) or
(token == token_type::value_integer) or
(token == token_type::valu... | pushq %rbx
subq $0x20, %rsp
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0xfeb1
movq 0x60(%rdi), %rcx
cmpq %rcx, %rax
jae 0xfed0
movq %rsi, %rbx
leal -0x5(%rdx), %esi
cmpl $0x3, %esi
jae 0xfeef
movq %rax, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
cmpl $0x6, %edx
je 0xfe44
cmpl $0x5, %edx
jne 0xfe64
leaq 0x8(%rsp), %rdi
movq %rsp, %... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::lexer::get_token_string() const | string_t get_token_string() const
{
assert(m_start != nullptr);
return string_t(reinterpret_cast<typename string_t::const_pointer>(m_start),
static_cast<size_t>(m_cursor - m_start));
} | pushq %rbx
movq %rsi, %rax
movq 0x50(%rsi), %rsi
testq %rsi, %rsi
je 0xff33
movq %rdi, %rbx
movq 0x60(%rax), %rdx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
callq 0x59b2
movq %rbx, %rax
popq %rbx
retq
leaq 0xcde6(%rip), %rdi # 0x1cd20
leaq 0xb569(%rip), %rsi # 0x1b4aa
leaq 0xcf44(%rip), %rcx # 0x1ce8c
movl ... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::lexer::token_type_name(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<c... | static std::string token_type_name(const token_type t)
{
switch (t)
{
case token_type::uninitialized:
return "<uninitialized>";
case token_type::literal_true:
return "true literal";
case token_type::l... | pushq %rbx
movq %rdi, %rbx
cmpl $0xf, %esi
ja 0x100ce
movl %esi, %eax
leaq 0xcaf8(%rip), %rcx # 0x1ca60
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xd0a3(%rip), %rsi # 0x1d022
leaq 0xd0aa(%rip), %rdx # 0x1d030
jmp 0x100e3
leaq 0x10(%rbx), %rax
movq ... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::lexer::to_unicode(unsigned long, unsigned long) | static string_t to_unicode(const std::size_t codepoint1,
const std::size_t codepoint2 = 0)
{
// calculate the code point from the given code points
std::size_t codepoint = codepoint1;
// check if codepoint1 is a high surrogate
i... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rax
andq $-0x400, %rax # imm = 0xFC00
cmpq $0xd800, %rax # imm = 0xD800
jne 0x10132
movq %rdx, %rax
andq $-0x400, %rax # imm = 0xFC00
cmpq $0xdc00, %rax # imm = 0xDC00
jne 0x10260
s... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
bool nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::lexer::strtonum::parse<unsigned long>(unsigned long&, std::integral_constant<bool, true>) const | bool parse(T& value, /*is_integral=*/std::true_type) const
{
char* endptr = nullptr;
errno = 0; // these are thread-local
const auto x = parse_integral(&endptr, std::is_signed<T>());
// called right overload?
static_assert(std:... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq $0x0, (%r15)
callq 0x4050
movq %rax, %r12
movl $0x0, (%rax)
movq (%rbx), %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x4400
movq %rax, (%r14)
cmpl $0x0, (%r12)
jne 0x105f2
movq 0x8(%rbx), %rax
cmpq %rax, (%rbx)
ja... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
bool nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::lexer::strtonum::parse<long>(long&, std::integral_constant<bool, true>) const | bool parse(T& value, /*is_integral=*/std::true_type) const
{
char* endptr = nullptr;
errno = 0; // these are thread-local
const auto x = parse_integral(&endptr, std::is_signed<T>());
// called right overload?
static_assert(std:... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq $0x0, (%r15)
callq 0x4050
movq %rax, %r12
movl $0x0, (%rax)
movq (%rbx), %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x4090
movq %rax, (%r14)
cmpl $0x0, (%r12)
jne 0x10652
movq 0x8(%rbx), %rax
cmpq %rax, (%rbx)
ja... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
Exception::Exception(ExceptionsEnum, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Exception::Exception(ExceptionsEnum exception, const string &msg) {
this->exception = exception;
this->msg = msg;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x17475(%rip), %rax # 0x27d28
movq %rax, (%rdi)
leaq 0x10(%rdi), %r15
leaq 0x20(%rdi), %r12
movq %r12, 0x10(%rdi)
leaq 0xc90d(%rip), %rdx # 0x1d1d6
movq %r15, %rdi
movq %rdx, %rsi
callq 0x59b2
movl %ebp,... | /antonio-ramadas[P]nurse-rostering-solution/code/Exception.cpp |
Requirement::Requirement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long,... | Requirement::Requirement(string shiftType, string skill, const json &daysRequirements) {
this->shiftType = shiftType;
this->skill = skill;
const vector<string> DaysOfTheWeekVector = Scenario::getInstance()->getDaysOfTheWeekVector();
string requirementTxt = "requirementOn";
for (int i = 0; i < Day... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, 0x70(%rsp)
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %r13
leaq 0x30(%rdi), %r12
movq %r12, 0x20(%rdi)
movq %rax, 0x28(%rd... | /antonio-ramadas[P]nurse-rostering-solution/code/Requirement.cpp |
NurseSolution::hasHistoryConflict(Turn const*) const | const bool NurseSolution::hasHistoryConflict(const Turn *turnToCheck) const {
if (turnToCheck->getDay() != 0)
return false;
if (nurse->getHistory().getLastAssignedShiftType() == "None")
return false;
return Scenario::getInstance()->getShifts()
.at(nurse->getHistory().getLastAss... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x12dde
testl %eax, %eax
je 0x122e3
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rdi
callq 0xd968
movq %rax, %rdi
callq 0xb358
leaq 0xb643(%rip), %rsi # 0x1d93d
movq %rax, %rdi
callq 0x4100
testl %eax, %eax
j... | /antonio-ramadas[P]nurse-rostering-solution/code/solution/NurseSolution.cpp |
NurseSolution::hasTurnConflict(Turn const*, Turn const*) const | bool NurseSolution::hasTurnConflict(const Turn *turnToCheck, const Turn *turnToIgnore) const {
return any_of(begin(turns), end(turns), [&](Turn* turnElem) -> bool {
if (turnToIgnore != nullptr && turnElem->getId() == turnToIgnore->getId())
return false;
if (turnElem->getDay() == turnTo... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x18(%rsp), %rax
movq %rsi, (%rax)
leaq 0x10(%rsp), %rcx
movq %rdx, (%rcx)
movq 0x8(%rdi), %rbx
movq 0x10(%rdi), %r12
movq %rcx, (%rsp)
movq %rax, 0x8(%rsp)
movq %r12, %r13
subq %rbx, %r13
sarq $0x5, %r13
testq %r13, %r13
jle 0x123f4
incq %r13... | /antonio-ramadas[P]nurse-rostering-solution/code/solution/NurseSolution.cpp |
NurseSolution::removeTurn(Turn*) | const bool NurseSolution::removeTurn( Turn *turn) {
if (!hasTurn(turn))
return false;
turns.erase(find(begin(turns), end(turns), turn));
return true;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsi, (%rsp)
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
movq 0x8(%rdi), %rdi
movq 0x10(%rbx), %rsi
callq 0x126ae
movq %rax, %r14
movq 0x10(%rbx), %r15
cmpq %r15, %rax
je 0x124c0
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
movq %rsp, %rdx
callq 0x1274d
le... | /antonio-ramadas[P]nurse-rostering-solution/code/solution/NurseSolution.cpp |
Turn::Turn(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, ShiftType const*) | Turn::Turn(const int day, const string &skill, const ShiftType *shiftType) : day(day), shiftType(shiftType), skill(skill) {
id = CURRENT_ID++;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
addq $0x28, %rdi
leaq 0x38(%rbx), %rax
movq %rax, 0x28(%rbx)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x7... | /antonio-ramadas[P]nurse-rostering-solution/code/solution/Turn.cpp |
Turn::addNurse(NurseSolution*) | bool Turn::addNurse(NurseSolution * nurse){
if(!hasNurse(nurse)) {
nurses.push_back(nurse);
nurse->addTurn(this);
return true;
}
return false;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsi, (%rsp)
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
movq 0x8(%rdi), %rdi
movq 0x10(%rbx), %rsi
callq 0x12f9d
movq %rax, %r14
movq 0x10(%rbx), %r15
cmpq %r15, %rax
jne 0x12d91
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x12d79
movq (%rsp), %rax
m... | /antonio-ramadas[P]nurse-rostering-solution/code/solution/Turn.cpp |
Turn::removeTurn(NurseSolution*) | const bool Turn::removeTurn(NurseSolution *nurseSolution) {
if (!hasNurse(nurseSolution) || !nurseSolution->hasTurn(this))
return false;
nurses.erase(find(begin(nurses), end(nurses), nurseSolution));
nurseSolution->removeTurn(this);
return true;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsi, (%rsp)
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
movq 0x8(%rdi), %rdi
movq 0x10(%rbx), %rsi
callq 0x12f9d
cmpq 0x10(%rbx), %rax
je 0x12e56
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0x120ec
testb %al, %al
je 0x12e56
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
movq %rsp, %... | /antonio-ramadas[P]nurse-rostering-solution/code/solution/Turn.cpp |
Validator::constraintH3(Solution const&) | bool Validator::constraintH3(const Solution &solution) {
map<string, NurseSolution *> nurses = solution.getNurses();
for(auto const &nurse : nurses)
{
vector<Turn *> turns = nurse.second->getTurns();
string lastShiftString = nurse.second->getNurse()->getHistory().getLastAssignedShiftType();... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
callq 0x11668
leaq 0x88(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x151fe
movq 0x18(%rbx), %r15
leaq 0x90(%rsp), %rax
cmpq %rax, %r15
sete %bpl
je 0x136c7
leaq 0x18(%rsp), %rbx
leaq 0x38(%rsp), %r14
movq 0x40(%r15), %rdi
callq 0x... | /antonio-ramadas[P]nurse-rostering-solution/code/Validator.cpp |
Validator::constraintS1(Solution const&) | unsigned int Validator::constraintS1(const Solution &solution) {
unsigned int sum = 0;
for(vector<Turn *> day : solution.getTurns())
for(Turn * turn : day){
unsigned long nNurses = turn->getNurses().size();
int optimal = Scenario::getInstance()->getWeekData().getRequirements().... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
callq 0x1166e
movq (%rax), %rsi
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
xorl %ebp, %ebp
cmpq %rax, %rsi
je 0x1388d
movq %rsp, %rdi
movq %rsi, 0x20(%rsp)
callq 0x119f2
movq (%rsp), %r13
movq 0x8(%rsp), %rbx
cmpq %rbx, %r13
je 0x13863
m... | /antonio-ramadas[P]nurse-rostering-solution/code/Validator.cpp |
Validator::constraintS2(Solution const&) | unsigned int Validator::constraintS2(const Solution &solution){
unsigned int sum = 0;
for(auto const &nurse : solution.getNurses())
{
Contract contract = Scenario::getInstance()->getContract(nurse.second->getNurse()->getContract());
int numberOfConsecutiveAssignments = nurse.s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
callq 0x11668
movq 0x18(%rax), %rbp
addq $0x8, %rax
movq %rax, 0x40(%rsp)
cmpq %rax, %rbp
je 0x13f80
leaq 0xa8(%rsp), %r12
leaq 0x28(%rsp), %r15
movq $0x0, 0x8(%rsp)
leaq 0x68(%rsp), %r14
callq 0x7328
movq %rax, %rbx
movq 0x40(%rbp), %rd... | /antonio-ramadas[P]nurse-rostering-solution/code/Validator.cpp |
Validator::constraintS3(Solution const&) | unsigned int Validator::constraintS3(const Solution &solution) {
unsigned int sum = 0;
for(auto const &nurse : solution.getNurses())
{
int numberOfConsecutiveDaysOff = nurse.second->getNurse()->getHistory().getNumberOfConsecutiveDaysOff();
int lastDay = - (numberOfConsecutiveDaysOff + 1);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
callq 0x11668
movq 0x18(%rax), %rbx
addq $0x8, %rax
movq %rax, 0xd8(%rsp)
cmpq %rax, %rbx
je 0x14393
movl $0x0, 0xc(%rsp)
leaq 0x18(%rsp), %r12
movq 0x40(%rbx), %rdi
callq 0x1211c
movq %rax, %rdi
callq 0xd968
movq %rax, %rdi
callq 0xb350... | /antonio-ramadas[P]nurse-rostering-solution/code/Validator.cpp |
Validator::constraintS5(Solution const&) | unsigned int Validator::constraintS5(const Solution &solution) {
unsigned int sum = 0;
for(auto const &nurse : solution.getNurses())
if(Scenario::getInstance()->getContract(nurse.second->getNurse()->getContract()).getCompleteWeekends())
{
if(nurseWorkingHalfWeekEnd(nurse.se... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
callq 0x11668
movq %rax, %rbx
movq 0x18(%rax), %r14
addq $0x8, %rbx
xorl %r15d, %r15d
cmpq %rbx, %r14
je 0x14902
leaq 0x8(%rsp), %r12
leaq 0x28(%rsp), %r13
callq 0x7328
movq %rax, %rbp
movq 0x40(%r14), %rdi
callq 0x1211c
movq %rax, %rdi
... | /antonio-ramadas[P]nurse-rostering-solution/code/Validator.cpp |
Validator::nurseWorkingHalfWeekEnd(NurseSolution*) | bool Validator::nurseWorkingHalfWeekEnd(NurseSolution *nurse){
vector<Turn *> turns = nurse->getTurns();
if(turns.size() > 1)
{
if(turns[turns.size() - 1]->getDay() == 6)
if(turns[turns.size() - 2]->getDay() != 5)
return true;
if(turns[turns.size() - 1]->getDay(... | pushq %rbx
subq $0x20, %rsp
callq 0x12116
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x119f2
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
cmpq $0x9, %rcx
jb 0x149bf
movq -0x8(%rax,%rcx), %rdi
callq 0x12dde
cmpl $0x6, %eax
jne 0x149aa
movq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
callq 0x12dde
m... | /antonio-ramadas[P]nurse-rostering-solution/code/Validator.cpp |
Validator::constraintS6(Solution const&) | unsigned int Validator::constraintS6(const Solution &solution){
unsigned int sum = 0;
for(auto const &nurse : solution.getNurses())
{
int totalAssignments = nurse.second->getNurse()->getHistory().getNumberOfAssignments();
totalAssignments += nurse.second->getTurns().size();
Contrac... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
callq 0x11668
movq 0x18(%rax), %r15
addq $0x8, %rax
movq %rax, 0x10(%rsp)
cmpq %rax, %r15
je 0x14b4b
leaq 0x28(%rsp), %r12
movq $0x0, (%rsp)
leaq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%r15), %rdi
callq 0x1211c
movq %rax, %rdi
c... | /antonio-ramadas[P]nurse-rostering-solution/code/Validator.cpp |
Validator::constraintS7(Solution const&) | unsigned int Validator::constraintS7(const Solution &solution){
unsigned int sum = 0;
for(auto const &nurse : solution.getNurses())
{
int numberOfWorkingWeekends = nurse.second->getNurse()->getHistory().getNumberOfWorkingWeekends();
if(nurse.second->getTurns().size() > 0)
if(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
callq 0x11668
movq %rax, %rbx
movq 0x18(%rax), %r14
addq $0x8, %rbx
cmpq %rbx, %r14
je 0x14db9
movl $0x0, 0x4(%rsp)
leaq 0x48(%rsp), %r12
movq 0x40(%r14), %rdi
callq 0x1211c
movq %rax, %rdi
callq 0xd968
movq %rax, %rdi
callq 0xb338
movl ... | /antonio-ramadas[P]nurse-rostering-solution/code/Validator.cpp |
Validator::evaluateSolution(Solution const&) | unsigned int Validator::evaluateSolution(const Solution &solution){
unsigned int sum = 0;
sum += constraintS1(solution);
sum += constraintS2(solution);
sum += constraintS3(solution);
sum += constraintS4(solution);
sum += constraintS5(solution);
sum += constraintS6(solution);
sum += con... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x13752
movl %eax, %ebp
movq %rbx, %rdi
callq 0x138de
movl %eax, %r14d
addl %ebp, %r14d
movq %rbx, %rdi
callq 0x14002
movl %eax, %ebp
movq %rbx, %rdi
callq 0x144ce
movl %eax, %r15d
addl %ebp, %r15d
addl %r14d, %r15d
movq %rbx, %rdi
callq 0x148... | /antonio-ramadas[P]nurse-rostering-solution/code/Validator.cpp |
Validator::printEvaluation(Solution const&) | void Validator::printEvaluation(const Solution &solution){
unsigned int sum = 0;
cout << "S1 : " << constraintS1(solution) << endl;
sum += constraintS1(solution);
cout << "S2 : " << constraintS2(solution) << endl;
sum += constraintS2(solution);
cout << "S3 : " << constraintS3(solution) << endl;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0x130d8(%rip), %rbx # 0x27fb0
leaq 0x8a63(%rip), %rsi # 0x1d942
movl $0x5, %edx
movq %rbx, %rdi
callq 0x4380
movq %r14, %rdi
callq 0x13752
movl %eax, %esi
movq %rbx, %rdi
callq 0x4240
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax),... | /antonio-ramadas[P]nurse-rostering-solution/code/Validator.cpp |
HillClimbing::runHillClimbing(Solution*) | Solution* HillClimbing::runHillClimbing(Solution* solution){
SolutionNeighbourhood* neighbourhood = new SolutionNeighbourhood(solution);
int bestScore = Validator::evaluateSolution(*solution);
//next will undo last move so it can reset the initial solution
while((solution = neighbourhood->getNext()) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x40, %edi
callq 0x4320
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x15894
movq %r14, %rdi
callq 0x14e5a
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1593e
movq %rax, %r14
testq %rax, %rax
je 0x1584a
movq %rbx, %rdi
callq 0x166e6
testb %... | /antonio-ramadas[P]nurse-rostering-solution/code/algorithms/HillClimbing.cpp |
SolutionNeighbourhood::SolutionNeighbourhood(Solution*) | SolutionNeighbourhood::SolutionNeighbourhood(Solution* solution) : solution(solution){
this->phase = 0;
this->iterator1 = 0;
this->iterator2 = 0;
this->iteratorTurn1 = 0;
this->iteratorTurn2 = 0;
for(auto it = solution->getNurses().begin(); it != solution->getNurses().end(); ++it ) {
th... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, (%rdi)
leaq 0x10(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movq $0x0, 0x35(%rdi)
movq %rsi, %rdi
callq 0x11668
movq 0x18(%rax), %r12
movq %r15, %rdi
callq 0x11... | /antonio-ramadas[P]nurse-rostering-solution/code/algorithms/SolutionNeighbourhood.cpp |
SolutionNeighbourhood::getNext() | Solution *SolutionNeighbourhood::getNext(){
undoLastMove();
if(phase == 0) {
while (1) {
Turn *currentTurn = solution->getTurns()[iterator1][iterator2];
if (currentTurn->getNurses().size() <
Scenario::getInstance()->getWeekData().getRequirements().at(currentTurn-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdi, %rbx
callq 0x16192
movl 0x28(%rbx), %eax
testl %eax, %eax
je 0x15d1b
cmpl $0x1, %eax
jne 0x15d12
movslq 0x2c(%rbx), %rax
movq 0x18(%rbx), %rcx
subq 0x10(%rbx), %rcx
sarq $0x3, %rcx
cmpq %rax, %rcx
jbe... | /antonio-ramadas[P]nurse-rostering-solution/code/algorithms/SolutionNeighbourhood.cpp |
SolutionNeighbourhood::undoLastMove() | void SolutionNeighbourhood::undoLastMove(){
if(lastMove == nullptr)
return;
vector<Turn*> day1 , day2;
switch (lastMove->getMoveType())
{
case 0:
//insert so we have to remove
day1 = solution->getTurns()[lastMove->getLastPosition().getDay()];
for(Turn*... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x1665b
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movq %rax, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
callq 0x18d6e
testl %eax, %eax
je 0x163d5
cmpl ... | /antonio-ramadas[P]nurse-rostering-solution/code/algorithms/SolutionNeighbourhood.cpp |
Writter::WriteSolutionToJSONFile(Solution const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void Writter::WriteSolutionToJSONFile(const Solution *solution, string path) {
if (path == "")
path = solPath;
json j;
j["scenario"] = Scenario::getInstance()->getId();
j["week"] = Scenario::getInstance()->getCurrentWeek();
j["assignments"] = json::array();
vector<string> weekDays = {... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x328, %rsp # imm = 0x328
movq %rsi, %rax
movq %rdi, 0x20(%rsp)
leaq 0x69f2(%rip), %rsi # 0x1d1d6
movq %rax, 0x18(%rsp)
movq %rax, %rdi
callq 0x4100
testl %eax, %eax
jne 0x16806
leaq 0x11b54(%rip), %rsi # 0x28350
movq 0x18(%rsp)... | /antonio-ramadas[P]nurse-rostering-solution/code/Writter.cpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::basic_json(std::initializer_list<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::cha... | basic_json(std::initializer_list<basic_json> init,
bool type_deduction = true,
value_t manual_type = value_t::array)
{
// check if each element is an array with two elements whose first
// element is a string
bool is_an_object = std::all_of(init.begin(), init.en... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movb $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
shlq $0x4, %r15
addq %rsi, %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0x17867
xorl %ecx, %ecx
cmpq %r15, %rax
se... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::basic_json<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string... | basic_json(CompatibleType && val) noexcept(noexcept(JSONSerializer<U>::to_json(
std::declval<basic_json_t&>(), std::forward<CompatibleType>(val))))
{
JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
assert_invariant();
} | pushq %rbx
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
movb $0x3, (%rdi)
movq %rsi, %rdi
callq 0xa1ee
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x8d80
movq %rbx, %rdi
popq %rbx
jmp 0x8d80
| /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::push_back(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::ba... | void push_back(const typename object_t::value_type& val)
{
// push_back only works for null objects or objects
if (not(is_null() or is_object()))
{
JSON_THROW(std::domain_error("cannot use push_back() with " + type_name()));
}
// transform null object into an obj... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
je 0x17568
cmpl $0x1, %eax
je 0x175a4
movl $0x10, %edi
callq 0x41b0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x8ff0
leaq 0x5d1f(%rip), %rsi # 0x1d252
leaq 0x20(%rsp), %rdi
movq %rsp, ... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
void nlohmann::detail::to_json<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>, char [6], 0>(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<cha... | void to_json(BasicJsonType& j, const CompatibleString& s)
{
external_constructor<value_t::string>::construct(j, s);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rsi, %rdi
callq 0x4180
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x59b2
movb $0x3, (%rbx)
movq %r15, %rdi
callq 0xa1ee
movq %rax, 0x8(%r... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::operator[](unsigned long) const | const_reference operator[](size_type idx) const
{
// const operator[] only works for arrays
if (is_array())
{
return m_value.array->operator[](idx);
}
JSON_THROW(std::domain_error("cannot use operator[] with " + type_name()));
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpb $0x2, (%rdi)
jne 0x179bb
movq 0x8(%r14), %rax
shlq $0x4, %rsi
addq (%rax), %rsi
movq %rsi, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x41b0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x8ff0
leaq 0x3cf... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
void nlohmann::detail::to_json<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>, char [10], 0>(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<ch... | void to_json(BasicJsonType& j, const CompatibleString& s)
{
external_constructor<value_t::string>::construct(j, s);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rsi, %rdi
callq 0x4180
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x59b2
movb $0x3, (%rbx)
movq %r15, %rdi
callq 0xa1ee
movq %rax, 0x8(%r... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::dump(std::ostream&, bool, unsigned int, unsigned int) const | void dump(std::ostream& o,
const bool pretty_print,
const unsigned int indent_step,
const unsigned int current_indent = 0) const
{
// variable to hold indentation for recursive calls
unsigned int new_indent = current_indent;
switch (m_type)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %ecx, (%rsp)
movzbl (%rdi), %eax
cmpq $0x8, %rax
ja 0x18415
movl %r8d, %ebp
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x5b32(%rip), %rcx # 0x1d980
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3888(%r... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::escape_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static string_t escape_string(const string_t& s)
{
const auto space = extra_space(s);
if (space == 0)
{
return s;
}
// create a result string of necessary size
string_t result(s.size() + space, '\\');
std::size_t pos = 0;
for (const auto&... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x18676
testq %rax, %rax
je 0x18652
addq 0x8(%r14), %rax
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
movq %rax, %rsi
movl $0x5c, %edx
callq 0x43a0
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x1866b
movq (%r14), %rcx
addq %r... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
void nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::numtostr::x_write<long>(long, std::integral_constant<bool, true>) | void x_write(NumberType x, /*is_integral=*/std::true_type)
{
// special case for "0"
if (x == 0)
{
m_buf[0] = '0';
return;
}
const bool is_negative = x < 0;
size_t i = 0;
// spare 1 byte for '\0... | pushq %rax
testq %rsi, %rsi
je 0x1876d
xorl %r8d, %r8d
movabsq $0x6666666666666667, %r9 # imm = 0x6666666666666667
movq %rsi, %rcx
cmpq $0x3f, %r8
je 0x18772
movq %rcx, %rax
imulq %r9
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x2, %rdx
addq %rax, %rdx
leaq (%rdx,%rdx), %rax
leaq (%rax,%rax,4), %rax
movq %rcx, %r10
subq %r... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
void nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::numtostr::x_write<unsigned long>(unsigned long, std::integral_constant<bool, true>) | void x_write(NumberType x, /*is_integral=*/std::true_type)
{
// special case for "0"
if (x == 0)
{
m_buf[0] = '0';
return;
}
const bool is_negative = x < 0;
size_t i = 0;
// spare 1 byte for '\0... | pushq %rax
testq %rsi, %rsi
je 0x1881d
leaq -0x1(%rdi), %rcx
movl $0x3f, %r8d
movabsq $-0x3333333333333333, %r9 # imm = 0xCCCCCCCCCCCCCCCD
subq $0x1, %r8
jb 0x18822
movq %rsi, %rax
mulq %r9
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %esi, %r10d
subl %eax, %r10d
orb $0x30, %r10b
movb %r10b, 0x1... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
void nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::numtostr::x_write<double>(double, std::integral_constant<bool, false>) | void x_write(NumberType x, /*is_integral=*/std::false_type)
{
// special case for 0.0 and -0.0
if (x == 0)
{
size_t i = 0;
if (std::signbit(x))
{
m_buf[i++] = '-';
}
m_buf[i++]... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x18867
jp 0x18867
movq %xmm0, %rax
testq %rax, %rax
js 0x188b3
xorl %eax, %eax
jmp 0x188bb
leaq 0x54ba(%rip), %rdx # 0x1dd28
movl $0x40, %esi
movq %rbx, %rdi
movl $0xf, %ecx
movb $0x1, %al
callq 0x44b0
te... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
Move::Move(Position, Position, NurseSolution*, NurseSolution*) | Move::Move(Position initialPosition,Position lastPosition, NurseSolution* movedNurse, NurseSolution* tradedNurse) : initialPosition(initialPosition), lastPosition(lastPosition), movedNurse(movedNurse) , tradedNurse(tradedNurse){} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rdi, %r15
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
leaq 0x10(%rdi), %r12
leaq 0x20(%rdi), %rbp
movq %rbp, 0x10(%rdi)
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
addq %rax, %rdx
movq %r12, %... | /antonio-ramadas[P]nurse-rostering-solution/code/algorithms/Move.cpp |
Move::Move(Position, Position, NurseSolution*) | Move::Move(Position initialPosition,Position lastPosition, NurseSolution* movedNurse) : initialPosition(initialPosition), lastPosition(lastPosition), movedNurse(movedNurse){} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r12
movq %rdi, %r14
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
leaq 0x10(%rdi), %r15
leaq 0x20(%rdi), %r13
movq %r13, 0x10(%rdi)
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
addq %rax, %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x7f78
movu... | /antonio-ramadas[P]nurse-rostering-solution/code/algorithms/Move.cpp |
Move::Move(Position, NurseSolution*) | Move::Move(Position initialPosition, NurseSolution* movedNurse) : initialPosition(initialPosition), movedNurse(movedNurse){} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %r15
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %r12
movq %r12, 0x10(%rdi)
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7f78
lea... | /antonio-ramadas[P]nurse-rostering-solution/code/algorithms/Move.cpp |
Move::getMoveType() | int Move::getMoveType(){
//If not nullptr, so it was a trade
if(tradedNurse != nullptr)
return 2;
//if last position is not valid, then nurse was removed
else if(!lastPosition.positionValid())
return 1;
//if not, nurse was added
else return 0;
} | movl $0x2, %eax
cmpq $0x0, 0x68(%rdi)
je 0x18d7b
retq
pushq %rax
addq $0x30, %rdi
callq 0x18db4
xorb $0x1, %al
movzbl %al, %eax
addq $0x8, %rsp
retq
nop
| /antonio-ramadas[P]nurse-rostering-solution/code/algorithms/Move.cpp |
InputParser::getCmdOption(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | const string InputParser::getCmdOption(const string &option) {
vector<string>::const_iterator itr;
itr = find(this->tokens.begin(), this->tokens.end(), option);
if (itr != this->tokens.end() && ++itr != this->tokens.end())
return removeQuotes(*itr);
return "";
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
callq 0x19009
movq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x18ebf
addq $0x20, %rax
cmpq %rcx, %rax
je 0x18ebf
movq %rbx, %rdi
movq %rax, %rdx
callq 0x18ee4
jmp 0x18ed8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4309(... | /antonio-ramadas[P]nurse-rostering-solution/code/InputParser.cpp |
InputParser::removeQuotes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | string InputParser::removeQuotes(const string &sentence) {
string ret(sentence);
if (ret.at(0) == '"' && ret.at(ret.size()-1) == '"')
ret = ret.substr(1, ret.size()-2);
return ret;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x7f78
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x18f67
movq (%rbx), %rax
cmpb $0x22, (%rax)
jne 0x18f5a
cmpb $0x22, -0x1(%rax,%rcx)
jne 0x18f5a
addq $-0... | /antonio-ramadas[P]nurse-rostering-solution/code/InputParser.cpp |
ConstructionHeuristics::FirstFit(Solution*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Solution *ConstructionHeuristics::FirstFit(Solution *solution, const string &skillId) {
auto rbegin = solution->getTurns().rbegin();
auto rend = solution->getTurns().rend();
for (auto dayIndex = rbegin; dayIndex != rend; dayIndex++)
assignGivenDay(solution, (unsigned int) distance(dayIndex, rend)-1... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1166e
movq 0x8(%rax), %r15
movq %rbx, %rdi
callq 0x1166e
movq (%rax), %r12
movq %r15, %r13
subq %r12, %r13
je 0x19192
movq %r13, %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %esi # imm = 0xAAAAAAAB
decl %esi
movq %rbx, %rdi
... | /antonio-ramadas[P]nurse-rostering-solution/code/algorithms/ConstructionHeuristics.cpp |
ConstructionHeuristics::assignGivenDay(Solution*, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void ConstructionHeuristics::assignGivenDay(Solution *solution, unsigned int dayIndex, const string &skillId) {
int minimum;
for (Turn *turn : solution->getTurns().at(dayIndex)) {
if (!skillId.empty() && turn->getSkill() != skillId)
continue;
minimum = Scenario::getInstance()->getWe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, (%rsp)
movl %esi, %ebx
movq %rdi, %r14
callq 0x1166e
movl %ebx, 0x8(%rsp)
movl %ebx, %esi
movq (%rax), %rcx
movq 0x8(%rax), %rax
subq %rcx, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imu... | /antonio-ramadas[P]nurse-rostering-solution/code/algorithms/ConstructionHeuristics.cpp |
ConstructionHeuristics::MoreSkilled(Solution*) | Solution *ConstructionHeuristics::MoreSkilled(Solution *solution) {
map<unsigned int, string> counter = countNurseSkills();
for (auto &it : counter)
solution = FirstFit(solution, it.second);
return solution;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x19370
movq 0x18(%r14), %r14
leaq 0x8(%rsp), %r15
cmpq %r15, %r14
je 0x19347
leaq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x19140
movq %r14, %rdi
callq 0x4260
movq %rax, %r14
cmpq %r15, %rax
jne 0x1932b
movq %rsp, %r... | /antonio-ramadas[P]nurse-rostering-solution/code/algorithms/ConstructionHeuristics.cpp |
ConstructionHeuristics::countNurseSkills[abi:cxx11]() | map<unsigned int, string> ConstructionHeuristics::countNurseSkills() {
unordered_map<string, unsigned int> counter;
for (const string &skill : Scenario::getInstance()->getSkills())
counter.insert(make_pair(skill, 0));
for (const Nurse &nurse : Scenario::getInstance()->getNurses())
for (con... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x60(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
callq 0x7328
movq %rax, %rdi
callq... | /antonio-ramadas[P]nurse-rostering-solution/code/algorithms/ConstructionHeuristics.cpp |
ConstructionHeuristics::RequestsFirst(Solution*) | Solution* ConstructionHeuristics::RequestsFirst(Solution* solution){
default_random_engine generator((unsigned int) chrono::system_clock::now().time_since_epoch().count());
uniform_int_distribution<int> distribution(0, (int) solution->getNurses().size()-1);
auto random = bind(distribution, generator);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdi, %r15
callq 0x4060
movl %eax, %ecx
movabsq $0x200000005, %rdx # imm = 0x200000005
movq %rcx, %rax
mulq %rdx
movq %rdx, %rbx
movq %rdx, %rax
shlq $0x1f, %rax
subq %rax, %rbx
leaq (%rcx,%rbx), %rax
... | /antonio-ramadas[P]nurse-rostering-solution/code/algorithms/ConstructionHeuristics.cpp |
ConstructionHeuristics::randomIteration(Solution*) | Solution* ConstructionHeuristics::randomIteration(Solution * solution) {
default_random_engine generator((unsigned int) chrono::system_clock::now().time_since_epoch().count());
uniform_int_distribution<int> distribution(0, (int) solution->getNurses().size()-1);
auto random = bind(distribution, generator);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
callq 0x4060
movl %eax, %ecx
movabsq $0x200000005, %rdx # imm = 0x200000005
movq %rcx, %rax
mulq %rdx
movq %rdx, %r14
movq %rdx, %rax
shlq $0x1f, %rax
subq %rax, %r14
leaq (%rcx,%r14), %rax
cmpq $0x1, %rax
adcq %rcx,... | /antonio-ramadas[P]nurse-rostering-solution/code/algorithms/ConstructionHeuristics.cpp |
ShiftOffRequest::operator==(ShiftOffRequest const&) | bool operator== (const ShiftOffRequest& shiftOffRequest) {
return nurse ==shiftOffRequest.getNurse() || day == shiftOffRequest.getDay() || shiftType ==shiftOffRequest.getShiftType();
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x11238
movq 0x8(%rbx), %rdx
cmpq 0x8(%rax), %rdx
jne 0x1a921
movb $0x1, %bpl
testq %rdx, %rdx
je 0x1a97d
movq (%rax), %rsi
movq (%rbx), %rdi
callq 0x4340
testl %eax, %eax
je 0x1a97d
movq %r14, %rdi
callq 0x11242
movq 0x48(%rbx), %rd... | /antonio-ramadas[P]nurse-rostering-solution/code/algorithms/../solution/../ShiftOffRequest.h |
print_lines3(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void print_lines3(const std::string& text_)
{
std::list<std::string> v;
just::lines::split(text_, v);
print(v.begin(), v.end());
} | pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rsi
movq %rsi, 0x8(%rsi)
movq %rsi, (%rsi)
movq $0x0, 0x10(%rsi)
callq 0x43b8
leaq 0x8(%rsp), %rsi
movq (%rsi), %rdi
callq 0x3955
leaq 0x8(%rsp), %rdi
callq 0x39be
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x39be
movq %rbx, %rdi
callq 0x3170
| /sabel83[P]just/libs/lines/example/multiple_lines/main.cpp |
main | int main()
{
const std::string text = "hello\nworld!\r\nfoo\rbar\n";
print_lines1(text);
print_lines2(text);
print_lines3(text);
print_lines4(text);
print_lines5(text);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x19c6(%rip), %rsi # 0x5004
leaq 0x19d5(%rip), %rdx # 0x501a
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x4c2e
movq %rbx, %rdi
callq 0x336c
leaq 0x8(%rsp), %rdi
callq 0x3423
leaq 0x8(%rsp), %rdi
callq 0x3469
leaq 0x8(%rsp... | /sabel83[P]just/libs/lines/example/multiple_lines/main.cpp |
void print<just::lines::iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>>(just::lines::iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>, jus... | void print(InputIt begin_, InputIt end_)
{
for (InputIt i = begin_; i != end_; ++i)
{
std::cout << *i << std::endl;
}
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb 0x10(%rdi), %al
leaq 0x18(%rsp), %rdi
movb %al, -0x8(%rdi)
movups (%r14), %xmm0
movaps %xmm0, -0x18(%rdi)
leaq 0x28(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rdx
addq %rsi, %rdx
... | /sabel83[P]just/libs/lines/example/multiple_lines/main.cpp |
just::lines::iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>::iterator(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char c... | iterator(InputIt begin_, InputIt end_) :
_at(begin_),
_end(end_),
_at_end(false),
_current(),
_last_char(0)
{
if (_at != _end)
{
if (*_at != '\n')
{
++(*this);
}
else if (KeepNewlines)
{
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x28(%rdi), %r15
movq %r15, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
movb %al, 0x28(%rdi)
movb %al, 0x38(%rdi)
cmpq %rdx, %rsi
je 0x3a87
cmpb $0xa, (%rsi)
je 0x3a87
movq %rdi, %rbx
callq 0x3aac
popq %rbx
popq %r14
... | /sabel83[P]just/include/just/lines.hpp |
just::lines::iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>::next_char() | void next_char()
{
assert(!_at_end);
assert(_at != _end);
_last_char = *_at;
++_at;
} | pushq %rax
cmpb $0x1, 0x10(%rdi)
je 0x3b65
movq (%rdi), %rax
cmpq 0x8(%rdi), %rax
je 0x3b84
movb (%rax), %cl
movb %cl, 0x38(%rdi)
incq %rax
movq %rax, (%rdi)
popq %rax
retq
leaq 0x14af(%rip), %rdi # 0x501b
leaq 0x14b1(%rip), %rsi # 0x5024
leaq 0x15f9(%rip), %rcx # 0x5173
movl $0x96, %edx
callq 0x3090
lea... | /sabel83[P]just/include/just/lines.hpp |
just::lines::impl::ignore_second<void, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::const_iterator>::type just::lines::split<false, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::list<std::__cxx11::basic_string<char, std::char_traits<char... | typename impl::ignore_second<void, typename String::const_iterator>::type
split(const String& s_, Container& out_)
{
std::copy(
begin_lines<KeepNewlines>(s_),
end_lines<KeepNewlines>(s_),
std::back_inserter(out_)
);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x3a4e
xorps %xmm0, %xmm0
leaq 0x28(%rsp), %r15
movaps %xmm0, -0x28(%r15)
movb $0x1, -0x18(%r15)
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%... | /sabel83[P]just/include/just/lines.hpp |
ncnn::Mat::create(int, int, int, unsigned long, ncnn::Allocator*) | void Mat::create(int _w, int _h, int _c, size_t _elemsize, Allocator* _allocator)
{
if (dims == 3 && w == _w && h == _h && c == _c && elemsize == _elemsize && elempack == 1 && allocator == _allocator)
return;
release();
elemsize = _elemsize;
elempack = 1;
allocator = _allocator;
dims ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movl %ecx, %ebp
movl %edx, %r12d
movl %esi, %r13d
movq %rdi, %rbx
cmpl $0x3, 0x28(%rdi)
jne 0x6ecd5
cmpl %r13d, 0x2c(%rbx)
jne 0x6ecd5
cmpl %r12d, 0x30(%rbx)
jne 0x6ecd5
cmpl %ebp, 0x38(%rbx)
jne 0x6ecd5
cmpq %r15... | /ysh329[P]ncnn/src/mat.cpp |
ncnn::Mat::create(int, int, int, int, unsigned long, ncnn::Allocator*) | void Mat::create(int _w, int _h, int _d, int _c, size_t _elemsize, Allocator* _allocator)
{
if (dims == 4 && w == _w && h == _h && d == _d && c == _c && elemsize == _elemsize && elempack == 1 && allocator == _allocator)
return;
release();
elemsize = _elemsize;
elempack = 1;
allocator = _al... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movl %r8d, %ebp
movl %ecx, %r12d
movl %edx, %r13d
movl %esi, %r14d
movq %rdi, %rbx
movq 0x40(%rsp), %rdi
movdqu 0x28(%rbx), %xmm0
movd %ecx, %xmm1
movd %edx, %xmm2
punpckldq %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[... | /ysh329[P]ncnn/src/mat.cpp |
ncnn::Mat::substract_mean_normalize(float const*, float const*) | void Mat::substract_mean_normalize(const float* mean_vals, const float* norm_vals)
{
Layer* op;
if (mean_vals && !norm_vals)
{
// substract mean only
op = create_layer(LayerType::Bias);
ParamDict pd;
pd.set(0, c);
op->load_param(pd);
Mat weights[1];
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rsi, %r15
movq %rdi, %rbx
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
setne %cl
orb %al, %cl
je 0x6f0ad
movq %rdx, %r12
testq %rdx, %rdx
sete %al
testq %r15, %r15
setne %cl
orb %al, %cl
jne 0x6f16f
pushq $0x1d
popq %rdi
callq 0x5c461
movq %rax... | /ysh329[P]ncnn/src/mat.cpp |
ncnn::cast_float32_to_bfloat16(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) | void cast_float32_to_bfloat16(const Mat& src, Mat& dst, const Option& opt)
{
Layer* cast = create_layer(LayerType::Cast);
ParamDict pd;
pd.set(0, 1);
pd.set(1, 4);
cast->load_param(pd);
cast->create_pipeline(opt);
cast->forward(src, dst, opt);
cast->destroy_pipeline(opt);
delet... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x40
popq %rdi
callq 0x5c461
movq %rax, %rbx
movq %rsp, %r13
movq %r13, %rdi
callq 0x7bfe4
pushq $0x1
popq %rdx
movq %r13, %rdi
xorl %esi, %esi
callq 0x7c3d6
movq %rsp, %rdi
pushq $0x1
popq %rs... | /ysh329[P]ncnn/src/mat.cpp |
ncnn::quantize_to_int8(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Option const&) | void quantize_to_int8(const Mat& src, Mat& dst, const Mat& scale_data, const Option& opt)
{
Layer* quantize = create_layer(LayerType::Quantize);
ParamDict pd;
pd.set(0, scale_data.w);
quantize->load_param(pd);
Mat weights[1];
weights[0] = scale_data;
quantize->load_model(ModelBinFromMatA... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
pushq $0x39
popq %rdi
callq 0x5c461
movq %rax, %r14
leaq 0x58(%rsp), %rbp
movq %rbp, %rdi
callq 0x7bfe4
movl 0x2c(%r13), %edx
movq %rbp, %rdi
xorl %esi, %esi
callq 0x7c3d6
m... | /ysh329[P]ncnn/src/mat.cpp |
ncnn::Extractor::Extractor(ncnn::Extractor const&) | Extractor::Extractor(const Extractor& rhs)
: d(new ExtractorPrivate(0))
{
d->net = rhs.d->net;
d->blob_mats = rhs.d->blob_mats;
d->opt = rhs.d->opt;
#if NCNN_VULKAN
d->local_blob_vkallocator = 0;
d->local_staging_vkallocator = 0;
d->blob_mats_gpu = rhs.d->blob_mats_gpu;
d->blob_mats_gp... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3d1c7c(%rip), %rax # 0x44be00
movq %rax, (%rdi)
pushq $0x60
popq %rdi
callq 0x573c0
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
callq 0x7ad88
movq %r15, 0x8(%rbx)
movq 0x8(%r14), %rsi
movq (%rsi), %rax
movq %rax, (%r15)
addq $0x8, %rsi
addq ... | /ysh329[P]ncnn/src/net.cpp |
ncnn::BatchNorm_x86_avx512::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int BatchNorm_x86_avx512::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int dims = bottom_top_blob.dims;
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int d = bottom_top_blob.d;
int c = bottom_top_blob.c;
int elempack = bottom_top_blob.elempack;
if (dims == 1)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x18(%rsi), %eax
movl 0x28(%rsi), %r10d
movl 0x2c(%rsi), %ecx
movl 0x30(%rsi), %r9d
movl 0x34(%rsi), %r8d
movl 0x38(%rsi), %edx
cmpl $0x2, %r10d
movl %r8d, -0x8(%rsp)
movl %r9d, -0xc(%rsp)
movl %r10d, -0x4(%rsp)
je 0x7d937
cmpl $0x1, %r10d
jne 0x7da... | /ysh329[P]ncnn/build_O2/src/layer/x86/batchnorm_x86_avx512.cpp |
ncnn::Convolution::forward_int8(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Convolution::forward_int8(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
int w = bottom_blob.w;
int h = bottom_blob.h;
int channels = bottom_blob.c;
size_t elemsize = bottom_blob.elemsize;
// NCNN_LOGE("Convolution input %d x %d ksize=%d %d stride=%d %d", w, h, kernel_w... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rcx, %r13
movq %rdx, 0x38(%rsp)
movq %rdi, %r14
movl 0x38(%rsi), %ebp
movl 0xd4(%rdi), %r15d
decl %r15d
imull 0xdc(%rdi), %r15d
movl 0xd8(%rdi), %ebx
decl %ebx
imull 0xe0(%rdi), %ebx
movq 0x10(%rsi), %rax
... | /ysh329[P]ncnn/src/layer/convolution.cpp |
virtual thunk to ncnn::Convolution_x86::forward(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int Convolution_x86::forward(const std::vector<Mat>& bottom_blobs, std::vector<Mat>& top_blobs, const Option& opt) const
{
const Mat& bottom_blob = bottom_blobs[0];
const Mat& _weight_data = bottom_blobs[1];
Mat& top_blob = top_blobs[0];
const int _kernel_w = _weight_data.w;
const int _kernel_h = _... | movq (%rdi), %rax
addq -0x40(%rax), %rdi
jmp 0xa13a8
| /ysh329[P]ncnn/src/layer/x86/convolution_x86.cpp |
ncnn::convolution_im2col_sgemm_transform_kernel_pack1to4_int8_sse(ncnn::Mat const&, ncnn::Mat&, int, int, int, int) | static void convolution_im2col_sgemm_transform_kernel_pack1to4_int8_sse(const Mat& _kernel, Mat& kernel_tm, int inch, int outch, int kernel_w, int kernel_h)
{
const int maxk = kernel_w * kernel_h;
// interleave
// src = maxk-inch-outch
// dst = 4a-4b-maxk-inch/4a-outch/4b
Mat kernel = _kernel.resha... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rsi
imull %r9d, %ebx
movq %rsp, %rdi
movl %ebx, %edx
movl %r15d, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x6e49c
cmpl $0x4, %r15d
jl 0xa1ed5
movl %ebx, %esi
... | /ysh329[P]ncnn/src/layer/x86/convolution_sgemm_pack1to4_int8.h |
ncnn::im2col_sgemm_pack8to16_avx512(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Mat const&, ncnn::Option const&) | static void im2col_sgemm_pack8to16_avx512(const Mat& bottom_im2col, Mat& top_blob, const Mat& kernel, const Mat& _bias, const Option& opt)
{
// Mat bottom_im2col(size, maxk, inch, 32u, 8, opt.workspace_allocator);
const int size = bottom_im2col.w;
const int maxk = bottom_im2col.h;
const int inch = bott... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movslq 0x2c(%rdi), %r13
movl 0x30(%rdi), %ebp
movl 0x38(%rdi), %r15d
movl 0x38(%rsi), %eax
movq %rax, 0x60(%rsp)
movq (%rcx), %rax
movq %rax, 0x68(%rsp)
leaq 0x10(%rsp), %rdi
andq $0x0, 0x4... | /ysh329[P]ncnn/src/layer/x86/convolution_sgemm_pack8to16.h |
ncnn::convolution_winograd_dot_pack4_sse(ncnn::Mat&, int, ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) | static void convolution_winograd_dot_pack4_sse(Mat& bottom_blob_tm, int outch, const Mat& kernel_tm, Mat& top_blob_tm, const Option& opt)
{
// Mat bottom_blob_tm(tiles, 16/36/64, inch, 16u, 4, opt.workspace_allocator);
const int tiles = bottom_blob_tm.w;
const int batch = bottom_blob_tm.h;
const int in... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, 0x28(%rsp)
movq %rdx, 0x90(%rsp)
movq %rdi, %r13
movslq 0x2c(%rdi), %r15
movl 0x30(%rdi), %ebx
movl 0x38(%rdi), %ebp
andq $0x0, 0x80(%rsp)
movq %rsi, 0x10(%rsp)
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, 0x40(%rsp)
vmovups %xmm... | /ysh329[P]ncnn/src/layer/x86/convolution_winograd_dot_pack4.h |
ncnn::convolution_transform_kernel_packed_sse(ncnn::Mat const&, ncnn::Mat&, int, int, int, int, int, int) | static void convolution_transform_kernel_packed_sse(const Mat& weight_data, Mat& weight_data_tm, int num_input, int num_output, int kernel_w, int kernel_h, int elempack, int out_elempack)
{
const int maxk = kernel_w * kernel_h;
// src = kw-kh-inch-outch
// dst = pb-pa-kw-kh-inch/pa-outch/pb
{
M... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %r8d, %r14d
movl %ecx, %r13d
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rsi
movl 0xc0(%rsp), %ebp
imull %r9d, %r14d
xorl %ebx, %ebx
leaq 0x40(%rsp), %rdi
movl %r14d, %edx
movl %r15d, %ecx
movl %r13d, %r8d
xorl %r9d, %r9d
callq 0x6... | /ysh329[P]ncnn/build_O2/src/layer/x86/convolution_x86_fma.cpp |
ncnn::convolution_winograd_dot_pack4_sse(ncnn::Mat&, int, ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) | static void convolution_winograd_dot_pack4_sse(Mat& bottom_blob_tm, int outch, const Mat& kernel_tm, Mat& top_blob_tm, const Option& opt)
{
// Mat bottom_blob_tm(tiles, 16/36/64, inch, 16u, 4, opt.workspace_allocator);
const int tiles = bottom_blob_tm.w;
const int batch = bottom_blob_tm.h;
const int in... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, 0x28(%rsp)
movq %rdx, 0x90(%rsp)
movq %rdi, %r13
movslq 0x2c(%rdi), %r15
movl 0x30(%rdi), %ebx
movl 0x38(%rdi), %ebp
andq $0x0, 0x80(%rsp)
movq %rsi, 0x10(%rsp)
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, 0x40(%rsp)
vmovups %xmm... | /ysh329[P]ncnn/src/layer/x86/convolution_winograd_dot_pack4.h |
ncnn::conv3x3s1_winograd43_transform_kernel_pack8to4_int8_sse_xop(ncnn::Mat const&, ncnn::Mat&, int, int, ncnn::Option const&) | void conv3x3s1_winograd43_transform_kernel_pack8to4_int8_sse_xop(const Mat& kernel, Mat& kernel_tm, int inch, int outch, const Option& opt)
{
conv3x3s1_winograd43_transform_kernel_pack8to4_int8_sse(kernel, kernel_tm, inch, outch, opt);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movl %ecx, %ebx
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, 0x10(%rsp)
leaq 0xd0(%rsp), %rdi
andq $0x0, 0x40(%rdi)
vpxor %xmm0, %xmm0, %xmm0
vmovdqa %xmm0, (%rdi)
vmovdqu %xmm0, 0xc(%rdi)
vmovdqa %xmm0, 0x20(%rd... | /ysh329[P]ncnn/src/layer/x86/convolution_x86_xop.cpp |
ncnn::Crop::resolve_crop_roi(ncnn::Mat const&, int&, int&, int&, int&, int&, int&, int&, int&) const | void Crop::resolve_crop_roi(const Mat& bottom_blob, int& _woffset, int& _hoffset, int& _doffset, int& _coffset, int& _outw, int& _outh, int& _outd, int& _outc) const
{
int w = bottom_blob.w;
int h = bottom_blob.h;
int d = bottom_blob.d;
int channels = bottom_blob.c;
int dims = bottom_blob.dims;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, -0x28(%rsp)
movq %r8, -0x20(%rsp)
movq %rcx, -0x38(%rsp)
movq %rdx, %rcx
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rbx
movq 0x40(%rsp), %r8
movl 0x28(%rsi), %r12d
movl 0x2c(%rsi), %r11d
movl 0x30(%rsi), %r10d
movl 0x34(%rsi), %eax
movl %eax, -0x3... | /ysh329[P]ncnn/src/layer/crop.cpp |
void ncnn::copy_cut_border_image<signed char>(ncnn::Mat const&, ncnn::Mat&, int, int) | static void copy_cut_border_image(const Mat& src, Mat& dst, int top, int left)
{
int w = dst.w;
int h = dst.h;
const T* ptr = src.row<T>(top) + left;
T* outptr = dst; //.data;
for (int y = 0; y < h; y++)
{
if (w < 12)
{
for (int x = 0; x < w; x++)
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0x2c(%rsi), %rbp
movslq 0x2c(%rdi), %rax
movslq %edx, %rdx
imulq %rax, %rdx
imulq 0x10(%rdi), %rdx
addq (%rdi), %rdx
movl 0x30(%rsi), %r14d
movslq %ecx, %r15
addq %rdx, %r15
xorl %r13d, %r13d
testl %ebp, %ebp
movl $0x0, %ebx
cmovgl %ebp... | /ysh329[P]ncnn/src/layer/crop.cpp |
void ncnn::copy_cut_border_image<float>(ncnn::Mat const&, ncnn::Mat&, int, int) | static void copy_cut_border_image(const Mat& src, Mat& dst, int top, int left)
{
int w = dst.w;
int h = dst.h;
const T* ptr = src.row<T>(top) + left;
T* outptr = dst; //.data;
for (int y = 0; y < h; y++)
{
if (w < 12)
{
for (int x = 0; x < w; x++)
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movslq 0x2c(%rsi), %rbp
movslq 0x2c(%rdi), %rax
movslq %edx, %rdx
imulq %rax, %rdx
imulq 0x10(%rdi), %rdx
movl 0x30(%rsi), %r15d
movq %rdi, 0x8(%rsp)
addq (%rdi), %rdx
movslq %ecx, %rcx
leaq (%rdx,%rcx,4), %r14
movq %rbp, %rbx
shlq $0x2,... | /ysh329[P]ncnn/src/layer/crop.cpp |
virtual thunk to ncnn::Crop_x86::forward(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int Crop_x86::forward(const std::vector<Mat>& bottom_blobs, std::vector<Mat>& top_blobs, const Option& opt) const
{
const Mat& bottom_blob = bottom_blobs[0];
const Mat& reference_blob = bottom_blobs[1];
int w = bottom_blob.w;
int h = bottom_blob.h;
int d = bottom_blob.d;
int channels = bottom_b... | movq (%rdi), %rax
addq -0x40(%rax), %rdi
jmp 0x165d8e
nop
| /ysh329[P]ncnn/src/layer/x86/crop_x86.cpp |
ncnn::Crop_x86_avx512::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Crop_x86_avx512::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
int w = bottom_blob.w;
int h = bottom_blob.h;
int d = bottom_blob.d;
int channels = bottom_blob.c;
int dims = bottom_blob.dims;
size_t elemsize = bottom_blob.elemsize;
int elempack = bottom_blob.el... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rcx, 0xc8(%rsp)
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, 0x130(%rsp)
movl 0x2c(%rsi), %r15d
movslq %r15d, %rax
movl 0x30(%rsi), %r14d
movslq %r14d, %rcx
movl 0x34(%rsi), %edx
movl %edx, 0xe4(%rsp)
movslq... | /ysh329[P]ncnn/build_O2/src/layer/x86/crop_x86_avx512.cpp |
ncnn::crop_pack16_avx512(ncnn::Mat const&, ncnn::Mat&, int, int) | static void crop_pack16_avx512(const Mat& src, Mat& dst, int top, int left)
{
int w = dst.w;
int h = dst.h;
int right = src.w - dst.w - left;
const float* ptr = src.row(top) + left * 16;
float* outptr = dst;
for (int y = 0; y < h; y++)
{
for (int x = 0; x < w; x++)
{
... | movl 0x2c(%rsi), %eax
movl 0x30(%rsi), %r8d
movslq 0x2c(%rdi), %r9
movslq %edx, %rdx
imulq %r9, %rdx
subl %eax, %r9d
imulq 0x10(%rdi), %rdx
addq (%rdi), %rdx
shll $0x4, %ecx
movslq %ecx, %rcx
leaq (%rdx,%rcx,4), %rcx
movq (%rsi), %rdx
shll $0x4, %r9d
movslq %r9d, %rsi
xorl %edi, %edi
testl %eax, %eax
cmovlel %edi, %eax... | /ysh329[P]ncnn/build_O2/src/layer/x86/crop_x86_avx512.cpp |
virtual thunk to ncnn::Crop_x86_avx512::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Crop_x86_avx512::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
int w = bottom_blob.w;
int h = bottom_blob.h;
int d = bottom_blob.d;
int channels = bottom_blob.c;
int dims = bottom_blob.dims;
size_t elemsize = bottom_blob.elemsize;
int elempack = bottom_blob.el... | movq (%rdi), %rax
addq -0x48(%rax), %rdi
jmp 0x167724
| /ysh329[P]ncnn/build_O2/src/layer/x86/crop_x86_avx512.cpp |
virtual thunk to ncnn::Crop_x86_avx512::forward(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int Crop_x86_avx512::forward(const std::vector<Mat>& bottom_blobs, std::vector<Mat>& top_blobs, const Option& opt) const
{
const Mat& bottom_blob = bottom_blobs[0];
const Mat& reference_blob = bottom_blobs[1];
int w = bottom_blob.w;
int h = bottom_blob.h;
int d = bottom_blob.d;
int channels = b... | movq (%rdi), %rax
addq -0x40(%rax), %rdi
jmp 0x16a6ea
nop
| /ysh329[P]ncnn/build_O2/src/layer/x86/crop_x86_avx512.cpp |
ncnn::Crop_x86_avx::forward(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int Crop_x86_avx::forward(const std::vector<Mat>& bottom_blobs, std::vector<Mat>& top_blobs, const Option& opt) const
{
const Mat& bottom_blob = bottom_blobs[0];
const Mat& reference_blob = bottom_blobs[1];
int w = bottom_blob.w;
int h = bottom_blob.h;
int d = bottom_blob.d;
int channels = bott... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rcx, 0xc0(%rsp)
movq %rdi, %rbp
movq (%rsi), %r12
leaq 0x48(%r12), %rax
movq %rax, 0x148(%rsp)
movl 0x2c(%r12), %eax
movl %eax, 0x54(%rsp)
movslq %eax, %r11
movl 0x30(%r12), %eax
movl %eax, 0xb4(%rsp)
movs... | /ysh329[P]ncnn/build_O2/src/layer/x86/crop_x86_avx.cpp |
ncnn::Dropout::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int Dropout::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
if (scale == 1.f)
{
return 0;
}
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int size = w * h;
#pragma omp parallel for num_threads(opt.num_threads)
for ... | movss 0x23a01e(%rip), %xmm0 # 0x3c5834
ucomiss 0xd0(%rdi), %xmm0
jne 0x18b822
xorl %eax, %eax
retq
movl 0x30(%rsi), %eax
imull 0x2c(%rsi), %eax
movl 0x38(%rsi), %ecx
movq 0x40(%rsi), %rdx
imulq 0x10(%rsi), %rdx
xorl %r8d, %r8d
testl %eax, %eax
cmovlel %r8d, %eax
movq (%rsi), %rsi
testl %ecx, %ecx
cmovlel %r8d, %ecx
c... | /ysh329[P]ncnn/src/layer/dropout.cpp |
ncnn::ELU_x86::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int ELU_x86::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int elempack = bottom_top_blob.elempack;
int size = w * h * elempack;
#pragma omp parallel for num_threads(opt.num_threads)
f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movl 0x30(%rsi), %ebp
movl 0x38(%rsi), %eax
imull 0x2c(%rsi), %ebp
movq %rsi, 0x8(%rsp)
imull 0x18(%rsi), %ebp
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
movq %rax, 0x10(%rsp)
movq (%rdi), %r13
xorps %xmm6, %xmm6... | /ysh329[P]ncnn/src/layer/x86/elu_x86.cpp |
ncnn::ELU_x86_avx::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int ELU_x86_avx::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int elempack = bottom_top_blob.elempack;
int size = w * h * elempack;
#pragma omp parallel for num_threads(opt.num_threads)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movl 0x30(%rsi), %ebp
imull 0x2c(%rsi), %ebp
movl 0x38(%rsi), %eax
movq %rsi, 0x8(%rsp)
imull 0x18(%rsi), %ebp
movq (%rdi), %r12
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
movq %rax, 0x10(%rsp)
vbroadcastss 0x235... | /ysh329[P]ncnn/build_O2/src/layer/x86/elu_x86_avx.cpp |
ncnn::Flatten_x86::forward_int8(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Flatten_x86::forward_int8(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
int dims = bottom_blob.dims;
if (dims == 1)
{
top_blob = bottom_blob;
return 0;
}
int w = bottom_blob.w;
int h = bottom_blob.h;
int d = bottom_blob.d;
int channels = bottom_b... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r9
movq %rsi, %r14
movl 0x28(%rsi), %eax
cmpl $0x1, %eax
jne 0x190aa1
xorl %ebp, %ebp
cmpq %r14, %r9
je 0x190f65
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x190a6d
lock
incl (%rax)
movq 0x8(%r9), %rax
testq %rax, %rax
je 0x190... | /ysh329[P]ncnn/src/layer/x86/flatten_x86.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.