LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: niekh1234[P]nnchesslib/movegen.cpp
// Function: nnchesslib::genWhiteDoublePawnMoves(nnchesslib::ChessBoard, std::vector<unsigned int, std::allocator<unsigned int>>&, nnchesslib::BitBoard)
void nnchesslib::genWhiteDoublePawnMoves(ChessBoard board, MoveList& moveList, BitBoard blockers)
{
    // targetting pawns that are on the second rank. These are the only pawns that can move twice.
    BitBoard unmovedPawns = board.getBoard(WHITE, PAWN).board & rank_bb[RANK_2];
    // moving pawns once to check if they are blocked:
    BitBoard firstMove = (unmovedPawns.board << 8) & ~blockers.board;
    // moving again:
    BitBoard secondMove = (firstMove.board << 8) & ~blockers.board;

    int validPawnCount = __builtin_popcountll(secondMove.board);

    for(int _ = 0; _ < validPawnCount; _++)
    {
        // finding current index of pawn.
        int index = popLsb(secondMove.board);

        if (index == -1)
            continue;
        // adding to pseudo legal movelist. 
        Move move = createMove(index - 16, index);
        moveList.push_back(move);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, %rax
leaq 0x10(%rbp), %rdi
movq %rsi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movl $0x1, %esi
xorl %edx, %edx
callq 0x76f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
andq 0x31a6(%rip), %rsi      # 0xeb68
leaq -0x18(%rbp), %rdi
callq 0x4bc0
movq -0x18(%rbp), %rsi
shlq $0x8, %rsi
movq -0x8(%rbp), %rax
xorq $-0x1, %rax
andq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x4bc0
movq -0x28(%rbp), %rsi
shlq $0x8, %rsi
movq -0x8(%rbp), %rax
xorq $-0x1, %rax
andq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x4bc0
movq -0x30(%rbp), %rcx
movq %rcx, %rax
shrq %rax
movabsq $0x5555555555555555, %rdx # imm = 0x5555555555555555
andq %rdx, %rax
subq %rax, %rcx
movabsq $0x3333333333333333, %rdx # imm = 0x3333333333333333
movq %rcx, %rax
andq %rdx, %rax
shrq $0x2, %rcx
andq %rdx, %rcx
addq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
addq %rcx, %rax
movabsq $0xf0f0f0f0f0f0f0f, %rcx # imm = 0xF0F0F0F0F0F0F0F
andq %rcx, %rax
movabsq $0x101010101010101, %rcx # imm = 0x101010101010101
imulq %rcx, %rax
shrq $0x38, %rax
movl %eax, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0xbaaf
leaq -0x30(%rbp), %rdi
callq 0xc970
movl %eax, -0x3c(%rbp)
cmpl $-0x1, -0x3c(%rbp)
jne 0xba86
jmp 0xbaa4
movl -0x3c(%rbp), %edi
subl $0x10, %edi
movl -0x3c(%rbp), %esi
callq 0xaab0
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xcbd0
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xba6a
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: niekh1234[P]nnchesslib/movegen.cpp
// Function: nnchesslib::genBlackDoublePawnMoves(nnchesslib::ChessBoard, std::vector<unsigned int, std::allocator<unsigned int>>&, nnchesslib::BitBoard)
void nnchesslib::genBlackDoublePawnMoves(ChessBoard board, MoveList& moveList, BitBoard blockers)
{
    // targetting pawns that are on the second rank. These are the only pawns that can move twice.
    BitBoard unmovedPawns = board.getBoard(BLACK, PAWN).board & rank_bb[RANK_7];
    // moving pawns once to check if they are blocked:
    BitBoard firstMove = (unmovedPawns.board >> 8) & ~blockers.board;
    // moving again:
    BitBoard secondMove = (firstMove.board >> 8) & ~blockers.board;

    int validPawnCount = __builtin_popcountll(secondMove.board);

    for(int _ = 0; _ < validPawnCount; _++)
    {
        // finding current index of pawn.
        int index = popLsb(secondMove.board);

        if (index == -1)
            continue;
        // adding to pseudo legal movelist. 
        Move move = createMove(index + 16, index);
        moveList.push_back(move);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, %rax
leaq 0x10(%rbp), %rdi
movq %rsi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
xorl %edx, %edx
movl %edx, %esi
callq 0x76f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
andq 0x2581(%rip), %rsi      # 0xeb90
leaq -0x18(%rbp), %rdi
callq 0x4bc0
movq -0x18(%rbp), %rsi
shrq $0x8, %rsi
movq -0x8(%rbp), %rax
xorq $-0x1, %rax
andq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x4bc0
movq -0x28(%rbp), %rsi
shrq $0x8, %rsi
movq -0x8(%rbp), %rax
xorq $-0x1, %rax
andq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x4bc0
movq -0x30(%rbp), %rcx
movq %rcx, %rax
shrq %rax
movabsq $0x5555555555555555, %rdx # imm = 0x5555555555555555
andq %rdx, %rax
subq %rax, %rcx
movabsq $0x3333333333333333, %rdx # imm = 0x3333333333333333
movq %rcx, %rax
andq %rdx, %rax
shrq $0x2, %rcx
andq %rdx, %rcx
addq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
addq %rcx, %rax
movabsq $0xf0f0f0f0f0f0f0f, %rcx # imm = 0xF0F0F0F0F0F0F0F
andq %rcx, %rax
movabsq $0x101010101010101, %rcx # imm = 0x101010101010101
imulq %rcx, %rax
shrq $0x38, %rax
movl %eax, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0xc6fc
leaq -0x30(%rbp), %rdi
callq 0xc970
movl %eax, -0x3c(%rbp)
cmpl $-0x1, -0x3c(%rbp)
jne 0xc6d3
jmp 0xc6f1
movl -0x3c(%rbp), %edi
addl $0x10, %edi
movl -0x3c(%rbp), %esi
callq 0xaab0
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xcbd0
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xc6b7
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: niekh1234[P]nnchesslib/movegen.cpp
// Function: nnchesslib::genPromotions(int, std::vector<unsigned int, std::allocator<unsigned int>>&, nnchesslib::Color, nnchesslib::BitBoard)
void nnchesslib::genPromotions(int pawnIndex, MoveList& moveList, Color color, BitBoard pawns)
{
    // counting the amount of attacked pawns.
    int count = __builtin_popcountll(pawns.board);

    for(int _ = 0; _ < count; _++)
    {
        int index = popLsb(pawns.board);
        
        Move queen = createMove(pawnIndex, index, QUEEN);
        Move knight = createMove(pawnIndex, index, KNIGHT);
        Move bishop = createMove(pawnIndex, index, BISHOP);
        Move rook = createMove(pawnIndex, index, ROOK);
        moveList.push_back(queen);
        moveList.push_back(knight);
        moveList.push_back(bishop);
        moveList.push_back(rook);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rcx, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, %rax
shrq %rax
movabsq $0x5555555555555555, %rdx # imm = 0x5555555555555555
andq %rdx, %rax
subq %rax, %rcx
movabsq $0x3333333333333333, %rdx # imm = 0x3333333333333333
movq %rcx, %rax
andq %rdx, %rax
shrq $0x2, %rcx
andq %rdx, %rcx
addq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
addq %rcx, %rax
movabsq $0xf0f0f0f0f0f0f0f, %rcx # imm = 0xF0F0F0F0F0F0F0F
andq %rcx, %rax
movabsq $0x101010101010101, %rcx # imm = 0x101010101010101
imulq %rcx, %rax
shrq $0x38, %rax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0xcae3
leaq -0x8(%rbp), %rdi
callq 0xc970
movl %eax, -0x28(%rbp)
movl -0xc(%rbp), %edi
movl -0x28(%rbp), %esi
movl $0x4, %edx
callq 0xaad0
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %edi
movl -0x28(%rbp), %esi
movl $0x1, %edx
callq 0xaad0
movl %eax, -0x30(%rbp)
movl -0xc(%rbp), %edi
movl -0x28(%rbp), %esi
movl $0x2, %edx
callq 0xaad0
movl %eax, -0x34(%rbp)
movl -0xc(%rbp), %edi
movl -0x28(%rbp), %esi
movl $0x3, %edx
callq 0xaad0
movl %eax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0xcbd0
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xcbd0
movq -0x18(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0xcbd0
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xcbd0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xca3d
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: niekh1234[P]nnchesslib/rays.cpp
// Function: nnchesslib::Rays::northWest(unsigned long long, int)
inline U64 Rays::northWest(U64 bRay, int n)
{
    U64 ray = bRay;
    for(int i = 0; i < n; i++)
    {
        ray = ((ray >> (U64)1) & ~0x8080808080808080ull);
    }
    return ray;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xd735
movq -0x18(%rbp), %rax
shrq %rax
movabsq $0x7f7f7f7f7f7f7f7f, %rcx # imm = 0x7F7F7F7F7F7F7F7F
andq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd70a
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: niekh1234[P]nnchesslib/rays.cpp
// Function: nnchesslib::Rays::northEast(unsigned long long, int)
inline U64 Rays::northEast(U64 bRay, int n)
{
    U64 ray = bRay;
    for(int i = 0; i < n; i++)
    {
        ray = (ray << ((U64)1) & ~0x0101010101010101ULL); 
    }
    return ray;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xd785
movq -0x18(%rbp), %rax
shlq %rax
movabsq $-0x101010101010102, %rcx # imm = 0xFEFEFEFEFEFEFEFE
andq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd75a
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: niekh1234[P]nnchesslib/utils.cpp
// Function: nnchesslib::countBits(unsigned long long)
int nnchesslib::countBits(U64 n)
{
    int output = 0;
    while (n != 0)
    {
        n &= (n - 1);
        output++;
    }
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xd7c1
movq -0x8(%rbp), %rax
subq $0x1, %rax
andq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xd79f
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: niekh1234[P]nnchesslib/utils.cpp
// Function: nnchesslib::getSquareString[abi:cxx11](int)
std::string nnchesslib::getSquareString(int square)
{
    assert(square >= 0 && square <= 63);
    int file = square % 8;
    int rank = square / 8 + 1;

    const char* files = "abcdefgh";

    return files[file] + std::to_string(rank);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x4d(%rbp)
jl 0xd89f
cmpl $0x3f, -0xc(%rbp)
setle %al
movb %al, -0x4d(%rbp)
movb -0x4d(%rbp), %al
testb $0x1, %al
jne 0xd8a8
jmp 0xd8aa
jmp 0xd8c9
leaq 0x1351(%rip), %rdi      # 0xec02
leaq 0x1366(%rip), %rsi      # 0xec1e
movl $0x29, %edx
leaq 0x1364(%rip), %rcx      # 0xec28
callq 0x3150
movl -0xc(%rbp), %eax
movl %eax, %edx
addl $0x7, %edx
testl %eax, %eax
movl %eax, %ecx
cmovsl %edx, %ecx
andl $-0x8, %ecx
subl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $0x7, %ecx
testl %eax, %eax
cmovsl %ecx, %eax
sarl $0x3, %eax
incl %eax
movl %eax, -0x14(%rbp)
leaq 0x1359(%rip), %rax      # 0xec55
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x6c(%rbp)
movl -0x14(%rbp), %esi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x9c90
movq -0x60(%rbp), %rdi
movl -0x6c(%rbp), %esi
movq -0x68(%rbp), %rdx
callq 0xd970
jmp 0xd931
leaq -0x40(%rbp), %rdi
callq 0x34a8
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x34a8
movq -0x48(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: lyqscmy[P]array_lock_free_queue/test.cpp
// Function: test_push()
void test_push() {
  ArrayLockFreeQueue<int, 3> q;
  q.push(1);
  assert(q.writeIndex == 1);
  assert(q.maximumReadIndex == 1);

  q.push(3);
  assert(q.writeIndex == 2);
  assert(q.maximumReadIndex == 2);

  q.push(5);
  assert(q.writeIndex == 3);
  assert(q.maximumReadIndex == 3);

  assert(!q.push(7));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x2940
movq -0x58(%rbp), %rdi
movl $0x1, -0x34(%rbp)
leaq -0x34(%rbp), %rsi
callq 0x29a0
jmp 0x125b
leaq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x2b80
cmpq $0x1, %rax
jne 0x1270
jmp 0x12a9
leaq 0x2db5(%rip), %rdi      # 0x402c
leaq 0x2dc0(%rip), %rsi      # 0x403e
movl $0xb, %edx
leaq 0x2dbd(%rip), %rcx      # 0x4047
callq 0x1060
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2c10
jmp 0x142d
leaq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x2b80
cmpq $0x1, %rax
jne 0x12be
jmp 0x12dd
leaq 0x2d93(%rip), %rdi      # 0x4058
leaq 0x2d72(%rip), %rsi      # 0x403e
movl $0xc, %edx
leaq 0x2d6f(%rip), %rcx      # 0x4047
callq 0x1060
movl $0x3, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x29a0
jmp 0x12f3
leaq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x2b80
cmpq $0x2, %rax
jne 0x1308
jmp 0x1327
leaq 0x2d61(%rip), %rdi      # 0x4070
leaq 0x2d28(%rip), %rsi      # 0x403e
movl $0xf, %edx
leaq 0x2d25(%rip), %rcx      # 0x4047
callq 0x1060
leaq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x2b80
cmpq $0x2, %rax
jne 0x133c
jmp 0x135b
leaq 0x2d3f(%rip), %rdi      # 0x4082
leaq 0x2cf4(%rip), %rsi      # 0x403e
movl $0x10, %edx
leaq 0x2cf1(%rip), %rcx      # 0x4047
callq 0x1060
movl $0x5, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
callq 0x29a0
jmp 0x1371
leaq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x2b80
cmpq $0x3, %rax
jne 0x1386
jmp 0x13a5
leaq 0x2d0d(%rip), %rdi      # 0x409a
leaq 0x2caa(%rip), %rsi      # 0x403e
movl $0x13, %edx
leaq 0x2ca7(%rip), %rcx      # 0x4047
callq 0x1060
leaq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x2b80
cmpq $0x3, %rax
jne 0x13ba
jmp 0x13d9
leaq 0x2ceb(%rip), %rdi      # 0x40ac
leaq 0x2c76(%rip), %rsi      # 0x403e
movl $0x14, %edx
leaq 0x2c73(%rip), %rcx      # 0x4047
callq 0x1060
movl $0x7, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x29a0
movb %al, -0x59(%rbp)
jmp 0x13f2
movb -0x59(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x13fd
jmp 0x13ff
jmp 0x141e
leaq 0x2cbe(%rip), %rdi      # 0x40c4
leaq 0x2c31(%rip), %rsi      # 0x403e
movl $0x16, %edx
leaq 0x2c2e(%rip), %rcx      # 0x4047
callq 0x1060
leaq -0x30(%rbp), %rdi
callq 0x2c10
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x10e0
nopw %cs:(%rax,%rax)
// File: lyqscmy[P]array_lock_free_queue/test.cpp
// Function: test_pop()
void test_pop() {
  ArrayLockFreeQueue<int, 3> q;
  q.push(1);
  q.push(3);
  q.push(5);
  int item = 0;

  q.pop(item);
  assert(q.readIndex == 1);
  assert(item == 1);

  q.pop(item);
  assert(q.readIndex == 2);
  assert(item == 3);

  q.pop(item);
  assert(q.readIndex == 3);
  assert(item == 5);

  assert(!q.pop(item));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x2940
movq -0x58(%rbp), %rdi
movl $0x1, -0x34(%rbp)
leaq -0x34(%rbp), %rsi
callq 0x29a0
jmp 0x146b
movl $0x3, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x29a0
jmp 0x1481
movl $0x5, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
callq 0x29a0
jmp 0x1497
movl $0x0, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2c20
jmp 0x14ad
leaq -0x30(%rbp), %rdi
addq $0x20, %rdi
callq 0x2b80
cmpq $0x1, %rax
jne 0x14c2
jmp 0x14fb
leaq 0x2c06(%rip), %rdi      # 0x40cf
leaq 0x2b6e(%rip), %rsi      # 0x403e
movl $0x21, %edx
leaq 0x2c04(%rip), %rcx      # 0x40e0
callq 0x1060
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2c10
jmp 0x1643
cmpl $0x1, -0x50(%rbp)
jne 0x1503
jmp 0x1522
leaq 0x2be6(%rip), %rdi      # 0x40f0
leaq 0x2b2d(%rip), %rsi      # 0x403e
movl $0x22, %edx
leaq 0x2bc3(%rip), %rcx      # 0x40e0
callq 0x1060
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2c20
jmp 0x1531
leaq -0x30(%rbp), %rdi
addq $0x20, %rdi
callq 0x2b80
cmpq $0x2, %rax
jne 0x1546
jmp 0x1565
leaq 0x2bad(%rip), %rdi      # 0x40fa
leaq 0x2aea(%rip), %rsi      # 0x403e
movl $0x25, %edx
leaq 0x2b80(%rip), %rcx      # 0x40e0
callq 0x1060
cmpl $0x3, -0x50(%rbp)
jne 0x156d
jmp 0x158c
leaq 0x2b97(%rip), %rdi      # 0x410b
leaq 0x2ac3(%rip), %rsi      # 0x403e
movl $0x26, %edx
leaq 0x2b59(%rip), %rcx      # 0x40e0
callq 0x1060
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2c20
jmp 0x159b
leaq -0x30(%rbp), %rdi
addq $0x20, %rdi
callq 0x2b80
cmpq $0x3, %rax
jne 0x15b0
jmp 0x15cf
leaq 0x2b5e(%rip), %rdi      # 0x4115
leaq 0x2a80(%rip), %rsi      # 0x403e
movl $0x29, %edx
leaq 0x2b16(%rip), %rcx      # 0x40e0
callq 0x1060
cmpl $0x5, -0x50(%rbp)
jne 0x15d7
jmp 0x15f6
leaq 0x2b48(%rip), %rdi      # 0x4126
leaq 0x2a59(%rip), %rsi      # 0x403e
movl $0x2a, %edx
leaq 0x2aef(%rip), %rcx      # 0x40e0
callq 0x1060
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2c20
movb %al, -0x59(%rbp)
jmp 0x1608
movb -0x59(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1613
jmp 0x1615
jmp 0x1634
leaq 0x2b14(%rip), %rdi      # 0x4130
leaq 0x2a1b(%rip), %rsi      # 0x403e
movl $0x2c, %edx
leaq 0x2ab1(%rip), %rcx      # 0x40e0
callq 0x1060
leaq -0x30(%rbp), %rdi
callq 0x2c10
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x10e0
nopl (%rax)
// File: lyqscmy[P]array_lock_free_queue/./array_lock_free_queue.h
// Function: ArrayLockFreeQueue<int, 3ul>::pop(int&)
bool pop(T &item) {

    size_t currentMaximumReadIndex = 0;
    size_t currentReadIndex = 0;
    size_t nextReadIndex = 0;

    do {
      currentReadIndex = readIndex.load();
      currentMaximumReadIndex = maximumReadIndex.load();

      if (currentReadIndex == currentMaximumReadIndex) {
        // queue empty
        return false;
      }

      // this read will not drop the item in data, so other consumer can still read this item.
      item = data[currentReadIndex];

      nextReadIndex = (currentReadIndex + 1) & sizeMask;
      // cas fail means this item is consumed by other consumer.
    } while (!std::atomic_compare_exchange_weak(&readIndex, &currentReadIndex,
                                                nextReadIndex));

    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x60(%rbp)
movq -0x68(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x8(%rbp)
movl $0x5, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0xc(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x2fa0
movl %eax, -0x6c(%rbp)
jmp 0x2c80
movl -0x6c(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x7c(%rbp)
decl %eax
subl $0x2, %eax
jb 0x2cac
jmp 0x2c95
movl -0x7c(%rbp), %eax
subl $0x5, %eax
je 0x2cb9
jmp 0x2c9f
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2cce
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2cce
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2cce
movq %rax, %rdi
callq 0x2fc0
movq -0x68(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x58(%rbp)
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movl $0x5, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x88(%rbp)
movl -0x24(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x2fa0
movl %eax, -0x80(%rbp)
jmp 0x2d06
movl -0x80(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x8c(%rbp)
decl %eax
subl $0x2, %eax
jb 0x2d3b
jmp 0x2d1e
movl -0x8c(%rbp), %eax
subl $0x5, %eax
je 0x2d4b
jmp 0x2d2b
movq -0x88(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x2d63
movq -0x88(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x2d63
movq -0x88(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x2d63
movq %rax, %rdi
callq 0x2fc0
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x50(%rbp), %rax
jne 0x2d7b
movb $0x0, -0x31(%rbp)
jmp 0x2dbf
movq -0x68(%rbp), %rcx
movq -0x58(%rbp), %rax
movl (%rcx,%rax,4), %edx
movq -0x48(%rbp), %rax
movl %edx, (%rax)
movq -0x58(%rbp), %rax
addq $0x1, %rax
andq 0x10(%rcx), %rax
movq %rax, -0x60(%rbp)
movq -0x68(%rbp), %rdi
addq $0x20, %rdi
movq -0x60(%rbp), %rdx
leaq -0x58(%rbp), %rsi
callq 0x2f40
xorb $-0x1, %al
testb $0x1, %al
jne 0x2c53
movb $0x1, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: biotomas[P]ipasir/app/ipasir-check-conflict/ipasir-check-conflict.cc
// Function: learnhook(void*, int*)
void learnhook(void * state, int * clause) {
  if(!clause) return;
  int len = 0;
  while( clause[len] != 0 ) ++len;
  std::cout << "c learned clause of size " << len << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x24a9
jmp 0x24f6
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x24c9
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x24b0
movq 0x22af8(%rip), %rdi     # 0x24fc8
leaq 0x1ab39(%rip), %rsi     # 0x1d010
callq 0x2170
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x2300
movq %rax, %rdi
movq 0x22ac7(%rip), %rsi     # 0x24fb8
callq 0x21a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: biotomas[P]ipasir/app/ipasir-check-conflict/./SATSolver.h
// Function: SATSolver::SATSolver()
SATSolver() : ipasirSolver(0), maxVar(0) {
    IPASIR( ipasirSolver = ipasir_init(); );
    IPASIR( std::cerr << "initialized IPASIR solver: " << std::string(ipasir_signature()) << std::endl; );
#ifndef HAVE_IPASIR
    std::cerr << "error: trying to use IPASIR solver without being compiled for ipasir, abort" << std::endl;
    exit (1);
#endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq $0x0, (%rax)
movl $0x0, 0x8(%rax)
callq 0x4720
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, (%rax)
movq 0x22588(%rip), %rdi     # 0x24ff0
leaq 0x1a72f(%rip), %rsi     # 0x1d19e
callq 0x2170
movq %rax, -0x58(%rbp)
callq 0x4710
movq %rax, -0x50(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x2320
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x3210
jmp 0x2aa1
movq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2150
movq %rax, -0x68(%rbp)
jmp 0x2ab4
movq -0x68(%rbp), %rdi
movq 0x224f9(%rip), %rsi     # 0x24fb8
callq 0x21a0
jmp 0x2ac6
leaq -0x28(%rbp), %rdi
callq 0x20d0
leaq -0x29(%rbp), %rdi
callq 0x21c0
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2b01
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x20d0
leaq -0x29(%rbp), %rdi
callq 0x21c0
movq -0x38(%rbp), %rdi
callq 0x2310
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: biotomas[P]ipasir/app/ipasir-check-conflict/./SATSolver.h
// Function: SATSolver::addClause(std::vector<int, std::allocator<int>>&)
void addClause(std::vector<int>& lits) {
    for( int i = 0 ; i<lits.size(); ++ i ) {
      IPASIR( ipasir_add(ipasirSolver, lits[i]); );
      maxVar = lits[i] > maxVar ? lits[i] : maxVar;
      maxVar = -lits[i] > maxVar ? -lits[i] : maxVar;
    }
    IPASIR( ipasir_add(ipasirSolver, 0); );
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3560
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x2d4b
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3580
movq -0x30(%rbp), %rdi
movl (%rax), %esi
callq 0x47c0
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3580
movq -0x20(%rbp), %rcx
movl (%rax), %eax
cmpl 0x8(%rcx), %eax
jle 0x2cdf
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3580
movl (%rax), %eax
movl %eax, -0x34(%rbp)
jmp 0x2ce9
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3580
movq -0x20(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
subl (%rdx), %eax
cmpl 0x8(%rcx), %eax
jle 0x2d29
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3580
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x38(%rbp)
jmp 0x2d33
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movl -0x38(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2c6f
movq -0x20(%rbp), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x47c0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: henrixh[P]shittydsa/examples/../src/primesieve.h
// Function: primesieve::primesieve(unsigned long)
primesieve(ul size) {
    p.flip();
    p[0] = false;
    ul increment = 3;

    ul limit = (ul)sqrt((double)size);
    while(increment < limit) {
      for(ul i = increment*increment; i < size; i += increment*2) {
        p[i/2] = false;
      }

      do {
        increment += 2;
      } while(increment < limit && !p[increment/2]);
    }
  }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x14d0
movq 0x10(%rsp), %rdi
callq 0x14e0
movq 0x10(%rsp), %rsi
xorl %eax, %eax
movl %eax, 0x1c(%rsp)
movl %eax, %edx
leaq 0x68(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x1510
movl 0x1c(%rsp), %esi
movq 0x20(%rsp), %rdi
callq 0x1550
movq 0x20(%rsp), %rdi
callq 0x15c0
movq $0x3, 0x60(%rsp)
movaps 0xd2c(%rip), %xmm1      # 0x2010
movq 0x78(%rsp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xd2a(%rip), %xmm1      # 0x2020
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
callq 0x1050
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0xd0f(%rip), %xmm1      # 0x2030
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rax
cmpq 0x58(%rsp), %rax
jae 0x1422
movq 0x60(%rsp), %rax
imulq 0x60(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
cmpq 0x78(%rsp), %rax
jae 0x13a2
movq 0x10(%rsp), %rsi
movq 0x50(%rsp), %rdx
shrq %rdx
leaq 0x40(%rsp), %rdi
callq 0x1510
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0x1550
leaq 0x40(%rsp), %rdi
callq 0x15c0
movq 0x60(%rsp), %rax
shlq %rax
addq 0x50(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x1355
jmp 0x13a4
movq 0x60(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rcx
movq 0x58(%rsp), %rdx
movb $0x0, 0x2f(%rsp)
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0xf(%rsp)
jae 0x13f8
movq 0x10(%rsp), %rsi
movq 0x60(%rsp), %rdx
shrq %rdx
leaq 0x30(%rsp), %rdi
callq 0x1510
movb $0x1, 0x2f(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x15d0
xorb $-0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
movb %al, 0xe(%rsp)
testb $0x1, 0x2f(%rsp)
jne 0x1409
jmp 0x1413
leaq 0x30(%rsp), %rdi
callq 0x15c0
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x13a4
jmp 0x141d
jmp 0x1335
addq $0x88, %rsp
retq
nopw (%rax,%rax)
// File: statgen[P]statgen/lib/tclap-1.2.0/examples/test16.cpp
// Function: void TCLAP::SetString<std::vector<double, std::allocator<double>>>(std::vector<double, std::allocator<double>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void SetString< std::vector<double> >(std::vector<double> &v,
                                          const std::string &s)
    {
        std::istringstream iss(s);
        while (iss) {
            double tmp;
            iss >> tmp;
            v.push_back(tmp);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x190(%rbp), %rdi
movl $0x8, %edx
callq 0x43f0
movq -0x190(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x190(%rbp,%rax), %rdi
callq 0x4320
movb %al, -0x1a9(%rbp)
jmp 0x4658
movb -0x1a9(%rbp), %al
testb $0x1, %al
jne 0x4664
jmp 0x46ad
leaq -0x190(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x41f0
jmp 0x4679
movq -0x8(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x6800
jmp 0x468b
jmp 0x4638
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x4120
jmp 0x46c2
leaq -0x190(%rbp), %rdi
callq 0x4120
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
movq -0x198(%rbp), %rdi
callq 0x4420
nop
// File: syzcch[P]FEC_C_version/fec_star.cpp
// Function: main
int main()
{

    printf("starting");

    const int NUM = 9;
    int *err = new int[NUM];
//    star *starItem = new star();
    star *starItem = new star(6,257,1024);

    starItem->setData();
    starItem->encoding();
    starItem->outputData();

    // 1 means fault data
    for(int i=0; i<NUM; i++)
    {
        err[i] = 0;
    }

//    err[0]=1;
//   err[1]=1;
    err[2]=1;
//    err[3]=1;

    starItem->setErrData(err);
    starItem->decoding();
    starItem->outputOrigin();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x3c9e(%rip), %rdi      # 0x6004
xorl %eax, %eax
callq 0x2040
movl $0x9, -0x8(%rbp)
movl $0x24, %edi
callq 0x2030
movq %rax, -0x10(%rbp)
movl $0x38, %edi
callq 0x20f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movl $0x6, %esi
movl $0x101, %edx            # imm = 0x101
movl $0x400, %ecx            # imm = 0x400
callq 0x2460
jmp 0x23ac
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movl $0x0, -0x28(%rbp)
cmpl $0x9, -0x28(%rbp)
jge 0x2415
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x23d9
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x38, %esi
callq 0x2100
jmp 0x244a
movq -0x10(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x21d0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: syzcch[P]FEC_C_version/./fec_star.h
// Function: star::star(int, int, int)
star(int disk, int prime, int dataLength )
    {
        p = prime;
        data_disk_nbr = disk;
        stripe_unit_size = dataLength;
        check_data_size = stripe_unit_size * sizeof(char) / sizeof(int);
        block_nbr = p - 1;
        block_size = check_data_size / block_nbr;
        allNum = data_disk_nbr + TOLERENCE;

        check_data = (int **)malloc(sizeof(int *) * (allNum));
        for(int i = 0; i < allNum; i++)
        {
            check_data[i] = (int *) malloc(sizeof(int )*check_data_size);
            memset(check_data[i],0,stripe_unit_size);
        }

        restarts = new int[allNum];
        for(int i = 0; i < allNum; i++)
        {
            restarts[i] = 0;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x25c0
movq -0x28(%rbp), %rcx
leaq 0x587b(%rip), %rax      # 0x7d08
addq $0x10, %rax
movq %rax, (%rcx)
movl -0x10(%rbp), %eax
movl %eax, 0x10(%rcx)
movl -0xc(%rbp), %eax
movl %eax, 0x28(%rcx)
movl -0x14(%rbp), %eax
movl %eax, 0x30(%rcx)
movslq 0x30(%rcx), %rax
shlq $0x0, %rax
shrq $0x2, %rax
movl %eax, 0x8(%rcx)
movl 0x10(%rcx), %eax
subl $0x1, %eax
movl %eax, 0x14(%rcx)
movl 0x8(%rcx), %eax
cltd
idivl 0x14(%rcx)
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xc(%rax)
movl 0x28(%rax), %ecx
addl $0x3, %ecx
movl %ecx, 0x2c(%rax)
movslq 0x2c(%rax), %rdi
shlq $0x3, %rdi
callq 0x2180
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x2c(%rcx), %eax
jge 0x2548
movq -0x28(%rbp), %rax
movslq 0x8(%rax), %rdi
shlq $0x2, %rdi
callq 0x2180
movq %rax, %rsi
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movslq -0x18(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0x18(%rax), %rcx
movslq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movslq 0x30(%rax), %rdx
xorl %esi, %esi
callq 0x2090
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x24f6
movq -0x28(%rbp), %rax
movslq 0x2c(%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x2c(%rcx), %eax
jge 0x25ad
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2583
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: syzcch[P]FEC_C_version/./fec_star.h
// Function: star::encoding()
void encoding()
    {
        if( check_data_size % block_nbr != 0)
        {
            printf(" Cannot  striping. wrong DATA_LENGTH!\n");
            exit(1);
        }

        STAR_encoding_row  ();
        STAR_encoding_diag1();
        STAR_encoding_diag2();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movl 0x8(%rcx), %eax
cltd
idivl 0x14(%rcx)
cmpl $0x0, %edx
je 0x2748
leaq 0x3905(%rip), %rdi      # 0x603c
movb $0x0, %al
callq 0x2040
movl $0x1, %edi
callq 0x2160
movq -0x10(%rbp), %rdi
callq 0x4800
movq -0x10(%rbp), %rdi
callq 0x4880
movq -0x10(%rbp), %rdi
callq 0x4b10
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: syzcch[P]FEC_C_version/./fec_star.h
// Function: star::outputOrigin()
void outputOrigin()
    {

        printf("After decoding:");
        for(int i=0; i < data_disk_nbr; i++)
        {
            printf("data:%d:  ",i);
            for(int j = 0; j < check_data_size; j++)
            {
                printf("%d ",check_data[i][j]);
            }
            printf("\n");
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x1cff(%rip), %rdi      # 0x607a
movb $0x0, %al
callq 0x2040
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0x4402
movl -0xc(%rbp), %esi
leaq 0x1ceb(%rip), %rdi      # 0x608a
movb $0x0, %al
callq 0x2040
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x43e9
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0x1cbe(%rip), %rdi      # 0x6095
movb $0x0, %al
callq 0x2040
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x43ad
leaq 0x1c71(%rip), %rdi      # 0x6061
movb $0x0, %al
callq 0x2040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4389
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: syzcch[P]FEC_C_version/./fec_star.h
// Function: star::outputData()
void outputData()
    {

        printf("The res:");
        for(int i = 0; i < allNum; i++)
        {
            for(int j = 0; j < check_data_size; j++)
            {
                printf("%d ",check_data[i][j]);
            }

            printf("\n");
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x1c6e(%rip), %rdi      # 0x6099
movb $0x0, %al
callq 0x2040
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x2c(%rcx), %eax
jge 0x44a1
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x4488
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0x1c1f(%rip), %rdi      # 0x6095
movb $0x0, %al
callq 0x2040
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x444c
leaq 0x1bd2(%rip), %rdi      # 0x6061
movb $0x0, %al
callq 0x2040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4439
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: syzcch[P]FEC_C_version/./fec_star.h
// Function: star::STAR_encoding_row()
void STAR_encoding_row()
    {
        int i,j;
        for( i = 0; i < check_data_size; i++)
        {
            for( j = 0; j < data_disk_nbr; j++)
            {
                check_data[data_disk_nbr][i] ^= check_data[j][i] ;
            }

        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
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 0x8(%rcx), %eax
jge 0x487b
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0x486e
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rax
movslq -0x10(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movslq -0xc(%rbp), %rdx
movl (%rax,%rdx,4), %edx
movq 0x18(%rcx), %rax
movslq 0x28(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x482a
jmp 0x4870
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4817
popq %rbp
retq
nopl (%rax)
// File: carellano8[P]Proyecto-Redes-I-2017/crc16.cpp
// Function: crc16::msjTobin(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
binario crc16::msjTobin(string mensaje){
            binario bin="";
            size_t i;
            for (i = 0; i < mensaje.size(); i++)
            {
                //cout<<bitset<8>(mensaje.c_str()[i]).to_string()<<endl;
                bin+=bitset<8>(mensaje[i]).to_string();
            }


            return bin;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x33a0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x52b7(%rip), %rsi      # 0xa159
callq 0x4340
jmp 0x4ea9
leaq -0x12(%rbp), %rdi
callq 0x3240
movq $0x0, -0x30(%rbp)
movq -0x78(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x80(%rbp)
callq 0x3170
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
jae 0x4f83
movq -0x78(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x3430
movq %rax, -0x88(%rbp)
jmp 0x4ef1
movq -0x88(%rbp), %rax
movsbq (%rax), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x6860
movq -0x90(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x68b0
jmp 0x4f1e
movq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x32b0
jmp 0x4f2d
leaq -0x50(%rbp), %rdi
callq 0x3140
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4eba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x3240
jmp 0x4fac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x4fa3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3140
jmp 0x4fa3
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x4f96
movq -0x68(%rbp), %rdi
callq 0x3140
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3140
movq -0x20(%rbp), %rdi
callq 0x3390
nopw %cs:(%rax,%rax)
// File: carellano8[P]Proyecto-Redes-I-2017/crc16.cpp
// Function: crc16::relleno_Bit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
binario crc16::relleno_Bit(binario bin_in){
            int contador=0;
            size_t i;
            binario bin_out="";
            for (i = 0; i < bin_in.size(); i++){
                if(bin_in[i]=='1'){
                    contador++;
                    }else{
                        contador=0;
                        }
                    bin_out+=bin_in[i];
                    if(contador==5){
                        bin_out+="0";
                        contador=0;
                    }
            }
            return bin_out;

        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movb $0x0, -0x21(%rbp)
leaq -0x22(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x33a0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x4ac3(%rip), %rsi      # 0xa159
callq 0x4340
jmp 0x569d
leaq -0x22(%rbp), %rdi
callq 0x3240
movq $0x0, -0x20(%rbp)
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x3170
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x5788
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3430
movq %rax, -0x68(%rbp)
jmp 0x56e2
movq -0x68(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x31, %eax
jne 0x572a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5731
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x22(%rbp), %rdi
callq 0x3240
jmp 0x57a5
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x3140
jmp 0x57a5
movl $0x0, -0x14(%rbp)
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3430
movq %rax, -0x70(%rbp)
jmp 0x5744
movq -0x48(%rbp), %rdi
movq -0x70(%rbp), %rax
movsbl (%rax), %esi
callq 0x3150
jmp 0x5756
cmpl $0x5, -0x14(%rbp)
jne 0x5775
movq -0x48(%rbp), %rdi
leaq 0x49e0(%rip), %rsi      # 0xa147
callq 0x31e0
jmp 0x576e
movl $0x0, -0x14(%rbp)
jmp 0x5777
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x56ae
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x579b
movq -0x48(%rbp), %rdi
callq 0x3140
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3390
nop
// File: carellano8[P]Proyecto-Redes-I-2017/crc16.cpp
// Function: crc16::BitStringToInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int crc16::BitStringToInt(string bin){
	size_t i,n=bin.size(),acum=0;
	for (i = 0; i < n; ++i)
	{
		if(bin[i]=='1'){
			acum+=pow(2,n-(i+1)) ;
		}
	}
	return acum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x3170
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x644f
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3430
movsbl (%rax), %eax
cmpl $0x31, %eax
jne 0x643c
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rsi
notq %rsi
addq %rax, %rsi
movl $0x2, %edi
callq 0x6a30
movaps %xmm0, %xmm1
movaps 0x3d22(%rip), %xmm2     # 0xa110
movq -0x20(%rbp), %xmm0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0x3d21(%rip), %xmm2     # 0xa120
subpd %xmm2, %xmm0
movaps %xmm0, %xmm2
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0x3d07(%rip), %xmm1     # 0xa130
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x643e
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x63a9
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: carellano8[P]Proyecto-Redes-I-2017/hamming.cpp
// Function: hamming::potencia2(int)
bool hamming::potencia2(int n){
    int i=0;bool r=false;int p;
    p=pow(2,i);

    while(!r&&p<=n){
        if(n==p){r=true;}
        i++;p=pow(2,i);
        }
    return r;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movl -0x8(%rbp), %esi
movl $0x2, %edi
callq 0x92c0
cvttsd2si %xmm0, %eax
movl %eax, -0x10(%rbp)
xorl %eax, %eax
testb $0x1, -0x9(%rbp)
movb %al, -0x11(%rbp)
jne 0x9251
movl -0x10(%rbp), %eax
cmpl -0x4(%rbp), %eax
setle %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x925a
jmp 0x9285
movl -0x4(%rbp), %eax
cmpl -0x10(%rbp), %eax
jne 0x9266
movb $0x1, -0x9(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %esi
movl $0x2, %edi
callq 0x92c0
cvttsd2si %xmm0, %eax
movl %eax, -0x10(%rbp)
jmp 0x923a
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: pawan231[P]MiniDataBase/include/BPtree.h
// Function: BPtree::search_leaf(int)
Btreenode
BPtree::search_leaf(int primary_key)
{
    Btreenode n(true);
    int q, curr_node = root_num;
    read_node(curr_node, n);

    //Traversing the Tree from root till leaf
    while (!n.isleaf())
    {
        q = n.num_pointers();
        if (primary_key <= n.get_key(1))
        {
            curr_node = n.get_pointer(1);
        }
        else if (primary_key > n.get_key(q - 1))
        {
            curr_node = n.get_pointer(q);
        }
        else
        {
            curr_node = n.get_pointer(n.get_next_key(primary_key) + 1);
        }
        read_node(curr_node, n);
    }

    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x15(%rbp)
movl $0x1, %esi
callq 0x5320
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movl 0x4(%rdi), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %esi
callq 0x5370
jmp 0x253c
jmp 0x253e
movq -0x38(%rbp), %rdi
callq 0x5460
movb %al, -0x49(%rbp)
jmp 0x254c
movb -0x49(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x255a
jmp 0x2648
movq -0x38(%rbp), %rdi
callq 0x5480
movl %eax, -0x50(%rbp)
jmp 0x2568
movq -0x38(%rbp), %rdi
movl -0x50(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x58(%rbp)
movl $0x1, %esi
callq 0x54a0
movl %eax, -0x54(%rbp)
jmp 0x2587
movl -0x58(%rbp), %eax
movl -0x54(%rbp), %ecx
cmpl %ecx, %eax
jg 0x25c9
movq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x54d0
movl %eax, -0x5c(%rbp)
jmp 0x25a4
movl -0x5c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x2631
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x5570
jmp 0x2665
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x64(%rbp)
movl -0x1c(%rbp), %esi
decl %esi
callq 0x54a0
movl %eax, -0x60(%rbp)
jmp 0x25e2
movl -0x64(%rbp), %eax
movl -0x60(%rbp), %ecx
cmpl %ecx, %eax
jle 0x2605
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x54d0
movl %eax, -0x68(%rbp)
jmp 0x25fd
movl -0x68(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x262f
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x5500
movl %eax, -0x6c(%rbp)
jmp 0x2616
movq -0x38(%rbp), %rdi
movl -0x6c(%rbp), %esi
incl %esi
callq 0x54d0
movl %eax, -0x70(%rbp)
jmp 0x2629
movl -0x70(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x2631
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x5370
jmp 0x2643
jmp 0x253e
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x265b
movq -0x38(%rbp), %rdi
callq 0x5570
movq -0x48(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2340
nop