LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ushitora-anqou[P]femtoyaml/./femtoyaml.hpp
// Function: femtoyaml::detail::tokenizer::is_blankz(int)
bool is_blankz(int ch)
    {
        switch (ch) {
        case ' ':
        case '\n':
            return true;
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0xa, %eax
je 0x81b2
jmp 0x81a8
movl -0x18(%rbp), %eax
subl $0x20, %eax
jne 0x81b8
jmp 0x81b2
movb $0x1, -0x1(%rbp)
jmp 0x81bc
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl 0x20(%rax), %eax
cmpl -0xc(%rbp), %eax
jge 0x825b
movq -0x58(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x60(%rbp)
leaq -0x39(%rbp), %rsi
callq 0xa520
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x82c0
jmp 0x821b
leaq -0x38(%rbp), %rdi
callq 0x8320
movq -0x58(%rbp), %rsi
movq %rsi, %rdi
addq $0x28, %rdi
addq $0x20, %rsi
callq 0xa550
movq -0x58(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x20(%rax)
jmp 0x825b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8320
jmp 0x8261
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3390
nopw (%rax,%rax)
// File: ushitora-anqou[P]femtoyaml/./femtoyaml.hpp
// Function: femtoyaml::detail::stream::next()
int next()
    {
        int ch = next_detail();
        if (ch == '\n')
            column_ = 0;
        else
            column_++;
        return ch;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xad70
movl %eax, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
jne 0x829f
movq -0x18(%rbp), %rax
movl $0x0, 0x58(%rax)
jmp 0x82ac
movq -0x18(%rbp), %rax
movl 0x58(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x58(%rax)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1c0(%rbp)
movq %rdi, %rax
movq %rax, -0x1b8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1b0(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x3150
jmp 0x858d
movq -0x1b0(%rbp), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x8120
movl %eax, -0x1c4(%rbp)
jmp 0x85a6
movl -0x1c4(%rbp), %eax
subl $-0x1, %eax
je 0x862a
jmp 0x85b3
movl -0x1c4(%rbp), %eax
subl $0xa, %eax
je 0x85f0
jmp 0x85c0
movl -0x1c4(%rbp), %eax
subl $0x3a, %eax
je 0x85f2
jmp 0x862c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x3170
jmp 0x869e
jmp 0x866d
movq -0x1b0(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0x8120
movl %eax, -0x1c8(%rbp)
jmp 0x860e
movl -0x1c8(%rbp), %esi
movq -0x1b0(%rbp), %rdi
callq 0x8190
testb $0x1, %al
jne 0x8626
jmp 0x8628
jmp 0x866d
jmp 0x862c
jmp 0x866d
movq -0x1b0(%rbp), %rax
leaq -0x188(%rbp), %rcx
movq %rcx, -0x1d8(%rbp)
movq (%rax), %rdi
callq 0x8270
movl %eax, -0x1cc(%rbp)
jmp 0x8651
movq -0x1d8(%rbp), %rdi
movl -0x1cc(%rbp), %eax
movsbl %al, %esi
callq 0x3260
jmp 0x8668
jmp 0x858b
movq -0x1c0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x31d0
jmp 0x8682
leaq -0x198(%rbp), %rdi
callq 0x3170
movq -0x1b8(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0x3390
nopw (%rax,%rax)
// File: ushitora-anqou[P]femtoyaml/./femtoyaml.hpp
// Function: femtoyaml::detail::stream::next_detail()
int next_detail()
    {
        if (pending_.empty()) return is_.get();
        int ret = pending_.front();
        pending_.pop_front();
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x8, %rdi
callq 0xade0
testb $0x1, %al
jne 0xad93
jmp 0xada4
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x3270
movl %eax, -0x4(%rbp)
jmp 0xadc9
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0xae10
movq -0x20(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x14(%rbp)
addq $0x8, %rdi
callq 0xae40
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xcdb0
movq %rax, %rdi
callq 0xf660
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xf146
movq -0x40(%rbp), %rdi
callq 0xf680
jmp 0xf162
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0xf6a0
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rsi
callq 0xf6e0
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x1(%rbp), %rdi
callq 0xd190
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x41(%rbp)
jne 0x653a
leaq -0x1(%rbp), %rdi
callq 0xd190
movq %rax, -0x20(%rbp)
subq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
setb %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x6543
jmp 0x65a6
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq (%rax), %rcx
movq %rcx, -0x58(%rbp)
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
subq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xb790
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq (%rax), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x6505
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
xorb $-0x1, %al
testb $0x1, %al
jne 0x685a
jmp 0x6896
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x6844
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0xf0(%rax), %rdi
callq 0xb5a0
testb $0x1, %al
jne 0x73c9
jmp 0x7485
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x7350
movq %rax, %rdi
callq 0xb620
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0xe0(%rcx)
movb %al, -0x29(%rbp)
jne 0x741d
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x7350
movq %rax, %rdi
callq 0x7370
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xb650
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x7426
jmp 0x7483
leaq -0x10(%rbp), %rdi
callq 0x65c0
movq %rax, %rdi
callq 0x6610
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq 0xf0(%rax), %rsi
callq 0xb680
testb $0x1, %al
jne 0x7450
jmp 0x7473
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0xf8(%rax)
movb $0x1, 0xe0(%rax)
movq 0xe8(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x7475
leaq -0x10(%rbp), %rdi
callq 0xb6b0
jmp 0x73e2
jmp 0x74e1
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x7350
movq %rax, %rdi
callq 0xb6d0
cmpq $0x0, %rax
jbe 0x74df
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x7350
movq %rax, %rdi
callq 0xb620
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0xf8(%rax)
movb $0x1, 0xe0(%rax)
movq 0xe8(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x74e1
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
callq 0x8070
movq %rax, -0x20(%rbp)
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x80d0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x80a0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x49(%rbp)
jne 0x7e35
jmp 0x7e5c
leaq -0x20(%rbp), %rdi
callq 0x8100
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
callq *(%rax)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x7e65
jmp 0x7e70
leaq -0x20(%rbp), %rdi
callq 0x8130
jmp 0x7e09
movq -0x48(%rbp), %rdi
movb $0x0, -0x29(%rbp)
addq $0x20, %rdi
callq 0x8150
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
callq 0x81b0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x8180
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x4a(%rbp)
jne 0x7eb1
jmp 0x7ed8
leaq -0x38(%rbp), %rdi
callq 0x81e0
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movb %al, %cl
andb $0x1, %cl
movb %cl, -0x29(%rbp)
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x4a(%rbp)
movb -0x4a(%rbp), %al
testb $0x1, %al
jne 0x7ee1
jmp 0x7eec
leaq -0x38(%rbp), %rdi
callq 0x8210
jmp 0x7e85
movb -0x29(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x11, %rcx
movb %al, -0x19(%rbp)
jb 0xbb7b
movq -0x18(%rbp), %rax
movzbl 0xe(%rax), %ecx
andl $0x7f, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
movb %al, -0x19(%rbp)
jl 0xbb7b
movq -0x18(%rbp), %rax
movzbl 0xf(%rax), %ecx
movzbl -0x9(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x19(%rbp)
jne 0xbb7b
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x28(%rbp), %rcx
movq %rax, %rdx
subq $0x11, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x1a(%rbp)
ja 0xbb75
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
movzbl -0xa(%rbp), %ecx
cmpl %ecx, %eax
setge %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0xa(%rbp), %eax
addq $0x4, %rax
movl $0x2, %esi
movzbl %al, %edx
callq 0xbad0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xb(%rbp)
jne 0xbc3e
jmp 0xbcb4
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movzbl 0x11(%rax), %ecx
movzbl 0x2c61e(%rip), %edx     # 0x38270
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0xb(%rbp)
jne 0xbcb4
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movzbl 0x12(%rax), %ecx
movzbl 0x2c602(%rip), %edx     # 0x38271
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0xb(%rbp)
jne 0xbcb4
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movzbl 0x13(%rax), %ecx
movzbl 0x2c5e6(%rip), %edx     # 0x38272
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0xb(%rbp)
jne 0xbcb4
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movzbl 0x14(%rax), %eax
movzbl -0x9(%rbp), %ecx
orl $0x80, %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0xb(%rbp)
movb -0xb(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x14, %rcx
movb %al, -0xb(%rbp)
jb 0xc196
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movzbl 0xe(%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xb(%rbp)
jne 0xc196
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movzwl 0xf(%rax), %ecx
movzwl -0xa(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0xb(%rbp)
jne 0xc196
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movzbl 0x11(%rax), %ecx
movzbl 0x2c11f(%rip), %edx     # 0x38273
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0xb(%rbp)
jne 0xc196
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movzbl 0x12(%rax), %ecx
movzbl 0x2c103(%rip), %edx     # 0x38274
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0xb(%rbp)
jne 0xc196
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movzbl 0x13(%rax), %eax
movzbl 0x2c0e7(%rip), %ecx     # 0x38275
cmpl %ecx, %eax
sete %al
movb %al, -0xb(%rbp)
movb -0xb(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x14, %rcx
movb %al, -0xb(%rbp)
jb 0xc301
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movzbl 0xe(%rax), %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
movb %al, -0xb(%rbp)
jne 0xc301
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movzwl 0xf(%rax), %ecx
movzwl -0xa(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0xb(%rbp)
jne 0xc301
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movzwl 0x11(%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xb(%rbp)
jne 0xc301
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movzbl 0x13(%rax), %ecx
movzbl 0x2bfb4(%rip), %edx     # 0x38273
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0xb(%rbp)
jne 0xc301
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movzbl 0x14(%rax), %ecx
movzbl 0x2bf98(%rip), %edx     # 0x38274
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0xb(%rbp)
jne 0xc301
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movzbl 0x15(%rax), %eax
movzbl 0x2bf7c(%rip), %ecx     # 0x38275
cmpl %ecx, %eax
sete %al
movb %al, -0xb(%rbp)
movb -0xb(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: dguglielmi[P]dlan-linux-software/tools/../common/mscounter.h
// Function: MSCounter::operator()()
unsigned long operator()() 
  {
    struct timeval tv;
    gettimeofday(&tv, 0);
    unsigned long long val = 1000;
    val *= tv.tv_sec;
    val = (val + (tv.tv_usec / 1000));
    return (unsigned long)val;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x54d0
movq $0x3e8, -0x20(%rbp)     # imm = 0x3E8
movq -0x18(%rbp), %rax
imulq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movb $0x0, -0x11(%rbp)
addq $0xa0, %rdi
callq 0xd440
movq %rax, -0x20(%rbp)
movq -0x50(%rbp), %rdi
addq $0xa0, %rdi
callq 0xd4a0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xd470
testb $0x1, %al
jne 0xd246
jmp 0xd28b
leaq -0x20(%rbp), %rdi
callq 0xd500
movq %rax, %rdi
callq 0x6610
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6610
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0xd4d0
testb $0x1, %al
jne 0xd276
jmp 0xd278
jmp 0xd28b
jmp 0xd27a
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0xd530
movq %rax, -0x30(%rbp)
jmp 0xd21f
movq -0x50(%rbp), %rdi
addq $0xa0, %rdi
callq 0xd4a0
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xd560
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x59(%rbp)
jne 0xd2e5
leaq -0x20(%rbp), %rdi
callq 0xd500
movq %rax, %rdi
callq 0x6610
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6610
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0xd590
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0xd2ee
jmp 0xd324
movq -0x50(%rbp), %rax
addq $0xa0, %rax
movq %rax, -0x70(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xd630
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rsi
callq 0xd5c0
movq %rax, -0x48(%rbp)
movb $0x1, -0x11(%rbp)
jmp 0xd362
leaq -0x20(%rbp), %rdi
callq 0xd650
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xd670
testb $0x1, %al
jne 0xd33f
jmp 0xd360
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xd650
movq -0x78(%rbp), %rsi
movq %rax, %rdi
callq 0xd6a0
movb $0x1, -0x11(%rbp)
jmp 0xd362
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0xa0, %rdi
callq 0xd440
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rdi
addq $0xa0, %rdi
callq 0xd4a0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xd470
testb $0x1, %al
jne 0xd3bf
jmp 0xd424
leaq -0x20(%rbp), %rdi
callq 0xd500
movq %rax, %rdi
callq 0x6610
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0xb680
testb $0x1, %al
jne 0xd3e2
jmp 0xd414
movq -0x40(%rbp), %rax
addq $0xa0, %rax
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xd630
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xd720
movq %rax, -0x38(%rbp)
movb $0x1, -0x1(%rbp)
jmp 0xd428
jmp 0xd416
leaq -0x20(%rbp), %rdi
callq 0xd770
jmp 0xd398
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0xe290
movq -0x18(%rbp), %rdi
addq $0x90, %rdi
movq -0x10(%rbp), %rsi
addq $0x90, %rsi
callq 0xe320
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0xa0, %rsi
addq $0xa0, %rdi
callq 0xe350
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0xd0, %rsi
addq $0xd0, %rdi
callq 0xe380
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0xd840
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0xd7bf
jmp 0xd82f
movq -0x20(%rbp), %rdi
addq $0x90, %rdi
movq -0x10(%rbp), %rsi
addq $0x90, %rsi
callq 0xd920
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0xd7e8
jmp 0xd82f
movq -0x20(%rbp), %rdi
addq $0xa0, %rdi
movq -0x10(%rbp), %rsi
addq $0xa0, %rsi
callq 0xd970
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0xd811
jmp 0xd82f
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
movq -0x10(%rbp), %rsi
addq $0xd0, %rsi
callq 0xd9a0
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: dguglielmi[P]dlan-linux-software/common/dlandevice.h
// Function: CDlanDevice::operator==(CDlanDevice const&) const
bool operator==(const CDlanDevice& rhs) const 
  { 
    return
      (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);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0xb680
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0xd872
jmp 0xd90c
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl 0x8(%rdx), %ecx
movb %al, -0x11(%rbp)
jne 0xd90c
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0xd9d0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0xd8ae
jmp 0xd90c
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
callq 0xd9d0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0xd8d1
jmp 0xd90c
movq -0x20(%rbp), %rdi
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
callq 0xd9d0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0xd8f4
jmp 0xd90c
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
movq -0x10(%rbp), %rsi
addq $0x70, %rsi
callq 0xd9d0
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0xe3b0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x8(%rdi)
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
addq $0x10, %rdi
callq 0x5050
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
addq $0x30, %rdi
callq 0x5050
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
addq $0x50, %rdi
callq 0x5050
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x70, %rsi
addq $0x70, %rdi
callq 0x5050
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x11(%rbp), %rsi
xorl %edx, %edx
callq 0x10690
testb $0x1, -0x11(%rbp)
je 0x1068a
movq -0x20(%rbp), %rdi
callq 0x17980
addq $0x20, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, 0x18(%rax)
jne 0x110ca
movq -0x60(%rbp), %rax
movb $0x0, -0x9(%rbp)
movq 0x28(%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movq -0x60(%rbp), %rdi
movq %rax, %rdx
leaq -0x9(%rbp), %rsi
movq %rsi, -0x70(%rbp)
callq 0x11150
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x17910
movq -0x60(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rcx
movl $0x1, %edx
callq 0x10690
jmp 0x1108e
leaq -0x40(%rbp), %rdi
callq 0x8810
movq -0x60(%rbp), %rdi
callq 0x11640
testb $0x1, -0x9(%rbp)
je 0x110c8
movq -0x60(%rbp), %rdi
callq 0x17980
jmp 0x110c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8810
jmp 0x11139
jmp 0x110ca
movq -0x60(%rbp), %rdi
movb $0x0, -0x4d(%rbp)
leaq -0x4d(%rbp), %rsi
callq 0x117e0
testb $0x1, -0x4d(%rbp)
je 0x110ef
movq -0x60(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x78(%rbp)
jmp 0x110ff
movq -0x60(%rbp), %rcx
movq 0x38(%rcx), %rax
subq 0x18(%rcx), %rax
movq %rax, -0x78(%rbp)
movq -0x60(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movq -0x58(%rbp), %rcx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq 0x38(%rax), %rcx
movq 0x18(%rax), %rax
xorl %edx, %edx
divq %rcx
movq -0x60(%rbp), %rax
movq %rdx, 0x18(%rax)
movq -0x58(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5530
nopw %cs:(%rax,%rax)
// File: dguglielmi[P]dlan-linux-software/common/dlanmonitor.cpp
// Function: CDlanMonitor::TickAdapters()
void CDlanMonitor::TickAdapters()
{
  for(std::map<CMACAddress,NetwAdapter>::iterator itNIC = m_mapNICs.begin(); 
    (itNIC != m_mapNICs.end()); ++itNIC)
  {
    itNIC->second.iTick++;
    
    if(itNIC->second.iFastBroadcastCnt)
    {
      if(itNIC->second.iTick == 1)
      {
        SendLocalDeviceBroadcasts(itNIC);
        SendRemoteDeviceBroadcasts(itNIC);
        TriggerUnknownDevices(itNIC);

        itNIC->second.iTick = 0;
        itNIC->second.iFastBroadcastCnt--;
      }
    }
    else if(itNIC->second.iTick == 12)
    {
      TriggerUnknownDevices(itNIC);
      ClearUnknownDevices(itNIC);
    }
    else if(itNIC->second.iTick == 16)
    {
      SendLocalDeviceBroadcasts(itNIC);
    }
    else if(itNIC->second.iTick == 20)
    {
      SendRemoteDeviceBroadcasts(itNIC);
      itNIC->second.iTick = 0;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0xa8, %rdi
callq 0x17c80
movq %rax, -0x10(%rbp)
movq -0x58(%rbp), %rdi
addq $0xa8, %rdi
callq 0x17a70
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x17cb0
testb $0x1, %al
jne 0x1168e
jmp 0x117cf
leaq -0x10(%rbp), %rdi
callq 0x17d40
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
leaq -0x10(%rbp), %rdi
callq 0x17d40
cmpl $0x0, 0xc(%rax)
je 0x11724
leaq -0x10(%rbp), %rdi
callq 0x17d40
cmpl $0x1, 0x8(%rax)
jne 0x1171f
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x12730
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x12c60
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x12ed0
leaq -0x10(%rbp), %rdi
callq 0x17d40
movl $0x0, 0x8(%rax)
leaq -0x10(%rbp), %rdi
callq 0x17d40
movl 0xc(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xc(%rax)
jmp 0x117bf
leaq -0x10(%rbp), %rdi
callq 0x17d40
cmpl $0xc, 0x8(%rax)
jne 0x1175f
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
callq 0x12ed0
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
callq 0x13b40
jmp 0x117bd
leaq -0x10(%rbp), %rdi
callq 0x17d40
cmpl $0x10, 0x8(%rax)
jne 0x11785
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
callq 0x12730
jmp 0x117bb
leaq -0x10(%rbp), %rdi
callq 0x17d40
cmpl $0x14, 0x8(%rax)
jne 0x117b9
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rsi
callq 0x12c60
leaq -0x10(%rbp), %rdi
callq 0x17d40
movl $0x0, 0x8(%rax)
jmp 0x117bb
jmp 0x117bd
jmp 0x117bf
jmp 0x117c1
leaq -0x10(%rbp), %rdi
callq 0x17f60
jmp 0x11664
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dguglielmi[P]dlan-linux-software/common/dlanmonitor.cpp
// Function: CDlanMonitor::SendQueuedPackets(bool&)
void CDlanMonitor::SendQueuedPackets(
  bool& bStillPacketsPending)
{
  for(std::map<CMACAddress,NetwAdapter>::iterator itNIC = m_mapNICs.begin(); 
    (itNIC != m_mapNICs.end()); ++itNIC)
  {
    if(!itNIC->second.queuePendingPackets.empty())
    {
      IPacket* pPacket = itNIC->second.queuePendingPackets.front();
      itNIC->second.queuePendingPackets.pop();

      m_ifc.SendPacket(itNIC->first, *pPacket);
      delete pPacket;

      if(!itNIC->second.queuePendingPackets.empty())
        bStillPacketsPending = true;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0xa8, %rdi
callq 0x17c80
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rdi
addq $0xa8, %rdi
callq 0x17a70
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x17cb0
testb $0x1, %al
jne 0x11832
jmp 0x11910
leaq -0x18(%rbp), %rdi
callq 0x17d40
movq %rax, %rdi
addq $0x8, %rdi
addq $0x190, %rdi            # imm = 0x190
callq 0x17e80
testb $0x1, %al
jne 0x11900
leaq -0x18(%rbp), %rdi
callq 0x17d40
movq %rax, %rdi
addq $0x8, %rdi
addq $0x190, %rdi            # imm = 0x190
callq 0x17ea0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x17d40
movq %rax, %rdi
addq $0x8, %rdi
addq $0x190, %rdi            # imm = 0x190
callq 0x17ec0
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x17d40
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq -0x28(%rbp), %rdx
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x118d7
movq -0x38(%rbp), %rdi
movl $0x8, %esi
callq 0x5330
leaq -0x18(%rbp), %rdi
callq 0x17d40
movq %rax, %rdi
addq $0x8, %rdi
addq $0x190, %rdi            # imm = 0x190
callq 0x17e80
testb $0x1, %al
jne 0x118fe
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
jmp 0x11900
jmp 0x11902
leaq -0x18(%rbp), %rdi
callq 0x17f60
jmp 0x11808
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x17d40
movq %rax, %rdi
addq $0x8, %rdi
addq $0x10, %rdi
callq 0x18a30
leaq -0x8(%rbp), %rdi
callq 0x17d40
movq %rax, %rdi
addq $0x8, %rdi
addq $0x40, %rdi
callq 0x18a30
leaq -0x8(%rbp), %rdi
callq 0x17d40
movq %rax, %rdi
addq $0x8, %rdi
addq $0x70, %rdi
callq 0x18a30
leaq -0x8(%rbp), %rdi
callq 0x17d40
movq %rax, %rdi
addq $0x8, %rdi
addq $0xa0, %rdi
callq 0x18a30
leaq -0x8(%rbp), %rdi
callq 0x17d40
movq %rax, %rdi
addq $0x8, %rdi
addq $0xd0, %rdi
callq 0x18a50
leaq -0x8(%rbp), %rdi
callq 0x17d40
movq %rax, %rdi
addq $0x8, %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0x18a70
leaq -0x8(%rbp), %rdi
callq 0x17d40
movq %rax, %rdi
addq $0x8, %rdi
addq $0x130, %rdi            # imm = 0x130
callq 0x18a90
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0xe290
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x90, %rsi
addq $0x90, %rdi
callq 0xe3b0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x96, %rsi
addq $0x96, %rdi
callq 0xe3b0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0xa0, %rsi
addq $0xa0, %rdi
callq 0x1d8b0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0xd840
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x1d68f
jmp 0x1d6ff
movq -0x20(%rbp), %rdi
addq $0x90, %rdi
movq -0x10(%rbp), %rsi
addq $0x90, %rsi
callq 0xb680
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x1d6b8
jmp 0x1d6ff
movq -0x20(%rbp), %rdi
addq $0x96, %rdi
movq -0x10(%rbp), %rsi
addq $0x96, %rsi
callq 0xb680
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x1d6e1
jmp 0x1d6ff
movq -0x20(%rbp), %rdi
addq $0xa0, %rdi
movq -0x10(%rbp), %rsi
addq $0xa0, %rsi
callq 0x1d710
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: dguglielmi[P]dlan-linux-software/common/hpmmes.h
// Function: HomePlugMMEs::TurboChannelCapacities::RateFromBPBlk(unsigned int)
inline double RateFromBPBlk(uint32_t ulBytesPer336usBlock)
    {
      double dCalculatedPhyRate = ((double)ulBytesPer336usBlock) * 8.0 / (40.0 * 8.4);
      if(dCalculatedPhyRate <= dMaxTrueRate)
        return dCalculatedPhyRate;
      else if((dCalculatedPhyRate > dMaxTrueRate) && (dCalculatedPhyRate <= dMaxHp1Rate))
        return (((dCalculatedPhyRate - dMaxTrueRate) / (dMaxHp1Rate - dMaxTrueRate)) * (14 - 6)) + 6;
      else
        return (((dCalculatedPhyRate - dMaxHp1Rate) / (dMaxTurboRate - dMaxHp1Rate)) * (85 - 14)) + 14;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
cvtsi2sd %rax, %xmm0
movsd 0x192d9(%rip), %xmm1    # 0x383e0
mulsd %xmm1, %xmm0
movsd 0x192c5(%rip), %xmm1    # 0x383d8
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x192ac(%rip), %xmm0    # 0x383d0
ucomisd -0x18(%rbp), %xmm0
jb 0x1f13a
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x1f1d2
movsd -0x18(%rbp), %xmm0
movsd 0x19289(%rip), %xmm1    # 0x383d0
ucomisd %xmm1, %xmm0
jbe 0x1f198
movsd 0x19293(%rip), %xmm0    # 0x383e8
ucomisd -0x18(%rbp), %xmm0
jb 0x1f198
movsd -0x18(%rbp), %xmm0
movsd 0x19267(%rip), %xmm1    # 0x383d0
subsd %xmm1, %xmm0
movsd 0x19293(%rip), %xmm1    # 0x38408
divsd %xmm1, %xmm0
movsd 0x1925f(%rip), %xmm1    # 0x383e0
mulsd %xmm1, %xmm0
movsd 0x19243(%rip), %xmm1    # 0x383d0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x1f1d2
movsd -0x18(%rbp), %xmm0
movsd 0x19243(%rip), %xmm1    # 0x383e8
subsd %xmm1, %xmm0
movsd 0x1924f(%rip), %xmm1    # 0x38400
divsd %xmm1, %xmm0
movsd 0x19233(%rip), %xmm1    # 0x383f0
mulsd %xmm1, %xmm0
movsd 0x1922f(%rip), %xmm1    # 0x383f8
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: dguglielmi[P]dlan-linux-software/common/hpsecurity.cpp
// Function: HomePlugSecurity::CSetKeyTask::Drumbeat()
unsigned long HomePlugSecurity::CSetKeyTask::Drumbeat()
{
  unsigned long ulTimeout = 0;

  if(!CSetKeyTask::Complete()) 
    m_iRetries++;

  if(!CSetKeyTask::Complete())
  {
    m_ifc.SendPacket(m_addrNIC, m_req);            
    ulTimeout = m_ulRetryTimer;
  }

  return ulTimeout;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
callq 0x29ad0
testb $0x1, %al
jne 0x29775
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x70(%rax)
movq -0x18(%rbp), %rdi
callq 0x29ad0
testb $0x1, %al
jne 0x297a7
movq -0x18(%rbp), %rdx
movq 0x18(%rdx), %rdi
movq %rdx, %rsi
addq $0x20, %rsi
addq $0x30, %rdx
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dguglielmi[P]dlan-linux-software/common/hpsecurity.cpp
// Function: HomePlugAvSecurity::CSetKeyTask::Drumbeat()
unsigned long HomePlugAvSecurity::CSetKeyTask::Drumbeat()
{
  unsigned long ulTimeout = 0;

  if(!CSetKeyTask::Complete()) 
    m_iRetries++;

  if(!CSetKeyTask::Complete())
  {
    m_ifc.SendPacket(m_addrNIC, m_req);
    ulTimeout = m_ulRetryTimer;
  }

  return ulTimeout;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
callq 0x29b50
testb $0x1, %al
jne 0x298fb
movq -0x18(%rbp), %rax
movq 0x98(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x98(%rax)
movq -0x18(%rbp), %rdi
callq 0x29b50
testb $0x1, %al
jne 0x29930
movq -0x18(%rbp), %rdx
movq 0x18(%rdx), %rdi
movq %rdx, %rsi
addq $0x20, %rsi
addq $0x38, %rdx
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: dguglielmi[P]dlan-linux-software/common/hpsecurity.cpp
// Function: HomePlugAvSecurity::CSetKeyTask::OnThunderSetKeyConfirm(CMACAddress const&, HomePlugAvMMEs::ThunderSetKey::CConfirm const&)
void HomePlugAvSecurity::CSetKeyTask::OnThunderSetKeyConfirm(
  const CMACAddress& adapter, 
  const HomePlugAvMMEs::ThunderSetKey::CConfirm& mme)
{
  if((adapter == m_addrNIC) && (mme.GetAddress() == m_addrLocalDev))
  {
    if(mme.GetStatus() == HomePlugAvMMEs::ThunderSetKey::eSuccess)
    {
      m_bSuccessful = true;
      m_iRetries = 0;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rsi
callq 0xb680
movb %al, %cl
movb $0x0, -0x1f(%rbp)
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x2d(%rbp)
jne 0x2997b
jmp 0x299ae
movq -0x18(%rbp), %rsi
leaq -0x1e(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x29bb0
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdi
movb $0x1, -0x1f(%rbp)
addq $0x26, %rsi
callq 0xb680
movb %al, -0x39(%rbp)
jmp 0x299a6
movb -0x39(%rbp), %al
movb %al, -0x2d(%rbp)
jmp 0x299ae
movb -0x2d(%rbp), %al
movb %al, -0x49(%rbp)
testb $0x1, -0x1f(%rbp)
jne 0x299bc
jmp 0x299c5
leaq -0x1e(%rbp), %rdi
callq 0x6b70
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x299ce
jmp 0x29a18
movq -0x18(%rbp), %rdi
callq 0x29be0
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x29a16
movq -0x38(%rbp), %rax
movb $0x1, 0x90(%rax)
movq $0x0, 0x98(%rax)
jmp 0x29a16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
testb $0x1, -0x1f(%rbp)
jne 0x29a0b
jmp 0x29a14
leaq -0x1e(%rbp), %rdi
callq 0x6b70
jmp 0x29a1e
jmp 0x29a18
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5530
nopw (%rax,%rax)
// File: dguglielmi[P]dlan-linux-software/common/hptools.cpp
// Function: (anonymous namespace)::md5_init((anonymous namespace)::md5_state*)
void md5_init(md5_state * md)
{
    md->state[0] = 0x67452301UL;
    md->state[1] = 0xefcdab89UL;
    md->state[2] = 0x98badcfeUL;
    md->state[3] = 0x10325476UL;
    md->curlen = 0;
    md->length = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x67452301, 0x8(%rax)  # imm = 0x67452301
movq -0x8(%rbp), %rax
movl $0xefcdab89, 0xc(%rax)  # imm = 0xEFCDAB89
movq -0x8(%rbp), %rax
movl $0x98badcfe, 0x10(%rax) # imm = 0x98BADCFE
movq -0x8(%rbp), %rax
movl $0x10325476, 0x14(%rax) # imm = 0x10325476
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
popq %rbp
retq
nopl (%rax)