LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/RNFile.cpp
// Function: gaps::RNWriteUnsignedInt(_IO_FILE*, unsigned int const*, int, int)
int
RNWriteUnsignedInt(FILE *fp, const unsigned int *ptr, int count, int swap_endian)
{
  // Swap endian
  if (swap_endian) RNSwap4((void *) ptr, count);

  // Write the values
  int status = 1;
  if (fwrite(ptr, sizeof(unsigned int), count, fp) != (size_t) count) {
    RNFail("Unable to write unsigned integer to file\n");
    status = 0;
  }

  // Swap endian back
  if (swap_endian) RNSwap4((void *) ptr, count);

  // Return status
  return status;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0x145d4b
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x145690
movl $0x1, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x14(%rsp), %rdx
movq 0x20(%rsp), %rcx
movl $0x4, %esi
callq 0x13a80
movslq 0x14(%rsp), %rcx
cmpq %rcx, %rax
je 0x145d8c
leaq 0x637c1(%rip), %rdi     # 0x1a953e
movb $0x0, %al
callq 0x1464b0
movl $0x0, 0xc(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0x145da1
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x145690
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/RNFile.cpp
// Function: gaps::RNWriteFloat(_IO_FILE*, float const*, int, int)
int
RNWriteFloat(FILE *fp, const float *ptr, int count, int swap_endian)
{
  // Swap endian
  if (swap_endian) RNSwap4((void *) ptr, count);

  // Write the values
  int status = 1;
  if (fwrite(ptr, sizeof(float), count, fp) != (size_t) count) {
    RNFail("Unable to write float to file\n");
    status = 0;
  }

  // Swap endian back
  if (swap_endian) RNSwap4((void *) ptr, count);

  // Return status
  return status;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0x145ddb
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x145690
movl $0x1, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x14(%rsp), %rdx
movq 0x20(%rsp), %rcx
movl $0x4, %esi
callq 0x13a80
movslq 0x14(%rsp), %rcx
cmpq %rcx, %rax
je 0x145e1c
leaq 0x6375b(%rip), %rdi     # 0x1a9568
movb $0x0, %al
callq 0x1464b0
movl $0x0, 0xc(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0x145e31
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x145690
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/RNFile.cpp
// Function: gaps::RNWriteDouble(_IO_FILE*, double const*, int, int)
int
RNWriteDouble(FILE *fp, const double *ptr, int count, int swap_endian)
{
  // Swap endian
  if (swap_endian) RNSwap8((void *) ptr, count);

  // Write the values
  int status = 1;
  if (fwrite(ptr, sizeof(double), count, fp) != (size_t) count) {
    RNFail("Unable to write double to file\n");
    status = 0;
  }

  // Swap endian back
  if (swap_endian) RNSwap8((void *) ptr, count);

  // Return status
  return status;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0x145e6b
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x145890
movl $0x1, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x14(%rsp), %rdx
movq 0x20(%rsp), %rcx
movl $0x8, %esi
callq 0x13a80
movslq 0x14(%rsp), %rcx
cmpq %rcx, %rax
je 0x145eac
leaq 0x636ea(%rip), %rdi     # 0x1a9587
movb $0x0, %al
callq 0x1464b0
movl $0x0, 0xc(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0x145ec1
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x145890
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/RNFile.cpp
// Function: gaps::RNWriteLongLong(_IO_FILE*, long long const*, int, int)
int
RNWriteLongLong(FILE *fp, const long long *ptr, int count, int swap_endian)
{
  // Swap endian
  if (swap_endian) RNSwap8((void *) ptr, count);

  // Write the values
  int status = 1;
  if (fwrite(ptr, sizeof(long long), count, fp) != (size_t) count) {
    RNFail("Unable to write long long to file\n");
    status = 0;
  }

  // Swap endian back
  if (swap_endian) RNSwap8((void *) ptr, count);

  // Return status
  return status;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0x145efb
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x145890
movl $0x1, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x14(%rsp), %rdx
movq 0x20(%rsp), %rcx
movl $0x8, %esi
callq 0x13a80
movslq 0x14(%rsp), %rcx
cmpq %rcx, %rax
je 0x145f3c
leaq 0x6367a(%rip), %rdi     # 0x1a95a7
movb $0x0, %al
callq 0x1464b0
movl $0x0, 0xc(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0x145f51
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x145890
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/RNFile.cpp
// Function: gaps::RNWriteUnsignedLongLong(_IO_FILE*, unsigned long long const*, int, int)
int
RNWriteUnsignedLongLong(FILE *fp, const unsigned long long *ptr, int count, int swap_endian)
{
  // Swap endian
  if (swap_endian) RNSwap8((void *) ptr, count);

  // Write the values
  int status = 1;
  if (fwrite(ptr, sizeof(unsigned long long), count, fp) != (size_t) count) {
    RNFail("Unable to write unsigned long long to file\n");
    status = 0;
  }

  // Swap endian back
  if (swap_endian) RNSwap8((void *) ptr, count);

  // Return status
  return status;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0x145f8b
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x145890
movl $0x1, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x14(%rsp), %rdx
movq 0x20(%rsp), %rcx
movl $0x8, %esi
callq 0x13a80
movslq 0x14(%rsp), %rcx
cmpq %rcx, %rax
je 0x145fcc
leaq 0x6360d(%rip), %rdi     # 0x1a95ca
movb $0x0, %al
callq 0x1464b0
movl $0x0, 0xc(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0x145fe1
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x145890
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: t3nma[P]sdl2-TicTacToe/src/main.cpp
// Function: main
int main(int argc, char *args[])
{
    App app;

    if(!app.init())
    {
        printf("Error initializing... bye!\n");
        return 666;
    }

    app.run();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x1360
movq -0xa0(%rbp), %rdi
callq 0x13e0
movb %al, -0x91(%rbp)
jmp 0x12cd
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x1319
jmp 0x12d9
leaq 0x1d24(%rip), %rdi      # 0x3004
xorl %eax, %eax
callq 0x1050
jmp 0x12e9
movl $0x29a, -0x4(%rbp)      # imm = 0x29A
movl $0x1, -0x90(%rbp)
jmp 0x1335
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1380
jmp 0x134a
leaq -0x80(%rbp), %rdi
callq 0x14c0
jmp 0x1324
movl $0x0, -0x4(%rbp)
movl $0x1, -0x90(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1380
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x1170
nopw %cs:(%rax,%rax)
// File: t3nma[P]sdl2-TicTacToe/src/App.cpp
// Function: App::~App()
App::~App()
{
    if(gRenderer != NULL)
    {
        SDL_DestroyRenderer(gRenderer);
        gRenderer = NULL;
    }

    if(gWindow != NULL)
    {
        SDL_DestroyWindow(gWindow);
        gWindow = NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x3d5c(%rip)      # 0x50f0
je 0x13af
movq 0x3d53(%rip), %rdi      # 0x50f0
callq 0x10d0
jmp 0x13a4
movq $0x0, 0x3d41(%rip) # 0x50f0
cmpq $0x0, 0x3d31(%rip)      # 0x50e8
je 0x13d2
movq 0x3d28(%rip), %rdi      # 0x50e8
callq 0x1030
jmp 0x13c7
movq $0x0, 0x3d16(%rip) # 0x50e8
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1560
// File: t3nma[P]sdl2-TicTacToe/src/App.cpp
// Function: App::init()
bool App::init()
{
    if(SDL_Init(SDL_INIT_VIDEO) < 0)
    {
        printf("Couldn't start SDL! SDL error: %s\n", SDL_GetError());
        return false;
    }

    gWindow = SDL_CreateWindow("Tic Tac Toe", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
    if(gWindow == NULL)
    {
        printf("Couldn't create Window! SDL error: %s\n", SDL_GetError());
        return false;
    }

    gRenderer = SDL_CreateRenderer(gWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
    if(gRenderer == NULL)
    {
        printf("Couldn't create Renderer! SDL error: %s\n", SDL_GetError());
        return false;
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movl $0x20, %edi
callq 0x1110
cmpl $0x0, %eax
jge 0x141a
callq 0x1100
movq %rax, %rsi
leaq 0x1c16(%rip), %rdi      # 0x3020
movb $0x0, %al
callq 0x1050
movb $0x0, -0x1(%rbp)
jmp 0x14b0
leaq 0x1c22(%rip), %rdi      # 0x3043
movl $0x1fff0000, %edx       # imm = 0x1FFF0000
movl $0x258, %r8d            # imm = 0x258
movl $0x4, %r9d
movl %edx, %esi
movl %r8d, %ecx
callq 0x1060
movq %rax, 0x3ca5(%rip)      # 0x50e8
cmpq $0x0, 0x3c9d(%rip)      # 0x50e8
jne 0x1469
callq 0x1100
movq %rax, %rsi
leaq 0x1bf3(%rip), %rdi      # 0x304f
movb $0x0, %al
callq 0x1050
movb $0x0, -0x1(%rbp)
jmp 0x14b0
movq 0x3c78(%rip), %rdi      # 0x50e8
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x6, %edx
callq 0x1040
movq %rax, 0x3c6a(%rip)      # 0x50f0
cmpq $0x0, 0x3c62(%rip)      # 0x50f0
jne 0x14ac
callq 0x1100
movq %rax, %rsi
leaq 0x1bd7(%rip), %rdi      # 0x3076
movb $0x0, %al
callq 0x1050
movb $0x0, -0x1(%rbp)
jmp 0x14b0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: t3nma[P]sdl2-TicTacToe/src/App.cpp
// Function: App::run()
void App::run()
{
    bool quit = false;
    while(!quit)
    {
        // handle exit events
        while(SDL_PollEvent(&event))
        {
            if(event.type == SDL_QUIT)
                quit = true;
        }

        // update and render the game
        game.update(&event);
        game.render();
        game.checkWin();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x9(%rbp)
movb -0x9(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x14e3
jmp 0x152e
jmp 0x14e5
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0x10e0
cmpl $0x0, %eax
je 0x150a
movq -0x18(%rbp), %rax
cmpl $0x100, 0x38(%rax)      # imm = 0x100
jne 0x1508
movb $0x1, -0x9(%rbp)
jmp 0x14e5
movq -0x18(%rbp), %rdi
movq %rdi, %rsi
addq $0x38, %rsi
callq 0x2740
movq -0x18(%rbp), %rdi
callq 0x2830
movq -0x18(%rbp), %rdi
callq 0x2890
jmp 0x14d8
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: t3nma[P]sdl2-TicTacToe/src/Board.cpp
// Function: Board::restart()
void Board::restart()
{
    for(int i=0; i<3; i++)
        for(int j=0; j<3; j++)
            m[i][j] = PIECE_EMPTY;

    occupiedPlaces = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0x15ec
movl $0x0, -0x10(%rbp)
cmpl $0x3, -0x10(%rbp)
jge 0x15df
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x15b4
jmp 0x15e1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x15a7
movq -0x18(%rbp), %rax
movl $0x0, 0x24(%rax)
popq %rbp
retq
nopl (%rax)
// File: t3nma[P]sdl2-TicTacToe/src/Board.cpp
// Function: Board::renderBoard() const
void Board::renderBoard() const
{
    // vertical lines
    SDL_RenderDrawLine(App::getRenderer(),
        App::SCREEN_WIDTH/3, 0,
        App::SCREEN_WIDTH/3, App::SCREEN_HEIGHT);

    SDL_RenderDrawLine(App::getRenderer(),
        App::SCREEN_WIDTH/3*2, 0,
        App::SCREEN_WIDTH/3*2, App::SCREEN_HEIGHT);

    // horizontal lines
    SDL_RenderDrawLine(App::getRenderer(),
        0, App::SCREEN_HEIGHT/3,
        App::SCREEN_WIDTH, App::SCREEN_HEIGHT/3);

    SDL_RenderDrawLine(App::getRenderer(),
        0, App::SCREEN_HEIGHT/3*2,
        App::SCREEN_WIDTH, App::SCREEN_HEIGHT/3*2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x1550
movq %rax, %rdi
movl $0xc8, %ecx
xorl %edx, %edx
movl $0x258, %r8d            # imm = 0x258
movl %ecx, %esi
callq 0x10b0
callq 0x1550
movq %rax, %rdi
movl $0x190, %ecx            # imm = 0x190
xorl %edx, %edx
movl $0x258, %r8d            # imm = 0x258
movl %ecx, %esi
callq 0x10b0
callq 0x1550
movq %rax, %rdi
xorl %esi, %esi
movl $0xc8, %r8d
movl $0x258, %ecx            # imm = 0x258
movl %r8d, %edx
callq 0x10b0
callq 0x1550
movq %rax, %rdi
xorl %esi, %esi
movl $0x190, %r8d            # imm = 0x190
movl $0x258, %ecx            # imm = 0x258
movl %r8d, %edx
callq 0x10b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: t3nma[P]sdl2-TicTacToe/src/Board.cpp
// Function: Board::renderPieces() const
void Board::renderPieces() const
{
    for(int i=0; i<3; i++)
        for(int j=0; j<3; j++)
        {
            switch(m[i][j])
            {
                case PIECE_X:
                    Util::drawCross(i, j); break;
                case PIECE_O:
                    Util::drawCircle(i, j); break;
                default:
                    break;
            }
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0x176f
movl $0x0, -0x10(%rbp)
cmpl $0x3, -0x10(%rbp)
jge 0x1762
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,4), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
subl $0x1, %eax
je 0x1739
jmp 0x172f
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x1746
jmp 0x1753
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x28e0
jmp 0x1755
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x2970
jmp 0x1755
jmp 0x1755
jmp 0x1757
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1708
jmp 0x1764
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x16fb
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: t3nma[P]sdl2-TicTacToe/src/Board.cpp
// Function: Board::checkRows() const
bool Board::checkRows() const
{
    if(m[0][0] == m[0][1] && m[0][1] == m[0][2] && !isFieldEmpty(0,2))
        return true;
    else if(m[1][0] == m[1][1] && m[1][1] == m[1][2] && !isFieldEmpty(1,2))
        return true;
    else if(m[2][0] == m[2][1] && m[2][1] == m[2][2] && !isFieldEmpty(2,2))
        return true;

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl (%rcx), %eax
cmpl 0x4(%rcx), %eax
jne 0x1821
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %eax
cmpl 0x8(%rcx), %eax
jne 0x1821
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x1a90
testb $0x1, %al
jne 0x1821
movb $0x1, -0x1(%rbp)
jmp 0x1890
movq -0x18(%rbp), %rcx
movl 0xc(%rcx), %eax
cmpl 0x10(%rcx), %eax
jne 0x1856
movq -0x18(%rbp), %rcx
movl 0x10(%rcx), %eax
cmpl 0x14(%rcx), %eax
jne 0x1856
movq -0x18(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1a90
testb $0x1, %al
jne 0x1856
movb $0x1, -0x1(%rbp)
jmp 0x1890
movq -0x18(%rbp), %rcx
movl 0x18(%rcx), %eax
cmpl 0x1c(%rcx), %eax
jne 0x1888
movq -0x18(%rbp), %rcx
movl 0x1c(%rcx), %eax
cmpl 0x20(%rcx), %eax
jne 0x1888
movq -0x18(%rbp), %rdi
movl $0x2, %edx
movl %edx, %esi
callq 0x1a90
testb $0x1, %al
jne 0x1888
movb $0x1, -0x1(%rbp)
jmp 0x1890
jmp 0x188a
jmp 0x188c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: t3nma[P]sdl2-TicTacToe/src/Board.cpp
// Function: Board::checkColumns() const
bool Board::checkColumns() const
{
    if(m[0][0] == m[1][0] && m[1][0] == m[2][0] && !isFieldEmpty(2,0))
        return true;
    else if(m[0][1] == m[1][1] && m[1][1] == m[2][1] && !isFieldEmpty(2,1))
        return true;
    else if(m[0][2] == m[1][2] && m[1][2] == m[2][2] && !isFieldEmpty(2,2))
        return true;

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl (%rcx), %eax
cmpl 0xc(%rcx), %eax
jne 0x18e1
movq -0x18(%rbp), %rcx
movl 0xc(%rcx), %eax
cmpl 0x18(%rcx), %eax
jne 0x18e1
movq -0x18(%rbp), %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a90
testb $0x1, %al
jne 0x18e1
movb $0x1, -0x1(%rbp)
jmp 0x1950
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %eax
cmpl 0x10(%rcx), %eax
jne 0x1916
movq -0x18(%rbp), %rcx
movl 0x10(%rcx), %eax
cmpl 0x1c(%rcx), %eax
jne 0x1916
movq -0x18(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x1a90
testb $0x1, %al
jne 0x1916
movb $0x1, -0x1(%rbp)
jmp 0x1950
movq -0x18(%rbp), %rcx
movl 0x8(%rcx), %eax
cmpl 0x14(%rcx), %eax
jne 0x1948
movq -0x18(%rbp), %rcx
movl 0x14(%rcx), %eax
cmpl 0x20(%rcx), %eax
jne 0x1948
movq -0x18(%rbp), %rdi
movl $0x2, %edx
movl %edx, %esi
callq 0x1a90
testb $0x1, %al
jne 0x1948
movb $0x1, -0x1(%rbp)
jmp 0x1950
jmp 0x194a
jmp 0x194c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: t3nma[P]sdl2-TicTacToe/src/Board.cpp
// Function: Board::checkDiagonals() const
bool Board::checkDiagonals() const
{
    if(m[0][0] == m[1][1] && m[1][1] == m[2][2] && !isFieldEmpty(2,2))
        return true;
    else if(m[0][2] == m[1][1] && m[1][1] == m[2][0] && !isFieldEmpty(2,0))
        return true;

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl (%rcx), %eax
cmpl 0x10(%rcx), %eax
jne 0x19a1
movq -0x18(%rbp), %rcx
movl 0x10(%rcx), %eax
cmpl 0x20(%rcx), %eax
jne 0x19a1
movq -0x18(%rbp), %rdi
movl $0x2, %edx
movl %edx, %esi
callq 0x1a90
testb $0x1, %al
jne 0x19a1
movb $0x1, -0x1(%rbp)
jmp 0x19d9
movq -0x18(%rbp), %rcx
movl 0x8(%rcx), %eax
cmpl 0x10(%rcx), %eax
jne 0x19d3
movq -0x18(%rbp), %rcx
movl 0x10(%rcx), %eax
cmpl 0x18(%rcx), %eax
jne 0x19d3
movq -0x18(%rbp), %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1a90
testb $0x1, %al
jne 0x19d3
movb $0x1, -0x1(%rbp)
jmp 0x19d9
jmp 0x19d5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: t3nma[P]sdl2-TicTacToe/src/Bot.cpp
// Function: Bot::play(Board&) const
void Bot::play(Board &board) const
{
    switch(level)
    {
        case LEVEL_EASY:
            easy(board); break;
        case LEVEL_MEDIUM:
            if(!medium(board))
                easy(board);
            break;
        case LEVEL_HARD:
            if(!hard(board) && !medium(board))
                easy(board);
            break;
        default:
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x1c37
jmp 0x1c23
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x1c46
jmp 0x1c2d
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x1c66
jmp 0x1c97
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ca0
jmp 0x1c99
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d20
testb $0x1, %al
jne 0x1c64
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ca0
jmp 0x1c99
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x21e0
testb $0x1, %al
jne 0x1c95
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d20
testb $0x1, %al
jne 0x1c95
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ca0
jmp 0x1c99
jmp 0x1c99
addq $0x20, %rsp
popq %rbp
retq
nop
// File: t3nma[P]sdl2-TicTacToe/src/Bot.cpp
// Function: Bot::easy(Board&) const
void Bot::Bot::easy(Board &board) const
{
    int x = rand()%3;
    int y = rand()%3;

    while(!board.isFieldEmpty(x,y))
    {
        x = rand()%3;
        y = rand()%3;
    }

    board.place(x, y, false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1090
movl $0x3, %ecx
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
callq 0x1090
movl $0x3, %ecx
cltd
idivl %ecx
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x1a90
xorb $-0x1, %al
testb $0x1, %al
jne 0x1ce7
jmp 0x1d09
callq 0x1090
movl $0x3, %ecx
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
callq 0x1090
movl $0x3, %ecx
cltd
idivl %ecx
movl %edx, -0x18(%rbp)
jmp 0x1cd0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
xorl %ecx, %ecx
callq 0x1a10
addq $0x20, %rsp
popq %rbp
retq
// File: t3nma[P]sdl2-TicTacToe/src/Game.cpp
// Function: Game::restartGame()
void Game::restartGame()
{
    bot.restart();
    board.restart();

    // randomly choose first player
    // 0=pc, 1=human
    humanTurn = (rand()&1) ? true : false;

    // corrects the game state
    state = STATE_RUNNING;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x4, %rdi
callq 0x1bd0
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x1590
callq 0x1090
movl %eax, %ecx
movq -0x10(%rbp), %rax
andb $0x1, %cl
negb %cl
andb $0x1, %cl
movb %cl, 0x30(%rax)
movl $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: t3nma[P]sdl2-TicTacToe/src/Game.cpp
// Function: Game::update(SDL_Event*)
void Game::update(SDL_Event *event)
{
    // have we reach the current game's end?
    if(state == STATE_STOPPED)
        restartGame();
    else
    {
        bool successfulPlay = false; // to handle change of player turn

        // process human or pc turn
        if(!humanTurn)
        {
            bot.play(board);
            successfulPlay = true;
        }
        else
        {
            // did the human play?
            if(event->type == SDL_MOUSEBUTTONDOWN)
            {
                // get mouse coordinates and normalize to row/col
                int x, y;
                SDL_GetMouseState(&x, &y);
                int row = y/(App::SCREEN_HEIGHT/3);
                int col = x/(App::SCREEN_WIDTH/3);

                // try to validate the move
                if(board.isFieldEmpty(row,col))
                {
                    board.place(row,col);
                    successfulPlay = true;
                }
            }
        }

        // change turns
        if(successfulPlay)
        {
            humanTurn = !humanTurn;
            SDL_Delay(100); // delay between turns
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x1, (%rax)
jne 0x276b
movq -0x30(%rbp), %rdi
callq 0x26f0
jmp 0x2823
movq -0x30(%rbp), %rax
movb $0x0, -0x11(%rbp)
testb $0x1, 0x30(%rax)
jne 0x2793
movq -0x30(%rbp), %rsi
movq %rsi, %rdi
addq $0x4, %rdi
addq $0x8, %rsi
callq 0x1c00
movb $0x1, -0x11(%rbp)
jmp 0x2801
movq -0x10(%rbp), %rax
cmpl $0x401, (%rax)          # imm = 0x401
jne 0x27ff
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x1160
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl $0xc8, %ecx
cltd
idivl %ecx
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movl $0xc8, %ecx
cltd
idivl %ecx
movl %eax, -0x24(%rbp)
addq $0x8, %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x1a90
testb $0x1, %al
jne 0x27e1
jmp 0x27fd
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
movl $0x1, %ecx
callq 0x1a10
movb $0x1, -0x11(%rbp)
jmp 0x27ff
jmp 0x2801
testb $0x1, -0x11(%rbp)
je 0x2821
movq -0x30(%rbp), %rax
movb 0x30(%rax), %cl
xorb $-0x1, %cl
andb $0x1, %cl
movb %cl, 0x30(%rax)
movl $0x64, %edi
callq 0x10f0
jmp 0x2823
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: t3nma[P]sdl2-TicTacToe/src/Game.cpp
// Function: Game::render() const
void Game::render() const
{
    // bg
    SDL_SetRenderDrawColor(App::getRenderer(), 0xFF, 0xFF, 0xFF, 0xFF);
    SDL_RenderClear(App::getRenderer());

    // game objects
    board.render();

    // render
    SDL_RenderPresent(App::getRenderer());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1550
movq %rax, %rdi
movl $0xff, %r8d
movl %r8d, %esi
movl %r8d, %edx
movl %r8d, %ecx
callq 0x1150
callq 0x1550
movq %rax, %rdi
callq 0x1130
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x1600
callq 0x1550
movq %rax, %rdi
callq 0x1070
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: t3nma[P]sdl2-TicTacToe/src/Util.cpp
// Function: Util::drawCross(int, int)
void Util::drawCross(int row, int col)
{
    int fieldW = App::SCREEN_WIDTH/3;
    int fieldH = App::SCREEN_HEIGHT/3;

    // top left to bottom right
    SDL_RenderDrawLine(App::getRenderer(),
        col*fieldW, row*fieldH,
        col*fieldW+fieldW, row*fieldH+fieldH);

    // top right to bottom left
    SDL_RenderDrawLine(App::getRenderer(),
        col*fieldW, row*fieldH+fieldH,
        col*fieldW+fieldW, row*fieldH);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0xc8, -0xc(%rbp)
movl $0xc8, -0x10(%rbp)
callq 0x1550
movq %rax, %rdi
movl -0x8(%rbp), %esi
imull -0xc(%rbp), %esi
movl -0x4(%rbp), %edx
imull -0x10(%rbp), %edx
movl -0x8(%rbp), %ecx
imull -0xc(%rbp), %ecx
addl -0xc(%rbp), %ecx
movl -0x4(%rbp), %r8d
imull -0x10(%rbp), %r8d
addl -0x10(%rbp), %r8d
callq 0x10b0
callq 0x1550
movq %rax, %rdi
movl -0x8(%rbp), %esi
imull -0xc(%rbp), %esi
movl -0x4(%rbp), %edx
imull -0x10(%rbp), %edx
addl -0x10(%rbp), %edx
movl -0x8(%rbp), %ecx
imull -0xc(%rbp), %ecx
addl -0xc(%rbp), %ecx
movl -0x4(%rbp), %r8d
imull -0x10(%rbp), %r8d
callq 0x10b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: t3nma[P]sdl2-TicTacToe/src/Util.cpp
// Function: Util::drawCircle(int, int)
void Util::drawCircle(int row, int col)
{
    int fieldW = App::SCREEN_WIDTH/3;
    int fieldH = App::SCREEN_HEIGHT/3;

    // calculate circle center
    int centerX = col*fieldW+(fieldW/2);
    int centerY = row*fieldH+(fieldH/2);

    int r = fieldW/2;

    double step = 2*M_PI/30;
    int endX = centerX + r;
    int endY = centerY;

    // draw circle.. Multiple straight lines between consecutive
    // points of the desired circle
    for(double angle=0; angle<2*M_PI; angle+=step)
    {
        int startX = endX;
        int startY = endY;
        endX = r * cos(angle) + centerX;
        endY = r * sin(angle) + centerY;
        SDL_RenderDrawLine(App::getRenderer(), startX, startY, endX, endY);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0xc8, -0xc(%rbp)
movl $0xc8, -0x10(%rbp)
movl -0x8(%rbp), %eax
imull -0xc(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x48(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x4(%rbp), %eax
imull -0x10(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x10(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x44(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
movsd 0x6c0(%rip), %xmm0      # 0x30a0
movsd %xmm0, -0x28(%rbp)
movl -0x14(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x6a4(%rip), %xmm0      # 0x30a8
ucomisd -0x38(%rbp), %xmm0
jbe 0x2aa9
movl -0x2c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x40(%rbp)
cvtsi2sdl -0x1c(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x1180
movaps %xmm0, %xmm2
movsd -0x58(%rbp), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x2c(%rbp)
cvtsi2sdl -0x1c(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x1080
movaps %xmm0, %xmm2
movsd -0x50(%rbp), %xmm0
cvtsi2sdl -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x30(%rbp)
callq 0x1550
movq %rax, %rdi
movl -0x3c(%rbp), %esi
movl -0x40(%rbp), %edx
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %r8d
callq 0x10b0
movsd -0x28(%rbp), %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x29fc
addq $0x60, %rsp
popq %rbp
retq
// File: luizaes[P]post-machine-simulator/post_machine_sim.cpp
// Function: ReadInputLine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void ReadInputLine(string& line) {
	getline(cin, line);

	/* Fix so that the program can run for both Windows and Linux file formats */
	if(!line.empty() && *line.rbegin() == '\r') {
    	line.erase( line.length()-1, 1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq 0x87b9(%rip), %rdi      # 0xbfe0
callq 0x2080
movq -0x8(%rbp), %rdi
callq 0x2340
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x3863
movq -0x8(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x2360
leaq -0x10(%rbp), %rdi
callq 0x4c00
movsbl (%rax), %eax
cmpl $0xd, %eax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x386c
jmp 0x3892
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x22e0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
movl $0x1, %edx
callq 0x2090
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: luizaes[P]post-machine-simulator/post_machine_sim.cpp
// Function: PostMachineSimulator::Run(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool PostMachineSimulator::Run(string& input) {
	int start_index;

	for(int i = 0; input[i] != '\0'; i++) {
		work_queue.push(input[i]);
	}

	for(int i = 0; i < flow_diagram.size(); i++) {
		if(flow_diagram[i].name.compare(start_state) == 0) {
			start_index = i;
			break;
		}
	}

	/* Process the input word through the working queue and flow diagram */
	return TraverseDiagram(start_index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x23d0
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x4b84
movq -0x28(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x23d0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x4de0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4b3f
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x4db0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x4bdf
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x4c50
movq -0x28(%rbp), %rsi
movq %rax, %rdi
addq $0x68, %rsi
callq 0x2030
cmpl $0x0, %eax
jne 0x4bd2
movl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x4bdf
jmp 0x4bd4
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4b8b
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x38a0
cmpl $0x0, %eax
setne %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: superblocks[P]superblocks/set-gdc.cpp
// Function: Superblocks::init()
void Superblocks::init() {

  coin = "GDC"; 
	coin_name = "Grandcoin";

	hash_length = 64;

	// normal (step 0)
	reward[0] = 1000;

	// superblocks

	seed_type[1] = SEED_WITH_PREVIOUS_BLOCK_HASH;
	cutout_start[1] = 3;
	cutout_length[1] = 7;
	rnd_range_low[1] = 1;
	rnd_range_high[1] = 19199;
	luck_type[1] = LUCK_WITH_MORE_THAN_X_AND_LESS_THAN_Y;
	luck_x[1] = 10000;
	luck_y[1] = 10011;
		secondary_rand[1] = 1;
		secondary_rand_type[1] = SECONDARY_REWARD_PLUS_RAND_MINUS_X;
		secondary_rand_low[1] = 1;
		secondary_rand_high[1] = 5000;
		secondary_rand_x[1] = 0;
	reward[1] = 5000;


	seed_type[2] = SEED_WITH_PREVIOUS_BLOCK_HASH;
	cutout_start[2] = 6;
	cutout_length[2] = 7;
	rnd_range_low[2] = 1;
	rnd_range_high[2] = 134399;
	luck_type[2] = LUCK_WITH_MORE_THAN_X_AND_LESS_THAN_Y;
	luck_x[2] = 60000;
	luck_y[2] = 60011;
		secondary_rand[2] = 1;
		secondary_rand_type[2] = SECONDARY_REWARD_PLUS_RAND_MINUS_X;
		secondary_rand_low[2] = 1;
		secondary_rand_high[2] = 50000;
		secondary_rand_x[2] = 0;
	reward[2] = 50000;


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x18, %rdi
leaq 0x1801(%rip), %rsi      # 0x5e80
callq 0x21a0
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
leaq 0x17f1(%rip), %rsi      # 0x5e84
callq 0x21a0
movq -0x10(%rbp), %rax
movl $0x40, 0x58(%rax)
movl $0x3e8, 0x110(%rax)     # imm = 0x3E8
movl $0x2, 0x60(%rax)
movl $0x3, 0x6c(%rax)
movl $0x7, 0x78(%rax)
movl $0x1, 0x84(%rax)
movl $0x4aff, 0x90(%rax)     # imm = 0x4AFF
movl $0x3, 0xf0(%rax)
movl $0x2710, 0xfc(%rax)     # imm = 0x2710
movl $0x271b, 0x108(%rax)    # imm = 0x271B
movl $0x1, 0x9c(%rax)
movl $0x1, 0xa8(%rax)
movl $0x1, 0xb4(%rax)
movl $0x1388, 0xc0(%rax)     # imm = 0x1388
movl $0x0, 0xcc(%rax)
movl $0x1388, 0x114(%rax)    # imm = 0x1388
movl $0x2, 0x64(%rax)
movl $0x6, 0x70(%rax)
movl $0x7, 0x7c(%rax)
movl $0x1, 0x88(%rax)
movl $0x20cff, 0x94(%rax)    # imm = 0x20CFF
movl $0x3, 0xf4(%rax)
movl $0xea60, 0x100(%rax)    # imm = 0xEA60
movl $0xea6b, 0x10c(%rax)    # imm = 0xEA6B
movl $0x1, 0xa0(%rax)
movl $0x1, 0xac(%rax)
movl $0x1, 0xb8(%rax)
movl $0xc350, 0xc4(%rax)     # imm = 0xC350
movl $0x0, 0xd0(%rax)
movl $0xc350, 0x118(%rax)    # imm = 0xC350
addq $0x10, %rsp
popq %rbp
retq
// File: Quinny[P]IteratedPrisoners/./ipd/common.h
// Function: ipd::score(ipd::decision, ipd::decision)
int score(decision d1, decision d2) {
    if (d1 == decision::cooperate && d2 == decision::cooperate)
        return 3;
    if (d1 == decision::cooperate && d2 == decision::defect)
        return 0;
    if (d1 == decision::defect && d2 == decision::cooperate)
        return 5;
    if (d1 == decision::defect && d2 == decision::defect)
        return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x577f
cmpl $0x0, -0xc(%rbp)
jne 0x577f
movl $0x3, -0x4(%rbp)
jmp 0x57c5
cmpl $0x0, -0x8(%rbp)
jne 0x5794
cmpl $0x1, -0xc(%rbp)
jne 0x5794
movl $0x0, -0x4(%rbp)
jmp 0x57c5
cmpl $0x1, -0x8(%rbp)
jne 0x57a9
cmpl $0x0, -0xc(%rbp)
jne 0x57a9
movl $0x5, -0x4(%rbp)
jmp 0x57c5
cmpl $0x1, -0x8(%rbp)
jne 0x57be
cmpl $0x1, -0xc(%rbp)
jne 0x57be
movl $0x1, -0x4(%rbp)
jmp 0x57c5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: Quinny[P]IteratedPrisoners/./ipd/common.h
// Function: ipd::play(ipd::prisoner_t const&, ipd::prisoner_t const&, int)
int play(const prisoner_t& p1, const prisoner_t& p2, int n) {
    history_t p1_hist, p2_hist;
    int p1_score = 0;

    for (int i = 0; i < n; ++i) {
        auto d1 = p1(p2_hist);
        auto d2 = p2(p1_hist);
        p1_score += score(d1, d2);

        p1_hist.push_front(d1);
        p2_hist.push_front(d2);
    }
    return p1_score;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x91b0
leaq -0x48(%rbp), %rdi
callq 0x91b0
movl $0x0, -0x4c(%rbp)
movl $0x0, -0x50(%rbp)
movl -0x50(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x58a2
movq -0x8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x91d0
movl %eax, -0x6c(%rbp)
jmp 0x5824
movl -0x6c(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x91d0
movl %eax, -0x70(%rbp)
jmp 0x583c
movl -0x70(%rbp), %eax
movl %eax, -0x68(%rbp)
movl -0x54(%rbp), %edi
movl -0x68(%rbp), %esi
callq 0x5760
movl %eax, %ecx
movl -0x4c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x54(%rbp), %rsi
callq 0x9200
jmp 0x5866
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x9200
jmp 0x5875
jmp 0x5877
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x5806
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x9240
leaq -0x30(%rbp), %rdi
callq 0x9240
jmp 0x58c6
movl -0x4c(%rbp), %eax
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x9240
leaq -0x30(%rbp), %rdi
callq 0x9240
movl -0x74(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x45c0
nop
// File: Quinny[P]IteratedPrisoners/./ipd/common.h
// Function: ipd::total_score(ipd::prisoner_t const&, std::vector<ipd::prisoner_t, std::allocator<ipd::prisoner_t>> const&, int)
int total_score(const prisoner_t& p, const std::vector<prisoner_t>& ps, int n) {
    int score = 0;
    for (const auto& i: ps)
        score += play(p, i, n);
    return score;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9260
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9290
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x92c0
testb $0x1, %al
jne 0x591f
jmp 0x594d
leaq -0x28(%rbp), %rdi
callq 0x9300
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x57d0
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9320
jmp 0x590c
movl -0x18(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Quinny[P]IteratedPrisoners/./ipd/common.h
// Function: ipd::play_tourny(std::vector<ipd::prisoner_t, std::allocator<ipd::prisoner_t>> const&, int)
std::vector<score_t>
play_tourny(const std::vector<prisoner_t>& players, int n) {
    std::vector<std::pair<prisoner_t, int>> ret;
    for (auto p1: players) {
        auto score = total_score(p1, players, n);
        ret.push_back({p1, score});
    }
    std::sort(ret.begin(), ret.end(), std::greater<score_t>());
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0xf0(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x9340
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9260
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9290
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x92c0
testb $0x1, %al
jne 0x5a28
jmp 0x5af0
leaq -0x28(%rbp), %rdi
callq 0x9300
movq %rax, %rsi
leaq -0x70(%rbp), %rdi
callq 0x9360
jmp 0x5a3f
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x70(%rbp), %rdi
callq 0x58d0
movl %eax, -0xf4(%rbp)
jmp 0x5a57
movl -0xf4(%rbp), %eax
movl %eax, -0x80(%rbp)
leaq -0xc8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x93f0
jmp 0x5a76
movq -0xf0(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x93c0
jmp 0x5a8b
leaq -0xc8(%rbp), %rdi
callq 0x9430
leaq -0x70(%rbp), %rdi
callq 0x9450
leaq -0x28(%rbp), %rdi
callq 0x9320
jmp 0x5a12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x5b51
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x5ae5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x9430
leaq -0x70(%rbp), %rdi
callq 0x9450
jmp 0x5b51
movq -0xf0(%rbp), %rdi
callq 0x94c0
movq -0xf0(%rbp), %rdi
movq %rax, -0xd0(%rbp)
callq 0x94f0
movq %rax, -0xd8(%rbp)
movq -0xd0(%rbp), %rdi
movq -0xd8(%rbp), %rsi
callq 0x9480
jmp 0x5b2b
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x5b41
movq -0xf0(%rbp), %rdi
callq 0x9520
movq -0xe8(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xf0(%rbp), %rdi
callq 0x9520
movq -0x78(%rbp), %rdi
callq 0x45c0
nopw %cs:(%rax,%rax)
// File: Quinny[P]IteratedPrisoners/./ipd/bots.h
// Function: ipd::bots::tf2t(std::__cxx11::list<ipd::decision, std::allocator<ipd::decision>> const&)
decision tf2t(const history_t& h) {
    if (h.size() < 2)
        return decision::cooperate;
    if (h.front() == decision::defect && *std::next(h.begin()) == decision::defect)
        return decision::defect;
    return decision::cooperate;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x95d0
cmpq $0x2, %rax
jae 0x5c34
movl $0x0, -0x4(%rbp)
jmp 0x5c94
movq -0x10(%rbp), %rdi
callq 0x95a0
movq %rax, %rcx
xorl %eax, %eax
cmpl $0x1, (%rcx)
movb %al, -0x21(%rbp)
jne 0x5c7b
movq -0x10(%rbp), %rdi
callq 0x9630
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9600
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x9660
cmpl $0x1, (%rax)
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x5c84
jmp 0x5c8d
movl $0x1, -0x4(%rbp)
jmp 0x5c94
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Quinny[P]IteratedPrisoners/./ipd/bots.h
// Function: ipd::bots::sus_tf2t(std::__cxx11::list<ipd::decision, std::allocator<ipd::decision>> const&)
decision sus_tf2t(const history_t& h) {
    if (h.size() < 2)
        return decision::defect;
    if (h.front() == decision::defect && *std::next(h.begin()) == decision::defect)
        return decision::defect;
    return decision::cooperate;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x95d0
cmpq $0x2, %rax
jae 0x5cc4
movl $0x1, -0x4(%rbp)
jmp 0x5d24
movq -0x10(%rbp), %rdi
callq 0x95a0
movq %rax, %rcx
xorl %eax, %eax
cmpl $0x1, (%rcx)
movb %al, -0x21(%rbp)
jne 0x5d0b
movq -0x10(%rbp), %rdi
callq 0x9630
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9600
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x9660
cmpl $0x1, (%rax)
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x5d14
jmp 0x5d1d
movl $0x1, -0x4(%rbp)
jmp 0x5d24
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Quinny[P]IteratedPrisoners/./ipd/config.h
// Function: ipd::config::parse_line(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::pair<std::string, int> parse_line(std::string line) {
        std::stringstream sstream(line);
        std::string name;
        int val;

        sstream >> name >> val;
        return {name, val};
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rsi, -0x1f0(%rbp)
movq %rdi, -0x200(%rbp)
movq %rdi, %rax
movq %rax, -0x1f8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x9e30
movq -0x1f0(%rbp), %rsi
movl %eax, %edx
leaq -0x198(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0x4540
leaq -0x1b8(%rbp), %rdi
movq %rdi, -0x1e0(%rbp)
callq 0x44e0
movq -0x1e8(%rbp), %rdi
movq -0x1e0(%rbp), %rsi
callq 0x4480
movq %rax, -0x1d8(%rbp)
jmp 0x6015
movq -0x1d8(%rbp), %rdi
leaq -0x1bc(%rbp), %rsi
callq 0x4220
jmp 0x602a
movq -0x200(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
leaq -0x1bc(%rbp), %rdx
callq 0x9e50
jmp 0x6046
leaq -0x1b8(%rbp), %rdi
callq 0x4230
leaq -0x198(%rbp), %rdi
callq 0x42d0
movq -0x1f8(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x4230
leaq -0x198(%rbp), %rdi
callq 0x42d0
movq -0x1c8(%rbp), %rdi
callq 0x45c0
nopw %cs:(%rax,%rax)
// File: Quinny[P]IteratedPrisoners/./ipd/config.h
// Function: ipd::config::load_config()
void load_config() {
        std::ifstream in("ipd.conf");
        std::string line;
        while (std::getline(in, line)) {
            auto p = parse_line(line);
            assign_arg(p.first, p.second);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp            # imm = 0x2B0
leaq -0x208(%rbp), %rdi
leaq 0x1a084(%rip), %rsi     # 0x201bd
movl $0x8, %edx
callq 0x45f0
leaq -0x228(%rbp), %rdi
callq 0x44e0
leaq -0x208(%rbp), %rdi
leaq -0x228(%rbp), %rsi
callq 0x40b0
movq %rax, -0x2a8(%rbp)
jmp 0x616b
movq -0x2a8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x4470
movb %al, -0x2a9(%rbp)
jmp 0x6189
movb -0x2a9(%rbp), %al
testb $0x1, %al
jne 0x6198
jmp 0x628b
leaq -0x280(%rbp), %rdi
leaq -0x228(%rbp), %rsi
callq 0x4160
jmp 0x61ad
leaq -0x260(%rbp), %rdi
leaq -0x280(%rbp), %rsi
callq 0x5f90
jmp 0x61c2
leaq -0x280(%rbp), %rdi
callq 0x4230
leaq -0x2a0(%rbp), %rdi
leaq -0x260(%rbp), %rsi
callq 0x4160
jmp 0x61e3
movl -0x240(%rbp), %esi
leaq -0x2a0(%rbp), %rdi
callq 0x60b0
jmp 0x61f7
leaq -0x2a0(%rbp), %rdi
callq 0x4230
leaq -0x260(%rbp), %rdi
callq 0x9f90
jmp 0x614f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
jmp 0x62ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
leaq -0x280(%rbp), %rdi
callq 0x4230
jmp 0x62ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
jmp 0x627d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
leaq -0x2a0(%rbp), %rdi
callq 0x4230
leaq -0x260(%rbp), %rdi
callq 0x9f90
jmp 0x62ac
leaq -0x228(%rbp), %rdi
callq 0x4230
leaq -0x208(%rbp), %rdi
callq 0x4100
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbp
retq
leaq -0x228(%rbp), %rdi
callq 0x4230
leaq -0x208(%rbp), %rdi
callq 0x4100
movq -0x230(%rbp), %rdi
callq 0x45c0
// File: Quinny[P]IteratedPrisoners/./ipd/genetic.h
// Function: ipd::genetic::random_decision()
decision random_decision() {
    static std::uniform_int_distribution<int> dist(0, 1);
    static std::knuth_b gen (std::time(nullptr));
    static auto roll = std::bind(dist, gen);

    if (roll())
        return decision::cooperate;
    return decision::defect;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpb $0x0, 0x2bfc9(%rip)     # 0x32408
jne 0x6473
leaq 0x2bfc0(%rip), %rdi     # 0x32408
callq 0x45e0
cmpl $0x0, %eax
je 0x6473
leaq 0x2bfa7(%rip), %rdi     # 0x32400
xorl %esi, %esi
movl $0x1, %edx
callq 0x9ff0
jmp 0x6467
leaq 0x2bf9a(%rip), %rdi     # 0x32408
callq 0x4260
cmpb $0x0, 0x2c7a6(%rip)     # 0x32c20
jne 0x64b3
leaq 0x2c79d(%rip), %rdi     # 0x32c20
callq 0x45e0
cmpl $0x0, %eax
je 0x64b3
xorl %eax, %eax
movl %eax, %edi
callq 0x4380
movq %rax, %rsi
leaq 0x2bf70(%rip), %rdi     # 0x32410
callq 0xa020
jmp 0x64a7
leaq 0x2c772(%rip), %rdi     # 0x32c20
callq 0x4260
cmpb $0x0, 0x2cf86(%rip)     # 0x33440
jne 0x64f5
leaq 0x2cf7d(%rip), %rdi     # 0x33440
callq 0x45e0
cmpl $0x0, %eax
je 0x64f5
leaq 0x2c754(%rip), %rdi     # 0x32c28
leaq 0x2bf25(%rip), %rsi     # 0x32400
leaq 0x2bf2e(%rip), %rdx     # 0x32410
callq 0xa050
jmp 0x64e9
leaq 0x2cf50(%rip), %rdi     # 0x33440
callq 0x4260
leaq 0x2c72c(%rip), %rdi     # 0x32c28
callq 0xa090
cmpl $0x0, %eax
je 0x655d
movl $0x0, -0x4(%rbp)
jmp 0x6564
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq 0x2bee6(%rip), %rdi     # 0x32408
callq 0x4250
jmp 0x656d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq 0x2c6e4(%rip), %rdi     # 0x32c20
callq 0x4250
jmp 0x656d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq 0x2ceea(%rip), %rdi     # 0x33440
callq 0x4250
jmp 0x656d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x45c0
nopw %cs:(%rax,%rax)