LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: dustin[P]kvtest/./async.hh
// Function: kvtest::AsyncQueue::drainTo(std::queue<kvtest::AsyncOperation*, std::deque<kvtest::AsyncOperation*, std::allocator<kvtest::AsyncOperation*>>>&)
void drainTo(std::queue<AsyncOperation*> &out) {
            LockHolder lh(&mutex);
            if(ops.empty()) {
                if(pthread_cond_wait(&cond, &mutex) != 0) {
                    throw std::runtime_error("Error waiting for signal.");
                }
            }
            for(int i = 0; i < max_drain_ && !ops.empty(); i++) {
                out.push(ops.front());
                ops.pop();
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x40(%rbp)
addq $0x8, %rsi
leaq -0x20(%rbp), %rdi
callq 0x5fc0
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
callq 0x5f40
movb %al, -0x31(%rbp)
jmp 0x5e07
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x5e13
jmp 0x5e9f
movq -0x40(%rbp), %rsi
movq %rsi, %rdi
addq $0x30, %rdi
addq $0x8, %rsi
callq 0x4440
movl %eax, -0x44(%rbp)
jmp 0x5e2c
movl -0x44(%rbp), %eax
cmpl $0x0, %eax
je 0x5e9d
movl $0x10, %edi
callq 0x4110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0xa258(%rip), %rsi      # 0x100a7
callq 0x40c0
jmp 0x5e56
movq -0x50(%rbp), %rdi
movq 0x1318f(%rip), %rsi     # 0x18ff0
movq 0x13150(%rip), %rdx     # 0x18fb8
callq 0x4490
jmp 0x5f40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x5f2e
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x41e0
jmp 0x5f2e
jmp 0x5e9f
movl $0x0, -0x30(%rbp)
movq -0x40(%rbp), %rdx
movl -0x30(%rbp), %ecx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0x51(%rbp)
jge 0x5ed0
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
callq 0x5f40
movb %al, -0x52(%rbp)
jmp 0x5ec8
movb -0x52(%rbp), %al
xorb $-0x1, %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x5ed9
jmp 0x5f1f
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0x60, %rdi
callq 0x5f60
movq %rax, -0x60(%rbp)
jmp 0x5ef4
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0x6060
jmp 0x5f03
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
callq 0x5f80
jmp 0x5f12
jmp 0x5f14
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x5ea6
leaq -0x20(%rbp), %rdi
callq 0x6090
addq $0x70, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x6090
movq -0x28(%rbp), %rdi
callq 0x44c0
// File: dustin[P]kvtest/./async.hh
// Function: kvtest::AsyncQueue::addOperation(kvtest::AsyncOperation*)
void addOperation(AsyncOperation *op) {
            LockHolder lh(&mutex);
            ops.push(op);
            if(pthread_cond_signal(&cond) != 0) {
                throw std::runtime_error("Error signaling change.");
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x38(%rbp)
addq $0x8, %rsi
leaq -0x20(%rbp), %rdi
callq 0x5fc0
movq -0x38(%rbp), %rdi
addq $0x60, %rdi
leaq -0x10(%rbp), %rsi
callq 0x6060
jmp 0x6e08
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
callq 0x4030
cmpl $0x0, %eax
je 0x6e7a
movl $0x10, %edi
callq 0x4110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x9345(%rip), %rsi      # 0x1017a
callq 0x40c0
jmp 0x6e3c
movq -0x40(%rbp), %rdi
movq 0x121a9(%rip), %rsi     # 0x18ff0
movq 0x1216a(%rip), %rdx     # 0x18fb8
callq 0x4490
jmp 0x6e9b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x6e89
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x41e0
jmp 0x6e89
leaq -0x20(%rbp), %rdi
callq 0x6090
addq $0x40, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x6090
movq -0x28(%rbp), %rdi
callq 0x44c0
nopl (%rax,%rax)
// File: wichtounet[P]articles/src/threads/part3/condition_variables.cpp
// Function: consumer(int, BoundedBuffer&)
void consumer(int id, BoundedBuffer& buffer){
    for(int i = 0; i < 50; ++i){
        int value = buffer.fetch();
        std::cout << "Consumer " << id << " fetched " << value << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(250));
    }
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x32, 0x14(%rsp)
jge 0x23a8
movq 0x18(%rsp), %rdi
callq 0x2780
movl %eax, 0x10(%rsp)
movq 0x4ca3(%rip), %rdi      # 0x6fd8
leaq 0x1cc8(%rip), %rsi      # 0x4004
callq 0x2110
movq %rax, %rdi
movl 0x24(%rsp), %esi
callq 0x2190
movq %rax, %rdi
leaq 0x1cb7(%rip), %rsi      # 0x400e
callq 0x2110
movq %rax, %rdi
movl 0x10(%rsp), %esi
callq 0x2190
movq %rax, %rdi
movq 0x4c4e(%rip), %rsi      # 0x6fc0
callq 0x2130
movl $0xfa, 0x4(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x2920
leaq 0x8(%rsp), %rdi
callq 0x2850
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2315
addq $0x28, %rsp
retq
nopl (%rax)
// File: wichtounet[P]articles/src/threads/part3/condition_variables.cpp
// Function: producer(int, BoundedBuffer&)
void producer(int id, BoundedBuffer& buffer){
    for(int i = 0; i < 75; ++i){
        buffer.deposit(i);
        std::cout << "Produced " << id << " produced " << i << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x4b, 0x14(%rsp)
jge 0x2458
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x2940
movq 0x4bf3(%rip), %rdi      # 0x6fd8
leaq 0x1c2c(%rip), %rsi      # 0x4018
callq 0x2110
movq %rax, %rdi
movl 0x24(%rsp), %esi
callq 0x2190
movq %rax, %rdi
leaq 0x1c1b(%rip), %rsi      # 0x4022
callq 0x2110
movq %rax, %rdi
movl 0x14(%rsp), %esi
callq 0x2190
movq %rax, %rdi
movq 0x4b9e(%rip), %rsi      # 0x6fc0
callq 0x2130
movl $0x64, 0x4(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x2920
leaq 0x8(%rsp), %rdi
callq 0x2850
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x23c5
addq $0x28, %rsp
retq
nopl (%rax)
// File: wichtounet[P]articles/src/threads/part3/condition_variables.cpp
// Function: main
int main(){
    BoundedBuffer buffer(200);

    std::thread c1(consumer, 0, std::ref(buffer));
    std::thread c2(consumer, 1, std::ref(buffer));
    std::thread c3(consumer, 2, std::ref(buffer));
    std::thread p1(producer, 0, std::ref(buffer));
    std::thread p2(producer, 1, std::ref(buffer));

    c1.join();
    c2.join();
    c3.join();
    p1.join();
    p2.join();

    return 0;
}

// Assembly:
subq $0x138, %rsp            # imm = 0x138
movl $0x0, 0x134(%rsp)
leaq 0x90(%rsp), %rdi
movq %rdi, (%rsp)
movl $0xc8, %esi
callq 0x2a00
movq (%rsp), %rdi
movl $0x0, 0x84(%rsp)
callq 0x2ad0
movq %rax, 0x78(%rsp)
leaq -0x1a8(%rip), %rsi      # 0x2300
leaq 0x88(%rsp), %rdi
leaq 0x84(%rsp), %rdx
leaq 0x78(%rsp), %rcx
callq 0x2b00
jmp 0x24c4
movl $0x1, 0x5c(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x2ad0
movq %rax, 0x50(%rsp)
leaq -0x1e5(%rip), %rsi      # 0x2300
leaq 0x60(%rsp), %rdi
leaq 0x5c(%rsp), %rdx
leaq 0x50(%rsp), %rcx
callq 0x2b00
jmp 0x24fb
movl $0x2, 0x44(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x2ad0
movq %rax, 0x38(%rsp)
leaq -0x21c(%rip), %rsi      # 0x2300
leaq 0x48(%rsp), %rdi
leaq 0x44(%rsp), %rdx
leaq 0x38(%rsp), %rcx
callq 0x2b00
jmp 0x2532
movl $0x0, 0x2c(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x2ad0
movq %rax, 0x20(%rsp)
leaq -0x1a3(%rip), %rsi      # 0x23b0
leaq 0x30(%rsp), %rdi
leaq 0x2c(%rsp), %rdx
leaq 0x20(%rsp), %rcx
callq 0x2b00
jmp 0x2569
movl $0x1, 0x14(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x2ad0
movq %rax, 0x8(%rsp)
leaq -0x1da(%rip), %rsi      # 0x23b0
leaq 0x18(%rsp), %rdi
leaq 0x14(%rsp), %rdx
leaq 0x8(%rsp), %rcx
callq 0x2b00
jmp 0x25a0
leaq 0x88(%rsp), %rdi
callq 0x2180
jmp 0x25af
leaq 0x60(%rsp), %rdi
callq 0x2180
jmp 0x25bb
leaq 0x48(%rsp), %rdi
callq 0x2180
jmp 0x25c7
leaq 0x30(%rsp), %rdi
callq 0x2180
jmp 0x25d3
leaq 0x18(%rsp), %rdi
callq 0x2180
jmp 0x25df
movl $0x0, 0x134(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x2bd0
leaq 0x30(%rsp), %rdi
callq 0x2bd0
leaq 0x48(%rsp), %rdi
callq 0x2bd0
leaq 0x60(%rsp), %rdi
callq 0x2bd0
leaq 0x88(%rsp), %rdi
callq 0x2bd0
leaq 0x90(%rsp), %rdi
callq 0x2bf0
movl 0x134(%rsp), %eax
addq $0x138, %rsp            # imm = 0x138
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x26d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x26c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x26ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x26b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x26a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x2bd0
leaq 0x30(%rsp), %rdi
callq 0x2bd0
leaq 0x48(%rsp), %rdi
callq 0x2bd0
leaq 0x60(%rsp), %rdi
callq 0x2bd0
leaq 0x88(%rsp), %rdi
callq 0x2bd0
leaq 0x90(%rsp), %rdi
callq 0x2bf0
movq 0x70(%rsp), %rdi
callq 0x21a0
nopl (%rax,%rax)
// File: wichtounet[P]articles/src/threads/part3/condition_variables.cpp
// Function: BoundedBuffer::fetch()
int fetch(){
        std::unique_lock<std::mutex> l(lock);

        not_empty.wait(l, [this](){return count != 0; });

        int result = buffer[front];
        front = (front + 1) % capacity;
        --count;

        l.unlock();
        not_full.notify_one();

        return result;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x18, %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x2c40
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rsi
movq %rax, %rdi
addq $0x70, %rdi
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdx
callq 0x2c80
jmp 0x27c8
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movslq 0xc(%rax), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x18(%rsp)
movl 0x8(%rax), %ecx
movl 0xc(%rax), %eax
incl %eax
cltd
idivl %ecx
movq 0x8(%rsp), %rax
movl %edx, 0xc(%rax)
movl 0x14(%rax), %ecx
decl %ecx
movl %ecx, 0x14(%rax)
leaq 0x30(%rsp), %rdi
callq 0x2cd0
jmp 0x2802
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
callq 0x20a0
movl 0x18(%rsp), %eax
movl %eax, 0x4(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x2d20
movl 0x4(%rsp), %eax
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x2d20
movq 0x20(%rsp), %rdi
callq 0x21a0
nopl (%rax)
// File: wichtounet[P]articles/src/threads/part3/condition_variables.cpp
// Function: BoundedBuffer::deposit(int)
void deposit(int data){
        std::unique_lock<std::mutex> l(lock);

        not_full.wait(l, [this](){return count != capacity; });

        buffer[rear] = data;
        rear = (rear + 1) % capacity;
        ++count;

        l.unlock();
        not_empty.notify_one();
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq 0x40(%rsp), %rsi
movq %rsi, (%rsp)
addq $0x18, %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x2c40
movq (%rsp), %rax
movq 0x8(%rsp), %rsi
movq %rax, %rdi
addq $0x40, %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdx
callq 0x2e30
jmp 0x298a
movq (%rsp), %rax
movl 0x3c(%rsp), %esi
movq (%rax), %rcx
movslq 0x10(%rax), %rdx
movl %esi, (%rcx,%rdx,4)
movl 0x8(%rax), %ecx
movl 0x10(%rax), %eax
incl %eax
cltd
idivl %ecx
movq (%rsp), %rax
movl %edx, 0x10(%rax)
movl 0x14(%rax), %ecx
incl %ecx
movl %ecx, 0x14(%rax)
leaq 0x28(%rsp), %rdi
callq 0x2cd0
jmp 0x29c2
movq (%rsp), %rdi
addq $0x70, %rdi
callq 0x20a0
leaq 0x28(%rsp), %rdi
callq 0x2d20
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x2d20
movq 0x18(%rsp), %rdi
callq 0x21a0
// File: shanet[P]Crypto-Example/crypto_file_example.cpp
// Function: main
int main(int argc, char **argv) {
  if(argc != 2) {
    fprintf(stderr, "Invalid number of arguments given.\nUsage: %s [input file]\n", argv[0]);
    return 1;
  }

  Crypto crypto;

  char *encryptedOutput = appendToString(argv[1], (char*)".enc");
  char *decryptedOutput = appendToString(argv[1], (char*)".dec");

  encryptFile(&crypto, argv[1], encryptedOutput);
  decryptFile(&crypto, encryptedOutput, decryptedOutput);

  free(encryptedOutput);
  free(decryptedOutput);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x35da
movq 0x2a22(%rip), %rax      # 0x5fd8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xaa9(%rip), %rsi       # 0x4070
movb $0x0, %al
callq 0x2320
movl $0x1, -0x4(%rbp)
jmp 0x3692
leaq -0x58(%rbp), %rdi
callq 0x2850
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xab9(%rip), %rsi       # 0x40ab
callq 0x36b0
movq %rax, -0x80(%rbp)
jmp 0x35fd
movq -0x80(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xa9c(%rip), %rsi       # 0x40b0
callq 0x36b0
movq %rax, -0x88(%rbp)
jmp 0x3622
movq -0x88(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x60(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x3740
jmp 0x3644
movq -0x60(%rbp), %rsi
movq -0x78(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x3840
jmp 0x3657
movq -0x60(%rbp), %rdi
callq 0x22d0
movq -0x78(%rbp), %rdi
callq 0x22d0
movl $0x0, -0x4(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2b20
jmp 0x3692
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2b20
jmp 0x369e
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x23d0
nopw (%rax,%rax)
// File: shanet[P]Crypto-Example/crypto_file_example.cpp
// Function: appendToString(char*, char*)
char* appendToString(char *string, char *suffix) {
  char *appenedString = (char*)malloc(strlen(string) + strlen(suffix) + 1);

  if(appenedString == NULL) {
    fprintf(stderr, "Failed to allocate memory\n");
    exit(1);
  }

  sprintf(appenedString, "%s%s", string, suffix);
  return appenedString;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2130
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2130
movq -0x20(%rbp), %rdi
addq %rax, %rdi
addq $0x1, %rdi
callq 0x2300
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3713
movq 0x28e0(%rip), %rax      # 0x5fd8
movq (%rax), %rdi
leaq 0x93e(%rip), %rsi       # 0x4040
movb $0x0, %al
callq 0x2320
movl $0x1, %edi
callq 0x22e0
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0xa7e(%rip), %rsi       # 0x41a4
movb $0x0, %al
callq 0x20a0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3920
cltq
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl %eax, %esi
leaq 0x941(%rip), %rdi       # 0x40b5
movb $0x0, %al
callq 0x2050
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x2f50
movl %eax, -0x34(%rbp)
cmpl $-0x1, -0x34(%rbp)
jne 0x37bb
movq 0x2838(%rip), %rax      # 0x5fd8
movq (%rax), %rdi
leaq 0x925(%rip), %rsi       # 0x40cf
movb $0x0, %al
callq 0x2320
movl $0x1, %edi
callq 0x22e0
movl -0x34(%rbp), %esi
leaq 0x91d(%rip), %rdi       # 0x40e2
movb $0x0, %al
callq 0x2050
movq -0x30(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x2550
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x2130
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x3a50
movq -0x18(%rbp), %rsi
leaq 0x8e5(%rip), %rdi       # 0x40f6
movb $0x0, %al
callq 0x2050
movq -0x20(%rbp), %rdi
callq 0x22d0
movq -0x30(%rbp), %rdi
callq 0x22d0
movq -0x40(%rbp), %rdi
callq 0x22d0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3920
cltq
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x26c0
cltq
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x3060
movl %eax, -0x44(%rbp)
cmpl $-0x1, -0x44(%rbp)
jne 0x38be
movq 0x2735(%rip), %rax      # 0x5fd8
movq (%rax), %rdi
leaq 0x869(%rip), %rsi       # 0x4116
movb $0x0, %al
callq 0x2320
movl $0x1, %edi
callq 0x22e0
movl -0x44(%rbp), %esi
leaq 0x861(%rip), %rdi       # 0x4129
movb $0x0, %al
callq 0x2050
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
movslq -0x44(%rbp), %rdx
callq 0x3a50
movq -0x18(%rbp), %rsi
leaq 0x852(%rip), %rdi       # 0x413d
movb $0x0, %al
callq 0x2050
movq -0x20(%rbp), %rdi
callq 0x22d0
movq -0x30(%rbp), %rdi
callq 0x22d0
movq -0x40(%rbp), %rdi
callq 0x22d0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x853(%rip), %rsi       # 0x418e
callq 0x22c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3984
movq 0x2686(%rip), %rax      # 0x5fd8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x2040
movl (%rax), %edi
callq 0x20f0
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x7ec(%rip), %rsi       # 0x415f
movb $0x0, %al
callq 0x2320
movl $0x1, %edi
callq 0x22e0
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x2280
movq -0x18(%rbp), %rdi
callq 0x2030
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2280
movq -0x20(%rbp), %rdi
callq 0x2300
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x39f1
movq 0x2602(%rip), %rax      # 0x5fd8
movq (%rax), %rdi
leaq 0x660(%rip), %rsi       # 0x4040
movb $0x0, %al
callq 0x2320
movl $0x1, %edi
callq 0x22e0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x2340
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x3a3a
movq 0x25b9(%rip), %rax      # 0x5fd8
movq (%rax), %rdi
leaq 0x767(%rip), %rsi       # 0x4190
movb $0x0, %al
callq 0x2320
movl $0x1, %edi
callq 0x22e0
movq -0x18(%rbp), %rdi
callq 0x2230
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x6ee(%rip), %rsi       # 0x415d
callq 0x22c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3ab8
movq 0x2552(%rip), %rax      # 0x5fd8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x2040
movl (%rax), %edi
callq 0x20f0
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x6b8(%rip), %rsi       # 0x415f
movb $0x0, %al
callq 0x2320
movl $0x1, %edi
callq 0x22e0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x23f0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x3afe
movq 0x24f5(%rip), %rax      # 0x5fd8
movq (%rax), %rdi
leaq 0x68b(%rip), %rsi       # 0x4178
movb $0x0, %al
callq 0x2320
movl $0x1, %edi
callq 0x22e0
movq -0x20(%rbp), %rdi
callq 0x2230
addq $0x30, %rsp
popq %rbp
retq
// File: 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
subq $0x50, %rsp
movl %edx, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpb $0x0, 0x9d6e(%rip)      # 0xc1b8
jne 0x248f
leaq 0x9d65(%rip), %rdi      # 0xc1b8
callq 0x22d0
cmpl $0x0, %eax
je 0x248f
leaq 0x9d3c(%rip), %rdi      # 0xc1a0
callq 0x4560
leaq 0x2110(%rip), %rdi      # 0x4580
leaq 0x9d29(%rip), %rsi      # 0xc1a0
leaq 0x9d02(%rip), %rdx      # 0xc180
callq 0x2140
leaq 0x9d2e(%rip), %rdi      # 0xc1b8
callq 0x20f0
leaq 0x9d0a(%rip), %rdi      # 0xc1a0
callq 0x45e0
movq -0x18(%rbp), %rsi
leaq 0x9cfa(%rip), %rdi      # 0xc1a0
callq 0x4600
movl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edi
callq 0x4880
movl %eax, -0x1c(%rbp)
leaq 0x9cdd(%rip), %rdi      # 0xc1a0
leaq -0x1c(%rbp), %rsi
callq 0x4850
movq -0x10(%rbp), %rdi
leaq 0x9cc9(%rip), %rsi      # 0xc1a0
callq 0x48a0
leaq 0x9cbd(%rip), %rdi      # 0xc1a0
callq 0x45e0
leaq 0x9cb1(%rip), %rdi      # 0xc1a0
leaq -0x4(%rbp), %rsi
callq 0x48d0
leaq 0x9ca1(%rip), %rdi      # 0xc1a0
leaq -0x4(%rbp), %rsi
callq 0x48d0
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4940
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4970
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x49a0
testb $0x1, %al
jne 0x253d
jmp 0x258d
leaq -0x30(%rbp), %rdi
callq 0x49e0
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %edi
callq 0x4880
movl %eax, -0x40(%rbp)
leaq 0x9c3d(%rip), %rdi      # 0xc1a0
movl $0x1, %esi
callq 0x4a00
movl -0x40(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
leaq 0x9c23(%rip), %rsi      # 0xc1a0
callq 0x48a0
leaq -0x30(%rbp), %rdi
callq 0x4a20
jmp 0x252a
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4560
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x4a40
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x4a70
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4aa0
testb $0x1, %al
jne 0x25fc
jmp 0x2689
leaq -0x40(%rbp), %rdi
callq 0x4ae0
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4b30
movl %eax, -0x84(%rbp)
jmp 0x261a
movl -0x84(%rbp), %edi
xorl %esi, %esi
callq 0x4b00
movl %eax, -0x88(%rbp)
jmp 0x262f
movl -0x88(%rbp), %eax
movl %eax, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x54(%rbp), %rsi
callq 0x48d0
jmp 0x2647
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
movl -0x54(%rbp), %eax
movl %eax, -0x68(%rbp)
movl -0x68(%rbp), %edx
callq 0x2430
jmp 0x265f
jmp 0x2661
leaq -0x40(%rbp), %rdi
callq 0x4b70
jmp 0x25e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4580
jmp 0x2787
movq -0x8(%rbp), %rdi
callq 0x4b30
movl %eax, -0x8c(%rbp)
jmp 0x269a
movl -0x8c(%rbp), %edi
xorl %esi, %esi
callq 0x4b00
movl %eax, -0x90(%rbp)
jmp 0x26af
movl -0x90(%rbp), %eax
movl %eax, -0x6c(%rbp)
movq -0x18(%rbp), %rax
movl -0x6c(%rbp), %ecx
movl %ecx, (%rax)
movl $0x0, -0x70(%rbp)
movslq -0x70(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4b90
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jae 0x2733
movslq -0x70(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x4a00
movl (%rax), %eax
movl %eax, -0x78(%rbp)
movl -0x78(%rbp), %edi
callq 0x4880
movl %eax, -0x9c(%rbp)
jmp 0x270d
movl -0x9c(%rbp), %eax
movl %eax, -0x74(%rbp)
movslq -0x70(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x4a00
movl -0x74(%rbp), %ecx
movl %ecx, (%rax)
movl -0x70(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x70(%rbp)
jmp 0x26c8
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x80(%rbp)
movl -0x80(%rbp), %edi
callq 0x4880
movl %eax, -0xa0(%rbp)
jmp 0x2757
movq -0xa8(%rbp), %rdi
movl -0xa0(%rbp), %eax
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %edx
leaq -0x30(%rbp), %rsi
callq 0x2430
jmp 0x2775
leaq -0x30(%rbp), %rdi
callq 0x4580
addq $0xb0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x22b0
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x2a2d
jmp 0x2b85
movl -0xc(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4bb0
movl %eax, %ecx
movl -0x50(%rbp), %eax
cmpl %ecx, %eax
jg 0x2a4a
jmp 0x2b85
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4bf0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4c20
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4c50
testb $0x1, %al
jne 0x2a86
jmp 0x2b5b
leaq -0x20(%rbp), %rdi
callq 0x4c90
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rdi
callq 0x4b90
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x2b4b
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x4a00
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %edi
callq 0x4cb0
cmpl -0xc(%rbp), %eax
jle 0x2b38
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x4a00
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %edi
callq 0x4cb0
addl -0x10(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x4a00
movl (%rax), %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %edi
callq 0x4cc0
movl -0x5c(%rbp), %edi
movzbl %al, %esi
andl $0x1, %esi
callq 0x4b00
movl %eax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x4a00
movl -0x40(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x2b3a
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x2a9b
jmp 0x2b4d
leaq -0x20(%rbp), %rdi
callq 0x4ce0
jmp 0x2a70
movq -0x8(%rbp), %rdi
callq 0x4bb0
movl %eax, -0x4c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4bb0
movl -0x4c(%rbp), %ecx
addl -0x10(%rbp), %ecx
cmpl %ecx, %eax
jge 0x2b85
movq -0x8(%rbp), %rdi
callq 0x4b30
jmp 0x2b67
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x4d00
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4bf0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4c20
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4c50
testb $0x1, %al
jne 0x2bf6
jmp 0x2ca7
leaq -0x28(%rbp), %rdi
callq 0x4c90
movq %rax, -0x38(%rbp)
movb $0x0, -0x39(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x38(%rbp), %rdi
callq 0x4b90
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x2c80
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x4d20
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %edi
callq 0x4cb0
movl %eax, -0x7c(%rbp)
jmp 0x2c4b
movl -0x7c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0x2c70
movb $0x1, -0x39(%rbp)
jmp 0x2c80
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x4db0
jmp 0x2cc7
jmp 0x2c72
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x2c0f
testb $0x1, -0x39(%rbp)
je 0x2c97
movq -0x70(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x4d40
jmp 0x2c95
jmp 0x2c97
jmp 0x2c99
leaq -0x28(%rbp), %rdi
callq 0x4ce0
jmp 0x2be0
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x2cba
movq -0x70(%rbp), %rdi
callq 0x4db0
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x22b0
// File: conp-solutions[P]cnfmiter/Main.cc
// Function: print_formula(CNFMITER::Formula&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void print_formula(Formula &f, std::string s)
{
    std::cout << "c CNFmiter, Norbert Manthey, 2020" << std::endl;
    if (!s.empty()) std::cout << "c " << s << std::endl;
    std::cout << "c " << std::endl;
    std::cout << "p cnf " << f.nVars() << " " << f.clauses.size() << std::endl;
    for (const auto &c : f.clauses) {
        std::stringstream s;
        s << c;
        printf("%s 0\n", s.str().c_str());
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rsi, -0x1f0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x9007(%rip), %rdi      # 0xbfb8
leaq 0x5104(%rip), %rsi      # 0x80bc
callq 0x2190
movq %rax, %rdi
movq 0x8fd1(%rip), %rsi      # 0xbf98
callq 0x21b0
movq -0x1f0(%rbp), %rdi
callq 0x2270
testb $0x1, %al
jne 0x300d
movq 0x8fd5(%rip), %rdi      # 0xbfb8
leaq 0x50f4(%rip), %rsi      # 0x80de
callq 0x2190
movq -0x1f0(%rbp), %rsi
movq %rax, %rdi
callq 0x2150
movq %rax, %rdi
movq 0x8f90(%rip), %rsi      # 0xbf98
callq 0x21b0
movq 0x8fa4(%rip), %rdi      # 0xbfb8
leaq 0x50c3(%rip), %rsi      # 0x80de
callq 0x2190
movq %rax, %rdi
movq 0x8f6e(%rip), %rsi      # 0xbf98
callq 0x21b0
movq 0x8f82(%rip), %rdi      # 0xbfb8
leaq 0x50a4(%rip), %rsi      # 0x80e1
callq 0x2190
movq %rax, -0x200(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4bb0
movq -0x200(%rbp), %rdi
movl %eax, %esi
callq 0x22a0
movq %rax, %rdi
leaq 0x524c(%rip), %rsi      # 0x82b6
callq 0x2190
movq %rax, -0x1f8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x4bc0
movq -0x1f8(%rbp), %rdi
movq %rax, %rsi
callq 0x2070
movq %rax, %rdi
movq 0x8efc(%rip), %rsi      # 0xbf98
callq 0x21b0
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4bf0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4c20
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4c50
testb $0x1, %al
jne 0x30dd
jmp 0x31a2
leaq -0x20(%rbp), %rdi
callq 0x4c90
movq %rax, -0x30(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x2110
leaq -0x1a8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4e40
jmp 0x3108
leaq -0x1e8(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x2180
jmp 0x311d
leaq -0x1e8(%rbp), %rdi
callq 0x20c0
movq %rax, %rsi
leaq 0x4fb5(%rip), %rdi      # 0x80e8
xorl %eax, %eax
callq 0x2040
jmp 0x313c
leaq -0x1e8(%rbp), %rdi
callq 0x20e0
leaq -0x1b8(%rbp), %rdi
callq 0x2120
leaq -0x20(%rbp), %rdi
callq 0x4ce0
jmp 0x30c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x3194
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x20e0
leaq -0x1b8(%rbp), %rdi
callq 0x2120
jmp 0x31ab
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1c0(%rbp), %rdi
callq 0x22b0
nopw (%rax,%rax)
// File: agorenst[P]trie/./radixtree.h
// Function: node<int>::edge_to_follow(int)
typename std::list<edge>::iterator edge_to_follow(T t) {
            for (auto it = edge_list.begin(); it != edge_list.end(); ++it) {
                if (*(it->first.begin()) == t) {
                    return it;
                }
            }
            return edge_list.end();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x4e40
movq %rax, -0x8(%rbp)
movq -0x30(%rbp), %rdi
callq 0x47d0
movq %rax, -0x20(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4e70
testb $0x1, %al
jne 0x4720
jmp 0x4754
leaq -0x8(%rbp), %rdi
callq 0x4970
movq %rax, %rdi
callq 0x4990
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4a70
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x4747
jmp 0x4761
jmp 0x4749
leaq -0x8(%rbp), %rdi
callq 0x4ea0
jmp 0x4700
movq -0x30(%rbp), %rdi
callq 0x47d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xe16(%rip), %rsi       # 0x7189
callq 0x2110
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4e40
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x47d0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4e70
testb $0x1, %al
jne 0x63b0
jmp 0x648f
leaq -0x20(%rbp), %rdi
callq 0x64a0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xdd6(%rip), %rsi       # 0x719e
callq 0x2110
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x3cf0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x6350
movq -0x10(%rbp), %rdi
leaq 0xdb6(%rip), %rsi       # 0x71a7
callq 0x2110
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x4990
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x49c0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4a40
testb $0x1, %al
jne 0x642b
jmp 0x6461
leaq -0x40(%rbp), %rdi
callq 0x4a70
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rax
movl (%rax), %esi
callq 0x21c0
movq %rax, %rdi
leaq 0xd78(%rip), %rsi       # 0x71c9
callq 0x2110
leaq -0x40(%rbp), %rdi
callq 0x4ad0
jmp 0x6418
movq -0x10(%rbp), %rdi
leaq 0xd5f(%rip), %rsi       # 0x71cb
callq 0x2110
movq -0x10(%rbp), %rdi
leaq 0xd53(%rip), %rsi       # 0x71cf
callq 0x2110
leaq -0x20(%rbp), %rdi
callq 0x4ea0
jmp 0x639a
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl $0x2a, -0x8(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x10b0
movq -0x48(%rbp), %rdx
leaq 0xd60(%rip), %rsi       # 0x204e
leaq -0x28(%rbp), %rdi
callq 0x1080
jmp 0x12f9
leaq -0x28(%rbp), %rdi
callq 0x1280
jmp 0x1304
leaq -0x28(%rbp), %rdi
callq 0x1030
leaq -0x29(%rbp), %rdi
callq 0x1070
movl -0x8(%rbp), %edi
callq 0x1200
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1349
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1030
leaq -0x29(%rbp), %rdi
callq 0x1070
movq -0x38(%rbp), %rdi
callq 0x10a0
// File: whitefusion[P]Jaipur_cardgame-/./Game.h
// Function: Game::getPlayer(int) const
Player& getPlayer(int id) const {
      if(id == 1) 
          return p1;
      else 
          return p2;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x4da7
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4db3
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0x98(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq 0x25d6c(%rip), %rdi     # 0x2b1f8
callq 0x5c90
movl (%rax), %eax
movl %eax, -0x84(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x2370
movq -0x80(%rbp), %rdx
movb $0x0, -0x72(%rbp)
movb $0x0, -0x73(%rbp)
leaq 0x18ce5(%rip), %rsi     # 0x1e19e
leaq -0x38(%rbp), %rdi
callq 0x4cb0
jmp 0x54c4
leaq 0x25d2d(%rip), %rdi     # 0x2b1f8
leaq -0x38(%rbp), %rsi
callq 0x5d70
movq %rax, -0xa0(%rbp)
jmp 0x54dd
movl -0x84(%rbp), %ecx
movq -0xa0(%rbp), %rdx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0xa1(%rbp)
jl 0x5587
movq -0x98(%rbp), %rsi
leaq 0x25cf0(%rip), %rdi     # 0x2b1f8
callq 0x5c90
movq %rax, -0xb0(%rbp)
jmp 0x5516
movq -0xb0(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xbc(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x2370
movq -0xb8(%rbp), %rdx
movb $0x1, -0x72(%rbp)
leaq 0x18c50(%rip), %rsi     # 0x1e197
leaq -0x70(%rbp), %rdi
callq 0x4cb0
jmp 0x5552
movb $0x1, -0x73(%rbp)
leaq 0x25c9b(%rip), %rdi     # 0x2b1f8
leaq -0x70(%rbp), %rsi
callq 0x5d70
movq %rax, -0xc8(%rbp)
jmp 0x556f
movl -0xbc(%rbp), %eax
movq -0xc8(%rbp), %rcx
cmpl (%rcx), %eax
setle %al
movb %al, -0xa1(%rbp)
movb -0xa1(%rbp), %al
movb %al, -0xc9(%rbp)
testb $0x1, -0x73(%rbp)
jne 0x559b
jmp 0x55a4
leaq -0x70(%rbp), %rdi
callq 0x2130
testb $0x1, -0x72(%rbp)
jne 0x55ac
jmp 0x55b5
leaq -0x71(%rbp), %rdi
callq 0x2260
leaq -0x38(%rbp), %rdi
callq 0x2130
leaq -0x39(%rbp), %rdi
callq 0x2260
movb -0xc9(%rbp), %al
testb $0x1, %al
jne 0x55d6
jmp 0x5662
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdi
callq 0x2040
movb $0x1, -0x1(%rbp)
jmp 0x5688
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x5657
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x564e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x563b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
testb $0x1, -0x73(%rbp)
jne 0x5630
jmp 0x5639
leaq -0x70(%rbp), %rdi
callq 0x2130
jmp 0x563b
testb $0x1, -0x72(%rbp)
jne 0x5643
jmp 0x564c
leaq -0x71(%rbp), %rdi
callq 0x2260
jmp 0x564e
leaq -0x38(%rbp), %rdi
callq 0x2130
leaq -0x39(%rbp), %rdi
callq 0x2260
jmp 0x5696
movq 0x25967(%rip), %rdi     # 0x2afd0
leaq 0x18b36(%rip), %rsi     # 0x1e1a6
callq 0x2200
movq %rax, %rdi
movq 0x25941(%rip), %rsi     # 0x2afc0
callq 0x2240
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2360
nop
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x80(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5830
leaq -0x48(%rbp), %rdi
callq 0x5e50
jmp 0x56ce
leaq -0x60(%rbp), %rdi
callq 0x5e80
leaq 0x25b4a(%rip), %rdi     # 0x2b228
leaq -0x38(%rbp), %rsi
callq 0x5ea0
movq %rdx, -0x90(%rbp)
movq %rax, -0x88(%rbp)
jmp 0x56f7
movq -0x90(%rbp), %rax
movq -0x88(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movq %rax, -0x68(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x5ee0
movq -0x48(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x48(%rbp), %rsi
addq $0x8, %rsi
leaq -0x60(%rbp), %rdi
callq 0x5f10
testb $0x1, %al
jne 0x5739
jmp 0x579a
movl -0x14(%rbp), %eax
movl %eax, -0x94(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5f40
movq %rax, %rcx
movl -0x94(%rbp), %eax
cmpl 0x20(%rcx), %eax
jne 0x578d
movq -0x80(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x20(%rax)
movb $0x1, -0x1(%rbp)
movl $0x1, -0x74(%rbp)
jmp 0x580b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2130
jmp 0x5822
jmp 0x578f
leaq -0x60(%rbp), %rdi
callq 0x5f60
jmp 0x5722
movq 0x2582f(%rip), %rdi     # 0x2afd0
leaq 0x18a12(%rip), %rsi     # 0x1e1ba
callq 0x2200
movq %rax, -0xa0(%rbp)
jmp 0x57b6
movq -0xa0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x21d0
movq %rax, -0xa8(%rbp)
jmp 0x57cf
movq -0xa8(%rbp), %rdi
leaq 0x18f7c(%rip), %rsi     # 0x1e759
callq 0x2200
movq %rax, -0xb0(%rbp)
jmp 0x57eb
movq -0xb0(%rbp), %rdi
movq 0x257c7(%rip), %rsi     # 0x2afc0
callq 0x2240
jmp 0x5800
movb $0x0, -0x1(%rbp)
movl $0x1, -0x74(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2130
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x2360
nopl (%rax,%rax)
// File: whitefusion[P]Jaipur_cardgame-/AllTokens.cpp
// Function: All_Tokens::All_Tokens()
All_Tokens::All_Tokens(): number{5,5,5,9,7,7,1}{
    int i;
    size_t j;
    Token tmpT; // temporary token
    vector<Token> tmpTs; // temporary vector of tokens 

    for (i = 0; i < 7; ++i){
        tmpT.setType(tokenName[i+1]); 
        for (j = 0; j < tokens.at(i).size(); ++j){
            tmpT.setVal(tokens.at(i).at(j));
            tmpTs.push_back(tmpT);
        } 
        allTokens.push_back(tmpTs);
        tmpTs.clear();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
callq 0x99e0
movq -0x98(%rbp), %rax
movups 0x15ced(%rip), %xmm0    # 0x1e444
movups %xmm0, 0x24(%rax)
movups 0x15cd6(%rip), %xmm0    # 0x1e438
movups %xmm0, 0x18(%rax)
leaq -0x40(%rbp), %rdi
callq 0x53d0
jmp 0x8771
leaq -0x68(%rbp), %rdi
callq 0x9a00
movl $0x0, -0xc(%rbp)
cmpl $0x7, -0xc(%rbp)
jge 0x88f7
movl -0xc(%rbp), %eax
incl %eax
movl %eax, -0x8c(%rbp)
leaq 0x22ac3(%rip), %rdi     # 0x2b260
leaq -0x8c(%rbp), %rsi
callq 0x9a20
movq %rax, -0xa8(%rbp)
jmp 0x87b2
movq -0xa8(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x20e0
jmp 0x87c7
leaq -0x40(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x5460
jmp 0x87d9
leaq -0x88(%rbp), %rdi
callq 0x2130
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xb8(%rbp)
movslq -0xc(%rbp), %rsi
leaq 0x22a8d(%rip), %rdi     # 0x2b290
callq 0x9b00
movq %rax, -0xb0(%rbp)
jmp 0x8811
movq -0xb0(%rbp), %rdi
callq 0x9b40
movq %rax, %rcx
movq -0xb8(%rbp), %rax
cmpq %rcx, %rax
jae 0x88ce
movslq -0xc(%rbp), %rsi
leaq 0x22a55(%rip), %rdi     # 0x2b290
callq 0x9b00
movq %rax, -0xc0(%rbp)
jmp 0x8849
movq -0xc0(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9b60
movq %rax, -0xc8(%rbp)
jmp 0x8862
movq -0xc8(%rbp), %rax
movl (%rax), %esi
leaq -0x40(%rbp), %rdi
callq 0x56a0
jmp 0x8876
leaq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x9ba0
jmp 0x8885
jmp 0x8887
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x87ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x8924
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x8912
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x2130
jmp 0x8912
movq -0xa0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x9c10
jmp 0x88e0
leaq -0x68(%rbp), %rdi
callq 0x9c80
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8781
leaq -0x68(%rbp), %rdi
callq 0x9ca0
leaq -0x40(%rbp), %rdi
callq 0x5440
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x68(%rbp), %rdi
callq 0x9ca0
leaq -0x40(%rbp), %rdi
callq 0x5440
movq -0x98(%rbp), %rdi
callq 0x9d00
movq -0x48(%rbp), %rdi
callq 0x2360
nopl (%rax)