LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: venGaza[P]starwars/src/Game.cpp
// Function: Game::doorInteraction(Map&)
void Game::doorInteraction(Map& map) {
    cout << map.getLocation()->getRoomDescription() << endl << endl;
    
    cout << "Please enter an access code: ";
    int userInput = getInteger();
    cout << endl;
    if (userInput == doorCode) {   //Door code is 1225 and found on paper description
        cout << "Access GRANTED (The door whirs open with a whoosh)" << endl << endl;
        map.moveSouth();
        pause();
    } else {
        cout << "Access DENIED (I guess you will be admiring the blasters a little longer)"       << endl << endl;
        map.moveWest();
        pause();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x58a0
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xa870
movq -0x50(%rbp), %rsi
movq 0x9244(%rip), %rdi      # 0x10fd0
callq 0x3180
movq %rax, -0x48(%rbp)
jmp 0x7d97
movq -0x48(%rbp), %rdi
movq 0x921e(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq %rax, -0x60(%rbp)
jmp 0x7dad
movq -0x60(%rbp), %rdi
movq 0x9208(%rip), %rsi      # 0x10fc0
callq 0x31d0
jmp 0x7dbf
leaq -0x30(%rbp), %rdi
callq 0x3110
movq 0x9201(%rip), %rdi      # 0x10fd0
leaq 0x3f9c(%rip), %rsi      # 0xbd72
callq 0x31a0
callq 0x95d0
movl %eax, -0x40(%rbp)
movq 0x91e6(%rip), %rdi      # 0x10fd0
movq 0x91cf(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq -0x58(%rbp), %rcx
movl -0x40(%rbp), %eax
cmpl 0x28(%rcx), %eax
jne 0x7e5e
movq 0x91c7(%rip), %rdi      # 0x10fd0
leaq 0x3f80(%rip), %rsi      # 0xbd90
callq 0x31a0
movq %rax, %rdi
movq 0x91a1(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq %rax, %rdi
movq 0x9192(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq -0x10(%rbp), %rdi
callq 0x5720
movq -0x58(%rbp), %rdi
callq 0x82f0
jmp 0x7ea1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3110
jmp 0x7ea7
movq 0x916b(%rip), %rdi      # 0x10fd0
leaq 0x3f57(%rip), %rsi      # 0xbdc3
callq 0x31a0
movq %rax, %rdi
movq 0x9145(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq %rax, %rdi
movq 0x9136(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq -0x10(%rbp), %rdi
callq 0x5800
movq -0x58(%rbp), %rdi
callq 0x82f0
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x32f0
// File: venGaza[P]starwars/src/Game.cpp
// Function: Game::winMessage()
void Game::winMessage() {
    if (chewbaccaFree) {
    cout << "You quickly glance around the Launch Bay. Luckily, there is one star ship available for you to commandeer and escape the ship. As you board the ship, Poe and Chewbacca run up the ramp to give you a high five for defeating Kylo Ren. The action music again starts to blare as alarms go off in the launch bay. You fire up the engines and take off from the ship knowing that Supreme Leader Snoke still needs to be found and dealt with. After a long deliberation with Poe and Chewbacca, you all decide to stop at the Mos Eisley cantina for a well deserved break! As you engage the light drive, the ship you left behind disintegrates into billions of pieces... Chewy must have made some modifications in the core reactor." << endl << endl;
    } else {
        cout << "You quickly glance around the Launch Bay. Luckily, there is one star ship available for you to commandeer and escape the ship. As you board the ship, Poe runs up the ramp to give you a high five for defeating Kylo Ren. The action music again starts to blare as alarms go off in the launch bay. You fire up the engines and take off from the ship knowing that Supreme Leader Snoke still needs to be found and dealt with. After a long deliberation with Poe, you all decide to stop at the Mos Eisley cantina for a well deserved break! As you engage the light drive, you hear a faint grrrwaaaaaarggggh and can't help but to think that someone was left in the detention block. Oh well... " << endl << endl;
    }
    
    cout << "Congratulation you have COMPLETED this Star Wars adventure!" << endl << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x23(%rax)
je 0x8239
movq 0x8dc3(%rip), %rdi      # 0x10fd0
leaq 0x42ab(%rip), %rsi      # 0xc4bf
callq 0x31a0
movq %rax, %rdi
movq 0x8d9d(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq %rax, %rdi
movq 0x8d8e(%rip), %rsi      # 0x10fc0
callq 0x31d0
jmp 0x826a
movq 0x8d90(%rip), %rdi      # 0x10fd0
leaq 0x4544(%rip), %rsi      # 0xc78b
callq 0x31a0
movq %rax, %rdi
movq 0x8d6a(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq %rax, %rdi
movq 0x8d5b(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq 0x8d5f(%rip), %rdi      # 0x10fd0
leaq 0x47be(%rip), %rsi      # 0xca36
callq 0x31a0
movq %rax, %rdi
movq 0x8d39(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq %rax, %rdi
movq 0x8d2a(%rip), %rsi      # 0x10fc0
callq 0x31d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: venGaza[P]starwars/src/Game.cpp
// Function: Game::pause()
void Game::pause() {
    cout << "Press enter to continue" << endl;
    char ch  = cin.get();   //PAUSE
    while (ch != '\n') {
        cin.clear();
        ch = cin.get();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x8ccd(%rip), %rdi      # 0x10fd0
leaq 0x4768(%rip), %rsi      # 0xca72
callq 0x31a0
movq %rax, %rdi
movq 0x8ca7(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq 0x8cbb(%rip), %rdi      # 0x10fe0
callq 0x3230
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0xa, %eax
je 0x8363
movq 0x8ca3(%rip), %rax      # 0x10fe0
movq (%rax), %rax
movq 0x8c99(%rip), %rdi      # 0x10fe0
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x32d0
movq 0x8c87(%rip), %rdi      # 0x10fe0
callq 0x3230
movb %al, -0x9(%rbp)
jmp 0x832d
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: venGaza[P]starwars/src/Game.cpp
// Function: Game::printItems()
void Game::printItems() {
    cout << setw(18) << "Inventory" << endl  //Header
    << "---------------------------------" << endl;
    for (int i = 0; i < inventory.size(); i++) {
        cout << inventory[i].itemName << ": " << inventory[i].itemDescription << endl;
    }
    cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x12, %edi
callq 0x88a0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
movq 0x89c5(%rip), %rdi      # 0x10fd0
callq 0x3220
movq %rax, %rdi
leaq 0x36aa(%rip), %rsi      # 0xbcc4
callq 0x31a0
movq %rax, %rdi
movq 0x8997(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq %rax, %rdi
leaq 0x3696(%rip), %rsi      # 0xbcce
callq 0x31a0
movq %rax, %rdi
movq 0x8979(%rip), %rsi      # 0x10fc0
callq 0x31d0
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x30, %rdi
callq 0x88c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x86e5
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movslq -0x10(%rbp), %rsi
callq 0x88e0
movq %rax, %rsi
movq 0x8941(%rip), %rdi      # 0x10fd0
callq 0x3180
movq %rax, %rdi
leaq 0x2b83(%rip), %rsi      # 0xb221
callq 0x31a0
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x30, %rdi
movslq -0x10(%rbp), %rsi
callq 0x88e0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x3180
movq %rax, %rdi
movq 0x88ee(%rip), %rsi      # 0x10fc0
callq 0x31d0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8653
movq 0x88e4(%rip), %rdi      # 0x10fd0
movq 0x88cd(%rip), %rsi      # 0x10fc0
callq 0x31d0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: venGaza[P]starwars/src/Game.cpp
// Function: Game::addLightsaber()
void Game::addLightsaber() {
    Items lightsaber;
    lightsaber.itemName = "GREEN LIGHT SABER: ";
    lightsaber.itemDescription = "The weapon of choice for a jedi.";
    inventory.push_back(lightsaber);
    kyloWinGame = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x62b0
movq -0x60(%rbp), %rdi
leaq 0x35c4(%rip), %rsi      # 0xbcf0
callq 0x3250
jmp 0x8733
leaq -0x28(%rbp), %rdi
leaq 0x35c6(%rip), %rsi      # 0xbd04
callq 0x3250
jmp 0x8745
movq -0x68(%rbp), %rdi
addq $0x30, %rdi
leaq -0x48(%rbp), %rsi
callq 0x8900
jmp 0x8758
movq -0x68(%rbp), %rax
movb $0x0, 0x21(%rax)
leaq -0x48(%rbp), %rdi
callq 0x8970
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8970
movq -0x50(%rbp), %rdi
callq 0x32f0
nopl (%rax)
// File: venGaza[P]starwars/src/Game.cpp
// Function: Game::addPaper()
void Game::addPaper() {
    Items accessCode;
    accessCode.itemName = "CRUMPLED PAPER: ";
    accessCode.itemDescription = "There is some writing in Ewokese: 1225... how mysterious...";
    inventory.push_back(accessCode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x62b0
movq -0x60(%rbp), %rdi
leaq 0x3569(%rip), %rsi      # 0xbd25
callq 0x3250
jmp 0x87c3
leaq -0x28(%rbp), %rdi
leaq 0x3568(%rip), %rsi      # 0xbd36
callq 0x3250
jmp 0x87d5
movq -0x68(%rbp), %rdi
addq $0x30, %rdi
leaq -0x48(%rbp), %rsi
callq 0x8900
jmp 0x87e8
leaq -0x48(%rbp), %rdi
callq 0x8970
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8970
movq -0x50(%rbp), %rdi
callq 0x32f0
nopw %cs:(%rax,%rax)
nop
// File: venGaza[P]starwars/src/getInteger.cpp
// Function: getInteger()
int getInteger() {                      //See code citation in comment at top of page
    int integer;
    while (true) {
        string line;
        getline(cin, line);
        
        istringstream stream(line);
        stream >> integer;
        if (!stream.fail() && stream.eof() && integer >= 0) { //Num Validation & Pos Number Validation
            break;
        } else {
            cout << "The value you entered is not a valid integer. Please \n"
                    << "enter another integer: ";
        }
    }
    
    return integer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
leaq -0x28(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0x3260
movq -0x1c8(%rbp), %rsi
movq 0x79e7(%rip), %rdi      # 0x10fe0
callq 0x3060
jmp 0x9600
leaq -0x1b8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0x8, %edx
callq 0x32b0
jmp 0x9617
leaq -0x1b8(%rbp), %rdi
leaq -0x4(%rbp), %rsi
callq 0x3100
jmp 0x9629
movq -0x1b8(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x1b8(%rbp,%rax), %rdi
callq 0x3030
movb %al, -0x1c9(%rbp)
jmp 0x9649
movb -0x1c9(%rbp), %al
testb $0x1, %al
jne 0x96bb
jmp 0x9655
movq -0x1b8(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x1b8(%rbp,%rax), %rdi
callq 0x3320
movb %al, -0x1ca(%rbp)
jmp 0x9675
movb -0x1ca(%rbp), %al
testb $0x1, %al
jne 0x9681
jmp 0x96bb
cmpl $0x0, -0x4(%rbp)
jl 0x96bb
movl $0x3, -0x1bc(%rbp)
jmp 0x96f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x9720
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x30d0
jmp 0x9720
movq 0x790e(%rip), %rdi      # 0x10fd0
leaq 0x33db(%rip), %rsi      # 0xcaa4
callq 0x31a0
movq %rax, -0x1d8(%rbp)
jmp 0x96d7
movq -0x1d8(%rbp), %rdi
leaq 0x33f6(%rip), %rsi      # 0xcadb
callq 0x31a0
jmp 0x96ec
jmp 0x96ee
movl $0x0, -0x1bc(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x30d0
leaq -0x28(%rbp), %rdi
callq 0x3110
movl -0x1bc(%rbp), %eax
testl %eax, %eax
je 0x971b
jmp 0x9719
jmp 0x972b
jmp 0x95db
leaq -0x28(%rbp), %rdi
callq 0x3110
jmp 0x9737
movl -0x4(%rbp), %eax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x32f0
// File: venGaza[P]starwars/src/Door.cpp
// Function: Door::Door()
Door::Door() {
    Space::roomName = "Door";
    Space::roomDescription= "There appears to be a big startanium door impeding the way. It looks like some access code needs to be entered.";
    
    Space::top = new Corridor;
    Space::top->setBottom(this);
    Space::bottom = new KyloSpace;
    Space::bottom->setTop(this);
    Space::left = nullptr;
    Space::right = nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xa730
movq -0x20(%rbp), %rdi
leaq 0x753c(%rip), %rax      # 0x10ca0
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x34e4(%rip), %rsi      # 0xcc56
callq 0x3250
jmp 0x9779
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
leaq 0x336b(%rip), %rsi      # 0xcaf3
callq 0x3250
jmp 0x978f
movl $0x68, %edi
callq 0x31b0
movq %rax, -0x28(%rbp)
jmp 0x979f
movq -0x28(%rbp), %rdi
callq 0x63d0
jmp 0x97aa
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rax
movq %rax, 0x48(%rsi)
movq 0x48(%rsi), %rdi
callq 0xa9a0
jmp 0x97c1
movl $0x68, %edi
callq 0x31b0
movq %rax, -0x30(%rbp)
jmp 0x97d1
movq -0x30(%rbp), %rdi
callq 0xa1c0
jmp 0x97dc
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rax
movq %rax, 0x50(%rsi)
movq 0x50(%rsi), %rdi
callq 0xa980
jmp 0x97f3
movq -0x20(%rbp), %rax
movq $0x0, 0x60(%rax)
movq $0x0, 0x58(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x9851
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x68, %esi
callq 0x31c0
jmp 0x9851
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x68, %esi
callq 0x31c0
movq -0x20(%rbp), %rdi
callq 0xa7f0
movq -0x10(%rbp), %rdi
callq 0x32f0
nopw %cs:(%rax,%rax)
// File: venGaza[P]starwars/src/Door.cpp
// Function: Door::printChoices()
void Door::printChoices() {
    cout << "1) North - Mysterious Room" << endl
         << "2) South - Command Center" << endl
         << "3) West - Armory" << endl
         << "4) Item Inventory " << endl
         << "5) Look around" << endl << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x762d(%rip), %rdi      # 0x10fd0
leaq 0x17e2(%rip), %rsi      # 0xb18c
callq 0x31a0
movq %rax, %rdi
movq 0x7607(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq %rax, %rdi
leaq 0x319b(%rip), %rsi      # 0xcb63
callq 0x31a0
movq %rax, %rdi
movq 0x75e9(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq %rax, %rdi
leaq 0x3197(%rip), %rsi      # 0xcb7d
callq 0x31a0
movq %rax, %rdi
movq 0x75cb(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq %rax, %rdi
leaq 0x17d5(%rip), %rsi      # 0xb1d9
callq 0x31a0
movq %rax, %rdi
movq 0x75ad(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq %rax, %rdi
leaq 0x17ca(%rip), %rsi      # 0xb1ec
callq 0x31a0
movq %rax, %rdi
movq 0x758f(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq %rax, %rdi
movq 0x7580(%rip), %rsi      # 0x10fc0
callq 0x31d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: venGaza[P]starwars/src/DetentionBlock.cpp
// Function: DetentionBlock::DetentionBlock()
DetentionBlock::DetentionBlock() {
    Space::roomName = "Detention Block";
    Space::roomDescription= "A bunch of cells line the wall of the room. It appears there is only one prisoner currently in the First Order's captivity. Who could it be?";
    
    Space::top = nullptr;
    Space::bottom = nullptr;
    Space::left = nullptr;
    Space::right = nullptr;
    
    doorOpen = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xa730
movq -0x20(%rbp), %rdi
leaq 0x7074(%rip), %rax      # 0x10ce8
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x2f12(%rip), %rsi      # 0xcb94
callq 0x3250
jmp 0x9c89
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
leaq 0x2f0c(%rip), %rsi      # 0xcba4
callq 0x3250
jmp 0x9c9f
movq -0x20(%rbp), %rax
movq $0x0, 0x48(%rax)
movq $0x0, 0x50(%rax)
movq $0x0, 0x60(%rax)
movq $0x0, 0x58(%rax)
movb $0x0, 0x68(%rax)
addq $0x20, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xa7f0
movq -0x10(%rbp), %rdi
callq 0x32f0
nopl (%rax,%rax)
// File: venGaza[P]starwars/src/DetentionBlock.cpp
// Function: DetentionBlock::printChoices()
void DetentionBlock::printChoices() {
    if (!doorOpen) {
        cout << "1) North - Core Reactor" << endl
             << "2) Item Inventory " << endl
             << "3) Look around" << endl
             << "4) Open Cell Door" << endl << endl;
    } else {
        cout << "1) North " << endl
        << "2) Item Inventory " << endl
        << "3) Look around" << endl << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x68(%rax)
jne 0x9e57
movq 0x71ff(%rip), %rdi      # 0x10fd0
leaq 0x2e59(%rip), %rsi      # 0xcc31
callq 0x31a0
movq %rax, %rdi
movq 0x71d9(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq %rax, %rdi
leaq 0x1554(%rip), %rsi      # 0xb34a
callq 0x31a0
movq %rax, %rdi
movq 0x71bb(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq %rax, %rdi
leaq 0x1549(%rip), %rsi      # 0xb35d
callq 0x31a0
movq %rax, %rdi
movq 0x719d(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq %rax, %rdi
leaq 0x2e17(%rip), %rsi      # 0xcc49
callq 0x31a0
movq %rax, %rdi
movq 0x717f(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq %rax, %rdi
movq 0x7170(%rip), %rsi      # 0x10fc0
callq 0x31d0
jmp 0x9ec4
movq 0x7172(%rip), %rdi      # 0x10fd0
leaq 0x2df6(%rip), %rsi      # 0xcc5b
callq 0x31a0
movq %rax, %rdi
movq 0x714c(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq %rax, %rdi
leaq 0x14c7(%rip), %rsi      # 0xb34a
callq 0x31a0
movq %rax, %rdi
movq 0x712e(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq %rax, %rdi
leaq 0x14bc(%rip), %rsi      # 0xb35d
callq 0x31a0
movq %rax, %rdi
movq 0x7110(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq %rax, %rdi
movq 0x7101(%rip), %rsi      # 0x10fc0
callq 0x31d0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: venGaza[P]starwars/src/KyloSpace.cpp
// Function: KyloSpace::KyloSpace()
KyloSpace::KyloSpace() {
    Space::roomName = "Command Center";
    Space::roomDescription= "The Command Center where all the nefarious bad guys tend to hang out. Oh look, Kylo Ren is here and he does not look happy to see you!";
    
    Space::top = nullptr;
    Space::bottom = new SnokeSpace;
    Space::bottom->setTop(this);
    Space::left = new LaunchBay;
    Space::left->setRight(this);
    Space::right = new SnokeSpace;
    Space::right->setLeft(this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xa730
movq -0x20(%rbp), %rdi
leaq 0x6b4c(%rip), %rax      # 0x10d30
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x297c(%rip), %rsi      # 0xcb6e
callq 0x3250
jmp 0xa1f9
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
leaq 0x2a6e(%rip), %rsi      # 0xcc76
callq 0x3250
jmp 0xa20f
movq -0x20(%rbp), %rax
movq $0x0, 0x48(%rax)
movl $0x68, %edi
callq 0x31b0
movq %rax, -0x28(%rbp)
jmp 0xa22b
movq -0x28(%rbp), %rdi
callq 0x4240
jmp 0xa236
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rax
movq %rax, 0x50(%rsi)
movq 0x50(%rsi), %rdi
callq 0xa980
jmp 0xa24d
movl $0x68, %edi
callq 0x31b0
movq %rax, -0x30(%rbp)
jmp 0xa25d
movq -0x30(%rbp), %rdi
callq 0x45b0
jmp 0xa268
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rax
movq %rax, 0x60(%rsi)
movq 0x60(%rsi), %rdi
callq 0xa9e0
jmp 0xa27f
movl $0x68, %edi
callq 0x31b0
movq %rax, -0x38(%rbp)
jmp 0xa28f
movq -0x38(%rbp), %rdi
callq 0x4240
jmp 0xa29a
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rax
movq %rax, 0x58(%rsi)
movq 0x58(%rsi), %rdi
callq 0xa9c0
jmp 0xa2b1
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0xa317
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x68, %esi
callq 0x31c0
jmp 0xa317
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x68, %esi
callq 0x31c0
jmp 0xa317
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x68, %esi
callq 0x31c0
movq -0x20(%rbp), %rdi
callq 0xa7f0
movq -0x10(%rbp), %rdi
callq 0x32f0
nopl (%rax)
// File: venGaza[P]starwars/src/KyloSpace.cpp
// Function: KyloSpace::KyloSpace(Space*, Space*, Space*, Space*)
KyloSpace::KyloSpace(Space* top, Space* bottom, Space* left, Space* right) {
    this->Space::top = top;
    this->Space::bottom = bottom;
    this->Space::left = left;
    this->Space::right = right;
}

// 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 %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xa730
movq -0x30(%rbp), %rax
leaq 0x69bc(%rip), %rcx      # 0x10d20
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x50(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x60(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x58(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: venGaza[P]starwars/src/KyloSpace.cpp
// Function: KyloSpace::printChoices()
void KyloSpace::printChoices() {
    cout << "1) North - Startanium Door" << endl
    << "2) East - Mysterious Room" << endl
    << "3) West - Launch Bay" << endl
    << "4) Item Inventory " << endl
    << "5) Look around" << endl << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x6b4d(%rip), %rdi      # 0x10fd0
leaq 0x2873(%rip), %rsi      # 0xccfd
callq 0x31a0
movq %rax, %rdi
movq 0x6b27(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq %rax, %rdi
leaq 0x2870(%rip), %rsi      # 0xcd18
callq 0x31a0
movq %rax, %rdi
movq 0x6b09(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq %rax, %rdi
leaq 0x286c(%rip), %rsi      # 0xcd32
callq 0x31a0
movq %rax, %rdi
movq 0x6aeb(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq %rax, %rdi
leaq 0xcf5(%rip), %rsi       # 0xb1d9
callq 0x31a0
movq %rax, %rdi
movq 0x6acd(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq %rax, %rdi
leaq 0xcea(%rip), %rsi       # 0xb1ec
callq 0x31a0
movq %rax, %rdi
movq 0x6aaf(%rip), %rsi      # 0x10fc0
callq 0x31d0
movq %rax, %rdi
movq 0x6aa0(%rip), %rsi      # 0x10fc0
callq 0x31d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: venGaza[P]starwars/src/Space.cpp
// Function: Space::Space()
Space::Space() {
    Space::roomName = "";
    Space::roomDescription= "";
    
    Space::top = nullptr;
    Space::bottom = nullptr;
    Space::left = nullptr;
    Space::right = nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq 0x662d(%rip), %rax      # 0x10d78
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x20(%rbp)
callq 0x3260
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x28(%rbp)
callq 0x3260
movq -0x20(%rbp), %rdi
leaq 0x9ba(%rip), %rsi       # 0xb131
callq 0x3250
jmp 0xa77e
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
leaq 0x9a4(%rip), %rsi       # 0xb131
callq 0x3250
jmp 0xa794
movq -0x30(%rbp), %rax
movq $0x0, 0x48(%rax)
movq $0x0, 0x50(%rax)
movq $0x0, 0x60(%rax)
movq $0x0, 0x58(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3110
movq -0x20(%rbp), %rdi
callq 0x3110
movq -0x10(%rbp), %rdi
callq 0x32f0
nopw %cs:(%rax,%rax)
// File: AndreRenaud[P]simple_uart/./acutest.h
// Function: acutest_line_indent_
static void
acutest_line_indent_(int level)
{
    static const char spaces[] = "                ";
    int n = level * 2;

    if(acutest_tap_  &&  n > 0) {
        n--;
        printf("#");
    }

    while(n > 16) {
        printf("%s", spaces);
        n -= 16;
    }
    printf("%.*s", n, spaces);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
shll %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, 0xa9ba(%rip)      # 0xd474
je 0x2ad9
cmpl $0x0, -0x8(%rbp)
jle 0x2ad9
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
leaq 0x6dec(%rip), %rdi      # 0x98be
movb $0x0, %al
callq 0x2160
jmp 0x2adb
cmpl $0x10, -0x8(%rbp)
jle 0x2b01
leaq 0x6e1c(%rip), %rdi      # 0x9904
leaq 0x65b1(%rip), %rsi      # 0x90a0
movb $0x0, %al
callq 0x2160
movl -0x8(%rbp), %eax
subl $0x10, %eax
movl %eax, -0x8(%rbp)
jmp 0x2adb
movl -0x8(%rbp), %esi
leaq 0x6db5(%rip), %rdi      # 0x98c0
leaq 0x658e(%rip), %rdx      # 0x90a0
movb $0x0, %al
callq 0x2160
addq $0x10, %rsp
popq %rbp
retq
nop
// File: AndreRenaud[P]simple_uart/./acutest.h
// Function: acutest_case_
acutest_case_(const char* fmt, ...)
{
    va_list args;

    if(acutest_verbose_level_ < 2)
        return;

    if(acutest_case_name_[0]) {
        acutest_case_already_logged_ = 0;
        acutest_case_name_[0] = '\0';
    }

    if(fmt == NULL)
        return;

    va_start(args, fmt);
    vsnprintf(acutest_case_name_, sizeof(acutest_case_name_) - 1, fmt, args);
    va_end(args);
    acutest_case_name_[sizeof(acutest_case_name_) - 1] = '\0';

    if(acutest_verbose_level_ >= 3) {
        acutest_line_indent_(1);
        acutest_colored_printf_(ACUTEST_COLOR_DEFAULT_INTENSIVE_, "Case %s:\n", acutest_case_name_);
        acutest_test_already_logged_++;
        acutest_case_already_logged_++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x2d85
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
cmpl $0x2, 0xa455(%rip)      # 0xd208
jge 0x2dba
jmp 0x2e73
cmpb $0x0, 0xa57f(%rip)      # 0xd340
je 0x2dd4
movl $0x0, 0xa56b(%rip)      # 0xd338
movb $0x0, 0xa56c(%rip)      # 0xd340
cmpq $0x0, -0x8(%rbp)
jne 0x2de0
jmp 0x2e73
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x8(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq 0xa52d(%rip), %rdi      # 0xd340
movl $0x3f, %esi
callq 0x20b0
leaq -0x20(%rbp), %rax
movb $0x0, 0xa557(%rip)      # 0xd37f
cmpl $0x3, 0xa3d9(%rip)      # 0xd208
jl 0x2e73
movl $0x1, %edi
callq 0x2aa0
movl $0xa, %edi
leaq 0x62d3(%rip), %rsi      # 0x911a
leaq 0xa4f2(%rip), %rdx      # 0xd340
movb $0x0, %al
callq 0x2b70
movl 0xa4c9(%rip), %eax      # 0xd324
addl $0x1, %eax
movl %eax, 0xa4c0(%rip)      # 0xd324
movl 0xa4ce(%rip), %eax      # 0xd338
addl $0x1, %eax
movl %eax, 0xa4c5(%rip)      # 0xd338
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: AndreRenaud[P]simple_uart/./acutest.h
// Function: acutest_message_
acutest_message_(const char* fmt, ...)
{
    char buffer[TEST_MSG_MAXSIZE];
    char* line_beg;
    char* line_end;
    va_list args;

    if(acutest_verbose_level_ < 2)
        return;

    /* We allow extra message only when something is already wrong in the
     * current test. */
    if(acutest_current_test_ == NULL  ||  !acutest_cond_failed_)
        return;

    va_start(args, fmt);
    vsnprintf(buffer, TEST_MSG_MAXSIZE, fmt, args);
    va_end(args);
    buffer[TEST_MSG_MAXSIZE-1] = '\0';

    line_beg = buffer;
    while(1) {
        line_end = strchr(line_beg, '\n');
        if(line_end == NULL)
            break;
        acutest_line_indent_(acutest_case_name_[0] ? 3 : 2);
        printf("%.*s\n", (int)(line_end - line_beg), line_beg);
        line_beg = line_end + 1;
    }
    if(line_beg[0] != '\0') {
        acutest_line_indent_(acutest_case_name_[0] ? 3 : 2);
        printf("%s\n", line_beg);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4f0, %rsp            # imm = 0x4F0
testb %al, %al
je 0x2ec7
movaps %xmm0, -0x4c0(%rbp)
movaps %xmm1, -0x4b0(%rbp)
movaps %xmm2, -0x4a0(%rbp)
movaps %xmm3, -0x490(%rbp)
movaps %xmm4, -0x480(%rbp)
movaps %xmm5, -0x470(%rbp)
movaps %xmm6, -0x460(%rbp)
movaps %xmm7, -0x450(%rbp)
movq %r9, -0x4c8(%rbp)
movq %r8, -0x4d0(%rbp)
movq %rcx, -0x4d8(%rbp)
movq %rdx, -0x4e0(%rbp)
movq %rsi, -0x4e8(%rbp)
movq %rdi, -0x8(%rbp)
cmpl $0x2, 0xa313(%rip)      # 0xd208
jge 0x2efc
jmp 0x302c
cmpq $0x0, 0xa424(%rip)      # 0xd328
je 0x2f0f
cmpl $0x0, 0xa473(%rip)      # 0xd380
jne 0x2f14
jmp 0x302c
leaq -0x440(%rbp), %rax
leaq -0x4f0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq -0x410(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq -0x440(%rbp), %rcx
movl $0x400, %esi            # imm = 0x400
callq 0x20b0
leaq -0x440(%rbp), %rax
movb $0x0, -0x11(%rbp)
leaq -0x410(%rbp), %rax
movq %rax, -0x418(%rbp)
movq -0x418(%rbp), %rdi
movl $0xa, %esi
callq 0x2150
movq %rax, -0x420(%rbp)
cmpq $0x0, -0x420(%rbp)
jne 0x2f94
jmp 0x2fec
movsbl 0xa3a5(%rip), %ecx      # 0xd340
movl $0x2, %edi
movl $0x3, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edi
callq 0x2aa0
movq -0x420(%rbp), %rax
movq -0x418(%rbp), %rcx
subq %rcx, %rax
movl %eax, %esi
movq -0x418(%rbp), %rdx
leaq 0x6153(%rip), %rdi      # 0x9124
movb $0x0, %al
callq 0x2160
movq -0x420(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x418(%rbp)
jmp 0x2f70
movq -0x418(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x302c
movsbl 0xa33e(%rip), %ecx      # 0xd340
movl $0x2, %edi
movl $0x3, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edi
callq 0x2aa0
movq -0x418(%rbp), %rsi
leaq 0x62d9(%rip), %rdi      # 0x92fe
movb $0x0, %al
callq 0x2160
addq $0x4f0, %rsp            # imm = 0x4F0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndreRenaud[P]simple_uart/./acutest.h
// Function: acutest_abort_
void
acutest_abort_(void)
{
    if(acutest_abort_has_jmp_buf_) {
        longjmp(acutest_abort_jmp_buf_, 1);
    } else {
        if(acutest_current_test_ != NULL)
            acutest_fini_(acutest_current_test_->name);
        fflush(stdout);
        fflush(stderr);
        acutest_exit_(ACUTEST_STATE_FAILED);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0xa0e9(%rip)      # 0xd384
je 0x32ae
leaq 0xa0ec(%rip), %rdi      # 0xd390
movl $0x1, %esi
callq 0x22c0
cmpq $0x0, 0xa072(%rip)      # 0xd328
je 0x32c7
movq 0xa069(%rip), %rax      # 0xd328
movq (%rax), %rdi
callq 0x32f0
movq 0x9d0a(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
callq 0x2290
movq 0x9d1b(%rip), %rax      # 0xcff8
movq (%rax), %rdi
callq 0x2290
movl $0x1, %edi
callq 0x3300
nop
// File: AndreRenaud[P]simple_uart/./acutest.h
// Function: acutest_timer_init_
static void
    acutest_timer_init_(void)
    {
        if(acutest_timer_ == 1)
            acutest_timer_id_ = CLOCK_MONOTONIC;
        else if(acutest_timer_ == 2)
            acutest_timer_id_ = CLOCK_PROCESS_CPUTIME_ID;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x1, 0x90d9(%rip)      # 0xd494
jne 0x43c9
movl $0x1, 0x90f1(%rip)      # 0xd4b8
jmp 0x43de
cmpl $0x2, 0x90c4(%rip)      # 0xd494
jne 0x43dc
movl $0x2, 0x90dc(%rip)      # 0xd4b8
jmp 0x43de
popq %rbp
retq
// File: AndreRenaud[P]simple_uart/./acutest.h
// Function: acutest_count_
static int
acutest_count_(enum acutest_state_ state)
{
    int i, n;

    for(i = 0, n = 0; i < acutest_list_size_; i++) {
        if(acutest_test_data_[i].state == state)
            n++;
    }

    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x9066(%rip), %eax      # 0xd464
jge 0x442f
movq 0x9061(%rip), %rax      # 0xd468
movslq -0x8(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x4422
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4424
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x43f5
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndreRenaud[P]simple_uart/simple_uart_test.c
// Function: test_open
void test_open(void)
{
    struct simple_uart *uart;
    pid_t pid;

    pid = setup_loopback();

    uart = simple_uart_open(UART_LOOPBACK_1, 115200, "8N1");
    TEST_ASSERT(uart != NULL);
    simple_uart_close(uart);

    shutdown_loopback(pid);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x48e0
movl %eax, -0xc(%rbp)
leaq 0x4ab8(%rip), %rdi      # 0x931f
movl $0x1c200, %esi          # imm = 0x1C200
leaq 0x4ab7(%rip), %rdx      # 0x932a
callq 0x6a90
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x4a9a(%rip), %rsi      # 0x932e
movl $0x41, %edx
leaq 0x5064(%rip), %rcx      # 0x9904
leaq 0x4a9a(%rip), %r8       # 0x9341
movb $0x0, %al
callq 0x26e0
cmpl $0x0, %eax
jne 0x48b8
callq 0x3290
jmp 0x48ba
movq -0x8(%rbp), %rdi
callq 0x6a20
movl -0xc(%rbp), %edi
callq 0x4980
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndreRenaud[P]simple_uart/simple_uart_test.c
// Function: setup_loopback
static pid_t setup_loopback(void)
{
    pid_t pid;
    char *const args[] = {"socat", "PTY,link=" UART_LOOPBACK_1 ",raw,echo=0,iexten=0",
                          "PTY,link=" UART_LOOPBACK_2 ",raw,echo=0,iexten=0", NULL};
    pid = fork();

    TEST_ASSERT(pid >= 0);

    if (pid == 0) {
        execvp(args[0], args);
    }
    /* Give it time to start */
    usleep(100000);
    return pid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x84c1(%rip), %rax      # 0xcdb0
movq %rax, -0x30(%rbp)
movq 0x84be(%rip), %rax      # 0xcdb8
movq %rax, -0x28(%rbp)
movq 0x84bb(%rip), %rax      # 0xcdc0
movq %rax, -0x20(%rbp)
movq 0x84b8(%rip), %rax      # 0xcdc8
movq %rax, -0x18(%rbp)
callq 0x23a0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
setge %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x49fb(%rip), %rsi      # 0x932e
movl $0x28, %edx
leaq 0x4fc5(%rip), %rcx      # 0x9904
leaq 0x59a8(%rip), %r8       # 0xa2ee
movb $0x0, %al
callq 0x26e0
cmpl $0x0, %eax
jne 0x4957
callq 0x3290
jmp 0x4959
cmpl $0x0, -0x4(%rbp)
jne 0x496c
movq -0x30(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2330
movl $0x186a0, %edi          # imm = 0x186A0
callq 0x23e0
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: AndreRenaud[P]simple_uart/./acutest.h
// Function: acutest_cmdline_handle_short_opt_group_
static int
acutest_cmdline_handle_short_opt_group_(const ACUTEST_CMDLINE_OPTION_* options,
                    const char* arggroup,
                    int (*callback)(int /*optval*/, const char* /*arg*/))
{
    const ACUTEST_CMDLINE_OPTION_* opt;
    int i;
    int ret = 0;

    for(i = 0; arggroup[i] != '\0'; i++) {
        for(opt = options; opt->id != 0; opt++) {
            if(arggroup[i] == opt->shortname)
                break;
        }

        if(opt->id != 0  &&  !(opt->flags & ACUTEST_CMDLINE_OPTFLAG_REQUIREDARG_)) {
            ret = callback(opt->id, NULL);
        } else {
            /* Unknown option. */
            char badoptname[3];
            badoptname[0] = '-';
            badoptname[1] = arggroup[i];
            badoptname[2] = '\0';
            ret = callback((opt->id != 0 ? ACUTEST_CMDLINE_OPTID_MISSINGARG_ : ACUTEST_CMDLINE_OPTID_UNKNOWN_),
                            badoptname);
        }

        if(ret != 0)
            break;
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x5ce3
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x5c62
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x5c52
jmp 0x5c62
jmp 0x5c54
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
jmp 0x5c2f
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x5c91
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x5c91
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movl 0x10(%rcx), %edi
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
movl %eax, -0x28(%rbp)
jmp 0x5ccb
movb $0x2d, -0x2b(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x2a(%rbp)
movb $0x0, -0x29(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movl 0x10(%rcx), %edx
movl $0x80000001, %edi       # imm = 0x80000001
movl $0x80000002, %ecx       # imm = 0x80000002
cmpl $0x0, %edx
cmovnel %ecx, %edi
leaq -0x2b(%rbp), %rsi
callq *%rax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x5cd3
jmp 0x5ce3
jmp 0x5cd5
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5c12
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: AndreRenaud[P]simple_uart/./acutest.h
// Function: acutest_list_names_
static void
acutest_list_names_(void)
{
    const struct acutest_test_* test;

    printf("Unit tests:\n");
    for(test = &acutest_list_[0]; test->func != NULL; test++)
        printf("  %s\n", test->name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x3e42(%rip), %rdi      # 0x9b41
movb $0x0, %al
callq 0x2160
leaq 0x7033(%rip), %rax      # 0xcd40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x5d3f
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x35d2(%rip), %rdi      # 0x92fc
movb $0x0, %al
callq 0x2160
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0x5d11
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndreRenaud[P]simple_uart/./acutest.h
// Function: acutest_select_
static int
acutest_select_(const char* pattern)
{
    int i;
    int n = 0;

    /* Try exact match. */
    for(i = 0; i < acutest_list_size_; i++) {
        if(strcmp(acutest_list_[i].name, pattern) == 0) {
            acutest_test_data_[i].state = ACUTEST_STATE_SELECTED;
            n++;
            break;
        }
    }
    if(n > 0)
        return n;

    /* Try word match. */
    for(i = 0; i < acutest_list_size_; i++) {
        if(acutest_name_contains_word_(acutest_list_[i].name, pattern)) {
            acutest_test_data_[i].state = ACUTEST_STATE_SELECTED;
            n++;
        }
    }
    if(n > 0)
        return n;

    /* Try relaxed match. */
    for(i = 0; i < acutest_list_size_; i++) {
        if(strstr(acutest_list_[i].name, pattern) != NULL) {
            acutest_test_data_[i].state = ACUTEST_STATE_SELECTED;
            n++;
        }
    }

    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x7521(%rip), %eax      # 0xd464
jge 0x5f98
movslq -0x14(%rbp), %rcx
leaq 0x6df0(%rip), %rax      # 0xcd40
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2200
cmpl $0x0, %eax
jne 0x5f8b
movq 0x74f9(%rip), %rax      # 0xd468
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5f98
jmp 0x5f8d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5f3a
cmpl $0x0, -0x18(%rbp)
jle 0x5fa9
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6084
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x74ab(%rip), %eax      # 0xd464
jge 0x600c
movslq -0x14(%rbp), %rcx
leaq 0x6d7a(%rip), %rax      # 0xcd40
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x6090
cmpl $0x0, %eax
je 0x5fff
movq 0x7483(%rip), %rax      # 0xd468
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6001
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5fb0
cmpl $0x0, -0x18(%rbp)
jle 0x601a
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6084
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x743a(%rip), %eax      # 0xd464
jge 0x607e
movslq -0x14(%rbp), %rcx
leaq 0x6d09(%rip), %rax      # 0xcd40
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x23b0
cmpq $0x0, %rax
je 0x6071
movq 0x7411(%rip), %rax      # 0xd468
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6073
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6021
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: AndreRenaud[P]simple_uart/./acutest.h
// Function: acutest_name_contains_word_
static int
acutest_name_contains_word_(const char* name, const char* pattern)
{
    static const char word_delim[] = " \t-_/.,:;";
    const char* substr;
    size_t pattern_len;

    pattern_len = strlen(pattern);

    substr = strstr(name, pattern);
    while(substr != NULL) {
        int starts_on_word_boundary = (substr == name || strchr(word_delim, substr[-1]) != NULL);
        int ends_on_word_boundary = (substr[pattern_len] == '\0' || strchr(word_delim, substr[pattern_len]) != NULL);

        if(starts_on_word_boundary && ends_on_word_boundary)
            return 1;

        substr = strstr(substr+1, pattern);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2130
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x23b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6173
movq -0x20(%rbp), %rcx
movb $0x1, %al
cmpq -0x10(%rbp), %rcx
movb %al, -0x31(%rbp)
je 0x60f6
movq -0x20(%rbp), %rax
movsbl -0x1(%rax), %esi
leaq 0x2fca(%rip), %rdi      # 0x90b1
callq 0x2150
cmpq $0x0, %rax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x32(%rbp)
je 0x6139
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0x2f87(%rip), %rdi      # 0x90b1
callq 0x2150
cmpq $0x0, %rax
setne %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x6159
cmpl $0x0, -0x30(%rbp)
je 0x6159
movl $0x1, -0x4(%rbp)
jmp 0x617a
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
movq -0x18(%rbp), %rsi
callq 0x23b0
movq %rax, -0x20(%rbp)
jmp 0x60be
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndreRenaud[P]simple_uart/./acutest.h
// Function: acutest_error_
acutest_error_(const char* fmt, ...)
{
    if(acutest_verbose_level_ == 0)
        return;

    if(acutest_verbose_level_ >= 2) {
        va_list args;

        acutest_line_indent_(1);
        if(acutest_verbose_level_ >= 3)
            acutest_colored_printf_(ACUTEST_COLOR_RED_INTENSIVE_, "ERROR: ");
        va_start(args, fmt);
        vprintf(fmt, args);
        va_end(args);
        printf("\n");
    }

    if(acutest_verbose_level_ >= 3) {
        printf("\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x61f5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x6fe5(%rip)      # 0xd208
jne 0x622a
jmp 0x62b3
cmpl $0x2, 0x6fd7(%rip)      # 0xd208
jl 0x629c
movl $0x1, %edi
callq 0x2aa0
cmpl $0x3, 0x6fc4(%rip)      # 0xd208
jl 0x6259
movl $0xb, %edi
leaq 0x3fce(%rip), %rsi      # 0xa220
movb $0x0, %al
callq 0x2b70
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x22a0
leaq -0x20(%rbp), %rax
leaq 0x37ea(%rip), %rdi      # 0x9a7f
movb $0x0, %al
callq 0x2160
cmpl $0x3, 0x6f65(%rip)      # 0xd208
jl 0x62b3
leaq 0x37d3(%rip), %rdi      # 0x9a7f
movb $0x0, %al
callq 0x2160
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: AndreRenaud[P]simple_uart/./acutest.h
// Function: acutest_begin_test_line_
static void
acutest_begin_test_line_(const struct acutest_test_* test)
{
    if(!acutest_tap_) {
        if(acutest_verbose_level_ >= 3) {
            acutest_colored_printf_(ACUTEST_COLOR_DEFAULT_INTENSIVE_, "Test %s:\n", test->name);
            acutest_test_already_logged_++;
        } else if(acutest_verbose_level_ >= 1) {
            int n;
            char spaces[48];

            n = acutest_colored_printf_(ACUTEST_COLOR_DEFAULT_INTENSIVE_, "Test %s... ", test->name);
            memset(spaces, ' ', sizeof(spaces));
            if(n < (int) sizeof(spaces))
                printf("%.*s", (int) sizeof(spaces) - n, spaces);
        } else {
            acutest_test_already_logged_ = 1;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x6f21(%rip)      # 0xd474
jne 0x65f6
cmpl $0x3, 0x6ca8(%rip)      # 0xd208
jl 0x658d
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movl $0xa, %edi
leaq 0x3d0d(%rip), %rsi      # 0xa282
movb $0x0, %al
callq 0x2b70
movl 0x6da2(%rip), %eax      # 0xd324
addl $0x1, %eax
movl %eax, 0x6d99(%rip)      # 0xd324
jmp 0x65f4
cmpl $0x1, 0x6c74(%rip)      # 0xd208
jl 0x65e8
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movl $0xa, %edi
leaq 0x3ce3(%rip), %rsi      # 0xa28c
movb $0x0, %al
callq 0x2b70
movl %eax, -0xc(%rbp)
leaq -0x40(%rbp), %rdi
movl $0x20, %esi
movl $0x30, %edx
callq 0x2190
cmpl $0x30, -0xc(%rbp)
jge 0x65e6
movl $0x30, %esi
subl -0xc(%rbp), %esi
leaq -0x40(%rbp), %rdx
leaq 0x32e1(%rip), %rdi      # 0x98c0
movb $0x0, %al
callq 0x2160
jmp 0x65f2
movl $0x1, 0x6d32(%rip)      # 0xd324
jmp 0x65f4
jmp 0x65f6
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)