LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: madpilot[P]mDNSResolver/src/Answer.cpp
// Function: mDNSResolver::Answer::skipQuestions(unsigned char*, unsigned int, unsigned int*)
MDNS_RESULT Answer::skipQuestions(unsigned char* buffer, unsigned int len, unsigned int* offset) {
    unsigned int questionCount = (buffer[4] << 8) + buffer[5];

    *offset += 12;
    for(int i = 0; i < questionCount; i++) {

      while(buffer[*offset] != '\0') {
        // If it's a pointer, add two to the counter
        if((buffer[*offset] & 0xc0) == 0xc0) {
          (*offset) += 2;
          break;
        } else {
          unsigned int labelLength = (unsigned int)buffer[*offset];

          if(labelLength > 0x3f) {
            return E_MDNS_INVALID_LABEL_LENGTH;
          }

          (*offset) += 1; // Increment to move to the next byte
          (*offset) += labelLength;

          if(*offset > len) {
            return E_MDNS_PACKET_ERROR;
          }
        }
      }

      (*offset) += 5; // 2 bytes for the qtypes and 2 bytes qclass + plus one to land us on the next bit
    }

    if(*offset > len + 1) {
      return E_MDNS_PACKET_ERROR;
    }

    return E_MDNS_OK;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
shll $0x8, %eax
movq -0x10(%rbp), %rcx
movzbl 0x5(%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0xc, %ecx
movl %ecx, (%rax)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x7f08b
jmp 0x7efe7
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x7f072
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
andl $0xc0, %eax
cmpl $0xc0, %eax
jne 0x7f021
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x2, %ecx
movl %ecx, (%rax)
jmp 0x7f072
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x3f, -0x2c(%rbp)
jbe 0x7f041
movl $0x26, -0x4(%rbp)
jmp 0x7f0ab
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jbe 0x7f06b
movl $0x23, -0x4(%rbp)
jmp 0x7f0ab
jmp 0x7f06d
jmp 0x7efe7
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x5, %ecx
movl %ecx, (%rax)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x7efd9
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jbe 0x7f0a4
movl $0x23, -0x4(%rbp)
jmp 0x7f0ab
movl $0x20, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: madpilot[P]mDNSResolver/src/Answer.cpp
// Function: mDNSResolver::Answer::resolveCnames(mDNSResolver::Cache&)
MDNS_RESULT Answer::resolveCnames(Cache &cache) {
    for(int i = 0; i < cache.length(); i++) {
      if(cache[i].cname != NULL && cache[i].cname->resolved) {
        cache[i].ipAddress = cache[i].cname->ipAddress;
        cache[i].resolved = true;
        cache[i].cname = NULL;
      }
    }
    return E_MDNS_OK;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x69840
movl %eax, %ecx
movl -0x10(%rbp), %eax
cmpl %ecx, %eax
jge 0x7f60e
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x694b0
cmpq $0x0, 0x110(%rax)
je 0x7f5fe
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x694b0
movq 0x110(%rax), %rax
testb $0x1, 0x108(%rax)
je 0x7f5fe
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x694b0
movq 0x110(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x694b0
movq -0x18(%rbp), %rcx
movl 0x10c(%rcx), %ecx
movl %ecx, 0x10c(%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x694b0
movb $0x1, 0x108(%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x694b0
movq $0x0, 0x110(%rax)
jmp 0x7f600
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7f553
movl $0x20, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: madpilot[P]mDNSResolver/src/Answer.cpp
// Function: mDNSResolver::Answer::resolveAName(unsigned char*, unsigned int, unsigned int*, mDNSResolver::Response&, long, int)
MDNS_RESULT Answer::resolveAName(unsigned char *buffer, unsigned int len, unsigned int *offset, Response& response, long ttl, int dataLen) {
    if(dataLen == 4) {
      unsigned int a = (unsigned int)*(buffer + (*offset)++);
      unsigned int b = (unsigned int)*(buffer + (*offset)++);
      unsigned int c = (unsigned int)*(buffer + (*offset)++);
      unsigned int d = (unsigned int)*(buffer + (*offset)++);

      response.resolved = true;
      response.ttl = ttl;
      response.ipAddress = IPAddress(a, b, c, d);

    } else {
      (*offset) += dataLen;
    }

    return E_MDNS_OK;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
cmpl $0x4, -0x2c(%rbp)
jne 0x7f704
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rdx
movl (%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, (%rdx)
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rdx
movl (%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, (%rdx)
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rdx
movl (%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, (%rdx)
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rdx
movl (%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, (%rdx)
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movb $0x1, 0x108(%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x100(%rax)
movl -0x30(%rbp), %eax
movb %al, %sil
movl -0x34(%rbp), %eax
movb %al, %dl
movl -0x38(%rbp), %eax
movb %al, %cl
movl -0x3c(%rbp), %eax
leaq -0x40(%rbp), %rdi
movzbl %sil, %esi
movzbl %dl, %edx
movzbl %cl, %ecx
movzbl %al, %r8d
callq 0x83010
movq -0x20(%rbp), %rax
movl -0x40(%rbp), %ecx
movl %ecx, 0x10c(%rax)
jmp 0x7f70f
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl $0x20, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: madpilot[P]mDNSResolver/src/Answer.cpp
// Function: mDNSResolver::Answer::parseName(char**, char const*, unsigned int)
MDNS_RESULT Answer::parseName(char** name, const char* mapped, unsigned int len) {
    unsigned int namePointer = 0;
    unsigned int mapPointer = 0;

    while(mapPointer < len) {
      int labelLength = mapped[mapPointer++];

      if(labelLength > 0x3f) {
        return E_MDNS_INVALID_LABEL_LENGTH;
      }

      if(namePointer + labelLength > len - 1) {
        return E_MDNS_PACKET_ERROR;
      }

      if(namePointer != 0) {
        (*name)[namePointer++] = '.';
      }

      for(int i = 0; i < labelLength; i++) {
        (*name)[namePointer++] = mapped[mapPointer++];
      }
    }

    (*name)[len - 1] = '\0';

    return E_MDNS_OK;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x7f837
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movl %ecx, %ecx
movsbl (%rax,%rcx), %eax
movl %eax, -0x28(%rbp)
cmpl $0x3f, -0x28(%rbp)
jle 0x7f7b3
movl $0x26, -0x4(%rbp)
jmp 0x7f851
movl -0x20(%rbp), %eax
addl -0x28(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jbe 0x7f7cf
movl $0x23, -0x4(%rbp)
jmp 0x7f851
cmpl $0x0, -0x20(%rbp)
je 0x7f7ed
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x20(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x20(%rbp)
movl %ecx, %ecx
movb $0x2e, (%rax,%rcx)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x7f832
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movl %ecx, %ecx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x20(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x20(%rbp)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x7f7f4
jmp 0x7f77d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
movl $0x20, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: madpilot[P]mDNSResolver/src/mDNSResolver.cpp
// Function: mDNSResolver::Resolver::search(char const*)
IPAddress Resolver::search(const char* name) {
    if(!isMDNSName(name)) {
      return INADDR_NONE;
    }

    cache.expire();

    int attempts = 0;

    while(attempts < MDNS_ATTEMPTS) {
      int index = cache.search(name);

      if(index == -1) {
        cache.insert(Response(name, 5));
        continue;
      } else if(cache[index].resolved) {
        return cache[index].ipAddress;
      }

      long now = millis();

      // Send a query packet every second
      if(now - timeout > MDNS_RETRY) {
        query(name);
        timeout = now;
        attempts++;
      }

      MDNS_RESULT result = read();
      if(result != E_MDNS_OK) {
        return INADDR_NONE;
      }
    }

    return INADDR_NONE;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x160(%rbp)
movq -0x18(%rbp), %rsi
callq 0x82870
testb $0x1, %al
jne 0x826f9
movl 0x360c7(%rip), %eax     # 0xb87b8
movl %eax, -0x4(%rbp)
jmp 0x8284d
leaq 0x360c0(%rip), %rdi     # 0xb87c0
callq 0x69790
movl $0x0, -0x1c(%rbp)
cmpl $0x5, -0x1c(%rbp)
jge 0x82844
movq -0x18(%rbp), %rsi
leaq 0x3609f(%rip), %rdi     # 0xb87c0
callq 0x69710
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
jne 0x82791
movq -0x18(%rbp), %rsi
leaq -0x138(%rbp), %rdi
movq %rdi, -0x168(%rbp)
movl $0x5, %edx
callq 0x6bd70
movq -0x168(%rbp), %rsi
leaq 0x36067(%rip), %rdi     # 0xb87c0
callq 0x694d0
jmp 0x82760
leaq -0x138(%rbp), %rdi
callq 0x6bdf0
jmp 0x8270c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
leaq -0x138(%rbp), %rdi
callq 0x6bdf0
jmp 0x82859
movl -0x20(%rbp), %esi
leaq 0x36025(%rip), %rdi     # 0xb87c0
callq 0x694b0
testb $0x1, 0x108(%rax)
je 0x827c6
movl -0x20(%rbp), %esi
leaq 0x3600d(%rip), %rdi     # 0xb87c0
callq 0x694b0
movl 0x10c(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x8284d
jmp 0x827c8
callq 0x83100
movq -0x160(%rbp), %rcx
movq %rax, -0x150(%rbp)
movq -0x150(%rbp), %rax
subq 0x28(%rcx), %rax
cmpq $0x3e8, %rax            # imm = 0x3E8
jle 0x82819
movq -0x160(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x828e0
movq -0x160(%rbp), %rax
movq -0x150(%rbp), %rcx
movq %rcx, 0x28(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x160(%rbp), %rdi
callq 0x829a0
movl %eax, -0x154(%rbp)
cmpl $0x20, -0x154(%rbp)
je 0x8283f
movl 0x35f7e(%rip), %eax     # 0xb87b8
movl %eax, -0x4(%rbp)
jmp 0x8284d
jmp 0x8270c
movl 0x35f6e(%rip), %eax     # 0xb87b8
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
movq -0x140(%rbp), %rdi
callq 0xc8b0
nopw %cs:(%rax,%rax)
// File: madpilot[P]mDNSResolver/src/mDNSResolver.cpp
// Function: mDNSResolver::Resolver::isMDNSName(char const*)
bool Resolver::isMDNSName(const char* name) {
    int len = strlen(name);
    int tldLen = strlen(MDNS_TLD);

    if(len < tldLen) {
      return false;
    }

    return strcmp(name + len - tldLen, MDNS_TLD) == 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xc220
movl %eax, -0x1c(%rbp)
movl $0x6, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x828a1
movb $0x0, -0x1(%rbp)
jmp 0x828cf
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rax
addq %rax, %rdi
movslq -0x20(%rbp), %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
leaq 0x41fe(%rip), %rsi      # 0x86abd
callq 0xc6d0
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: madpilot[P]mDNSResolver/src/mDNSResolver.cpp
// Function: mDNSResolver::Resolver::query(char const*)
void Resolver::query(const char* name) {
    Query query(name);
    
#if defined(ESP32)
	udp.beginMulticast(MDNS_BROADCAST_IP, MDNS_PORT);
	udp.beginMulticastPacket();
#else
	udp.beginPacketMulticast(MDNS_BROADCAST_IP, MDNS_PORT, localIP, UDP_TIMEOUT);
#endif
    query.sendPacket(udp);
    udp.endPacket();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x5eb90
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
leaq -0x1c(%rbp), %rdi
movl $0xe0, %esi
xorl %ecx, %ecx
movl $0xfb, %r8d
movl %ecx, %edx
callq 0x83010
jmp 0x8292b
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x1c(%rbp), %esi
movl -0x30(%rbp), %ecx
movl $0x14e9, %edx           # imm = 0x14E9
movl $0xff, %r8d
callq 0x82e70
jmp 0x82951
movq -0x40(%rbp), %rsi
addq $0x8, %rsi
leaq -0x18(%rbp), %rdi
callq 0x5ebc0
jmp 0x82964
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
callq 0x82e90
jmp 0x82973
leaq -0x18(%rbp), %rdi
callq 0x5ebb0
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x5ebb0
movq -0x28(%rbp), %rdi
callq 0xc8b0
// File: madpilot[P]mDNSResolver/src/mDNSResolver.cpp
// Function: mDNSResolver::Resolver::read()
MDNS_RESULT Resolver::read() {
    cache.expire();

    if(!init) {
      init = true;
#if defined(ESP32)
	udp.beginMulticast(MDNS_BROADCAST_IP, MDNS_PORT);
#else
	udp.beginMulticast(localIP, MDNS_BROADCAST_IP, MDNS_PORT);
#endif
    }

    unsigned int len = udp.parsePacket();

    if(len > 0) {
      unsigned char *buffer = (unsigned char *)malloc(sizeof(unsigned char) * len);

      if(buffer == NULL) {
        // Out of memory - the packet is probably too big to parse. Probably.
        // Silently bombing out, possibly isn't great, but it'll do for the moment.
        return E_MDNS_OUT_OF_MEMORY;
      }

      udp.read(buffer, len);
      lastResult = Answer::process(buffer, len, cache);

      free(buffer);
      return lastResult;
    }

    return E_MDNS_OK;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x35e05(%rip), %rdi     # 0xb87c0
callq 0x69790
movq -0x30(%rbp), %rax
testb $0x1, 0x24(%rax)
jne 0x82a0f
movq -0x30(%rbp), %rax
movb $0x1, 0x24(%rax)
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x38(%rbp)
movl 0x20(%rax), %eax
movl %eax, -0x14(%rbp)
leaq -0x18(%rbp), %rdi
movl $0xe0, %esi
xorl %ecx, %ecx
movl $0xfb, %r8d
movl %ecx, %edx
callq 0x83010
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl $0x14e9, %ecx           # imm = 0x14E9
callq 0x82e10
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x82fd0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jbe 0x82a8c
movl -0x1c(%rbp), %eax
movl %eax, %edi
shlq $0x0, %rdi
callq 0xc670
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x82a47
movl $0x27, -0x4(%rbp)
jmp 0x82a93
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x82ef0
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
leaq 0x35d55(%rip), %rdx     # 0xb87c0
callq 0x7ee80
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rdi
callq 0xc5c0
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x82a93
movl $0x20, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: madpilot[P]mDNSResolver/src/mDNSResolver.cpp
// Function: mDNSResolver::Resolver::loop()
void Resolver::loop() {
    // Clear the buffers out.
    // This wouldn't be needed if the UDP library had the ability to
    // leave a multicast group
    unsigned int len = udp.parsePacket();
    unsigned char *buffer = (unsigned char *)malloc(sizeof(unsigned char) * len);
    if(buffer != NULL) {
      udp.read(buffer, len);
      free(buffer);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x8, %rdi
callq 0x82fd0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %edi
shlq $0x0, %rdi
callq 0xc670
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x82af8
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %eax
movl %eax, %edx
callq 0x82ef0
movq -0x18(%rbp), %rdi
callq 0xc5c0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: madpilot[P]mDNSResolver/mocks/WiFiUdp.cpp
// Function: WiFiUDP::WiFiUDP()
WiFiUDP::WiFiUDP() {
  this->readBuffer = NULL;
  this->writeBuffer = NULL;
  this->readBufferLength = 0;
  this->writeBufferLength = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
movl $0x0, 0x14(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: madpilot[P]mDNSResolver/mocks/WiFiUdp.cpp
// Function: WiFiUDP::WiFiUDP(unsigned char*, int)
WiFiUDP::WiFiUDP(unsigned char *buffer, int length) {
  this->readBuffer = NULL;
  this->writeBuffer = NULL;
  this->readBufferLength = 0;
  this->writeBufferLength = 0;
  this->setReadBuffer(buffer, length);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movl $0x0, 0x14(%rdi)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x82b80
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: madpilot[P]mDNSResolver/mocks/WiFiUdp.cpp
// Function: WiFiUDP::setReadBuffer(unsigned char*, int)
void WiFiUDP::setReadBuffer(unsigned char *buffer, int length) {
  //if(this->readBuffer != NULL) {
    //free(this->readBuffer);
    //this->readBuffer = NULL;
  //}

  this->readBuffer = (unsigned char *)malloc(sizeof(unsigned char) * length);
  memcpy(this->readBuffer, buffer, length);
  this->readBufferLength = length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movslq -0x14(%rbp), %rdi
shlq $0x0, %rdi
callq 0xc670
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0xc410
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: madpilot[P]mDNSResolver/mocks/WiFiUdp.cpp
// Function: WiFiUDP::write(unsigned char const*, unsigned long)
size_t WiFiUDP::write(const uint8_t *buffer, size_t size) {
  //if(this->writeBuffer != NULL) {
    //free(this->writeBuffer);
    //this->writeBuffer = NULL;
  //}

  this->writeBuffer = (unsigned char *)malloc(sizeof(unsigned char) * size);
  memcpy(this->writeBuffer, buffer, size);
  this->writeBufferLength = size;

  return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
shlq $0x0, %rdi
callq 0xc670
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xc410
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: madpilot[P]mDNSResolver/mocks/IPAddress.cpp
// Function: IPAddress::IPAddress(unsigned char, unsigned char, unsigned char, unsigned char)
IPAddress::IPAddress(uint8_t first_octet, uint8_t second_octet, uint8_t third_octet, uint8_t fourth_octet)
{
    _address.bytes[0] = first_octet;
    _address.bytes[1] = second_octet;
    _address.bytes[2] = third_octet;
    _address.bytes[3] = fourth_octet;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movb %sil, -0x9(%rbp)
movb %dl, -0xa(%rbp)
movb %cl, -0xb(%rbp)
movb %al, -0xc(%rbp)
movq -0x8(%rbp), %rax
movb -0x9(%rbp), %cl
movb %cl, (%rax)
movb -0xa(%rbp), %cl
movb %cl, 0x1(%rax)
movb -0xb(%rbp), %cl
movb %cl, 0x2(%rax)
movb -0xc(%rbp), %cl
movb %cl, 0x3(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dvjdjvu[P]bntree/./src/bntree.cpp
// Function: bntree::clear(node_s*)
void bntree::clear(node_t *p) {
    if (p != NULL) {
        if (p->right) {
            this->clear(p->right);
            this->node_free(p->right);
        }

        if (p->left) {
            this->clear(p->left);
            this->node_free(p->left);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x254b
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x251c
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rsi
callq 0x24d0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rsi
callq 0x25a0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x2549
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x24d0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x25a0
jmp 0x254b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dvjdjvu[P]bntree/./src/bntree.cpp
// Function: bntree::search(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
uint64_t bntree::search(string key) {
    if (!this->tree->root) {
        return -1;
    }

    node_t *search_node = this->tree->root;
    uint64_t index_node = this->get_child_weight(search_node->left);

    for (;;) {
        if (key == search_node->data.key) {
            return index_node; // найден узел с таким ключем, вернем его индекс
        } else if (key > search_node->data.key) {
            search_node = search_node->right;

            if (search_node == NULL)
                return -1;

            index_node += (this->get_child_weight(search_node->left) + 1);
        } else {
            search_node = search_node->left;

            if (search_node == NULL)
                return -1;

            index_node -= (this->get_child_weight(search_node->left) + 1);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rax
cmpq $0x0, (%rax)
jne 0x2612
movq $-0x1, -0x8(%rbp)
jmp 0x26e7
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x2700
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3840
testb $0x1, %al
jne 0x2644
jmp 0x2651
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x26e7
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x38d0
testb $0x1, %al
jne 0x2664
jmp 0x26a0
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2681
movq $-0x1, -0x8(%rbp)
jmp 0x26e7
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x2700
addq $0x1, %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x26e0
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x26bd
movq $-0x1, -0x8(%rbp)
jmp 0x26e7
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x2700
movq %rax, %rcx
addq $0x1, %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x26e2
jmp 0x2631
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dvjdjvu[P]bntree/./src/bntree.cpp
// Function: bntree::get(unsigned long)
data_t *bntree::get(uint64_t index) {
    if (index < 0 || index > this->size() - 1) {
        return NULL;
    }

    node_t *search_node = this->tree->root;
    uint64_t index_node = this->get_child_weight(search_node->left);

    for (;;) {
        if (index == index_node) {
            return &search_node->data;
        } else if (index > index_node) {
            search_node = search_node->right;
            index_node += (this->get_child_weight(search_node->left) + 1);
        } else {
            search_node = search_node->left;
            index_node -= (this->get_child_weight(search_node->right) + 1);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jb 0x3360
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x30c0
movq %rax, %rcx
movq -0x38(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jbe 0x336d
movq $0x0, -0x8(%rbp)
jmp 0x3408
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x2700
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x33a0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3408
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0x33d5
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x2700
addq $0x1, %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x3404
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rsi
callq 0x2700
movq %rax, %rcx
addq $0x1, %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x3406
jmp 0x338c
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dvjdjvu[P]bntree/./src/bntree.cpp
// Function: bntree::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
data_t *bntree::get(string key) {
    node_t *search_node = this->tree->root;
    uint64_t index_node = this->get_child_weight(search_node->left);

    for (;;) {
        if (key == search_node->data.key) {
            return &search_node->data;
        } else if (key > search_node->data.key) {
            search_node = search_node->right;
            index_node += (this->get_child_weight(search_node->left) + 1);
        } else {
            search_node = search_node->left;
            index_node -= (this->get_child_weight(search_node->right) + 1);
        }
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq (%rdi), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x2700
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3840
testb $0x1, %al
jne 0x346a
jmp 0x3474
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x38d0
testb $0x1, %al
jne 0x3487
jmp 0x34b2
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x2700
addq $0x1, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x34e1
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rsi
callq 0x2700
movq %rax, %rcx
addq $0x1, %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x34e3
jmp 0x3457
nopl (%rax,%rax)
// File: dvjdjvu[P]bntree/./src/bntree.cpp
// Function: bntree::print(node_s*, int)
void bntree::print(node_t *p, int indent) {
    if (p != NULL) {
        if (p->right) {
            this->print(p->right, indent + 4);
        }
        if (indent) {
            //std::cout << std::setw(indent) << ' ' << p->weight << ' ';
            std::cout << std::setw(indent) << ' ';
        }
        if (p->right) {
            std::cout << " /\n" << std::setw(indent) << ' ';
        }
        //std::cout << p->data.key << ":" << p->data.val << "\n ";
        std::cout << p->data.key << ":" << p << ":" << p->parent << "\n ";
        if (p->left) {
            std::cout << std::setw(indent) << ' ' << " \\\n";
            this->print(p->left, indent + 4);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x368e
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x3568
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rsi
movl -0x14(%rbp), %edx
addl $0x4, %edx
callq 0x3520
cmpl $0x0, -0x14(%rbp)
je 0x3595
movl -0x14(%rbp), %edi
callq 0x3990
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
movq 0x6a55(%rip), %rdi      # 0x9fd8
callq 0x21b0
movq %rax, %rdi
movl $0x20, %esi
callq 0x21c0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x35db
movq 0x6a31(%rip), %rdi      # 0x9fd8
leaq 0x3a56(%rip), %rsi      # 0x7004
callq 0x2170
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %edi
callq 0x3990
movq -0x30(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
callq 0x21b0
movq %rax, %rdi
movl $0x20, %esi
callq 0x21c0
movq -0x10(%rbp), %rsi
movq 0x69f2(%rip), %rdi      # 0x9fd8
callq 0x2150
movq %rax, %rdi
leaq 0x3a13(%rip), %rsi      # 0x7008
callq 0x2170
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x2130
movq %rax, %rdi
leaq 0x39f8(%rip), %rsi      # 0x7008
callq 0x2170
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rsi
callq 0x2130
movq %rax, %rdi
leaq 0x39db(%rip), %rsi      # 0x700a
callq 0x2170
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x368c
movl -0x14(%rbp), %edi
callq 0x3990
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %esi
movq 0x6984(%rip), %rdi      # 0x9fd8
callq 0x21b0
movq %rax, %rdi
movl $0x20, %esi
callq 0x21c0
movq %rax, %rdi
leaq 0x399d(%rip), %rsi      # 0x700d
callq 0x2170
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
movl -0x14(%rbp), %edx
addl $0x4, %edx
callq 0x3520
jmp 0x368e
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dvjdjvu[P]bntree/./src/bntree.cpp
// Function: bntree::weight_to_depth(node_s*)
uint64_t bntree::weight_to_depth(node_t *p) {
    if (p == NULL) {
        return 0;
    }

    if (p->weight == 1) {
        return 1;
    } else if (p->weight == 2) {
        return 2;
    }

    return this->ilog2(this->cpl2(p->weight));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x36c9
movq $0x0, -0x8(%rbp)
jmp 0x3716
movq -0x18(%rbp), %rax
cmpq $0x1, 0x40(%rax)
jne 0x36de
movq $0x1, -0x8(%rbp)
jmp 0x3716
movq -0x18(%rbp), %rax
cmpq $0x2, 0x40(%rax)
jne 0x36f3
movq $0x2, -0x8(%rbp)
jmp 0x3716
jmp 0x36f5
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x3720
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x37c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: dvjdjvu[P]bntree/./src/bntree.cpp
// Function: bntree::cpl2(unsigned long)
uint64_t bntree::cpl2(uint64_t x) {
    x = x - 1;
    x = x | (x >> 1);
    x = x | (x >> 2);
    x = x | (x >> 4);
    x = x | (x >> 8);
    x = x | (x >> 16);
    x = x | (x >> 32);

    return x + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq %rcx
orq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq $0x2, %rcx
orq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq $0x4, %rcx
orq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq $0x8, %rcx
orq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq $0x10, %rcx
orq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq $0x20, %rcx
orq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dvjdjvu[P]bntree/./src/test.cpp
// Function: std::vector<std::pair<unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> get_sequence<std::vector<std::pair<unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
S get_sequence(const string& _file_name)
{
    ifstream infile(_file_name);
    S result;

    typename S::value_type item;

    while (infile >> item)
    {
        result.emplace_back(move(item));
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x260(%rbp)
movq %rdi, %rax
movq %rax, -0x268(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x2240
movq -0x260(%rbp), %rdi
movb $0x0, -0x219(%rbp)
callq 0x5810
leaq -0x248(%rbp), %rdi
callq 0x5830
jmp 0x46ea
jmp 0x46ec
leaq -0x218(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x3aa0
movq %rax, -0x270(%rbp)
jmp 0x4708
movq -0x270(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x21d0
movb %al, -0x271(%rbp)
jmp 0x4726
movb -0x271(%rbp), %al
testb $0x1, %al
jne 0x4732
jmp 0x477d
movq -0x260(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x5860
jmp 0x4747
jmp 0x46ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
jmp 0x47c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x58d0
jmp 0x47c1
movb $0x1, -0x219(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x58d0
testb $0x1, -0x219(%rbp)
jne 0x47a5
movq -0x260(%rbp), %rdi
callq 0x4b50
leaq -0x218(%rbp), %rdi
callq 0x2070
movq -0x268(%rbp), %rax
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq -0x260(%rbp), %rdi
callq 0x4b50
leaq -0x218(%rbp), %rdi
callq 0x2070
movq -0x250(%rbp), %rdi
callq 0x2260
nopw %cs:(%rax,%rax)
nop
// File: yiboyang[P]VirtualMemory/TLB.cpp
// Function: TLB::operator[](int)
int& TLB::operator[] (const int pnum) {
	// before returning a reference to tb[pnum], update the queue according to LRU policy
	if (tb.count(pnum))
		// if pnum is in tb
		q.remove(pnum);
	else {
		// TLB miss; tb[pnum] will create a new entry in tb and reference 0 (default int)
		if (q.size() == TLB_SIZE) {
			// if queue (TLB) full
			int victim = q.front();	// victim page number
			tb.erase(tb.find(victim));	// remove victim entry
			q.pop_front();
		}
	}
	q.push_back(pnum);	// add pnum at the end of queue

	return tb[pnum];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
leaq -0xc(%rbp), %rsi
callq 0x36c0
cmpq $0x0, %rax
je 0x3639
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
leaq -0xc(%rbp), %rsi
callq 0x3720
jmp 0x368f
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
callq 0x3800
cmpq $0x10, %rax
jne 0x368d
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
callq 0x3830
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x38a0
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x3860
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x30, %rdi
callq 0x38d0
jmp 0x368f
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
leaq -0xc(%rbp), %rsi
callq 0x3900
movq -0x28(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x3940
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yiboyang[P]VirtualMemory/PageTable.cpp
// Function: PageTable::~PageTable()
PageTable::~PageTable() {
	// commit all dirty pages to backing store
	for (auto const& kv : pt) {
		if (kv.second.second)
			bs.write(kv.first, kv.second.first);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6700
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6730
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6760
testb $0x1, %al
jne 0x5e78
jmp 0x5f28
leaq -0x18(%rbp), %rdi
callq 0x6790
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x5f18
movq -0x40(%rbp), %rdi
addq $0x98, %rdi
movq -0x28(%rbp), %rax
movl (%rax), %esi
movl 0x4(%rax), %edx
callq 0x9520
jmp 0x5eae
jmp 0x5f18
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
addq $0x3a8, %rdi            # imm = 0x3A8
callq 0x6640
movq -0x40(%rbp), %rdi
addq $0x98, %rdi
callq 0x6670
movq -0x40(%rbp), %rdi
addq $0x80, %rdi
callq 0x3f50
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
callq 0x31c0
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
callq 0x66c0
movq -0x40(%rbp), %rdi
callq 0x66e0
movq -0x30(%rbp), %rdi
callq 0x32f0
jmp 0x5f1a
leaq -0x18(%rbp), %rdi
callq 0x67b0
jmp 0x5e62
movq -0x40(%rbp), %rdi
addq $0x3a8, %rdi            # imm = 0x3A8
callq 0x6640
movq -0x40(%rbp), %rdi
addq $0x98, %rdi
callq 0x6670
movq -0x40(%rbp), %rdi
addq $0x80, %rdi
callq 0x3f50
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
callq 0x31c0
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
callq 0x66c0
movq -0x40(%rbp), %rdi
callq 0x66e0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yiboyang[P]VirtualMemory/PageTable.cpp
// Function: PageTable::getFreeFrameNum()
int PageTable::getFreeFrameNum() {
	/*
	Find a free frame and return its frame number
	*/
	int fnum;
	if (!fs.empty()) {
		fnum = *fs.begin();		// always get the free frame with the smallest frame number
		fs.erase(fnum);			// remove fnum from the set of free frames
	}
	else {	// need to replace a page, q is full (since we don't delete a page by itself, fs.size() == 64 - q.size())
		// either FIFO or LRU replaces the page at the front of the queue
		int pnum = q.front();	// victim page number
		fnum = pt[pnum].first;

		// if a dirty page, write its memory frame to backing store
		if (pt[pnum].second) {
			bs.write(pnum, fnum);
			setDirty(pnum, false);	// reset dirty bit
		}

		pt[pnum].first = -1;	// reset victim page's frame number
		q.pop_front();
	}
	return fnum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x30, %rdi
callq 0x6870
testb $0x1, %al
jne 0x6186
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
callq 0x6890
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x68c0
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0xc(%rbp)
addq $0x30, %rdi
leaq -0xc(%rbp), %rsi
callq 0x68e0
jmp 0x6207
movq -0x28(%rbp), %rdi
addq $0x80, %rdi
callq 0x3830
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x64b0
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0xc(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x64b0
testb $0x1, 0x4(%rax)
je 0x61e4
movq -0x28(%rbp), %rdi
addq $0x98, %rdi
movl -0x1c(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x9520
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
xorl %edx, %edx
callq 0x6910
movq -0x28(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x64b0
movq -0x28(%rbp), %rdi
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
addq $0x80, %rdi
callq 0x38d0
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: yiboyang[P]VirtualMemory/PageTable.cpp
// Function: operator<<(std::ostream&, PageTable const&)
ostream& operator<<(ostream &strm, const PageTable &PT) {
	for (auto const& kv : PT.pt) {
		if (kv.second.first != -1)
			strm << kv.first << ' ' << kv.second.first << endl;
	}
	return strm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6950
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6980
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x69b0
testb $0x1, %al
jne 0x6255
jmp 0x62b3
leaq -0x20(%rbp), %rdi
callq 0x69e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $-0x1, 0x4(%rax)
je 0x62a6
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movl (%rax), %esi
callq 0x33e0
movq %rax, %rdi
movl $0x20, %esi
callq 0x32a0
movq %rax, %rdi
movq -0x30(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x33e0
movq %rax, %rdi
movq 0xacf7(%rip), %rsi      # 0x10f98
callq 0x3270
jmp 0x62a8
leaq -0x20(%rbp), %rdi
callq 0x6a00
jmp 0x6242
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: yiboyang[P]VirtualMemory/./BackingStore.h
// Function: BackingStore::BackingStore(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
BackingStore(std::string name) {
		// open the file that simulates disk in rw mode
		store.open(name, std::ios::binary | std::ios::in | std::ios::out);	// c++11 allows istream.open string rather than char*
		if (!store)
			throw std::invalid_argument("Can't open backing store file!");
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x32b0
movl $0x4, %edi
movl $0x8, %esi
callq 0x6c30
movl %eax, -0x20(%rbp)
jmp 0x6363
movl -0x20(%rbp), %edi
movl $0x10, %esi
callq 0x6c30
movl %eax, -0x44(%rbp)
jmp 0x6375
movl -0x44(%rbp), %edx
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x3330
jmp 0x6387
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3130
movb %al, -0x45(%rbp)
jmp 0x639f
movb -0x45(%rbp), %al
testb $0x1, %al
jne 0x63a8
jmp 0x6408
movl $0x10, %edi
callq 0x3150
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0x4c73(%rip), %rsi      # 0xb036
callq 0x3430
jmp 0x63ca
movq -0x50(%rbp), %rdi
movq 0xabfb(%rip), %rsi      # 0x10fd0
movq 0xabe4(%rip), %rdx      # 0x10fc0
callq 0x33d0
jmp 0x6420
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x640e
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31f0
jmp 0x640e
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x30a0
movq -0x18(%rbp), %rdi
callq 0x33f0
// File: yiboyang[P]VirtualMemory/BackingStore.cpp
// Function: BackingStore::read(int)
void BackingStore::read(int pnum) {
	assert(!store.eof());

	// seek to the page at pnum
	if (store.seekg(pnum * FRAME_SIZE, ios::beg))
		store.read((char *)buff, FRAME_SIZE);
	else
		throw runtime_error("Seek error");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x3420
xorb $-0x1, %al
testb $0x1, %al
jne 0x945b
jmp 0x945d
jmp 0x947c
leaq 0x1bf2(%rip), %rdi      # 0xb056
leaq 0x1bf8(%rip), %rsi      # 0xb063
movl $0xd, %edx
leaq 0x1bfd(%rip), %rcx      # 0xb074
callq 0x31d0
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %eax
shll $0x8, %eax
movslq %eax, %rsi
xorl %edx, %edx
callq 0x3310
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x32c0
testb $0x1, %al
jne 0x94a5
jmp 0x94bf
movq -0x28(%rbp), %rdi
movq %rdi, %rsi
addq $0x210, %rsi            # imm = 0x210
movl $0x100, %edx            # imm = 0x100
callq 0x32d0
jmp 0x950f
movl $0x10, %edi
callq 0x3150
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x1bb7(%rip), %rsi      # 0xb091
callq 0x30f0
jmp 0x94e1
movq -0x30(%rbp), %rdi
movq 0x7b04(%rip), %rsi      # 0x10ff0
movq 0x7ab5(%rip), %rdx      # 0x10fa8
callq 0x33d0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31f0
jmp 0x9515
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x33f0
nop
// File: yiboyang[P]VirtualMemory/BackingStore.cpp
// Function: BackingStore::write(int, int)
void BackingStore::write(int pnum, int fnum) {
	assert(!store.eof());

	// seek to the page at pnum
	if (store.seekg(pnum * FRAME_SIZE, ios::beg))
		store.write((char *)Memory[fnum], FRAME_SIZE);
	else
		throw runtime_error("Seek error");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x3420
xorb $-0x1, %al
testb $0x1, %al
jne 0x954e
jmp 0x9550
jmp 0x956f
leaq 0x1aff(%rip), %rdi      # 0xb056
leaq 0x1b05(%rip), %rsi      # 0xb063
movl $0x1a, %edx
leaq 0x1b32(%rip), %rcx      # 0xb09c
callq 0x31d0
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %eax
shll $0x8, %eax
movslq %eax, %rsi
xorl %edx, %edx
callq 0x3310
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x32c0
testb $0x1, %al
jne 0x9598
jmp 0x95be
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movslq -0x10(%rbp), %rax
leaq 0x7cb5(%rip), %rsi      # 0x11260
shlq $0x8, %rax
addq %rax, %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x3300
jmp 0x960e
movl $0x10, %edi
callq 0x3150
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x1ab8(%rip), %rsi      # 0xb091
callq 0x30f0
jmp 0x95e0
movq -0x30(%rbp), %rdi
movq 0x7a05(%rip), %rsi      # 0x10ff0
movq 0x79b6(%rip), %rdx      # 0x10fa8
callq 0x33d0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31f0
jmp 0x9614
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x33f0
nopl (%rax)
// File: ALSchwalm[P]cppEvolve/examples/primes.cpp
// Function: treeFitness(evolve::tree::Tree<int> const*)
double treeFitness(const tree::Tree<int>* tree)
{
    double total = 0;
    std::vector<int> used;
    for(nodes::x=0; nodes::x < static_cast<int>(primes.size()); ++nodes::x) {
        auto val = tree->eval();
        if (std::find(primes.begin(), primes.end(), val) != primes.end() &&
            std::find(used.begin(), used.end(), val) == used.end()) {

            used.push_back(val);
            total += 1;
        }
    }
    return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2d10
movl $0x0, 0x18c72(%rip)     # 0x1b15c
movl 0x18c6c(%rip), %eax     # 0x1b15c
movl %eax, -0x64(%rbp)
leaq 0xec06(%rip), %rdi      # 0x11100
callq 0x2d30
movq %rax, %rcx
movl -0x64(%rbp), %eax
cmpl %ecx, %eax
jge 0x2639
movq -0x8(%rbp), %rdi
callq 0x2d40
movl %eax, -0x68(%rbp)
jmp 0x251b
movl -0x68(%rbp), %eax
movl %eax, -0x2c(%rbp)
leaq 0xebd8(%rip), %rdi      # 0x11100
movq %rdi, -0x80(%rbp)
callq 0x2db0
movq -0x80(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x2dd0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
leaq -0x2c(%rbp), %rdx
callq 0x2d60
movq %rax, -0x70(%rbp)
jmp 0x2554
leaq 0xeba5(%rip), %rdi      # 0x11100
callq 0x2dd0
movq -0x70(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x81(%rbp)
je 0x25dd
leaq -0x28(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x2e80
movq -0x98(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x2eb0
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0x2e30
movq %rax, -0x90(%rbp)
jmp 0x25b2
movq -0x90(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2eb0
movq %rax, -0x60(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2df0
movb %al, -0x81(%rbp)
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x25e9
jmp 0x2623
leaq -0x28(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x2ee0
jmp 0x25f8
movsd 0xea08(%rip), %xmm0     # 0x11008
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x2623
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2f50
jmp 0x2660
jmp 0x2625
movl 0x18b31(%rip), %eax     # 0x1b15c
addl $0x1, %eax
movl %eax, 0x18b28(%rip)     # 0x1b15c
jmp 0x24ea
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0xa0(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2f50
movsd -0xa0(%rbp), %xmm0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2210
nopl (%rax)