LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2PixelDatabase.cpp
// Function: gaps::R2PixelDatabase::CloseStream()
int R2PixelDatabase::
CloseStream(void)
{
  // Check if writing file
  if (strcmp(rwaccess, "rb")) {
    // Write entries
    if (!WriteEntries(fp, swap_endian)) return 0;

    // Get position at end of stream
    unsigned long long end_of_stream = RNFileTell(fp);
    
    // Write header again (now that the seek values have been filled in)
    if (!WriteHeader(fp, swap_endian)) return 0;

    // Seek back to end of stream
    RNFileSeek(fp, end_of_stream, RN_FILE_SEEK_SET);
  }

  // Reset filename
  if (filename) free(filename);
  filename = NULL;

  // Reset rwaccess
  if (rwaccess) free(rwaccess);
  rwaccess = NULL;

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rax
cmpb $0x72, (%rax)
jne 0x9be38
cmpb $0x62, 0x1(%rax)
jne 0x9be38
cmpb $0x0, 0x2(%rax)
je 0x9be7f
movq (%rbx), %rax
movq 0x8(%rbx), %rsi
movl 0x30(%rbx), %edx
movq %rbx, %rdi
callq *0x80(%rax)
xorl %ebp, %ebp
testl %eax, %eax
je 0x9beb0
movq 0x8(%rbx), %rdi
callq 0xabc6b
movq %rax, %r14
movq (%rbx), %rax
movq 0x8(%rbx), %rsi
movl 0x30(%rbx), %edx
movq %rbx, %rdi
callq *0x70(%rax)
testl %eax, %eax
je 0x9beb0
movq 0x8(%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xabc5a
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x9be8d
callq 0x135e0
movq $0x0, 0x18(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x9bea3
callq 0x135e0
movq $0x0, 0x20(%rbx)
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2PixelDatabase.cpp
// Function: gaps::R2PixelDatabase::ReadHeader(_IO_FILE*)
int R2PixelDatabase::
ReadHeader(FILE *fp)
{
  // Seek to beginning of file
  RNFileSeek(fp, 0, RN_FILE_SEEK_SET);

  // Read magic string
  char buffer[1024]; 
  if (!RNReadChar(fp, buffer, 32, 0)) return 0;
  if (strcmp(buffer, "R2PixelDatabase")) {
    RNFail("Incorrect header (%s) in database file %s\n", buffer, filename);
    return 0;
  }

  // Read endian test
  unsigned int endian_test1, endian_test2;
  if (!RNReadUnsignedInt(fp, &endian_test1, 1, 0)) return 0;
  if (endian_test1 != 1) swap_endian = 1;
  if (!RNReadUnsignedInt(fp, &endian_test2, 1, swap_endian)) return 0;
  if (endian_test2 != 1) {
    RNFail("Incorrect endian (%x) in database file %s\n", endian_test1, filename);
    return 0;
  }

  // Read version
  if (!RNReadUnsignedInt(fp, &major_version, 1, swap_endian)) return 0;
  if (!RNReadUnsignedInt(fp, &minor_version, 1, swap_endian)) return 0;
  
  // Read entry info
  if (!RNReadUnsignedLongLong(fp, &entries_seek, 1, swap_endian)) return 0;
  if (!RNReadUnsignedInt(fp, &entries_count, 1, swap_endian)) return 0;

  // Read extra at end of header
  if (!RNReadChar(fp, buffer, 1024, swap_endian)) return 0;
  
  // Return success
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x410, %rsp            # imm = 0x410
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xabc5a
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movl $0x20, %edx
xorl %ecx, %ecx
callq 0xabc70
testl %eax, %eax
je 0x9bf22
movdqa 0x10(%rsp), %xmm0
pcmpeqb 0x4a102(%rip), %xmm0    # 0xe6000
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x9bf31
movq 0x18(%r15), %rdx
leaq 0x42adc(%rip), %rdi     # 0xde9f0
xorl %ebx, %ebx
leaq 0x10(%rsp), %rsi
xorl %eax, %eax
callq 0xac81a
movl %ebx, %eax
addq $0x410, %rsp            # imm = 0x410
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %rsi
xorl %ebx, %ebx
movq %r14, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0xabe71
testl %eax, %eax
je 0x9bf22
cmpl $0x1, 0x8(%rsp)
jne 0x9bf58
movl 0x30(%r15), %ecx
jmp 0x9bf65
movl $0x1, 0x30(%r15)
movl $0x1, %ecx
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0xabe71
testl %eax, %eax
je 0x9bf22
cmpl $0x1, 0xc(%rsp)
jne 0x9c018
leaq 0x28(%r15), %rsi
movl 0x30(%r15), %ecx
movq %r14, %rdi
movl $0x1, %edx
callq 0xabe71
testl %eax, %eax
je 0x9bf22
leaq 0x2c(%r15), %rsi
movl 0x30(%r15), %ecx
movq %r14, %rdi
movl $0x1, %edx
callq 0xabe71
testl %eax, %eax
je 0x9bf22
leaq 0x38(%r15), %rsi
movl 0x30(%r15), %ecx
movq %r14, %rdi
movl $0x1, %edx
callq 0xac05b
testl %eax, %eax
je 0x9bf22
leaq 0x34(%r15), %rsi
movl 0x30(%r15), %ecx
movq %r14, %rdi
movl $0x1, %edx
callq 0xabe71
testl %eax, %eax
je 0x9bf22
movl 0x30(%r15), %ecx
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movl $0x400, %edx            # imm = 0x400
callq 0xabc70
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
jmp 0x9bf22
movl 0x8(%rsp), %esi
movq 0x18(%r15), %rdx
leaq 0x429f4(%rip), %rdi     # 0xdea1b
xorl %ebx, %ebx
xorl %eax, %eax
callq 0xac81a
jmp 0x9bf22
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2PixelDatabase.cpp
// Function: gaps::R2PixelDatabase::WriteHeader(_IO_FILE*, int)
int R2PixelDatabase::
WriteHeader(FILE *fp, int swap_endian)
{
  // Seek to beginning of file
  RNFileSeek(fp, 0, RN_FILE_SEEK_SET);

  // Get convenient variables
  unsigned int endian_test = 1;
  char magic[32] = { '\0' };
  strncpy(magic, "R2PixelDatabase", 32);
  char buffer[1024] = { '\0' };

  // Write header
  if (!RNWriteChar(fp, magic, 32, swap_endian)) return 0;
  if (!RNWriteUnsignedInt(fp, &endian_test, 1, swap_endian)) return 0;
  if (!RNWriteUnsignedInt(fp, &endian_test, 1, swap_endian)) return 0;
  if (!RNWriteUnsignedInt(fp, &major_version, 1, swap_endian)) return 0;
  if (!RNWriteUnsignedInt(fp, &minor_version, 1, swap_endian)) return 0;
  if (!RNWriteUnsignedLongLong(fp, &entries_seek, 1, swap_endian)) return 0;
  if (!RNWriteUnsignedInt(fp, &entries_count, 1, swap_endian)) return 0;
  if (!RNWriteChar(fp, buffer, 1024, swap_endian)) return 0;
  
  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x430, %rsp            # imm = 0x430
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xabc5a
movl $0x1, 0xc(%rsp)
movups 0x4a005(%rip), %xmm0    # 0xe606f
leaq 0x10(%rsp), %r12
movaps %xmm0, 0x10(%r12)
movups 0x49fe3(%rip), %xmm0    # 0xe605f
movaps %xmm0, (%r12)
leaq 0x30(%rsp), %rdi
movl $0x400, %edx            # imm = 0x400
xorl %esi, %esi
callq 0x132a0
movq %r14, %rdi
movq %r12, %rsi
movl $0x20, %edx
movl %ebp, %ecx
callq 0xac0d0
testl %eax, %eax
je 0x9c15a
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
movl $0x1, %edx
movl %ebp, %ecx
callq 0xac2de
testl %eax, %eax
je 0x9c15a
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
movl $0x1, %edx
movl %ebp, %ecx
callq 0xac2de
testl %eax, %eax
je 0x9c15a
leaq 0x28(%r15), %rsi
movq %r14, %rdi
movl $0x1, %edx
movl %ebp, %ecx
callq 0xac2de
testl %eax, %eax
je 0x9c15a
leaq 0x2c(%r15), %rsi
movq %r14, %rdi
movl $0x1, %edx
movl %ebp, %ecx
callq 0xac2de
testl %eax, %eax
je 0x9c15a
leaq 0x38(%r15), %rsi
movq %r14, %rdi
movl $0x1, %edx
movl %ebp, %ecx
callq 0xac50a
testl %eax, %eax
je 0x9c15a
addq $0x34, %r15
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
movl %ebp, %ecx
callq 0xac2de
testl %eax, %eax
je 0x9c15a
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
movl $0x400, %edx            # imm = 0x400
movl %ebp, %ecx
callq 0xac0d0
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
movl %ebx, %eax
addq $0x430, %rsp            # imm = 0x430
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R2Shapes/R2PixelDatabase.cpp
// Function: gaps::R2PixelDatabase::WriteEntries(_IO_FILE*, int)
int R2PixelDatabase::
WriteEntries(FILE *fp, int swap_endian)
{
  // Seek to entries seek
  RNFileSeek(fp, entries_seek, RN_FILE_SEEK_SET);

  // Write entries
  int dummy = 0;
  char buffer[128] = { '\0' };
  std::map<std::string, R2PixelDatabaseEntry, RNMapComparator<std::string> >::iterator it;
  for (it = map.m->begin(); it != map.m->end(); ++it) {
    R2PixelDatabaseEntry entry = it->second;
    strncpy(buffer, entry.key, 128);
    if (!RNWriteChar(fp, buffer, 128, swap_endian)) return 0;
    if (!RNWriteUnsignedInt(fp, &entry.format, 1, swap_endian)) return 0;
    if (!RNWriteUnsignedInt(fp, &entry.size, 1, swap_endian)) return 0;
    if (!RNWriteUnsignedLongLong(fp, &entry.seek, 1, swap_endian)) return 0;
    if (!RNWriteDouble(fp, &entry.offset, 1, swap_endian)) return 0;
    if (!RNWriteDouble(fp, &entry.scale, 1, swap_endian)) return 0;
    if (!RNWriteDouble(fp, &entry.exponent, 1, swap_endian)) return 0;
    for (int j = 0; j < 12; j++) RNWriteInt(fp, &dummy, 1, swap_endian);
  }

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x38(%rdi), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xabc5a
movl $0x0, 0x4(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq %r15, 0x8(%rsp)
movq 0x40(%r15), %rax
movq 0x18(%rax), %r12
addq $0x8, %rax
cmpq %rax, %r12
je 0x9c609
leaq 0x4(%rsp), %rbp
leaq 0x40(%r12), %r13
movl $0xa8, %edx
leaq 0x90(%rsp), %rdi
movq %r13, %rsi
callq 0x133f0
movl $0x80, %edx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x13280
movq %r14, %rdi
movq %r15, %rsi
movl $0x80, %edx
movl %ebx, %ecx
callq 0xac0d0
testl %eax, %eax
je 0x9c610
movq %r14, %rdi
leaq 0x110(%rsp), %rsi
movl $0x1, %edx
movl %ebx, %ecx
callq 0xac2de
testl %eax, %eax
je 0x9c610
movq %r14, %rdi
leaq 0x114(%rsp), %rsi
movl $0x1, %edx
movl %ebx, %ecx
callq 0xac2de
testl %eax, %eax
je 0x9c610
movq %r14, %rdi
leaq 0x118(%rsp), %rsi
movl $0x1, %edx
movl %ebx, %ecx
callq 0xac50a
testl %eax, %eax
je 0x9c610
movq %r14, %rdi
leaq 0x120(%rsp), %rsi
movl $0x1, %edx
movl %ebx, %ecx
callq 0xac3ee
testl %eax, %eax
je 0x9c610
movq %r14, %rdi
leaq 0x128(%rsp), %rsi
movl $0x1, %edx
movl %ebx, %ecx
callq 0xac3ee
testl %eax, %eax
je 0x9c610
movq %r14, %rdi
leaq 0x130(%rsp), %rsi
movl $0x1, %edx
movl %ebx, %ecx
callq 0xac3ee
testl %eax, %eax
je 0x9c610
movl $0xc, %r13d
movq %r14, %rdi
movq %rbp, %rsi
movl $0x1, %edx
movl %ebx, %ecx
callq 0xac256
decl %r13d
jne 0x9c5d1
movq %r12, %rdi
callq 0x13370
movq %rax, %r12
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
addq $0x8, %rax
cmpq %rax, %r12
jne 0x9c4d4
movl $0x1, %eax
jmp 0x9c612
xorl %eax, %eax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/RNFile.cpp
// Function: gaps::RNFileSize(char const*)
unsigned long long
RNFileSize(const char *filename)
{
#if 1
    // Return size of file in bytes
    FILE *fp = fopen(filename, "r");
    if (!fp) return 0;
    RNFileSeek(fp, 0, RN_FILE_SEEK_END);
    unsigned long long file_size = RNFileTell(fp);
    fclose(fp);
    return file_size;
#else
    // Requires "unistd.h"
    struct stat stat_buf;
    int rc = fstat(filename, &stat_buf);
    if (rc == 0) return 0;
    else return stat_buf.st_size;
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x3cc77(%rip), %rsi     # 0xe8893
callq 0x135d0
testq %rax, %rax
je 0xabc50
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x132e0
movq %rbx, %rdi
callq 0x13630
movq %rax, %r14
movq %rbx, %rdi
callq 0x134d0
movq %r14, %rax
jmp 0xabc52
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/RNFile.cpp
// Function: gaps::RNReadShort(_IO_FILE*, short*, int, int)
int 
RNReadShort(FILE *fp, short *ptr, int count, int swap_endian)
{
  // Read the values
  if (fread(ptr, sizeof(short), count, fp) != (size_t) count) {
    RNFail("Unable to read short from file\n");
    return 0;
  }

  // Swap endian
  if (swap_endian) RNSwap2(ptr, count);

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %rcx
movslq %edx, %r15
movl $0x2, %esi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x13790
cmpq %r15, %rax
jne 0xabd44
testl %ebp, %ebp
sete %al
testl %r14d, %r14d
setle %cl
movl $0x1, %ebp
orb %al, %cl
jne 0xabd54
movl %r14d, %eax
xorl %ecx, %ecx
rolw $0x8, (%rbx,%rcx,2)
incq %rcx
cmpq %rcx, %rax
jne 0xabd35
jmp 0xabd54
leaq 0x3ab14(%rip), %rdi     # 0xe685f
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xac81a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/RNFile.cpp
// Function: gaps::RNReadUnsignedShort(_IO_FILE*, unsigned short*, int, int)
int 
RNReadUnsignedShort(FILE *fp, unsigned short *ptr, int count, int swap_endian)
{
  // Read the values
  if (fread(ptr, sizeof(unsigned short), count, fp) != (size_t) count) {
    RNFail("Unable to read unsigned short from file\n");
    return 0;
  }

  // Swap endian
  if (swap_endian) RNSwap2(ptr, count);

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %rcx
movslq %edx, %r15
movl $0x2, %esi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x13790
cmpq %r15, %rax
jne 0xabdc9
testl %ebp, %ebp
sete %al
testl %r14d, %r14d
setle %cl
movl $0x1, %ebp
orb %al, %cl
jne 0xabdd9
movl %r14d, %eax
xorl %ecx, %ecx
rolw $0x8, (%rbx,%rcx,2)
incq %rcx
cmpq %rcx, %rax
jne 0xabdba
jmp 0xabdd9
leaq 0x3aaaf(%rip), %rdi     # 0xe687f
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xac81a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/RNFile.cpp
// Function: gaps::RNReadInt(_IO_FILE*, int*, int, int)
int 
RNReadInt(FILE *fp, int *ptr, int count, int swap_endian)
{
  // Read the values
  if (fread(ptr, sizeof(int), count, fp) != (size_t) count) {
    RNFail("Unable to read integer from file\n");
    return 0;
  }

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

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %rcx
movslq %edx, %r15
movl $0x4, %esi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x13790
cmpq %r15, %rax
jne 0xabe3b
testl %ebp, %ebp
sete %al
testl %r14d, %r14d
setle %cl
movl $0x1, %ebp
orb %al, %cl
jne 0xabe4b
movl %r14d, %eax
xorl %ecx, %ecx
movl (%rbx,%rcx,4), %edx
bswapl %edx
movl %edx, (%rbx,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0xabe29
jmp 0xabe4b
leaq 0x3aa66(%rip), %rdi     # 0xe68a8
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xac81a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/RNFile.cpp
// Function: gaps::RNReadUnsignedInt(_IO_FILE*, unsigned int*, int, int)
int 
RNReadUnsignedInt(FILE *fp, unsigned int *ptr, int count, int swap_endian)
{
  // Read the values
  if (fread(ptr, sizeof(unsigned int), count, fp) != (size_t) count) {
    RNFail("Unable to read unsigned integer from file\n");
    return 0;
  }

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

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %rcx
movslq %edx, %r15
movl $0x4, %esi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x13790
cmpq %r15, %rax
jne 0xabec6
testl %ebp, %ebp
sete %al
testl %r14d, %r14d
setle %cl
movl $0x1, %ebp
orb %al, %cl
jne 0xabed6
movl %r14d, %eax
xorl %ecx, %ecx
movl (%rbx,%rcx,4), %edx
bswapl %edx
movl %edx, (%rbx,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0xabeb4
jmp 0xabed6
leaq 0x3a9fd(%rip), %rdi     # 0xe68ca
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xac81a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/RNFile.cpp
// Function: gaps::RNReadFloat(_IO_FILE*, float*, int, int)
int
RNReadFloat(FILE *fp, float *ptr, int count, int swap_endian)
{
  // Read the values
  if (fread(ptr, sizeof(float), count, fp) != (size_t) count) {
    RNFail("Unable to read float from file\n");
    return 0;
  }

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

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %rcx
movslq %edx, %r15
movl $0x4, %esi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x13790
cmpq %r15, %rax
jne 0xabf38
testl %ebp, %ebp
sete %al
testl %r14d, %r14d
setle %cl
movl $0x1, %ebp
orb %al, %cl
jne 0xabf48
movl %r14d, %eax
xorl %ecx, %ecx
movl (%rbx,%rcx,4), %edx
bswapl %edx
movl %edx, (%rbx,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0xabf26
jmp 0xabf48
leaq 0x3a9b6(%rip), %rdi     # 0xe68f5
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xac81a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/RNFile.cpp
// Function: gaps::RNReadDouble(_IO_FILE*, double*, int, int)
int
RNReadDouble(FILE *fp, double *ptr, int count, int swap_endian)
{
  // Read the values
  if (fread(ptr, sizeof(double), count, fp) != (size_t) count) {
    RNFail("Unable to read double from file\n");
    return 0;
  }

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

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %rcx
movslq %edx, %r15
movl $0x8, %esi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x13790
cmpq %r15, %rax
jne 0xabfad
testl %ebp, %ebp
sete %al
testl %r14d, %r14d
setle %cl
movl $0x1, %ebp
orb %al, %cl
jne 0xabfbd
movl %r14d, %eax
xorl %ecx, %ecx
movq (%rbx,%rcx,8), %rdx
bswapq %rdx
movq %rdx, (%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0xabf98
jmp 0xabfbd
leaq 0x3a961(%rip), %rdi     # 0xe6915
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xac81a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/RNFile.cpp
// Function: gaps::RNReadLongLong(_IO_FILE*, long long*, int, int)
int
RNReadLongLong(FILE *fp, long long *ptr, int count, int swap_endian)
{
  // Read the values
  if (fread(ptr, sizeof(long long), count, fp) != (size_t) count) {
    RNFail("Unable to read long long from file\n");
    return 0;
  }

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

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %rcx
movslq %edx, %r15
movl $0x8, %esi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x13790
cmpq %r15, %rax
jne 0xac03e
testl %ebp, %ebp
sete %al
testl %r14d, %r14d
setle %cl
movl $0x1, %ebp
orb %al, %cl
jne 0xac04e
movl %r14d, %eax
xorl %ecx, %ecx
movq (%rbx,%rcx,8), %rdx
bswapq %rdx
movq %rdx, (%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0xac029
jmp 0xac04e
leaq 0x3a8f1(%rip), %rdi     # 0xe6936
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xac81a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/RNFile.cpp
// Function: gaps::RNReadUnsignedLongLong(_IO_FILE*, unsigned long long*, int, int)
int
RNReadUnsignedLongLong(FILE *fp, unsigned long long *ptr, int count, int swap_endian)
{
  // Read the values
  if (fread(ptr, sizeof(unsigned long long), count, fp) != (size_t) count) {
    RNFail("Unable to read unsigned long long from file\n");
    return 0;
  }

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

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %rcx
movslq %edx, %r15
movl $0x8, %esi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x13790
cmpq %r15, %rax
jne 0xac0b3
testl %ebp, %ebp
sete %al
testl %r14d, %r14d
setle %cl
movl $0x1, %ebp
orb %al, %cl
jne 0xac0c3
movl %r14d, %eax
xorl %ecx, %ecx
movq (%rbx,%rcx,8), %rdx
bswapq %rdx
movq %rdx, (%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0xac09e
jmp 0xac0c3
leaq 0x3a8a0(%rip), %rdi     # 0xe695a
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xac81a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/RNFile.cpp
// Function: gaps::RNWriteShort(_IO_FILE*, short const*, int, int)
int
RNWriteShort(FILE *fp, const short *ptr, int count, int swap_endian)
{
  // Swap endian
  if (swap_endian) RNSwap2((void *) ptr, count);

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

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

  // Return status
  return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %eax
movq %rsi, %rbx
movq %rdi, %rcx
testl %eax, %eax
setne %al
testl %edx, %edx
setg %r12b
andb %al, %r12b
movl %edx, %r15d
cmpb $0x1, %r12b
jne 0xac188
xorl %eax, %eax
rolw $0x8, (%rbx,%rax,2)
incq %rax
cmpq %rax, %r15
jne 0xac17b
movslq %edx, %r14
movl $0x2, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x139a0
movl $0x1, %ebp
cmpq %r14, %rax
je 0xac1b5
leaq 0x3a823(%rip), %rdi     # 0xe69cf
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xac81a
testb %r12b, %r12b
je 0xac1c9
xorl %eax, %eax
rolw $0x8, (%rbx,%rax,2)
incq %rax
cmpq %rax, %r15
jne 0xac1bc
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/RNFile.cpp
// Function: gaps::RNWriteUnsignedShort(_IO_FILE*, unsigned short const*, int, int)
int
RNWriteUnsignedShort(FILE *fp, const unsigned short *ptr, int count, int swap_endian)
{
  // Swap endian
  if (swap_endian) RNSwap2((void *) ptr, count);

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

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

  // Return status
  return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %eax
movq %rsi, %rbx
movq %rdi, %rcx
testl %eax, %eax
setne %al
testl %edx, %edx
setg %r12b
andb %al, %r12b
movl %edx, %r15d
cmpb $0x1, %r12b
jne 0xac20a
xorl %eax, %eax
rolw $0x8, (%rbx,%rax,2)
incq %rax
cmpq %rax, %r15
jne 0xac1fd
movslq %edx, %r14
movl $0x2, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x139a0
movl $0x1, %ebp
cmpq %r14, %rax
je 0xac237
leaq 0x3a7c0(%rip), %rdi     # 0xe69ee
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xac81a
testb %r12b, %r12b
je 0xac24b
xorl %eax, %eax
rolw $0x8, (%rbx,%rax,2)
incq %rax
cmpq %rax, %r15
jne 0xac23e
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/RNFile.cpp
// Function: gaps::RNWriteInt(_IO_FILE*, int const*, int, int)
int
RNWriteInt(FILE *fp, const 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(int), count, fp) != (size_t) count) {
    RNFail("Unable to write integer to file\n");
    status = 0;
  }

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

  // Return status
  return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %eax
movq %rsi, %rbx
movq %rdi, %rcx
testl %eax, %eax
setne %al
testl %edx, %edx
setg %r12b
andb %al, %r12b
movl %edx, %r15d
cmpb $0x1, %r12b
jne 0xac28f
xorl %eax, %eax
movl (%rbx,%rax,4), %esi
bswapl %esi
movl %esi, (%rbx,%rax,4)
incq %rax
cmpq %rax, %r15
jne 0xac27f
movslq %edx, %r14
movl $0x4, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x139a0
movl $0x1, %ebp
cmpq %r14, %rax
je 0xac2bc
leaq 0x3a6d4(%rip), %rdi     # 0xe6987
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xac81a
testb %r12b, %r12b
je 0xac2d3
xorl %eax, %eax
movl (%rbx,%rax,4), %ecx
bswapl %ecx
movl %ecx, (%rbx,%rax,4)
incq %rax
cmpq %rax, %r15
jne 0xac2c3
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %eax
movq %rsi, %rbx
movq %rdi, %rcx
testl %eax, %eax
setne %al
testl %edx, %edx
setg %r12b
andb %al, %r12b
movl %edx, %r15d
cmpb $0x1, %r12b
jne 0xac317
xorl %eax, %eax
movl (%rbx,%rax,4), %esi
bswapl %esi
movl %esi, (%rbx,%rax,4)
incq %rax
cmpq %rax, %r15
jne 0xac307
movslq %edx, %r14
movl $0x4, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x139a0
movl $0x1, %ebp
cmpq %r14, %rax
je 0xac344
leaq 0x3a6db(%rip), %rdi     # 0xe6a16
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xac81a
testb %r12b, %r12b
je 0xac35b
xorl %eax, %eax
movl (%rbx,%rax,4), %ecx
bswapl %ecx
movl %ecx, (%rbx,%rax,4)
incq %rax
cmpq %rax, %r15
jne 0xac34b
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %eax
movq %rsi, %rbx
movq %rdi, %rcx
testl %eax, %eax
setne %al
testl %edx, %edx
setg %r12b
andb %al, %r12b
movl %edx, %r15d
cmpb $0x1, %r12b
jne 0xac39f
xorl %eax, %eax
movl (%rbx,%rax,4), %esi
bswapl %esi
movl %esi, (%rbx,%rax,4)
incq %rax
cmpq %rax, %r15
jne 0xac38f
movslq %edx, %r14
movl $0x4, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x139a0
movl $0x1, %ebp
cmpq %r14, %rax
je 0xac3cc
leaq 0x3a67d(%rip), %rdi     # 0xe6a40
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xac81a
testb %r12b, %r12b
je 0xac3e3
xorl %eax, %eax
movl (%rbx,%rax,4), %ecx
bswapl %ecx
movl %ecx, (%rbx,%rax,4)
incq %rax
cmpq %rax, %r15
jne 0xac3d3
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %eax
movq %rsi, %rbx
movq %rdi, %rcx
testl %eax, %eax
setne %al
testl %edx, %edx
setg %r12b
andb %al, %r12b
movl %edx, %r15d
cmpb $0x1, %r12b
jne 0xac42a
xorl %eax, %eax
movq (%rbx,%rax,8), %rsi
bswapq %rsi
movq %rsi, (%rbx,%rax,8)
incq %rax
cmpq %rax, %r15
jne 0xac417
movslq %edx, %r14
movl $0x8, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x139a0
movl $0x1, %ebp
cmpq %r14, %rax
je 0xac457
leaq 0x3a611(%rip), %rdi     # 0xe6a5f
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xac81a
testb %r12b, %r12b
je 0xac471
xorl %eax, %eax
movq (%rbx,%rax,8), %rcx
bswapq %rcx
movq %rcx, (%rbx,%rax,8)
incq %rax
cmpq %rax, %r15
jne 0xac45e
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %eax
movq %rsi, %rbx
movq %rdi, %rcx
testl %eax, %eax
setne %al
testl %edx, %edx
setg %r12b
andb %al, %r12b
movl %edx, %r15d
cmpb $0x1, %r12b
jne 0xac4b8
xorl %eax, %eax
movq (%rbx,%rax,8), %rsi
bswapq %rsi
movq %rsi, (%rbx,%rax,8)
incq %rax
cmpq %rax, %r15
jne 0xac4a5
movslq %edx, %r14
movl $0x8, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x139a0
movl $0x1, %ebp
cmpq %r14, %rax
je 0xac4e5
leaq 0x3a5a3(%rip), %rdi     # 0xe6a7f
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xac81a
testb %r12b, %r12b
je 0xac4ff
xorl %eax, %eax
movq (%rbx,%rax,8), %rcx
bswapq %rcx
movq %rcx, (%rbx,%rax,8)
incq %rax
cmpq %rax, %r15
jne 0xac4ec
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %eax
movq %rsi, %rbx
movq %rdi, %rcx
testl %eax, %eax
setne %al
testl %edx, %edx
setg %r12b
andb %al, %r12b
movl %edx, %r15d
cmpb $0x1, %r12b
jne 0xac546
xorl %eax, %eax
movq (%rbx,%rax,8), %rsi
bswapq %rsi
movq %rsi, (%rbx,%rax,8)
incq %rax
cmpq %rax, %r15
jne 0xac533
movslq %edx, %r14
movl $0x8, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x139a0
movl $0x1, %ebp
cmpq %r14, %rax
je 0xac573
leaq 0x3a538(%rip), %rdi     # 0xe6aa2
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xac81a
testb %r12b, %r12b
je 0xac58d
xorl %eax, %eax
movq (%rbx,%rax,8), %rcx
bswapq %rcx
movq %rcx, (%rbx,%rax,8)
incq %rax
cmpq %rax, %r15
jne 0xac57a
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
movq %r14, %rdi
callq 0x10e0
testl %eax, %eax
je 0x1446
xorl %r15d, %r15d
cmpl $0x100, (%r14)          # imm = 0x100
sete %al
orb %al, %r15b
movq %r14, %rdi
callq 0x10e0
testl %eax, %eax
jne 0x140a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x208e
movq %rbx, %rdi
callq 0x2162
movq %rbx, %rdi
callq 0x21ba
testb $0x1, %r15b
je 0x13fb
jmp 0x1463
movq %rbx, %rdi
movq %r14, %rsi
callq 0x208e
movq %rbx, %rdi
callq 0x2162
movq %rbx, %rdi
callq 0x21ba
jmp 0x13fb
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
callq 0x147c
movq %rax, %rdi
movl $0xc8, %esi
xorl %edx, %edx
movl $0xc8, %ecx
movl $0x258, %r8d            # imm = 0x258
callq 0x10b0
callq 0x147c
movq %rax, %rdi
movl $0x190, %esi            # imm = 0x190
xorl %edx, %edx
movl $0x190, %ecx            # imm = 0x190
movl $0x258, %r8d            # imm = 0x258
callq 0x10b0
callq 0x147c
movq %rax, %rdi
xorl %esi, %esi
movl $0xc8, %edx
movl $0x258, %ecx            # imm = 0x258
movl $0xc8, %r8d
callq 0x10b0
callq 0x147c
movq %rax, %rdi
xorl %esi, %esi
movl $0x190, %edx            # imm = 0x190
movl $0x258, %ecx            # imm = 0x258
movl $0x190, %r8d            # imm = 0x190
popq %rbp
jmp 0x10b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movl (%rbx,%r15,4), %eax
cmpl $0x2, %eax
je 0x15ae
cmpl $0x1, %eax
jne 0x15b9
movl %r14d, %edi
movl %r15d, %esi
callq 0x21ec
jmp 0x15b9
movl %r14d, %edi
movl %r15d, %esi
callq 0x224e
incq %r15
cmpq $0x3, %r15
jne 0x1593
incq %r14
addq $0xc, %rbx
cmpq $0x3, %r14
jne 0x1590
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl 0x4(%rdi), %ecx
movb $0x1, %al
cmpl %ecx, (%rdi)
jne 0x1648
movl 0x8(%rdi), %edx
cmpl %edx, %ecx
jne 0x1648
testl %edx, %edx
jne 0x1677
movl 0x10(%rdi), %ecx
cmpl %ecx, 0xc(%rdi)
jne 0x165b
movl 0x14(%rdi), %edx
cmpl %edx, %ecx
jne 0x165b
testl %edx, %edx
jne 0x1677
movl 0x1c(%rdi), %eax
cmpl %eax, 0x18(%rdi)
sete %cl
movl 0x20(%rdi), %edx
cmpl %edx, %eax
sete %sil
testl %edx, %edx
setne %al
andb %sil, %al
andb %cl, %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl 0xc(%rdi), %ecx
movb $0x1, %al
cmpl %ecx, (%rdi)
jne 0x1692
movl 0x18(%rdi), %edx
cmpl %edx, %ecx
jne 0x1692
testl %edx, %edx
jne 0x16c1
movl 0x10(%rdi), %ecx
cmpl %ecx, 0x4(%rdi)
jne 0x16a5
movl 0x1c(%rdi), %edx
cmpl %edx, %ecx
jne 0x16a5
testl %edx, %edx
jne 0x16c1
movl 0x14(%rdi), %eax
cmpl %eax, 0x8(%rdi)
sete %cl
movl 0x20(%rdi), %edx
cmpl %edx, %eax
sete %sil
testl %edx, %edx
setne %al
andb %sil, %al
andb %cl, %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl 0x10(%rdi), %ecx
cmpl %ecx, (%rdi)
jne 0x16dc
movl 0x20(%rdi), %edx
cmpl %edx, %ecx
jne 0x16dc
movb $0x1, %al
testl %edx, %edx
jne 0x16f3
cmpl %ecx, 0x8(%rdi)
movl 0x18(%rdi), %eax
sete %dl
cmpl %eax, %ecx
sete %cl
testl %eax, %eax
setne %al
andb %cl, %al
andb %dl, %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x4, %rdi
callq 0x1802
leaq 0x8(%rbx), %rdi
callq 0x14b0
callq 0x1090
andb $0x1, %al
movb %al, 0x30(%rbx)
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x1, (%rdi)
jne 0x20b9
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x205c
cmpb $0x0, 0x30(%rbx)
je 0x2139
cmpl $0x401, (%rsi)          # imm = 0x401
jne 0x2154
leaq -0x28(%rbp), %r15
leaq -0x24(%rbp), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x1170
movslq (%r14), %rax
imulq $0x51eb851f, %rax, %r14 # imm = 0x51EB851F
movq %r14, %rax
shrq $0x3f, %rax
sarq $0x26, %r14
addl %eax, %r14d
movslq (%r15), %rax
imulq $0x51eb851f, %rax, %r15 # imm = 0x51EB851F
movq %r15, %rax
shrq $0x3f, %rax
sarq $0x26, %r15
addl %eax, %r15d
leaq 0x8(%rbx), %r12
movq %r12, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x1746
testb %al, %al
je 0x2154
movq %r12, %rdi
movl %r14d, %esi
movl %r15d, %edx
movl $0x1, %ecx
callq 0x1704
jmp 0x2146
leaq 0x4(%rbx), %rdi
leaq 0x8(%rbx), %rsi
callq 0x1834
xorb $0x1, 0x30(%rbx)
movl $0x64, %edi
callq 0x10f0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x147c
movq %rax, %rdi
movl $0xff, %esi
movl $0xff, %edx
movl $0xff, %ecx
movl $0xff, %r8d
callq 0x1150
callq 0x147c
movq %rax, %rdi
callq 0x1130
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x14c8
callq 0x147c
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1070
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movl %edi, %r14d
callq 0x147c
imull $0xc8, %ebx, %ebx
imull $0xc8, %r14d, %r14d
movl $0xc8, %r15d
leal (%rbx,%r15), %r12d
addl %r14d, %r15d
movq %rax, %rdi
movl %ebx, %esi
movl %r14d, %edx
movl %r12d, %ecx
movl %r15d, %r8d
callq 0x10b0
callq 0x147c
movq %rax, %rdi
movl %ebx, %esi
movl %r15d, %edx
movl %r12d, %ecx
movl %r14d, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
imull $0xc8, %esi, %ebx
leal 0x64(%rbx), %eax
imull $0xc8, %edi, %r14d
addl $0x64, %r14d
addl $0xc8, %ebx
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
movsd %xmm0, -0x30(%rbp)
xorpd %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x1190
movsd 0xdf8(%rip), %xmm1      # 0x30a0
mulsd %xmm1, %xmm0
addsd -0x38(%rbp), %xmm0
cvttsd2si %xmm0, %r15d
movsd -0x28(%rbp), %xmm0
callq 0x1080
mulsd 0xdd8(%rip), %xmm0      # 0x30a0
addsd -0x30(%rbp), %xmm0
cvttsd2si %xmm0, %r12d
callq 0x147c
movq %rax, %rdi
movl %ebx, %esi
movl %r14d, %edx
movl %r15d, %ecx
movl %r12d, %r8d
callq 0x10b0
movsd -0x28(%rbp), %xmm0
addsd 0xdb1(%rip), %xmm0      # 0x30a8
movsd 0xdb1(%rip), %xmm1      # 0x30b0
ucomisd %xmm0, %xmm1
movl %r15d, %ebx
movl %r12d, %r14d
ja 0x2291
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movb (%rsi), %al
testb %al, %al
je 0x36c8
leaq 0x18(%rbx), %r15
movl $0x1, %r12d
movq 0x48(%rbx), %rcx
movq 0x58(%rbx), %rdx
decq %rdx
cmpq %rdx, %rcx
je 0x36af
movb %al, (%rcx)
incq 0x48(%rbx)
jmp 0x36b7
movq %r15, %rdi
callq 0x388c
movq (%r14), %rsi
movb (%rsi,%r12), %al
addq %r12, %rsi
incq %r12
testb %al, %al
jne 0x3697
movq (%rbx), %rdi
cmpq %rdi, 0x8(%rbx)
je 0x3714
leaq 0x68(%rbx), %r15
xorl %r12d, %r12d
movabsq $0x6db6db6db6db6db7, %r13 # imm = 0x6DB6DB6DB6DB6DB7
xorl %r14d, %r14d
addq %r12, %rdi
movq %r15, %rsi
callq 0x2040
testl %eax, %eax
je 0x3717
incq %r14
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
subq %rdi, %rax
sarq $0x3, %rax
imulq %r13, %rax
addq $0x38, %r12
cmpq %r14, %rax
ja 0x36e5
jmp 0x3717
xorl %r14d, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x29d0
testl %eax, %eax
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %esi, %eax
orl %edi, %eax
je 0x5673
movl %esi, %ecx
xorl $0x1, %ecx
xorl %eax, %eax
movl %edi, %edx
orl %ecx, %edx
je 0x5678
xorl $0x1, %edi
movl $0x5, %eax
orl %edi, %esi
je 0x5678
xorl %eax, %eax
orl %ecx, %edi
sete %al
jmp 0x5678
movl $0x3, %eax
popq %rbp
retq