LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mikeakohn[P]cloudtari/build/../src/TelevisionVNC.cxx
// Function: TelevisionVNC::send_image_update(int, int, int, int, bool)
int TelevisionVNC::send_image_update(
  int x,
  int y,
  int width,
  int height,
  bool incremental)
{
  if (needs_color_table)
  {
    needs_color_table = false;
  }

  //printf("send_image_update(%d, %d, %d, %d)\n", x, y, width, height);

  if (x == 0 && y == 0 && width == this->width && height == this->height)
  {
    if (incremental) { return 0; }
    needs_full_image = true;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %r9b, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0x2d(%rax)
je 0xe6e3
movq -0x30(%rbp), %rax
movb $0x0, 0x2d(%rax)
cmpl $0x0, -0x14(%rbp)
jne 0xe71e
cmpl $0x0, -0x18(%rbp)
jne 0xe71e
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jne 0xe71e
movq -0x30(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0xc(%rcx), %eax
jne 0xe71e
testb $0x1, -0x21(%rbp)
je 0xe716
movl $0x0, -0x4(%rbp)
jmp 0xe725
movq -0x30(%rbp), %rax
movb $0x1, 0x2c(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: mikeakohn[P]cloudtari/build/../src/TelevisionVNC.cxx
// Function: TelevisionVNC::send_color_table()
int TelevisionVNC::send_color_table()
{
  struct
  {
    uint8_t message_type;
    uint8_t padding;
    uint16_t first_colour;
    uint16_t number_of_colours;
    uint16_t table[128 * 3];
  } packet;

  memset(&packet, 0, sizeof(packet));

  if (sizeof(packet) != 768 + 6)
  {
    printf("Error: sizeof() error  %s:%d\n", __FILE__, __LINE__);
    return -1;
  }

  packet.message_type = 1;
  packet.number_of_colours = htons(128);

  for (int n = 0; n < 128; n++)
  {
    uint32_t color = ColorTable::get_color(n);
    uint16_t red = color >> 16;
    uint16_t green = (color >> 8) & 0xff;
    uint16_t blue = color & 0xff;

    int index = n * 3;
    packet.table[index + 0] = htons(red);
    packet.table[index + 1] = htons(green);
    packet.table[index + 2] = htons(blue);
  }

  if (net_send((const uint8_t *)&packet, sizeof(packet)) != sizeof(packet))
  {
    printf("Error: Send packet %s:%d\n", __FILE__, __LINE__);
    return -1;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x340, %rsp            # imm = 0x340
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x338(%rbp)
leaq -0x316(%rbp), %rdi
xorl %esi, %esi
movl $0x306, %edx            # imm = 0x306
callq 0x4170
movb $0x1, -0x316(%rbp)
movl $0x80, %edi
callq 0x4070
movw %ax, -0x312(%rbp)
movl $0x0, -0x31c(%rbp)
cmpl $0x80, -0x31c(%rbp)
jge 0xe85e
movl -0x31c(%rbp), %edi
callq 0x5540
movl %eax, -0x320(%rbp)
movl -0x320(%rbp), %eax
shrl $0x10, %eax
movw %ax, -0x322(%rbp)
movl -0x320(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movw %ax, -0x324(%rbp)
movl -0x320(%rbp), %eax
andl $0xff, %eax
movw %ax, -0x326(%rbp)
imull $0x3, -0x31c(%rbp), %eax
movl %eax, -0x32c(%rbp)
movzwl -0x322(%rbp), %edi
callq 0x4070
movw %ax, %cx
movl -0x32c(%rbp), %eax
addl $0x0, %eax
cltq
movw %cx, -0x310(%rbp,%rax,2)
movzwl -0x324(%rbp), %edi
callq 0x4070
movw %ax, %cx
movl -0x32c(%rbp), %eax
addl $0x1, %eax
cltq
movw %cx, -0x310(%rbp,%rax,2)
movzwl -0x326(%rbp), %edi
callq 0x4070
movw %ax, %cx
movl -0x32c(%rbp), %eax
addl $0x2, %eax
cltq
movw %cx, -0x310(%rbp,%rax,2)
movl -0x31c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x31c(%rbp)
jmp 0xe77f
movq -0x338(%rbp), %rdi
addq $0x20, %rdi
leaq -0x316(%rbp), %rsi
movl $0x306, %edx            # imm = 0x306
callq 0x9ba0
cltq
cmpq $0x306, %rax            # imm = 0x306
je 0xe8a7
leaq 0x1d00(%rip), %rdi      # 0x1058b
leaq 0x1d13(%rip), %rsi      # 0x105a5
movl $0x16d, %edx            # imm = 0x16D
movb $0x0, %al
callq 0x4050
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe8ae
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x340, %rsp            # imm = 0x340
popq %rbp
retq
nopw (%rax,%rax)
// File: mikeakohn[P]cloudtari/build/../src/TelevisionVNC.cxx
// Function: TelevisionVNC::send_image_full()
int TelevisionVNC::send_image_full()
{
  //if (needs_color_table) { return 0; }

  if (net_send((const uint8_t *)image_packet[image_page], image_packet_length) != image_packet_length)
  {
    printf("Error: Send packet %s:%d\n", __FILE__, __LINE__);
    return -1;
  }

  needs_full_image = false;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rax, %rdi
addq $0x20, %rdi
movslq 0x48(%rax), %rcx
movq 0x38(%rax,%rcx,8), %rsi
movl 0x30(%rax), %edx
callq 0x9ba0
movq -0x18(%rbp), %rcx
cmpl 0x30(%rcx), %eax
je 0xe918
leaq 0x1c8f(%rip), %rdi      # 0x1058b
leaq 0x1ca2(%rip), %rsi      # 0x105a5
movl $0x17a, %edx            # imm = 0x17A
movb $0x0, %al
callq 0x4050
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe927
movq -0x18(%rbp), %rax
movb $0x0, 0x2c(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: mikeakohn[P]cloudtari/build/../src/TelevisionSDL.cxx
// Function: TelevisionSDL::TelevisionSDL()
TelevisionSDL::TelevisionSDL()
{
  SDL_Init(SDL_INIT_EVERYTHING);

  window = SDL_CreateWindow(
    "Debug",
    SDL_WINDOWPOS_UNDEFINED,
    SDL_WINDOWPOS_UNDEFINED,
    width,
    height,
    0);

  background_rect.x = 0;
  background_rect.y = 0;
  background_rect.w = width;
  background_rect.h = height;

  // NOTE: It's possible to write directly to the surface, but requires
  // SDL_LockSurface() so it seems this might be a little simpler for now.
  image = (uint32_t *)malloc(width * height * 4);

  //SDL_RenderClear(renderer);
  screen = SDL_GetWindowSurface(window);

  background_color = SDL_MapRGB(screen->format, 50, 50, 100);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xbe80
movq -0x20(%rbp), %rax
leaq 0x63bc(%rip), %rcx      # 0x14d60
movq %rcx, (%rax)
movl $0xf231, %edi           # imm = 0xF231
callq 0x4210
jmp 0xe9b3
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
movl 0xc(%rax), %r8d
leaq 0x1d88(%rip), %rdi      # 0x1074d
movl $0x1fff0000, %edx       # imm = 0x1FFF0000
xorl %r9d, %r9d
movl %edx, %esi
callq 0x4060
movq %rax, -0x28(%rbp)
jmp 0xe9da
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rax, 0x28(%rcx)
movl $0x0, 0x38(%rcx)
movl $0x0, 0x3c(%rcx)
movl 0x8(%rcx), %eax
movl %eax, 0x40(%rcx)
movl 0xc(%rcx), %eax
movl %eax, 0x44(%rcx)
movl 0x8(%rcx), %eax
movl 0xc(%rcx), %ecx
imull %ecx, %eax
shll $0x2, %eax
movslq %eax, %rdi
callq 0x4320
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x50(%rax)
movq 0x28(%rax), %rdi
callq 0x4310
movq %rax, -0x30(%rbp)
jmp 0xea2e
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq 0x20(%rax), %rax
movq 0x8(%rax), %rdi
movl $0x32, %edx
movl $0x64, %ecx
movl %edx, %esi
callq 0x4150
movl %eax, -0x34(%rbp)
jmp 0xea58
movq -0x20(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, 0x48(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xbed0
movq -0x10(%rbp), %rdi
callq 0x43d0
nopw %cs:(%rax,%rax)
// File: mikeakohn[P]cloudtari/build/../src/TelevisionSDL.cxx
// Function: TelevisionSDL::~TelevisionSDL()
TelevisionSDL::~TelevisionSDL()
{
  free(image);

  if (screen != NULL) { SDL_FreeSurface(screen); }
  if (window != NULL) { SDL_DestroyWindow(window); }

  SDL_Quit();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x62a5(%rip), %rcx      # 0x14d50
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x50(%rax), %rdi
callq 0x42e0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xead7
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x4230
jmp 0xead5
jmp 0xead7
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xeaf3
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x4030
jmp 0xeaf1
jmp 0xeaf3
callq 0x4080
jmp 0xeafa
movq -0x10(%rbp), %rdi
callq 0xbed0
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xa180
nopw %cs:(%rax,%rax)
// File: mikeakohn[P]cloudtari/build/../src/TelevisionSDL.cxx
// Function: TelevisionSDL::refresh()
bool TelevisionSDL::refresh()
{
  pause();

#if 0
  SDL_Rect rect;
  rect.x = 0;
  rect.y = 0;
  rect.w = width;
  rect.h = height;
#endif

  // Copy the drawn image to the screen.
  SDL_LockSurface(screen);
  memcpy(screen->pixels, image, width * height * 4);
  SDL_UnlockSurface(screen);

  SDL_UpdateWindowSurface(window);

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xcc40
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x4330
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rax
movq 0x20(%rax), %rdi
movq 0x50(%rcx), %rsi
movl 0x8(%rcx), %eax
imull 0xc(%rcx), %eax
shll $0x2, %eax
movslq %eax, %rdx
callq 0x41f0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x4390
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x42a0
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH18_ToolsForLargePrograms/examples/spec.cc
// Function: main
int main()
{
    try {
		cout << "f: " << std::boolalpha << noexcept(f()) << endl;
		cout << "g: " << std::boolalpha << noexcept(g()) << endl;
		cout << "h: " << std::boolalpha << noexcept(h()) << endl;
		cout << "i: " << std::boolalpha << noexcept(i()) << endl;
        f();
    } catch (exception &e) {
        cout << "caught " << e.what() << endl;
    }
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
movq 0x2d0f(%rip), %rdi      # 0x3fc8
leaq 0xd44(%rip), %rsi       # 0x2004
callq 0x1080
movq %rax, -0x28(%rbp)
jmp 0x12cb
movq -0x28(%rbp), %rdi
leaq 0x21a(%rip), %rsi       # 0x14f0
callq 0x1040
movq %rax, -0x30(%rbp)
jmp 0x12e1
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x10e0
movq %rax, -0x38(%rbp)
jmp 0x12f5
movq -0x38(%rbp), %rdi
movq 0x2cb0(%rip), %rsi      # 0x3fb0
callq 0x1090
jmp 0x1307
movq 0x2cba(%rip), %rdi      # 0x3fc8
leaq 0xcf3(%rip), %rsi       # 0x2008
callq 0x1080
movq %rax, -0x40(%rbp)
jmp 0x1320
movq -0x40(%rbp), %rdi
leaq 0x1c5(%rip), %rsi       # 0x14f0
callq 0x1040
movq %rax, -0x48(%rbp)
jmp 0x1336
movq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x10e0
movq %rax, -0x50(%rbp)
jmp 0x1347
movq -0x50(%rbp), %rdi
movq 0x2c5e(%rip), %rsi      # 0x3fb0
callq 0x1090
jmp 0x1359
movq 0x2c68(%rip), %rdi      # 0x3fc8
leaq 0xca5(%rip), %rsi       # 0x200c
callq 0x1080
movq %rax, -0x58(%rbp)
jmp 0x1372
movq -0x58(%rbp), %rdi
leaq 0x173(%rip), %rsi       # 0x14f0
callq 0x1040
movq %rax, -0x60(%rbp)
jmp 0x1388
movq -0x60(%rbp), %rdi
movl $0x1, %esi
callq 0x10e0
movq %rax, -0x68(%rbp)
jmp 0x139c
movq -0x68(%rbp), %rdi
movq 0x2c09(%rip), %rsi      # 0x3fb0
callq 0x1090
jmp 0x13ae
movq 0x2c13(%rip), %rdi      # 0x3fc8
leaq 0xc54(%rip), %rsi       # 0x2010
callq 0x1080
movq %rax, -0x70(%rbp)
jmp 0x13c7
movq -0x70(%rbp), %rdi
leaq 0x11e(%rip), %rsi       # 0x14f0
callq 0x1040
movq %rax, -0x78(%rbp)
jmp 0x13dd
movq -0x78(%rbp), %rdi
xorl %esi, %esi
callq 0x10e0
movq %rax, -0x80(%rbp)
jmp 0x13ee
movq -0x80(%rbp), %rdi
movq 0x2bb7(%rip), %rsi      # 0x3fb0
callq 0x1090
jmp 0x1400
callq 0x1230
jmp 0x148e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x14ae
movq -0x10(%rbp), %rdi
callq 0x1050
movq %rax, -0x20(%rbp)
movq 0x2b8e(%rip), %rdi      # 0x3fc8
leaq 0xbd3(%rip), %rsi       # 0x2014
callq 0x1080
movq %rax, -0x88(%rbp)
jmp 0x144f
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x1080
movq %rax, -0x90(%rbp)
jmp 0x1474
movq -0x90(%rbp), %rdi
movq 0x2b2e(%rip), %rsi      # 0x3fb0
callq 0x1090
jmp 0x1489
callq 0x10b0
xorl %eax, %eax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x10b0
jmp 0x14ac
jmp 0x14ae
movq -0x10(%rbp), %rdi
callq 0x10d0
movq %rax, %rdi
callq 0x14e0
nop
// File: BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: operator<<(std::ostream&, ROAGroup)
ostream& operator<<(ostream& os, ROAGroup g)
{
  set<int>* ASes = g.getASes();

  for( set<int>::iterator i = ASes->begin(); i != ASes->end(); ++i){
    int as = *i;
    PrefixRange* r = g.getByAS( as );
    
    os<<"AS:"<<as<<"={"<<endl;
    os<<*r<<endl;
    os<<"}"<<endl;

  }
  return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, %rax
movq -0x48(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x5bf0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5c10
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5c70
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5c40
testb $0x1, %al
jne 0x38a8
jmp 0x3948
leaq -0x20(%rbp), %rdi
callq 0x5ca0
movq -0x40(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %esi
callq 0x5cc0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1073d(%rip), %rsi     # 0x1400e
callq 0x3260
movq %rax, %rdi
movl -0x2c(%rbp), %esi
callq 0x33f0
movq %rax, %rdi
leaq 0x1073d(%rip), %rsi     # 0x14028
callq 0x3260
movq %rax, %rdi
movq 0x1a6ce(%rip), %rsi     # 0x1dfc8
callq 0x32a0
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x36a0
movq %rax, %rdi
movq 0x1a6b2(%rip), %rsi     # 0x1dfc8
callq 0x32a0
movq -0x8(%rbp), %rdi
leaq 0x10700(%rip), %rsi     # 0x14026
callq 0x3260
movq %rax, %rdi
movq 0x1a693(%rip), %rsi     # 0x1dfc8
callq 0x32a0
leaq -0x20(%rbp), %rdi
callq 0x5d20
jmp 0x3885
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: ValidToInvalid(ROAGroup*, PrefixRange*, int)
void ValidToInvalid( ROAGroup* newPrefixes, PrefixRange* rOld, int as){
  bool argDense = false;  // most likely, known has many entries and the intersections have few entries

  PrefixRange noLongerValid =  PrefixRange(); 

  if( newPrefixes->hasAS( as ) ) { 

    // ( R.valid -  new.AS.Valid)
    PrefixRange* newASValid = newPrefixes->getByAS(as);
    PrefixRange newASUnknownOrInvalid = newASValid->complement();
    rOld->denseIntersectWith( newASUnknownOrInvalid, argDense); // LEOCOM: would it be more efficent to do a subtraction, ETHANCOM: unfortunately substraction only applies to IPPrefixes which don't have MaxLen

  } // if new.AS.valid doesn't exist then ( R.valid -  new.AS.valid) = (R.valid) and we can skip ahead

  // subtracting new.unknown is the same as intersecting with new.known
  rOld->denseIntersectWith( *(newPrefixes->getKnown()), argDense);
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5fd0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x6030
movb %al, -0x61(%rbp)
jmp 0x3c04
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x3c0d
jmp 0x3c7c
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x5cc0
movq %rax, -0x70(%rbp)
jmp 0x3c1f
movq -0x70(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x6080
jmp 0x3c36
movq -0x10(%rbp), %rdi
movzbl -0x15(%rbp), %edx
andl $0x1, %edx
leaq -0x60(%rbp), %rsi
callq 0x5ed0
jmp 0x3c4c
leaq -0x60(%rbp), %rdi
callq 0x61e0
jmp 0x3c7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3cbb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x61e0
jmp 0x3cbb
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6280
movq %rax, -0x78(%rbp)
jmp 0x3c93
movq -0x78(%rbp), %rsi
movq -0x80(%rbp), %rdi
movzbl -0x15(%rbp), %edx
andl $0x1, %edx
callq 0x5ed0
jmp 0x3ca9
leaq -0x30(%rbp), %rdi
callq 0x61e0
addq $0x80, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x61e0
movq -0x38(%rbp), %rdi
callq 0x3400
nopl (%rax)
// File: BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: UnknownToKnown(PrefixRange const*, ROA, PrefixRange*)
void UnknownToKnown(const PrefixRange* oldUnknown, ROA rNew, PrefixRange* unknownToKnown){
  bool argDense = true;
  assert(unknownToKnown->empty());

  unknownToKnown->addROA( rNew.getPrefix(), IPAddr::numBits);

  // unknownToKnown =  R.known INTERSECTS old
  unknownToKnown->denseIntersectWith( *oldUnknown, argDense);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x1, -0x19(%rbp)
movq -0x18(%rbp), %rdi
callq 0x62a0
testb $0x1, %al
jne 0x3f7b
jmp 0x3f7d
jmp 0x3f9c
leaq 0x100cc(%rip), %rdi     # 0x14050
leaq 0x100dd(%rip), %rsi     # 0x14068
movl $0x380, %edx            # imm = 0x380
leaq 0x100db(%rip), %rcx     # 0x14072
callq 0x3180
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x24(%rbp), %rdi
callq 0x5b70
movq -0x38(%rbp), %rdi
leaq -0x24(%rbp), %rsi
movl $0x20, %edx
callq 0x6570
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x5ed0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: std::ostream& operator<<<IPAddr>(std::ostream&, IntervalList<IPAddr> const&)
ostream& operator<< (ostream& os, const IntervalList<T> & l)
{
  typename map<T, T>::const_iterator it = l.m.begin();
  if (it==l.m.end()) {
    os << "empty ";
  }
  while (it!=l.m.end()) {
    os << "["<<it->first<<"-" << it->second<<"] ";
    ++it;
  }
  return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x86e0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x87a0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8770
testb $0x1, %al
jne 0x5a5d
jmp 0x5a6d
movq -0x8(%rbp), %rdi
leaq 0xe8bf(%rip), %rsi      # 0x14327
callq 0x3260
jmp 0x5a6f
movq -0x10(%rbp), %rdi
callq 0x87a0
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8860
testb $0x1, %al
jne 0x5a92
jmp 0x5b1e
movq -0x8(%rbp), %rdi
leaq 0xe58e(%rip), %rsi      # 0x1402b
callq 0x3260
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x8890
movq %rax, %rsi
leaq -0x2c(%rbp), %rdi
callq 0x5a00
movq -0x40(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x35a0
movq %rax, %rdi
leaq 0xe54a(%rip), %rsi      # 0x1401c
callq 0x3260
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x8890
movq %rax, %rsi
addq $0x4, %rsi
leaq -0x30(%rbp), %rdi
callq 0x5a00
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x35a0
movq %rax, %rdi
leaq 0xe823(%rip), %rsi      # 0x1432e
callq 0x3260
leaq -0x18(%rbp), %rdi
callq 0xf350
jmp 0x5a6f
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: PrefixRange::complement()
PrefixRange complement() {
    PrefixRange ret(bound, endLength);

    for (int i = bound.getLength(); i<=endLength; i++) { 
      lists[i-bound.getLength()].subtractFromInterval(bound.getPrefix(), bound.endAddress(i), ret.lists[i-bound.getLength()]);
    }
    return ret;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x40(%rbp)
movb $0x0, -0x11(%rbp)
addq $0x8, %rsi
leaq -0x1c(%rbp), %rdi
callq 0x7fb0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rax
movl 0x10(%rax), %edx
leaq -0x1c(%rbp), %rsi
callq 0x7350
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
callq 0x5b30
movl %eax, -0x20(%rbp)
movq -0x40(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x10(%rcx), %eax
jg 0x61b3
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movq %rax, -0x60(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x6c(%rbp)
addq $0x8, %rdi
movq %rdi, -0x68(%rbp)
callq 0x5b30
movl -0x6c(%rbp), %ecx
movq -0x68(%rbp), %rsi
movl %eax, %edx
movq -0x60(%rbp), %rax
subl %edx, %ecx
movslq %ecx, %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
leaq -0x24(%rbp), %rdi
callq 0xb080
jmp 0x6131
movq -0x40(%rbp), %rsi
addq $0x8, %rsi
movl -0x20(%rbp), %edx
leaq -0x38(%rbp), %rdi
callq 0xb0b0
jmp 0x6147
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x78(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x70(%rbp)
addq $0x8, %rdi
callq 0x5b30
movq -0x78(%rbp), %rcx
movq -0x58(%rbp), %rdi
movl %eax, %edx
movl -0x70(%rbp), %eax
subl %edx, %eax
cltq
imulq $0x38, %rax, %rax
addq %rax, %rcx
leaq -0x24(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0xad60
jmp 0x618c
jmp 0x618e
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x60db
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x61e0
jmp 0x61d3
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x61c6
movq -0x48(%rbp), %rdi
callq 0x61e0
movq -0x50(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3400
nopl (%rax)
// File: BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: PrefixRange::empty()
bool empty () {
    for (int i = 0; i<len; i++)
      if (!lists[i].empty())
        return false;
    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x14(%rcx), %eax
jge 0x62f5
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rax
imulq $0x38, %rax, %rax
addq %rax, %rdi
callq 0xb3c0
testb $0x1, %al
jne 0x62e8
movb $0x0, -0x1(%rbp)
jmp 0x62f9
jmp 0x62ea
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x62bb
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: PrefixRange::PrefixRange(PrefixRange const&)
PrefixRange( const PrefixRange& original ) : bound(original.bound), endLength(original.endLength), len(original.len) {
    
    //copy everything in lists
    lists = new IntervalList<IPAddr>[len]; 
     for (int i = 0; i<len; i++){
       IntervalList<IPAddr> list = IntervalList<IPAddr>( original.lists[i] );
       lists[i] = list;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x7fb0
movq -0x80(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
movl %ecx, 0x14(%rax)
movslq 0x14(%rax), %rax
movq %rax, -0x70(%rbp)
movl $0x38, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
setb %al
orb %al, %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
movq %rdi, -0x78(%rbp)
callq 0x3030
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x68(%rbp)
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, -0x60(%rbp)
cmpq $0x0, %rax
je 0x6469
movq -0x60(%rbp), %rax
movq -0x70(%rbp), %rcx
imulq $0x38, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x90(%rbp)
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xa570
jmp 0x644b
movq -0x90(%rbp), %rcx
movq -0x98(%rbp), %rax
addq $0x38, %rax
cmpq %rcx, %rax
movq %rax, -0x88(%rbp)
jne 0x6436
movq -0x80(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, (%rax)
movl $0x0, -0x20(%rbp)
movq -0x80(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x14(%rcx), %eax
jge 0x6556
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movslq -0x20(%rbp), %rax
imulq $0x38, %rax, %rax
addq %rax, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xb410
movq -0x80(%rbp), %rax
movq -0xa0(%rbp), %rsi
movq (%rax), %rdi
movslq -0x20(%rbp), %rax
imulq $0x38, %rax, %rax
addq %rax, %rdi
callq 0xb450
jmp 0x64cd
leaq -0x58(%rbp), %rdi
callq 0xa5a0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x647b
movq -0x60(%rbp), %rcx
movq %rax, %rsi
movq -0x98(%rbp), %rax
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq %rax, %rcx
movq %rax, -0xa8(%rbp)
je 0x6530
movq -0xa8(%rbp), %rdi
addq $-0x38, %rdi
movq %rdi, -0xb0(%rbp)
callq 0xa5a0
movq -0x60(%rbp), %rcx
movq -0xb0(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0xa8(%rbp)
jne 0x6502
movq -0x78(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0x3430
jmp 0x655f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xa5a0
jmp 0x655f
addq $0xb0, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3400
nopl (%rax,%rax)
// File: BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: PrefixRange::addROA(IPPrefix, int)
void addROA(IPPrefix prefix, int maxLength) {
    int endIndex = min(maxLength, endLength);
    if (prefix.isSubPrefixOf(bound)){
      for (int i=prefix.getLength(); i<=endIndex; i++)
        lists[i-bound.getLength()].add(prefix.getPrefix(), prefix.endAddress(i));
    } else if (bound.isSubPrefixOf(prefix)) {
      for (int i=bound.getLength(); i<=endIndex; i++)
        lists[i-bound.getLength()].add(bound.getPrefix(), bound.endAddress(i));
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x50(%rbp)
addq $0x10, %rsi
leaq -0x14(%rbp), %rdi
callq 0x80d0
movq -0x50(%rbp), %rsi
movl (%rax), %eax
movl %eax, -0x18(%rbp)
addq $0x8, %rsi
leaq -0x20(%rbp), %rdi
callq 0x7fb0
movq -0x48(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xc210
testb $0x1, %al
jne 0x65cb
jmp 0x6650
movq -0x48(%rbp), %rdi
callq 0x5b30
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x664b
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
movq %rax, -0x60(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x64(%rbp)
addq $0x8, %rdi
callq 0x5b30
movl -0x64(%rbp), %ecx
movq -0x48(%rbp), %rsi
movl %eax, %edx
movq -0x60(%rbp), %rax
subl %edx, %ecx
movslq %ecx, %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xb080
movq -0x48(%rbp), %rsi
movl -0x24(%rbp), %edx
leaq -0x2c(%rbp), %rdi
callq 0xb0b0
movq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0xc280
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x65d7
jmp 0x6718
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x70(%rbp)
leaq -0x34(%rbp), %rdi
callq 0x7fb0
movq -0x70(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0xc210
testb $0x1, %al
jne 0x667f
jmp 0x6716
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
callq 0x5b30
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x6714
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
movq %rax, -0x80(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x84(%rbp)
addq $0x8, %rdi
callq 0x5b30
movl -0x84(%rbp), %ecx
movq -0x50(%rbp), %rsi
movl %eax, %edx
movq -0x80(%rbp), %rax
subl %edx, %ecx
movslq %ecx, %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x78(%rbp)
addq $0x8, %rsi
leaq -0x3c(%rbp), %rdi
callq 0xb080
movq -0x50(%rbp), %rsi
addq $0x8, %rsi
movl -0x38(%rbp), %edx
leaq -0x40(%rbp), %rdi
callq 0xb0b0
movq -0x78(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0xc280
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x668f
jmp 0x6716
jmp 0x6718
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: ROAGroup::ROAGroup(ROAGroup const&)
ROAGroup(const ROAGroup& original){
      
      known = new PrefixRange( *original.known );
      ases = original.ases;

      unordered_map<int, PrefixRange*> origMap =  original.AStoROA;

      for( set<int>::iterator j = ases.begin(); j!= ases.end(); ++j){
        int as = *j;

        AStoROA[as] = new PrefixRange( *origMap[as] );
      }

    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
callq 0x6750
movq -0x88(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x80(%rbp)
callq 0xc960
movl $0x18, %edi
callq 0x3270
movq %rax, -0x78(%rbp)
jmp 0x67c1
movq -0x78(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x6380
jmp 0x67d4
movq -0x90(%rbp), %rdi
movq -0x78(%rbp), %rax
movq %rax, 0x38(%rdi)
movq -0x10(%rbp), %rsi
addq $0x48, %rsi
addq $0x48, %rdi
callq 0xc980
jmp 0x67f6
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xc9b0
jmp 0x6805
movq -0x90(%rbp), %rdi
addq $0x48, %rdi
callq 0x5c10
movq %rax, -0x60(%rbp)
movq -0x90(%rbp), %rdi
addq $0x48, %rdi
callq 0x5c70
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5c40
testb $0x1, %al
jne 0x6843
jmp 0x6921
leaq -0x60(%rbp), %rdi
callq 0x5ca0
movl (%rax), %eax
movl %eax, -0x6c(%rbp)
movl $0x18, %edi
callq 0x3270
movq %rax, -0x98(%rbp)
jmp 0x6864
leaq -0x58(%rbp), %rdi
leaq -0x6c(%rbp), %rsi
callq 0x6e80
movq %rax, -0xa0(%rbp)
jmp 0x687a
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rax
movq (%rax), %rsi
callq 0x6380
jmp 0x6892
movq -0x90(%rbp), %rdi
leaq -0x6c(%rbp), %rsi
callq 0x6e80
movq %rax, -0xa8(%rbp)
jmp 0x68ab
movq -0xa8(%rbp), %rax
movq -0x98(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x60(%rbp), %rdi
callq 0x5d20
jmp 0x6819
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x693c
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x18, %esi
callq 0x3280
jmp 0x693c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x6933
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x18, %esi
callq 0x3280
jmp 0x6933
leaq -0x58(%rbp), %rdi
callq 0x71e0
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x58(%rbp), %rdi
callq 0x71e0
movq -0x80(%rbp), %rdi
callq 0xc9e0
movq -0x88(%rbp), %rdi
callq 0x71e0
movq -0x18(%rbp), %rdi
callq 0x3400
nopw (%rax,%rax)
// File: BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: ROAGroup::~ROAGroup()
inline ~ROAGroup() {
      for( set<int>::iterator j = ases.begin(); j!= ases.end(); ++j){
        int as = *j;
        delete AStoROA[as];
      }
      delete known;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x48, %rdi
callq 0x5c10
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
addq $0x48, %rdi
callq 0x5c70
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x5c40
testb $0x1, %al
jne 0x69a5
jmp 0x69fb
leaq -0x10(%rbp), %rdi
callq 0x5ca0
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x6e80
movq %rax, -0x30(%rbp)
jmp 0x69c6
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x69ee
movq -0x38(%rbp), %rdi
callq 0x61e0
movq -0x38(%rbp), %rdi
movl $0x18, %esi
callq 0x3280
jmp 0x69f0
leaq -0x10(%rbp), %rdi
callq 0x5d20
jmp 0x6981
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x6a24
movq -0x40(%rbp), %rdi
callq 0x61e0
movq -0x40(%rbp), %rdi
movl $0x18, %esi
callq 0x3280
movq -0x28(%rbp), %rdi
addq $0x48, %rdi
callq 0xc9e0
movq -0x28(%rbp), %rdi
callq 0x71e0
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x8b70
nopl (%rax,%rax)
// File: BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: ROA::toJSON[abi:cxx11]()
string toJSON(){
      stringstream ss;
      ss<<"{";
      ss<<"\"AS\":"<<getAS()<<", ";
      ss<<"\"PREFIX\":\""<<getPrefix()<<"-"<<getMaxlen()<<"\", ";
      ss<<"\"PATH\":"<<"\""<<getPath()<<"\""; 
      ss<<"}";

      return ss.str();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x1e8(%rbp)
movq %rdi, %rax
movq %rax, -0x1e0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1d8(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x31b0
leaq -0x188(%rbp), %rdi
leaq 0xcf4c(%rip), %rsi      # 0x14325
callq 0x3260
jmp 0x73e0
leaq -0x188(%rbp), %rdi
leaq 0xcf03(%rip), %rsi      # 0x142f1
callq 0x3260
movq %rax, -0x1f0(%rbp)
jmp 0x73fc
movq -0x1d8(%rbp), %rdi
callq 0x5b50
movq -0x1f0(%rbp), %rdi
movl %eax, %esi
callq 0x33f0
movq %rax, -0x1f8(%rbp)
jmp 0x741f
movq -0x1f8(%rbp), %rdi
leaq 0xceec(%rip), %rsi      # 0x14319
callq 0x3260
jmp 0x7434
leaq -0x188(%rbp), %rdi
leaq 0xceb5(%rip), %rsi      # 0x142f7
callq 0x3260
movq %rax, -0x200(%rbp)
jmp 0x7450
movq -0x1d8(%rbp), %rsi
leaq -0x1ac(%rbp), %rdi
callq 0x5b70
jmp 0x7465
movq -0x200(%rbp), %rdi
leaq -0x1ac(%rbp), %rsi
callq 0x3640
movq %rax, -0x208(%rbp)
jmp 0x7481
movq -0x208(%rbp), %rdi
leaq 0xcb8d(%rip), %rsi      # 0x1401c
callq 0x3260
movq %rax, -0x210(%rbp)
jmp 0x749d
movq -0x1d8(%rbp), %rdi
callq 0x5ba0
movq -0x210(%rbp), %rdi
movl %eax, %esi
callq 0x33f0
movq %rax, -0x218(%rbp)
jmp 0x74c0
movq -0x218(%rbp), %rdi
leaq 0xce4a(%rip), %rsi      # 0x14318
callq 0x3260
jmp 0x74d5
leaq -0x188(%rbp), %rdi
leaq 0xce1f(%rip), %rsi      # 0x14302
callq 0x3260
movq %rax, -0x220(%rbp)
jmp 0x74f1
movq -0x220(%rbp), %rdi
leaq 0xce01(%rip), %rsi      # 0x14300
callq 0x3260
movq %rax, -0x228(%rbp)
jmp 0x750d
movq -0x1d8(%rbp), %rsi
leaq -0x1d0(%rbp), %rdi
callq 0x5bc0
jmp 0x7522
movq -0x228(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x3230
movq %rax, -0x230(%rbp)
jmp 0x753e
movq -0x230(%rbp), %rdi
leaq 0xcdb4(%rip), %rsi      # 0x14300
callq 0x3260
jmp 0x7553
leaq -0x1d0(%rbp), %rdi
callq 0x3170
leaq -0x188(%rbp), %rdi
leaq 0xcab9(%rip), %rsi      # 0x14026
callq 0x3260
jmp 0x7574
movq -0x1e8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x3250
jmp 0x7589
leaq -0x198(%rbp), %rdi
callq 0x31d0
movq -0x1e0(%rbp), %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x75d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x3170
leaq -0x198(%rbp), %rdi
callq 0x31d0
movq -0x1a0(%rbp), %rdi
callq 0x3400
nop
// File: BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: PrefixRange::toJSON[abi:cxx11]()
string toJSON(){
    stringstream ss;
    ss<<"[";
    for (int i = 0; i<len; i++){
      ss << "\"" << lists[i] << "/"<<bound.getLength()+i << "\"";
      if (i!=len-1) ss<<", ";
    }
    ss<<"]";
    return 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 0x31b0
leaq -0x188(%rbp), %rdi
leaq 0xc9f2(%rip), %rsi      # 0x1402b
callq 0x3260
jmp 0x7640
movl $0x0, -0x1a8(%rbp)
movq -0x1b0(%rbp), %rcx
movl -0x1a8(%rbp), %eax
cmpl 0x14(%rcx), %eax
jge 0x776d
leaq -0x188(%rbp), %rdi
leaq 0xcc92(%rip), %rsi      # 0x14300
callq 0x3260
movq %rax, -0x1c8(%rbp)
jmp 0x767c
movq -0x1c8(%rbp), %rdi
movq -0x1b0(%rbp), %rax
movq (%rax), %rsi
movslq -0x1a8(%rbp), %rax
imulq $0x38, %rax, %rax
addq %rax, %rsi
callq 0x5a20
movq %rax, -0x1d0(%rbp)
jmp 0x76a9
movq -0x1d0(%rbp), %rdi
leaq 0xc953(%rip), %rsi      # 0x1400a
callq 0x3260
movq %rax, -0x1d8(%rbp)
jmp 0x76c5
movq -0x1b0(%rbp), %rdi
addq $0x8, %rdi
callq 0x5b30
movq -0x1d8(%rbp), %rdi
movl %eax, %esi
movl -0x1a8(%rbp), %eax
addl %eax, %esi
callq 0x33f0
movq %rax, -0x1e0(%rbp)
jmp 0x76f4
movq -0x1e0(%rbp), %rdi
leaq 0xcbfe(%rip), %rsi      # 0x14300
callq 0x3260
jmp 0x7709
movq -0x1b0(%rbp), %rcx
movl -0x1a8(%rbp), %eax
movl 0x14(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x7757
leaq -0x188(%rbp), %rdi
leaq 0xcbeb(%rip), %rsi      # 0x14319
callq 0x3260
jmp 0x7735
jmp 0x7757
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x31d0
jmp 0x77b3
jmp 0x7759
movl -0x1a8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1a8(%rbp)
jmp 0x764a
leaq -0x188(%rbp), %rdi
leaq 0xcad8(%rip), %rsi      # 0x14253
callq 0x3260
jmp 0x7782
movq -0x1c0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x3250
jmp 0x7797
leaq -0x198(%rbp), %rdi
callq 0x31d0
movq -0x1b8(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0x3400
nop
// File: BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: IPPrefix::endAddress(int) const
inline IPAddr endAddress (int level) const {
    if (level<length) return 0;
    
    //Can't bit shift by 32
    assert( length >= 0 ); 
    if (length == 0){
      if (level == 0) return prefix;
      // at this point we know numBits-level<32, so the shift is safe
      else return (IPAddr::maxAddr - (1<<(IPAddr::numBits-level)) ) +1; //~erh refactor
    }
    
    // at this point we know numBits - length and numBits - level < 32, so the shifts are safe
    // we know we are adding a nonnegative quantity because length<=level
    // we know this addtion won't overflow because prefix has all zero bits after
    // the first length bits
    return prefix+((1<<(IPAddr::numBits-length))-(1<<(IPAddr::numBits-level)));
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0xb0ee
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0xb3a0
jmp 0xb189
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jl 0xb0fa
jmp 0xb119
leaq 0x91bd(%rip), %rdi      # 0x142be
leaq 0x8f60(%rip), %rsi      # 0x14068
movl $0x4f, %edx
leaq 0x91b6(%rip), %rcx      # 0x142ca
callq 0x3180
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0xb15c
cmpl $0x0, -0x14(%rbp)
jne 0xb138
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x5a00
jmp 0xb189
movq -0x30(%rbp), %rdi
movl $0x20, %ecx
subl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
subl %eax, %esi
addl $0x1, %esi
callq 0xb3a0
jmp 0xb189
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
movl $0x20, %ecx
subl 0x4(%rsi), %ecx
movl $0x1, %edx
shll %cl, %edx
movl $0x20, %ecx
subl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl %eax, %edx
callq 0xb260
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: IPAddr::truncate(int)
inline IPAddr truncate (int l) { // truncate the address to have only the top l bits
    IPAddr ret(a);
    if (l==0)
      ret.a=0;
    else {
      ret.a>>=(numBits-l);
      ret.a<<=(numBits-l);
    }
    return ret;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0xb3a0
cmpl $0x0, -0x14(%rbp)
jne 0xc6bb
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
jmp 0xc6df
movq -0x28(%rbp), %rax
movl $0x20, %ecx
subl -0x14(%rbp), %ecx
movl (%rax), %edx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, (%rax)
movl $0x20, %ecx
subl -0x14(%rbp), %ecx
movl (%rax), %edx
shll %cl, %edx
movl %edx, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: ROAGroup::Setup()
void Setup() {
      AStoROA.clear();    
      known = new PrefixRange(); 
      unknown = (PrefixRange*)NULL;

      changed = true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xec50
movl $0x18, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x20(%rbp)
callq 0x5fd0
jmp 0xeba4
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq $0x0, 0x40(%rax)
movb $0x1, 0x78(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x18, %esi
callq 0x3280
movq -0x10(%rbp), %rdi
callq 0x3400
nopw %cs:(%rax,%rax)
nop
// File: BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: ROAGroup::addROA(int, IPPrefix, int)
void addROA(int as, IPPrefix prefix, int maxLength){
      // If we don't have a prefixRange setup for this AS then set one up
      if ( ! hasAS(as) ) { 
         AStoROA[as] = new PrefixRange();
         ases.insert(as);
      } 

      AStoROA[as]->addROA(prefix, maxLength);

      // known prefixes includes the invalid shadows of the valid prefixes
      known->addROA(prefix, IPAddr::numBits);

      changed = true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl -0xc(%rbp), %esi
callq 0x6030
testb $0x1, %al
jne 0xed06
movl $0x18, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
callq 0x5fd0
jmp 0xecbc
movq -0x58(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x6e80
movq -0x68(%rbp), %rcx
movq -0x58(%rbp), %rdi
movq %rcx, (%rax)
addq $0x48, %rdi
leaq -0xc(%rbp), %rsi
callq 0xed80
movq %rax, -0x40(%rbp)
movb %dl, -0x38(%rbp)
jmp 0xed06
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x18, %esi
callq 0x3280
jmp 0xed73
movq -0x58(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x6e80
movq -0x60(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x78(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x7fb0
movq -0x78(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq -0x48(%rbp), %rsi
callq 0x6570
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x70(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x7fb0
movq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x20, %edx
callq 0x6570
movq -0x58(%rbp), %rax
movb $0x1, 0x78(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3400
nopl (%rax)
// File: adamjanovsky[P]PA193_test_parser_monero/main.cpp
// Function: main
int main(int argc, const char * argv[]) {
    
    if (argc != 3) {
        std::cerr << "Usage: parser <block_to_validate> <valid_block>" << std::endl;
        return 1;
    }
   
    string f_lower(argv[1]);
    string f_higher(argv[2]);

    Parser p = Parser();
    
    p.validate_block(f_lower, f_higher, true);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x254d
movq 0xaaca(%rip), %rdi      # 0xcff0
leaq 0x6ad7(%rip), %rsi      # 0x9004
callq 0x2160
movq %rax, %rdi
movq 0xaa84(%rip), %rsi      # 0xcfc0
callq 0x2190
movl $0x1, -0x4(%rbp)
jmp 0x271d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x200(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
callq 0x22e0
movq -0x200(%rbp), %rsi
movq -0x1f8(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x2200
jmp 0x2585
leaq -0x31(%rbp), %rdi
callq 0x21a0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x210(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x208(%rbp)
callq 0x22e0
movq -0x210(%rbp), %rsi
movq -0x208(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0x2200
jmp 0x25c6
leaq -0x69(%rbp), %rdi
callq 0x21a0
leaq -0x1b0(%rbp), %rdi
movq %rdi, -0x218(%rbp)
xorl %esi, %esi
movl $0x140, %edx            # imm = 0x140
callq 0x20f0
movq -0x218(%rbp), %rdi
callq 0x2740
jmp 0x25f7
leaq -0x1d0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x20c0
jmp 0x2609
leaq -0x1f0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x20c0
jmp 0x261b
leaq -0x1b0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
leaq -0x1f0(%rbp), %rdx
movl $0x1, %ecx
callq 0x2b50
jmp 0x263c
leaq -0x1f0(%rbp), %rdi
callq 0x2100
leaq -0x1d0(%rbp), %rdi
callq 0x2100
movl $0x0, -0x4(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x2790
leaq -0x68(%rbp), %rdi
callq 0x2100
leaq -0x30(%rbp), %rdi
callq 0x2100
jmp 0x271d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x21a0
jmp 0x2729
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x69(%rbp), %rdi
callq 0x21a0
jmp 0x2712
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2709
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x26fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x26f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0x2100
leaq -0x1d0(%rbp), %rdi
callq 0x2100
leaq -0x1b0(%rbp), %rdi
callq 0x2790
leaq -0x68(%rbp), %rdi
callq 0x2100
leaq -0x30(%rbp), %rdi
callq 0x2100
jmp 0x2729
movl -0x4(%rbp), %eax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x22d0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: adamjanovsky[P]PA193_test_parser_monero/src/block.cpp
// Function: Block::get_prev_id(std::array<unsigned char, 32ul>&) const
int Block::get_prev_id(hash::hash_t & prev_id_copy) const {
    if (this->initialized) {
        std::copy(prev_id.begin(), prev_id.end(), prev_id_copy.begin());
        return OK;
    } else {
        return ERR_BL_NOT_INITIALIZED;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, (%rax)
je 0x2fe1
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0x4520
movq -0x20(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x28, %rdi
callq 0x4540
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4560
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x44e0
movl $0x0, -0x4(%rbp)
jmp 0x2fe8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: adamjanovsky[P]PA193_test_parser_monero/src/block.cpp
// Function: Block::load_tx_hashes(std::basic_ifstream<char, std::char_traits<char>>&)
int Block::load_tx_hashes(ifstream & in) {
    // Read count of tx hashes
    if (tools::read_varint(in, tx_hashes_count) < 0) {
        std::cerr << "Tx hashes: could not read count of hashes." << std::endl;
        return ERR_TXH_PARSER_ERROR;
    }

    // Alloc memory
    tx_hashes.resize(tx_hashes_count * hash::HASH_SIZE, 0x00);

    // Read the hashes
    in.read(reinterpret_cast<char *>(&tx_hashes[0]), tx_hashes.size());
    if(!in.good()) {
        std::cerr << "Tx hashes: invalid stream." << std::endl;
        return ERR_TXH_PARSER_ERROR;
    }

    // Try to read one more byte and test EOF
    char c;
    in.read(&c, 1);
    if(!in.eof()) {
        // still some bytes to read, weird
        std::cerr << "Tx hashes: Blocked parsed but some bytes are remaining." << std::endl;
        return ERR_TXH_NO_EOF;
    }

    return OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x98, %rsi
callq 0x79c0
cmpl $0x0, %eax
jge 0x3dab
movq 0x926c(%rip), %rdi      # 0xcff0
leaq 0x5636(%rip), %rsi      # 0x93c1
callq 0x2160
movq %rax, %rdi
movq 0x9226(%rip), %rsi      # 0xcfc0
callq 0x2190
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x3ea8
movq -0x28(%rbp), %rax
movq %rax, %rdi
addq $0x80, %rdi
movq 0x98(%rax), %rsi
shlq $0x5, %rsi
movb $0x0, -0x19(%rbp)
leaq -0x19(%rbp), %rdx
callq 0x45e0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x80, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4690
movq -0x28(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x80, %rdi
callq 0x46b0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x21d0
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x22a0
testb $0x1, %al
jne 0x3e50
movq 0x91c4(%rip), %rdi      # 0xcff0
leaq 0x55b9(%rip), %rsi      # 0x93ec
callq 0x2160
movq %rax, %rdi
movq 0x917e(%rip), %rsi      # 0xcfc0
callq 0x2190
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x3ea8
movq -0x18(%rbp), %rdi
leaq -0x1a(%rbp), %rsi
movl $0x1, %edx
callq 0x21d0
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x22f0
testb $0x1, %al
jne 0x3ea1
movq 0x9173(%rip), %rdi      # 0xcff0
leaq 0x5583(%rip), %rsi      # 0x9407
callq 0x2160
movq %rax, %rdi
movq 0x912d(%rip), %rsi      # 0xcfc0
callq 0x2190
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x3ea8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)