LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/bits/succinctvector.cpp
// Function: CSA::SuccinctVector::indexForRank()
void
SuccinctVector::indexForRank()
{
  delete this->rank_index; this->rank_index = 0;

  WriteBuffer buffer(this->number_of_blocks + 1, this->integer_bits);
  const usint* data = this->array;

  buffer.writeItem(0);
  usint bitcount = 0;
  for(usint block = 0; block < this->number_of_blocks; block++)
  {
    for(usint word = 0; word < this->block_size; word++, ++data) { bitcount += popcount(*data); }
    buffer.writeItem(bitcount);
  }

  this->rank_index = buffer.getReadBuffer();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %r14
testq %r14, %r14
je 0x1a51f
movq %r14, %rdi
callq 0x16f06
movl $0x28, %esi
movq %r14, %rdi
callq 0x3270
movq $0x0, 0x28(%rbx)
movl 0x14(%rbx), %esi
movl 0x20(%rbx), %edx
incl %esi
movq %rsp, %r14
movq %r14, %rdi
callq 0x17002
movl 0xc(%r14), %ecx
movl 0x1c(%r14), %eax
movl %ecx, %edx
subl %eax, %edx
jb 0x1a568
incl 0x18(%rsp)
movl $0x20, 0x1c(%rsp)
movl $0x20, %eax
movl %edx, %ecx
testl %ecx, %ecx
je 0x1a572
subl %ecx, %eax
movl %eax, 0x1c(%rsp)
movq 0x8(%rbx), %rsi
incl 0x20(%rsp)
cmpl $0x0, 0x14(%rbx)
je 0x1a646
xorl %edi, %edi
movq (%rsp), %r8
movl $0x33333333, %r9d       # imm = 0x33333333
xorl %r10d, %r10d
movl 0x10(%rbx), %eax
testl %eax, %eax
je 0x1a5d6
movl (%rsi), %ecx
movl %ecx, %edx
shrl %edx
andl $0x55555555, %edx       # imm = 0x55555555
subl %edx, %ecx
movl %ecx, %edx
andl %r9d, %edx
shrl $0x2, %ecx
andl %r9d, %ecx
addl %edx, %ecx
movl %ecx, %edx
shrl $0x4, %edx
addl %ecx, %edx
andl $0xf0f0f0f, %edx        # imm = 0xF0F0F0F
imull $0x1010101, %edx, %ecx  # imm = 0x1010101
shrl $0x18, %ecx
addl %ecx, %r10d
addq $0x4, %rsi
decl %eax
jne 0x1a59a
movl 0xc(%rsp), %ecx
movl 0x1c(%rsp), %edx
movl %ecx, %eax
subl %edx, %eax
jae 0x1a5e8
movl %ecx, %eax
jmp 0x1a613
movl %r10d, %r11d
movl %eax, %ecx
shrl %cl, %r11d
negb %dl
movl %edx, %ecx
shll %cl, %r11d
shrl %cl, %r11d
movl 0x18(%rsp), %ecx
orl %r11d, (%r8,%rcx,4)
incl 0x18(%rsp)
movl $0x20, 0x1c(%rsp)
movl $0x20, %edx
testl %eax, %eax
je 0x1a637
subl %eax, %edx
movl %edx, 0x1c(%rsp)
negb %al
movl %r10d, %r11d
movl %eax, %ecx
shll %cl, %r11d
shrl %cl, %r11d
movl %edx, %ecx
shll %cl, %r11d
movl 0x18(%rsp), %eax
orl %r11d, (%r8,%rax,4)
incl 0x20(%rsp)
incl %edi
cmpl 0x14(%rbx), %edi
jb 0x1a593
movq %rsp, %rdi
callq 0x170c6
movq %rax, 0x28(%rbx)
movq %rsp, %rdi
callq 0x170b2
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x170b2
movq %rbx, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/bits/succinctvector.cpp
// Function: CSA::SuccinctVector::SuccinctVector(_IO_FILE*)
SuccinctVector::SuccinctVector(FILE* file) :
  BitVector()
{
  if(file == 0) { return; }

  this->readHeader(file);
  this->readArray(file);

  this->integer_bits = length(this->size);
  this->indexForRank();
  this->indexForSelect();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x17d5c
testq %r14, %r14
je 0x1a93d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17892
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17916
movl (%rbx), %eax
bsrl %eax, %ecx
xorl $-0x20, %ecx
addl $0x21, %ecx
testl %eax, %eax
cmovel %eax, %ecx
movl %ecx, 0x20(%rbx)
movq %rbx, %rdi
callq 0x1a504
movq %rbx, %rdi
callq 0x1a676
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x17d70
movq %r14, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/bits/succinctvector.cpp
// Function: CSA::SuccinctVector::SuccinctVector(CSA::SuccinctEncoder&, unsigned int)
SuccinctVector::SuccinctVector(Encoder& encoder, usint universe_size) :
  BitVector()
{
  if(encoder.items == 0)
  {
    std::cerr << "SuccinctVector: Cannot create a bit vector with no 1-bits!" << std::endl;
    return;
  }

  this->size = universe_size;
  this->items = encoder.items;
  this->block_size = encoder.block_size;

  this->number_of_blocks = (this->size + this->block_size * WORD_BITS - 1) / (this->block_size * WORD_BITS);
  this->copyArray(encoder);

  this->integer_bits = length(this->size);
  this->indexForRank();
  this->indexForSelect();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
callq 0x17d5c
movl 0x4(%r14), %eax
testl %eax, %eax
je 0x1a9c2
movl %r15d, (%rbx)
movl %eax, 0x4(%rbx)
movl 0xc(%r14), %ecx
movl %ecx, 0x10(%rbx)
shll $0x5, %ecx
leal (%r15,%rcx), %eax
decl %eax
xorl %edx, %edx
divl %ecx
movl %eax, 0x14(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x17c62
movl (%rbx), %eax
bsrl %eax, %ecx
xorl $-0x20, %ecx
addl $0x21, %ecx
testl %eax, %eax
cmovel %eax, %ecx
movl %ecx, 0x20(%rbx)
movq %rbx, %rdi
callq 0x1a504
movq %rbx, %rdi
callq 0x1a676
jmp 0x1aa08
movq 0xd627(%rip), %r14      # 0x27ff0
leaq 0x420f(%rip), %rsi      # 0x1ebdf
movl $0x3a, %edx
movq %r14, %rdi
callq 0x32b0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq 0xd5f5(%rip), %rdi      # 0x27ff0
callq 0x3040
movq %rax, %rdi
callq 0x3190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x17d70
movq %r14, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/bits/succinctvector.cpp
// Function: CSA::SuccinctVector::SuccinctVector(CSA::SuccinctEncoder&)
SuccinctVector::SuccinctVector(Encoder& encoder) :
  BitVector()
{
  if(encoder.items == 0)
  {
    std::cerr << "SuccinctVector: Cannot create a bit vector with no 1-bits!" << std::endl;
    return;
  }

  this->size = std::max(encoder.size, encoder.superblock_bytes * CHAR_BIT);
  this->items = encoder.items;
  this->block_size = encoder.block_size;

  this->number_of_blocks = (this->size + this->block_size * WORD_BITS - 1) / (this->block_size * WORD_BITS);
  this->copyArray(encoder, true);

  this->integer_bits = length(this->size);
  this->indexForRank();
  this->indexForSelect();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x17d5c
movl 0x4(%r14), %eax
testl %eax, %eax
je 0x1aa98
movl (%r14), %ecx
movl 0x10(%r14), %edx
shll $0x3, %edx
cmpl %edx, %ecx
cmoval %ecx, %edx
movl %edx, (%rbx)
movl %eax, 0x4(%rbx)
movl 0xc(%r14), %ecx
movl %ecx, 0x10(%rbx)
shll $0x5, %ecx
leal (%rdx,%rcx), %eax
decl %eax
xorl %edx, %edx
divl %ecx
movl %eax, 0x14(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x17c62
movl (%rbx), %eax
bsrl %eax, %ecx
xorl $-0x20, %ecx
addl $0x21, %ecx
testl %eax, %eax
cmovel %eax, %ecx
movl %ecx, 0x20(%rbx)
movq %rbx, %rdi
callq 0x1a504
movq %rbx, %rdi
callq 0x1a676
jmp 0x1aade
movq 0xd551(%rip), %r14      # 0x27ff0
leaq 0x4139(%rip), %rsi      # 0x1ebdf
movl $0x3a, %edx
movq %r14, %rdi
callq 0x32b0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq 0xd51f(%rip), %rdi      # 0x27ff0
callq 0x3040
movq %rax, %rdi
callq 0x3190
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x17d70
movq %r14, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/bits/succinctvector.cpp
// Function: CSA::SuccinctVector::Iterator::rank(unsigned int, bool)
usint
SuccinctVector::Iterator::rank(usint value, bool at_least)
{
  const SuccinctVector& par = (const SuccinctVector&)(this->parent);

  if(value >= par.size) { return par.items; }

  usint block = value / (par.block_size * WORD_BITS);
  usint result = par.rank_index->readItemConst(block);
  const usint* data = par.array + block * par.block_size;

  // Value is now the number of bits to be read within the block.
  // Add popcounts for entire words as long as possible.
  value = value - block * par.block_size * WORD_BITS + 1;
  while(value >= WORD_BITS)
  {
    result += popcount(*data);
    ++data; value -= WORD_BITS;
  }

  // Add popcount for the last bits.
  if(value > 0)
  {
    result += popcount(GET(LOWER(*data, WORD_BITS - value), value));
  }

  return result;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %r9
cmpl %esi, (%r9)
jbe 0x1abae
movl 0x10(%r9), %r10d
movl %r10d, %ecx
shll $0x5, %ecx
xorl %edi, %edi
movl %esi, %eax
xorl %edx, %edx
divl %ecx
movq 0x28(%r9), %r11
movl 0xc(%r11), %ebp
movl %ebp, %ecx
imull %eax, %ecx
movl %ecx, %ebx
shrl $0x5, %ebx
andl $0x1f, %ecx
movl $0x20, %r8d
movl $0x20, %r14d
subl %ecx, %r14d
movl %ebp, %edx
subl %r14d, %edx
jae 0x1abb7
movl %r14d, %r8d
movl %ebp, %edx
jmp 0x1abcb
movl 0x4(%r9), %edi
jmp 0x1ac9a
movq (%r11), %rdi
movl %ebx, %r14d
movl (%rdi,%r14,4), %edi
shll %cl, %edi
shrl %cl, %edi
movl %edx, %ecx
shll %cl, %edi
incl %ebx
testl %edx, %edx
je 0x1abef
subl %edx, %r8d
movq (%r11), %rcx
movl %ebx, %r11d
movl (%rcx,%r11,4), %r11d
movl %r8d, %ecx
shrl %cl, %r11d
negb %dl
movl %edx, %ecx
shll %cl, %r11d
shrl %cl, %r11d
orl %r11d, %edi
imull %r10d, %eax
leaq (,%rax,4), %rcx
addq 0x8(%r9), %rcx
shll $0x5, %eax
subl %eax, %esi
incl %esi
cmpl $0x20, %esi
jb 0x1ac59
movl $0x33333333, %eax       # imm = 0x33333333
movl (%rcx), %edx
movl %edx, %r8d
shrl %r8d
andl $0x55555555, %r8d       # imm = 0x55555555
subl %r8d, %edx
movl %edx, %r8d
andl %eax, %r8d
shrl $0x2, %edx
andl %eax, %edx
addl %r8d, %edx
movl %edx, %r8d
shrl $0x4, %r8d
addl %edx, %r8d
andl $0xf0f0f0f, %r8d        # imm = 0xF0F0F0F
imull $0x1010101, %r8d, %edx  # imm = 0x1010101
shrl $0x18, %edx
addl %edx, %edi
addq $0x4, %rcx
addl $-0x20, %esi
cmpl $0x1f, %esi
ja 0x1ac10
testl %esi, %esi
je 0x1ac9a
movl (%rcx), %eax
negb %sil
movl %esi, %ecx
shrl %cl, %eax
movl %eax, %ecx
shrl %ecx
andl $0x55555555, %ecx       # imm = 0x55555555
subl %ecx, %eax
movl $0x33333333, %ecx       # imm = 0x33333333
movl %eax, %edx
andl %ecx, %edx
shrl $0x2, %eax
andl %ecx, %eax
addl %edx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
addl %eax, %ecx
andl $0xf0f0f0f, %ecx        # imm = 0xF0F0F0F
imull $0x1010101, %ecx, %eax  # imm = 0x1010101
shrl $0x18, %eax
addl %eax, %edi
movl %edi, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/bits/succinctvector.cpp
// Function: CSA::SuccinctVector::Iterator::valueBefore(unsigned int)
pair_type
SuccinctVector::Iterator::valueBefore(usint value)
{
  const SuccinctVector& par = (const SuccinctVector&)(this->parent);
  if(value >= par.size) { return pair_type(par.size, par.items); }

	usint temp = this->rank(value);
	if(temp == 0)         { return pair_type(par.size, par.items); }
	return pair_type(this->select(temp - 1), temp - 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r12
movl (%r12), %ebx
cmpl %esi, %ebx
jbe 0x1b126
movq %rdi, %r15
xorl %edx, %edx
callq 0x1ab5e
testl %eax, %eax
je 0x1b126
movl %eax, %r14d
decl %r14d
movq %r15, %rdi
movl %r14d, %esi
callq 0x1aca2
movl %eax, %ebx
jmp 0x1b12b
movl 0x4(%r12), %r14d
shlq $0x20, %r14
movl %ebx, %eax
orq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/bits/succinctvector.cpp
// Function: CSA::SuccinctVector::Iterator::valueAfter(unsigned int)
pair_type
SuccinctVector::Iterator::valueAfter(usint value)
{
  const SuccinctVector& par = (const SuccinctVector&)(this->parent);
  if(value >= par.size) { return pair_type(par.size, par.items); }

	if(value == 0) { return pair_type(this->select(0), 0); }
	usint temp = this->rank(value - 1);
	return pair_type(this->select(temp), temp);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rcx
movl (%rcx), %eax
cmpl %esi, %eax
jbe 0x1b169
movq %rdi, %r14
testl %esi, %esi
je 0x1b16e
decl %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1ab5e
movl %eax, %ebx
movq %r14, %rdi
movl %eax, %esi
jmp 0x1b175
movl 0x4(%rcx), %ebx
jmp 0x1b17a
xorl %ebx, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x1aca2
shlq $0x20, %rbx
movl %eax, %eax
orq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/bits/succinctvector.cpp
// Function: CSA::SuccinctVector::Iterator::countRuns()
usint
SuccinctVector::Iterator::countRuns()
{
  usint runs = 0;
  usint prev = this->select(0);
  while(this->hasNext())
  {
    usint temp = this->selectNext();
    if(temp != prev + 1) { runs++; }
    prev = temp;
  }
  return runs;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x1aca2
movl %eax, %r14d
movl 0x8(%rbx), %esi
movq (%rbx), %rax
movl 0x4(%rax), %eax
decl %eax
cmpl %eax, %esi
jae 0x1b215
xorl %ebp, %ebp
incl %esi
movq %rbx, %rdi
callq 0x1aca2
incl %r14d
xorl %ecx, %ecx
cmpl %r14d, %eax
setne %cl
addl %ecx, %ebp
movl 0x8(%rbx), %esi
movq (%rbx), %rcx
movl 0x4(%rcx), %ecx
decl %ecx
movl %eax, %r14d
cmpl %ecx, %esi
jb 0x1b1ec
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/bits/succinctvector.cpp
// Function: CSA::SuccinctEncoder::setBit(unsigned int)
void
SuccinctEncoder::setBit(usint value)
{
  // We can set any bit in the current superblock as well as those bits after it.
  if(value < this->array_blocks.size() * this->superblock_bytes * CHAR_BIT) { return; }
  this->size = std::max(this->size, value + 1);

  value -= this->array_blocks.size() * this->superblock_bytes * CHAR_BIT;
  while(value >= this->superblock_bytes * CHAR_BIT)
  {
    this->addNewBlock();
    value -= this->superblock_bytes * CHAR_BIT;
  }

  if(!(this->buffer->isSet(value))) { this->items++; }
  this->buffer->setBit(value);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movl %esi, %edx
movq 0x30(%rdi), %rcx
movl 0x10(%rdi), %eax
movq %rcx, %rsi
imulq %rax, %rsi
shlq $0x3, %rsi
cmpq %rdx, %rsi
ja 0x1b2b2
movq %rdi, %rbx
leal 0x1(%r14), %edx
movl (%rdi), %esi
cmpl %edx, %esi
cmoval %esi, %edx
movl %edx, (%rdi)
imull %eax, %ecx
shll $0x3, %ecx
subl %ecx, %r14d
shll $0x3, %eax
cmpl %eax, %r14d
jb 0x1b281
movq %rbx, %rdi
callq 0x185b4
movl 0x10(%rbx), %eax
shll $0x3, %eax
subl %eax, %r14d
cmpl %eax, %r14d
jae 0x1b26b
movq 0x18(%rbx), %rax
movq (%rax), %rax
movl %r14d, %edx
notb %r14b
movl $0x1, %esi
movl %r14d, %ecx
shll %cl, %esi
shrl $0x5, %edx
movl (%rax,%rdx,4), %ecx
movzbl %r14b, %edi
btl %edi, %ecx
jb 0x1b2ad
incl 0x4(%rbx)
movl (%rax,%rdx,4), %ecx
orl %esi, %ecx
movl %ecx, (%rax,%rdx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/ushitora-anqou[P]femtoyaml/./femtoyaml.hpp
// Function: femtoyaml::detail::to_string[abi:cxx11](std::variant<femtoyaml::detail::tk_eof, femtoyaml::detail::tk_scalar_plain, femtoyaml::detail::tk_block_sequence_start, femtoyaml::detail::tk_block_end, femtoyaml::detail::tk_block_entry, femtoyaml::detail::tk_block_mapping_start, femtoyaml::detail::tk_key, femtoyaml::detail::tk_value> const&)
std::string to_string(const token& tk)
{
    return match_with(
        tk, [](const tk_eof&) { return std::string("EOF"); },
        [](const tk_scalar_plain& tk) {
            return "SCALAR(" + tk.str + ", plain)";
        },
        [](const tk_block_sequence_start&) {
            return std::string("BLOCK-SEQUENCE-START");
        },
        [](const tk_block_end&) { return std::string("BLOCK-END"); },
        [](const tk_block_entry&) { return std::string("BLOCK-ENTRY"); },
        [](const tk_block_mapping_start&) {
            return std::string("BLOCK-MAPPING-START");
        },
        [](const tk_key&) { return std::string("KEY"); },
        [](const tk_value&) { return std::string("VALUE"); });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movsbq 0x20(%rsi), %rax
cmpq $-0x1, %rax
je 0x3632
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x94ef(%rip), %rcx      # 0xcb10
leaq -0x9(%rbp), %rsi
callq *(%rcx,%rax,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x10, %edi
callq 0x30c0
leaq 0x94b5(%rip), %rcx      # 0xcaf8
movq %rcx, (%rax)
leaq 0x49f5(%rip), %rcx      # 0x8042
movq %rcx, 0x8(%rax)
leaq 0x9478(%rip), %rsi      # 0xcad0
movq 0x9981(%rip), %rdx      # 0xcfe0
movq %rax, %rdi
callq 0x3280
nop
// File: /workspace/github_cpp_makefile_star2_O3/ushitora-anqou[P]femtoyaml/./femtoyaml.hpp
// Function: femtoyaml::load(std::istream&)
inline value load(std::istream& is)
{
    detail::stream st = is;
    auto tokens = detail::tokenizer(st).get();
    // for (auto&& tk : tokens)
    //    std::cout << femtoyaml::detail::to_string(tk) << std::endl;
    return detail::parser(tokens.begin()).get();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %r14
leaq -0xd0(%rbp), %rbx
movq %rsi, -0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x40(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4542
movl $0x0, 0x50(%rbx)
leaq -0x78(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x4344
leaq -0x70(%rbp), %r15
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x43b0
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3b95
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x3180
movq %r15, %rdi
callq 0x44ec
movq -0x38(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x4484
movq %r14, %rdi
movq %r15, %rsi
callq 0x70b8
movzbl -0x50(%rbp), %eax
leaq 0x9080(%rip), %rcx      # 0xcc40
leaq -0x19(%rbp), %rdi
movq %r15, %rsi
callq *(%rcx,%rax,8)
leaq -0x38(%rbp), %rdi
callq 0x44ec
movq %rbx, %rdi
callq 0x7192
movq %r14, %rax
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x3d9b
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0x44ba
jmp 0x3c05
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x44ec
jmp 0x3c21
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0x4454
jmp 0x3c21
movq %rax, %r14
movq %rbx, %rdi
callq 0x7192
movq %r14, %rdi
callq 0x32a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ushitora-anqou[P]femtoyaml/./femtoyaml.hpp
// Function: femtoyaml::detail::stream::skip_ws()
void skip_ws()
    {
        while (true) {
            switch (peek()) {
            case ' ':
            case '\n':
                next();
                break;

            default:
                return;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4a0e
cmpl $0x20, %eax
je 0x497d
cmpl $0xa, %eax
jne 0x4996
movq %rbx, %rdi
callq 0x5120
movl 0x58(%rbx), %ecx
incl %ecx
cmpl $0xa, %eax
cmovel %r14d, %ecx
movl %ecx, 0x58(%rbx)
jmp 0x4969
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ushitora-anqou[P]femtoyaml/./femtoyaml.hpp
// Function: femtoyaml::detail::tokenizer::unroll_indent(int)
void unroll_indent(int column)
    {
        // check indent and unroll it if needed
        while (indent_ > column) {
            indent_ = indents_.back();
            indents_.pop_back();
            tks_.push_back(tk_block_end{});
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
cmpl %esi, 0x20(%rdi)
jle 0x49ed
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8(%rdi), %r15
leaq -0x48(%rbp), %r12
movq 0x30(%r14), %rax
movl -0x4(%rax), %ecx
addq $-0x4, %rax
movl %ecx, 0x20(%r14)
movq %rax, 0x30(%r14)
movb $0x3, -0x28(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x51a4
movq %r12, %rdi
callq 0x4b54
cmpl %ebx, 0x20(%r14)
jg 0x49bd
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x4b54
movq %rbx, %rdi
callq 0x32a0
// File: /workspace/github_cpp_makefile_star2_O3/ushitora-anqou[P]femtoyaml/./femtoyaml.hpp
// Function: void femtoyaml::detail::tokenizer::roll_indent<femtoyaml::detail::tk_block_sequence_start>(int)
void roll_indent(int column)
    {
        // check if block sequence starts
        if (indent_ < column) {
            tks_.push_back(T{});
            indents_.push_back(indent_);
            indent_ = column;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl %esi, 0x20(%rdi)
jge 0x4b35
movl %esi, %ebx
movq %rdi, %r14
addq $0x8, %rdi
leaq -0x40(%rbp), %rsi
movb $0x2, 0x20(%rsi)
callq 0x51a4
leaq 0x20(%r14), %r15
leaq -0x40(%rbp), %rdi
callq 0x4b54
movq 0x30(%r14), %rsi
cmpq 0x38(%r14), %rsi
je 0x4b23
movl 0x20(%r14), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x30(%r14)
jmp 0x4b32
addq $0x28, %r14
movq %r14, %rdi
movq %r15, %rdx
callq 0x4ffe
movl %ebx, (%r15)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x4b54
movq %rbx, %rdi
callq 0x32a0
// File: /workspace/github_cpp_makefile_star2_O3/ushitora-anqou[P]femtoyaml/./femtoyaml.hpp
// Function: femtoyaml::detail::tokenizer::fetch_plain_scalar()
tk_scalar_plain fetch_plain_scalar()
    {
        std::stringstream ss;
        while (true) {
            switch (st_.peek()) {
            case '\n':
                goto end;
            case ':':
                if (is_blankz(st_.peek(1))) goto end;
                break;
            case EOF:
                goto end;
            }
            ss << (char)st_.next();
        }
    end:
        return tk_scalar_plain{ss.str()};
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, -0x38(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x3100
leaq -0x1b0(%rbp), %r15
xorl %ebx, %ebx
leaq -0x29(%rbp), %r12
movq (%r14), %rdi
xorl %esi, %esi
callq 0x4a0e
cmpl $0x3a, %eax
je 0x4c97
cmpl $-0x1, %eax
je 0x4cde
cmpl $0xa, %eax
jne 0x4cae
jmp 0x4cde
movq (%r14), %rdi
movl $0x1, %esi
callq 0x4a0e
cmpl $0xa, %eax
je 0x4cde
cmpl $0x20, %eax
je 0x4cde
movq (%r14), %r13
movq %r13, %rdi
callq 0x5120
movl 0x58(%r13), %ecx
incl %ecx
cmpl $0xa, %eax
cmovel %ebx, %ecx
movl %ecx, 0x58(%r13)
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x31a0
jmp 0x4c7c
leaq -0x1a8(%rbp), %rsi
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x3240
movq 0x82b0(%rip), %rsi      # 0xcfa8
leaq -0x1c0(%rbp), %rdi
callq 0x3120
leaq -0x140(%rbp), %rdi
callq 0x3080
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4d27
movq %rax, %rbx
movq 0x8277(%rip), %rsi      # 0xcfa8
leaq -0x1c0(%rbp), %rdi
callq 0x3120
leaq -0x140(%rbp), %rdi
callq 0x3080
movq %rbx, %rdi
callq 0x32a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ushitora-anqou[P]femtoyaml/./femtoyaml.hpp
// Function: std::optional<femtoyaml::detail::tk_scalar_plain> femtoyaml::detail::parser::pop_if<femtoyaml::detail::tk_scalar_plain>()
std::optional<T> pop_if()
    {
        auto ptk = std::get_if<T>(&*tks_iter_);
        if (!ptk) return std::nullopt;
        tks_iter_++;
        return *ptk;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
testq %rax, %rax
je 0x57ff
cmpb $0x1, 0x20(%rax)
jne 0x57ff
leaq 0x28(%rax), %rcx
movq %rcx, (%rsi)
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x42a6
movb $0x1, %al
jmp 0x5801
xorl %eax, %eax
movb %al, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dguglielmi[P]dlan-linux-software/tools/../common/packettask.h
// Function: bool CPacketTaskRunner::Run<MSCounter>(unsigned long, MSCounter)
bool Run(unsigned long ulTimeout, TMSecCounterFunc fncGetMsCount)
  {
    unsigned long ulNow, ulStart = fncGetMsCount();
    while(!task.Complete() && (((ulNow = fncGetMsCount()) - ulStart) < ulTimeout))
    {
      unsigned long ulWait = task.Drumbeat();
      ifc.ReceivePackets(task.GetReceiver(), std::min<unsigned long>(ulWait, ulTimeout - (ulNow - ulStart)));
    }
    return task.Successful();
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, (%rsp)
movq %rdi, %rbx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x43a0
movabsq $-0x20c49ba5e353f7cf, %rax # imm = 0xDF3B645A1CAC0831
imulq 0x8(%r12)
movq %rdx, %r15
movq (%r12), %r13
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
jne 0x4d75
movq %r15, %rax
shrq $0x3f, %rax
sarq $0x7, %r15
addq %rax, %r15
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x43a0
movabsq $0x20c49ba5e353f7cf, %rax # imm = 0x20C49BA5E353F7CF
imulq 0x10(%rsp)
movq 0x8(%rsp), %rax
subq %r13, %rax
movq %rdx, %rcx
shrq $0x3f, %rcx
sarq $0x7, %rdx
addq %rcx, %rdx
addq %r15, %rdx
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
addq %rdx, %rax
movq (%rsp), %r14
subq %rax, %r14
jbe 0x4d75
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, %rbp
movq (%rbx), %r12
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpq %rbp, %r14
cmovbq %r14, %rbp
movq (%r12), %rcx
movq %r12, %rdi
movq %rax, %rsi
movq %rbp, %rdx
callq *0x18(%rcx)
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x4cec
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *0x18(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O3/dguglielmi[P]dlan-linux-software/tools/../common/packettask.h
// Function: CPacketTaskRunner::Run()
bool Run()
  {
    while(!task.Complete())
    {
      unsigned long ulWait = task.Drumbeat();
      ifc.ReceivePackets(task.GetReceiver(), ulWait);
    }
    return task.Successful();
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
jne 0x4f62
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, %r14
movq (%rbx), %r15
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%r15), %rcx
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq *0x18(%rcx)
movq 0x8(%rbx), %rdi
jmp 0x4f2a
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
popq %rbx
popq %r14
popq %r15
jmpq *0x18(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O3/dguglielmi[P]dlan-linux-software/tools/dlanpasswd.cpp
// Function: CFindLocalDevice::OnUpdate()
virtual void OnUpdate()
  {
    if(devToFind)
    {
      for(CDlanLocalDeviceList::const_iterator itLocal = GetLocalDevices().begin(); 
        !stop && (itLocal != GetLocalDevices().end()); ++itLocal)
      {
        if(itLocal->GetAddress() == devToFind)
        {
          itDevice = itLocal;
          stop = true;
          ifc.StopReceiving();
        }
      }
    }
    else if(GetLocalDevices().size() > 0)
    {
      itDevice = GetLocalDevices().begin();
      stop = true;
      ifc.StopReceiving();
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0xf0(%rdi), %rax
movw $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movzwl 0x4(%rax), %ecx
orl (%rax), %ecx
je 0x544a
leaq 0x98(%rbx), %r14
movq 0x98(%rbx), %r15
movb 0xe0(%rbx), %al
cmpq %r14, %r15
sete %cl
orb %al, %cl
jne 0x547f
movq 0xf0(%rbx), %rcx
movl 0x10(%r15), %edx
xorl (%rcx), %edx
movzwl 0x14(%r15), %esi
xorw 0x4(%rcx), %si
movzwl %si, %ecx
orl %edx, %ecx
jne 0x543c
movq %r15, 0xf8(%rbx)
movb $0x1, 0xe0(%rbx)
movq 0xe8(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movb 0xe0(%rbx), %al
testb $0x1, %al
jne 0x547f
movq (%r15), %r15
cmpq %r14, %r15
jne 0x53fe
jmp 0x547f
cmpq $0x0, 0xa8(%rbx)
je 0x547f
movq 0x98(%rbx), %rax
movq 0xe8(%rbx), %rdi
movq %rax, 0xf8(%rbx)
movb $0x1, 0xe0(%rbx)
movq (%rdi), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmpq *0x20(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dguglielmi[P]dlan-linux-software/tools/../common/packetdispatcher.h
// Function: CPacketReceiverAndDispatcher::PacketIndication(CMACAddress const&, IPacket const&)
virtual bool PacketIndication(const CMACAddress& adapter, const IPacket& packet)
  {
    std::list<IPacketDispatcher*>::iterator itDispatcher = listDispatchers.begin();
    while((itDispatcher != listDispatchers.end()) && ((*itDispatcher)->Dispatch(adapter, packet) == false))
      ++itDispatcher;

    bool bResult = false;
    std::list<IPacketWaiter*>::iterator itWaiter = listWaiters.begin();
    while((itWaiter != listWaiters.end()) && ((bResult = (*itWaiter)->WaitSatisfied()) == false))
      ++itWaiter;

    return bResult;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %r12
movq %r12, %r13
movq (%r13), %r13
cmpq %r12, %r13
je 0x5b47
movq 0x10(%r13), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %r14, %rdx
callq *(%rax)
testb %al, %al
je 0x5b2b
addq $0x20, %rbx
movq %rbx, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x5b63
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
je 0x5b4e
cmpq %rbx, %r14
setne %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dguglielmi[P]dlan-linux-software/tools/../common/hpmmes.h
// Function: HomePlugMMEs::MmeHdr::IsValid(IPacket const&, unsigned char, unsigned char)
static bool IsValid(const IPacket& pkt, uint8_t expectedMmeHdr, uint8_t expectedMmeLen)
    {
      MmeHdr* pHdr = (MmeHdr*)pkt.Data();
      return
        (pkt.Size() >= sizeof(MmeHdr)) &&
        (((pHdr)->cMmeCtrl & 0x7F) >= 1) &&
        ((pHdr)->cMmeHdr == expectedMmeHdr) &&
        ((pHdr)->cMmeLen <= (pkt.Size() - sizeof(MmeHdr)) &&
        ((pHdr)->cMmeLen >= expectedMmeLen));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r15
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r14
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
cmpq $0x11, %rax
jb 0x617a
testb $0x7f, 0xe(%r14)
je 0x617a
cmpb %bpl, 0xf(%r14)
jne 0x617a
movzbl 0x10(%r14), %r12d
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
addq $-0x11, %rax
cmpq %r12, %rax
jae 0x6185
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpb %bl, 0x10(%r14)
setae %al
jmp 0x617c
// File: /workspace/github_cpp_makefile_star2_O3/dguglielmi[P]dlan-linux-software/tools/../common/hpmmes.h
// Function: HomePlugMMEs::TurboVSHdr::IsValid(IPacket const&, unsigned char, unsigned char)
static bool IsValid(const IPacket& pkt, uint8_t expectedMsgID, uint8_t expectedMsgLen)
    {
      return
        MmeHdr::IsValid(pkt, eTurboVendorSpecMmeHdr, (sizeof(TurboVSHdr) - sizeof(MmeHdr)) + expectedMsgLen) && 
        (((TurboVSHdr*)pkt.Data())->cOUI[0] == cCogencyOUI[0]) &&
        (((TurboVSHdr*)pkt.Data())->cOUI[1] == cCogencyOUI[1]) &&
        (((TurboVSHdr*)pkt.Data())->cOUI[2] == cCogencyOUI[2]) &&
        (((TurboVSHdr*)pkt.Data())->cMsgID == (expectedMsgID | 0x80));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
addb $0x4, %dl
movzbl %dl, %edx
movl $0x2, %esi
callq 0x6130
testb %al, %al
je 0x61e8
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
cmpb $0x0, 0x11(%rax)
jne 0x61e8
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
cmpb $0x4, 0x12(%rax)
jne 0x61e8
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
cmpb $-0x79, 0x13(%rax)
jne 0x61e8
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
orb $-0x80, %bl
cmpb %bl, 0x14(%rax)
sete %al
jmp 0x61ea
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/dguglielmi[P]dlan-linux-software/tools/../common/hpmmes.h
// Function: HomePlugAvMMEs::ThunderVSHdr::IsValid(IPacket const&, unsigned short)
static bool IsValid(const IPacket& pkt, uint16_t expectedMmeType)
    {
      return
        (pkt.Size() >= sizeof(ThunderVSHdr)) &&
        (((ThunderVSHdr*)pkt.Data())->cMmeVersion == eMmeVersion0) &&
        (((ThunderVSHdr*)pkt.Data())->uMmeType == htoles(expectedMmeType)) &&
        (((ThunderVSHdr*)pkt.Data())->cOUI[0] == cIntellonOUI[0]) &&
        (((ThunderVSHdr*)pkt.Data())->cOUI[1] == cIntellonOUI[1]) &&
        (((ThunderVSHdr*)pkt.Data())->cOUI[2] == cIntellonOUI[2]);
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x8(%rax)
cmpq $0x14, %rax
jb 0x6303
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpb $0x0, 0xe(%rax)
jne 0x6303
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpw %bp, 0xf(%rax)
jne 0x6303
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpb $0x0, 0x11(%rax)
jne 0x6303
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpb $-0x50, 0x12(%rax)
jne 0x6303
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpb $0x52, 0x13(%rax)
sete %al
jmp 0x6305
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dguglielmi[P]dlan-linux-software/tools/../common/hpmmes.h
// Function: HomePlugAvMMEs::ThunderVSV1Hdr::IsValid(IPacket const&, unsigned short)
static bool IsValid(const IPacket& pkt, uint16_t expectedMmeType)
    {
      return
        (pkt.Size() >= sizeof(ThunderVSHdr)) &&
        (((ThunderVSV1Hdr*)pkt.Data())->cMmeVersion == eMmeVersion1) &&
        (((ThunderVSV1Hdr*)pkt.Data())->uMmeType == htoles(expectedMmeType)) &&
        (((ThunderVSV1Hdr*)pkt.Data())->uFragInfo == 0) &&
        (((ThunderVSV1Hdr*)pkt.Data())->cOUI[0] == cIntellonOUI[0]) &&
        (((ThunderVSV1Hdr*)pkt.Data())->cOUI[1] == cIntellonOUI[1]) &&
        (((ThunderVSV1Hdr*)pkt.Data())->cOUI[2] == cIntellonOUI[2]);
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x8(%rax)
cmpq $0x14, %rax
jb 0x6378
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpb $0x1, 0xe(%rax)
jne 0x6378
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpw %bp, 0xf(%rax)
jne 0x6378
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpw $0x0, 0x11(%rax)
jne 0x6378
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpb $0x0, 0x13(%rax)
jne 0x6378
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpb $-0x50, 0x14(%rax)
jne 0x6378
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpb $0x52, 0x15(%rax)
sete %al
jmp 0x637a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dguglielmi[P]dlan-linux-software/common/dlandevice.cpp
// Function: CDlanLocalDevice::UpdateRemoteDevice(CDlanRemoteDevice const&)
bool CDlanLocalDevice::UpdateRemoteDevice(
  const CDlanRemoteDevice& remoteDevice)
{
  bool bResult = false;

  CDlanRemoteDeviceList::iterator itDevice = m_remoteDeviceList.begin();
  for( ; (itDevice != m_remoteDeviceList.end()); itDevice++)
  {
    if(itDevice->GetAddress() >= remoteDevice.GetAddress())
      break;
  }
  
  if((itDevice == m_remoteDeviceList.end()) || (itDevice->GetAddress() != remoteDevice.GetAddress()))
  {
    m_remoteDeviceList.insert(itDevice, remoteDevice);
    bResult = true;
  }
  else if(*itDevice != remoteDevice)
  {
    *itDevice = remoteDevice;
    bResult = true;
  }

  return bResult;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0xa0, %rdi
movq %rdi, %rbx
movq (%rbx), %rbx
cmpq %rdi, %rbx
je 0x6532
movl 0x10(%rbx), %eax
movl (%r14), %ecx
bswapl %eax
bswapl %ecx
cmpl %ecx, %eax
jne 0x650c
movzwl 0x14(%rbx), %eax
movzwl 0x4(%r14), %ecx
rolw $0x8, %ax
rolw $0x8, %cx
movzwl %ax, %eax
movzwl %cx, %ecx
xorl %edx, %edx
cmpl %ecx, %eax
je 0x6518
cmpl %ecx, %eax
movl $0x0, %edx
sbbl %edx, %edx
orl $0x1, %edx
testl %edx, %edx
js 0x64d9
movl 0x10(%rbx), %eax
xorl (%r14), %eax
movzwl 0x14(%rbx), %ecx
xorw 0x4(%r14), %cx
movzwl %cx, %ecx
orl %eax, %ecx
je 0x6554
movq %r14, %rsi
callq 0x6dc8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4060
incq 0xb0(%r15)
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
addq $0x10, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x660e
testb %al, %al
je 0x656b
xorl %eax, %eax
jmp 0x654e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x65c0
jmp 0x654c
// File: /workspace/github_cpp_makefile_star2_O3/dguglielmi[P]dlan-linux-software/common/dlandevice.cpp
// Function: CDlanLocalDevice::RemoveRemoteDevice(CMACAddress const&)
bool CDlanLocalDevice::RemoveRemoteDevice(
  const CMACAddress& remoteDeviceAddr)
{
  for(CDlanRemoteDeviceList::iterator itDevice = m_remoteDeviceList.begin();
    itDevice != m_remoteDeviceList.end(); ++itDevice)
  {
    if(itDevice->GetAddress() == remoteDeviceAddr)
    {
      m_remoteDeviceList.erase(itDevice);
      return true;
    }
  }
  
  return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0xa0, %rbx
movq %rbx, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x65b2
movl 0x10(%r14), %eax
xorl (%rsi), %eax
movzwl 0x14(%r14), %ecx
xorw 0x4(%rsi), %cx
movzwl %cx, %ecx
orl %eax, %ecx
jne 0x6589
movq %rbx, %rdi
movq %r14, %rsi
callq 0x740c
cmpq %rbx, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/dguglielmi[P]dlan-linux-software/common/dlandevice.h
// Function: CDlanRemoteDevice::operator=(CDlanRemoteDevice const&)
CDlanRemoteDevice& operator=(const CDlanRemoteDevice& rhs) 
  { 
    CDlanDevice::operator=(rhs); 
    CDlanDataRates::operator=(rhs);
    m_remoteDataRates = rhs.m_remoteDataRates;
    m_bridgedAddresses = rhs.m_bridgedAddresses;
    return *this;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6852
movups 0x90(%rbx), %xmm0
movups %xmm0, 0x90(%r14)
movl $0xa0, %edi
leaq (%rbx,%rdi), %rsi
addq %r14, %rdi
callq 0x68b8
movl $0xd0, %edi
addq %rdi, %rbx
addq %r14, %rdi
movq %rbx, %rsi
callq 0x6b4e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dguglielmi[P]dlan-linux-software/common/dlandevice.h
// Function: CDlanRemoteDevice::operator==(CDlanRemoteDevice const&) const
bool operator==(const CDlanRemoteDevice& rhs) const 
  {
    return 
      CDlanDevice::operator==(rhs) && 
      CDlanDataRates::operator==(rhs) && 
      (m_remoteDataRates == rhs.m_remoteDataRates) &&
      (m_bridgedAddresses == rhs.m_bridgedAddresses);
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x66bc
testb %al, %al
je 0x66b1
movsd 0x90(%rbx), %xmm0
ucomisd 0x90(%r14), %xmm0
jne 0x66b1
jp 0x66b1
movsd 0x98(%rbx), %xmm0
ucomisd 0x98(%r14), %xmm0
jne 0x66b1
jp 0x66b1
movq 0xc8(%rbx), %rax
cmpq 0xc8(%r14), %rax
jne 0x66b1
movq 0xb8(%rbx), %rdi
leaq 0xa8(%rbx), %rsi
movq 0xb8(%r14), %rdx
callq 0x677a
testb %al, %al
je 0x66b1
movq 0xf8(%rbx), %rax
cmpq 0xf8(%r14), %rax
jne 0x66b1
movq 0xe8(%rbx), %rdi
addq $0xd8, %rbx
movq 0xe8(%r14), %rdx
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x67f2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dguglielmi[P]dlan-linux-software/common/dlanmonitor.cpp
// Function: CDlanMonitor::RemoveFromDeviceLists(std::set<CMACAddress, std::less<CMACAddress>, std::allocator<CMACAddress>> const&)
void CDlanMonitor::RemoveFromDeviceLists(
  const std::set<CMACAddress>& setDevices)
{
  bool bUpdate = false;
  RemoveDevices(bUpdate, false, setDevices);
  if(bUpdate) 
    OnUpdate();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %rbx
leaq 0x7(%rsp), %r14
movb $0x0, (%r14)
movq %r14, %rsi
xorl %edx, %edx
callq 0x74de
cmpb $0x1, (%r14)
jne 0x74d6
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x74d6
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/dguglielmi[P]dlan-linux-software/common/dlanmonitor.cpp
// Function: CDlanMonitor::Drumbeat()
unsigned long CDlanMonitor::Drumbeat()
{
  if(m_ulTick == 0)
  {
    bool bUpdate = false;
    UpdateAdapters(bUpdate, m_ifc.GetAdapters());
    RemoveDevices(bUpdate, true);
    TickAdapters();

    if(bUpdate)
      OnUpdate();
  }

  bool bStillPacketsPending = false;
  SendQueuedPackets(bStillPacketsPending);

  unsigned long ulWait = bStillPacketsPending ? 
    m_timings.DelayedSendingInterval : (m_timings.TickInterval - m_ulTick);

  m_ulTick += ulWait;
  m_ulTick %= m_timings.TickInterval;

  return ulWait;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
jne 0x7c49
leaq 0xf(%rsp), %r14
movb $0x0, (%r14)
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7ca4
leaq 0x18(%rsp), %rax
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x74de
leaq 0x10(%rsp), %rdi
callq 0x5f24
movq %rbx, %rdi
callq 0x7f8e
cmpb $0x1, 0xf(%rsp)
jne 0x7c49
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x7c49
movq (%rdi), %rax
callq *(%rax)
leaq 0x10(%rsp), %r14
movb $0x0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8050
movq 0x18(%rbx), %rax
movq 0x38(%rbx), %rsi
cmpb $0x0, (%r14)
je 0x7c71
movq 0x40(%rbx), %rcx
jmp 0x7c77
movq %rsi, %rcx
subq %rax, %rcx
addq %rcx, %rax
xorl %edx, %edx
divq %rsi
movq %rdx, 0x18(%rbx)
movq %rcx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5f24
movq %rbx, %rdi
callq 0x43e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/dguglielmi[P]dlan-linux-software/common/dlanmonitor.cpp
// Function: CDlanMonitor::SendRemoteDeviceBroadcasts(std::_Rb_tree_iterator<std::pair<CMACAddress const, CDlanMonitor::NetwAdapter>>)
void CDlanMonitor::SendRemoteDeviceBroadcasts(
  std::map<CMACAddress,NetwAdapter>::iterator itNIC)
{
  size_t iAvDeviceCnt = 0;
  for(std::map<CMACAddress,LocalDevice>::iterator itLocalDevice = itNIC->second.mapLocalDevices.begin();
    (itLocalDevice != itNIC->second.mapLocalDevices.end()); ++itLocalDevice)
  {
    if(itLocalDevice->second.itPublicDevice->GetType() == CDlanDevice::eThunderbolt)
      iAvDeviceCnt++;
  }

  if(itNIC->second.mapLocalDevices.size() > iAvDeviceCnt)
  {
    if(((m_eMode & eMonitorHP1) == eMonitorHP1) || ((m_eMode & eMonitorTurbo) == eMonitorTurbo))
    {
      itNIC->second.queuePendingPackets.push(
        new HomePlugMMEs::ParamsAndStats::CRequest(CMACAddress::Broadcast(), itNIC->first));

      itNIC->second.queuePendingPackets.push(
        new HomePlugMMEs::TurboChannelCapacities::CRequest(CMACAddress::Broadcast(), itNIC->first, 
        HomePlugMMEs::TurboChannelCapacities::eDirectionFlagTxCaps));
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1a0(%rsi), %rax
leaq 0x190(%rsi), %r12
xorl %r15d, %r15d
cmpq %r12, %rax
je 0x8bec
movq 0x30(%rax), %rcx
xorl %edx, %edx
cmpl $0x2, 0x18(%rcx)
sete %dl
addq %rdx, %r15
movq %rax, %rdi
callq 0x41d0
jmp 0x8bcd
cmpq %r15, 0x1b0(%rbx)
jbe 0x8cbe
movl 0x20(%r14), %eax
notl %eax
testb $0x3, %al
setne %cl
testb $0xc, %al
setne %al
testb %al, %cl
jne 0x8cbe
leaq 0x20(%rbx), %r15
addq $0x1b8, %rbx            # imm = 0x1B8
movl $0x20, %edi
callq 0x4260
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, 0x8(%rax)
movw $0xffff, %r12w          # imm = 0xFFFF
movw %r12w, 0xc(%rax)
leaq 0x14e19(%rip), %rcx     # 0x1da58
movq %rcx, (%rax)
movl (%r15), %ecx
movl %ecx, 0xe(%rax)
movzwl 0x4(%r15), %ecx
movw %cx, 0x12(%rax)
movl $0x7017b88, 0x14(%rax)  # imm = 0x7017B88
movb $0x0, 0x18(%rax)
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe242
movl $0x20, %edi
callq 0x4260
movl %ebp, 0x8(%rax)
movw %r12w, 0xc(%rax)
leaq 0x14e08(%rip), %rcx     # 0x1da90
movq %rcx, (%rax)
movl (%r15), %ecx
movl %ecx, 0xe(%rax)
movzwl 0x4(%r15), %ecx
movw %cx, 0x12(%rax)
movw $0x7b88, 0x14(%rax)     # imm = 0x7B88
movabsq $0x118870400050201, %rcx # imm = 0x118870400050201
movq %rcx, 0x16(%rax)
movq %rax, (%r14)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xe242
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dguglielmi[P]dlan-linux-software/common/dlanmonitor.cpp
// Function: CDlanMonitor::ClearUnknownDevices(std::_Rb_tree_iterator<std::pair<CMACAddress const, CDlanMonitor::NetwAdapter>>)
void CDlanMonitor::ClearUnknownDevices(
  std::map<CMACAddress,NetwAdapter>::iterator itNIC)
{
  itNIC->second.setParamsAndStatsResponses.clear();
  itNIC->second.setRemoteTurboResponses.clear();
  itNIC->second.setDevicesToTrigger.clear();
  itNIC->second.setReadModDataResponses.clear();
  itNIC->second.mapGetVersionResponses.clear();
  itNIC->second.mapUserDataResponses.clear();
  itNIC->second.mapNetworkInfoResponses.clear();
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
leaq 0x38(%rsi), %rdi
callq 0xeb4c
leaq 0x68(%rbx), %rdi
callq 0xeb4c
leaq 0x98(%rbx), %rdi
callq 0xeb4c
leaq 0xc8(%rbx), %rdi
callq 0xeb4c
leaq 0xf8(%rbx), %rdi
callq 0xe9ba
leaq 0x128(%rbx), %rdi
callq 0xeb7a
addq $0x158, %rbx            # imm = 0x158
movq %rbx, %rdi
popq %rbx
jmp 0xeba8
// File: /workspace/github_cpp_makefile_star2_O3/dguglielmi[P]dlan-linux-software/common/dlandevice.h
// Function: CDlanLocalDevice::operator=(CDlanLocalDevice const&)
CDlanLocalDevice& operator=(const CDlanLocalDevice& rhs) 
  { 
    CDlanDevice::operator=(rhs); 
    m_addrNIC = rhs.m_addrNIC; 
    m_addrCCo = rhs.m_addrCCo; 
    m_remoteDeviceList = rhs.m_remoteDeviceList; 
    return *this; 
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x6852
cmpq %rbx, %r14
je 0xc0d4
movzwl 0x94(%r14), %eax
movw %ax, 0x94(%rbx)
movl 0x90(%r14), %eax
movl %eax, 0x90(%rbx)
movl 0x96(%r14), %eax
movl %eax, 0x96(%rbx)
movzwl 0x9a(%r14), %eax
movw %ax, 0x9a(%rbx)
movl $0xa0, %edi
leaq (%r14,%rdi), %rdx
addq %rbx, %rdi
movq 0xa0(%r14), %rsi
callq 0xd202
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dguglielmi[P]dlan-linux-software/common/dlandevice.h
// Function: CDlanLocalDevice::operator==(CDlanLocalDevice const&) const
bool operator==(const CDlanLocalDevice& rhs) const 
  { 
    return 
      CDlanDevice::operator==(rhs) && 
      (m_addrNIC == rhs.m_addrNIC) && 
      (m_addrCCo == rhs.m_addrCCo) && 
      (m_remoteDeviceList == rhs.m_remoteDeviceList);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x66bc
testb %al, %al
je 0xd1f3
movl 0x90(%r14), %eax
xorl 0x90(%rbx), %eax
movzwl 0x94(%r14), %ecx
xorw 0x94(%rbx), %cx
movzwl %cx, %ecx
orl %eax, %ecx
jne 0xd1f3
movl 0x96(%r14), %eax
xorl 0x96(%rbx), %eax
movzwl 0x9a(%r14), %ecx
xorw 0x9a(%rbx), %cx
movzwl %cx, %ecx
orl %eax, %ecx
jne 0xd1f3
movq 0xb0(%r14), %rax
cmpq 0xb0(%rbx), %rax
jne 0xd1f3
movl $0xa0, %eax
addq %rax, %r14
addq %rax, %rbx
movq %r14, %r15
movq %rbx, %r12
movq (%r12), %r12
movq (%r15), %r15
cmpq %r14, %r15
je 0xd1e5
cmpq %rbx, %r12
je 0xd1e5
leaq 0x10(%r15), %rdi
leaq 0x10(%r12), %rsi
callq 0x660e
testb %al, %al
jne 0xd1c2
xorq %r14, %r15
xorq %rbx, %r12
orq %r15, %r12
sete %al
jmp 0xd1f5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop