LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sagardoshi[P]NegotiationsEncounter/src/GameMaster.cpp
// Function: GameMaster::runEnding()
void GameMaster::runEnding() {
    // Should give score at end of most recent level
    float finalScoreFloat = player->getInvValue();

    // Convert score to string for later use
    string finalScore = player->toPreciseString(finalScoreFloat);

    // Modify to output sentence
    string scoreText = "\n\nYou started with £100 in loot. You finished with £";
           scoreText += finalScore + ".\n";

    doSkip = false; // In order to print the final goodbye

    clearScreen(); // To switch to the THE END screen

    // Printouts
    cout << scoreText;
    loadScript("Gen/Ending"); // Generic text for victory or defeat
    cout << endl << endl;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq 0x90(%rax), %rdi
callq 0x12a90
movq -0xc0(%rbp), %rax
movss %xmm0, -0xc(%rbp)
movq 0x90(%rax), %rsi
movss -0xc(%rbp), %xmm0
leaq -0x30(%rbp), %rdi
xorl %edx, %edx
callq 0x11f30
leaq -0x51(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x3520
movq -0xb8(%rbp), %rdx
leaq 0x14ca3(%rip), %rsi     # 0x1c41a
leaq -0x50(%rbp), %rdi
callq 0x3b80
jmp 0x7782
leaq -0x51(%rbp), %rdi
callq 0x3350
leaq 0x1585e(%rip), %rdx     # 0x1cff0
leaq -0x88(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8c30
jmp 0x77a4
leaq -0x50(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x33e0
jmp 0x77b6
leaq -0x88(%rbp), %rdi
callq 0x3200
movq -0xc0(%rbp), %rdi
movb $0x0, 0x6c(%rdi)
callq 0x5670
jmp 0x77d4
movq 0x1f7e5(%rip), %rdi     # 0x26fc0
leaq -0x50(%rbp), %rsi
callq 0x32b0
jmp 0x77e6
leaq -0xa9(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x3520
movq -0xc8(%rbp), %rdx
leaq 0x14c4a(%rip), %rsi     # 0x1c451
leaq -0xa8(%rbp), %rdi
callq 0x3b80
jmp 0x7815
movq -0xc0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x6fa0
jmp 0x782a
leaq -0xa8(%rbp), %rdi
callq 0x3200
leaq -0xa9(%rbp), %rdi
callq 0x3350
movq 0x1f777(%rip), %rdi     # 0x26fc0
movq 0x1f758(%rip), %rsi     # 0x26fa8
callq 0x3330
movq %rax, -0xd0(%rbp)
jmp 0x785e
movq -0xd0(%rbp), %rdi
movq 0x1f73c(%rip), %rsi     # 0x26fa8
callq 0x3330
jmp 0x7873
leaq -0x50(%rbp), %rdi
callq 0x3200
leaq -0x30(%rbp), %rdi
callq 0x3200
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x51(%rbp), %rdi
callq 0x3350
jmp 0x7908
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x78ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x3200
jmp 0x78ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x78f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x3200
leaq -0xa9(%rbp), %rdi
callq 0x3350
leaq -0x50(%rbp), %rdi
callq 0x3200
leaq -0x30(%rbp), %rdi
callq 0x3200
movq -0x60(%rbp), %rdi
callq 0x3510
nopw (%rax,%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/GameMaster.cpp
// Function: GameMaster::endCurrentLevel()
void GameMaster::endCurrentLevel() {
    string outText  = to_string(currLevel) + "/Level" + to_string(currLevel);
    // Load the correct script
    (wonLevel ? (outText += "Win") : (outText += "Lose"));

    doSkip = false; // Allow scripts after encounter
    loadScript(outText); // Text for victory or loss to be run first

    // If lost encounter and not in tutorial, send to end of game
    if (!wonLevel && (currLevel > 0)) currLevel = 5; // Head straight to ending

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movl 0x68(%rax), %esi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x8620
movq -0xc0(%rbp), %rsi
leaq 0x14991(%rip), %rdx     # 0x1c45c
leaq -0x48(%rbp), %rdi
callq 0x8440
jmp 0x7ad6
movq -0xc8(%rbp), %rax
movl 0x68(%rax), %esi
leaq -0x98(%rbp), %rdi
callq 0x8620
jmp 0x7aee
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0x8490
jmp 0x7b04
leaq -0x98(%rbp), %rdi
callq 0x3200
leaq -0x48(%rbp), %rdi
callq 0x3200
leaq -0x68(%rbp), %rdi
callq 0x3200
movq -0xc8(%rbp), %rax
testb $0x1, 0x6d(%rax)
je 0x7b43
leaq 0x14933(%rip), %rsi     # 0x1c469
leaq -0x28(%rbp), %rdi
callq 0x32d0
jmp 0x7b41
jmp 0x7b57
leaq 0x14923(%rip), %rsi     # 0x1c46d
leaq -0x28(%rbp), %rdi
callq 0x32d0
jmp 0x7b55
jmp 0x7b57
movq -0xc8(%rbp), %rax
movb $0x0, 0x6c(%rax)
leaq -0xb8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3170
jmp 0x7b74
movq -0xc8(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x6fa0
jmp 0x7b89
leaq -0xb8(%rbp), %rdi
callq 0x3200
movq -0xc8(%rbp), %rax
testb $0x1, 0x6d(%rax)
jne 0x7c37
movq -0xc8(%rbp), %rax
cmpl $0x0, 0x68(%rax)
jle 0x7c37
movq -0xc8(%rbp), %rax
movl $0x5, 0x68(%rax)
jmp 0x7c37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x7c04
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x7bfb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x3200
leaq -0x48(%rbp), %rdi
callq 0x3200
leaq -0x68(%rbp), %rdi
callq 0x3200
jmp 0x7c52
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x7c49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x3200
jmp 0x7c49
leaq -0x28(%rbp), %rdi
callq 0x3200
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x3200
movq -0x70(%rbp), %rdi
callq 0x3510
nopl (%rax,%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/GameMaster.cpp
// Function: GameMaster::playGame()
void GameMaster::playGame() {
    // Ugly, but the cost of the GameMaster class are these frequent quit checks

    startScreen(); // Ask to skip intro
    if (uInput == "quit") return; // For every new entry, check for quit

    if (currLevel == 0) runIntro(); // Runs intro
    if (uInput == "quit") return; // For every new entry, check for quit

    while (currLevel < NUM_LEVELS) {
        runNextLevel();
        if (uInput == "quit") return; // For every new entry, check for quit
    }

    if (currLevel > 4) runEnding();
    if (uInput == "quit") return; // For every new entry, check for quit

    gameFinished = true;


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x6000
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
leaq 0x14718(%rip), %rsi     # 0x1c3a0
callq 0x8a80
testb $0x1, %al
jne 0x7c93
jmp 0x7c98
jmp 0x7d34
movq -0x10(%rbp), %rax
cmpl $0x0, 0x68(%rax)
jne 0x7cab
movq -0x10(%rbp), %rdi
callq 0x7470
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
leaq 0x146e6(%rip), %rsi     # 0x1c3a0
callq 0x8a80
testb $0x1, %al
jne 0x7cc5
jmp 0x7cc7
jmp 0x7d34
jmp 0x7cc9
movq -0x10(%rbp), %rcx
movl 0x68(%rcx), %eax
cmpl (%rcx), %eax
jge 0x7cfd
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x7580
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
leaq 0x146b2(%rip), %rsi     # 0x1c3a0
callq 0x8a80
testb $0x1, %al
jne 0x7cf9
jmp 0x7cfb
jmp 0x7d34
jmp 0x7cc9
movq -0x10(%rbp), %rax
cmpl $0x4, 0x68(%rax)
jle 0x7d10
movq -0x10(%rbp), %rdi
callq 0x7710
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
leaq 0x14681(%rip), %rsi     # 0x1c3a0
callq 0x8a80
testb $0x1, %al
jne 0x7d2a
jmp 0x7d2c
jmp 0x7d34
movq -0x10(%rbp), %rax
movb $0x1, 0x6e(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/Encounter.cpp
// Function: Encounter::setInventoryForEncounter()
void Encounter::setInventoryForEncounter() {
    mapPlayerInventory(); // Order all the player's inventory for encounter
    opponent->resetGenerosity(); // Ensure no offer at start of encounter

    // Calculate open market value of inventory at start of encounter
    startInvValue = player->getInvValue();
    offerInvValue = 0.0; // init to zero
    endInvValue = 0.0; // init to zero
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xec50
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x16af0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x12a90
movq -0x10(%rbp), %rax
movss %xmm0, 0x28(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x2c(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/Encounter.cpp
// Function: Encounter::mapPlayerInventory()
void Encounter::mapPlayerInventory() {
    map<string, int>::iterator it;
    string item = "";
    int amount = 0;
    int itemOrder = 1;

    for (it = player->inventory.begin(); it != player->inventory.end(); it++) {
        item = it->first;
        amount = it->second;

        if (amount > 0) {
            invMap[item] = itemOrder;
            itemOrder++;
        }
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x8740
leaq -0x31(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3520
movq -0x70(%rbp), %rdx
leaq 0xd740(%rip), %rsi      # 0x1c3c8
leaq -0x30(%rbp), %rdi
callq 0x3b80
jmp 0xec93
leaq -0x31(%rbp), %rdi
callq 0x3350
movq -0x78(%rbp), %rax
movl $0x0, -0x48(%rbp)
movl $0x1, -0x4c(%rbp)
movq 0x10(%rax), %rdi
addq $0x38, %rdi
callq 0x8760
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x78(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x38, %rdi
callq 0x87c0
movq %rax, -0x60(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x8790
testb $0x1, %al
jne 0xecf2
jmp 0xed99
leaq -0x10(%rbp), %rdi
callq 0x87f0
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x3050
jmp 0xed09
leaq -0x10(%rbp), %rdi
callq 0x87f0
movl 0x20(%rax), %eax
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x48(%rbp)
jle 0xed83
movq -0x78(%rbp), %rdi
movl -0x4c(%rbp), %eax
movl %eax, -0x84(%rbp)
addq $0x38, %rdi
leaq -0x30(%rbp), %rsi
callq 0x8890
movq %rax, -0x80(%rbp)
jmp 0xed3e
movq -0x80(%rbp), %rax
movl -0x84(%rbp), %ecx
movl %ecx, (%rax)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0xed83
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x3350
jmp 0xedab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3200
jmp 0xedab
jmp 0xed85
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x8810
movq %rax, -0x68(%rbp)
jmp 0xecc7
leaq -0x30(%rbp), %rdi
callq 0x3200
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3510
nopw %cs:(%rax,%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/Encounter.cpp
// Function: Encounter::printTitle(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Encounter::printTitle(string textToSay) {
    const int WIDTH = 80;

    string title  = "\n\n" + string(WIDTH, '=') + "\n";
           centerText(textToSay, title);
           title += string(WIDTH, '=') + "\n\n\n";

    cout << title;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rsi, -0x110(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x108(%rbp)
movl $0x50, -0x14(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x3520
movq -0x100(%rbp), %rcx
leaq -0x78(%rbp), %rdi
movl $0x50, %esi
movl $0x3d, %edx
callq 0x85b0
jmp 0xf468
leaq 0xcf57(%rip), %rsi      # 0x1c3c6
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x11340
jmp 0xf47e
leaq 0xcf42(%rip), %rdx      # 0x1c3c7
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x8440
jmp 0xf494
leaq -0x58(%rbp), %rdi
callq 0x3200
leaq -0x78(%rbp), %rdi
callq 0x3200
leaq -0x79(%rbp), %rdi
callq 0x3350
movq -0x110(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x3170
jmp 0xf4c4
movq -0x108(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0xee80
jmp 0xf4dd
leaq -0xb0(%rbp), %rdi
callq 0x3200
leaq -0xf1(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x3520
movq -0x118(%rbp), %rcx
leaq -0xf0(%rbp), %rdi
movl $0x50, %esi
movl $0x3d, %edx
callq 0x85b0
jmp 0xf51b
leaq 0xcea3(%rip), %rdx      # 0x1c3c5
leaq -0xd0(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x8440
jmp 0xf537
leaq -0x38(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x33e0
jmp 0xf549
leaq -0xd0(%rbp), %rdi
callq 0x3200
leaq -0xf0(%rbp), %rdi
callq 0x3200
leaq -0xf1(%rbp), %rdi
callq 0x3350
movq 0x17a4c(%rip), %rdi     # 0x26fc0
leaq -0x38(%rbp), %rsi
callq 0x32b0
jmp 0xf57f
leaq -0x38(%rbp), %rdi
callq 0x3200
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xf5dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xf5d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3200
leaq -0x78(%rbp), %rdi
callq 0x3200
leaq -0x79(%rbp), %rdi
callq 0x3350
jmp 0xf686
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xf67d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x3200
jmp 0xf67d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xf671
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xf665
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x3200
leaq -0xf0(%rbp), %rdi
callq 0x3200
leaq -0xf1(%rbp), %rdi
callq 0x3350
leaq -0x38(%rbp), %rdi
callq 0x3200
movq -0x88(%rbp), %rdi
callq 0x3510
nopw %cs:(%rax,%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/Encounter.cpp
// Function: Encounter::isNum(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool Encounter::isNum(string &input) {
    string::const_iterator it = input.begin();

    // Advance iterator as long as every character in string is a digit
    while (it != input.end() && isdigit(*it)) ++it;

    // Return true if not empty AND iterator has reached the end
    return ( !input.empty() && (it == input.end()) );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3290
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8b90
movq -0x10(%rbp), %rdi
callq 0x31d0
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x11390
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x31(%rbp)
jne 0xf7f2
jmp 0xf80c
leaq -0x18(%rbp), %rdi
callq 0x113d0
movsbl (%rax), %edi
callq 0x32c0
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xf815
jmp 0xf820
leaq -0x18(%rbp), %rdi
callq 0x113f0
jmp 0xf7ca
movq -0x10(%rbp), %rdi
callq 0x34e0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x32(%rbp)
jne 0xf852
movq -0x10(%rbp), %rdi
callq 0x31d0
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x11410
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/Encounter.cpp
// Function: Encounter::remapKeyword(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void Encounter::remapKeyword(string &keyword) {
    if (!isNum(keyword)) return; // Only do this for number inputs

    // Keyword should come in as number
    int keyNumber = stoi(keyword);

    // Re-save it as the appropriate string
    map<string, int>::iterator it;
    string currentItem = "";
    int currentOrder;

    for (it = invMap.begin(); it != invMap.end(); it++) {
        currentItem = it->first;
        currentOrder = it->second;

        // If the invMap leads to the player's entry, save that string mapping
        if (currentOrder == keyNumber) {
            keyword = currentItem;
            return;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq -0x10(%rbp), %rsi
callq 0xf7a0
testb $0x1, %al
jne 0xf88d
jmp 0xf9b7
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x8850
movl %eax, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x8740
leaq -0x41(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3520
movq -0x88(%rbp), %rdx
leaq 0xcaff(%rip), %rsi      # 0x1c3c8
leaq -0x40(%rbp), %rdi
callq 0x3b80
jmp 0xf8d4
leaq -0x41(%rbp), %rdi
callq 0x3350
movq -0x80(%rbp), %rdi
addq $0x38, %rdi
callq 0x8760
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x80(%rbp), %rdi
addq $0x38, %rdi
callq 0x87c0
movq %rax, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x8790
testb $0x1, %al
jne 0xf91d
jmp 0xf9a7
leaq -0x20(%rbp), %rdi
callq 0x87f0
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x3050
jmp 0xf934
leaq -0x20(%rbp), %rdi
callq 0x87f0
movl 0x20(%rax), %eax
movl %eax, -0x58(%rbp)
movl -0x58(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0xf991
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3050
jmp 0xf95a
movl $0x1, -0x6c(%rbp)
jmp 0xf9ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x3350
jmp 0xf9c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3200
jmp 0xf9c0
jmp 0xf993
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x8810
movq %rax, -0x78(%rbp)
jmp 0xf8f6
movl $0x0, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3200
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3510
nopl (%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/Encounter.cpp
// Function: Encounter::userEntry(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Encounter::userEntry(string &keyword, string &echo, string prompt) {
    // This creates the user prompt
    printTitle(prompt);

    // Print echo below prompt but above entry area
    if (echo != "") cout << echo;
    echo = ""; // Reset to blank either way

    // Take in and process user entry
    cout << ">>>> ";
    getline(cin, keyword);
    lower(keyword);
    removeWS(keyword);
    remapKeyword(keyword); // In case user put item num, switch to item string
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rcx, -0x68(%rbp)
movq %rsi, %rax
movq -0x68(%rbp), %rsi
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3170
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0xf410
jmp 0xfa17
leaq -0x40(%rbp), %rdi
callq 0x3200
movq -0x18(%rbp), %rdi
leaq 0xc99d(%rip), %rsi      # 0x1c3c8
callq 0x8bd0
testb $0x1, %al
jne 0xfa36
jmp 0xfa5f
movq -0x18(%rbp), %rsi
movq 0x1757f(%rip), %rdi     # 0x26fc0
callq 0x32b0
jmp 0xfa5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3200
jmp 0xfabf
movq -0x18(%rbp), %rdi
leaq 0xc95e(%rip), %rsi      # 0x1c3c8
callq 0x3400
movq 0x1754a(%rip), %rdi     # 0x26fc0
leaq 0xc928(%rip), %rsi      # 0x1c3a5
callq 0x32e0
movq -0x10(%rbp), %rsi
movq 0x1754b(%rip), %rdi     # 0x26fd8
callq 0x30b0
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf6a0
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf710
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf860
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3510
nopl (%rax,%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/Encounter.cpp
// Function: Encounter::printHelp()
void Encounter::printHelp() {
    string optText  = "";
           optText += "Add items one by one to the table with their ";
           optText += "corresponding number on the left.\n";
           optText += "When ready, type \"propose\" to finalise your offer ";
           optText += "or \"cancel\" to undo it.\n\n";

           optText += "propose:  type this to send your current offer\n";
           optText += "cancel:   take your current offer off the table\n\n";

           optText += "turns:    see how many turns you have left\n";
           optText += "strategy: see strategy hints\n";
           optText += "help:     see this menu\n";
           optText += "<RETURN>: dismiss help / go to negotiating table\n\n";

           optText += "forfeit:  admit defeat in this encounter\n";
           optText += "quit:     immediately exit the game\n";

    cout << optText;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3520
movq -0x48(%rbp), %rdx
leaq 0xc554(%rip), %rsi      # 0x1c3c8
leaq -0x28(%rbp), %rdi
callq 0x3b80
jmp 0xfe7f
leaq -0x29(%rbp), %rdi
callq 0x3350
leaq 0xc9e3(%rip), %rsi      # 0x1c872
leaq -0x28(%rbp), %rdi
callq 0x32d0
jmp 0xfe9a
leaq 0xc9ff(%rip), %rsi      # 0x1c8a0
leaq -0x28(%rbp), %rdi
callq 0x32d0
jmp 0xfeac
leaq 0xca10(%rip), %rsi      # 0x1c8c3
leaq -0x28(%rbp), %rdi
callq 0x32d0
jmp 0xfebe
leaq 0xca31(%rip), %rsi      # 0x1c8f6
leaq -0x28(%rbp), %rdi
callq 0x32d0
jmp 0xfed0
leaq 0xca39(%rip), %rsi      # 0x1c910
leaq -0x28(%rbp), %rdi
callq 0x32d0
jmp 0xfee2
leaq 0xca57(%rip), %rsi      # 0x1c940
leaq -0x28(%rbp), %rdi
callq 0x32d0
jmp 0xfef4
leaq 0xca77(%rip), %rsi      # 0x1c972
leaq -0x28(%rbp), %rdi
callq 0x32d0
jmp 0xff06
leaq 0xca91(%rip), %rsi      # 0x1c99e
leaq -0x28(%rbp), %rdi
callq 0x32d0
jmp 0xff18
leaq 0xca9d(%rip), %rsi      # 0x1c9bc
leaq -0x28(%rbp), %rdi
callq 0x32d0
jmp 0xff2a
leaq 0xcaa4(%rip), %rsi      # 0x1c9d5
leaq -0x28(%rbp), %rdi
callq 0x32d0
jmp 0xff3c
leaq 0xcac5(%rip), %rsi      # 0x1ca08
leaq -0x28(%rbp), %rdi
callq 0x32d0
jmp 0xff4e
leaq 0xcadd(%rip), %rsi      # 0x1ca32
leaq -0x28(%rbp), %rdi
callq 0x32d0
jmp 0xff60
movq 0x17059(%rip), %rdi     # 0x26fc0
leaq -0x28(%rbp), %rsi
callq 0x32b0
jmp 0xff72
leaq -0x28(%rbp), %rdi
callq 0x3200
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x3350
jmp 0xffad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3200
movq -0x38(%rbp), %rdi
callq 0x3510
nopw %cs:(%rax,%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/Encounter.cpp
// Function: Encounter::encounterIsOver(bool&)
bool Encounter::encounterIsOver(bool &didWin) {
    // Fill win with true or false, depending on acceptance
    didWin = opponent->reactToOffer(table, keyValue);

    // In case over, save last value into encounter history
    endInvValue = player->getInvValue();

    // If won or if didn't win and no turns left
    if (didWin || (!didWin && turns <= 1)) return true;
    else { // but turns are left, must return items to inventory and continue
        turns--; // Use one turn
        player->takeBackOffer(table);
        opponent->rejectTerms(turns, isPrologue);
        return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x18(%rax), %rdi
movq 0x20(%rax), %rsi
movss 0x8(%rax), %xmm0
callq 0x16b90
movb %al, %dl
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
andb $0x1, %dl
movb %dl, (%rcx)
movq 0x10(%rax), %rdi
callq 0x12a90
movq -0x20(%rbp), %rax
movss %xmm0, 0x30(%rax)
movq -0x18(%rbp), %rax
testb $0x1, (%rax)
jne 0x10067
movq -0x18(%rbp), %rax
testb $0x1, (%rax)
jne 0x1006d
movq -0x20(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jg 0x1006d
movb $0x1, -0x1(%rbp)
jmp 0x100a2
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movq 0x10(%rax), %rdi
movq 0x20(%rax), %rsi
callq 0x1b080
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movl 0x4(%rax), %esi
movb (%rax), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x17350
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/Encounter.cpp
// Function: Encounter::handleEnd(bool)
void Encounter::handleEnd(bool didWin) {
    clearScreen(); // To remove the "YOU ARE NEGOTIATING VS." title

    string textToSay = "";
    if (didWin) textToSay = "YOU WON AGAINST " + getCapsName();
    else textToSay = "YOU LOST AGAINST " + getCapsName();

    printTitle(textToSay);
    if (didWin) {
        printScore();
        opponent->acceptTerms();
    } else player->takeBackOffer(table); // Returns stuff to you if loss ≠ end
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0xf340
leaq -0x31(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x3520
movq -0xf0(%rbp), %rdx
leaq 0xbe03(%rip), %rsi      # 0x1c3c8
leaq -0x30(%rbp), %rdi
callq 0x3b80
jmp 0x105d0
leaq -0x31(%rbp), %rdi
callq 0x3350
testb $0x1, -0x9(%rbp)
je 0x10680
movq -0xf8(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0xedc0
jmp 0x105f8
leaq 0xc4ff(%rip), %rsi      # 0x1cafe
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x11340
jmp 0x10611
leaq -0x30(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x3390
leaq -0x68(%rbp), %rdi
callq 0x3200
leaq -0x88(%rbp), %rdi
callq 0x3200
jmp 0x106f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x3350
jmp 0x107a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x10797
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x3200
jmp 0x10797
movq -0xf8(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
callq 0xedc0
jmp 0x10695
leaq 0xc473(%rip), %rsi      # 0x1cb0f
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rdx
callq 0x11340
jmp 0x106b1
leaq -0x30(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x3390
leaq -0xa8(%rbp), %rdi
callq 0x3200
leaq -0xc8(%rbp), %rdi
callq 0x3200
jmp 0x106f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x3200
jmp 0x10797
leaq -0xe8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3170
jmp 0x1070a
movq -0xf8(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0xf410
jmp 0x1071f
leaq -0xe8(%rbp), %rdi
callq 0x3200
testb $0x1, -0x9(%rbp)
je 0x1076d
movq -0xf8(%rbp), %rdi
callq 0x100b0
jmp 0x1073f
movq -0xf8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x16e60
jmp 0x10751
jmp 0x10785
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x3200
jmp 0x10797
movq -0xf8(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0x20(%rax), %rsi
callq 0x1b080
jmp 0x10783
jmp 0x10785
leaq -0x30(%rbp), %rdi
callq 0x3200
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x3200
movq -0x40(%rbp), %rdi
callq 0x3510
nopl (%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/Inventory.cpp
// Function: Inventory::toPreciseString[abi:cxx11](float, int)
string Inventory::toPreciseString(float input, int precision) {
    string asString = to_string(input);

    int decimalIndex = asString.find(".");
    int cutoff = decimalIndex + 1 + precision;

    // Don't include decimal if zero floats desired
    if (precision == 0) return asString.substr(0, decimalIndex);
    else return asString.substr(0, cutoff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movss -0x14(%rbp), %xmm0
leaq -0x38(%rbp), %rdi
callq 0x13710
leaq -0x38(%rbp), %rdi
leaq 0xa432(%rip), %rsi      # 0x1c39e
xorl %eax, %eax
movl %eax, %edx
callq 0x3570
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
addl -0x18(%rbp), %eax
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x11fc1
movq -0x60(%rbp), %rdi
movslq -0x3c(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x38(%rbp), %rsi
callq 0x3310
jmp 0x11fa1
movl $0x1, -0x50(%rbp)
jmp 0x11fdf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3200
jmp 0x11ff2
movq -0x60(%rbp), %rdi
movslq -0x40(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x38(%rbp), %rsi
callq 0x3310
jmp 0x11fd8
movl $0x1, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3200
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3510
nopl (%rax,%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/Inventory.cpp
// Function: Inventory::getInvCount()
int Inventory::getInvCount() {
    map<string, int>::iterator it;
    int total = 0, amount = 0;
    for (it = inventory.begin(); it != inventory.end(); it++) {
        amount = it->second;
        total += amount;
    }
    return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x8740
movq -0x38(%rbp), %rdi
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
addq $0x38, %rdi
callq 0x8760
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
callq 0x87c0
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8790
testb $0x1, %al
jne 0x12a28
jmp 0x12a51
leaq -0x10(%rbp), %rdi
callq 0x87f0
movl 0x20(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x8810
movq %rax, -0x30(%rbp)
jmp 0x12a04
movl -0x14(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/Inventory.cpp
// Function: Inventory::getInvValue()
float Inventory::getInvValue() {
    map<string, int>::iterator it;
    string itemName = "";
    float baseValue = 0.0, totalValue = 0.0;
    int quantity = 0;

    // Multiply each inventory item's base value by amount held and sum up
    for (it = inventory.begin(); it != inventory.end(); it++) {
        itemName = it->first;
        quantity = it->second;
        baseValue = economy[itemName];
        totalValue += (baseValue * quantity);
    }

    latestInvValue = totalValue; // Update latestInvValue;

    return latestInvValue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x8740
leaq -0x31(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3520
movq -0x70(%rbp), %rdx
leaq 0x9900(%rip), %rsi      # 0x1c3c8
leaq -0x30(%rbp), %rdi
callq 0x3b80
jmp 0x12ad3
leaq -0x31(%rbp), %rdi
callq 0x3350
movq -0x78(%rbp), %rdi
xorps %xmm0, %xmm0
movss %xmm0, -0x48(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x4c(%rbp)
movl $0x0, -0x50(%rbp)
addq $0x38, %rdi
callq 0x8760
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x78(%rbp), %rdi
addq $0x38, %rdi
callq 0x87c0
movq %rax, -0x60(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x8790
testb $0x1, %al
jne 0x12b33
jmp 0x12bdb
leaq -0x10(%rbp), %rdi
callq 0x87f0
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x3050
jmp 0x12b4a
leaq -0x10(%rbp), %rdi
callq 0x87f0
movq -0x78(%rbp), %rdi
movl 0x20(%rax), %eax
movl %eax, -0x50(%rbp)
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
callq 0x8890
movq %rax, -0x80(%rbp)
jmp 0x12b70
movq -0x80(%rbp), %rax
cvtsi2ssl (%rax), %xmm0
movss %xmm0, -0x48(%rbp)
movss -0x48(%rbp), %xmm0
cvtsi2ssl -0x50(%rbp), %xmm2
movss -0x4c(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x4c(%rbp)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x8810
movq %rax, -0x68(%rbp)
jmp 0x12b0c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x3350
jmp 0x12c0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3200
jmp 0x12c0e
movq -0x78(%rbp), %rax
movss -0x4c(%rbp), %xmm0
movss %xmm0, (%rax)
movss (%rax), %xmm0
movss %xmm0, -0x84(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3200
movss -0x84(%rbp), %xmm0
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3510
nopw (%rax,%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/Negotiator.cpp
// Function: Negotiator::getRandWeight()
float Negotiator::getRandWeight() {
    unsigned seed = chrono::system_clock::now().time_since_epoch().count();
    default_random_engine generator (seed);
    uniform_int_distribution<int> distribution(1, 100);
    return distribution(generator) / 100.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
callq 0x3070
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x17c10
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x17c30
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0x17c50
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
movl $0x64, %edx
callq 0x17c80
leaq -0x30(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x17cb0
cvtsi2sd %eax, %xmm0
movsd 0x62a0(%rip), %xmm1     # 0x1ce18
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/Negotiator.cpp
// Function: Negotiator::handlePrologueRejection(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void Negotiator::handlePrologueRejection(int turnsLeft, string &rejection) {
    switch (turnsLeft) {
        case 2:
            rejection += "Unfortunately, this seems inevitable. Of course she ";
            rejection += "won't accept your clothes\nfor a deal! What were ";
            rejection += "you thinking? But all you can do is keep trying.\n\n";
            rejection += "Two more attempts left to go before she runs out of ";
            rejection += "patience. You can sense it.\n\n";
            break;
        case 1:
            rejection += "You put your clothes back on, humiliated by this ";
            rejection += "ordeal. Is she amused by you?\nDisgusted? You can't ";
            rejection += "tell. There's nothing for it. One more doomed ";
            rejection += "offer to go.\n\nHopefully she won't just ";
            rejection += "squash you where you stand. The odds don't exactly ";
            rejection += "seem\ngood...\n\n";
            break;
        default:
            break;
    }

    cout << rejection;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x1, %eax
je 0x172d0
jmp 0x17270
movl -0x1c(%rbp), %eax
subl $0x2, %eax
jne 0x17332
jmp 0x1727e
movq -0x18(%rbp), %rdi
leaq 0x5f60(%rip), %rsi      # 0x1d1e9
callq 0x32d0
movq -0x18(%rbp), %rdi
leaq 0x5f85(%rip), %rsi      # 0x1d21e
callq 0x32d0
movq -0x18(%rbp), %rdi
leaq 0x5fa6(%rip), %rsi      # 0x1d24f
callq 0x32d0
movq -0x18(%rbp), %rdi
leaq 0x5fc9(%rip), %rsi      # 0x1d282
callq 0x32d0
movq -0x18(%rbp), %rdi
leaq 0x5fee(%rip), %rsi      # 0x1d2b7
callq 0x32d0
jmp 0x17334
movq -0x18(%rbp), %rdi
leaq 0x5ffa(%rip), %rsi      # 0x1d2d5
callq 0x32d0
movq -0x18(%rbp), %rdi
leaq 0x601c(%rip), %rsi      # 0x1d307
callq 0x32d0
movq -0x18(%rbp), %rdi
leaq 0x6040(%rip), %rsi      # 0x1d33b
callq 0x32d0
movq -0x18(%rbp), %rdi
leaq 0x605f(%rip), %rsi      # 0x1d36a
callq 0x32d0
movq -0x18(%rbp), %rdi
leaq 0x6077(%rip), %rsi      # 0x1d392
callq 0x32d0
movq -0x18(%rbp), %rdi
leaq 0x609b(%rip), %rsi      # 0x1d3c6
callq 0x32d0
jmp 0x17334
jmp 0x17334
movq -0x18(%rbp), %rsi
movq 0xfc81(%rip), %rdi      # 0x26fc0
callq 0x32b0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/PlayerCharacter.cpp
// Function: PlayerCharacter::takeBackOffer(Inventory*)
void PlayerCharacter::takeBackOffer(Inventory* table) {
    map<string, int>::iterator it;
    string item = "";
    int amount = 0;

    for (it = table->inventory.begin(); it != table->inventory.end(); it++) {
        item = it->first;
        amount = it->second;
        if (amount > 0) {
            table->inventory[item] = 0; // Take item(s) off table
            inventory[item] += amount;  // Put item(s) back into bag

        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x8740
leaq -0x39(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3520
movq -0x70(%rbp), %rdx
leaq 0x130c(%rip), %rsi      # 0x1c3c8
leaq -0x38(%rbp), %rdi
callq 0x3b80
jmp 0x1b0c7
leaq -0x39(%rbp), %rdi
callq 0x3350
movl $0x0, -0x50(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x8760
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x87c0
movq %rax, -0x60(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x8790
testb $0x1, %al
jne 0x1b117
jmp 0x1b1e2
leaq -0x18(%rbp), %rdi
callq 0x87f0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x3050
jmp 0x1b12e
leaq -0x18(%rbp), %rdi
callq 0x87f0
movl 0x20(%rax), %eax
movl %eax, -0x50(%rbp)
cmpl $0x0, -0x50(%rbp)
jle 0x1b1cc
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
leaq -0x38(%rbp), %rsi
callq 0x8890
movq %rax, -0x80(%rbp)
jmp 0x1b15e
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rax
movl $0x0, (%rax)
movl -0x50(%rbp), %eax
movl %eax, -0x8c(%rbp)
addq $0x38, %rdi
leaq -0x38(%rbp), %rsi
callq 0x8890
movq %rax, -0x88(%rbp)
jmp 0x1b18b
movq -0x88(%rbp), %rax
movl -0x8c(%rbp), %ecx
addl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x1b1cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x3350
jmp 0x1b1f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3200
jmp 0x1b1f4
jmp 0x1b1ce
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x8810
movq %rax, -0x68(%rbp)
jmp 0x1b0f0
leaq -0x38(%rbp), %rdi
callq 0x3200
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3510
// File: nmmmnu[P]HM3/test/test_checkedvalue.cc
// Function: void test_pass<CalcError, (CalcError)0, (CalcError)2>(bool)
void test_pass(bool const success){
	constexpr int n = 5;

	const float dividor	= success ? 1 : 0;
	const auto  expected	= success ? OK : ERR;

	const auto v = test_function<T, OK, ERR>(n, dividor);

	PRINTF_TEST("bool",	v == success		);
	PRINTF_TEST("code()",	v.code() == expected	);

	if (success)
	PRINTF_TEST("get()",	v.get() == n		);

	printf("\n");
}

// Assembly:
subq $0x18, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x17(%rsp)
movl $0x5, 0x10(%rsp)
movb 0x17(%rsp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, 0xc(%rsp)
movb 0x17(%rsp), %dl
movl $0x2, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x8(%rsp)
movss 0xc(%rsp), %xmm1
movss 0xdf1(%rip), %xmm0      # 0x2004
callq 0x1310
movq %rax, (%rsp)
movq %rsp, %rdi
callq 0x1370
andb $0x1, %al
movzbl %al, %edx
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
leaq 0xdfc(%rip), %rcx       # 0x2035
leaq 0xdf2(%rip), %rax       # 0x2032
cmpl %esi, %edx
cmoveq %rax, %rcx
leaq 0xdbb(%rip), %rdi       # 0x2008
leaq 0xdcc(%rip), %rsi       # 0x2020
leaq 0xdd2(%rip), %rdx       # 0x202d
movb $0x0, %al
callq 0x1030
movq %rsp, %rdi
callq 0x1390
movl %eax, %edx
movl 0x8(%rsp), %esi
leaq 0xdbe(%rip), %rcx       # 0x2035
leaq 0xdb4(%rip), %rax       # 0x2032
cmpl %esi, %edx
cmoveq %rax, %rcx
leaq 0xd7d(%rip), %rdi       # 0x2008
leaq 0xd8e(%rip), %rsi       # 0x2020
leaq 0xda1(%rip), %rdx       # 0x203a
movb $0x0, %al
callq 0x1030
testb $0x1, 0x17(%rsp)
je 0x12f6
movq %rsp, %rdi
callq 0x13a0
movss (%rax), %xmm0
movss 0xd49(%rip), %xmm1      # 0x2004
leaq 0xd73(%rip), %rcx       # 0x2035
leaq 0xd69(%rip), %rax       # 0x2032
ucomiss %xmm1, %xmm0
setnp %sil
sete %dl
testb %sil, %dl
cmovneq %rax, %rcx
leaq 0xd27(%rip), %rdi       # 0x2008
leaq 0xd38(%rip), %rsi       # 0x2020
leaq 0xd52(%rip), %rdx       # 0x2041
movb $0x0, %al
callq 0x1030
leaq 0xd21(%rip), %rdi       # 0x201e
movb $0x0, %al
callq 0x1030
addq $0x18, %rsp
retq
nopl (%rax)
// File: ivanzamanov[P]kmeans/src/kmeans/kmeans.cpp
// Function: expandVector(vector&)
void expandVector(vector& v) {
	int* new_keys = new int[v.size+1];
	double* new_values = new double[v.size+1];
	for(int i=0; i<v.size; i++) {
		new_keys[i] = v.keys[i];
		new_values[i] = v.values[i];
	}

	if(v.keys != 0)
		delete v.keys;
	if(v.values != 0)
		delete v.values;

	v.size++;
	v.keys = new_keys;
	v.values = new_values;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movl (%rax), %eax
addl $0x1, %eax
cltq
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movl (%rax), %eax
addl $0x1, %eax
cltq
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x131f
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x1c(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x28(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x12c5
movq 0x30(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x134b
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x1349
movq 0x10(%rsp), %rdi
callq 0x10b0
jmp 0x134b
movq 0x30(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1377
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1375
movq 0x8(%rsp), %rdi
callq 0x10b0
jmp 0x1377
movq 0x30(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ivanzamanov[P]kmeans/src/kmeans/kmeans.cpp
// Function: scalar(vector const&, vector const&)
double scalar(const vector& v1, const vector& v2) {
	double result = 0;
	int i1 = 0, i2 = 0;
	while(i1 < v1.size && i2 < v2.size) {
		if(v1.keys[i1] == v2.keys[i2]) {
			result += v1.values[i1] * v2.values[i2];
			i1++;
			i2++;
		} else if (v1.keys[i1] < v2.keys[i2]) {
			i1++;
		} else {
			i2++;
		}
	}
	return result;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movl $0x0, -0x20(%rsp)
movl -0x1c(%rsp), %ecx
movq -0x8(%rsp), %rdx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0x21(%rsp)
jge 0x13f8
movl -0x20(%rsp), %eax
movq -0x10(%rsp), %rcx
cmpl (%rcx), %eax
setl %al
movb %al, -0x21(%rsp)
movb -0x21(%rsp), %al
testb $0x1, %al
jne 0x1405
jmp 0x14be
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x20(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x147b
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq -0x20(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x18(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rsp)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x14b9
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x20(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x14ac
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x14b7
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x14b9
jmp 0x13d3
movsd -0x18(%rsp), %xmm0
retq
nopw %cs:(%rax,%rax)
// File: ivanzamanov[P]kmeans/src/kmeans/kmeans.cpp
// Function: distanceSQ(vector const&, vector const&)
double distanceSQ(const vector& v1, const vector& v2) {
	double result = 0;
	int i1 = 0, i2 = 0;
	while(i1 < v1.size && i2 < v2.size) {
		double diff;
		if(v1.keys[i1] == v2.keys[i2]) {
			diff = v1.values[i1] - v2.values[i2];
			i1++;
			i2++;
		} else if (v1.keys[i1] < v2.keys[i2]) {
			diff = v1.values[i1];
			i1++;
		} else {
			diff = v2.values[i2];
			i2++;
		}
		result += diff * diff;
	}
	return result;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movl $0x0, -0x20(%rsp)
movl -0x1c(%rsp), %ecx
movq -0x8(%rsp), %rdx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0x29(%rsp)
jge 0x1518
movl -0x20(%rsp), %eax
movq -0x10(%rsp), %rcx
cmpl (%rcx), %eax
setl %al
movb %al, -0x29(%rsp)
movb -0x29(%rsp), %al
testb $0x1, %al
jne 0x1525
jmp 0x1622
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x20(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x158d
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq -0x20(%rsp), %rcx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x28(%rsp)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x15fd
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x20(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x15d7
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x28(%rsp)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x15fb
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq -0x20(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x28(%rsp)
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x15fd
movsd -0x28(%rsp), %xmm0
movsd -0x28(%rsp), %xmm2
movsd -0x18(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rsp)
jmp 0x14f3
movsd -0x18(%rsp), %xmm0
retq
nopl (%rax)
// File: ivanzamanov[P]kmeans/src/kmeans/kmeans.cpp
// Function: clone(vector&, vector&)
void clone(vector& dest, vector& src) {
	if(dest.keys != 0)
		delete dest.keys;
	if(dest.values != 0)
		delete dest.values;
	dest.size = src.size;
	dest.keys = new int[dest.size];
	dest.values = new double[dest.size];
	for(int i=0; i<dest.size; i++) {
		dest.keys[i] = src.keys[i];
		dest.values[i] = src.values[i];
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x166a
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1668
movq 0x8(%rsp), %rdi
callq 0x10b0
jmp 0x166a
movq 0x20(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1694
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x1692
movq (%rsp), %rdi
callq 0x10b0
jmp 0x1694
movq 0x18(%rsp), %rax
movl (%rax), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x20(%rsp), %rax
movslq (%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movslq (%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x1776
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x14(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x14(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1714
addq $0x28, %rsp
retq
nopl (%rax,%rax)