LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tlaloc1313[P]chess-project/Board.cpp
// Function: Board::getPiece(int)
const char* Board::getPiece(int space){
  char type = pieceArray[space]->getType();
  bool isWhite = pieceArray[space]->getIsWhite();

  if (isWhite == 1) {
    //White Pieces
    switch (type) {
      case 'p':
      return u8"\u2659";
      case 'r':
      return u8"\u2656";
      case 'b':
      return u8"\u2657";
      case 'n':
      return u8"\u2658";
      case 'k':
      return u8"♔";
      case 'q':
      return u8"\u2655";
    }
  } else {
    //Black Pieces
    switch (type) {
      case 'p':
      return u8"\u265F";
      case 'r':
      return u8"\u265C";
      case 'b':
      return u8"\u265D";
      case 'n':
      return u8"\u265E";
      case 'k':
      return u8"\u265A";
      case 'q':
      return u8"\u265B";
    }
  }

  return u8"\uFFFD";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movslq -0x14(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rdi
callq 0x9880
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, -0x15(%rbp)
movslq -0x14(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rdi
callq 0x98a0
andb $0x1, %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x52ea
movsbl -0x15(%rbp), %eax
addl $-0x62, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x10, %eax
ja 0x52e8
movq -0x28(%rbp), %rax
leaq 0x5295(%rip), %rcx      # 0xa514
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x5358(%rip), %rax      # 0xa5e7
movq %rax, -0x8(%rbp)
jmp 0x536b
leaq 0x534c(%rip), %rax      # 0xa5eb
movq %rax, -0x8(%rbp)
jmp 0x536b
leaq 0x5340(%rip), %rax      # 0xa5ef
movq %rax, -0x8(%rbp)
jmp 0x536b
leaq 0x5334(%rip), %rax      # 0xa5f3
movq %rax, -0x8(%rbp)
jmp 0x536b
leaq 0x5328(%rip), %rax      # 0xa5f7
movq %rax, -0x8(%rbp)
jmp 0x536b
leaq 0x531c(%rip), %rax      # 0xa5fb
movq %rax, -0x8(%rbp)
jmp 0x536b
jmp 0x5360
movsbl -0x15(%rbp), %eax
addl $-0x62, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x10, %eax
ja 0x535e
movq -0x30(%rbp), %rax
leaq 0x51c9(%rip), %rcx      # 0xa4d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x52e8(%rip), %rax      # 0xa5ff
movq %rax, -0x8(%rbp)
jmp 0x536b
leaq 0x52df(%rip), %rax      # 0xa603
movq %rax, -0x8(%rbp)
jmp 0x536b
leaq 0x52d6(%rip), %rax      # 0xa607
movq %rax, -0x8(%rbp)
jmp 0x536b
leaq 0x52cd(%rip), %rax      # 0xa60b
movq %rax, -0x8(%rbp)
jmp 0x536b
leaq 0x52c4(%rip), %rax      # 0xa60f
movq %rax, -0x8(%rbp)
jmp 0x536b
leaq 0x52bb(%rip), %rax      # 0xa613
movq %rax, -0x8(%rbp)
jmp 0x536b
jmp 0x5360
leaq 0x52b0(%rip), %rax      # 0xa617
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tlaloc1313[P]chess-project/Board.cpp
// Function: Board::getPastPiece(int)
const char* Board::getPastPiece(int number) {

  //Special Cases
  if (pastPieces[number] == 'x') {
    return u8"\u200A";
  }


  int isWhite = ((number + 1) % 2);

  if (isWhite == 1) {
    //White Pieces
    switch (pastPieces[number]) {
      case 'p':
      return u8"\u2659";
      case 'r':
      return u8"\u2656";
      case 'b':
      return u8"\u2657";
      case 'n':
      return u8"\u2658";
      case 'k':
      return u8"♔";
      case 'q':
      return u8"\u2655";
    }
  } else {
    //Black Pieces
    switch (pastPieces[number]) {
      case 'p':
      return u8"\u265F";
      case 'r':
      return u8"\u265C";
      case 'b':
      return u8"\u265D";
      case 'n':
      return u8"\u265E";
      case 'k':
      return u8"\u265A";
      case 'q':
      return u8"\u265B";
    }
  }

  //Error character
  return u8"\uFFFD";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x248, %rdi            # imm = 0x248
movslq -0x14(%rbp), %rsi
callq 0x6c90
movsbl (%rax), %eax
cmpl $0x78, %eax
jne 0x53bf
leaq 0x5265(%rip), %rax      # 0xa61b
movq %rax, -0x8(%rbp)
jmp 0x550c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %edx, -0x18(%rbp)
cmpl $0x1, -0x18(%rbp)
jne 0x5478
movq -0x20(%rbp), %rdi
addq $0x248, %rdi            # imm = 0x248
movslq -0x14(%rbp), %rsi
callq 0x6c90
movsbl (%rax), %eax
addl $-0x62, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x10, %eax
ja 0x5473
movq -0x28(%rbp), %rax
leaq 0x5192(%rip), %rcx      # 0xa59c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x51cd(%rip), %rax      # 0xa5e7
movq %rax, -0x8(%rbp)
jmp 0x550c
leaq 0x51c1(%rip), %rax      # 0xa5eb
movq %rax, -0x8(%rbp)
jmp 0x550c
leaq 0x51b5(%rip), %rax      # 0xa5ef
movq %rax, -0x8(%rbp)
jmp 0x550c
leaq 0x51a9(%rip), %rax      # 0xa5f3
movq %rax, -0x8(%rbp)
jmp 0x550c
leaq 0x519d(%rip), %rax      # 0xa5f7
movq %rax, -0x8(%rbp)
jmp 0x550c
leaq 0x5191(%rip), %rax      # 0xa5fb
movq %rax, -0x8(%rbp)
jmp 0x550c
jmp 0x5501
movq -0x20(%rbp), %rdi
addq $0x248, %rdi            # imm = 0x248
movslq -0x14(%rbp), %rsi
callq 0x6c90
movsbl (%rax), %eax
addl $-0x62, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x10, %eax
ja 0x54ff
movq -0x30(%rbp), %rax
leaq 0x50b0(%rip), %rcx      # 0xa558
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x5147(%rip), %rax      # 0xa5ff
movq %rax, -0x8(%rbp)
jmp 0x550c
leaq 0x513e(%rip), %rax      # 0xa603
movq %rax, -0x8(%rbp)
jmp 0x550c
leaq 0x5135(%rip), %rax      # 0xa607
movq %rax, -0x8(%rbp)
jmp 0x550c
leaq 0x512c(%rip), %rax      # 0xa60b
movq %rax, -0x8(%rbp)
jmp 0x550c
leaq 0x5123(%rip), %rax      # 0xa60f
movq %rax, -0x8(%rbp)
jmp 0x550c
leaq 0x511a(%rip), %rax      # 0xa613
movq %rax, -0x8(%rbp)
jmp 0x550c
jmp 0x5501
leaq 0x510f(%rip), %rax      # 0xa617
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tlaloc1313[P]chess-project/Bishop.cpp
// Function: Bishop::Bishop(int, int)
Bishop::Bishop(int startingSquare, int pieceIsWhite){
  location = startingSquare;
  pieceType = 'b';
  isWhite = pieceIsWhite;
  hasMoved = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x93c0
movq -0x18(%rbp), %rax
leaq 0x5f76(%rip), %rcx      # 0xeb80
addq $0x10, %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0xc(%rax)
movb $0x62, 0x8(%rax)
cmpl $0x0, -0x10(%rbp)
setne %cl
andb $0x1, %cl
movb %cl, 0x10(%rax)
movb $0x0, 0x11(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tlaloc1313[P]chess-project/Bishop.cpp
// Function: Bishop::move(int, bool*)
bool Bishop::move(int square, bool activeArray[64]){
  // Decoding square numbers:
  int fromRow = row(location);
  int fromCol = col(location);
  int toRow = row(square);
  int toCol = col(square);

  // Pieces can't move to the square they are already on.
  if (square == location) {
    return 0;
  }
  // Checks that the move is strictly diagonal, and uses 'checkDiagonal' to
  // ensure that no other pieces are in the way.
  if ((abs(toRow-fromRow) == abs(toCol-fromCol)) && checkDiagonal(square, activeArray) == -1) {
		location = square;
    hasMoved = 1;
		return 1;
  } else {
    return 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl 0xc(%rax), %edi
callq 0x47f0
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, -0x24(%rbp)
movl 0xc(%rax), %edi
callq 0x4810
movl %eax, -0x28(%rbp)
movl -0x14(%rbp), %edi
callq 0x47f0
movl %eax, -0x2c(%rbp)
movl -0x14(%rbp), %edi
callq 0x4810
movq -0x38(%rbp), %rcx
movl %eax, -0x30(%rbp)
movl -0x14(%rbp), %eax
cmpl 0xc(%rcx), %eax
jne 0x8c9f
movb $0x0, -0x1(%rbp)
jmp 0x8cea
movl -0x2c(%rbp), %eax
subl -0x24(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl -0x30(%rbp), %ecx
subl -0x28(%rbp), %ecx
movl %ecx, %edx
negl %edx
cmovnsl %edx, %ecx
cmpl %ecx, %eax
jne 0x8ce6
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x96b0
cmpl $-0x1, %eax
jne 0x8ce6
movq -0x38(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0xc(%rax)
movb $0x1, 0x11(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x8cea
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tlaloc1313[P]chess-project/King.cpp
// Function: King::King(int, int)
King::King(int startingSquare, int pieceIsWhite){
  location = startingSquare;
  pieceType = 'k';
  isWhite = pieceIsWhite;
  hasMoved = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x93c0
movq -0x18(%rbp), %rax
leaq 0x5e56(%rip), %rcx      # 0xebd0
addq $0x10, %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0xc(%rax)
movb $0x6b, 0x8(%rax)
cmpl $0x0, -0x10(%rbp)
setne %cl
andb $0x1, %cl
movb %cl, 0x10(%rax)
movb $0x0, 0x11(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tlaloc1313[P]chess-project/King.cpp
// Function: King::move(int, bool*)
bool King::move(int square, bool activeArray[64]){
  //Decoding square numbers:
  int fromRow = row(location);
  int fromCol = col(location);
  int toRow = row(square);
  int toCol = col(square);

  // Same square check
  if (square==location){
    return 0;
  }

  // The king can move 1 square in any direction
  if ( abs(fromRow-toRow)<2 && abs(fromCol-toCol)<2 ){
    location = square;
    hasMoved = 1;
    return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl 0xc(%rax), %edi
callq 0x47f0
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, -0x24(%rbp)
movl 0xc(%rax), %edi
callq 0x4810
movl %eax, -0x28(%rbp)
movl -0x14(%rbp), %edi
callq 0x47f0
movl %eax, -0x2c(%rbp)
movl -0x14(%rbp), %edi
callq 0x4810
movq -0x38(%rbp), %rcx
movl %eax, -0x30(%rbp)
movl -0x14(%rbp), %eax
cmpl 0xc(%rcx), %eax
jne 0x8e0f
movb $0x0, -0x1(%rbp)
jmp 0x8e4b
movl -0x24(%rbp), %eax
subl -0x2c(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cmpl $0x2, %eax
jge 0x8e47
movl -0x28(%rbp), %eax
subl -0x30(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cmpl $0x2, %eax
jge 0x8e47
movq -0x38(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0xc(%rax)
movb $0x1, 0x11(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x8e4b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tlaloc1313[P]chess-project/King.cpp
// Function: King::castle(int)
void King::castle(int square){
  if (hasMoved == 0){
    location = square;
    hasMoved = 1;
  }
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb 0x11(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x8e8e
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0xc(%rax)
movb $0x1, 0x11(%rax)
popq %rbp
retq
// File: tlaloc1313[P]chess-project/Knight.cpp
// Function: Knight::move(int, bool*)
bool Knight::move(int square, bool activeArray[64]){
  int currentPos = location;
  int dist = abs(currentPos - square);

  // Checks that the move is legal using relative position of start and end space.
  if (dist == 6 || dist == 10 || dist == 15 || dist == 17) {
    // Move is illegal if it involves going off the edge of the board
    if (row(currentPos)<2 && row(square)>5) {
      return 0;
    }
    if (row(currentPos)>5 && row(square)<2) {
      return 0;
    }
    if (col(currentPos)<2 && col(square)>5) {
      return 0;
    }
    if (col(currentPos)>5 && col(square)<2) {
      return 0;
    }

    // Moves piece and returns
    location = square;
    hasMoved = 1;
    return 1;
  }
	return 0; // Failure
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl 0xc(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x28(%rbp)
cmpl $0x6, -0x28(%rbp)
je 0x8f8d
cmpl $0xa, -0x28(%rbp)
je 0x8f8d
cmpl $0xf, -0x28(%rbp)
je 0x8f8d
cmpl $0x11, -0x28(%rbp)
jne 0x9021
movl -0x24(%rbp), %edi
callq 0x47f0
cmpl $0x2, %eax
jge 0x8fad
movl -0x14(%rbp), %edi
callq 0x47f0
cmpl $0x5, %eax
jle 0x8fad
movb $0x0, -0x1(%rbp)
jmp 0x9025
movl -0x24(%rbp), %edi
callq 0x47f0
cmpl $0x5, %eax
jle 0x8fcd
movl -0x14(%rbp), %edi
callq 0x47f0
cmpl $0x2, %eax
jge 0x8fcd
movb $0x0, -0x1(%rbp)
jmp 0x9025
movl -0x24(%rbp), %edi
callq 0x4810
cmpl $0x2, %eax
jge 0x8fed
movl -0x14(%rbp), %edi
callq 0x4810
cmpl $0x5, %eax
jle 0x8fed
movb $0x0, -0x1(%rbp)
jmp 0x9025
movl -0x24(%rbp), %edi
callq 0x4810
cmpl $0x5, %eax
jle 0x900d
movl -0x14(%rbp), %edi
callq 0x4810
cmpl $0x2, %eax
jge 0x900d
movb $0x0, -0x1(%rbp)
jmp 0x9025
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0xc(%rax)
movb $0x1, 0x11(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x9025
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: tlaloc1313[P]chess-project/Pawn.cpp
// Function: Pawn::Pawn(int, int)
Pawn::Pawn(int startingSquare, int pieceIsWhite){
  location = startingSquare;
  pieceType = 'p';
  isWhite = pieceIsWhite;
  hasMoved = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x93c0
movq -0x18(%rbp), %rax
leaq 0x5bc6(%rip), %rcx      # 0xec70
addq $0x10, %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0xc(%rax)
movb $0x70, 0x8(%rax)
cmpl $0x0, -0x10(%rbp)
setne %cl
andb $0x1, %cl
movb %cl, 0x10(%rax)
movb $0x0, 0x11(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tlaloc1313[P]chess-project/Piece.cpp
// Function: Piece::direction(int)
int Piece::direction(int destination){
	int dir;

	if (col(location) < col(destination)) {
		if (row(location) < row(destination)) {
			dir = 1;
		} else if (row(location) > row(destination)) {
			dir = 7;
		} else {
			dir = 0;
		}
	} else if (col(location) > col(destination)) {
		if (row(location) < row(destination)) {
			dir = 3;
		} else if (row(location) > row(destination)) {
			dir = 5;
		} else {
			dir = 4;
		}
	} else {
		if (row(location) < row(destination)) {
			dir = 2;
		} else {
			dir = 6;
		}
	}
	return dir;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0xc(%rax), %edi
callq 0x4810
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %edi
callq 0x4810
movl %eax, %ecx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jge 0x9483
movq -0x20(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x47f0
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %edi
callq 0x47f0
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x944c
movl $0x1, -0x10(%rbp)
jmp 0x947e
movq -0x20(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x47f0
movl %eax, -0x28(%rbp)
movl -0xc(%rbp), %edi
callq 0x47f0
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
jle 0x9475
movl $0x7, -0x10(%rbp)
jmp 0x947c
movl $0x0, -0x10(%rbp)
jmp 0x947e
jmp 0x9534
movq -0x20(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x4810
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %edi
callq 0x4810
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jle 0x9500
movq -0x20(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x47f0
movl %eax, -0x30(%rbp)
movl -0xc(%rbp), %edi
callq 0x47f0
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
jge 0x94cc
movl $0x3, -0x10(%rbp)
jmp 0x94fe
movq -0x20(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x47f0
movl %eax, -0x34(%rbp)
movl -0xc(%rbp), %edi
callq 0x47f0
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jle 0x94f5
movl $0x5, -0x10(%rbp)
jmp 0x94fc
movl $0x4, -0x10(%rbp)
jmp 0x94fe
jmp 0x9532
movq -0x20(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x47f0
movl %eax, -0x38(%rbp)
movl -0xc(%rbp), %edi
callq 0x47f0
movl %eax, %ecx
movl -0x38(%rbp), %eax
cmpl %ecx, %eax
jge 0x9529
movl $0x2, -0x10(%rbp)
jmp 0x9530
movl $0x6, -0x10(%rbp)
jmp 0x9532
jmp 0x9534
movl -0x10(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: tlaloc1313[P]chess-project/Piece.cpp
// Function: Piece::checkStraight(int, bool*)
int Piece::checkStraight(int destination, bool activeArray[64]) {
	int dir = direction(destination);

	int east, north, west, south;

	switch (dir) {
		case 0: //East
			for (east = location+8; east < destination; east+=8) {
				if (activeArray[east] == 1) {
					return east;
				}
			}
			break;
		case 2: //North
			for (north = location+1; north < destination; north++) {
				if (activeArray[north] == 1) {
					return north;
				}
			}
			break;
		case 4: //West
			for (west = location-8; west > destination; west-=8) {
				if (activeArray[west] == 1) {
					return west;
				}
			}
			break;
		case 6: //South
			for (south = location-1; south > destination; south--) {
				if (activeArray[south] == 1) {
					return south;
				}
			}
			break;
	}

	//If there are no pieces found
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl -0x14(%rbp), %esi
callq 0x93f0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x40(%rbp)
subq $0x6, %rax
ja 0x969b
movq -0x40(%rbp), %rax
leaq 0x114a(%rip), %rcx      # 0xa6cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x48(%rbp), %rax
movl 0xc(%rax), %eax
addl $0x8, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x95cd
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x95c0
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x96a2
jmp 0x95c2
movl -0x28(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x28(%rbp)
jmp 0x9598
jmp 0x969b
movq -0x48(%rbp), %rax
movl 0xc(%rax), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x9614
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x9607
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x96a2
jmp 0x9609
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x95df
jmp 0x969b
movq -0x48(%rbp), %rax
movl 0xc(%rax), %eax
subl $0x8, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x9658
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x964b
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x96a2
jmp 0x964d
movl -0x30(%rbp), %eax
subl $0x8, %eax
movl %eax, -0x30(%rbp)
jmp 0x9626
jmp 0x969b
movq -0x48(%rbp), %rax
movl 0xc(%rax), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x9699
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x968c
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x96a2
jmp 0x968e
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x9667
jmp 0x969b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: tlaloc1313[P]chess-project/Piece.cpp
// Function: Piece::checkDiagonal(int, bool*)
int Piece::checkDiagonal(int destination, bool activeArray[64]) {
	int dir = direction(destination);
	switch (dir) {
		case 1: //North East
			for (int ne = location+9; ne < destination; ne+=9) {
				if (activeArray[ne] == 1) {
					return ne;
				}
			}
			break;
		case 3: //North West
			for (int nw = location-7; nw > destination; nw-=7) {
				if (activeArray[nw] == 1) {
					return nw;
				}
			}
			break;
		case 5: //South West
			for (int sw = location-9; sw > destination; sw-=9) {
				if (activeArray[sw] == 1) {
					return sw;
				}
			}
			break;
		case 7: //South East
			for (int se = location+7; se < destination; se+=7) {
				if (activeArray[se] == 1) {
					return se;
				}
			}
			break;
	}

	//If there are no pieces found
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl -0x14(%rbp), %esi
callq 0x93f0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x40(%rbp)
subl $0x6, %eax
ja 0x980e
movq -0x40(%rbp), %rax
leaq 0xff3(%rip), %rcx       # 0xa6e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x48(%rbp), %rax
movl 0xc(%rax), %eax
addl $0x9, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x9740
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x9733
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9815
jmp 0x9735
movl -0x28(%rbp), %eax
addl $0x9, %eax
movl %eax, -0x28(%rbp)
jmp 0x970b
jmp 0x980e
movq -0x48(%rbp), %rax
movl 0xc(%rax), %eax
subl $0x7, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x9787
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x977a
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9815
jmp 0x977c
movl -0x2c(%rbp), %eax
subl $0x7, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9752
jmp 0x980e
movq -0x48(%rbp), %rax
movl 0xc(%rax), %eax
subl $0x9, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x97cb
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x97be
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9815
jmp 0x97c0
movl -0x30(%rbp), %eax
subl $0x9, %eax
movl %eax, -0x30(%rbp)
jmp 0x9799
jmp 0x980e
movq -0x48(%rbp), %rax
movl 0xc(%rax), %eax
addl $0x7, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x980c
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x97ff
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9815
jmp 0x9801
movl -0x34(%rbp), %eax
addl $0x7, %eax
movl %eax, -0x34(%rbp)
jmp 0x97da
jmp 0x980e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: tlaloc1313[P]chess-project/Queen.cpp
// Function: Queen::Queen(int, int)
Queen::Queen(int startingSquare, int pieceIsWhite){
  location = startingSquare;
  pieceType = 'q';
  isWhite = pieceIsWhite;
  hasMoved = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x93c0
movq -0x18(%rbp), %rax
leaq 0x539e(%rip), %rcx      # 0xed08
addq $0x10, %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0xc(%rax)
movb $0x71, 0x8(%rax)
cmpl $0x0, -0x10(%rbp)
setne %cl
andb $0x1, %cl
movb %cl, 0x10(%rax)
movb $0x0, 0x11(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tlaloc1313[P]chess-project/Queen.cpp
// Function: Queen::checkPath(int, bool*)
bool Queen::checkPath(int destination, bool activeArray[64]){
	int dir = direction(destination);
	if (dir%2 == 0) {
		if (checkStraight(destination, activeArray) == -1) {
			return 1;
		}
	} else {
		if (checkDiagonal(destination, activeArray) == -1) {
			return 1;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0x14(%rbp), %esi
callq 0x93f0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x99f3
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x9540
cmpl $-0x1, %eax
jne 0x99f1
movb $0x1, -0x1(%rbp)
jmp 0x9a14
jmp 0x9a10
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x96b0
cmpl $-0x1, %eax
jne 0x9a0e
movb $0x1, -0x1(%rbp)
jmp 0x9a14
jmp 0x9a10
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: tlaloc1313[P]chess-project/Queen.cpp
// Function: Queen::move(int, bool*)
bool Queen::move(int square, bool activeArray[64]){
	int currentLocation = location;
  // Illegal if moving to current position
  if (currentLocation == square) {
    return 0;
  }

  // Move OK if piece is moving to same row or col OR moving diagonally
  // AND path is free
  if (  ((row(currentLocation) == row(square)
        || col(currentLocation) == col(square))
        || (abs(row(square)-row(location)) == abs(col(square)-col(location))))
      && checkPath(square, activeArray)){
    location = square;
    hasMoved = 1;
    return 1;
  }
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl 0xc(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x9a52
movb $0x0, -0x1(%rbp)
jmp 0x9b10
movl -0x24(%rbp), %edi
callq 0x47f0
movl %eax, -0x34(%rbp)
movl -0x14(%rbp), %edi
callq 0x47f0
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
je 0x9ae2
movl -0x24(%rbp), %edi
callq 0x4810
movl %eax, -0x38(%rbp)
movl -0x14(%rbp), %edi
callq 0x4810
movl %eax, %ecx
movl -0x38(%rbp), %eax
cmpl %ecx, %eax
je 0x9ae2
movl -0x14(%rbp), %edi
callq 0x47f0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x44(%rbp)
movl 0xc(%rax), %edi
callq 0x47f0
movl %eax, %ecx
movl -0x44(%rbp), %eax
subl %ecx, %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x3c(%rbp)
movl -0x14(%rbp), %edi
callq 0x4810
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x40(%rbp)
movl 0xc(%rax), %edi
callq 0x4810
movl -0x40(%rbp), %ecx
movl %eax, %edx
movl -0x3c(%rbp), %eax
subl %edx, %ecx
movl %ecx, %edx
negl %edx
cmovnsl %edx, %ecx
cmpl %ecx, %eax
jne 0x9b0c
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq (%rdi), %rax
callq *(%rax)
testb $0x1, %al
jne 0x9af8
jmp 0x9b0c
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0xc(%rax)
movb $0x1, 0x11(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x9b10
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: tlaloc1313[P]chess-project/Rook.cpp
// Function: Rook::Rook(int, int)
Rook::Rook(int startingSquare, int pieceIsWhite){
  location = startingSquare;
  pieceType = 'r';
  isWhite = pieceIsWhite;
  hasMoved = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x93c0
movq -0x18(%rbp), %rax
leaq 0x51be(%rip), %rcx      # 0xed58
addq $0x10, %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0xc(%rax)
movb $0x72, 0x8(%rax)
cmpl $0x0, -0x10(%rbp)
setne %cl
andb $0x1, %cl
movb %cl, 0x10(%rax)
movb $0x0, 0x11(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tlaloc1313[P]chess-project/Rook.cpp
// Function: Rook::move(int, bool*)
bool Rook::move(int square, bool activeArray[64]){
  int currentLocation = location;
  //Illegal if moving to current position
  if (currentLocation == square) {
    return 0;
  }

  // Move is legal if piece is moving to same row or col and path is empty
  if ((row(currentLocation) == row(square) || col(currentLocation) == col(square)) && checkStraight(square, activeArray) == -1) {
    location = square;
    hasMoved = 1;
    return 1;
  }
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl 0xc(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x9bff
movb $0x0, -0x1(%rbp)
jmp 0x9c64
movl -0x24(%rbp), %edi
callq 0x47f0
movl %eax, -0x34(%rbp)
movl -0x14(%rbp), %edi
callq 0x47f0
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
je 0x9c37
movl -0x24(%rbp), %edi
callq 0x4810
movl %eax, -0x38(%rbp)
movl -0x14(%rbp), %edi
callq 0x4810
movl %eax, %ecx
movl -0x38(%rbp), %eax
cmpl %ecx, %eax
jne 0x9c60
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x9540
cmpl $-0x1, %eax
jne 0x9c60
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0xc(%rax)
movb $0x1, 0x11(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x9c64
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: tlaloc1313[P]chess-project/Rook.cpp
// Function: Rook::castle(int)
void Rook::castle(int square){
  if (hasMoved == 0){
    location = square;
    hasMoved = 1;
  }
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb 0x11(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x9c9e
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0xc(%rax)
movb $0x1, 0x11(%rax)
popq %rbp
retq
// File: kdungs[P]codecon/src/gloves.cc
// Function: isPalindrome(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
auto isPalindrome(const std::string& str) -> bool {
  auto l = std::begin(str);
  auto r = std::end(str);
  --r;  // since end(str) points to the first position after str

  while (std::distance(l, r) > 0u) {
    if (*l != *r) {
      return false;
    }
    ++l;
    --r;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x25d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2600
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2630
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2650
cmpq $0x0, %rax
jle 0x23e1
leaq -0x18(%rbp), %rdi
callq 0x2690
movsbl (%rax), %eax
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2690
movq %rax, %rcx
movl -0x34(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x23cd
movb $0x0, -0x1(%rbp)
jmp 0x23e5
leaq -0x18(%rbp), %rdi
callq 0x26b0
leaq -0x20(%rbp), %rdi
callq 0x2630
jmp 0x237f
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: kdungs[P]codecon/src/gloves.cc
// Function: main
int main() {
  auto gm = GloveMatcher{};

  auto line = std::string{};
  getline(std::cin, line);  // ignore number
  while (getline(std::cin, line)) {
    gm.process(line);
  }

  std::cout << gm.matched() << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2770
leaq -0x70(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x2190
movq -0x88(%rbp), %rsi
movq 0x5af4(%rip), %rdi      # 0x7fe0
callq 0x2030
jmp 0x24f3
jmp 0x24f5
movq 0x5ae4(%rip), %rdi      # 0x7fe0
leaq -0x70(%rbp), %rsi
callq 0x2030
movq %rax, -0x90(%rbp)
jmp 0x250e
movq -0x90(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2160
movb %al, -0x91(%rbp)
jmp 0x252c
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x2538
jmp 0x2569
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2790
jmp 0x2547
jmp 0x24f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x20d0
leaq -0x50(%rbp), %rdi
callq 0x28e0
jmp 0x25ba
leaq -0x50(%rbp), %rdi
callq 0x28a0
movl %eax, %esi
movq 0x5a55(%rip), %rdi      # 0x7fd0
callq 0x21e0
movq %rax, -0xa0(%rbp)
jmp 0x2589
movq -0xa0(%rbp), %rdi
movl $0xa, %esi
callq 0x2150
jmp 0x259c
leaq -0x70(%rbp), %rdi
callq 0x20d0
leaq -0x50(%rbp), %rdi
callq 0x28e0
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x21f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: kdungs[P]codecon/src/gloves.cc
// Function: GloveMatcher::process(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
auto process(const std::string& item) -> void {
    if (isPalindrome(item)) {  // we found a hat!
      return;
    }

    const auto hint = cache_.find(item);
    if (hint != cache_.end()) {
      cache_.erase(hint);
      ++matched_;
    } else {
      cache_.emplace(reverse(item));
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2350
testb $0x1, %al
jne 0x27ba
jmp 0x27bf
jmp 0x2885
movq -0x70(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x2b50
movq -0x70(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x8, %rdi
callq 0x2bb0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2b80
testb $0x1, %al
jne 0x27f8
jmp 0x2825
movq -0x70(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x2be0
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x30(%rbp)
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x2885
movq -0x70(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x23f0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x2c20
movq %rax, -0x78(%rbp)
jmp 0x285b
movq -0x78(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x20d0
jmp 0x2885
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x20d0
jmp 0x288e
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x21f0
nopw (%rax,%rax)
// File: raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::Tree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Tree::Tree(
	std::string& input,
	std::string alphabet
	):
	input(input),
	alphabet(alphabet),
	B(input.length() + 1, 0),
	B_i(0),
	ranDFS(false),
	nIntNodes(1),
	nLeaves(0)
{
	input += '$';

	size_t size = sizeof(Node) * input.length() * 2;
	alloc_buf = (Node*)malloc(size);
	bzero(alloc_buf, size);

	alloc_i = 0;

	nextNodeId = input.length();
	root = newNode(assignId(), nullptr, 0, 0);
	lowestIntNode = root;
	root->suffixLink = root;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x68(%rbp)
movq %rsi, %rax
movq -0x68(%rbp), %rsi
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x18, %rdi
movq %rdi, -0x60(%rbp)
callq 0x20a0
movq -0x58(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x40(%rax)
movl $0x0, 0x50(%rax)
movb $0x0, 0x54(%rax)
movl $0x1, 0x58(%rax)
movl $0x0, 0x5c(%rax)
addq $0x68, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2290
incq %rax
movq %rax, -0x48(%rbp)
movb $0x0, -0x19(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x22f0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rcx
leaq -0x19(%rbp), %rdx
callq 0x3800
jmp 0x25ac
leaq -0x1a(%rbp), %rdi
callq 0x21d0
movq -0x10(%rbp), %rdi
movl $0x24, %esi
callq 0x2100
jmp 0x25c5
movq -0x10(%rbp), %rdi
callq 0x2290
imulq $0xb0, %rax, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2250
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rdi
movq -0x38(%rbp), %rdx
xorl %esi, %esi
callq 0x20d0
movq -0x58(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x2290
movq -0x58(%rbp), %rdi
movl %eax, 0x48(%rdi)
callq 0x2730
movl %eax, -0x6c(%rbp)
jmp 0x261f
movl -0x6c(%rbp), %esi
movq -0x58(%rbp), %rdi
xorl %r8d, %r8d
movl %r8d, %edx
movl %r8d, %ecx
callq 0x26b0
movq %rax, -0x78(%rbp)
jmp 0x263a
movq -0x58(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rcx
movq %rcx, 0x60(%rax)
movq 0x10(%rax), %rcx
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0x21d0
jmp 0x268f
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3880
movq -0x60(%rbp), %rdi
callq 0x20f0
movq -0x28(%rbp), %rdi
callq 0x22e0
nopw %cs:(%rax,%rax)
// File: raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::newNode(int, suffixtree::Node*, int, int)
Node *Tree::newNode(int id, Node *parent, int beg, int len) {
	Node *nxt = &alloc_buf[alloc_i++];
	nxt->id = id;
	nxt->parent = parent;
	nxt->beg = beg;
	nxt->len = len;
	if (parent != nullptr) {
		nxt->stringDepth = parent->stringDepth + len;
	}
	return nxt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x8(%rbp), %rdx
movq (%rdx), %rax
movl 0x8(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x8(%rdx)
movslq %ecx, %rcx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x50(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x48(%rax)
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4c(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x2727
movq -0x18(%rbp), %rax
movl 0x54(%rax), %ecx
addl -0x20(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x54(%rax)
movq -0x28(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::Build()
void Tree::Build() {
	Node *n = root;
	for (int i = 0; i < input.length(); i++) {
		n = insertSuffix(n, i);
	}
	DisplayChildren(root);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq 0x40(%rax), %rdi
callq 0x2290
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x27b3
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x27d0
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2773
movq -0x20(%rbp), %rdi
movq 0x10(%rdi), %rsi
callq 0x2a70
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::DisplayChildren(suffixtree::Node*)
void
Tree::DisplayChildren(
	Node *node
	)
{
	Node *child = node->child;

	while (child != nullptr) {
		std::cout << "Node id: " << child->id << "Edge label: '";
		for (int i = child->beg; i < child->len + child->beg; i++) {
			std::cout << input[i];
		}
		std::cout << "'" << std::endl;

		child = child->sibling;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2b4d
movq 0x5532(%rip), %rdi      # 0x7fd8
leaq 0x25d0(%rip), %rsi      # 0x507d
callq 0x2180
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x50(%rax), %esi
callq 0x22d0
movq %rax, %rdi
leaq 0x25bc(%rip), %rsi      # 0x5087
callq 0x2180
movq -0x18(%rbp), %rax
movl 0x48(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
movl 0x4c(%rcx), %ecx
movq -0x18(%rbp), %rdx
addl 0x48(%rdx), %ecx
cmpl %ecx, %eax
jge 0x2b1a
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x2340
movq 0x54d1(%rip), %rdi      # 0x7fd8
movsbl (%rax), %esi
callq 0x2200
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2ada
movq 0x54b7(%rip), %rdi      # 0x7fd8
leaq 0x256b(%rip), %rsi      # 0x5093
callq 0x2180
movq %rax, %rdi
movq 0x5491(%rip), %rsi      # 0x7fc8
callq 0x21b0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2a94
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::getChildByLabelBeginning(suffixtree::Node*, char)
Node *
Tree::getChildByLabelBeginning(
	Node *n,
	char c
	)
{
	Node *cur = n->child;
	while (cur != nullptr)
	{
		if (input[cur->beg] == c)
			return cur;
		cur = cur->sibling;
	}
	return cur;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2d78
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x28(%rbp), %rax
movslq 0x48(%rax), %rsi
callq 0x2340
movsbl (%rax), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jne 0x2d6a
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2d80
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x2d39
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::addChildToNode(suffixtree::Node*, suffixtree::Node*)
void 
Tree::addChildToNode(
	Node *parent,
	Node *child
	)
{
	Node *cur = parent->child;
	if (cur == nullptr) {
		parent->child = child;
		return;
	}

	char k = input[child->beg];
	if (k == '$') {
		if (cur != nullptr && input[cur->beg] == '$') {
			panic("shouldnt already have child with this label");
		}

		child->sibling = cur;
		parent->child = child;
		return;
	}

	Node *prev = nullptr;
	while(cur != nullptr) {
		if (k < input[cur->beg]) {
			child->sibling = cur;
			if (prev == nullptr) {
				parent->child = child;
			} else {
				prev->sibling = child;
			}
			return;
		}

		prev = cur;
		cur = cur->sibling;
	}
	prev->sibling = child;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2dd0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x2ee1
movq -0x38(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x18(%rbp), %rax
movslq 0x48(%rax), %rsi
callq 0x2340
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x24, %eax
jne 0x2e58
cmpq $0x0, -0x20(%rbp)
je 0x2e3b
movq -0x38(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x20(%rbp), %rax
movslq 0x48(%rax), %rsi
callq 0x2340
movsbl (%rax), %eax
cmpl $0x24, %eax
jne 0x2e3b
leaq 0x222c(%rip), %rdi      # 0x504a
leaq 0x2212(%rip), %rsi      # 0x5037
movl $0x101, %edx            # imm = 0x101
movb $0x0, %al
callq 0x2030
movl $0x1, %edi
callq 0x2210
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x2ee1
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2ed5
movq -0x38(%rbp), %rax
movsbl -0x21(%rbp), %ecx
movl %ecx, -0x3c(%rbp)
movq 0x40(%rax), %rdi
movq -0x20(%rbp), %rax
movslq 0x48(%rax), %rsi
callq 0x2340
movq %rax, %rcx
movl -0x3c(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x2ebf
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x30(%rbp)
jne 0x2eb1
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x2ebd
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x2ee1
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2e60
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::breakEdge(suffixtree::Node*, int)
Node *
Tree::breakEdge(
	Node *n,
	int i
	)
{
	//printf("= breakEdge(%d)\n", i);
	Node *parent = nullptr, *nNode = nullptr;

	parent = n->parent;

	//Make new node
	nNode = newNode(assignId(), parent, n->beg, i);
	//Remove n from parent's children, replace with new node.
	replaceChild(parent, nNode);

	n->sibling = nullptr;

	//Insert n under new node
	addChildToNode(nNode, n);

	//Alter n
	n->beg = n->beg + i;
	n->parent = nNode;
	n->len = n->len - i;

	//We have a new internal node
	nIntNodes++;
	if (lowestIntNode == nullptr ||
		nNode->stringDepth > lowestIntNode->stringDepth) {
		lowestIntNode = nNode;
	}

	return nNode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x2730
movq -0x30(%rbp), %rdi
movl %eax, %esi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x48(%rax), %ecx
movl -0x14(%rbp), %r8d
callq 0x26b0
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x3130
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x2d90
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x48(%rcx), %edx
addl -0x14(%rbp), %edx
movq -0x10(%rbp), %rcx
movl %edx, 0x48(%rcx)
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, (%rcx)
movq -0x10(%rbp), %rcx
movl 0x4c(%rcx), %edx
subl -0x14(%rbp), %edx
movq -0x10(%rbp), %rcx
movl %edx, 0x4c(%rcx)
movl 0x58(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x58(%rax)
cmpq $0x0, 0x60(%rax)
je 0x2fcc
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movl 0x54(%rax), %eax
movq 0x60(%rcx), %rcx
cmpl 0x54(%rcx), %eax
jle 0x2fd8
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x60(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::nodeHopToV(suffixtree::Node*, int, int)
Node *
Tree::nodeHopToV(
	Node *start,
	int beta,
	int len
	)
{
	int i = 0, remaining;
	char c;
	Node *n1 = start, *n2;

	if (len == 0)
		return start;

	while (true) {
		remaining = len - i;
		c = input[beta + i];
		n2 = getChildByLabelBeginning(n1, c);


		if (n2->len > remaining) {
			//break edge right before index 'remaining' of the edge.
			return breakEdge(n2, remaining);

		} else if (n2->len == remaining) {
			//Beta is perfectly consumed, we have found V.
			return n2;

		} else {
			//Travel edge, consume part of beta
			i += n2->len;
			n1 = n2;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x3090
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x311f
jmp 0x3092
movq -0x48(%rbp), %rax
movl -0x20(%rbp), %ecx
subl -0x24(%rbp), %ecx
movl %ecx, -0x28(%rbp)
movq 0x40(%rax), %rdi
movl -0x1c(%rbp), %eax
addl -0x24(%rbp), %eax
movslq %eax, %rsi
callq 0x2340
movq -0x48(%rbp), %rdi
movb (%rax), %al
movb %al, -0x29(%rbp)
movq -0x38(%rbp), %rsi
movsbl -0x29(%rbp), %edx
callq 0x2d10
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl 0x4c(%rax), %eax
cmpl -0x28(%rbp), %eax
jle 0x30ed
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl -0x28(%rbp), %edx
callq 0x2ef0
movq %rax, -0x8(%rbp)
jmp 0x311f
movq -0x40(%rbp), %rax
movl 0x4c(%rax), %eax
cmpl -0x28(%rbp), %eax
jne 0x3103
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x311f
movq -0x40(%rbp), %rax
movl 0x4c(%rax), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x311a
jmp 0x3092
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)