LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x17a9e
testq %r14, %r14
je 0x1a423
movq %rbx, %rdi
movq %r14, %rsi
callq 0x175f6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1767a
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 0x1a010
movq %rbx, %rdi
callq 0x1a174
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x17ab2
movq %r14, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O1/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 0x17a9e
movl 0x4(%r14), %eax
testl %eax, %eax
je 0x1a4a8
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 0x179a4
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 0x1a010
movq %rbx, %rdi
callq 0x1a174
jmp 0x1a4ee
movq 0xdb41(%rip), %r14      # 0x27ff0
leaq 0x46d9(%rip), %rsi      # 0x1eb8f
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 0xdb0f(%rip), %rdi      # 0x27ff0
callq 0x3040
movq %rax, %rdi
callq 0x3190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x17ab2
movq %r14, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x17a9e
movl 0x4(%r14), %eax
testl %eax, %eax
je 0x1a57e
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 0x179a4
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 0x1a010
movq %rbx, %rdi
callq 0x1a174
jmp 0x1a5c4
movq 0xda6b(%rip), %r14      # 0x27ff0
leaq 0x4603(%rip), %rsi      # 0x1eb8f
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 0xda39(%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 0x17ab2
movq %r14, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1a694
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 0x1a69d
movl %r14d, %r8d
movl %ebp, %edx
jmp 0x1a6b1
movl 0x4(%r9), %edi
jmp 0x1a780
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 0x1a6d5
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 0x1a73f
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 0x1a6f6
testl %esi, %esi
je 0x1a780
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_O1/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 0x1ac04
movq %rdi, %r15
xorl %edx, %edx
callq 0x1a644
testl %eax, %eax
je 0x1ac04
movl %eax, %r14d
decl %r14d
movq %r15, %rdi
movl %r14d, %esi
callq 0x1a788
movl %eax, %ebx
jmp 0x1ac09
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_O1/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 0x1ac47
movq %rdi, %r14
testl %esi, %esi
je 0x1ac4c
decl %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1a644
movl %eax, %ebx
movq %r14, %rdi
movl %eax, %esi
jmp 0x1ac53
movl 0x4(%rcx), %ebx
jmp 0x1ac58
xorl %ebx, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x1a788
shlq $0x20, %rbx
movl %eax, %eax
orq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1a788
movl %eax, %r14d
movl 0x8(%rbx), %esi
movq (%rbx), %rax
movl 0x4(%rax), %eax
decl %eax
cmpl %eax, %esi
jae 0x1acf3
xorl %ebp, %ebp
incl %esi
movq %rbx, %rdi
callq 0x1a788
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 0x1acca
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
movl 0x10(%rdi), %ecx
movq %rax, %rsi
imulq %rcx, %rsi
shlq $0x3, %rsi
cmpq %rdx, %rsi
ja 0x1ad8e
movq %rdi, %rbx
leal 0x1(%r14), %edx
movl (%rdi), %esi
cmpl %edx, %esi
cmoval %esi, %edx
movl 0x10(%rdi), %esi
movl %edx, (%rdi)
imull %ecx, %eax
shll $0x3, %eax
subl %eax, %r14d
shll $0x3, %esi
cmpl %esi, %r14d
jb 0x1ad62
movq %rbx, %rdi
callq 0x182fa
movl 0x10(%rbx), %eax
shll $0x3, %eax
subl %eax, %r14d
cmpl %eax, %r14d
jae 0x1ad4c
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 0x1ad8b
incl 0x4(%rbx)
orl %esi, (%rax,%rdx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x94b7(%rip), %rcx      # 0xcad8
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 0x947d(%rip), %rcx      # 0xcac0
movq %rcx, (%rax)
leaq 0x49f5(%rip), %rcx      # 0x8042
movq %rcx, 0x8(%rax)
leaq 0x9440(%rip), %rsi      # 0xca98
movq 0x9981(%rip), %rdx      # 0xcfe0
movq %rax, %rdi
callq 0x3280
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4538
movl $0x0, 0x50(%rbx)
leaq -0x78(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x4340
leaq -0x70(%rbp), %r15
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x43ac
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x3b95
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x3180
movq %r15, %rdi
callq 0x44e8
movq -0x38(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x4480
movq %r14, %rdi
movq %r15, %rsi
callq 0x7136
movzbl -0x50(%rbp), %eax
leaq 0x9048(%rip), %rcx      # 0xcc08
leaq -0x19(%rbp), %rdi
movq %r15, %rsi
callq *(%rcx,%rax,8)
leaq -0x38(%rbp), %rdi
callq 0x44e8
movq %rbx, %rdi
callq 0x7214
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 0x44b6
jmp 0x3c05
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x44e8
jmp 0x3c21
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0x4450
jmp 0x3c21
movq %rax, %r14
movq %rbx, %rdi
callq 0x7214
movq %r14, %rdi
callq 0x32a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdi, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x49fc
cmpl $0x20, %eax
je 0x4967
cmpl $0xa, %eax
jne 0x4982
movq %rbx, %rdi
callq 0x5112
cmpl $0xa, %eax
jne 0x497d
movl $0x0, 0x58(%rbx)
jmp 0x4953
incl 0x58(%rbx)
jmp 0x4953
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x49db
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 0x5196
movq %r12, %rdi
callq 0x4b4c
cmpl %ebx, 0x20(%r14)
jg 0x49ab
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x4b4c
movq %rbx, %rdi
callq 0x32a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4b2d
movl %esi, %ebx
movq %rdi, %r14
addq $0x8, %rdi
leaq -0x40(%rbp), %rsi
movb $0x2, 0x20(%rsi)
callq 0x5196
leaq 0x20(%r14), %r15
leaq -0x40(%rbp), %rdi
callq 0x4b4c
movq 0x30(%r14), %rsi
cmpq 0x38(%r14), %rsi
je 0x4b1b
movl 0x20(%r14), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x30(%r14)
jmp 0x4b2a
addq $0x28, %r14
movq %r14, %rdi
movq %r15, %rdx
callq 0x4ff0
movl %ebx, (%r15)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x4b4c
movq %rbx, %rdi
callq 0x32a0
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
leaq -0x1b8(%rbp), %rdi
callq 0x3100
leaq -0x1a8(%rbp), %r15
leaq -0x29(%rbp), %r12
movq (%r14), %rdi
xorl %esi, %esi
callq 0x49fc
cmpl $0x3a, %eax
je 0x4c8c
cmpl $-0x1, %eax
je 0x4cd4
cmpl $0xa, %eax
jne 0x4ca3
jmp 0x4cd4
movq (%r14), %rdi
movl $0x1, %esi
callq 0x49fc
cmpl $0xa, %eax
je 0x4cd4
cmpl $0x20, %eax
je 0x4cd4
movq (%r14), %r13
movq %r13, %rdi
callq 0x5112
xorl %ecx, %ecx
cmpl $0xa, %eax
je 0x4cbb
movl 0x58(%r13), %ecx
incl %ecx
movl %ecx, 0x58(%r13)
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x31a0
jmp 0x4c71
leaq -0x1a0(%rbp), %rsi
movq %rbx, %rdi
callq 0x3240
movq 0x82be(%rip), %rsi      # 0xcfa8
leaq -0x1b8(%rbp), %rdi
callq 0x3120
leaq -0x138(%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 0x4d19
movq %rax, %rbx
movq 0x8285(%rip), %rsi      # 0xcfa8
leaq -0x1b8(%rbp), %rdi
callq 0x3120
leaq -0x138(%rbp), %rdi
callq 0x3080
movq %rbx, %rdi
callq 0x32a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
xorl %ecx, %ecx
testq %rax, %rax
je 0x57cd
cmpb $0x1, 0x20(%rax)
cmoveq %rax, %rcx
testq %rcx, %rcx
je 0x57f6
addq $0x28, %rax
movq %rax, (%rsi)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x42a6
movb $0x1, %al
jmp 0x57f8
xorl %eax, %eax
movb %al, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4da7
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 0x4da7
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 0x4d1e
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_O1/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 0x4f94
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 0x4f5c
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
popq %rbx
popq %r14
popq %r15
jmpq *0x18(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5479
leaq 0x98(%rbx), %r14
movq 0x98(%rbx), %r15
cmpq %r14, %r15
sete %al
orb 0xe0(%rbx), %al
jne 0x54ae
movq 0xf0(%rbx), %rax
movl 0x10(%r15), %ecx
xorl (%rax), %ecx
movzwl 0x14(%r15), %edx
xorw 0x4(%rax), %dx
movzwl %dx, %eax
orl %ecx, %eax
jne 0x5466
movq %r15, 0xf8(%rbx)
movb $0x1, 0xe0(%rbx)
movq 0xe8(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
cmpb $0x0, 0xe0(%rbx)
jne 0x54ae
movq (%r15), %r15
cmpq %r14, %r15
jne 0x542e
jmp 0x54ae
cmpq $0x0, 0xa8(%rbx)
je 0x54ae
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
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5b95
movq 0x10(%r13), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %r14, %rdx
callq *(%rax)
testb %al, %al
je 0x5b79
movq 0x20(%rbx), %r14
addq $0x20, %rbx
cmpq %rbx, %r14
je 0x5bb9
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0x5bbb
movq (%r14), %r14
cmpq %rbx, %r14
jne 0x5ba2
jmp 0x5bbb
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x61c4
testb $0x7f, 0xe(%r14)
je 0x61c4
cmpb %bpl, 0xf(%r14)
jne 0x61c4
movzbl 0x10(%r14), %r12d
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
addq $-0x11, %rax
cmpq %r12, %rax
jae 0x61cf
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpb %bl, 0x10(%r14)
setae %al
jmp 0x61c6
// File: /workspace/github_cpp_makefile_star2_O1/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 0x617a
testb %al, %al
je 0x6232
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
cmpb $0x0, 0x11(%rax)
jne 0x6232
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
cmpb $0x4, 0x12(%rax)
jne 0x6232
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
cmpb $-0x79, 0x13(%rax)
jne 0x6232
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
orb $-0x80, %bl
cmpb %bl, 0x14(%rax)
sete %al
jmp 0x6234
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x634d
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpb $0x0, 0xe(%rax)
jne 0x634d
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpw %bp, 0xf(%rax)
jne 0x634d
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpb $0x0, 0x11(%rax)
jne 0x634d
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpb $-0x50, 0x12(%rax)
jne 0x634d
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpb $0x52, 0x13(%rax)
sete %al
jmp 0x634f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x63c2
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpb $0x1, 0xe(%rax)
jne 0x63c2
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpw %bp, 0xf(%rax)
jne 0x63c2
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpw $0x0, 0x11(%rax)
jne 0x63c2
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpb $0x0, 0x13(%rax)
jne 0x63c2
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpb $-0x50, 0x14(%rax)
jne 0x63c2
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpb $0x52, 0x15(%rax)
sete %al
jmp 0x63c4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6560
movl 0x10(%rbx), %eax
movl (%r14), %ecx
bswapl %eax
bswapl %ecx
cmpl %ecx, %eax
jne 0x6550
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 0x655c
cmpl %ecx, %eax
movl $0x0, %edx
sbbl %edx, %edx
orl $0x1, %edx
testl %edx, %edx
js 0x651d
cmpq %rdi, %rbx
je 0x657b
movl 0x10(%rbx), %eax
xorl (%r14), %eax
movzwl 0x14(%rbx), %ecx
xorw 0x4(%r14), %cx
movzwl %cx, %ecx
orl %eax, %ecx
je 0x659d
movq %r14, %rsi
callq 0x6e80
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 0x666a
testb %al, %al
je 0x65b4
xorl %eax, %eax
jmp 0x6597
movq %rbx, %rdi
movq %r14, %rsi
callq 0x660a
jmp 0x6595
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x65fc
movl 0x10(%r14), %eax
xorl (%rsi), %eax
movzwl 0x14(%r14), %ecx
xorw 0x4(%rsi), %cx
movzwl %cx, %ecx
orl %eax, %ecx
jne 0x65d3
movq %rbx, %rdi
movq %r14, %rsi
callq 0x74f2
cmpq %rbx, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x68e6
movsd 0x90(%rbx), %xmm0
movsd %xmm0, 0x90(%r14)
movsd 0x98(%rbx), %xmm0
movsd %xmm0, 0x98(%r14)
movl $0xa0, %edi
leaq (%rbx,%rdi), %rsi
addq %r14, %rdi
callq 0x694c
movl $0xd0, %edi
addq %rdi, %rbx
addq %r14, %rdi
movq %rbx, %rsi
callq 0x6bf0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6718
testb %al, %al
je 0x670d
movsd 0x90(%rbx), %xmm0
ucomisd 0x90(%r14), %xmm0
jne 0x670d
jp 0x670d
movsd 0x98(%rbx), %xmm0
ucomisd 0x98(%r14), %xmm0
jne 0x670d
jp 0x670d
movq 0xc8(%rbx), %rax
cmpq 0xc8(%r14), %rax
jne 0x670d
movq 0xb8(%rbx), %rdi
leaq 0xa8(%rbx), %rsi
movq 0xb8(%r14), %rdx
callq 0x67d6
testb %al, %al
je 0x670d
movq 0xf8(%rbx), %rax
cmpq 0xf8(%r14), %rax
jne 0x670d
movq 0xe8(%rbx), %rdi
addq $0xd8, %rbx
movq 0xe8(%r14), %rdx
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6872
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dguglielmi[P]dlan-linux-software/common/dlandevice.h
// Function: CDlanDevice::operator=(CDlanDevice const&)
CDlanDevice& operator=(const CDlanDevice& rhs)
  { 
    m_addr = rhs.m_addr; 
    m_eType = rhs.m_eType; 
    m_strVersion = rhs.m_strVersion; 
    m_strMftString = rhs.m_strMftString; 
    m_strUserString = rhs.m_strUserString; 
    m_strAvlnString = rhs.m_strAvlnString;
    return *this; 
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq %rdi, %rsi
je 0x6903
movzwl 0x4(%r14), %eax
movw %ax, 0x4(%rbx)
movl (%r14), %eax
movl %eax, (%rbx)
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
leaq 0x10(%r14), %rsi
leaq 0x10(%rbx), %rdi
callq 0x41a0
leaq 0x30(%r14), %rsi
leaq 0x30(%rbx), %rdi
callq 0x41a0
leaq 0x50(%r14), %rsi
leaq 0x50(%rbx), %rdi
callq 0x41a0
addq $0x70, %r14
leaq 0x70(%rbx), %rdi
movq %r14, %rsi
callq 0x41a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x75c2
cmpb $0x1, (%r14)
jne 0x75ba
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x75ba
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_O1/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 0x7d2f
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 0x7d8a
leaq 0x18(%rsp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x8(%rax)
movaps %xmm0, 0x18(%rax)
movaps %xmm0, -0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq $0x0, 0x20(%rax)
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x75c2
leaq 0x10(%rsp), %rdi
callq 0x5f6e
movq %rbx, %rdi
callq 0x8078
cmpb $0x1, 0xf(%rsp)
jne 0x7d2f
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x7d2f
movq (%rdi), %rax
callq *(%rax)
leaq 0x10(%rsp), %r14
movb $0x0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x813a
movq 0x18(%rbx), %rax
movq 0x38(%rbx), %rsi
cmpb $0x0, (%r14)
je 0x7d57
movq 0x40(%rbx), %rcx
jmp 0x7d5d
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 0x5f6e
movq %rbx, %rdi
callq 0x43e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8d78
movq 0x30(%rax), %rcx
xorl %edx, %edx
cmpl $0x2, 0x18(%rcx)
sete %dl
addq %rdx, %r15
movq %rax, %rdi
callq 0x41d0
jmp 0x8d59
cmpq %r15, 0x1b0(%rbx)
jbe 0x8e4c
movl 0x20(%r14), %eax
notl %eax
testb $0x3, %al
setne %cl
testb $0xc, %al
setne %al
testb %al, %cl
jne 0x8e4c
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 0x14c9d(%rip), %rcx     # 0x1da68
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 0xe4a0
movl $0x20, %edi
callq 0x4260
movl %ebp, 0x8(%rax)
movw %r12w, 0xc(%rax)
leaq 0x14c8c(%rip), %rcx     # 0x1daa0
movq %rcx, (%rax)
movl (%r15), %ecx
movl %ecx, 0xe(%rax)
movzwl 0x4(%r15), %ecx
movw %cx, 0x12(%rax)
movl $0x2017b88, 0x14(%rax)  # imm = 0x2017B88
movb $0x5, 0x18(%rax)
movl $0x18870400, 0x19(%rax) # imm = 0x18870400
movb $0x1, 0x1d(%rax)
movq %rax, (%r14)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xe4a0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xed96
leaq 0x68(%rbx), %rdi
callq 0xed96
leaq 0x98(%rbx), %rdi
callq 0xed96
leaq 0xc8(%rbx), %rdi
callq 0xed96
leaq 0xf8(%rbx), %rdi
callq 0xec08
leaq 0x128(%rbx), %rdi
callq 0xedc4
addq $0x158, %rbx            # imm = 0x158
movq %rbx, %rdi
popq %rbx
jmp 0xedf2
// File: /workspace/github_cpp_makefile_star2_O1/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 0x68e6
cmpq %rbx, %r14
je 0xc300
movzwl 0x94(%r14), %eax
movw %ax, 0x94(%rbx)
movl 0x90(%r14), %eax
movl %eax, 0x90(%rbx)
cmpq %rbx, %r14
je 0xc321
movzwl 0x9a(%r14), %eax
movw %ax, 0x9a(%rbx)
movl 0x96(%r14), %eax
movl %eax, 0x96(%rbx)
cmpq %r14, %rbx
je 0xc33e
movl $0xa0, %edi
leaq (%r14,%rdi), %rdx
addq %rbx, %rdi
movq 0xa0(%r14), %rsi
callq 0xd480
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6718
testb %al, %al
je 0xd471
movl 0x90(%r14), %eax
xorl 0x90(%rbx), %eax
movzwl 0x94(%r14), %ecx
xorw 0x94(%rbx), %cx
movzwl %cx, %ecx
orl %eax, %ecx
jne 0xd471
movl 0x96(%r14), %eax
xorl 0x96(%rbx), %eax
movzwl 0x9a(%r14), %ecx
xorw 0x9a(%rbx), %cx
movzwl %cx, %ecx
orl %eax, %ecx
jne 0xd471
movq 0xb0(%r14), %rax
cmpq 0xb0(%rbx), %rax
jne 0xd471
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 0xd463
cmpq %rbx, %r12
je 0xd463
leaq 0x10(%r15), %rdi
leaq 0x10(%r12), %rsi
callq 0x666a
testb %al, %al
jne 0xd440
xorq %r14, %r15
xorq %rbx, %r12
orq %r15, %r12
sete %al
jmp 0xd473
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dguglielmi[P]dlan-linux-software/common/hptools.cpp
// Function: HomePlugTools::KeyFromPassword(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned char*)
void HomePlugTools::KeyFromPassword(
  const std::string& strPassword,
  unsigned char cKEY[8])
{
  std::string strSaltedPassword = strPassword + std::string("\x08\x85\x6D\xAF\x7C\xF5\x81\x85", 8);
  
  md5_state md5;
  unsigned char digest[16];
  md5_init(&md5);
  md5_process(&md5, (const unsigned char*)strSaltedPassword.data(), strSaltedPassword.size());
  md5_done(&md5, digest);

  for(int i = 2; i <= 1000; i++)
  {
    md5_init(&md5);
    md5_process(&md5, digest, 16);
    md5_done(&md5, digest);
  }

  memcpy(cKEY, digest, 8);

  for(int i = 0; i < 8; i++)
  {
    int iOneBits = 0;

    for(int j = 0x02; j != 0x00; j <<= 1)
      if(j & cKEY[i])
        iOneBits++;

    if((iOneBits & 0x01))
      cKEY[i] &= 0xFE;
    else
      cKEY[i] |= 0x01;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %rbx
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
movabsq $-0x7a7e0a8350927af8, %rax # imm = 0x8581F57CAF6D8508
movq %rax, (%r14)
movq $0x8, -0x8(%r14)
movb $0x0, 0x8(%r14)
movq (%rdi), %rcx
movq 0x8(%rdi), %r8
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x42b0
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x10b7d
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x10b85
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x10bb4
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x4270
movaps 0x5af5(%rip), %xmm0     # 0x166b0
leaq 0x30(%rsp), %r14
movups %xmm0, 0x8(%r14)
movl $0x0, 0x18(%r14)
movq $0x0, (%r14)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x10cbb
leaq 0x20(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x10d6c
movl $0x3e7, %ebp            # imm = 0x3E7
movaps 0x5aaf(%rip), %xmm0     # 0x166b0
movups %xmm0, 0x38(%rsp)
movl $0x0, 0x48(%rsp)
movq $0x0, 0x30(%rsp)
movl $0x10, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x10cbb
movq %r14, %rdi
movq %r15, %rsi
callq 0x10d6c
decl %ebp
jne 0x10bfa
movq 0x20(%rsp), %rax
movq %rax, (%rbx)
xorl %eax, %eax
movzbl (%rbx,%rax), %edx
movl $0x2, %esi
xorl %ecx, %ecx
movl %esi, %edi
andl %edx, %edi
cmpl $0x1, %edi
sbbl $-0x1, %ecx
addl %esi, %esi
jne 0x10c4b
movb (%rbx,%rax), %dl
andb $-0x2, %dl
andb $0x1, %cl
orb %dl, %cl
xorb $0x1, %cl
movb %cl, (%rbx,%rax)
incq %rax
cmpq $0x8, %rax
jne 0x10c40
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x10c89
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4270
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x10cb3
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x4270
movq %rbx, %rdi
callq 0x43e0