LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movsd %xmm0, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movq %r8, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x8817
movq 0xf7cc(%rip), %rdi      # 0x17fc8
leaq 0xa988(%rip), %rsi      # 0x1318b
callq 0x8210
movq %rax, %rdi
movq 0xf79e(%rip), %rsi      # 0x17fb0
callq 0x8250
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl 0xfa75(%rip), %eax      # 0x1829c
jae 0x891c
movl -0x40(%rbp), %eax
movl %eax, %ecx
incl %ecx
cvtsi2sd %rcx, %xmm0
cvtsi2sd %rax, %xmm1
movsd 0xa7ca(%rip), %xmm2     # 0x13010
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0xa7b2(%rip), %xmm0     # 0x13008
mulsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x890c
movq -0x50(%rbp), %rax
movl -0x40(%rbp), %ecx
movsd (%rax,%rcx,8), %xmm0
movsd 0xa79a(%rip), %xmm1     # 0x13020
mulsd %xmm1, %xmm0
movsd 0xa796(%rip), %xmm1     # 0x13028
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movw %ax, %cx
movq -0x48(%rbp), %rax
movq %rax, %rdx
addq $0x2, %rdx
movq %rdx, -0x48(%rbp)
movw %cx, (%rax)
movsd -0x58(%rbp), %xmm0
movq -0x50(%rbp), %rax
movl -0x40(%rbp), %ecx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x50(%rbp), %rax
movl -0x40(%rbp), %ecx
movsd (%rax,%rcx,8), %xmm0
movsd 0xa73f(%rip), %xmm1     # 0x13018
ucomisd %xmm1, %xmm0
jb 0x88fc
movq -0x50(%rbp), %rax
movl -0x40(%rbp), %ecx
movsd (%rax,%rcx,8), %xmm0
movsd 0xa73d(%rip), %xmm1     # 0x13030
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
jmp 0x88fe
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x8866
jmp 0x890e
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x881e
movl -0x1c(%rbp), %eax
addl 0xf9ab(%rip), %eax      # 0x182d0
movl %eax, 0xf9a5(%rip)      # 0x182d0
testb $0x1, 0xf9a2(%rip)      # 0x182d4
je 0x894b
movl 0xf996(%rip), %eax      # 0x182d0
cmpl 0xf998(%rip), %eax      # 0x182d8
jb 0x894b
movl $0x1, -0x4(%rbp)
jmp 0x8952
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl $0x14, (%rdi)
xorl %esi, %esi
callq 0x3820
movq -0x28(%rbp), %rax
movb $0x20, 0x5(%rax)
movl $0x28, %edi
callq 0x3220
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x20(%rbp)
callq 0x80f0
jmp 0x3784
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl $0x48, %edi
callq 0x3220
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x63e0
jmp 0x37ab
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, 0x8(%rdi)
callq 0x3840
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x2a, %esi
callq 0x5640
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x28, %esi
callq 0x3230
jmp 0x380a
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x48, %esi
callq 0x3230
movq -0x10(%rbp), %rdi
callq 0x33b0
nopw %cs:(%rax,%rax)
// File: JacobLCarter[P]2D-Portal/game.cpp
// Function: Game::~Game()
Game::~Game()
{
    delete testSubject;
    testSubject = NULL;

    delete map;
    map = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x38e9
movq -0x10(%rbp), %rdi
callq 0x6580
movq -0x10(%rbp), %rdi
movl $0x48, %esi
callq 0x3230
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x391a
movq -0x20(%rbp), %rdi
callq 0x86a0
movq -0x20(%rbp), %rdi
movl $0x28, %esi
callq 0x3230
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3330
movq -0x50(%rbp), %rdi
leaq 0x86f5(%rip), %rsi      # 0xc17c
callq 0x3320
jmp 0x3a8e
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x48(%rbp), %rdi
callq 0x65d0
jmp 0x3aa1
movq -0x50(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3300
jmp 0x3ab0
leaq -0x48(%rbp), %rdi
callq 0x3140
movq -0x50(%rbp), %rdi
leaq 0x8819(%rip), %rsi      # 0xc2dd
callq 0x3200
jmp 0x3acb
movq -0x50(%rbp), %rdi
leaq 0x86ae(%rip), %rsi      # 0xc184
callq 0x3200
jmp 0x3add
movq -0x50(%rbp), %rdi
leaq 0x86d5(%rip), %rsi      # 0xc1bd
callq 0x3200
jmp 0x3aef
movq -0x50(%rbp), %rdi
leaq 0x86f1(%rip), %rsi      # 0xc1eb
callq 0x3200
jmp 0x3b01
movq -0x50(%rbp), %rdi
leaq 0x8715(%rip), %rsi      # 0xc221
callq 0x3200
jmp 0x3b13
movq -0x50(%rbp), %rdi
leaq 0x872e(%rip), %rsi      # 0xc24c
callq 0x3200
jmp 0x3b25
movq -0x50(%rbp), %rdi
leaq 0x8757(%rip), %rsi      # 0xc287
callq 0x3200
jmp 0x3b37
movq -0x50(%rbp), %rdi
leaq 0x8760(%rip), %rsi      # 0xc2a2
callq 0x3200
jmp 0x3b49
movq -0x50(%rbp), %rdi
leaq 0x878d(%rip), %rsi      # 0xc2e1
callq 0x3200
jmp 0x3b5b
movq -0x50(%rbp), %rdi
leaq 0x87a7(%rip), %rsi      # 0xc30d
callq 0x3200
jmp 0x3b6d
movq -0x50(%rbp), %rdi
leaq 0x87d1(%rip), %rsi      # 0xc349
callq 0x3200
jmp 0x3b7f
movq -0x50(%rbp), %rdi
leaq 0x87e1(%rip), %rsi      # 0xc36b
callq 0x3200
jmp 0x3b91
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x3bcb
jmp 0x3bc2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x3bd5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3140
jmp 0x3bd5
movq -0x50(%rbp), %rdi
callq 0x3140
movq -0x60(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3140
movq -0x20(%rbp), %rdi
callq 0x33b0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3330
movq -0x30(%rbp), %rdi
leaq 0x8c5a(%rip), %rsi      # 0xd319
callq 0x3320
jmp 0x46c6
movq -0x30(%rbp), %rdi
leaq 0x8c69(%rip), %rsi      # 0xd33a
callq 0x3200
jmp 0x46d8
movq -0x30(%rbp), %rdi
leaq 0x8c77(%rip), %rsi      # 0xd35a
callq 0x3200
jmp 0x46ea
movq -0x30(%rbp), %rdi
leaq 0x8c8d(%rip), %rsi      # 0xd382
callq 0x3200
jmp 0x46fc
movq -0x30(%rbp), %rdi
leaq 0x8ca5(%rip), %rsi      # 0xd3ac
callq 0x3200
jmp 0x470e
movq -0x30(%rbp), %rdi
leaq 0x8cbe(%rip), %rsi      # 0xd3d7
callq 0x3200
jmp 0x4720
movq -0x30(%rbp), %rdi
leaq 0x8cdd(%rip), %rsi      # 0xd408
callq 0x3200
jmp 0x4732
movq -0x30(%rbp), %rdi
leaq 0x8cf5(%rip), %rsi      # 0xd432
callq 0x3200
jmp 0x4744
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x4770
jmp 0x4767
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3140
jmp 0x477a
movq -0x30(%rbp), %rdi
callq 0x3140
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x33b0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movsbl -0x9(%rbp), %esi
callq 0x48e0
testb $0x1, %al
jne 0x47ca
movq -0x18(%rbp), %rdi
movsbl -0x9(%rbp), %esi
callq 0x49d0
testb $0x1, %al
jne 0x47ca
jmp 0x47f1
movq 0xe7ff(%rip), %rdi      # 0x12fd0
leaq 0x8c81(%rip), %rsi      # 0xd459
callq 0x3210
movq %rax, %rdi
movq 0xe7d9(%rip), %rsi      # 0x12fc0
callq 0x3240
jmp 0x48cf
movsbl -0x9(%rbp), %eax
addl $-0x61, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x16, %eax
ja 0x4851
movq -0x20(%rbp), %rax
leaq 0x77f6(%rip), %rcx      # 0xc004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6680
jmp 0x4851
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6640
jmp 0x4851
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x66a0
jmp 0x4851
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6660
movq -0x18(%rbp), %rdi
callq 0x3840
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x18(%rax), %rdi
movl $0x3, %esi
callq 0x8840
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq 0x18(%rax), %rdi
movl $0x2, %esi
callq 0x8840
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rdi
movsbl -0x9(%rbp), %esi
callq 0x4b40
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x9880
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rdi
callq 0x6600
cmpl $0x0, %eax
jne 0x491a
movsbl -0x11(%rbp), %eax
cmpl $0x77, %eax
jne 0x491a
movb $0x1, -0x1(%rbp)
jmp 0x49c2
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6600
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x24(%rbp)
movq 0x18(%rax), %rdi
callq 0x87f0
movl %eax, %ecx
movl -0x24(%rbp), %eax
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x4954
movsbl -0x11(%rbp), %eax
cmpl $0x73, %eax
jne 0x4954
movb $0x1, -0x1(%rbp)
jmp 0x49c2
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6620
cmpl $0x0, %eax
jne 0x4975
movsbl -0x11(%rbp), %eax
cmpl $0x61, %eax
jne 0x4975
movb $0x1, -0x1(%rbp)
jmp 0x49c2
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6620
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x28(%rbp)
movq 0x18(%rax), %rdi
callq 0x8800
movl %eax, %ecx
movl -0x28(%rbp), %eax
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x49af
movsbl -0x11(%rbp), %eax
cmpl $0x64, %eax
jne 0x49af
movb $0x1, -0x1(%rbp)
jmp 0x49c2
movsbl -0x11(%rbp), %eax
cmpl $0x6e, %eax
jne 0x49be
movb $0x0, -0x1(%rbp)
jmp 0x49c2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movsbl -0x9(%rbp), %eax
addl $-0x61, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x16, %eax
ja 0x4c0e
movq -0x18(%rbp), %rax
leaq 0x7545(%rip), %rcx      # 0xc0c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rdi
callq 0x3960
movq %rax, %rdi
callq 0x5540
movq %rax, %rdi
movq -0x20(%rbp), %rax
movsbl 0x5(%rax), %esi
callq 0x5640
jmp 0x4c0e
movq -0x20(%rbp), %rdi
callq 0x3960
movq %rax, %rdi
callq 0x5520
movq %rax, %rdi
movq -0x20(%rbp), %rax
movsbl 0x5(%rax), %esi
callq 0x5640
jmp 0x4c0e
movq -0x20(%rbp), %rdi
callq 0x3960
movq %rax, %rdi
callq 0x5580
movq %rax, %rdi
movq -0x20(%rbp), %rax
movsbl 0x5(%rax), %esi
callq 0x5640
jmp 0x4c0e
movq -0x20(%rbp), %rdi
callq 0x3960
movq %rax, %rdi
callq 0x5560
movq %rax, %rdi
movq -0x20(%rbp), %rax
movsbl 0x5(%rax), %esi
callq 0x5640
movq -0x20(%rbp), %rdi
callq 0x3960
movq %rax, %rdi
callq 0x54e0
movq -0x20(%rbp), %rdi
movb %al, 0x5(%rdi)
callq 0x3960
movq %rax, %rdi
movl $0x2a, %esi
callq 0x5640
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x3960
movq %rax, %rdi
callq 0x5620
cmpq $0x0, %rax
je 0x5223
movq 0xde7e(%rip), %rdi      # 0x12fd0
leaq 0x8420(%rip), %rsi      # 0xd579
callq 0x3210
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x58(%rbp)
movq 0x10(%rax), %rdi
callq 0x5620
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x6360
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x31f0
movq %rax, -0x48(%rbp)
jmp 0x5195
movq -0x48(%rbp), %rdi
leaq 0x85fe(%rip), %rsi      # 0xd79e
callq 0x3210
movq %rax, -0x60(%rbp)
jmp 0x51ab
movq -0x60(%rbp), %rdi
movq 0xde0a(%rip), %rsi      # 0x12fc0
callq 0x3240
movq %rax, -0x68(%rbp)
jmp 0x51c1
movq -0x68(%rbp), %rdi
movq 0xddf4(%rip), %rsi      # 0x12fc0
callq 0x3240
jmp 0x51d3
leaq -0x28(%rbp), %rdi
callq 0x3140
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x70(%rbp)
movq 0x10(%rax), %rdi
callq 0x5620
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x66c0
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x5700
jmp 0x5223
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3140
jmp 0x5229
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x33b0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x8(%rax), %rdi
callq 0x6600
cmpl $0x1, %eax
jne 0x527f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6620
cmpl $0x4, %eax
jne 0x527f
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x50a0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x65c0
cmpl $0x0, %eax
jne 0x529f
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x50a0
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x52b6
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x50a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: JacobLCarter[P]2D-Portal/game.cpp
// Function: Game::playRound()
void Game::playRound()
{
    executeUserInput(getUserAction());
    checkForCake();
    checkForItem();
    checkDoor();
    checkForEnding();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x39f0
movq -0x10(%rbp), %rdi
movsbl %al, %esi
callq 0x4ee0
movq -0x10(%rbp), %rdi
callq 0x5310
movq -0x10(%rbp), %rdi
callq 0x5120
movq -0x10(%rbp), %rdi
callq 0x52c0
movq -0x10(%rbp), %rdi
callq 0x5240
addq $0x10, %rsp
popq %rbp
retq
nop
// File: JacobLCarter[P]2D-Portal/space.cpp
// Function: Space::Space()
Space::Space()
{
    up = bottom = left = right = NULL;
    spaceTypeIdentifier = ' ';
    itemInSpace = NULL;
    isPressed = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0xd7bd(%rip), %rcx      # 0x12bb0
addq $0x10, %rcx
movq %rcx, (%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x18(%rax)
movb $0x20, 0x8(%rax)
movq $0x0, 0x10(%rax)
movb $0x0, 0x9(%rax)
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
leaq 0xd767(%rip), %rcx      # 0x12bb0
addq $0x10, %rcx
movq %rcx, (%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x18(%rax)
movb -0x9(%rbp), %cl
movb %cl, 0x8(%rax)
movq $0x0, 0x10(%rax)
movb $0x0, 0x9(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6980
testb $0x1, %al
jne 0x5cd3
jmp 0x5d0a
movq -0x28(%rbp), %rax
movb $0x1, 0x9(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x66f0
movq 0xd2e1(%rip), %rdi      # 0x12fd0
leaq 0x7951(%rip), %rsi      # 0xd647
callq 0x3210
movq %rax, %rdi
movq 0xd2bb(%rip), %rsi      # 0x12fc0
callq 0x3240
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x8, %rdi
movq %rdi, -0x50(%rbp)
callq 0x3330
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x48(%rbp)
callq 0x6a10
movq -0x40(%rbp), %rdi
movl $0x64, %esi
callq 0x64f0
jmp 0x6422
movq 0xcba7(%rip), %rdi      # 0x12fd0
leaq 0x73c8(%rip), %rsi      # 0xd7f8
callq 0x3210
movq %rax, -0x58(%rbp)
jmp 0x643b
movq -0x58(%rbp), %rdi
movq 0xcb7a(%rip), %rsi      # 0x12fc0
callq 0x3240
jmp 0x644d
movq 0xcb7c(%rip), %rdi      # 0x12fd0
leaq 0x73c8(%rip), %rsi      # 0xd823
callq 0x3210
jmp 0x6462
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x9c80
jmp 0x646f
movq -0x40(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6510
jmp 0x647e
leaq -0x38(%rbp), %rdi
callq 0x3140
movq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x6540
jmp 0x6494
movq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x6560
jmp 0x64a1
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x64ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3140
movq -0x48(%rbp), %rdi
callq 0x6a30
movq -0x50(%rbp), %rdi
callq 0x3140
movq -0x10(%rbp), %rdi
callq 0x33b0
nopw %cs:(%rax,%rax)
// File: JacobLCarter[P]2D-Portal/player.cpp
// Function: Player::displayBackpackContents()
void Player::displayBackpackContents()
{
    std::cout << "Current contents of your backpack: " << std::endl;

    if (backpack.empty())
    {
        std::cout << "Nothing!" << std::endl;
    }
    else
    {
        //for each item, print an ascending number and the name and description
        for (int i = 0; i < backpack.size(); i++)
        {
            std::cout << i + 1 << ": " << backpack.at(i)->getItemName()
                      << " - " << backpack.at(i)->getItemDescription()
                      << std::endl;
        }
        std::cout << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq 0xc822(%rip), %rdi      # 0x12fd0
leaq 0x7080(%rip), %rsi      # 0xd835
callq 0x3210
movq %rax, %rdi
movq 0xc7fc(%rip), %rsi      # 0x12fc0
callq 0x3240
movq -0x68(%rbp), %rdi
addq $0x30, %rdi
callq 0x6ca0
testb $0x1, %al
jne 0x67dc
jmp 0x6803
movq 0xc7ed(%rip), %rdi      # 0x12fd0
leaq 0x706f(%rip), %rsi      # 0xd859
callq 0x3210
movq %rax, %rdi
movq 0xc7c7(%rip), %rsi      # 0x12fc0
callq 0x3240
jmp 0x6964
movl $0x0, -0xc(%rbp)
movq -0x68(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x70(%rbp)
addq $0x30, %rdi
callq 0x6ce0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x6951
movl -0xc(%rbp), %esi
incl %esi
movq 0xc795(%rip), %rdi      # 0x12fd0
callq 0x33a0
movq %rax, %rdi
leaq 0x7199(%rip), %rsi      # 0xd9e3
callq 0x3210
movq -0x68(%rbp), %rdi
movq %rax, -0x88(%rbp)
addq $0x30, %rdi
movslq -0xc(%rbp), %rsi
callq 0x6d00
movq (%rax), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x6360
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x31f0
movq %rax, -0x78(%rbp)
jmp 0x688d
movq -0x78(%rbp), %rdi
leaq 0x6fca(%rip), %rsi      # 0xd862
callq 0x3210
movq %rax, -0x90(%rbp)
jmp 0x68a6
movq -0x68(%rbp), %rdi
addq $0x30, %rdi
movslq -0xc(%rbp), %rsi
callq 0x6d00
movq %rax, -0x98(%rbp)
jmp 0x68c0
movq -0x98(%rbp), %rax
movq (%rax), %rsi
leaq -0x60(%rbp), %rdi
callq 0x6390
jmp 0x68d5
movq -0x90(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x31f0
movq %rax, -0xa0(%rbp)
jmp 0x68ee
movq -0xa0(%rbp), %rdi
movq 0xc6c4(%rip), %rsi      # 0x12fc0
callq 0x3240
jmp 0x6903
leaq -0x60(%rbp), %rdi
callq 0x3140
leaq -0x30(%rbp), %rdi
callq 0x3140
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x680a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x6946
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3140
leaq -0x30(%rbp), %rdi
callq 0x3140
jmp 0x696d
movq 0xc678(%rip), %rdi      # 0x12fd0
movq 0xc661(%rip), %rsi      # 0x12fc0
callq 0x3240
addq $0xa0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x33b0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movslq (%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0xc(%rbp)
movq -0x28(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0x8676
movq -0x28(%rbp), %rax
movslq 0x4(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rdx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x10(%rbp)
movq -0x28(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x8666
movl $0x38, %edi
callq 0x3220
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x5d10
jmp 0x8623
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x85fc
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x38, %esi
callq 0x3230
jmp 0x8697
jmp 0x8668
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x85aa
movq -0x28(%rbp), %rdi
callq 0x9140
movq -0x28(%rbp), %rdi
callq 0x9240
movq -0x28(%rbp), %rdi
callq 0x93b0
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x33b0
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0x8745
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x8712
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x8705
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x8707
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x86cd
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x8735
movq -0x28(%rbp), %rdi
callq 0x3310
jmp 0x8737
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x86bb
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x8760
movq -0x30(%rbp), %rdi
callq 0x3310
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x8791
movq -0x38(%rbp), %rdi
callq 0x6330
movq -0x38(%rbp), %rdi
movl $0x48, %esi
callq 0x3230
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x87ba
movq -0x40(%rbp), %rdi
callq 0x6330
movq -0x40(%rbp), %rdi
movl $0x48, %esi
callq 0x3230
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x87e3
movq -0x48(%rbp), %rdi
callq 0x6330
movq -0x48(%rbp), %rdi
movl $0x48, %esi
callq 0x3230
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x1, %eax
je 0x8874
jmp 0x8860
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0x8882
jmp 0x886a
movl -0x18(%rbp), %eax
subl $0x3, %eax
je 0x8890
jmp 0x889e
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x88a6
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x88a6
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x88a6
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x1, %edx
movl %edx, %esi
callq 0x9410
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x3, %edx
callq 0x94c0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x4, %edx
callq 0x9570
movq -0x10(%rbp), %rdi
movl $0x4, %esi
movl $0x3, %edx
callq 0x9620
movq -0x10(%rbp), %rdi
movl $0x3, %esi
movl $0x4, %edx
callq 0x9620
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x9620
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x96d0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x96d0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x96d0
movq -0x10(%rbp), %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x96d0
movq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0x3, %edx
callq 0x96d0
movq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0x4, %edx
callq 0x96d0
movq -0x10(%rbp), %rdi
movl $0x3, %esi
movl $0x1, %edx
callq 0x96d0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0x93a6
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x9396
cmpl $0x0, -0xc(%rbp)
jle 0x92bd
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x5660
cmpl $0x0, -0x10(%rbp)
jle 0x92f9
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
callq 0x56a0
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x933f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x5680
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
movl 0x4(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x9386
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
callq 0x56c0
jmp 0x9388
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x9271
jmp 0x9398
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x925b
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movb %sil, %al
movq %rdi, %rcx
movq %rcx, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movb $0x0, -0xa(%rbp)
callq 0x3330
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x9ce6
movq 0x9314(%rip), %rdi      # 0x12fd0
leaq 0x3d39(%rip), %rsi      # 0xd9fc
callq 0x3210
jmp 0x9cca
jmp 0x9ce6
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3140
jmp 0x9d74
movq -0x30(%rbp), %rsi
movq 0x92ef(%rip), %rdi      # 0x12fe0
callq 0x3060
jmp 0x9cf8
jmp 0x9cfa
movq -0x30(%rbp), %rdi
leaq 0x29e6(%rip), %rsi      # 0xc6eb
callq 0xaa60
movb %al, -0x31(%rbp)
jmp 0x9d0f
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x9d18
jmp 0x9d57
movq 0x92b1(%rip), %rdi      # 0x12fd0
leaq 0x3cef(%rip), %rsi      # 0xda15
callq 0x3210
movq %rax, -0x40(%rbp)
jmp 0x9d31
movq -0x40(%rbp), %rdi
movq 0x9284(%rip), %rsi      # 0x12fc0
callq 0x3240
jmp 0x9d43
movq -0x30(%rbp), %rsi
movq 0x9292(%rip), %rdi      # 0x12fe0
callq 0x3060
jmp 0x9d55
jmp 0x9cfa
movb $0x1, -0xa(%rbp)
testb $0x1, -0xa(%rbp)
jne 0x9d6a
movq -0x30(%rbp), %rdi
callq 0x3140
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x33b0
nopl (%rax)
// File: JacobLCarter[P]2D-Portal/utils.cpp
// Function: getInt(bool)
int getInt(bool prompt)
{
    std::string input;

    //causes the function to output a generic prompt
    if (prompt == true)
    {
        std::cout << "Enter an integer: ";
    }

    //get the users input
    std::getline(std::cin, input);

    //reprompt if the input is blank or not made up of int values 
    while (input.find_first_not_of("0123456789-") != std::string::npos ||
            input == "")
    {
        std::cout << "Not an integer -- please enter an int: " 
            << std::endl;
        std::getline(std::cin, input);
    }
       
    //convert the input to an integer
    int i = std::atoi(input.c_str());
    
    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3330
movb -0x1(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x9dd7
movq 0x9223(%rip), %rdi      # 0x12fd0
leaq 0x3c90(%rip), %rsi      # 0xda44
callq 0x3210
jmp 0x9dbb
jmp 0x9dd7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3140
jmp 0x9ea1
movq 0x9202(%rip), %rdi      # 0x12fe0
leaq -0x28(%rbp), %rsi
callq 0x3060
jmp 0x9de9
jmp 0x9deb
leaq -0x28(%rbp), %rdi
leaq 0x3c61(%rip), %rsi      # 0xda57
xorl %eax, %eax
movl %eax, %edx
callq 0x3120
movq %rax, %rcx
movb $0x1, %al
cmpq $-0x1, %rcx
movb %al, -0x39(%rbp)
jne 0x9e2a
leaq 0x28d7(%rip), %rsi      # 0xc6eb
leaq -0x28(%rbp), %rdi
callq 0xaa60
movb %al, -0x3a(%rbp)
jmp 0x9e22
movb -0x3a(%rbp), %al
movb %al, -0x39(%rbp)
jmp 0x9e2a
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x9e33
jmp 0x9e75
movq 0x9196(%rip), %rdi      # 0x12fd0
leaq 0x3c22(%rip), %rsi      # 0xda63
callq 0x3210
movq %rax, -0x48(%rbp)
jmp 0x9e4c
movq -0x48(%rbp), %rdi
movq 0x9169(%rip), %rsi      # 0x12fc0
callq 0x3240
jmp 0x9e5e
movq 0x917b(%rip), %rdi      # 0x12fe0
leaq -0x28(%rbp), %rsi
callq 0x3060
jmp 0x9e70
jmp 0x9deb
leaq -0x28(%rbp), %rdi
callq 0x30e0
movq %rax, %rdi
callq 0x3370
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x4c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3140
movl -0x4c(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x33b0
nopw (%rax,%rax)
// File: JacobLCarter[P]2D-Portal/utils.cpp
// Function: getDouble()
double getDouble()
{
    std::string input;
  
    std::cout << "Enter a double :";
    std::getline(std::cin, input);

    while (input.find_first_not_of("0123456789.-") != std::string::npos ||
            input == "")
    {
        std::cout << "Not a double -- enter a double: " << std::endl;
        std::getline(std::cin, input);
    }
        
    double d = std::atof(input.c_str());
    
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq -0x20(%rbp), %rdi
callq 0x3330
movq 0x9108(%rip), %rdi      # 0x12fd0
leaq 0x3bbc(%rip), %rsi      # 0xda8b
callq 0x3210
jmp 0x9ed6
movq 0x9103(%rip), %rdi      # 0x12fe0
leaq -0x20(%rbp), %rsi
callq 0x3060
jmp 0x9ee8
jmp 0x9eea
leaq -0x20(%rbp), %rdi
leaq 0x3ba7(%rip), %rsi      # 0xda9c
xorl %eax, %eax
movl %eax, %edx
callq 0x3120
movq %rax, %rcx
movb $0x1, %al
cmpq $-0x1, %rcx
movb %al, -0x39(%rbp)
jne 0x9f29
leaq 0x27d8(%rip), %rsi      # 0xc6eb
leaq -0x20(%rbp), %rdi
callq 0xaa60
movb %al, -0x3a(%rbp)
jmp 0x9f21
movb -0x3a(%rbp), %al
movb %al, -0x39(%rbp)
jmp 0x9f29
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x9f32
jmp 0x9f8b
movq 0x9097(%rip), %rdi      # 0x12fd0
leaq 0x3b69(%rip), %rsi      # 0xdaa9
callq 0x3210
movq %rax, -0x48(%rbp)
jmp 0x9f4b
movq -0x48(%rbp), %rdi
movq 0x906a(%rip), %rsi      # 0x12fc0
callq 0x3240
jmp 0x9f5d
movq 0x907c(%rip), %rdi      # 0x12fe0
leaq -0x20(%rbp), %rsi
callq 0x3060
jmp 0x9f6f
jmp 0x9eea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3140
jmp 0x9fbf
leaq -0x20(%rbp), %rdi
callq 0x30e0
movq %rax, %rdi
callq 0x32e0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3140
movsd -0x50(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x33b0
nopl (%rax,%rax)
// File: JacobLCarter[P]2D-Portal/utils.cpp
// Function: getChar()
char getChar()
{
    
    std::string input;
  
    std::getline(std::cin, input);

    while (input.find_first_not_of("wsadebmthx") != std::string::npos ||
            input == "")
    {
        std::cout << "Not a valid control input -- try again" 
            << std::endl;
        std::getline(std::cin, input);
    }

    return input[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x3330
movq -0x38(%rbp), %rsi
movq 0x8ff0(%rip), %rdi      # 0x12fe0
callq 0x3060
jmp 0x9ff7
jmp 0x9ff9
leaq -0x20(%rbp), %rdi
leaq 0x3ac6(%rip), %rsi      # 0xdaca
xorl %eax, %eax
movl %eax, %edx
callq 0x3120
movq %rax, %rcx
movb $0x1, %al
cmpq $-0x1, %rcx
movb %al, -0x39(%rbp)
jne 0xa038
leaq 0x26c9(%rip), %rsi      # 0xc6eb
leaq -0x20(%rbp), %rdi
callq 0xaa60
movb %al, -0x3a(%rbp)
jmp 0xa030
movb -0x3a(%rbp), %al
movb %al, -0x39(%rbp)
jmp 0xa038
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xa041
jmp 0xa09a
movq 0x8f88(%rip), %rdi      # 0x12fd0
leaq 0x3a86(%rip), %rsi      # 0xdad5
callq 0x3210
movq %rax, -0x48(%rbp)
jmp 0xa05a
movq -0x48(%rbp), %rdi
movq 0x8f5b(%rip), %rsi      # 0x12fc0
callq 0x3240
jmp 0xa06c
movq 0x8f6d(%rip), %rdi      # 0x12fe0
leaq -0x20(%rbp), %rsi
callq 0x3060
jmp 0xa07e
jmp 0x9ff9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3140
jmp 0xa0c8
xorl %eax, %eax
movl %eax, %esi
leaq -0x20(%rbp), %rdi
callq 0x33f0
movq %rax, -0x50(%rbp)
jmp 0xa0ad
movq -0x50(%rbp), %rax
movb (%rax), %al
movb %al, -0x51(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3140
movb -0x51(%rbp), %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x33b0
nopw %cs:(%rax,%rax)
// File: JacobLCarter[P]2D-Portal/utils.cpp
// Function: getHorizontalChar()
char getHorizontalChar()
{
    
    std::string input;
  
    std::getline(std::cin, input);

    while (input.find_first_not_of("adx") != std::string::npos ||
            input == "")
    {
        std::cout << "Not a valid control input -- try again" 
            << std::endl;
        std::getline(std::cin, input);
    }

    return input[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x3330
movq -0x38(%rbp), %rsi
movq 0x8ee0(%rip), %rdi      # 0x12fe0
callq 0x3060
jmp 0xa107
jmp 0xa109
leaq -0x20(%rbp), %rdi
leaq 0x39e8(%rip), %rsi      # 0xdafc
xorl %eax, %eax
movl %eax, %edx
callq 0x3120
movq %rax, %rcx
movb $0x1, %al
cmpq $-0x1, %rcx
movb %al, -0x39(%rbp)
jne 0xa148
leaq 0x25b9(%rip), %rsi      # 0xc6eb
leaq -0x20(%rbp), %rdi
callq 0xaa60
movb %al, -0x3a(%rbp)
jmp 0xa140
movb -0x3a(%rbp), %al
movb %al, -0x39(%rbp)
jmp 0xa148
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xa151
jmp 0xa1aa
movq 0x8e78(%rip), %rdi      # 0x12fd0
leaq 0x3976(%rip), %rsi      # 0xdad5
callq 0x3210
movq %rax, -0x48(%rbp)
jmp 0xa16a
movq -0x48(%rbp), %rdi
movq 0x8e4b(%rip), %rsi      # 0x12fc0
callq 0x3240
jmp 0xa17c
movq 0x8e5d(%rip), %rdi      # 0x12fe0
leaq -0x20(%rbp), %rsi
callq 0x3060
jmp 0xa18e
jmp 0xa109
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3140
jmp 0xa1d8
xorl %eax, %eax
movl %eax, %esi
leaq -0x20(%rbp), %rdi
callq 0x33f0
movq %rax, -0x50(%rbp)
jmp 0xa1bd
movq -0x50(%rbp), %rax
movb (%rax), %al
movb %al, -0x51(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3140
movb -0x51(%rbp), %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x33b0
nopw %cs:(%rax,%rax)