LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: XDragonSl[P]git-switcher/src/main.cpp
// Function: list()
void list() {
    Store store;
    int size = store.size();
    vector<Profile> profileList = store.getAll();
    for (int i = 0; i < size; i++) {
        cout << left;
        cout << setw(NUMBER_WIDTH) << i + 1;
        cout << setw(NAME_WIDTH) << profileList[i].getName();
        cout << setw(EMAIL_WIDTH) << profileList[i].getEmail();
        cout << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2d0, %rsp            # imm = 0x2D0
leaq -0x230(%rbp), %rdi
movq %rdi, -0x280(%rbp)
callq 0x8d90
movq -0x280(%rbp), %rdi
callq 0x91f0
movl %eax, -0x274(%rbp)
jmp 0x6562
movl -0x274(%rbp), %eax
movl %eax, -0x234(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x90c0
movq %rax, -0x288(%rbp)
jmp 0x6583
movq -0x288(%rbp), %rsi
leaq -0x260(%rbp), %rdi
callq 0x6970
jmp 0x6598
movl $0x0, -0x264(%rbp)
movl -0x264(%rbp), %eax
cmpl -0x234(%rbp), %eax
jge 0x675b
movq 0x9a05(%rip), %rdi      # 0xffc0
leaq 0x49e(%rip), %rsi       # 0x6a60
callq 0x30a0
jmp 0x65c9
movl $0x4, %edi
callq 0x6a90
movl %eax, -0x28c(%rbp)
jmp 0x65db
movl -0x28c(%rbp), %eax
movl %eax, -0x268(%rbp)
movl -0x268(%rbp), %esi
movq 0x99cc(%rip), %rdi      # 0xffc0
callq 0x3270
movq %rax, -0x298(%rbp)
jmp 0x6602
movq -0x298(%rbp), %rdi
movl -0x264(%rbp), %esi
incl %esi
callq 0x33c0
jmp 0x6618
movl $0x30, %edi
callq 0x6a90
movl %eax, -0x29c(%rbp)
jmp 0x662a
movl -0x29c(%rbp), %eax
movl %eax, -0x26c(%rbp)
movl -0x26c(%rbp), %esi
movq 0x997d(%rip), %rdi      # 0xffc0
callq 0x3270
movq %rax, -0x2a8(%rbp)
jmp 0x6651
movslq -0x264(%rbp), %rsi
leaq -0x260(%rbp), %rdi
callq 0x6ab0
movq %rax, %rdi
callq 0x8c40
movq %rax, -0x2b0(%rbp)
jmp 0x6675
movq -0x2b0(%rbp), %rsi
movq -0x2a8(%rbp), %rdi
callq 0x31f0
jmp 0x668a
movl $0x30, %edi
callq 0x6a90
movl %eax, -0x2b4(%rbp)
jmp 0x669c
movl -0x2b4(%rbp), %eax
movl %eax, -0x270(%rbp)
movl -0x270(%rbp), %esi
movq 0x990b(%rip), %rdi      # 0xffc0
callq 0x3270
movq %rax, -0x2c0(%rbp)
jmp 0x66c3
movslq -0x264(%rbp), %rsi
leaq -0x260(%rbp), %rdi
callq 0x6ab0
movq %rax, %rdi
callq 0x8c50
movq %rax, -0x2c8(%rbp)
jmp 0x66e7
movq -0x2c8(%rbp), %rsi
movq -0x2c0(%rbp), %rdi
callq 0x31f0
jmp 0x66fc
movq 0x98bd(%rip), %rdi      # 0xffc0
movq 0x989e(%rip), %rsi      # 0xffa8
callq 0x3240
jmp 0x6711
jmp 0x6713
movl -0x264(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x264(%rbp)
jmp 0x65a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
jmp 0x677c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
leaq -0x260(%rbp), %rdi
callq 0x6ad0
jmp 0x677c
leaq -0x260(%rbp), %rdi
callq 0x6ad0
leaq -0x230(%rbp), %rdi
callq 0x9220
addq $0x2d0, %rsp            # imm = 0x2D0
popq %rbp
retq
leaq -0x230(%rbp), %rdi
callq 0x9220
movq -0x240(%rbp), %rdi
callq 0x33d0
nopw %cs:(%rax,%rax)
nop
// File: XDragonSl[P]git-switcher/src/Options/Options.cpp
// Function: Options::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
const string& Options::get(const string &option) {
    vector<string>::const_iterator itr;
    itr = find(this->tokens.begin(), this->tokens.end(), option);
    if (itr != this->tokens.end() && ++itr != this->tokens.end()){
        return *itr;
    }
    static const string empty_string("");
    return empty_string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7cd0
movq -0x70(%rbp), %rdi
callq 0x7d40
movq -0x70(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x7d70
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdx
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x7cf0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7da0
movq -0x70(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x7d70
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x7de0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x65(%rbp)
jne 0x7b10
jmp 0x7b3a
leaq -0x20(%rbp), %rdi
callq 0x7e20
movq -0x70(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x7d70
movq -0x78(%rbp), %rdi
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x7de0
movb %al, -0x65(%rbp)
movb -0x65(%rbp), %al
testb $0x1, %al
jne 0x7b43
jmp 0x7b55
leaq -0x20(%rbp), %rdi
callq 0x7e40
movq %rax, -0x8(%rbp)
jmp 0x7bf4
cmpb $0x0, 0x89f4(%rip)      # 0x10550
jne 0x7bc4
leaq 0x89eb(%rip), %rdi      # 0x10550
callq 0x33f0
cmpl $0x0, %eax
je 0x7bc4
leaq -0x51(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x33e0
movq -0x80(%rbp), %rdx
leaq 0x89a9(%rip), %rdi      # 0x10530
leaq 0x3771(%rip), %rsi      # 0xb2ff
callq 0x32e0
jmp 0x7b95
leaq -0x51(%rbp), %rdi
callq 0x3260
movq 0x840b(%rip), %rdi      # 0xffb0
leaq 0x8984(%rip), %rsi      # 0x10530
leaq 0x8675(%rip), %rdx      # 0x10228
callq 0x31e0
leaq 0x8991(%rip), %rdi      # 0x10550
callq 0x3190
leaq 0x8965(%rip), %rax      # 0x10530
movq %rax, -0x8(%rbp)
jmp 0x7bf4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x51(%rbp), %rdi
callq 0x3260
leaq 0x8963(%rip), %rdi      # 0x10550
callq 0x3180
jmp 0x7c01
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x33d0
nopw (%rax,%rax)
// File: XDragonSl[P]git-switcher/src/Store/Store.cpp
// Function: Store::~Store()
Store::~Store() {
    if (isChanged) {
        store.open(STORE_LOCATION + STORE_NAME, ios::out);
        for(Profile profile : allProfiles) {
            store << profile.toString() << endl;
        }
        store.close();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
testb $0x1, 0x228(%rax)
je 0x93d3
movq -0xb8(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq 0x72fc(%rip), %rsi      # 0x10558
leaq 0x7315(%rip), %rdx      # 0x10578
leaq -0x28(%rbp), %rdi
callq 0x6c10
jmp 0x926e
movq -0xc0(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0x10, %edx
callq 0x32f0
jmp 0x9285
leaq -0x28(%rbp), %rdi
callq 0x3448
movq -0xb8(%rbp), %rax
addq $0x210, %rax            # imm = 0x210
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x9530
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x95e0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x9610
testb $0x1, %al
jne 0x92cf
jmp 0x93c3
leaq -0x48(%rbp), %rdi
callq 0x9650
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
callq 0x6b60
jmp 0x92e9
movq -0xb8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0xc8(%rbp)
leaq -0xb0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x8c70
jmp 0x9310
movq -0xc8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x31f0
movq %rax, -0xd0(%rbp)
jmp 0x932c
movq -0xd0(%rbp), %rdi
movq 0x6c6e(%rip), %rsi      # 0xffa8
callq 0x3240
jmp 0x9341
leaq -0xb0(%rbp), %rdi
callq 0x3448
leaq -0x90(%rbp), %rdi
callq 0x6b30
leaq -0x48(%rbp), %rdi
callq 0x9670
jmp 0x92b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x93fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3448
jmp 0x93fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x93b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x3448
leaq -0x90(%rbp), %rdi
callq 0x6b30
jmp 0x93fb
movq -0xb8(%rbp), %rdi
callq 0x3050
jmp 0x93d1
jmp 0x93d3
movq -0xb8(%rbp), %rdi
addq $0x210, %rdi            # imm = 0x210
callq 0x6ad0
movq -0xb8(%rbp), %rdi
callq 0x3080
addq $0xd0, %rsp
popq %rbp
retq
movq -0xb8(%rbp), %rdi
addq $0x210, %rdi            # imm = 0x210
callq 0x6ad0
movq -0xb8(%rbp), %rdi
callq 0x3080
movq -0x30(%rbp), %rdi
callq 0x32c0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: matallui[P]nibble-curses/src/CPoint.cpp
// Function: CPoint::operator=(CPoint const&)
CPoint & CPoint::operator = ( CPoint const & src )
{
  if ( &src == this ) return *this;
  
  m_x = src.getX();
  m_y = src.getY();
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq %rax, -0x18(%rbp)
jne 0x3ca8
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3ccf
movq -0x18(%rbp), %rdi
callq 0x3c50
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x3c60
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: matallui[P]nibble-curses/src/CObstacle.cpp
// Function: CObstacle::CObstacle(int const&, int const&, int const&, char const&)
CObstacle::CObstacle ( int const & ox, int const & oy, int const & length, char const & mode )
		      : m_orig ( ox, oy )
{
  m_length = length;
  m_mode = mode;
  m_cp_draw = 2;
  m_cp_erase = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3bd0
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movb (%rcx), %cl
movb %cl, 0xc(%rax)
movl $0x2, 0x10(%rax)
movl $0x1, 0x14(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: matallui[P]nibble-curses/src/CObstacle.cpp
// Function: CObstacle::Update(int const&, int const&, int const&, char const&)
void CObstacle::Update ( int const & ox, int const & oy, int const & length, char const & mode )
{
  m_orig.setX ( ox );
  m_orig.setY ( oy );
  m_length = length;
  m_mode = mode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0x3ce0
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3d00
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movb (%rcx), %cl
movb %cl, 0xc(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: matallui[P]nibble-curses/src/CObstacle.cpp
// Function: CObstacle::Paint() const
void CObstacle::Paint ( void ) const
{
  int x = m_orig.getX();
  int y = m_orig.getY();
  
  switch ( m_mode )
  {
    case 'V':					// draw vertical object starting on the upper point
      for ( int i = 0; i < m_length; i++ )
      {
	move ( x+i, y );
	addch ( ' ' );
      }
      break;
    case 'H':					// draw horizontal object starting on the left
      for ( int i = 0; i < m_length; i++ )
      {
	move ( x, y+i );
	addch ( ' ' );
      }
      break;
    case 'D':					// draw diagonal object starting on the upper-left points
      for ( int i = 0; i < m_length; i++ )
      {
	move ( x+i, y+i );
	addch ( ' ' );
      }
      break;
    case 'I':					// draw dashed vertical object starting from upper point
      for ( int i = 0; i < m_length; i+=2 )
      {
	move ( x+i, y );
	addch ( ' ' );
      }
      break;
  }
  
  refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x3c50
movq -0x30(%rbp), %rdi
movl %eax, -0xc(%rbp)
callq 0x3c60
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x10(%rbp)
movsbl 0xc(%rax), %eax
addl $-0x44, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x12, %eax
ja 0x40b9
movq -0x28(%rbp), %rax
leaq 0x8091(%rip), %rcx      # 0xc030
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x3fe8
movl -0xc(%rbp), %edi
addl -0x14(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x3200
movq 0xc000(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movl $0x20, %esi
callq 0x30e0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3faf
jmp 0x40b9
movl $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x402d
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
addl -0x18(%rbp), %esi
callq 0x3200
movq 0xbfbb(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movl $0x20, %esi
callq 0x30e0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3ff4
jmp 0x40b9
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x4075
movl -0xc(%rbp), %edi
addl -0x1c(%rbp), %edi
movl -0x10(%rbp), %esi
addl -0x1c(%rbp), %esi
callq 0x3200
movq 0xbf73(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movl $0x20, %esi
callq 0x30e0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4039
jmp 0x40b9
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x40b7
movl -0xc(%rbp), %edi
addl -0x20(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x3200
movq 0xbf31(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movl $0x20, %esi
callq 0x30e0
movl -0x20(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x20(%rbp)
jmp 0x407e
jmp 0x40b9
callq 0x34c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: matallui[P]nibble-curses/src/CSnake.cpp
// Function: CSnake::CSnake()
CSnake::CSnake ( void )
{
  m_size = 0;
  m_max_size = 150;
  m_body = new CPoint [150];
  m_head = 0;
  m_tail = 0;
  m_score = 0;
  m_delay = 0;
  m_lives = 5;
  m_direction = '-';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0xb7cd(%rip), %rcx      # 0xfaf8
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, 0x14(%rax)
movl $0x96, 0x10(%rax)
movl $0x4b0, %edi            # imm = 0x4B0
callq 0x3030
movq %rax, -0x38(%rbp)
movq %rax, %rcx
addq $0x4b0, %rcx            # imm = 0x4B0
movq %rcx, -0x30(%rbp)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x3bd0
jmp 0x4385
movq -0x30(%rbp), %rcx
movq -0x48(%rbp), %rax
addq $0x8, %rax
cmpq %rcx, %rax
movq %rax, -0x28(%rbp)
jne 0x4360
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, 0x18(%rax)
movl $0x0, 0x1c(%rax)
movl $0x0, 0x20(%rax)
movl $0x0, 0x2c(%rax)
movl $0x5, 0x24(%rax)
movb $0x2d, 0x28(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x4b0, %esi            # imm = 0x4B0
callq 0x3510
movq -0x18(%rbp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
// File: matallui[P]nibble-curses/src/CSnake.cpp
// Function: CSnake::hasPoint(CPoint const&) const
bool CSnake::hasPoint ( CPoint const & p ) const
{ 
  if ( !m_lives ) return false;
  
  int i = m_head;
  for ( int k = 0; k < m_size; k++ )
  {
    if ( m_body[i] == p ) return true;
    i = (i + (m_max_size - 1)) % m_max_size;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, 0x24(%rax)
jne 0x4494
movb $0x0, -0x1(%rbp)
jmp 0x44fe
movq -0x28(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x14(%rcx), %eax
jge 0x44fa
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x1c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3de0
testb $0x1, %al
jne 0x44d3
jmp 0x44d9
movb $0x1, -0x1(%rbp)
jmp 0x44fe
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
movl 0x10(%rcx), %edx
subl $0x1, %edx
addl %edx, %eax
cltd
idivl 0x10(%rcx)
movl %edx, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x44a5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: matallui[P]nibble-curses/src/CSnake.cpp
// Function: CSnake::Eat(CPoint const&, int const&, int const&)
bool CSnake::Eat ( CPoint const & food, int const & nfood, int const & level )
{
  if ( !m_lives ) return false;
  
  if ( m_body[m_head] == food )
  {
    m_delay += (3 * nfood);
    m_score += ( 100*level + 100*nfood );
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, 0x24(%rax)
jne 0x453c
movb $0x0, -0x1(%rbp)
jmp 0x458f
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movslq 0x18(%rax), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3de0
testb $0x1, %al
jne 0x455e
jmp 0x458b
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
imull $0x3, (%rcx), %ecx
addl 0x2c(%rax), %ecx
movl %ecx, 0x2c(%rax)
movq -0x28(%rbp), %rcx
imull $0x64, (%rcx), %ecx
movq -0x20(%rbp), %rdx
imull $0x64, (%rdx), %edx
addl %edx, %ecx
addl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x458f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: matallui[P]nibble-curses/src/CSingle.cpp
// Function: CSingle::Collision(CObstacle*, int const&, CSnake*)
bool CSingle::Collision ( CObstacle * const obstacles, int const & num_obstacles, CSnake * sfriend )
{
  if ( !m_lives ) return false;
  
  // collision with obstacles
  for ( int i = 0; i < num_obstacles; i++ )
    if ( obstacles[i].Intersection ( m_body[m_head] ) )
    {
      m_lives --;
      m_score -= 1000;
      return true;
    }
  
  // collision with body
  int i = m_tail;
  for ( int k = 0; k < m_size-3; k++ )
  {
    if ( m_body[m_head] == m_body[i] )
    {
      m_lives --;
      m_score -= 1000;
      return true;
    }
    i = (i + 1) % m_max_size;
  }
  
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, 0x24(%rax)
jne 0x4a8f
movb $0x0, -0x1(%rbp)
jmp 0x4b8b
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x4afd
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rdi
movslq -0x2c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rdi
movq 0x8(%rax), %rsi
movslq 0x18(%rax), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x4150
testb $0x1, %al
jne 0x4ace
jmp 0x4af0
movq -0x40(%rbp), %rax
movl 0x24(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x24(%rax)
movl 0x20(%rax), %ecx
subl $0x3e8, %ecx            # imm = 0x3E8
movl %ecx, 0x20(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x4b8b
jmp 0x4af2
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4a96
movq -0x40(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x40(%rbp), %rcx
movl -0x34(%rbp), %eax
movl 0x14(%rcx), %ecx
subl $0x3, %ecx
cmpl %ecx, %eax
jge 0x4b87
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
movslq 0x18(%rax), %rcx
shlq $0x3, %rcx
addq %rcx, %rdi
movq 0x8(%rax), %rsi
movslq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x3de0
testb $0x1, %al
jne 0x4b4c
jmp 0x4b6b
movq -0x40(%rbp), %rax
movl 0x24(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x24(%rax)
movl 0x20(%rax), %ecx
subl $0x3e8, %ecx            # imm = 0x3E8
movl %ecx, 0x20(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x4b8b
movq -0x40(%rbp), %rcx
movl -0x30(%rbp), %eax
addl $0x1, %eax
cltd
idivl 0x10(%rcx)
movl %edx, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4b0e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: matallui[P]nibble-curses/src/CMultPC.cpp
// Function: CMultPC::Die(CMultPC*)
void CMultPC::Die ( CMultPC * sfriend )
{
  if ( m_lives > 0 )
  {
    m_lives --;
    if ( !m_lives )
      sfriend->ManDown();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x24(%rax)
jle 0x559c
movq -0x18(%rbp), %rax
movl 0x24(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x24(%rax)
cmpl $0x0, 0x24(%rax)
jne 0x559a
movq -0x10(%rbp), %rdi
callq 0x59b0
jmp 0x559c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: matallui[P]nibble-curses/src/CSocket.cpp
// Function: CSocket::Send(char*, int const&)
bool CSocket::Send ( char * buffer, int const & buffsize )
{
  if ( !m_connected ) return false;
  
  int n;
  n = write ( m_newsockfd, buffer, buffsize );
  if ( n < 0 ) return false;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0x20(%rax)
jne 0x5d18
movb $0x0, -0x1(%rbp)
jmp 0x5d42
movq -0x30(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movslq (%rax), %rdx
callq 0x3120
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x5d3e
movb $0x0, -0x1(%rbp)
jmp 0x5d42
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: matallui[P]nibble-curses/src/CSocket.cpp
// Function: CSocket::Recv(char*, int const&)
bool CSocket::Recv ( char * buffer, int const & buffsize )
{
  if ( !m_connected ) return false;
  
  bzero ( buffer, buffsize );
  int n;
  n = read ( m_newsockfd, buffer, buffsize );
  if ( n < 0 ) return false;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0x20(%rax)
jne 0x5d78
movb $0x0, -0x1(%rbp)
jmp 0x5db4
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq (%rax), %rdx
xorl %esi, %esi
callq 0x31b0
movq -0x30(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movslq (%rax), %rdx
callq 0x3440
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x5db0
movb $0x0, -0x1(%rbp)
jmp 0x5db4
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: matallui[P]nibble-curses/src/CSocketServer.cpp
// Function: CSocketServer::Initialize(int const&, char*)
bool CSocketServer::Initialize ( int const & portno, char * hostname )
{
  m_sockfd = socket ( AF_INET, SOCK_STREAM, 0 );
  if ( m_sockfd < 0 ) return false;
  
  bzero ( (char*) (&m_serverAddr), sizeof(m_serverAddr) );
  m_portno = portno;
  m_serverAddr.sin_family = AF_INET;
  m_serverAddr.sin_addr.s_addr = INADDR_ANY;
  m_serverAddr.sin_port = htons ( m_portno );
  
  int s;
  s = bind ( m_sockfd, (struct sockaddr*) (&m_serverAddr), sizeof( m_serverAddr ) );
  if ( s < 0 ) return false;
  listen ( m_sockfd, 5 );
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x30b0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
cmpl $0x0, 0x24(%rax)
jge 0x5eb2
movb $0x0, -0x1(%rbp)
jmp 0x5f28
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x31b0
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0xc(%rax)
movw $0x2, 0x10(%rax)
movl $0x0, 0x14(%rax)
movl 0xc(%rax), %eax
movzwl %ax, %edi
callq 0x3050
movq -0x30(%rbp), %rsi
movw %ax, 0x12(%rsi)
movl 0x24(%rsi), %edi
addq $0x10, %rsi
movl $0x10, %edx
callq 0x3060
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x5f13
movb $0x0, -0x1(%rbp)
jmp 0x5f28
movq -0x30(%rbp), %rax
movl 0x24(%rax), %edi
movl $0x5, %esi
callq 0x3370
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: matallui[P]nibble-curses/src/CSocketServer.cpp
// Function: CSocketServer::EstablishConnection()
bool CSocketServer::EstablishConnection ( void )
{
  m_clientLength = sizeof ( m_clientAddr );
  m_newsockfd = accept ( m_sockfd, (struct sockaddr*) (&m_clientAddr), &m_clientLength );
  if ( m_newsockfd < 0 ) return false;
  
  m_connected = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movq %rdx, -0x18(%rbp)
movl $0x10, 0x38(%rdx)
movl 0x24(%rdx), %edi
movq %rdx, %rsi
addq $0x28, %rsi
addq $0x38, %rdx
callq 0x30f0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
cmpl $0x0, 0x8(%rax)
jge 0x5f83
movb $0x0, -0x1(%rbp)
jmp 0x5f8f
movq -0x18(%rbp), %rax
movb $0x1, 0x20(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: matallui[P]nibble-curses/src/CSocketClient.cpp
// Function: CSocketClient::Initialize(int const&, char*)
bool CSocketClient::Initialize ( int const & portno, char * hostname )
{
  m_portno = portno;
  m_newsockfd = socket ( AF_INET, SOCK_STREAM, 0 );
  if ( m_newsockfd < 0 ) return false;
  m_server = gethostbyname ( hostname );
  if ( m_server == NULL ) return false;
  
  bzero ( (char*) (&m_serverAddr), sizeof( m_serverAddr ) );
  m_serverAddr.sin_family = AF_INET;
  bcopy ( (char*) m_server->h_addr, (char*) (&m_serverAddr.sin_addr.s_addr), m_server->h_length );
  m_serverAddr.sin_port = htons ( m_portno );
  
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0xc(%rax)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x30b0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
cmpl $0x0, 0x8(%rax)
jge 0x607e
movb $0x0, -0x1(%rbp)
jmp 0x60fe
movq -0x20(%rbp), %rdi
callq 0x3390
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
cmpq $0x0, 0x28(%rax)
jne 0x609f
movb $0x0, -0x1(%rbp)
jmp 0x60fe
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x31b0
movq -0x28(%rbp), %rax
movw $0x2, 0x10(%rax)
movq 0x28(%rax), %rcx
movq 0x18(%rcx), %rcx
movq (%rcx), %rsi
movq %rax, %rdi
addq $0x10, %rdi
addq $0x4, %rdi
movq 0x28(%rax), %rax
movslq 0x14(%rax), %rdx
callq 0x3490
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
movzwl %ax, %edi
callq 0x3050
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, 0x12(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: matallui[P]nibble-curses/src/CSocketClient.cpp
// Function: CSocketClient::EstablishConnection()
bool CSocketClient::EstablishConnection ( void )
{
  int s;
  s = connect ( m_newsockfd, (struct sockaddr*) (&m_serverAddr), sizeof(m_serverAddr) );
  if ( s < 0 ) return false;
  m_connected = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x20(%rbp)
movl 0x8(%rsi), %edi
addq $0x10, %rsi
movl $0x10, %edx
callq 0x3260
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x6144
movb $0x0, -0x1(%rbp)
jmp 0x6150
movq -0x20(%rbp), %rax
movb $0x1, 0x20(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: matallui[P]nibble-curses/src/CNibbles.cpp
// Function: CNibbles::~CNibbles()
CNibbles::~CNibbles ( void )
{
  for ( int i = 0; i < 2; i++ )
    if ( m_snakes[i] ) delete m_snakes[i];
  delete [] m_snakes;
  delete [] m_obstacles;
  if ( m_mode == 3 && m_socket ) delete m_socket;
  nodelay( stdscr, false );
  endwin ();
  
  if ( m_state == 5 )
  {
    cout << "\nThe program has aborted!\nReason:" << endl;
    cout << " - " << m_exception << endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jge 0x6527
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x651a
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x6518
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x651a
jmp 0x651c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x64db
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x6542
movq -0x28(%rbp), %rdi
callq 0x3400
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x655d
movq -0x30(%rbp), %rdi
callq 0x3400
movq -0x18(%rbp), %rax
cmpl $0x3, 0x14(%rax)
jne 0x6590
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x6590
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x658e
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x6590
movq 0x9a39(%rip), %rax      # 0xffd0
movq (%rax), %rdi
xorl %esi, %esi
callq 0x31c0
jmp 0x65a3
callq 0x33b0
jmp 0x65aa
movq -0x18(%rbp), %rax
cmpl $0x5, 0x24(%rax)
jne 0x6623
movq 0x9a1d(%rip), %rdi      # 0xffd8
leaq 0x5d9d(%rip), %rsi      # 0xc35f
callq 0x32c0
movq %rax, -0x40(%rbp)
jmp 0x65cd
movq -0x40(%rbp), %rdi
movq 0x99e0(%rip), %rsi      # 0xffb8
callq 0x3310
jmp 0x65df
movq 0x99f2(%rip), %rdi      # 0xffd8
leaq 0x5d94(%rip), %rsi      # 0xc381
callq 0x32c0
movq %rax, -0x48(%rbp)
jmp 0x65f8
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x50, %rsi
callq 0x3840
movq %rax, -0x50(%rbp)
jmp 0x660f
movq -0x50(%rbp), %rdi
movq 0x999e(%rip), %rsi      # 0xffb8
callq 0x3310
jmp 0x6621
jmp 0x6623
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
callq 0xbc30
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3b90
nop
// File: matallui[P]nibble-curses/src/CNibbles.cpp
// Function: CNibbles::Start()
void CNibbles::Start ( void )
{
  try
  {
    Menu ();
    
    m_state = 2; // next level;
    for ( m_level = 1; m_level <= 10; m_level++ )
    {
      InitLevel ( );
      m_state = 0; // normal game curse
      while ( Step() )	usleep ( m_speed );
      // - same level (player dies)   	-> 1
      // - next level			-> 2
      // - game over			-> 3
      // - winner				
      // - Abort Execution		-> 5
      if ( m_state == 1 )		m_level--;
      else if ( m_state == 3 )
      {
	if ( GameOver_Restart() ) 	Restart ();
	else				break;
      }
      if ( m_level == 10 )
      {
	if ( Winner_Restart() )	Restart ();
	else 			break;
      }
	
    }
  }
  catch (CException e)
  {
    m_exception = e;
    m_state = 5;
  }
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x6800
jmp 0x665b
movq -0x40(%rbp), %rax
movl $0x2, 0x24(%rax)
movl $0x1, 0x8(%rax)
movq -0x40(%rbp), %rax
cmpl $0xa, 0x8(%rax)
jg 0x67c0
movq -0x40(%rbp), %rdi
callq 0x7b90
jmp 0x6686
movq -0x40(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x40(%rbp), %rdi
callq 0x8950
movb %al, -0x41(%rbp)
jmp 0x669f
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x66ab
jmp 0x672d
movq -0x40(%rbp), %rax
movl 0x1c(%rax), %edi
callq 0x3430
jmp 0x66b9
jmp 0x6691
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 0x67e3
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x33e0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x37a0
jmp 0x66f2
movq -0x50(%rbp), %rdi
callq 0x3150
movq -0x40(%rbp), %rdi
addq $0x50, %rdi
leaq -0x38(%rbp), %rsi
callq 0x37f0
jmp 0x670e
movq -0x40(%rbp), %rax
movl $0x5, 0x24(%rax)
leaq -0x38(%rbp), %rdi
callq 0xbc30
callq 0x34a0
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rax
cmpl $0x1, 0x24(%rax)
jne 0x6746
movq -0x40(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x677a
movq -0x40(%rbp), %rax
cmpl $0x3, 0x24(%rax)
jne 0x6778
movq -0x40(%rbp), %rdi
callq 0x8e70
movb %al, -0x51(%rbp)
jmp 0x675e
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x6767
jmp 0x6774
movq -0x40(%rbp), %rdi
callq 0x97d0
jmp 0x6772
jmp 0x6776
jmp 0x67c0
jmp 0x6778
jmp 0x677a
movq -0x40(%rbp), %rax
cmpl $0xa, 0x8(%rax)
jne 0x67ac
movq -0x40(%rbp), %rdi
callq 0x9840
movb %al, -0x52(%rbp)
jmp 0x6792
movb -0x52(%rbp), %al
testb $0x1, %al
jne 0x679b
jmp 0x67a8
movq -0x40(%rbp), %rdi
callq 0x97d0
jmp 0x67a6
jmp 0x67aa
jmp 0x67c0
jmp 0x67ac
jmp 0x67ae
movq -0x40(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x666d
jmp 0x6727
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xbc30
callq 0x34a0
jmp 0x67e1
jmp 0x67e3
movq -0x10(%rbp), %rdi
callq 0x34e0
movq %rax, %rdi
callq 0x3b90
nopw %cs:(%rax,%rax)
// File: matallui[P]nibble-curses/src/CNibbles.cpp
// Function: CNibbles::Restart()
void CNibbles::Restart ( void )
{
  for ( int i = 0; i < m_nplayers; i++ )
    m_snakes[i]->Reset();
  m_score = 0;
  m_state = 2;
  m_level = 0;  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x9818
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x97eb
movq -0x18(%rbp), %rax
movl $0x0, 0x20(%rax)
movl $0x2, 0x24(%rax)
movl $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: matallui[P]nibble-curses/src/CNibbles.cpp
// Function: CNibbles::PopUp(char*, char*) const
void CNibbles::PopUp ( char * title1, char * title2 ) const
{
  attrset ( COLOR_PAIR(6) );
  mvaddstr ( 14, 35, "******************************" );
  mvaddstr ( 15, 35, "*                            *" );
  mvaddstr ( 16, 35, title1 );
  mvaddstr ( 17, 35, "*                            *" );
  mvaddstr ( 18, 35, title2 );
  mvaddstr ( 19, 35, "******************************" );
  refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x52a5(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movl $0x600, %esi            # imm = 0x600
callq 0x3330
movq 0x5291(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movl $0xe, %esi
movl $0x23, %edx
callq 0x3300
cmpl $-0x1, %eax
jne 0xad58
jmp 0xad73
movq 0x5271(%rip), %rax      # 0xffd0
movq (%rax), %rdi
leaq 0x1819(%rip), %rsi      # 0xc582
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x3110
movq 0x5256(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movl $0xf, %esi
movl $0x23, %edx
callq 0x3300
cmpl $-0x1, %eax
jne 0xad93
jmp 0xadae
movq 0x5236(%rip), %rax      # 0xffd0
movq (%rax), %rdi
leaq 0x17fd(%rip), %rsi      # 0xc5a1
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x3110
movq 0x521b(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movl $0x10, %esi
movl $0x23, %edx
callq 0x3300
cmpl $-0x1, %eax
jne 0xadce
jmp 0xade6
movq 0x51fb(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x3110
movq 0x51e3(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movl $0x11, %esi
movl $0x23, %edx
callq 0x3300
cmpl $-0x1, %eax
jne 0xae06
jmp 0xae21
movq 0x51c3(%rip), %rax      # 0xffd0
movq (%rax), %rdi
leaq 0x178a(%rip), %rsi      # 0xc5a1
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x3110
movq 0x51a8(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movl $0x12, %esi
movl $0x23, %edx
callq 0x3300
cmpl $-0x1, %eax
jne 0xae41
jmp 0xae59
movq 0x5188(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x3110
movq 0x5170(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movl $0x13, %esi
movl $0x23, %edx
callq 0x3300
cmpl $-0x1, %eax
jne 0xae79
jmp 0xae94
movq 0x5150(%rip), %rax      # 0xffd0
movq (%rax), %rdi
leaq 0x16f8(%rip), %rsi      # 0xc582
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x3110
callq 0x34c0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: matallui[P]nibble-curses/src/CNibbles.cpp
// Function: CNibbles::UpdateScores()
void CNibbles::UpdateScores ( void )
{
  // Display scores
  attrset ( COLOR_PAIR(3) );
  if ( m_snakes[0] )
  {
  move ( 36, 2 );
  printw ("PLAYER 1 -> Lives: %d , Score: %d  ", m_snakes[0]->getLives(), m_snakes[0]->getScore());
  }
  if ( m_snakes[1] )
  {
  move ( 36, 62 );
  printw ("PLAYER 2 -> Lives: %d , Score: %d  ", m_snakes[1]->getLives(), m_snakes[1]->getScore());
  }
  move ( 36, 46);
  printw ( "%d  ", m_score ); // global score
  refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x4995(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movl $0x300, %esi            # imm = 0x300
callq 0x3330
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpq $0x0, (%rax)
je 0xb69d
movl $0x24, %edi
movl $0x2, %esi
callq 0x3200
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rdi
callq 0x45a0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, -0x14(%rbp)
movq 0x30(%rax), %rax
movq (%rax), %rdi
callq 0x45c0
movl -0x14(%rbp), %esi
movl %eax, %edx
leaq 0x100a(%rip), %rdi      # 0xc6a0
movb $0x0, %al
callq 0x32e0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0xb6f5
movl $0x24, %edi
movl $0x3e, %esi
callq 0x3200
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x45a0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, -0x18(%rbp)
movq 0x30(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x45c0
movl -0x18(%rbp), %esi
movl %eax, %edx
leaq 0xfd6(%rip), %rdi       # 0xc6c4
movb $0x0, %al
callq 0x32e0
movl $0x24, %edi
movl $0x2e, %esi
callq 0x3200
movq -0x10(%rbp), %rax
movl 0x20(%rax), %esi
leaq 0xfad(%rip), %rdi       # 0xc6bf
movb $0x0, %al
callq 0x32e0
callq 0x34c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: quancs[P]EAVC/./pcg32.h
// Function: pcg32()
uint32_t pcg32(void) {
    uint64_t x = state;
    unsigned count = static_cast<unsigned>(x >> 59);		// 59 = 64 - 5

    state = x * multiplier + increment;
    x ^= x >> 18;								// 18 = (64 - 27)/2
    return rotr32(static_cast<unsigned>(x >> 27), count);	// 27 = 32 - 5
}

// Assembly:
subq $0x18, %rsp
movq 0x8dc5(%rip), %rax      # 0xb110
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
shrq $0x3b, %rax
movl %eax, 0xc(%rsp)
movabsq $0x5851f42d4c957f2d, %rax # imm = 0x5851F42D4C957F2D
imulq 0x10(%rsp), %rax
movabsq $0x14057b7ef767814f, %rcx # imm = 0x14057B7EF767814F
addq %rcx, %rax
movq %rax, 0x8d8f(%rip)      # 0xb110
movq 0x10(%rsp), %rax
shrq $0x12, %rax
xorq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
shrq $0x1b, %rax
movl %eax, %edi
movl 0xc(%rsp), %esi
callq 0x23b0
addq $0x18, %rsp
retq
nopl (%rax)
// File: quancs[P]EAVC/./pcg32.h
// Function: pcg32_fast()
uint32_t pcg32_fast(void) {
    uint64_t x = mcg_state;
    unsigned count = static_cast<unsigned>(x >> 61);	// 61 = 64 - 3

    mcg_state = x * multiplier;
    x ^= x >> 22;
    return static_cast<unsigned>(x >> (22 + count));	// 22 = 32 - 3 - 7
}

// Assembly:
movq 0x8d01(%rip), %rax      # 0xb118
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x3d, %rax
movl %eax, -0xc(%rsp)
movabsq $0x5851f42d4c957f2d, %rax # imm = 0x5851F42D4C957F2D
imulq -0x8(%rsp), %rax
movq %rax, 0x8cd8(%rip)      # 0xb118
movq -0x8(%rsp), %rax
shrq $0x16, %rax
xorq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %ecx
addl $0x16, %ecx
movl %ecx, %ecx
shrq %cl, %rax
retq
nopw %cs:(%rax,%rax)
// File: quancs[P]EAVC/./eavc.h
// Function: prep_remove_from_neighbours(unsigned int)
void prep_remove_from_neighbours(unsigned v) {
    //'remove' v from vAdj: move v to the end part of v_adj's vAdj
    for (unsigned i = 0; i < dVDegree[v]; i++) {
        unsigned adj = vAdj[v][i];
        unsigned indexOfLast = dVDegree[adj] - 1;
        dVDegree[adj] = indexOfLast;
        //vAdj
        for (unsigned j = 0; j <= indexOfLast; j++) {
            if (vAdj[adj][j] == v) {
                vAdj[adj][j] = vAdj[adj][indexOfLast];
                vAdj[adj][indexOfLast] = v;

                unsigned e = vEdges[adj][j];
                vEdges[adj][j] = vEdges[adj][indexOfLast];
                vEdges[adj][indexOfLast] = e;
                break;
            }
        }
    }
}

// Assembly:
movl %edi, -0x4(%rsp)
movl $0x0, -0x8(%rsp)
movl -0x8(%rsp), %eax
movq 0x8549(%rip), %rcx      # 0xb1b0
movl -0x4(%rsp), %edx
cmpl (%rcx,%rdx,4), %eax
jae 0x2db7
movq 0x8505(%rip), %rax      # 0xb180
movl -0x4(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x8(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rsp)
movq 0x851b(%rip), %rax      # 0xb1b0
movl -0xc(%rsp), %ecx
movl (%rax,%rcx,4), %eax
subl $0x1, %eax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %edx
movq 0x8502(%rip), %rax      # 0xb1b0
movl -0xc(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movl $0x0, -0x14(%rsp)
movl -0x14(%rsp), %eax
cmpl -0x10(%rsp), %eax
ja 0x2da5
movq 0x84ae(%rip), %rax      # 0xb180
movl -0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x14(%rsp), %ecx
movl (%rax,%rcx,4), %eax
cmpl -0x4(%rsp), %eax
jne 0x2d93
movq 0x848e(%rip), %rax      # 0xb180
movl -0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x10(%rsp), %ecx
movl (%rax,%rcx,4), %edx
movq 0x8478(%rip), %rax      # 0xb180
movl -0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x14(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x4(%rsp), %edx
movq 0x845e(%rip), %rax      # 0xb180
movl -0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x10(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movq 0x8440(%rip), %rax      # 0xb178
movl -0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x14(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rsp)
movq 0x8426(%rip), %rax      # 0xb178
movl -0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x10(%rsp), %ecx
movl (%rax,%rcx,4), %edx
movq 0x8410(%rip), %rax      # 0xb178
movl -0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x14(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rsp), %edx
movq 0x83f6(%rip), %rax      # 0xb178
movl -0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x10(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
jmp 0x2da5
jmp 0x2d95
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x2cbd
jmp 0x2da7
movl -0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0x2c5c
retq
nopl (%rax,%rax)
// File: quancs[P]EAVC/./eavc.h
// Function: free_memory()
void free_memory() {
    for (unsigned int v = 0; v < vNum; v++) {
        delete[] vAdj[v];
        delete[] vEdges[v];
    }
    delete[] vInBest;
    delete[] cVertexIndexes;
    delete[] cVertexes;
    delete[] vInC;
    delete[] vDegree;
    delete[] vAdj;
    delete[] vEdges;
    delete[] vTimestamp;
    delete[] dscore;
    delete[] uncovEdgeIndexes;
    delete[] uncovEdges;
    delete[] edges;
    delete[] eTimestamp;
    delete[] uvSet;
    delete[] dVDegree;
}

// Assembly:
subq $0x98, %rsp
movl $0x0, 0x94(%rsp)
movl 0x94(%rsp), %eax
cmpl 0x7d1d(%rip), %eax      # 0xb13c
jae 0x3490
movq 0x7d58(%rip), %rax      # 0xb180
movl 0x94(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x88(%rsp)
cmpq $0x0, %rax
je 0x344e
movq 0x88(%rsp), %rdi
callq 0x2160
movq 0x7d23(%rip), %rax      # 0xb178
movl 0x94(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x80(%rsp)
cmpq $0x0, %rax
je 0x347b
movq 0x80(%rsp), %rdi
callq 0x2160
jmp 0x347d
movl 0x94(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x94(%rsp)
jmp 0x3412
movq 0x7d11(%rip), %rax      # 0xb1a8
movq %rax, 0x78(%rsp)
cmpq $0x0, %rax
je 0x34ac
movq 0x78(%rsp), %rdi
callq 0x2160
movq 0x7ced(%rip), %rax      # 0xb1a0
movq %rax, 0x70(%rsp)
cmpq $0x0, %rax
je 0x34c8
movq 0x70(%rsp), %rdi
callq 0x2160
movq 0x7cc9(%rip), %rax      # 0xb198
movq %rax, 0x68(%rsp)
cmpq $0x0, %rax
je 0x34e4
movq 0x68(%rsp), %rdi
callq 0x2160
movq 0x7ca5(%rip), %rax      # 0xb190
movq %rax, 0x60(%rsp)
cmpq $0x0, %rax
je 0x3500
movq 0x60(%rsp), %rdi
callq 0x2160
movq 0x7c81(%rip), %rax      # 0xb188
movq %rax, 0x58(%rsp)
cmpq $0x0, %rax
je 0x351c
movq 0x58(%rsp), %rdi
callq 0x2160
movq 0x7c5d(%rip), %rax      # 0xb180
movq %rax, 0x50(%rsp)
cmpq $0x0, %rax
je 0x3538
movq 0x50(%rsp), %rdi
callq 0x2160
movq 0x7c39(%rip), %rax      # 0xb178
movq %rax, 0x48(%rsp)
cmpq $0x0, %rax
je 0x3554
movq 0x48(%rsp), %rdi
callq 0x2160
movq 0x7c15(%rip), %rax      # 0xb170
movq %rax, 0x40(%rsp)
cmpq $0x0, %rax
je 0x3570
movq 0x40(%rsp), %rdi
callq 0x2160
movq 0x7bf1(%rip), %rax      # 0xb168
movq %rax, 0x38(%rsp)
cmpq $0x0, %rax
je 0x358c
movq 0x38(%rsp), %rdi
callq 0x2160
movq 0x7bcd(%rip), %rax      # 0xb160
movq %rax, 0x30(%rsp)
cmpq $0x0, %rax
je 0x35a8
movq 0x30(%rsp), %rdi
callq 0x2160
movq 0x7ba9(%rip), %rax      # 0xb158
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x35c4
movq 0x28(%rsp), %rdi
callq 0x2160
movq 0x7b85(%rip), %rax      # 0xb150
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x35e0
movq 0x20(%rsp), %rdi
callq 0x2160
movq 0x7b61(%rip), %rax      # 0xb148
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x35fc
movq 0x18(%rsp), %rdi
callq 0x2160
movq 0x7bdd(%rip), %rax      # 0xb1e0
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x3618
movq 0x10(%rsp), %rdi
callq 0x2160
movq 0x7b91(%rip), %rax      # 0xb1b0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x3634
movq 0x8(%rsp), %rdi
callq 0x2160
addq $0x98, %rsp
retq
nopl (%rax)
// File: quancs[P]EAVC/./eavc.h
// Function: reset_remove_cand()
void reset_remove_cand() {
    unsigned int v, j;
    j = 0;
    for (v = 0; v < vNum; v++) {
        if (vInC[v] == true) {
            cVertexes[j] = v;
            cVertexIndexes[v] = j;
            j++;
        } else cVertexIndexes[v] = 0;
    }

    cvSize = j;
}

// Assembly:
movl $0x0, -0x8(%rsp)
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
cmpl 0x7ae2(%rip), %eax      # 0xb13c
jae 0x36c2
movq 0x7b2d(%rip), %rax      # 0xb190
movl -0x4(%rsp), %ecx
movzbl (%rax,%rcx), %eax
cmpl $0x1, %eax
jne 0x36a1
movl -0x4(%rsp), %edx
movq 0x7b1d(%rip), %rax      # 0xb198
movl -0x8(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x8(%rsp), %edx
movq 0x7b13(%rip), %rax      # 0xb1a0
movl -0x4(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0x36b3
movq 0x7af8(%rip), %rax      # 0xb1a0
movl -0x4(%rsp), %ecx
movl $0x0, (%rax,%rcx,4)
jmp 0x36b5
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x3650
movl -0x8(%rsp), %eax
movl %eax, 0x7b24(%rip)      # 0xb1f0
retq
nopl (%rax)
// File: quancs[P]EAVC/./eavc.h
// Function: remove(unsigned int)
void remove(unsigned int v) {
    vInC[v] = NIN;
    dscore[v] = -dscore[v];

    unsigned int i, e, n;

    unsigned int edge_count = dVDegree[v];
    for (i = 0; i < edge_count; ++i) {
        e = vEdges[v][i];
        n = vAdj[v][i];

        if (not_in(vInC, n)) { //this adj isn't in cover set
            dscore[n]++;
            uncover(e);
        } else {
            dscore[n]--;
        }
    }
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq 0x7901(%rip), %rax      # 0xb190
movl 0x14(%rsp), %ecx
movb $0x0, (%rax,%rcx)
movq 0x78ca(%rip), %rax      # 0xb168
movl 0x14(%rsp), %ecx
xorl %edx, %edx
subl (%rax,%rcx,4), %edx
movq 0x78ba(%rip), %rax      # 0xb168
movl 0x14(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movq 0x78f4(%rip), %rax      # 0xb1b0
movl 0x14(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, 0x4(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x4(%rsp), %eax
jae 0x396c
movq 0x7894(%rip), %rax      # 0xb178
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl 0x10(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, 0xc(%rsp)
movq 0x7882(%rip), %rax      # 0xb180
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl 0x10(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, 0x8(%rsp)
movq 0x7878(%rip), %rdi      # 0xb190
movl 0x8(%rsp), %esi
callq 0x72f0
testb $0x1, %al
jne 0x3927
jmp 0x3946
movq 0x783a(%rip), %rax      # 0xb168
movl 0x8(%rsp), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movl 0xc(%rsp), %edi
callq 0x7380
jmp 0x395a
movq 0x781b(%rip), %rax      # 0xb168
movl 0x8(%rsp), %ecx
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x395c
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x38cf
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)