LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: afinit[P]afin/readlist.cpp
// Function: Readlist::cmp_rc(int, int)
bool Readlist::cmp_rc( const int ind1, const int ind2 ){
  string str1 = rlist[ind1].substr( rlist[ind1].length()-max_sort_char, max_sort_char );
  str1 = revcomp( str1 );
  string str2 = rlist[ind2].substr( rlist[ind2].length()-max_sort_char, max_sort_char );
  str2 = revcomp( str2 );

  return (str1.compare( str2 ) < 0 ); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movslq -0x4(%rbp), %rsi
leaq 0x2393c(%rip), %rdi     # 0x3e748
movq %rdi, -0xf0(%rbp)
callq 0x1b5a0
movq -0xf0(%rbp), %rdi
movq %rax, -0xe8(%rbp)
movslq -0x4(%rbp), %rsi
callq 0x1b5a0
movq %rax, %rdi
callq 0x45e0
movq -0xe8(%rbp), %rsi
movq %rax, %rdx
leaq 0x2387c(%rip), %rax     # 0x3e6c4
movslq (%rax), %rcx
subq %rcx, %rdx
leaq -0x28(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x43e0
movq -0xe0(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x41b0
jmp 0x1ae70
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xfc10
jmp 0x1ae7f
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movq %rsi, -0x108(%rbp)
callq 0x4480
movq -0x108(%rbp), %rdi
callq 0x4270
leaq -0x68(%rbp), %rdi
callq 0x4270
movslq -0x8(%rbp), %rsi
leaq 0x23895(%rip), %rdi     # 0x3e748
movq %rdi, -0x100(%rbp)
callq 0x1b5a0
movq -0x100(%rbp), %rdi
movq %rax, -0xf8(%rbp)
movslq -0x8(%rbp), %rsi
callq 0x1b5a0
movq %rax, %rdi
callq 0x45e0
movq -0xf8(%rbp), %rsi
movq %rax, %rdx
leaq 0x237d5(%rip), %rax     # 0x3e6c4
movslq (%rax), %rcx
subq %rcx, %rdx
leaq -0x98(%rbp), %rdi
callq 0x43e0
jmp 0x1af03
leaq -0xd8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x41b0
jmp 0x1af18
leaq -0xb8(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0xfc10
jmp 0x1af2d
leaq -0x98(%rbp), %rdi
movq %rdi, -0x118(%rbp)
leaq -0xb8(%rbp), %rsi
movq %rsi, -0x120(%rbp)
callq 0x4480
movq -0x120(%rbp), %rdi
callq 0x4270
leaq -0xd8(%rbp), %rdi
callq 0x4270
movq -0x118(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x4050
movl %eax, -0x10c(%rbp)
jmp 0x1af7e
movl -0x10c(%rbp), %eax
cmpl $0x0, %eax
setl %al
movb %al, -0x121(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x4270
leaq -0x28(%rbp), %rdi
callq 0x4270
movb -0x121(%rbp), %al
andb $0x1, %al
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x1b00d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4270
jmp 0x1b00d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x1b001
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x4270
leaq -0x98(%rbp), %rdi
callq 0x4270
leaq -0x28(%rbp), %rdi
callq 0x4270
movq -0x70(%rbp), %rdi
callq 0x46c0
nop
// File: afinit[P]afin/readlist.cpp
// Function: Readlist::get_read_range(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
tuple<long,long,long,long> Readlist::get_read_range( string read_seg ){
  try{
    return read_range.at(read_seg);
  }
  catch( const out_of_range& e ){
    return make_tuple( -1,-1,-1,-1 );
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x70(%rbp)
movq %rsi, %rax
movq -0x70(%rbp), %rsi
movq %rdi, -0x68(%rbp)
movq %rdi, %rcx
movq %rcx, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bc70
movq %rax, -0x58(%rbp)
jmp 0x1b0e9
movq -0x68(%rbp), %rax
movq -0x58(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
jmp 0x1b199
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1b1a3
movq -0x20(%rbp), %rdi
callq 0x4190
movq %rax, -0x30(%rbp)
movl $0xffffffff, -0x44(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x48(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x4c(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x50(%rbp) # imm = 0xFFFFFFFF
leaq -0x40(%rbp), %rdi
leaq -0x44(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x4c(%rbp), %rcx
leaq -0x50(%rbp), %r8
callq 0x1bca0
jmp 0x1b170
movq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1bcf0
callq 0x4650
jmp 0x1b199
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4650
jmp 0x1b197
jmp 0x1b1a3
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x46c0
movq %rax, %rdi
callq 0x6c90
nopw %cs:(%rax,%rax)
// File: afinit[P]afin/readlist.cpp
// Function: void Readlist::merge_sort<__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, bool (*)(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, __gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, bool (*)(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>))
void Readlist::merge_sort( Iter first, Iter last, Order order ){
  if (last - first > 1){
    Iter middle = first + (last - first)/2;
    merge_sort( first, middle, order );
    merge_sort( middle, last, order );
    inplace_merge( first, middle, last, order );
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x1d4e0
cmpq $0x1, %rax
jle 0x1b695
leaq -0x10(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x1d4e0
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rsi
leaq -0x8(%rbp), %rdi
callq 0x1d520
movq -0x68(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x1b5c0
movq -0x68(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x1b5c0
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rcx
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0x1d560
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: afinit[P]afin/extension.cpp
// Function: Extension::Extension(Readlist*, int)
Extension::Extension( Readlist *reads, int len ) : reads(reads), len(len), matches(Match(reads)){
  start = -1;
  missed_bp_tot = 0;
  missed_bp_avg = 0;
  back = false;
  contig = "";
  exten_seq = "";
  pos_mult = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
callq 0x171e0
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, 0x48(%rdi)
addq $0x50, %rdi
movq %rdi, -0x50(%rbp)
callq 0x25c00
movq -0x38(%rbp), %rdi
addq $0x68, %rdi
movq %rdi, -0x48(%rbp)
callq 0x152a0
movq -0x38(%rbp), %rdi
addq $0x88, %rdi
movq %rdi, -0x30(%rbp)
callq 0x4550
movq -0x38(%rbp), %rdi
addq $0xa8, %rdi
movq %rdi, -0x40(%rbp)
callq 0x4550
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %ecx
movl %ecx, 0xcc(%rax)
movl $0xffffffff, 0x80(%rax) # imm = 0xFFFFFFFF
movl $0x0, 0xd0(%rax)
movl $0x0, 0xd4(%rax)
movb $0x0, 0x84(%rax)
leaq 0x76de(%rip), %rsi      # 0x2c1b8
callq 0x4520
jmp 0x24ae1
movq -0x58(%rbp), %rdi
addq $0xa8, %rdi
leaq 0x76c5(%rip), %rsi      # 0x2c1b8
callq 0x4520
jmp 0x24afa
movq -0x58(%rbp), %rax
movl $0xffffffff, 0xc8(%rax) # imm = 0xFFFFFFFF
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4270
movq -0x30(%rbp), %rdi
callq 0x4270
movq -0x48(%rbp), %rdi
callq 0x6b60
movq -0x50(%rbp), %rdi
callq 0x6bc0
movq -0x38(%rbp), %rdi
callq 0x6c20
movq -0x20(%rbp), %rdi
callq 0x46c0
// File: afinit[P]afin/extension.cpp
// Function: Extension::Extension(Readlist*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Extension::Extension( Readlist *reads, int len, string contig ) : reads(reads), len(len), matches(Match(reads,contig)){
  start = -1;
  missed_bp_tot = 0;
  missed_bp_avg = 0;
  back = false;
  contig = "";
  exten_seq = "";
  pos_mult = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rcx, -0x80(%rbp)
movq %rsi, %rax
movq -0x80(%rbp), %rsi
movq %rsi, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x41b0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x17270
jmp 0x24bad
leaq -0x40(%rbp), %rdi
callq 0x4270
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, 0x48(%rdi)
addq $0x50, %rdi
movq %rdi, -0xa0(%rbp)
callq 0x25c00
movq -0x70(%rbp), %rdi
addq $0x68, %rdi
movq %rdi, -0x98(%rbp)
callq 0x152a0
movq -0x70(%rbp), %rdi
addq $0x88, %rdi
movq %rdi, -0x90(%rbp)
callq 0x4550
movq -0x70(%rbp), %rdi
addq $0xa8, %rdi
movq %rdi, -0x88(%rbp)
callq 0x4550
movq -0x70(%rbp), %rax
movq -0x78(%rbp), %rdi
movl -0x14(%rbp), %ecx
movl %ecx, 0xcc(%rax)
movl $0xffffffff, 0x80(%rax) # imm = 0xFFFFFFFF
movl $0x0, 0xd0(%rax)
movl $0x0, 0xd4(%rax)
movb $0x0, 0x84(%rax)
leaq 0x7567(%rip), %rsi      # 0x2c1b8
callq 0x4520
jmp 0x24c58
movq -0x70(%rbp), %rdi
addq $0xa8, %rdi
leaq 0x754e(%rip), %rsi      # 0x2c1b8
callq 0x4520
jmp 0x24c71
movq -0x70(%rbp), %rax
movl $0xffffffff, 0xc8(%rax) # imm = 0xFFFFFFFF
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4270
jmp 0x24ce4
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x4270
movq -0x90(%rbp), %rdi
callq 0x4270
movq -0x98(%rbp), %rdi
callq 0x6b60
movq -0xa0(%rbp), %rdi
callq 0x6bc0
movq -0x68(%rbp), %rdi
callq 0x6c20
movq -0x48(%rbp), %rdi
callq 0x46c0
nopl (%rax)
// File: afinit[P]afin/extension.cpp
// Function: Extension::error_removal()
bool Extension::error_removal(){
  int start_size = (int)matches.get_matchlist_size();
  for( int i=0; i<missed_bp.size(); i++ ){
    if( missed_bp[i] > missed_bp_avg ){
      matches.remove_match( i );
      missed_bp.erase( missed_bp.begin() + i );
      i--;
    }
  }
  if( start_size > 5 && matches.get_matchlist_size() < start_size * stop_ext ){
    return false;
  }
  
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x17330
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x40(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x68, %rdi
callq 0x8960
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x253a7
movq -0x40(%rbp), %rdi
addq $0x68, %rdi
movslq -0x18(%rbp), %rsi
callq 0x153d0
movq -0x40(%rbp), %rcx
movl (%rax), %eax
cmpl 0xd4(%rcx), %eax
jle 0x25397
movq -0x40(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x17eb0
movq -0x40(%rbp), %rdi
movq %rdi, %rax
addq $0x68, %rax
movq %rax, -0x50(%rbp)
addq $0x68, %rdi
callq 0x97b0
movq %rax, -0x30(%rbp)
movslq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x99d0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x15460
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x153f0
movq %rax, -0x38(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x25399
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x252f3
cmpl $0x5, -0x14(%rbp)
jle 0x253f9
movq -0x40(%rbp), %rdi
callq 0x17330
movq %rax, %xmm1
movaps 0x6f9e(%rip), %xmm0     # 0x2c360
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movapd 0x6fa2(%rip), %xmm0     # 0x2c370
subpd %xmm0, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
cvtsi2sdl -0x14(%rbp), %xmm0
leaq 0x192f7(%rip), %rax     # 0x3e6e0
mulsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x253f9
movb $0x0, -0x1(%rbp)
jmp 0x253fd
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: afinit[P]afin/contiglist.cpp
// Function: Contiglist::append_contig(int, Contig)
void Contiglist::append_contig( int list_num, Contig cont ){
  if( list_num ){
    contigs_fused.push_back( cont );
  }
  else{
    contigs.push_back( cont );
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdx, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x28288
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0x28a90
jmp 0x28299
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x28a90
addq $0x30, %rsp
popq %rbp
retq
nop
// File: afinit[P]afin/contiglist.cpp
// Function: Contiglist::parse_ids()
void Contiglist::parse_ids(){
  for( int i=0; i<contigs.size(); i++ ){
    string contig_id = contigs[i].get_contig_id(); 
    size_t pos = contig_id.find( "_", 5, 1 );

    if( pos != string::npos ){
      contig_id = contig_id.substr( 0, pos );
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x70(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x78(%rbp)
addq $0x8, %rdi
callq 0x28940
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x28382
movq -0x70(%rbp), %rdi
addq $0x8, %rdi
movslq -0xc(%rbp), %rsi
callq 0x28920
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x5e80
leaq -0x30(%rbp), %rdi
leaq 0x4078(%rip), %rsi      # 0x2c383
movl $0x5, %edx
movl $0x1, %ecx
callq 0x46b0
movq %rax, -0x38(%rbp)
cmpq $-0x1, -0x38(%rbp)
je 0x2836b
movq -0x38(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x43e0
jmp 0x2833c
leaq -0x30(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x4480
leaq -0x58(%rbp), %rdi
callq 0x4270
jmp 0x2836b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4270
jmp 0x2838b
leaq -0x30(%rbp), %rdi
callq 0x4270
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x282be
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x46c0
nopw %cs:(%rax,%rax)
// File: sharmaeklavya2[P]ddos-on-anycast/src/lib/network.cpp
// Function: Network::init(int, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>> const&, bool, int)
void Network::init(int n, const ipvec& edges, bool virtual_parent, int side_connectivity) {
    // if side_connectivity is positive, that many side_links are made for each edge
    // otherwise in_links are used.
    int vparent = -1;
    depthwise.resize(1);
    if(virtual_parent) {
        vparent = 0;
        make_new_vertices(1, -1);
        depthwise[0].push_back(0);
    }
    int ufirst = vparent + 1;
    int uend = ufirst + n;
    make_new_vertices(n, vparent);
    for(int i=ufirst; i<uend; ++i) {
        depthwise[0].push_back(i);
    }

    for(const iipair& p: edges) {
        int u = ufirst + p.first, v = ufirst + p.second;
        if(side_connectivity > 0) {
            for(int i=0; i<side_connectivity; ++i) {
                add_side_edge(u, v);
            }
        }
        else {
            add_in_edge(u, v);
        }
    }
}

// Assembly:
subq $0x78, %rsp
movb %cl, %al
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movq %rdx, 0x60(%rsp)
andb $0x1, %al
movb %al, 0x5f(%rsp)
movl %r8d, 0x58(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
addq $0xa8, %rdi
movl $0x1, %esi
callq 0x4600
testb $0x1, 0x5f(%rsp)
je 0x25df
movq 0x8(%rsp), %rdi
movl $0x0, 0x54(%rsp)
movl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2720
movq 0x8(%rsp), %rdi
addq $0xa8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x46a0
movq %rax, %rdi
movl $0x0, 0x50(%rsp)
leaq 0x50(%rsp), %rsi
callq 0x46c0
movq 0x8(%rsp), %rdi
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
addl 0x6c(%rsp), %eax
movl %eax, 0x48(%rsp)
movl 0x6c(%rsp), %esi
movl 0x54(%rsp), %edx
callq 0x2720
movl 0x4c(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
cmpl 0x48(%rsp), %eax
jge 0x2649
movq 0x8(%rsp), %rdi
addq $0xa8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x46a0
movq %rax, %rdi
leaq 0x44(%rsp), %rsi
callq 0x46f0
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x2610
movq 0x60(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x4760
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x4790
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x47c0
testb $0x1, %al
jne 0x2689
jmp 0x2714
leaq 0x30(%rsp), %rdi
callq 0x4800
movq %rax, 0x20(%rsp)
movl 0x4c(%rsp), %eax
movq 0x20(%rsp), %rcx
addl (%rcx), %eax
movl %eax, 0x1c(%rsp)
movl 0x4c(%rsp), %eax
movq 0x20(%rsp), %rcx
addl 0x4(%rcx), %eax
movl %eax, 0x18(%rsp)
cmpl $0x0, 0x58(%rsp)
jle 0x26f1
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x58(%rsp), %eax
jge 0x26ef
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0x2870
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x26c6
jmp 0x2703
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0x28d0
jmp 0x2705
leaq 0x30(%rsp), %rdi
callq 0x4810
jmp 0x2671
addq $0x78, %rsp
retq
nopl (%rax)
// File: sharmaeklavya2[P]ddos-on-anycast/src/lib/network.cpp
// Function: Network::make_new_vertices(int, int)
int Network::make_new_vertices(int k, int _nid) {
    // insert k new physical nodes in the network whose network id is _nid
    // doesn't fill 'depthwise'
    int u = size();
    int uend = u+k;
    nid.resize(uend, _nid);
    netsize.resize(uend, 0);
    if(_nid >= 0) {
        netsize[_nid] += k;
        depth.resize(uend, depth[_nid]);
    }
    else {
        depth.resize(uend, 0);
    }

    in_nbrs.resize(uend);
    side_nbrs.resize(uend);
    up_nbrs.resize(uend);
    down_nbrs.resize(uend);
    return u;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x4950
movq 0x20(%rsp), %rdi
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addl 0x3c(%rsp), %eax
movl %eax, 0x30(%rsp)
movslq 0x30(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x4b40
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movslq 0x30(%rsp), %rsi
movl $0x0, 0x2c(%rsp)
leaq 0x2c(%rsp), %rdx
callq 0x4b40
cmpl $0x0, 0x38(%rsp)
jl 0x27eb
movq 0x20(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x18, %rdi
movslq 0x38(%rsp), %rsi
callq 0x4860
movl 0xc(%rsp), %ecx
movq 0x20(%rsp), %rdi
addl (%rax), %ecx
movl %ecx, (%rax)
movq %rdi, %rax
addq $0x30, %rax
movq %rax, 0x10(%rsp)
movslq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x30, %rdi
movslq 0x38(%rsp), %rsi
callq 0x4860
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
callq 0x4b40
jmp 0x280b
movq 0x20(%rsp), %rdi
addq $0x30, %rdi
movslq 0x30(%rsp), %rsi
movl $0x0, 0x28(%rsp)
leaq 0x28(%rsp), %rdx
callq 0x4b40
movq 0x20(%rsp), %rdi
addq $0x48, %rdi
movslq 0x30(%rsp), %rsi
callq 0x4600
movq 0x20(%rsp), %rdi
addq $0x60, %rdi
movslq 0x30(%rsp), %rsi
callq 0x4600
movq 0x20(%rsp), %rdi
addq $0x78, %rdi
movslq 0x30(%rsp), %rsi
callq 0x4600
movq 0x20(%rsp), %rdi
addq $0x90, %rdi
movslq 0x30(%rsp), %rsi
callq 0x4600
movl 0x34(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: sharmaeklavya2[P]ddos-on-anycast/src/lib/network.cpp
// Function: Network::add_upward_edge(int, int)
void Network::add_upward_edge(int u, int v) {
    insert(up_nbrs[u], v);
    insert(down_nbrs[v], u);
    if(is_virtual(v)) {
        fprintf(stderr, "virtual node %d got a child %d\n", v, u);
    }
    if(depth[u] != depth[v] + 1) {
        fprintf(stderr, "Depth of lower node %d is %d, depth of upper node %d is %d\n",
            u, depth[u], v, depth[v]);
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x20(%rsp)
addq $0x78, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x46a0
movq %rax, %rdi
movl 0x28(%rsp), %esi
callq 0x2930
movq 0x20(%rsp), %rdi
addq $0x90, %rdi
movslq 0x28(%rsp), %rsi
callq 0x46a0
movq %rax, %rdi
movl 0x2c(%rsp), %esi
callq 0x2930
movq 0x20(%rsp), %rdi
movl 0x28(%rsp), %esi
callq 0x4830
testb $0x1, %al
jne 0x29cb
jmp 0x29eb
movq 0x2a5f6(%rip), %rax     # 0x2cfc8
movq (%rax), %rdi
movl 0x28(%rsp), %edx
movl 0x2c(%rsp), %ecx
leaq 0x1e630(%rip), %rsi     # 0x21014
movb $0x0, %al
callq 0x2180
movq 0x20(%rsp), %rdi
addq $0x30, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x4860
movq 0x20(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
addq $0x30, %rdi
movslq 0x28(%rsp), %rsi
callq 0x4860
movq %rax, %rcx
movl 0x1c(%rsp), %eax
movl (%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
je 0x2a95
movq 0x20(%rsp), %rdi
movq 0x2a595(%rip), %rax     # 0x2cfc8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x10(%rsp)
addq $0x30, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x4860
movq 0x20(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x14(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x18(%rsp)
addq $0x30, %rdi
movslq 0x28(%rsp), %rsi
callq 0x4860
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %edx
movl 0x14(%rsp), %ecx
movl 0x18(%rsp), %r8d
movl (%rax), %r9d
leaq 0x1e5a6(%rip), %rsi     # 0x21034
movb $0x0, %al
callq 0x2180
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: sharmaeklavya2[P]ddos-on-anycast/src/lib/network.cpp
// Function: Network::num_vertices() const
int Network::num_vertices() const {
    // returns the number of physical nodes
    int n = 0;
    for(int s: netsize) {
        if(s == 0) {
            n++;
        }
    }
    return n;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movl $0x0, 0x2c(%rsp)
addq $0x18, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4880
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x48b0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x48e0
testb $0x1, %al
jne 0x2af2
jmp 0x2b22
leaq 0x18(%rsp), %rdi
callq 0x4920
movl (%rax), %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x2b14
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x2b16
leaq 0x18(%rsp), %rdi
callq 0x4930
jmp 0x2add
movl 0x2c(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: sharmaeklavya2[P]ddos-on-anycast/src/lib/network.cpp
// Function: Network::num_edges() const
int Network::num_edges() const {
    // returns the number of edges between physical nodes
    int m = 0;
    for(int u=0; u<size(); ++u) {
        if(netsize[u] == 0) {
            m += degree(u);
        }
    }
    if(m % 2 != 0) {
        fprintf(stderr, "Degree sum is odd.\n");
    }
    return m / 2;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x4950
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x2bac
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movslq 0x18(%rsp), %rsi
callq 0x4970
cmpl $0x0, (%rax)
jne 0x2b9d
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x4990
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0x2b9f
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x2b53
movl 0x1c(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x2bd5
movq 0x2a404(%rip), %rax     # 0x2cfc8
movq (%rax), %rdi
leaq 0x1e4a2(%rip), %rsi     # 0x21070
movb $0x0, %al
callq 0x2180
movl 0x1c(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: sharmaeklavya2[P]ddos-on-anycast/src/lib/network.cpp
// Function: Network::print(std::ostream&) const
void Network::print(ostream& os) const {
    os << "Network"
        << "(\n        nid = " << nid
        << ",\n    netsize = " << netsize
        << "(\n      depth = " << depth
        << ",\n    in_nbrs = " << in_nbrs
        << ",\n  side_nbrs = " << side_nbrs
        << ",\n    up_nbrs = " << up_nbrs
        << ",\n  down_nbrs = " << down_nbrs
        << "\n)\n";
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
leaq 0x1e071(%rip), %rsi     # 0x21084
callq 0x2140
movq %rax, %rdi
leaq 0x1e06a(%rip), %rsi     # 0x2108c
callq 0x2140
movq (%rsp), %rsi
movq %rax, %rdi
callq 0x4ce0
movq %rax, %rdi
leaq 0x1e060(%rip), %rsi     # 0x2109d
callq 0x2140
movq (%rsp), %rsi
movq %rax, %rdi
addq $0x18, %rsi
callq 0x4ce0
movq %rax, %rdi
leaq 0x1e052(%rip), %rsi     # 0x210ae
callq 0x2140
movq (%rsp), %rsi
movq %rax, %rdi
addq $0x30, %rsi
callq 0x4ce0
movq %rax, %rdi
leaq 0x1e044(%rip), %rsi     # 0x210bf
callq 0x2140
movq (%rsp), %rsi
movq %rax, %rdi
addq $0x48, %rsi
callq 0x4c00
movq %rax, %rdi
leaq 0x1e036(%rip), %rsi     # 0x210d0
callq 0x2140
movq (%rsp), %rsi
movq %rax, %rdi
addq $0x60, %rsi
callq 0x4c00
movq %rax, %rdi
leaq 0x1e028(%rip), %rsi     # 0x210e1
callq 0x2140
movq (%rsp), %rsi
movq %rax, %rdi
addq $0x78, %rsi
callq 0x4c00
movq %rax, %rdi
leaq 0x1e01a(%rip), %rsi     # 0x210f2
callq 0x2140
movq (%rsp), %rsi
movq %rax, %rdi
addq $0x90, %rsi
callq 0x4c00
movq %rax, %rdi
leaq 0x1e009(%rip), %rsi     # 0x21103
callq 0x2140
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: sharmaeklavya2[P]ddos-on-anycast/src/lib/network.cpp
// Function: Network::basic_sanity_check() const
bool Network::basic_sanity_check() const {
    // sizes of all lists should be the same
    size_t sizes[7] = {nid.size(), depth.size(), netsize.size(),
        in_nbrs.size(), side_nbrs.size(), up_nbrs.size(), down_nbrs.size()};
    for(int i=0; i<6; ++i) {
        if(sizes[i] != sizes[i+1]) {
            fprintf(stderr, "sizes of lists %d and %d differ\n", i, i+1);
            return false;
        }
    }
    int s = 0;
    for(int i=0; i<=height(); ++i) {
        s += depthwise[i].size();
    }
    if(s != size()) {
        fprintf(stderr, "depthwise node-count sum doesn't equal total node-count\n");
        return false;
    }
    return true;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4f00
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x30, %rdi
callq 0x4f00
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
addq $0x18, %rdi
callq 0x4f00
movq 0x8(%rsp), %rdi
movq %rax, 0x30(%rsp)
addq $0x48, %rdi
callq 0x4ee0
movq 0x8(%rsp), %rdi
movq %rax, 0x38(%rsp)
addq $0x60, %rdi
callq 0x4ee0
movq 0x8(%rsp), %rdi
movq %rax, 0x40(%rsp)
addq $0x78, %rdi
callq 0x4ee0
movq 0x8(%rsp), %rdi
movq %rax, 0x48(%rsp)
addq $0x90, %rdi
callq 0x4ee0
movq %rax, 0x50(%rsp)
movl $0x0, 0x1c(%rsp)
cmpl $0x6, 0x1c(%rsp)
jge 0x3538
movslq 0x1c(%rsp), %rax
movq 0x20(%rsp,%rax,8), %rax
movl 0x1c(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpq 0x20(%rsp,%rcx,8), %rax
je 0x3529
movq 0x29ac5(%rip), %rax     # 0x2cfc8
movq (%rax), %rdi
movl 0x1c(%rsp), %edx
movl 0x1c(%rsp), %ecx
addl $0x1, %ecx
leaq 0x1dc69(%rip), %rsi     # 0x21181
movb $0x0, %al
callq 0x2180
movb $0x0, 0x67(%rsp)
jmp 0x35dc
jmp 0x352b
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x34da
movl $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x4f20
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jg 0x359e
movq 0x8(%rsp), %rdi
addq $0xa8, %rdi
movslq 0x14(%rsp), %rsi
callq 0x4a60
movq %rax, %rdi
callq 0x4f00
movq %rax, %rcx
movslq 0x18(%rsp), %rax
addq %rcx, %rax
movl %eax, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x3548
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, (%rsp)
callq 0x4950
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
je 0x35d7
movq 0x29a09(%rip), %rax     # 0x2cfc8
movq (%rax), %rdi
leaq 0x1dbd9(%rip), %rsi     # 0x211a2
movb $0x0, %al
callq 0x2180
movb $0x0, 0x67(%rsp)
jmp 0x35dc
movb $0x1, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: sharmaeklavya2[P]ddos-on-anycast/src/lib/prettyprint.hpp
// Function: std::ostream& std::operator<<<std::vector<int, std::allocator<int>>>(std::ostream&, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&)
ostream& operator<<(ostream& os, const std::vector<T>& v) {
        os << "[";
        if(!v.empty()) {
            os << v[0];
        }
        for(int i=1; i < int(v.size()); ++i) {
            os << ", " << v[i];
        }
        os << "]";
        return os;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x1c8f4(%rip), %rsi     # 0x2150e
callq 0x2140
movq 0x28(%rsp), %rdi
callq 0x86f0
testb $0x1, %al
jne 0x4c52
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4a60
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x4ce0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
callq 0x4ee0
movq %rax, %rcx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0x4cb6
movq 0x30(%rsp), %rdi
leaq 0x1c4b8(%rip), %rsi     # 0x2113b
callq 0x2140
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x4a60
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x4ce0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x4c5a
movq 0x30(%rsp), %rdi
leaq 0x1c78a(%rip), %rsi     # 0x2144c
callq 0x2140
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: sharmaeklavya2[P]ddos-on-anycast/src/lib/network_grow.cpp
// Function: Network::hgrow(GraphGen&, int)
void Network::hgrow(GraphGen& graph_gen, int seed) {
    rng_t rng(seed);
    ivec leaves(depthwise.back().begin(), depthwise.back().end());
    for(int u: leaves) {
        if(!is_virtual(u)) {
            expand_node(u, graph_gen, rng());
        }
    }
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movl %edx, 0xa4(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x20(%rsp)
movslq 0xa4(%rsp), %rsi
leaq 0x98(%rsp), %rdi
callq 0x9f10
movq 0x20(%rsp), %rdi
addq $0xa8, %rdi
movq %rdi, 0x28(%rsp)
callq 0xa0d0
movq %rax, %rdi
callq 0x5bf0
movq 0x28(%rsp), %rdi
movq %rax, 0x78(%rsp)
callq 0xa0d0
movq %rax, %rdi
callq 0x5a70
movq %rax, 0x70(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x4f40
movq 0x30(%rsp), %rcx
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
leaq 0x80(%rsp), %rdi
callq 0xa110
jmp 0x93c7
leaq 0x6f(%rsp), %rdi
callq 0x4fd0
leaq 0x80(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x5bf0
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x5a70
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x9fe0
testb $0x1, %al
jne 0x9414
jmp 0x94d5
leaq 0x48(%rsp), %rdi
callq 0xa020
movq 0x20(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %esi
callq 0x4830
movb %al, 0x1f(%rsp)
jmp 0x9438
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x94c4
jmp 0x9446
movl 0x3c(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x9f40
movq %rax, 0x10(%rsp)
jmp 0x946f
movq 0x8(%rsp), %rdx
movl 0x4(%rsp), %esi
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movl %eax, %ecx
callq 0x8a40
jmp 0x948b
jmp 0x94c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x6f(%rsp), %rdi
callq 0x4fd0
jmp 0x94ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x5020
jmp 0x94ea
jmp 0x94c6
leaq 0x48(%rsp), %rdi
callq 0xa0b0
jmp 0x93fc
leaq 0x80(%rsp), %rdi
callq 0x5020
addq $0xb8, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x21f0
nopw %cs:(%rax,%rax)
// File: sharmaeklavya2[P]ddos-on-anycast/src/lib/sample.hpp
// Function: do_sigma_n(int, double, std::linear_congruential_engine<unsigned long, 48271ul, 0ul, 2147483647ul>&)
MAYBE_INLINE int do_sigma_n(int n, double sigma, rng_t& rng) {
    if(sigma == 0.0) {
        return n;
    }
    else {
        return std::max(1, int(n * std::normal_distribution<double>(1.0, sigma)(rng)));
    }
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movsd 0x38(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x9dde
jp 0x9dde
movl 0x40(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x9e41
movl $0x1, 0x2c(%rsp)
cvtsi2sdl 0x40(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x38(%rsp), %xmm1
leaq 0x8(%rsp), %rdi
movsd 0x17684(%rip), %xmm0    # 0x21488
callq 0xad80
movq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0xadd0
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x28(%rsp)
leaq 0x2c(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xad40
movl (%rax), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: sharmaeklavya2[P]ddos-on-anycast/src/lib/util.hpp
// Function: bool find_and_erase<std::vector<int, std::allocator<int>>>(std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>::value_type)
inline bool find_and_erase(C& c, typename C::value_type x) {
    typename C::const_iterator it = find(c, x);
    if(it == c.end()) {
        return false;
    }
    else {
        c.erase(it);
        return true;
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x9e90
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x5a70
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xb840
testb $0x1, %al
jne 0xa074
jmp 0xa07b
movb $0x0, 0x37(%rsp)
jmp 0xa09d
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
callq 0xb880
movq %rax, (%rsp)
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: sharmaeklavya2[P]ddos-on-anycast/src/lib/network.hpp
// Function: Network::reserve(int)
void reserve(int n) {
        nid.reserve(n);
        netsize.reserve(n);
        depth.reserve(n);
        in_nbrs.reserve(n);
        side_nbrs.reserve(n);
        up_nbrs.reserve(n);
        down_nbrs.reserve(n);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movslq 0xc(%rsp), %rsi
callq 0xa200
movq (%rsp), %rdi
addq $0x18, %rdi
movslq 0xc(%rsp), %rsi
callq 0xa200
movq (%rsp), %rdi
addq $0x30, %rdi
movslq 0xc(%rsp), %rsi
callq 0xa200
movq (%rsp), %rdi
addq $0x48, %rdi
movslq 0xc(%rsp), %rsi
callq 0xac10
movq (%rsp), %rdi
addq $0x60, %rdi
movslq 0xc(%rsp), %rsi
callq 0xac10
movq (%rsp), %rdi
addq $0x78, %rdi
movslq 0xc(%rsp), %rsi
callq 0xac10
movq (%rsp), %rdi
addq $0x90, %rdi
movslq 0xc(%rsp), %rsi
callq 0xac10
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: sharmaeklavya2[P]ddos-on-anycast/src/lib/sample.hpp
// Function: std::vector<int, std::allocator<int>>::value_type sample<std::vector<int, std::allocator<int>>>(std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&, std::linear_congruential_engine<unsigned long, 48271ul, 0ul, 2147483647ul>&)
inline typename C::value_type sample(const C& v1, const C& v2, rng_t& rng) {
    int i = iunidist(0, v1.size() + v2.size() - 1, rng);
    if(v1.size() + v2.size() == 0) {
        fprintf(stderr, "sample: both containers are empty\n");
    }
    if(i < int(v1.size())) {
        return ord_stat(v1, i);
    }
    else {
        return ord_stat(v2, i-v1.size());
    }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
callq 0x4f00
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
callq 0x4f00
movq %rax, %rcx
movq 0x20(%rsp), %rax
addq %rcx, %rax
subq $0x1, %rax
movl %eax, %esi
movq 0x38(%rsp), %rdx
xorl %edi, %edi
callq 0x92e0
movl %eax, 0x34(%rsp)
movq 0x48(%rsp), %rdi
callq 0x4f00
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
callq 0x4f00
movq %rax, %rcx
movq 0x28(%rsp), %rax
addq %rcx, %rax
cmpq $0x0, %rax
jne 0xa43f
movq 0x22b9a(%rip), %rax     # 0x2cfc8
movq (%rax), %rdi
leaq 0x17168(%rip), %rsi     # 0x215a0
movb $0x0, %al
callq 0x2180
movl 0x34(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x48(%rsp), %rdi
callq 0x4f00
movq %rax, %rcx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
jge 0xa470
movq 0x48(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x9ee0
movl %eax, 0x54(%rsp)
jmp 0xa4a9
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movslq 0x34(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x4f00
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movq 0x10(%rsp), %rax
subq %rcx, %rax
movl %eax, %esi
callq 0x9ee0
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: sharmaeklavya2[P]ddos-on-anycast/src/lib/sample.hpp
// Function: std::vector<int, std::allocator<int>>::value_type sample<std::vector<int, std::allocator<int>>>(std::vector<int, std::allocator<int>> const&, std::linear_congruential_engine<unsigned long, 48271ul, 0ul, 2147483647ul>&)
inline typename C::value_type sample(const C& v, rng_t& rng) {
    if(v.empty()) {
        fprintf(stderr, "sample: container is empty\n");
    }
    int i = iunidist(0, v.size() - 1, rng);
    return ord_stat(v, i);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x86a0
testb $0x1, %al
jne 0xa53e
jmp 0xa556
movq 0x22a83(%rip), %rax     # 0x2cfc8
movq (%rax), %rdi
leaq 0x17074(%rip), %rsi     # 0x215c3
movb $0x0, %al
callq 0x2180
movq 0x10(%rsp), %rdi
callq 0x4f00
subq $0x1, %rax
movl %eax, %esi
movq 0x8(%rsp), %rdx
xorl %edi, %edi
callq 0x92e0
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x9ee0
addq $0x18, %rsp
retq
nopl (%rax)
// File: sharmaeklavya2[P]ddos-on-anycast/src/lib/sample.hpp
// Function: std::vector<int, std::allocator<int>>::value_type sample_other<std::vector<int, std::allocator<int>>>(std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>>::value_type, std::linear_congruential_engine<unsigned long, 48271ul, 0ul, 2147483647ul>&)
inline typename C::value_type sample_other(const C& v, typename C::value_type x, rng_t& rng) {
    if(v.empty()) {
        // fprintf(stderr, "sample_other: container is empty\n");
        return x;
    }
    bool all_x = true;
    for(auto y: v) {
        if(y != x) {
            all_x = false;
            break;
        }
    }
    if(all_x) {
        // fprintf(stderr, "sample_other: container contains no other element\n");
        return x;
    }
    typename C::value_type y = x;
    while(y == x) {
        y = sample(v, rng);
    }
    return y;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x86a0
testb $0x1, %al
jne 0xa892
jmp 0xa89f
movl 0x34(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0xa94c
movb $0x1, 0x27(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4880
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x48b0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x48e0
testb $0x1, %al
jne 0xa8e1
jmp 0xa910
leaq 0x10(%rsp), %rdi
callq 0x4920
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x34(%rsp), %eax
je 0xa902
movb $0x0, 0x27(%rsp)
jmp 0xa910
jmp 0xa904
leaq 0x10(%rsp), %rdi
callq 0x4930
jmp 0xa8cc
testb $0x1, 0x27(%rsp)
je 0xa921
movl 0x34(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0xa94c
movl 0x34(%rsp), %eax
movl %eax, (%rsp)
movl (%rsp), %eax
cmpl 0x34(%rsp), %eax
jne 0xa945
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xa520
movl %eax, (%rsp)
jmp 0xa928
movl (%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: sharmaeklavya2[P]ddos-on-anycast/src/lib/graph_gen.cpp
// Function: make_cycle_graph(int, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>&)
void make_cycle_graph(int n, ipvec& l) {
    // iipair st_graph[] = {{0, 1}, {1, 2}, {2, 3}, {3, 0}, {3, 4}, {0, 5}};
    l.emplace_back(n-1, 0);
    for(int i=1; i<n; ++i) {
        l.emplace_back(i-1, i);
    }
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
leaq 0x14(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0xcd90
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0xc372
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
leaq 0xc(%rsp), %rdx
callq 0xce10
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xc33c
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: sharmaeklavya2[P]ddos-on-anycast/src/lib/dsu.hpp
// Function: DisjointSets::find(int)
int find(int x) {
        if(parent[x] == x) {
            return x;
        }
        else {
            int p = find(parent[x]);
            parent[x] = p;
            return p;
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x20, %rdi
movslq 0x14(%rsp), %rsi
callq 0x4860
movl (%rax), %eax
cmpl 0x14(%rsp), %eax
jne 0xd617
movl 0x14(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0xd663
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
movslq 0x14(%rsp), %rsi
callq 0x4860
movq 0x8(%rsp), %rdi
movl (%rax), %esi
callq 0xd5e0
movq 0x8(%rsp), %rdi
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x4(%rsp)
addq $0x20, %rdi
movslq 0x14(%rsp), %rsi
callq 0x4860
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
movl 0x10(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: sharmaeklavya2[P]ddos-on-anycast/src/lib/dsu.hpp
// Function: DisjointSets::unite(int, int)
void unite(int x, int y) {
        x = find(x);
        y = find(y);
        if(subsize[x] > subsize[y]) {
            std::swap(x, y);
        }
        parent[x] = y;
        subsize[y] += subsize[x];
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0x1c(%rsp), %esi
callq 0xd5e0
movq 0x8(%rsp), %rdi
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %esi
callq 0xd5e0
movq 0x8(%rsp), %rdi
movl %eax, 0x18(%rsp)
addq $0x8, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x4860
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x14(%rsp)
addq $0x8, %rdi
movslq 0x18(%rsp), %rsi
callq 0x4860
movq %rax, %rcx
movl 0x14(%rsp), %eax
cmpl (%rcx), %eax
jle 0xd760
leaq 0x1c(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xe1a0
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, (%rsp)
addq $0x20, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x4860
movl (%rsp), %ecx
movq 0x8(%rsp), %rdi
movl %ecx, (%rax)
addq $0x8, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x4860
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x4(%rsp)
addq $0x8, %rdi
movslq 0x18(%rsp), %rsi
callq 0x4860
movl 0x4(%rsp), %ecx
addl (%rax), %ecx
movl %ecx, (%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: sharmaeklavya2[P]ddos-on-anycast/src/lib/dsu.hpp
// Function: DisjointSets::init(int)
void init(int _n) {
        n = _n;
        subsize.resize(n);
        parent.resize(n);
        for(int i=0; i<n; ++i) {
            parent[i] = i;
            subsize[i] = 1;
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x1c(%rsp), %ecx
movl %ecx, (%rax)
movq %rax, %rdi
addq $0x8, %rdi
movslq (%rax), %rsi
callq 0xdbc0
movq 0x10(%rsp), %rax
movq %rax, %rdi
addq $0x20, %rdi
movslq (%rax), %rsi
callq 0xdbc0
movl $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rcx
movl 0x18(%rsp), %eax
cmpl (%rcx), %eax
jge 0xdbac
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x20, %rdi
movslq 0x18(%rsp), %rsi
callq 0x4860
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rdi
movl %ecx, (%rax)
addq $0x8, %rdi
movslq 0x18(%rsp), %rsi
callq 0x4860
movl $0x1, (%rax)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xdb58
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: sharmaeklavya2[P]ddos-on-anycast/src/lib/attack.cpp
// Function: normalize_edge_weights(int&, int&)
void normalize_edge_weights(int& in_weight, int& side_weight) {
    if(in_weight < 0) {
        fprintf(stderr, "in_weight = %d\n", in_weight);
    }
    if(side_weight < 0) {
        fprintf(stderr, "side_weight = %d\n", side_weight);
    }
    if(in_weight == 0) {
        if(side_weight == 0) {
            in_weight = side_weight = 1;
        }
        else {
            in_weight = 1;
            side_weight = -1;
        }
    }
    else if(side_weight == 0) {
        side_weight = 1;
        in_weight = -1;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax)
jge 0x121d7
movq 0x1ae09(%rip), %rax     # 0x2cfc8
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movl (%rax), %edx
leaq 0xf418(%rip), %rsi      # 0x215e8
movb $0x0, %al
callq 0x2180
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax)
jge 0x12200
movq 0x1ade0(%rip), %rax     # 0x2cfc8
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movl (%rax), %edx
leaq 0xf3ff(%rip), %rsi      # 0x215f8
movb $0x0, %al
callq 0x2180
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x12244
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x1222c
movq 0x8(%rsp), %rax
movl $0x1, (%rax)
movq 0x10(%rsp), %rax
movl $0x1, (%rax)
jmp 0x12242
movq 0x10(%rsp), %rax
movl $0x1, (%rax)
movq 0x8(%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0x12266
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x12264
movq 0x8(%rsp), %rax
movl $0x1, (%rax)
movq 0x10(%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0x12266
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: sharmaeklavya2[P]ddos-on-anycast/src/lib/place_victims.cpp
// Function: place_victims_randomly(Network const&, int, std::vector<int, std::allocator<int>>&, int)
void place_victims_randomly(const Network& network, int n, ivec& victims, int seed) {
    victims.reserve(network.depthwise.back().size());
    for(int u: network.depthwise.back()) {
        if(network.netsize[u] == 0) {
            victims.push_back(u);
        }
    }
    n = std::min<int>(n, victims.size());
    std::shuffle(victims.begin(), victims.end(), rng_t(seed));
    victims.resize(n);
    victims.shrink_to_fit();
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq %rdx, 0x50(%rsp)
movl %ecx, 0x4c(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rdi
addq $0xa8, %rdi
callq 0x19d40
movq %rax, %rdi
callq 0x4f00
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xa200
movq 0x60(%rsp), %rdi
addq $0xa8, %rdi
callq 0x19d40
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x4880
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x48b0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x48e0
testb $0x1, %al
jne 0x17adf
jmp 0x17b24
leaq 0x38(%rsp), %rdi
callq 0x4920
movl (%rax), %eax
movl %eax, 0x2c(%rsp)
movq 0x60(%rsp), %rdi
addq $0x18, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x4970
cmpl $0x0, (%rax)
jne 0x17b16
movq 0x50(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0x46f0
jmp 0x17b18
leaq 0x38(%rsp), %rdi
callq 0x4930
jmp 0x17aca
movq 0x50(%rsp), %rdi
callq 0x4f00
movl %eax, 0x28(%rsp)
leaq 0x5c(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x19d80
movl (%rax), %eax
movl %eax, 0x5c(%rsp)
movq 0x50(%rsp), %rdi
callq 0x5bf0
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rdi
callq 0x5a70
movq %rax, 0x18(%rsp)
movslq 0x4c(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x9f10
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x19dc0
movq 0x50(%rsp), %rdi
movslq 0x5c(%rsp), %rsi
callq 0xdbc0
movq 0x50(%rsp), %rdi
callq 0x1a0b0
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)