LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/tobias93[P]piano/rtaudio/tests/playsaw.cpp
// Function: saw(void*, void*, unsigned int, double, unsigned int, void*)
int saw( void *outputBuffer, void * /*inputBuffer*/, unsigned int nBufferFrames,
         double /*streamTime*/, RtAudioStreamStatus status, void *data )
{
  unsigned int i, j;
  extern unsigned int channels;
  MY_TYPE *buffer = (MY_TYPE *) outputBuffer;
  double *lastValues = (double *) data;

  if ( status )
    std::cout << "Stream underflow detected!" << std::endl;

  double increment;
  for ( j=0; j<channels; j++ ) {
    increment = BASE_RATE * (j+1+(j*0.1));
    for ( i=0; i<nBufferFrames; i++ ) {
      *buffer++ = (MY_TYPE) (lastValues[j] * SCALE * 0.5);
      lastValues[j] += increment;
      if ( lastValues[j] >= 1.0 ) lastValues[j] -= 2.0;
    }
  }

  frameCounter += nBufferFrames;
  if ( checkCount && ( frameCounter >= nFrames ) ) return callbackReturnValue;
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl %edx, %ebx
movq %rdi, %r15
testl %ecx, %ecx
je 0x4784
movq 0x7880(%rip), %r12      # 0xbfc8
leaq 0x4a3c(%rip), %rsi      # 0x918b
movl $0x1a, %edx
movq %r12, %rdi
callq 0x4210
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x41d0
movsbl %al, %esi
movq %r12, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4150
movl 0x7ab2(%rip), %eax      # 0xc23c
testq %rax, %rax
je 0x484b
xorl %ecx, %ecx
movsd 0x486b(%rip), %xmm0     # 0x9008
movsd 0x486b(%rip), %xmm1     # 0x9010
movsd 0x486b(%rip), %xmm2     # 0x9018
movsd 0x486b(%rip), %xmm3     # 0x9020
movsd 0x486b(%rip), %xmm4     # 0x9028
movsd 0x486b(%rip), %xmm5     # 0x9030
movq %rcx, %rdx
incq %rcx
movl %ecx, %esi
xorps %xmm7, %xmm7
cvtsi2sd %rsi, %xmm7
movl %edx, %esi
xorps %xmm6, %xmm6
cvtsi2sd %rsi, %xmm6
mulsd %xmm0, %xmm6
addsd %xmm7, %xmm6
mulsd %xmm1, %xmm6
testl %ebx, %ebx
je 0x4842
movsd (%r14,%rdx,8), %xmm7
movl %ebx, %esi
movapd %xmm6, %xmm8
addsd %xmm7, %xmm8
mulsd %xmm2, %xmm7
mulsd %xmm3, %xmm7
cvttsd2si %xmm7, %edi
movw %di, (%r15)
addq $0x2, %r15
movapd %xmm8, %xmm9
addsd %xmm4, %xmm9
movapd %xmm5, %xmm7
cmpnlesd %xmm8, %xmm7
andpd %xmm7, %xmm8
andnpd %xmm9, %xmm7
orpd %xmm8, %xmm7
decl %esi
jne 0x47f7
movsd %xmm7, (%r14,%rdx,8)
cmpq %rax, %rcx
jne 0x47c5
addl 0x7a1f(%rip), %ebx      # 0xc270
movl %ebx, 0x7a19(%rip)      # 0xc270
cmpl 0x7a1b(%rip), %ebx      # 0xc278
setae %al
andb 0x7a0e(%rip), %al       # 0xc274
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/JacobLCarter[P]2D-Portal/game.cpp
// Function: Game::Game()
Game::Game()
{
    turnCounter = 20;
    setGameOver(false);
    tempSpaceType = ' ';
    map = new World_Map;
    testSubject = new Player;
   
    //sets the starting space to 0,0
    setPlayerSpace();
    //prints the player's character on the board
    playerSpace->setSpaceTypeIdentifier('*');
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x14, (%rdi)
movw $0x2000, 0x4(%rdi)      # imm = 0x2000
movl $0x28, %edi
callq 0x2150
movq %rax, %r14
movq %rax, %rdi
callq 0x4874
movq %r14, 0x18(%rbx)
movl $0x48, %edi
callq 0x2150
movq %rax, %r14
movq %rax, %rdi
callq 0x418c
movq %r14, 0x8(%rbx)
movq %rbx, %rdi
callq 0x25a6
movq 0x10(%rbx), %rdi
movl $0x2a, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3b18
movq %rax, %rbx
movl $0x48, %esi
jmp 0x2590
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/JacobLCarter[P]2D-Portal/game.cpp
// Function: Game::~Game()
Game::~Game()
{
    delete testSubject;
    testSubject = NULL;

    delete map;
    map = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x2609
movq %r14, %rdi
callq 0x42d4
movl $0x48, %esi
movq %r14, %rdi
callq 0x2160
movq $0x0, 0x8(%rbx)
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x262f
movq %r14, %rdi
callq 0x4c2e
movl $0x28, %esi
movq %r14, %rdi
callq 0x2160
movq $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/JacobLCarter[P]2D-Portal/game.cpp
// Function: Game::gameIntroduction[abi:cxx11]()
std::string Game::gameIntroduction()
{
    std::string introText;

    introText = "\nHello ";
    introText += testSubject->getName();
    introText += ".\n\n";
    introText += "My name is GLaDOS. I am your best friend and overlord.\n\n";
    introText += "I am glad to see that you are finally awake.\n";
    introText += "I have been waiting so long for you to enjoy the new ";
    introText += "Test Chamber that I have set up for you.\n\n"; 
    introText += "You have done well with the other tests, but this chamber ";
    introText += "will certainly kill you.\n\n";
    introText += "Haha. Just kidding. You will only be permanently disfigured.\n\n";
    introText += "You have 20 moves to escape the chamber. \n\n";
    introText += "If you require assistance, I will grudingly give it if you ";
    introText += "if you press 'h' and hit enter.\n\n";
    introText += "Now, press Enter to step outside and begin the test.\n\n";

    return introText;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x49a3(%rip), %rcx      # 0x7064
movl $0x7, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x21f0
movq 0x8(%r14), %rsi
movq %rsp, %rdi
callq 0x4316
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x2090
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2708
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2160
leaq 0x4ab6(%rip), %rsi      # 0x71c5
movq %rbx, %rdi
callq 0x2270
leaq 0x494e(%rip), %rsi      # 0x706c
movq %rbx, %rdi
callq 0x2270
leaq 0x4978(%rip), %rsi      # 0x70a5
movq %rbx, %rdi
callq 0x2270
leaq 0x4997(%rip), %rsi      # 0x70d3
movq %rbx, %rdi
callq 0x2270
leaq 0x49be(%rip), %rsi      # 0x7109
movq %rbx, %rdi
callq 0x2270
leaq 0x49da(%rip), %rsi      # 0x7134
movq %rbx, %rdi
callq 0x2270
leaq 0x4a06(%rip), %rsi      # 0x716f
movq %rbx, %rdi
callq 0x2270
leaq 0x4a12(%rip), %rsi      # 0x718a
movq %rbx, %rdi
callq 0x2270
leaq 0x4a42(%rip), %rsi      # 0x71c9
movq %rbx, %rdi
callq 0x2270
leaq 0x4a5f(%rip), %rsi      # 0x71f5
movq %rbx, %rdi
callq 0x2270
leaq 0x4a8c(%rip), %rsi      # 0x7231
movq %rbx, %rdi
callq 0x2270
leaq 0x4a9f(%rip), %rsi      # 0x7253
movq %rbx, %rdi
callq 0x2270
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27ee
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x27ee
jmp 0x27eb
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x2801
movq (%r15), %rsi
incq %rsi
callq 0x2160
movq %r14, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/JacobLCarter[P]2D-Portal/game.cpp
// Function: Game::displayHelpMenu[abi:cxx11]()
std::string Game::displayHelpMenu()
{
    std::string helpMenuText;

    helpMenuText = "\nMOVEMENT               ACTIONS\n";
    helpMenuText += "--------               -------\n";
    helpMenuText += "Move up = w            Make Portal = e\n";
    helpMenuText += "Move down = s          View Backpack = b\n";
    helpMenuText += "Move left = a          View Map Legend= m\n";
    helpMenuText += "Move right = d         View Remaining Turns = t\n";
    helpMenuText += "                       View Controls = h\n"; 
    helpMenuText += "                       Exit Game = x\n\n";

    return helpMenuText;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x5201(%rip), %rcx      # 0x8201
movl $0x20, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x21f0
leaq 0x520c(%rip), %rsi      # 0x8222
movq %rbx, %rdi
callq 0x2270
leaq 0x521d(%rip), %rsi      # 0x8242
movq %rbx, %rdi
callq 0x2270
leaq 0x5236(%rip), %rsi      # 0x826a
movq %rbx, %rdi
callq 0x2270
leaq 0x5251(%rip), %rsi      # 0x8294
movq %rbx, %rdi
callq 0x2270
leaq 0x526d(%rip), %rsi      # 0x82bf
movq %rbx, %rdi
callq 0x2270
leaq 0x528f(%rip), %rsi      # 0x82f0
movq %rbx, %rdi
callq 0x2270
leaq 0x52aa(%rip), %rsi      # 0x831a
movq %rbx, %rdi
callq 0x2270
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3097
movq (%r15), %rsi
incq %rsi
callq 0x2160
movq %r14, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/JacobLCarter[P]2D-Portal/game.cpp
// Function: Game::makeMove(char)
void Game::makeMove(char userDirectionInput)
{
    //integrity check to ensure the player does not move out of bounds or on
    //top of an obstacle
    if (isOutOfBounds(userDirectionInput) || isObstacle(userDirectionInput))
    {
        std::cout << "Seriously? You clearly can't go that way. Try again." << std::endl;
    }
    else
    {
        //switch to change the player's coordinates based on chosen direction
        switch (userDirectionInput)
        {
            case 'w': testSubject->decrementCurrentX();
                      break;
            case 's': testSubject->incrementCurrentX();
                      break;
            case 'a': testSubject->decrementCurrentY();
                      break;
            case 'd': testSubject->incrementCurrentY();
                      break;
        }

        //set the player space based on new coordinates
        setPlayerSpace();
       
        //check for a special space type interaction
        playerSpace->spaceTypeSpecialInteraction(testSubject, map->getItem(3), map->getItem(2));
      
        //print the player's character on the map
        showPosition(userDirectionInput);

        //show the map
        map->showMap();
       
        //remove one turn from the total allowed
        turnCounter--;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0x31b6
testb %al, %al
jne 0x30c8
movsbl %bpl, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x323c
testb %al, %al
je 0x3112
movq 0x9f01(%rip), %rbx      # 0xcfd0
leaq 0x526b(%rip), %rsi      # 0x8341
movl $0x34, %edx
movq %rbx, %rdi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
cmpl $0x72, %ebp
jg 0x312c
cmpl $0x61, %ebp
je 0x3141
cmpl $0x64, %ebp
jne 0x3155
movq 0x8(%rbx), %rdi
callq 0x4346
jmp 0x3155
cmpl $0x73, %ebp
je 0x314c
cmpl $0x77, %ebp
jne 0x3155
movq 0x8(%rbx), %rdi
callq 0x434a
jmp 0x3155
movq 0x8(%rbx), %rdi
callq 0x434e
jmp 0x3155
movq 0x8(%rbx), %rdi
callq 0x4342
movq %rbx, %rdi
callq 0x25a6
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %r15
movq 0x18(%rbx), %rdi
movl $0x3, %esi
callq 0x4d10
movq %rax, %r12
movq 0x18(%rbx), %rdi
movl $0x2, %esi
callq 0x4d10
movq (%r15), %r8
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq *0x10(%r8)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x330c
movq 0x18(%rbx), %rdi
callq 0x57aa
decl (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/JacobLCarter[P]2D-Portal/game.cpp
// Function: Game::isOutOfBounds(char)
bool Game::isOutOfBounds(char intendedInput)
{
    //executes if the player would move out of bounds upwards
    if (testSubject->getCurrentX() == 0 && intendedInput == 'w')
    {
        return true; 
    }
    
    //executes if the player would move out of bounds downwards
    if (testSubject->getCurrentX() == map->getRows() - 1 && intendedInput == 's')
    {
        return true; 
    }
    
    //executes if the player would move out of bounds to the left
    if (testSubject->getCurrentY() == 0 && intendedInput == 'a')
    {
        return true; 
    }
    
    //executes if the player would move out of bounds to the right
    if (testSubject->getCurrentY() == map->getColumns() - 1 && intendedInput == 'd')
    {
        return true; 
    }

    //if the player chooses not to move, do nothing
    if (intendedInput == 'n')
    {
        return false;
    }

    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x433a
movb $0x1, %bpl
cmpb $0x77, %bl
jne 0x31d7
testl %eax, %eax
je 0x322f
movq 0x8(%r14), %rdi
callq 0x433a
movl %eax, %r15d
movq 0x18(%r14), %rdi
callq 0x4d02
cmpb $0x73, %bl
jne 0x31f8
decl %eax
cmpl %eax, %r15d
je 0x322f
movq 0x8(%r14), %rdi
callq 0x433e
cmpb $0x61, %bl
jne 0x320a
testl %eax, %eax
je 0x322f
movq 0x8(%r14), %rdi
callq 0x433e
movl %eax, %ebp
movq 0x18(%r14), %rdi
callq 0x4d06
decl %eax
cmpl %eax, %ebp
sete %al
cmpb $0x64, %bl
sete %bpl
andb %al, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/JacobLCarter[P]2D-Portal/game.cpp
// Function: Game::isObstacle(char)
bool Game::isObstacle(char intendedInput)
{
    switch (intendedInput)
    {
        //case if the player would move onto an obstacle upwards
        case 'w': if (playerSpace->getSpaceUp()->getSpaceTypeIdentifier() == 'X'
                      || playerSpace->getSpaceUp()->getSpaceTypeIdentifier() == '[')
                  {
                      return true;
                  }
                  break;
        //case if the player would move onto an obstacle downwards
        case 's': if (playerSpace->getSpaceBottom()->getSpaceTypeIdentifier() == 'X'
                      || playerSpace->getSpaceBottom()->getSpaceTypeIdentifier() == '[')
                  {
                      return true;
                  }
                  break;
        //case if the player would move onto an obstacle to the left
        case 'a': if (playerSpace->getSpaceLeft()->getSpaceTypeIdentifier() == 'X'
                      || playerSpace->getSpaceLeft()->getSpaceTypeIdentifier() == '[')
                  {
                      return true;
                  }
                  break;
        //case if the player would move onto an obstacle to the right
        case 'd': if (playerSpace->getSpaceRight()->getSpaceTypeIdentifier() == 'X'
                      || playerSpace->getSpaceRight()->getSpaceTypeIdentifier() == '[')
                  {
                      return true;
                  }
                  break;
        //case if the player chooses not to move 
        case 'x': return false;
    }

    return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpl $0x72, %esi
jle 0x3285
cmpl $0x73, %esi
je 0x32b1
cmpl $0x78, %esi
je 0x32ff
cmpl $0x77, %esi
jne 0x32ff
movq 0x10(%r14), %rdi
callq 0x3ada
movq %rax, %rdi
callq 0x3ad2
movb $0x1, %bl
cmpb $0x58, %al
je 0x3301
movq 0x10(%r14), %rdi
callq 0x3ada
jmp 0x32f3
cmpl $0x61, %esi
je 0x32d3
cmpl $0x64, %esi
jne 0x32ff
movq 0x10(%r14), %rdi
callq 0x3aec
movq %rax, %rdi
callq 0x3ad2
movb $0x1, %bl
cmpb $0x58, %al
je 0x3301
movq 0x10(%r14), %rdi
callq 0x3aec
jmp 0x32f3
movq 0x10(%r14), %rdi
callq 0x3ae0
movq %rax, %rdi
callq 0x3ad2
movb $0x1, %bl
cmpb $0x58, %al
je 0x3301
movq 0x10(%r14), %rdi
callq 0x3ae0
jmp 0x32f3
movq 0x10(%r14), %rdi
callq 0x3ae6
movq %rax, %rdi
callq 0x3ad2
movb $0x1, %bl
cmpb $0x58, %al
je 0x3301
movq 0x10(%r14), %rdi
callq 0x3ae6
movq %rax, %rdi
callq 0x3ad2
cmpb $0x5b, %al
je 0x3301
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/JacobLCarter[P]2D-Portal/game.cpp
// Function: Game::showPosition(char)
void Game::showPosition(char userDirectionInput)
{
    //replaces the current space identifier based on the direction the player
    //is going to move
    switch (userDirectionInput)
    {
        case 'w': getPlayerSpace()->getSpaceBottom()->setSpaceTypeIdentifier(tempSpaceType);
                  break;
        case 's': getPlayerSpace()->getSpaceUp()->setSpaceTypeIdentifier(tempSpaceType);
                  break;
        case 'a': getPlayerSpace()->getSpaceRight()->setSpaceTypeIdentifier(tempSpaceType);
                  break;
        case 'd': getPlayerSpace()->getSpaceLeft()->setSpaceTypeIdentifier(tempSpaceType);
                  break;
    }
   
    //holds the space type identifier while the player identifier is placed
    tempSpaceType = getPlayerSpace()->getSpaceTypeIdentifier();
   
    //add the player's identifier to the map
    getPlayerSpace()->setSpaceTypeIdentifier('*');
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x72, %esi
jg 0x3331
cmpl $0x61, %esi
je 0x334d
cmpl $0x64, %esi
jne 0x337b
movq %rbx, %rdi
callq 0x264a
movq %rax, %rdi
callq 0x3ae6
jmp 0x336f
cmpl $0x73, %esi
je 0x335f
cmpl $0x77, %esi
jne 0x337b
movq %rbx, %rdi
callq 0x264a
movq %rax, %rdi
callq 0x3ae0
jmp 0x336f
movq %rbx, %rdi
callq 0x264a
movq %rax, %rdi
callq 0x3aec
jmp 0x336f
movq %rbx, %rdi
callq 0x264a
movq %rax, %rdi
callq 0x3ada
movsbl 0x5(%rbx), %esi
movq %rax, %rdi
callq 0x3b18
movq %rbx, %rdi
callq 0x264a
movq %rax, %rdi
callq 0x3ad2
movb %al, 0x5(%rbx)
movq %rbx, %rdi
callq 0x264a
movq %rax, %rdi
movl $0x2a, %esi
popq %rbx
jmp 0x3b18
// File: /workspace/github_cpp_makefile_star2_O1/JacobLCarter[P]2D-Portal/game.cpp
// Function: Game::executeUserInput(char)
void Game::executeUserInput(char userInput)
{
    //switch based on the user's chosen control input
    switch(userInput)
    {
        //move up
        case 'w': makeMove(userInput);
                  break;
        //move down 
        case 's': makeMove(userInput);
                  break;
        //move left 
        case 'a': makeMove(userInput);
                  break;
        //move right 
        case 'd': makeMove(userInput);
                  break;
        //move through Portal 
        case 'e': moveThroughPortal();
                  break;
        //show contents of player's backpack
        case 'b': testSubject->displayBackpackContents();
                  break;
        //show map legend 
        case 'm': std::cout << map->getMapLegend() << std::endl;
                  break;
        //show number of turns left 
        case 't': std::cout << "You have " << turnCounter 
                            << " turns before immolation." << std::endl;
                  break;
        //show help menu 
        case 'h': std::cout << displayHelpMenu();
                  break;
        //quit game 
        case 'x': endGame(EXITED);
                  break;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leal -0x61(%rsi), %eax
cmpl $0x17, %eax
ja 0x3703
movq %rdi, %rbx
leaq 0x39c7(%rip), %rcx      # 0x7004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsbl %sil, %esi
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x30a0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2fde
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x995c(%rip), %rdi      # 0xcfd0
callq 0x2180
jmp 0x36e8
movq 0x8(%rbx), %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x43be
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x33a4
movq 0x18(%rbx), %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x4d32
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x9917(%rip), %rdi      # 0xcfd0
callq 0x2180
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20e0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3703
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq 0x98be(%rip), %r14      # 0xcfd0
leaq 0x4d24(%rip), %rsi      # 0x843d
movl $0x9, %edx
movq %r14, %rdi
callq 0x2180
movl (%rbx), %esi
movq %r14, %rdi
callq 0x2230
movq %rax, %rbx
leaq 0x4d0d(%rip), %rsi      # 0x8447
movl $0x19, %edx
movq %rax, %rdi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x20e0
movq %rbx, %rdi
movl $0x3, %esi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x37b2
jmp 0x378b
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x37a9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/JacobLCarter[P]2D-Portal/game.cpp
// Function: Game::checkForItem()
void Game::checkForItem()
{
    if (getPlayerSpace()->getItemInSpace() != NULL)
    {
        std::cout << "Oh great. You found the " << playerSpace->
            getItemInSpace()->getItemName() << "..." << std::endl << std::endl;

        //add the item to the player's backpack
        testSubject->addItemToBackpack(playerSpace->
                getItemInSpace());
       
        //remove the item from the space
        playerSpace->removeItemFromSpace();
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x264a
movq %rax, %rdi
callq 0x3b12
testq %rax, %rax
je 0x392d
movq 0x9781(%rip), %r14      # 0xcfd0
leaq 0x4c0b(%rip), %rsi      # 0x8461
movl $0x18, %edx
movq %r14, %rdi
callq 0x2180
movq 0x10(%rbx), %rdi
callq 0x3b12
movq %rsp, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x40b2
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x2180
movq %rax, %r14
leaq 0x4df3(%rip), %rsi      # 0x8686
movl $0x3, %edx
movq %rax, %rdi
callq 0x2180
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20e0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20e0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x390c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2160
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %rdi
callq 0x3b12
movq %r14, %rdi
movq %rax, %rsi
callq 0x4352
movq 0x10(%rbx), %rdi
callq 0x3b3c
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3955
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/JacobLCarter[P]2D-Portal/game.cpp
// Function: Game::checkForEnding()
void Game::checkForEnding()
{
    
    //executes if the player has escaped the chamber
    if (testSubject->getCurrentX() == 1 && testSubject->getCurrentY() == 4)
    {
        endGame(VICTORY);
    }

    //executes if the player dies
    if (testSubject->getHitPoints() == 0)
    {
        endGame(MELTED);
    }
     
    //executes if the player runs out of time
    if (turnCounter == 0)
    {
        endGame(BURNED);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x433a
cmpl $0x1, %eax
jne 0x3988
movq 0x8(%rbx), %rdi
callq 0x433e
cmpl $0x4, %eax
jne 0x3988
movq %rbx, %rdi
xorl %esi, %esi
callq 0x37b2
movq 0x8(%rbx), %rdi
callq 0x4312
testl %eax, %eax
jne 0x39a2
movq %rbx, %rdi
movl $0x2, %esi
callq 0x37b2
cmpl $0x0, (%rbx)
je 0x39a9
popq %rbx
retq
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
jmp 0x37b2
nop
// File: /workspace/github_cpp_makefile_star2_O1/JacobLCarter[P]2D-Portal/game.cpp
// Function: Game::playRound()
void Game::playRound()
{
    executeUserInput(getUserAction());
    checkForCake();
    checkForItem();
    checkDoor();
    checkForEnding();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x5e24
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3620
movq %rbx, %rdi
callq 0x39e2
movq %rbx, %rdi
callq 0x3826
movq %rbx, %rdi
callq 0x39b8
movq %rbx, %rdi
popq %rbx
jmp 0x395e
nop
// File: /workspace/github_cpp_makefile_star2_O1/JacobLCarter[P]2D-Portal/space.cpp
// Function: Space::Space(char)
Space::Space(char typeIdentifier)
{
    up = bottom = left = right = NULL;
    spaceTypeIdentifier = typeIdentifier;
    itemInSpace = NULL;
    isPressed = false;
}

// Assembly:
leaq 0x9135(%rip), %rax      # 0xcbd0
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movb %sil, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x9(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/JacobLCarter[P]2D-Portal/button.cpp
// Function: Button::spaceTypeSpecialInteraction(Player*, Item*, Item*)
void Button::spaceTypeSpecialInteraction(Player *playerInput, Item *cc, Item *pg)
{
    //if the player has the Companion Cube, press the button down
    if (playerInput->checkBackpackForItem(cc))
    {
        isPressed = true;
        //remove the Companion Cube from the player's backpack
        playerInput->removeItemFromBackpack(cc);
        
        std::cout << "What?! How did you just open that door?!" << std::endl;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x4626
testb %al, %al
je 0x3d10
movb $0x1, 0x9(%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x437c
movq 0x9300(%rip), %rbx      # 0xcfd0
leaq 0x4858(%rip), %rsi      # 0x852f
movl $0x28, %edx
movq %rbx, %rdi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x20e0
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/JacobLCarter[P]2D-Portal/player.cpp
// Function: Player::Player()
Player::Player()
{
    setHitPoints(100);
    std::cout << "It's waking up...what was it's name again?" << std::endl;
    std::cout << "Enter your name: ";
    setName(getString(false));
    setCurrentX(0);
    setCurrentY(0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x18(%rdi), %r12
movq %r12, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movq %rax, 0x40(%rdi)
movl $0x64, (%rdi)
movq 0x8e08(%rip), %r15      # 0xcfd0
leaq 0x44fe(%rip), %rsi      # 0x86cd
movl $0x2a, %edx
movq %r15, %rdi
callq 0x2180
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq 0x8dd6(%rip), %rdi      # 0xcfd0
callq 0x2040
movq %rax, %rdi
callq 0x20e0
movq 0x8dc2(%rip), %rdi      # 0xcfd0
leaq 0x44e3(%rip), %rsi      # 0x86f8
movl $0x11, %edx
callq 0x2180
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x5a20
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x20c0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4253
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movq $0x0, 0x28(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x428a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x428a
movq %rax, %r15
leaq 0x30(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x42a2
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x2160
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x42b6
movq (%r12), %rsi
incq %rsi
callq 0x2160
movq %r15, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/JacobLCarter[P]2D-Portal/worldMap.cpp
// Function: World_Map::makeNewMap()
void World_Map::makeNewMap()
{
     
    testChamberMap = new Space**[rows];
    for (int i = 0; i < rows; i++)
    {
        testChamberMap[i] = new Space*[columns];

        for (int j = 0; j < columns; j++)
        {
            testChamberMap[i][j] = new Floor;
        }
    }
   
    //add all special-type spaces
    initializeSpecialSpaces();
    //link all rooms together
    linkRooms();
    //add all items the map
    initializeItems();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movslq (%rdi), %rax
leaq (,%rax,8), %rdi
testq %rax, %rax
movq $-0x1, %r15
cmovsq %r15, %rdi
callq 0x2030
movq %rax, 0x8(%rbx)
cmpl $0x0, (%rbx)
jle 0x4bf5
xorl %r12d, %r12d
movslq 0x4(%rbx), %rax
leaq (,%rax,8), %rdi
testq %rax, %rax
cmovsq %r15, %rdi
callq 0x2030
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
cmpl $0x0, 0x4(%rbx)
jle 0x4bea
xorl %r13d, %r13d
movl $0x38, %edi
callq 0x2150
movq %rax, %r14
movq %rax, %rdi
callq 0x3d18
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rax
movq %r14, (%rax,%r13,8)
incq %r13
movslq 0x4(%rbx), %rax
cmpq %rax, %r13
jl 0x4bbd
incq %r12
movslq (%rbx), %rax
cmpq %rax, %r12
jl 0x4b94
movq %rbx, %rdi
callq 0x52fc
movq %rbx, %rdi
callq 0x53dc
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x54a4
movq %rax, %rbx
movl $0x38, %esi
movq %r14, %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/JacobLCarter[P]2D-Portal/worldMap.cpp
// Function: World_Map::~World_Map()
World_Map::~World_Map()
{
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < columns; j++)
        {
            delete testChamberMap[i][j];
        }
        delete [] testChamberMap[i];
    }
    delete [] testChamberMap;
    testChamberMap = NULL;

    delete cake;
    delete portalGun;
    delete companionCube;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x4c87
xorl %r14d, %r14d
cmpl $0x0, 0x4(%rbx)
jle 0x4c6a
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x4c5e
movq (%rdi), %rax
callq *0x8(%rax)
incq %r15
movslq 0x4(%rbx), %rax
cmpq %rax, %r15
jl 0x4c47
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x4c7c
callq 0x21c0
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x4c3e
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x4c95
callq 0x21c0
movq $0x0, 0x8(%rbx)
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x4cbb
movq %r14, %rdi
callq 0x407c
movl $0x48, %esi
movq %r14, %rdi
callq 0x2160
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x4cd9
movq %r14, %rdi
callq 0x407c
movl $0x48, %esi
movq %r14, %rdi
callq 0x2160
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
je 0x4cfc
movq %rbx, %rdi
callq 0x407c
movl $0x48, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2160
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/JacobLCarter[P]2D-Portal/worldMap.cpp
// Function: World_Map::getItem(int)
Item* World_Map::getItem(int itemToGet)
{
    //switch based on item specified
    switch (itemToGet)
    {
        case 1: return cake;
                break;
        case 2: return portalGun;
                break;
        case 3: return companionCube;
                break;
    }

    return NULL;
}

// Assembly:
cmpl $0x3, %esi
je 0x4d29
cmpl $0x2, %esi
je 0x4d24
cmpl $0x1, %esi
jne 0x4d2e
movq 0x10(%rdi), %rax
retq
movq 0x18(%rdi), %rax
retq
movq 0x20(%rdi), %rax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/JacobLCarter[P]2D-Portal/worldMap.cpp
// Function: World_Map::initializeSpecialSpaces()
void World_Map::initializeSpecialSpaces()
{
    addButton(1, 1);
    addDoor(1, 3);
    addChamberlock(1, 4);
    addToxic_Waste(4, 3);
    addToxic_Waste(3, 4);
    addToxic_Waste(1, 2);
    addWall(0, 1);
    addWall(0, 3);
    addWall(0, 4);
    addWall(2, 0);
    addWall(2, 3);
    addWall(2, 4);
    addWall(3, 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
movl $0x1, %edx
callq 0x54e6
movq %rbx, %rdi
movl $0x1, %esi
movl $0x3, %edx
callq 0x5554
movq %rbx, %rdi
movl $0x1, %esi
movl $0x4, %edx
callq 0x55c2
movq %rbx, %rdi
movl $0x4, %esi
movl $0x3, %edx
callq 0x5630
movq %rbx, %rdi
movl $0x3, %esi
movl $0x4, %edx
callq 0x5630
movq %rbx, %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x5630
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x569e
movq %rbx, %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x569e
movq %rbx, %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x569e
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x569e
movq %rbx, %rdi
movl $0x2, %esi
movl $0x3, %edx
callq 0x569e
movq %rbx, %rdi
movl $0x2, %esi
movl $0x4, %edx
callq 0x569e
movq %rbx, %rdi
movl $0x3, %esi
movl $0x1, %edx
popq %rbx
jmp 0x569e
// File: /workspace/github_cpp_makefile_star2_O1/JacobLCarter[P]2D-Portal/worldMap.cpp
// Function: World_Map::linkRooms()
void World_Map::linkRooms()
{
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < columns; j++)
        {
            //if not an edge, link to room above
            if (i > 0)
            {
                testChamberMap[i][j]->setSpaceUp(testChamberMap[i - 1][j]);
            }
            //if not an edge, link to room left
            if (j > 0)
            {
                testChamberMap[i][j]->setSpaceLeft(testChamberMap[i][j - 1]);
            }
            //if not an edge, link to room below
            if (i < rows - 1)
            {
                testChamberMap[i][j]->setSpaceBottom(testChamberMap[i + 1][j]);
            }
            //if not an edge, link to room right
            if (j < columns - 1)
            {
                testChamberMap[i][j]->setSpaceRight(testChamberMap[i][j + 1]);
            }
        }
    }
}

// Assembly:
cmpl $0x0, (%rdi)
jle 0x54a2
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
cmpl $0x0, 0x4(%rbx)
jle 0x548e
xorl %r15d, %r15d
testq %r14, %r14
je 0x541c
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r14,8), %rcx
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rdi
movq (%rcx,%r15,8), %rsi
callq 0x3b1e
testq %r15, %r15
je 0x5437
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq -0x8(%rax,%r15,8), %rsi
movq (%rax,%r15,8), %rdi
callq 0x3b2a
movslq (%rbx), %rax
decq %rax
cmpq %rax, %r14
jge 0x545c
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rcx
movq 0x8(%rax,%r14,8), %rax
movq (%rcx,%r15,8), %rdi
movq (%rax,%r15,8), %rsi
callq 0x3b24
movslq 0x4(%rbx), %rax
decq %rax
cmpq %rax, %r15
jge 0x547e
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rdi
movq 0x8(%rax,%r15,8), %rsi
callq 0x3b30
incq %r15
movslq 0x4(%rbx), %rax
cmpq %rax, %r15
jl 0x53fd
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x53f0
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/JacobLCarter[P]2D-Portal/utils.cpp
// Function: getString[abi:cxx11](bool)
std::string getString(bool prompt)
{
    std::string input;
  
    if (prompt == true)
    {
        std::cout << "Enter a word or phrase: ";
    }

    //get the user's input
    std::getline(std::cin, input);

    //remprompt if input is empty std::string
    while (input == "")
    {
        std::cout << "Empty string -- enter at least one character: "
            << std::endl;
        std::getline(std::cin, input);
    }
    
    return input;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rbp
movq %rbp, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
testl %esi, %esi
je 0x5a5d
movq 0x7584(%rip), %rdi      # 0xcfd0
leaq 0x2e6b(%rip), %rsi      # 0x88be
movl $0x18, %edx
callq 0x2180
movq 0x757c(%rip), %rdi      # 0xcfe0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %edx
movq 0x7561(%rip), %r14      # 0xcfe0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2260
leaq 0x1b42(%rip), %r15      # 0x75d3
movq 0x7538(%rip), %r12      # 0xcfd0
leaq 0x2e38(%rip), %r13      # 0x88d7
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2080
testl %eax, %eax
jne 0x5b0a
movl $0x2e, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x2180
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20e0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2260
jmp 0x5a9f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5b1e
movq %rax, %r14
movq (%rbx), %rdi
cmpq %rbp, %rdi
je 0x5b35
movq (%rbp), %rsi
incq %rsi
callq 0x2160
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/JacobLCarter[P]2D-Portal/utils.cpp
// Function: printArray(int*, int)
void printArray(int *array, int s)
{
    int i = 0;
    
    while (i < s)
    {
        std::cout << array[i] << " ";
        i++;
    }
    std::cout << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testl %esi, %esi
jle 0x6600
movq %rdi, %rbx
movl %esi, %r12d
xorl %r13d, %r13d
movq 0x69fb(%rip), %r14      # 0xcfd0
leaq 0x1457(%rip), %r15      # 0x7a33
movl (%rbx,%r13,4), %esi
movq %r14, %rdi
callq 0x2230
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2180
incq %r13
cmpq %r13, %r12
jne 0x65dc
movq 0x69c9(%rip), %rbx      # 0xcfd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x20e0
// File: /workspace/github_cpp_makefile_star2_O1/JacobLCarter[P]2D-Portal/utils.cpp
// Function: replay()
char replay()
{
    char choice;

    do
    {
        std::cout << std::endl;
        std::cout << "Would you like to play again? (y/n)" << std::endl;
        choice = getMenuChar();
    }
    while (choice != 'y' && choice !='n');

    return choice;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x6701(%rip), %rbx      # 0xcfd0
leaq 0x23f0(%rip), %r14      # 0x8cc6
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20e0
movl $0x23, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20e0
callq 0x6214
cmpb $0x79, %al
je 0x6945
movzbl %al, %ecx
cmpl $0x6e, %ecx
jne 0x68d6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/JacobLCarter[P]2D-Portal/utils.cpp
// Function: selectionYN()
char selectionYN()
{
    char choice;

    do
    {
        std::cout << std::endl;
        std::cout << "Please enter yes or no? (y/n)" << std::endl;
        choice = getMenuChar();
    }
    while (choice != 'y' && choice != 'n');

    return choice;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x6678(%rip), %rbx      # 0xcfd0
leaq 0x238b(%rip), %r14      # 0x8cea
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20e0
movl $0x1d, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20e0
callq 0x6214
cmpb $0x79, %al
je 0x69ce
movzbl %al, %ecx
cmpl $0x6e, %ecx
jne 0x695f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/JacobLCarter[P]2D-Portal/main.cpp
// Function: main
int main()
{
    //get user's choice at the main menu
    int menuChoice = mainMenu();

    //executes if the user chooses to play
    if (menuChoice == 1)
    {
        //loop repeats until the user chooses not to replay
        do
        {
            //make a new game
            Game *currentGame = new Game;
      
            //show the introduction and wait for the user to press enter to continue
            std::cout << currentGame->gameIntroduction();
            std::cin.get();

            //show the starting map
            currentGame->getMap()->showMap();

            //show the map legend
            std::cout << currentGame->getMap()->getMapLegend();

            //display the game's controls
            std::cout << currentGame->displayHelpMenu();

            //play another round while it is not true that the game is over
            while (!currentGame->getGameOver())
            {
                currentGame->playRound();
            }
           
            //free memory allocated for the game
            delete currentGame;
        }
        while (replay() != 'n');
    }
    else
    {
        std::cout << "Exiting the program" << std::endl;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
callq 0x6637
cmpl $0x1, %eax
jne 0x6b0b
leaq 0x10(%rsp), %r13
movq %rsp, %rbx
movq 0x65ce(%rip), %r14      # 0xcfd0
movq 0x65d7(%rip), %r15      # 0xcfe0
movl $0x20, %edi
callq 0x2150
movq %rax, %r12
movq %rax, %rdi
callq 0x251c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2698
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x2180
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x6a50
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2160
movq %r15, %rdi
callq 0x21a0
movq %r12, %rdi
callq 0x2684
movq %rax, %rdi
callq 0x57aa
movq %r12, %rdi
callq 0x2684
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4d32
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x2180
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x6aa2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2fde
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x2180
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x6adb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x6adb
callq 0x3a3a
movq %r12, %rdi
callq 0x2690
movq %r12, %rdi
testb %al, %al
je 0x6ad6
callq 0x25e4
movl $0x20, %esi
movq %r12, %rdi
callq 0x2160
callq 0x68c4
cmpb $0x6e, %al
jne 0x6a09
jmp 0x6b4d
movq 0x64be(%rip), %rbx      # 0xcfd0
leaq 0x21ef(%rip), %rsi      # 0x8d08
movl $0x13, %edx
movq %rbx, %rdi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20e0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x20, %esi
movq %r12, %rdi
jmp 0x6b82
jmp 0x6b6e
jmp 0x6b6e
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x6b87
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/vjeux[P]jspp/example/scope.cpp
// Function: main::$_4::operator()(Object, Object)
_(function (var $) {
	var global = "local";

	std::cout << "Inside:      $ = " << $ << std::endl;
	std::cout << "Inside: global = " << global << std::endl;

	// Inside:      $ = jQuery
	// Inside: global = local

	return undefined;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
movq %rdi, %rbx
leaq 0x1c11(%rip), %rsi      # 0xa26b
movq %rsp, %rdi
callq 0x67a4
movq 0x596f(%rip), %rdi      # 0xdfd8
leaq 0x1c01(%rip), %rsi      # 0xa271
movl $0x11, %edx
callq 0x21f0
movq (%r14), %rax
leaq 0x30(%rsp), %rsi
movq %rax, (%rsi)
movq %rsi, 0x8(%rsi)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsi)
incl (%rax)
movq 0x593e(%rip), %r14      # 0xdfd8
movq %r14, %rdi
callq 0x24fc
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq 0x5918(%rip), %rdi      # 0xdfd8
callq 0x2030
movq %rax, %rdi
callq 0x2120
leaq 0x30(%rsp), %rdi
callq 0x8838
movq 0x58fa(%rip), %rdi      # 0xdfd8
leaq 0x1b9e(%rip), %rsi      # 0xa283
movl $0x11, %edx
callq 0x21f0
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movq %rsi, 0x8(%rsi)
movq %rcx, 0x10(%rsi)
incl (%rcx)
movq 0x58c7(%rip), %r14      # 0xdfd8
movq %r14, %rdi
callq 0x24fc
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq 0x58a1(%rip), %rdi      # 0xdfd8
callq 0x2030
movq %rax, %rdi
callq 0x2120
leaq 0x18(%rsp), %rdi
callq 0x8838
movq 0x5a3b(%rip), %rax      # 0xe190
movq %rax, (%rbx)
movq %rbx, 0x8(%rbx)
movq 0x5a3d(%rip), %rax      # 0xe1a0
movq %rax, 0x10(%rbx)
incl (%rax)
movq %rsp, %rdi
callq 0x8838
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x8798
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0x8793
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x8838
movq %rsp, %rdi
callq 0x8838
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O1/cpirc[P]Monochrome/src/eval.cpp
// Function: int evaluate_mobility<(Piece)1>(Position const&)
int evaluate_mobility(const Position& pos) {
    int score = 0;
    uint64_t pieces = get_piece(pos, p, US);

    while (pieces) {
        score += popcnt(attacks<p>(lsb(pieces), get_occupancy(pos))) *
                 mobility_weights[p];

        pieces &= pieces - 1;
    }

    return score + evaluate_mobility<p + 1>(pos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x30(%rdi), %rax
andq 0x8(%rdi), %rax
je 0x43e5
xorl %ebx, %ebx
leaq 0xd24b(%rip), %rcx      # 0x115c0
movabsq $0x5555555555555555, %rdx # imm = 0x5555555555555555
movabsq $0x3333333333333333, %rsi # imm = 0x3333333333333333
movabsq $0xf0f0f0f0f0f0f0f, %r8 # imm = 0xF0F0F0F0F0F0F0F
movabsq $0x101010101010101, %r9 # imm = 0x101010101010101
bsfq %rax, %r10
movq (%rcx,%r10,8), %r10
movq %r10, %r11
shrq %r11
andq %rdx, %r11
subq %r11, %r10
movq %r10, %r11
andq %rsi, %r11
shrq $0x2, %r10
andq %rsi, %r10
addq %r11, %r10
movq %r10, %r11
shrq $0x4, %r11
addq %r10, %r11
andq %r8, %r11
imulq %r9, %r11
shrq $0x38, %r11
leal (%rbx,%r11,4), %ebx
leaq -0x1(%rax), %r10
andq %r10, %rax
jne 0x439d
jmp 0x43e7
xorl %ebx, %ebx
callq 0x43f5
addl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/cpirc[P]Monochrome/src/main.cpp
// Function: main
int main() {
    seed_rng(17594872);
    init_keys();
    init_bitboards();

    std::setbuf(stdout, NULL);
    std::setbuf(stdin, NULL);

    std::string line;
    while (true) {
        std::getline(std::cin, line);
        if (line == "uci") {
            UCI::listen();
            break;
        } else if (line == "xboard") {
            std::cout << "Protocol not supported" << std::endl;
        } else if (line == "quit") {
            break;
        } else {
            std::cout << "Unknown protocol" << std::endl;
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq $0x10c79f8, 0x24e41c(%rip) # imm = 0x10C79F8
movl $0x1, %eax
movl $0x10c79f8, %edx        # imm = 0x10C79F8
leaq 0x24e40b(%rip), %rcx    # 0x252d58
movq %rdx, %rsi
shrq $0x1e, %rsi
xorl %edx, %esi
imull $0x6c078965, %esi, %edx # imm = 0x6C078965
addl %eax, %edx
movq %rdx, (%rcx,%rax,8)
incq %rax
cmpq $0x270, %rax            # imm = 0x270
jne 0x494d
movq $0x270, 0x24f760(%rip) # imm = 0x270
callq 0x6aec
callq 0x388c
movq 0xc607(%rip), %rax      # 0x10f90
movq (%rax), %rdi
xorl %esi, %esi
callq 0x3230
movq 0xc626(%rip), %rax      # 0x10fc0
movq (%rax), %rdi
xorl %esi, %esi
callq 0x3230
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0xc61a(%rip), %rbx      # 0x10fd8
leaq -0x48(%rbp), %r14
leaq 0x7dd7(%rip), %r15      # 0xc7a0
leaq 0x7dd4(%rip), %r12      # 0xc7a4
movq 0xc5f1(%rip), %r13      # 0x10fc8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3300
movq %r14, %rdi
movq %r15, %rsi
callq 0x3070
testl %eax, %eax
je 0x4a79
movq %r14, %rdi
movq %r12, %rsi
callq 0x3070
testl %eax, %eax
je 0x4a38
movq %r14, %rdi
leaq 0x7da1(%rip), %rsi      # 0xc7c2
callq 0x3070
movl $0x10, %edx
leaq 0x7d95(%rip), %rsi      # 0xc7c7
testl %eax, %eax
jne 0x4a44
jmp 0x4a7e
movl $0x16, %edx
leaq 0x7d67(%rip), %rsi      # 0xc7ab
movq %r13, %rdi
callq 0x31e0
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %r13, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
jmp 0x49d7
callq 0xa4e7
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x4a90
callq 0x31a0
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4aa3
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x4ab8
callq 0x31a0
movq %rbx, %rdi
callq 0x32d0