LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/shanet[P]Crypto-Example/crypto_file_example.cpp
// Function: encryptFile(Crypto*, char*, char*)
void encryptFile(Crypto *crypto, char *input, char *output) {
  // Read the file to encrypt
  unsigned char *plaintext;
  size_t plainTextLength = readFile(input, &plaintext);
  printf("%d bytes to be encrypted\n", (int)plainTextLength);

  // Encrypt the file
  unsigned char *ciphertext;
  int ciphertextLength = crypto->aesEncrypt((const unsigned char*)plaintext, plainTextLength, &ciphertext);

  if(ciphertextLength == -1) {
    fprintf(stderr, "Encryption failed\n");
    exit(1);
  }
  printf("%d bytes encrypted\n", ciphertextLength);

  // Encode the encrypted file to base64
  char *base64Ciphertext = base64Encode(ciphertext, ciphertextLength);

  // Write the encrypted file to its own file
  writeFile(output, (unsigned char*)base64Ciphertext, strlen((char*)base64Ciphertext));
  printf("Encrypted file written to \"%s\"\n", output);

  free(plaintext);
  free(ciphertext);
  free(base64Ciphertext);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r15
leaq 0x8(%rsp), %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x3341
movslq %eax, %r12
leaq 0xed4(%rip), %rdi       # 0x40cd
movl %r12d, %esi
xorl %eax, %eax
callq 0x2050
movq (%r14), %r14
movq %rsp, %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x2d84
cmpl $-0x1, %eax
je 0x328a
movl %eax, %ebp
leaq 0xed5(%rip), %rdi       # 0x40fa
movl %eax, %esi
xorl %eax, %eax
callq 0x2050
movq (%rsp), %rdi
movslq %ebp, %rsi
callq 0x26ec
movq %rax, %r15
movq %rax, %rdi
callq 0x2130
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x33cb
leaq 0xeb4(%rip), %rdi       # 0x410e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2050
movq %r14, %rdi
callq 0x22d0
movq (%rsp), %rdi
callq 0x22d0
movq %r15, %rdi
callq 0x22d0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x24ad
// File: /workspace/github_cpp_makefile_star2_O1/shanet[P]Crypto-Example/crypto_file_example.cpp
// Function: decryptFile(Crypto*, char*, char*)
void decryptFile(Crypto *crypto, char *input, char *output) {
  // Read the encrypted file back
  unsigned char *base64Ciphertext;
  size_t base64CiphertextLength = readFile(input, &base64Ciphertext);

  // Decode the encrypted file from base64
  unsigned char *ciphertext;
  size_t ciphertextLength = base64Decode((char*)base64Ciphertext, base64CiphertextLength, &ciphertext);

  // Decrypt the encrypted file
  unsigned char *plaintext;
  int plaintextLength = crypto->aesDecrypt(ciphertext, ciphertextLength, &plaintext);

  if(plaintextLength == -1) {
    fprintf(stderr, "Decryption failed\n");
    exit(1);
  }
  printf("%d bytes decrypted\n", (int)plaintextLength);

  // Write the decrypted file to its own file
  writeFile(output, plaintext, plaintextLength);
  printf("Decrypted file written to \"%s\"\n", output);

  free(base64Ciphertext);
  free(ciphertext);
  free(plaintext);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rdi, %r15
leaq 0x18(%rsp), %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x3341
movslq %eax, %rsi
movq (%r14), %r14
leaq 0x10(%rsp), %r12
movq %r14, %rdi
movq %r12, %rdx
callq 0x2801
movslq %eax, %rdx
movq (%r12), %rsi
leaq 0x8(%rsp), %rcx
movq %r15, %rdi
callq 0x2e20
cmpl $-0x1, %eax
je 0x333c
movl %eax, %ebp
leaq 0xe58(%rip), %rdi       # 0x4141
movl %eax, %esi
xorl %eax, %eax
callq 0x2050
movq 0x8(%rsp), %rsi
movslq %ebp, %rdx
movq %rbx, %rdi
callq 0x33cb
leaq 0xe4c(%rip), %rdi       # 0x4155
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2050
movq %r14, %rdi
callq 0x22d0
movq 0x10(%rsp), %rdi
callq 0x22d0
movq 0x8(%rsp), %rdi
callq 0x22d0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x24d2
// File: /workspace/github_cpp_makefile_star2_O1/shanet[P]Crypto-Example/crypto_file_example.cpp
// Function: readFile(char*, unsigned char**)
int readFile(char *filename, unsigned char **file) {
  FILE *fd = fopen(filename, "r");
  if(fd == NULL) {
    fprintf(stderr, "Failed to open file: %s\n", strerror(errno));
    exit(1);
  }

  // Determine size of the file
  fseek(fd, 0, SEEK_END);
  size_t fileLength = ftell(fd);
  fseek(fd, 0, SEEK_SET);

  // Allocate space for the file
  *file = (unsigned char*)malloc(fileLength);
  if(*file == NULL) {
    fprintf(stderr, "Failed to allocate memory\n");
    exit(1);
  }

  // Read the file into the buffer
  size_t bytesRead = fread(*file, 1, fileLength, fd);

  if(bytesRead != fileLength) {
    fprintf(stderr, "Error reading file\n");
    exit(1);
  }

  fclose(fd);

  return fileLength;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
leaq 0xe56(%rip), %rsi       # 0x41a6
callq 0x22c0
testq %rax, %rax
je 0x33bc
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2280
movq %rbx, %rdi
callq 0x2030
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2280
movq %r15, %rdi
callq 0x2300
movq %rax, (%r14)
testq %rax, %rax
je 0x33c1
movl $0x1, %esi
movq %rax, %rdi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x2340
cmpq %r15, %rax
jne 0x33c6
movq %rbx, %rdi
callq 0x2230
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x2541
callq 0x251c
callq 0x24f7
// File: /workspace/github_cpp_makefile_star2_O1/shanet[P]Crypto-Example/crypto_file_example.cpp
// Function: writeFile(char*, unsigned char*, unsigned long)
void writeFile(char *filename, unsigned char *file, size_t fileLength) {
  FILE *fd = fopen(filename, "w");
  if(fd == NULL) {
    fprintf(stderr, "Failed to open file: %s\n", strerror(errno));
    exit(1);
  }

  size_t bytesWritten = fwrite(file, 1, fileLength, fd);

  if(bytesWritten != fileLength) {
    fprintf(stderr, "Failed to write file\n");
    exit(1);
  }

  fclose(fd);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
leaq 0xd98(%rip), %rsi       # 0x4175
callq 0x22c0
testq %rax, %rax
je 0x340f
movq %rax, %r14
movl $0x1, %esi
movq %r15, %rdi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x23f0
cmpq %rbx, %rax
jne 0x3414
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2230
callq 0x2599
callq 0x2574
// File: /workspace/github_cpp_makefile_star2_O1/conp-solutions[P]cnfmiter/Main.cc
// Function: generate_or_equivalence(CNFMITER::Formula&, std::vector<CNFMITER::Lit, std::allocator<CNFMITER::Lit>> const&, CNFMITER::Lit)
void generate_or_equivalence(Formula &f, const std::vector<Lit> &clause, Lit enabler_lit)
{
    static std::vector<Lit> tmpClause;
    tmpClause.clear();

    // !enabler_lit -> clause
    tmpClause = clause;
    tmpClause.push_back(~enabler_lit);
    f.addClause_(tmpClause);

    // clause -> enabler_lit
    tmpClause.clear();
    tmpClause.push_back(enabler_lit);
    tmpClause.push_back(enabler_lit);
    for (Lit l : clause) {
        tmpClause[1] = ~l;
        f.addClause_(tmpClause);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, -0x24(%rbp)
movb 0x4c7e(%rip), %al       # 0x71b8
testb %al, %al
je 0x2672
movq 0x4c57(%rip), %rax      # 0x71a0
cmpq %rax, 0x4c58(%rip)      # 0x71a8
je 0x2559
movq %rax, 0x4c4f(%rip)      # 0x71a8
leaq 0x4c40(%rip), %rdi      # 0x71a0
movq %r14, %rsi
callq 0x3c5c
movl -0x24(%rbp), %eax
xorl $0x1, %eax
movl %eax, -0x28(%rbp)
movq 0x4c30(%rip), %rsi      # 0x71a8
cmpq 0x4c31(%rip), %rsi      # 0x71b0
je 0x2590
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x4c1a(%rip)      # 0x71a8
jmp 0x25a0
leaq 0x4c09(%rip), %rdi      # 0x71a0
leaq -0x28(%rbp), %rdx
callq 0x405e
addq $0x8, %rbx
leaq 0x4bf5(%rip), %rsi      # 0x71a0
movq %rbx, %rdi
callq 0x3d34
movq 0x4be6(%rip), %rax      # 0x71a0
cmpq %rax, 0x4be7(%rip)      # 0x71a8
je 0x25ca
movq %rax, 0x4bde(%rip)      # 0x71a8
movq 0x4bd7(%rip), %rsi      # 0x71a8
cmpq 0x4bd8(%rip), %rsi      # 0x71b0
je 0x25ec
movl -0x24(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x4bbe(%rip)      # 0x71a8
jmp 0x25fc
leaq 0x4bad(%rip), %rdi      # 0x71a0
leaq -0x24(%rbp), %rdx
callq 0x4178
movq 0x4ba5(%rip), %rsi      # 0x71a8
cmpq 0x4ba6(%rip), %rsi      # 0x71b0
je 0x261e
movl -0x24(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x4b8c(%rip)      # 0x71a8
jmp 0x262e
leaq 0x4b7b(%rip), %rdi      # 0x71a0
leaq -0x24(%rbp), %rdx
callq 0x4178
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x2665
leaq 0x4b5f(%rip), %r14      # 0x71a0
movl (%r15), %eax
xorl $0x1, %eax
movq 0x4b52(%rip), %rcx      # 0x71a0
movl %eax, 0x4(%rcx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3d34
addq $0x4, %r15
cmpq %r12, %r15
jne 0x2641
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x2300
jmp 0x2542
// File: /workspace/github_cpp_makefile_star2_O1/conp-solutions[P]cnfmiter/Main.cc
// Function: generate_clause_sat(CNFMITER::Formula&, CNFMITER::Formula const&, CNFMITER::Lit&)
void generate_clause_sat(Formula &formula, const Formula &input, Lit &equivalence_lit)
{
    std::vector<Lit> enabler_lits; // literals that are equal to satisfiability of each clause

    for (const auto &c : input.clauses) {
        Lit enabler_lit = mkLit(formula.newVar());
        enabler_lits.push_back(enabler_lit);

        generate_or_equivalence(formula, c, enabler_lit);
    }

    equivalence_lit = mkLit(formula.newVar());

    // (x <-> (a or b)) is the same as (!x <->(!b and !c))
    for (int i = 0; i < enabler_lits.size(); ++i) enabler_lits[i] = ~enabler_lits[i];
    generate_or_equivalence(formula, enabler_lits, ~equivalence_lit);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, -0x58(%rbp)
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %r14
cmpq %r14, %r15
je 0x26fc
leaq -0x50(%rbp), %r12
leaq -0x2c(%rbp), %r13
movl (%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rbx)
addl %eax, %eax
movl %eax, -0x2c(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x26da
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x26e5
movq %r12, %rdi
movq %r13, %rdx
callq 0x4178
movl -0x2c(%rbp), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x251c
addq $0x18, %r15
cmpq %r14, %r15
jne 0x26b8
movl (%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rbx)
addl %eax, %eax
movq -0x58(%rbp), %rsi
movl %eax, (%rsi)
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
subq %rax, %rcx
je 0x2732
sarq $0x2, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
xorb $0x1, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x2726
movl (%rsi), %edx
xorl $0x1, %edx
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x251c
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x2751
callq 0x2180
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2762
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x2773
callq 0x2180
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/conp-solutions[P]cnfmiter/Main.cc
// Function: rewrite_variable_range(CNFMITER::Formula&, int, int)
void rewrite_variable_range(Formula &formula, Var largest_input_variable, int offset)
{
    if (offset == 0) return;
    if (largest_input_variable <= formula.nVars()) return;

    for (auto &c : formula.clauses) {
        for (size_t i = 0; i < c.size(); ++i) {
            if (var(c[i]) > largest_input_variable) {
                c[i] = mkLit(var(c[i]) + offset, sign(c[i]));
            }
        }
    }

    int oldVars = formula.nVars();
    while (formula.nVars() < oldVars + offset) formula.newVar();
}

// Assembly:
testl %edx, %edx
je 0x2a3a
cmpl %esi, (%rdi)
jge 0x2a3a
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
cmpq %rcx, %rax
je 0x2a29
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq (%rax), %r8
movq 0x8(%rax), %r9
subq %r8, %r9
je 0x2a1e
sarq $0x2, %r9
cmpq $0x1, %r9
adcq $0x0, %r9
xorl %r10d, %r10d
movl (%r8,%r10,4), %r11d
movl %r11d, %ebx
sarl %ebx
cmpl %esi, %ebx
jle 0x2a16
addl %edx, %ebx
andl $0x1, %r11d
leal (%r11,%rbx,2), %r11d
movl %r11d, (%r8,%r10,4)
incq %r10
cmpq %r10, %r9
jne 0x29fb
addq $0x18, %rax
cmpq %rcx, %rax
jne 0x29e0
popq %rbx
popq %rbp
testl %edx, %edx
jle 0x2a3a
movl (%rdi), %eax
addl %eax, %edx
incl %eax
cmpl %eax, %edx
cmovgl %edx, %eax
movl %eax, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/conp-solutions[P]cnfmiter/Main.cc
// Function: get_definition_clauses(CNFMITER::Formula&, int)
std::vector<std::vector<Lit>> get_definition_clauses(Formula &f1, int largest_input_variable)
{
    std::vector<std::vector<Lit>> l2r;

    for (const auto &c : f1.clauses) {
        bool move = false;
        for (size_t i = 0; i < c.size(); ++i) {
            if (var(c[i]) >= largest_input_variable) {
                move = true;
                break;
            }
        }
        if (move) l2r.push_back(c);
    }

    return l2r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %r12
cmpq %r12, %r15
je 0x2aa9
movl %edx, %r14d
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
je 0x2aa0
sarq $0x2, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
movl (%rax,%rdx,4), %esi
sarl %esi
cmpl %r14d, %esi
jge 0x2a95
incq %rdx
cmpq %rdx, %rcx
jne 0x2a81
jmp 0x2aa0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3d34
addq $0x18, %r15
cmpq %r12, %r15
jne 0x2a67
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3d70
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/agorenst[P]trie/./radixtree.h
// Function: node<int>::tikz_print(std::ostream&)
void tikz_print(std::ostream& o) {
                o << "node[circle,draw]{}\n";
                for(auto& e : edge_list) {
                    o << "child {\n";
                    e.second->tikz_print(o);
                    o << "    edge from parent node[left]{\n";
                    for (auto& s : e.first) {
                        o << s << " ";
                    }
                    o << "    }\n";
                    o << "}\n";
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xe96(%rip), %rsi       # 0x41a5
movl $0x14, %edx
movq %rbx, %rdi
callq 0x2120
movq (%r14), %r13
movq %r14, -0x30(%rbp)
cmpq %r14, %r13
je 0x33cb
leaq 0xeb2(%rip), %r12       # 0x41e5
leaq 0x10(%r13), %r15
movl $0x8, %edx
movq %rbx, %rdi
leaq 0xe74(%rip), %rsi       # 0x41ba
callq 0x2120
movq 0x28(%r13), %rdi
movq %rbx, %rsi
callq 0x32f4
movl $0x21, %edx
movq %rbx, %rdi
leaq 0xe5d(%rip), %rsi       # 0x41c3
callq 0x2120
movq 0x10(%r13), %r14
cmpq %r15, %r14
je 0x3395
movl 0x10(%r14), %esi
movq %rbx, %rdi
callq 0x21a0
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2120
movq (%r14), %r14
jmp 0x336f
movl $0x6, %edx
movq %rbx, %rdi
leaq 0xe43(%rip), %rsi       # 0x41e7
callq 0x2120
movl $0x2, %edx
movq %rbx, %rdi
leaq 0xe33(%rip), %rsi       # 0x41eb
callq 0x2120
movq (%r13), %r13
cmpq -0x30(%rbp), %r13
jne 0x3333
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH18_ToolsForLargePrograms/examples/over.cc
// Function: main
int main()
{
	int ival = 42;
    print("Value: "); // calls global print(const string &)
    print(ival);      // calls libs_R_us::print(int)

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xd2e(%rip), %rsi       # 0x204e
leaq 0xd2e(%rip), %rdx       # 0x2055
leaq -0x30(%rbp), %rdi
callq 0x137a
callq 0x12b8
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x134a
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x1090
callq 0x121c
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x1372
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x1090
movq %rbx, %rdi
callq 0x10c0
// File: /workspace/github_cpp_makefile_star2_O1/whitefusion[P]Jaipur_cardgame-/Token.cpp
// Function: Token::setType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Token::setType(string t){
    if (tokenType[t] >= tokenType["Diamond"] && tokenType[t] <= tokenType["5Bonus"]){
        type = t;
        return true;
    }
    else{
        cout << "Invalid token type!" << endl; 
        return false;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1206d(%rip), %r15     # 0x16180
movq %r15, %rdi
callq 0x451c
movl (%rax), %r13d
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0xc06b(%rip), %rsi      # 0x10199
leaq 0xc06b(%rip), %rdx      # 0x101a0
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x3fee
movq %r15, %rdi
movq %r12, %rsi
callq 0x4598
movl (%rax), %r15d
cmpl %r15d, %r13d
jge 0x4159
xorl %ebp, %ebp
jmp 0x41a3
leaq 0x12020(%rip), %rdi     # 0x16180
movq %rbx, %rsi
callq 0x451c
movl (%rax), %ebp
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xc017(%rip), %rsi      # 0x10192
leaq 0xc016(%rip), %rdx      # 0x10198
leaq 0x28(%rsp), %rdi
callq 0x3fee
leaq 0x11fed(%rip), %rdi     # 0x16180
leaq 0x28(%rsp), %rsi
callq 0x4598
cmpl (%rax), %ebp
setle %bpl
cmpl %r15d, %r13d
jl 0x41c3
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x41c3
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x41df
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
testb %bpl, %bpl
je 0x41f1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20e0
jmp 0x4233
movq 0x11dd8(%rip), %rbx     # 0x15fd0
leaq 0xbfa2(%rip), %rsi      # 0x101a1
movl $0x13, %edx
movq %rbx, %rdi
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x4265
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x4265
jmp 0x4262
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4281
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O1/whitefusion[P]Jaipur_cardgame-/Token.cpp
// Function: Token::setVal(int)
bool Token::setVal(int v){
    string thisToken = getType();
    pair<multimap<string,int>::iterator, multimap<string,int>::iterator> ii;
    multimap<string,int>::iterator it;
    ii = tokenValue.equal_range(thisToken);
    for (it = ii.first; it != ii.second; ++it){
        if (v == it->second){ 
            val = v;
            return true;
        }
    }

    cout << "Invalid token value of " << thisToken << "!" << endl;
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x3f5e
leaq 0x11eef(%rip), %rdi     # 0x161b0
movq %rbx, %rsi
callq 0x4e44
movq %rdx, %r15
cmpq %r15, %rax
setne %bl
je 0x42e3
cmpl %ebp, 0x40(%rax)
je 0x4350
movq %rax, %rdi
callq 0x2100
jmp 0x42cc
movq 0x11ce6(%rip), %rdi     # 0x15fd0
leaq 0xbec4(%rip), %rsi      # 0x101b5
movl $0x17, %edx
callq 0x21d0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x11cc5(%rip), %rdi     # 0x15fd0
callq 0x21d0
movq %rax, %r14
leaq 0xc434(%rip), %rsi      # 0x1074e
movl $0x1, %edx
movq %rax, %rdi
callq 0x21d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
jmp 0x4354
movl %ebp, 0x20(%r14)
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x436a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21a0
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x437b
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x4394
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/whitefusion[P]Jaipur_cardgame-/AllTokens.cpp
// Function: All_Tokens::getSize(int)
int All_Tokens::getSize(int id){
    if (id >= 1 && id <= 7){
        return number[id-1];
    }
    
    cout << "getSize:Invalid type of token!" << endl;
    return -1;
}

// Assembly:
decl %esi
cmpl $0x6, %esi
ja 0x54b8
movl %esi, %eax
movl 0x18(%rdi,%rax,4), %eax
retq
pushq %rbx
movq 0x10b10(%rip), %rbx     # 0x15fd0
leaq 0xad19(%rip), %rsi      # 0x101e0
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/whitefusion[P]Jaipur_cardgame-/AllTokens.cpp
// Function: All_Tokens::getToken(int)
Token All_Tokens::getToken(int id){
    if (id >= 1 && id <= 7)
        return allTokens.at(id-1).at(getSize(id)-1); 
    else // if the id is invalid, then always return last token
        cout << "getToken: Invalid type of token!" << endl;
    return allTokens.at(6).at(getSize(6)-1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leal -0x1(%rdx), %eax
cmpl $0x6, %eax
ja 0x5586
movl %eax, %esi
movq (%r14), %r15
movq 0x8(%r14), %rcx
subq %r15, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
cmpq %rsi, %rax
jbe 0x5659
leaq (%rsi,%rsi,2), %r12
movq %r14, %rdi
movl %edx, %esi
callq 0x54aa
decl %eax
movslq %eax, %rsi
movq (%r15,%r12,8), %rax
movq 0x8(%r15,%r12,8), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x5650
leaq (%rsi,%rsi,4), %rcx
leaq (%rax,%rcx,8), %r14
jmp 0x5621
movq 0x10a43(%rip), %r15     # 0x15fd0
leaq 0xac6b(%rip), %rsi      # 0x101ff
movl $0x20, %edx
movq %r15, %rdi
callq 0x21d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq $0x6, %rdx
jbe 0x5665
movslq 0x2c(%r14), %rsi
decq %rsi
movq 0x90(%rax), %rcx
movq 0x98(%rax), %rax
subq %rcx, %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rdx
cmpq %rsi, %rdx
jbe 0x5650
leaq (%rsi,%rsi,4), %rax
leaq (%rcx,%rax,8), %r14
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3f5e
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xacf1(%rip), %rdi      # 0x10348
jmp 0x5671
leaq 0xace8(%rip), %rdi      # 0x10348
movq %rax, %rdx
jmp 0x5671
leaq 0xacdc(%rip), %rdi      # 0x10348
movl $0x6, %esi
xorl %eax, %eax
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/whitefusion[P]Jaipur_cardgame-/AllBonus.cpp
// Function: All_Bonus::All_Bonus()
int All_Bonus::getSize(int id)
{
  if(id >=3 && id <=5){
    return size[id-3];
  }
  cout<<"getSize: Invalid type of Bonus!"<<endl;
  return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movabsq $0x600000006, %rax      # imm = 0x600000006
movq %rax, 0x18(%rdi)
movq %rdi, 0x8(%rsp)
movl $0x6, 0x20(%rdi)
leaq 0x50(%rsp), %rdi
callq 0x4080
leaq 0x30(%rsp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x20(%rsp), %r12
xorl %r15d, %r15d
leaq 0x10(%rsp), %r13
leaq 0x50(%rsp), %rbp
movabsq $-0x5555555555555555, %rbx # imm = 0xAAAAAAAAAAAAAAAB
leaq 0x1(%r15), %rax
movq %rax, 0x48(%rsp)
movl %eax, 0x4(%rsp)
leaq 0xf390(%rip), %rdi      # 0x16238
leaq 0x4(%rsp), %rsi
callq 0x6034
movq %r12, 0x10(%rsp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x3f5e
movq %rbp, %rdi
movq %r13, %rsi
callq 0x40f8
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x6eeb
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0xf37e(%rip), %rdx      # 0x16270
movq 0xf36f(%rip), %rax      # 0x16268
subq %rax, %rdx
sarq $0x3, %rdx
imulq %rbx, %rdx
cmpq %r15, %rdx
jbe 0x6fd7
leaq (%r15,%r15,2), %r13
xorl %r12d, %r12d
movq (%rax,%r13,8), %rcx
movq 0x8(%rax,%r13,8), %rax
subq %rcx, %rax
sarq $0x2, %rax
cmpq %rax, %r12
jae 0x6f63
movl (%rcx,%r12,4), %esi
movq %rbp, %rdi
callq 0x428a
movq %r14, %rdi
movq %rbp, %rsi
callq 0x6098
incq %r12
movq 0xf326(%rip), %rdx      # 0x16270
movq 0xf317(%rip), %rax      # 0x16268
subq %rax, %rdx
sarq $0x3, %rdx
imulq %rbx, %rdx
cmpq %r15, %rdx
ja 0x6f14
jmp 0x6fd7
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x60ec
movq 0x30(%rsp), %r12
movq 0x38(%rsp), %r13
cmpq %r12, %r13
je 0x6f98
movq %r12, %r15
movq %r15, %rdi
callq 0x40dc
addq $0x28, %r15
cmpq %r13, %r15
jne 0x6f82
movq %r12, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, %r15
cmpq $0x3, %rax
leaq 0x20(%rsp), %r12
leaq 0x10(%rsp), %r13
jne 0x6e94
leaq 0x30(%rsp), %rdi
callq 0x6118
leaq 0x50(%rsp), %rdi
callq 0x40dc
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x936a(%rip), %rdi      # 0x10348
movq %r15, %rsi
xorl %eax, %eax
callq 0x21f0
movq %rax, %r14
jmp 0x7026
jmp 0x700f
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x7012
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x7012
jmp 0x700f
jmp 0x700f
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x6118
leaq 0x50(%rsp), %rdi
callq 0x40dc
movq 0x8(%rsp), %rdi
callq 0x615a
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/whitefusion[P]Jaipur_cardgame-/AllBonus.cpp
// Function: All_Bonus::shuffle()
void All_Bonus::shuffle()
{
  unsigned seed;
  if (TEST == 0)
      seed = std::chrono::system_clock::now().time_since_epoch().count();
  else 
      seed = 839223;

  for(int i = 0; i < 3; i++){
    std::shuffle(allBonus.at(i).begin(), allBonus.at(i).end(), std::default_random_engine(seed));
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl $0x8, %r12d
xorl %ebx, %ebx
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
leaq 0x8(%rsp), %r15
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %r13, %rdx
cmpq %rbx, %rdx
jbe 0x7339
movq -0x8(%rax,%r12), %rdi
movq (%rax,%r12), %rsi
movq $0xcce37, 0x8(%rsp)     # imm = 0xCCE37
movq %r15, %rdx
callq 0x7c08
incq %rbx
addq $0x18, %r12
cmpq $0x3, %rbx
jne 0x72ed
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x9008(%rip), %rdi      # 0x10348
movq %rbx, %rsi
xorl %eax, %eax
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/whitefusion[P]Jaipur_cardgame-/AllBonus.cpp
// Function: All_Bonus::getBonus(int)
Token All_Bonus::getBonus(int id)
{
  if( id >= 3 && id <=5)
    return allBonus.at(id-3).at(getSize(id)-1);
  else{ 
    cout<<" getBonus: Invalid type of bonus! Get the 3Bonus instead!" << endl;
  }
  return allBonus.at(0).at(getSize(3)-1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leal -0x3(%rdx), %eax
cmpl $0x2, %eax
ja 0x74b3
movl %eax, %esi
movq (%r14), %r15
movq 0x8(%r14), %rcx
subq %r15, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
cmpq %rsi, %rax
jbe 0x7569
leaq (%rsi,%rsi,2), %r12
movq %r14, %rdi
movl %edx, %esi
callq 0x73fe
decl %eax
movslq %eax, %rsi
movq (%r15,%r12,8), %rax
movq 0x8(%r15,%r12,8), %rcx
jmp 0x750f
movq 0xeb16(%rip), %r15      # 0x15fd0
leaq 0x8fa3(%rip), %rsi      # 0x10464
movl $0x39, %edx
movq %r15, %rdi
callq 0x21d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq (%r14), %rcx
movq 0x8(%r14), %rax
subq %rcx, %rax
je 0x7575
movslq 0x18(%r14), %rsi
decq %rsi
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x7560
leaq (%rsi,%rsi,4), %rcx
leaq (%rax,%rcx,8), %r14
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3f5e
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x8de1(%rip), %rdi      # 0x10348
jmp 0x7590
leaq 0x8dd8(%rip), %rdi      # 0x10348
movq %rax, %rdx
jmp 0x7590
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
leaq 0x8dba(%rip), %rdi      # 0x10348
xorl %esi, %esi
xorl %eax, %eax
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/whitefusion[P]Jaipur_cardgame-/Deck.cpp
// Function: Deck::drawCard()
Card Deck::drawCard(){
  Card temp;
  vector<Card>::iterator dit = deck.end()-1;
  temp = *dit;
  deck.erase(dit);
  return temp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x9248
movq 0x8(%r14), %r15
addq $-0x20, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x91e2
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x92e2
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/whitefusion[P]Jaipur_cardgame-/Market.cpp
// Function: Market::Market()
Market::Market(){
    Card tmpC;
    tmpC.setCard("CAMEL");
    for (int i = 0; i < 5; ++i)
        goods.push_back(tmpC); 
    size = 5;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x28(%rsp), %rdi
callq 0x9248
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6df5(%rip), %rsi      # 0x1017e
leaq 0x6df3(%rip), %rdx      # 0x10183
leaq 0x8(%rsp), %rdi
callq 0x3fee
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x9320
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x93c0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movl $0x5, %ebp
leaq 0x28(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8c6e
decl %ebp
jne 0x93ca
movl $0x5, 0x18(%rbx)
leaq 0x28(%rsp), %rdi
callq 0x92e2
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x941b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x941b
jmp 0x9418
movq %rax, %r14
jmp 0x9425
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x92e2
movq %rbx, %rdi
callq 0x8cac
movq %r14, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O1/whitefusion[P]Jaipur_cardgame-/Market.cpp
// Function: Market::Market(Deck&)
Market::Market(Deck &deck){
    Card tmpC;
    tmpC.setCard("CAMEL");
    for (int i = 0; i < 3; ++i)
        goods.push_back(tmpC); 
    for (int i = 0; i < 2; ++i){
        tmpC = deck.drawCard();
        goods.push_back(tmpC); 
    }
    size = 5;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x20(%rsp), %rdi
callq 0x9248
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6d0e(%rip), %rsi      # 0x1017e
leaq 0x6d0c(%rip), %rdx      # 0x10183
movq %rsp, %rdi
callq 0x3fee
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x9320
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x94a2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21a0
movl $0x3, %ebp
leaq 0x20(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8c6e
decl %ebp
jne 0x94ac
movl $0x1, %ebp
leaq 0x40(%rsp), %r15
leaq 0x20(%rsp), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x8c24
movq %r12, %rdi
movq %r15, %rsi
callq 0x20e0
movq %r15, %rdi
callq 0x92e2
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8c6e
decl %ebp
je 0x94ca
movl $0x5, 0x18(%rbx)
leaq 0x20(%rsp), %rdi
callq 0x92e2
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x954d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x954d
jmp 0x954a
movq %rax, %r14
jmp 0x9557
jmp 0x954a
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x92e2
jmp 0x954d
jmp 0x954a
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x92e2
movq %rbx, %rdi
callq 0x8cac
movq %r14, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O1/whitefusion[P]Jaipur_cardgame-/Market.cpp
// Function: Market::newMarket(Deck&)
void Market::newMarket(Deck &deck){
    goods.clear();
    size = 0;
    Card tmpC;
    tmpC.setCard("CAMEL");
    for (int i = 0; i < 3; ++i)
        goods.push_back(tmpC); 
    for (int i = 0; i < 2; ++i){
        tmpC = deck.drawCard();
        goods.push_back(tmpC); 
    }
    size = 5;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r12
movq 0x8(%rdi), %r13
cmpq %r12, %r13
je 0x95a0
movq %r12, %r15
movq %r15, %rdi
callq 0x92e2
addq $0x20, %r15
cmpq %r13, %r15
jne 0x958b
movq %r12, 0x8(%rbx)
movl $0x0, 0x18(%rbx)
leaq 0x28(%rsp), %rdi
callq 0x9248
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6bbd(%rip), %rsi      # 0x1017e
leaq 0x6bbb(%rip), %rdx      # 0x10183
leaq 0x8(%rsp), %rdi
callq 0x3fee
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x9320
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x95f8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movl $0x3, %ebp
leaq 0x28(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8c6e
decl %ebp
jne 0x9602
movl $0x1, %ebp
leaq 0x48(%rsp), %r15
leaq 0x28(%rsp), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x8c24
movq %r12, %rdi
movq %r15, %rsi
callq 0x20e0
movq %r15, %rdi
callq 0x92e2
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8c6e
decl %ebp
je 0x9620
movl $0x5, 0x18(%rbx)
leaq 0x28(%rsp), %rdi
callq 0x92e2
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x96a1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x96a1
jmp 0x969e
jmp 0x969e
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x92e2
jmp 0x96a1
jmp 0x969e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x92e2
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O1/whitefusion[P]Jaipur_cardgame-/Market.cpp
// Function: Market::getGoods(int)
Card Market::getGoods(int id){
    Card tmpC;
    if (id > 0 && id < size+1){
        tmpC = goods.at(id-1);
        return tmpC;
    }
    // if the card id is outside the market, always return the first card
    else{ 
        cout << "Invalid choice! You get the first Card instead!" << endl; 
        tmpC = goods.at(0);
    }
    return tmpC; 
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
callq 0x9248
testl %r15d, %r15d
jle 0x9737
cmpl %r15d, 0x18(%r14)
jl 0x9737
decl %r15d
movq (%r14), %rsi
movq 0x8(%r14), %rdx
subq %rsi, %rdx
sarq $0x5, %rdx
cmpq %r15, %rdx
jbe 0x979c
shlq $0x5, %r15
addq %r15, %rsi
jmp 0x9786
movq 0xc892(%rip), %r15      # 0x15fd0
leaq 0x6e70(%rip), %rsi      # 0x105b5
movl $0x2f, %edx
movq %r15, %rdi
callq 0x21d0
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq 0xc860(%rip), %rdi      # 0x15fd0
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq (%r14), %rsi
cmpq %rsi, 0x8(%r14)
je 0x9797
movq %rbx, %rdi
callq 0x20e0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
xorl %r15d, %r15d
xorl %edx, %edx
leaq 0x6ba5(%rip), %rdi      # 0x10348
movq %r15, %rsi
xorl %eax, %eax
callq 0x21f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x92e2
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/whitefusion[P]Jaipur_cardgame-/Market.cpp
// Function: Market::setGoods(Deck&)
void Market::setGoods(Deck &deck){
    int n = 5 - size;
    if (deck.getsize() != 0){
        for (int i = 0; i < n; ++i){
            if(deck.getsize() == 0)
                break;
            goods.push_back(deck.drawCard()); 
            size++;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movabsq $0x1fffffffe0, %r12     # imm = 0x1FFFFFFFE0
movl 0x18(%rdi), %eax
movq 0x8(%rsi), %rcx
subq (%rsi), %rcx
testq %r12, %rcx
setne %cl
cmpl $0x5, %eax
setl %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x9860
movq %rsi, %rbx
movq %rdi, %r14
movl $0x5, %ecx
subl %eax, %ecx
cmpl $0x2, %ecx
movl $0x1, %ebp
cmovgel %ecx, %ebp
movq %rsp, %r15
movq 0x8(%rbx), %rax
subq (%rbx), %rax
testq %r12, %rax
je 0x9860
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8c24
movq %r14, %rdi
movq %r15, %rsi
callq 0x9cc8
movq %r15, %rdi
callq 0x92e2
incl 0x18(%r14)
decl %ebp
jne 0x982e
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x92e2
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/whitefusion[P]Jaipur_cardgame-/Player.cpp
// Function: Player::Player()
Player::Player(){
    Card tmpC;
    tmpC.setCard("DIAMD");
    vector<Card> cards;
    vector<Card> herds;

    for (int i = 0; i < 3; ++i)
        cards.push_back(tmpC);
    size[0] = 3;

    tmpC.setCard("CAMEL");
    for (int i = 0; i < 2; ++i)
        herds.push_back(tmpC);
    size[1] = 2;

    hand.push_back(cards);
    hand.push_back(herds);

    name = "LLL";

    for (int i = 0; i < 4; ++i)
        point[i] = 0;

    GTokenNum = BTokenNum = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r15
leaq 0xbeb5(%rip), %rax      # 0x15d48
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x30(%rdi), %rcx
movq %rcx, 0x8(%rsp)
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb $0x0, 0x30(%rdi)
leaq 0x70(%rsp), %rdi
callq 0x9248
leaq 0x60(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x6285(%rip), %rsi      # 0x10160
leaq 0x6283(%rip), %rdx      # 0x10165
leaq 0x50(%rsp), %rdi
callq 0x3fee
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x9320
movq 0x50(%rsp), %rdi
cmpq %r12, %rdi
je 0x9f12
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x21a0
xorps %xmm0, %xmm0
leaq 0x90(%rsp), %r12
movaps %xmm0, (%r12)
xorl %eax, %eax
movq %rax, 0x10(%r12)
movq %rax, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movl $0x3, %ebp
leaq 0x70(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x8c6e
decl %ebp
jne 0x9f3d
movl $0x3, 0x40(%r15)
leaq 0x40(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x6219(%rip), %rsi      # 0x1017e
leaq 0x6217(%rip), %rdx      # 0x10183
leaq 0x30(%rsp), %rdi
callq 0x3fee
leaq 0x70(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x9320
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0x9f9c
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x21a0
movl $0x1, %ebp
leaq 0x10(%rsp), %r12
leaq 0x70(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x8c6e
decl %ebp
je 0x9fab
movl $0x2, 0x44(%r15)
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0xbbb8
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xbbb8
movq 0x28(%r15), %rdx
leaq 0x66de(%rip), %rcx      # 0x106c8
movl $0x3, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x2210
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r15)
movq $0x0, 0x58(%r15)
leaq 0x10(%rsp), %rdi
callq 0x8cac
leaq 0x90(%rsp), %rdi
callq 0x8cac
leaq 0x70(%rsp), %rdi
callq 0x92e2
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0xa088
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0xa088
jmp 0xa085
movq %rax, %r15
movq 0x50(%rsp), %rdi
cmpq %r12, %rdi
je 0xa09f
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0xa09f
movq %rax, %r15
jmp 0xa09f
movq %rax, %r15
jmp 0xa0a9
jmp 0xa085
jmp 0xa085
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x8cac
leaq 0x90(%rsp), %rdi
callq 0x8cac
leaq 0x70(%rsp), %rdi
callq 0x92e2
movq (%r14), %rdi
cmpq 0x8(%rsp), %rdi
je 0xa0c3
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0xbbe4
movq %r15, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O1/whitefusion[P]Jaipur_cardgame-/Player.cpp
// Function: Player::Player(Deck&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Player::Player(Deck &deck, string playerName){
    Card tmpC;
    int i;
    size[0] = size[1] = 0;

    vector<Card> cards;
    vector<Card> herds;

    // draw five cards from deck, if card == CAMEL put it in herds 
    for (i = 0; i < 5; ++i){
        tmpC = deck.drawCard();
        if (tmpC.getCard() == "CAMEL"){
            herds.push_back(tmpC);
            size[1]++;
        }
        else{
            cards.push_back(tmpC);
            size[0]++;
        }
    }

    hand.push_back(cards);
    hand.push_back(herds);

    name = playerName;

    // initialize all points to zero
    for (i = 0; i < 4; ++i)
        point[i] = 0;

    GTokenNum = BTokenNum = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, 0x18(%rsp)
movq %rsi, %r13
movq %rdi, %r15
leaq 0xbc51(%rip), %rax      # 0x15d48
movq %rax, (%rdi)
leaq 0x8(%rdi), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, 0x8(%rsp)
leaq 0x30(%rdi), %rcx
movq %rcx, (%rsp)
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb $0x0, 0x30(%rdi)
leaq 0x78(%rsp), %rdi
callq 0x9248
xorl %eax, %eax
movq %rax, 0x40(%r15)
leaq 0x40(%rsp), %rcx
movq %rax, 0x10(%rcx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rcx)
leaq 0x20(%rsp), %rcx
movq %rax, 0x10(%rcx)
movaps %xmm0, (%rcx)
movl $0x5, %r14d
leaq 0x58(%rsp), %r12
leaq 0x78(%rsp), %rbx
movq %r12, %rdi
movq %r13, %rsi
callq 0x8c24
movq %rbx, %rdi
movq %r12, %rsi
callq 0x20e0
movq %r12, %rdi
callq 0x92e2
movq %r12, %rdi
movq %rbx, %rsi
callq 0x92fe
movq %r12, %rdi
leaq 0x5fe3(%rip), %rsi      # 0x1017e
callq 0x2080
movl %eax, %ebp
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0xa1be
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x21a0
testl %ebp, %ebp
je 0xa1d5
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
callq 0x8c6e
incl 0x40(%r15)
jmp 0xa1e6
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x8c6e
incl 0x44(%r15)
decl %r14d
jne 0xa168
leaq 0x40(%rsp), %rsi
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %r12
callq 0xbbb8
leaq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0xbbb8
movq %r12, %rdi
movq 0x18(%rsp), %rsi
callq 0x20e0
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r15)
movq $0x0, 0x58(%r15)
leaq 0x20(%rsp), %rdi
callq 0x8cac
leaq 0x40(%rsp), %rdi
callq 0x8cac
leaq 0x78(%rsp), %rdi
callq 0x92e2
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %r14
movq 0x8(%rsp), %r12
jmp 0xa2b3
movq %rax, %rbx
movq (%rsp), %r14
jmp 0xa295
jmp 0xa289
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x92e2
jmp 0xa28c
jmp 0xa289
movq %rax, %rbx
movq (%rsp), %r14
movq 0x8(%rsp), %r12
leaq 0x20(%rsp), %rdi
callq 0x8cac
leaq 0x40(%rsp), %rdi
callq 0x8cac
leaq 0x78(%rsp), %rdi
callq 0x92e2
movq (%r12), %rdi
cmpq %r14, %rdi
je 0xa2c7
movq (%r14), %rsi
incq %rsi
callq 0x21a0
movq 0x10(%rsp), %rdi
callq 0xbbe4
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O1/whitefusion[P]Jaipur_cardgame-/Player.cpp
// Function: Player::setHand(Card)
void Player::setHand(Card c){
    if (c.getCard() == "CAMEL"){
        hand.at(1).push_back(c);
        size[1]++;
    }
    else{
        hand.at(0).push_back(c);
        size[0]++;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x92fe
leaq 0x5b34(%rip), %rsi      # 0x1017e
movq %r15, %rdi
callq 0x2080
movl %eax, %ebp
movq (%r15), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xa66e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rax
testl %ebp, %ebp
je 0xa68c
subq %rdi, %rax
je 0xa6c1
movq %r14, %rsi
callq 0x8c6e
incl 0x40(%rbx)
jmp 0xa6b6
subq %rdi, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
cmpq $0x1, %rdx
jbe 0xa6de
addq $0x18, %rdi
movq %r14, %rsi
callq 0x8c6e
incl 0x44(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
leaq 0x5c6e(%rip), %rdi      # 0x10348
xorl %esi, %esi
jmp 0xa6ea
leaq 0x5c63(%rip), %rdi      # 0x10348
movl $0x1, %esi
xorl %eax, %eax
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/whitefusion[P]Jaipur_cardgame-/Player.cpp
// Function: Player::getHand(int, int) const
Card Player::getHand(int type, int location) const{ // location from 0
    if (type >= 0 && type <= 1){
        if (location >= 0 && location < size[type])
            return hand.at(type).at(location); 
        else{ // if location out of range, return the first card
            cout << "getHand: location is out of range! get the first card instead!" << endl;
            return hand.at(type).at(0);
        }
    }
    else{ // if type not found, return the card
        cout << "getHand: card type not found! will return a card(not camel) instead!" << endl;
    }
    return hand.at(0).at(0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x1, %edx
ja 0xa769
movl %edx, %r15d
testl %ecx, %ecx
js 0xa7f1
cmpl %ecx, 0x40(%r14,%r15,4)
jle 0xa7f1
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rax
subq %rdi, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
cmpq %r15, %rdx
jbe 0xa893
leaq (%r15,%r15,2), %rdx
movl %ecx, %esi
movq (%rdi,%rdx,8), %rax
movq 0x8(%rdi,%rdx,8), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %rsi, %rdx
jbe 0xa89f
shlq $0x5, %rsi
addq %rsi, %rax
jmp 0xa7c9
movq 0xb860(%rip), %r15      # 0x15fd0
leaq 0x5f94(%rip), %rsi      # 0x1070b
movl $0x44, %edx
movq %r15, %rdi
callq 0x21d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rax
subq %rcx, %rax
je 0xa876
movq (%rcx), %rax
cmpq %rax, 0x8(%rcx)
je 0xa869
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3f5e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xb7d8(%rip), %r12      # 0x15fd0
leaq 0x5ecd(%rip), %rsi      # 0x106cc
movl $0x3e, %edx
movq %r12, %rdi
callq 0x21d0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rax
subq %rcx, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
cmpq %r15, %rdx
jbe 0xa893
leaq (%r15,%r15,2), %rdx
movq (%rcx,%rdx,8), %rax
cmpq %rax, 0x8(%rcx,%rdx,8)
jne 0xa7c9
leaq 0x5ad8(%rip), %rdi      # 0x10348
xorl %esi, %esi
xorl %edx, %edx
jmp 0xa8a6
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
leaq 0x5ab9(%rip), %rdi      # 0x10348
xorl %esi, %esi
jmp 0xa8a6
leaq 0x5aae(%rip), %rdi      # 0x10348
movq %r15, %rsi
jmp 0xa8a6
leaq 0x5aa2(%rip), %rdi      # 0x10348
xorl %eax, %eax
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/whitefusion[P]Jaipur_cardgame-/Player.cpp
// Function: Player::getPoints(int) const
int Player::getPoints(int type) const{
    if (type >= 0 && type <=3)
        return point[type];
    else
        cout << "getPoints: point type not found! Will return total points!" << endl;
    return point[2];
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x3, %esi
ja 0xa92a
movl %esi, %eax
leaq (%rbx,%rax,4), %rbx
addq $0x48, %rbx
jmp 0xa970
movq 0xb69f(%rip), %r14      # 0x15fd0
leaq 0x5e18(%rip), %rsi      # 0x10750
movl $0x3a, %edx
movq %r14, %rdi
callq 0x21d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
addq $0x50, %rbx
movl (%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq