LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: dustin[P]kvtest/./callbacks.hh
// Function: kvtest::RememberingCallback<bool>::waitForValue()
void waitForValue() {
            LockHolder lh(&mutex);
            if (!fired) {
                if(pthread_cond_wait(&cond, &mutex) != 0) {
                    throw std::runtime_error("Failed to wait for condition.");
                }
            }
            assert(fired);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x30(%rbp)
addq $0x10, %rsi
leaq -0x18(%rbp), %rdi
callq 0x7b50
movq -0x30(%rbp), %rax
testb $0x1, 0x9(%rax)
jne 0x6fc2
movq -0x30(%rbp), %rsi
movq %rsi, %rdi
addq $0x38, %rdi
addq $0x10, %rsi
callq 0x33f0
movl %eax, -0x34(%rbp)
jmp 0x6f58
movl -0x34(%rbp), %eax
cmpl $0x0, %eax
je 0x6fc0
movl $0x10, %edi
callq 0x3110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x7310(%rip), %rsi      # 0xe28b
callq 0x30c0
jmp 0x6f82
movq -0x40(%rbp), %rdi
movq 0xe063(%rip), %rsi      # 0x14ff0
movq 0xe024(%rip), %rdx      # 0x14fb8
callq 0x3430
jmp 0x700e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x6ffc
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x31d0
jmp 0x6ffc
jmp 0x6fc2
movq -0x30(%rbp), %rax
testb $0x1, 0x9(%rax)
je 0x6fce
jmp 0x6fed
leaq 0x70af(%rip), %rdi      # 0xe084
leaq 0x72cd(%rip), %rsi      # 0xe2a9
movl $0x4d, %edx
leaq 0x72d0(%rip), %rcx      # 0xe2b8
callq 0x3170
leaq -0x18(%rbp), %rdi
callq 0x7bf0
addq $0x40, %rsp
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0x7bf0
movq -0x20(%rbp), %rdi
callq 0x3450
nop
// File: dustin[P]kvtest/./locks.hh
// Function: kvtest::LockHolder::LockHolder(pthread_mutex_t*)
LockHolder(pthread_mutex_t *m) {
            mutex = m;
            if(pthread_mutex_lock(mutex) != 0) {
                throw std::runtime_error("Failed to acquire lock.");
            }
            unlocked = false;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x33d0
cmpl $0x0, %eax
je 0x7bcc
movl $0x10, %edi
callq 0x3110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x6650(%rip), %rsi      # 0xe1e7
callq 0x30c0
jmp 0x7b9e
movq -0x30(%rbp), %rdi
movq 0xd447(%rip), %rsi      # 0x14ff0
movq 0xd408(%rip), %rdx      # 0x14fb8
callq 0x3430
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31d0
jmp 0x7bda
movq -0x28(%rbp), %rax
movb $0x0, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3450
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dustin[P]kvtest/./callbacks.hh
// Function: kvtest::RememberingCallback<kvtest::GetValue>::callback(kvtest::GetValue&)
void callback(T &value) {
            LockHolder lh(&mutex);
            val = value;
            fired = true;
            if(pthread_cond_broadcast(&cond) != 0) {
                throw std::runtime_error("Failed to broadcast 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 $0x38, %rsi
leaq -0x20(%rbp), %rdi
callq 0x7b50
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rdi
callq 0x7f60
jmp 0x7e18
movq -0x38(%rbp), %rdi
movb $0x1, 0x30(%rdi)
addq $0x60, %rdi
callq 0x30a0
cmpl $0x0, %eax
je 0x7e8e
movl $0x10, %edi
callq 0x3110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x6426(%rip), %rsi      # 0xe26f
callq 0x30c0
jmp 0x7e50
movq -0x40(%rbp), %rdi
movq 0xd195(%rip), %rsi      # 0x14ff0
movq 0xd156(%rip), %rdx      # 0x14fb8
callq 0x3430
jmp 0x7eaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x7e9d
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x31d0
jmp 0x7e9d
leaq -0x20(%rbp), %rdi
callq 0x7bf0
addq $0x40, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x7bf0
movq -0x28(%rbp), %rdi
callq 0x3450
nop
// File: dustin[P]kvtest/suite.cc
// Function: kvtest::TestSuite::initTests()
void TestSuite::initTests() {
    const char *req = getenv("KVTEST_SUITE");
    if (req == NULL || (strcmp(req, "full") == 0)) {
        addTest(new TestTest());
        addTest(new WriteTest());
    } else if (strcmp(req, "test") == 0) {
        addTest(new TestTest());
    } else if (strcmp(req, "endurance") == 0) {
        addTest(new EnduranceTest());
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x6438(%rip), %rdi      # 0xe453
callq 0x3360
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8040
movq -0x10(%rbp), %rdi
leaq 0x642a(%rip), %rsi      # 0xe460
callq 0x33b0
cmpl $0x0, %eax
jne 0x80ab
movl $0x8, %edi
callq 0x3290
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x3140
movq -0x28(%rbp), %rdi
callq 0x85d0
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x81f0
movl $0x8, %edi
callq 0x3290
movq %rax, %rdi
movq %rdi, -0x20(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x3140
movq -0x20(%rbp), %rdi
callq 0x8610
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x81f0
jmp 0x8141
movq -0x10(%rbp), %rdi
leaq 0x6178(%rip), %rsi      # 0xe22e
callq 0x33b0
cmpl $0x0, %eax
jne 0x80f5
movl $0x8, %edi
callq 0x3290
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x3140
movq -0x30(%rbp), %rdi
callq 0x85d0
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x81f0
jmp 0x813f
movq -0x10(%rbp), %rdi
leaq 0x6365(%rip), %rsi      # 0xe465
callq 0x33b0
cmpl $0x0, %eax
jne 0x813d
movl $0x8, %edi
callq 0x3290
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x3140
movq -0x38(%rbp), %rdi
callq 0x8650
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x81f0
jmp 0x813f
jmp 0x8141
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: dustin[P]kvtest/keys.cc
// Function: kvtest::generateKey()
static const char* generateKey() {
        char *rv = (char *)calloc(1, KEY_LEN + 1);
        assert(rv);
        for (int i = 0; i < KEY_LEN; i++) {
            rv[i] = nextChar();
        }
        return rv;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x11, %esi
callq 0x3180
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8f74
jmp 0x8f93
leaq 0x5568(%rip), %rdi      # 0xe4e3
leaq 0x553e(%rip), %rsi      # 0xe4c0
movl $0x39, %edx
leaq 0x5558(%rip), %rcx      # 0xe4e6
callq 0x3170
movl $0x0, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
jge 0x8fbd
callq 0x9100
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8f9a
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: dustin[P]kvtest/keys.cc
// Function: kvtest::Keys::nextKey()
const char* Keys::nextKey() {
        const char *rv = *it;
        ++it;
        if (it == keys.end()) {
            it = keys.begin();
        }
        return rv;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x18, %rdi
callq 0x93d0
movq -0x30(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x10(%rbp)
addq $0x18, %rdi
callq 0x93f0
movq -0x30(%rbp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
callq 0x93a0
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x9410
testb $0x1, %al
jne 0x90ac
jmp 0x90c8
movq -0x30(%rbp), %rdi
callq 0x9290
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dustin[P]kvtest/values.cc
// Function: kvtest::Values::Values(unsigned long, unsigned long, unsigned long)
Values::Values(size_t n, size_t lower, size_t upper) : values(n) {
        for (int i = 0; i < (int)n; i++) {
            values[i] = generateValue(lower, upper);
        }
        assert(values.size() == n);

        it = values.begin();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x21(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x9150
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x9170
jmp 0x9cac
leaq -0x21(%rbp), %rdi
callq 0x91e0
movq -0x60(%rbp), %rdi
addq $0x18, %rdi
callq 0x9200
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl %ecx, %eax
jge 0x9d34
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9d90
movq %rax, -0x68(%rbp)
jmp 0x9ce7
movq -0x60(%rbp), %rdi
movslq -0x38(%rbp), %rsi
callq 0x9ff0
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x9cc9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x91e0
jmp 0x9d86
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x92e0
jmp 0x9d86
movq -0x60(%rbp), %rdi
callq 0x92c0
cmpq -0x10(%rbp), %rax
jne 0x9d45
jmp 0x9d64
leaq 0x482b(%rip), %rdi      # 0xe577
leaq 0x4837(%rip), %rsi      # 0xe58a
movl $0x29, %edx
leaq 0x4835(%rip), %rcx      # 0xe594
callq 0x3170
movq -0x60(%rbp), %rdi
callq 0x9290
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3450
nop
// File: dustin[P]kvtest/values.cc
// Function: kvtest::generateValue(unsigned long, unsigned long)
static const char* generateValue(size_t min, size_t max) {
        size_t size = min + (random() & (max - min));
        assert(size >= min);
        assert(size <= max);

        char *rv = (char*)calloc(size + 1, sizeof(char));
        for (int i = 0; i < (int)size; i++) {
            rv[i] = nextChar();
        }
        return rv;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x3120
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdx
subq -0x8(%rbp), %rdx
andq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
jb 0x9dd2
jmp 0x9df1
leaq 0x47ea(%rip), %rdi      # 0xe5c3
leaq 0x47aa(%rip), %rsi      # 0xe58a
movl $0x17, %edx
leaq 0x47e3(%rip), %rcx      # 0xe5cf
callq 0x3170
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x9dfd
jmp 0x9e1c
leaq 0x47fd(%rip), %rdi      # 0xe601
leaq 0x477f(%rip), %rsi      # 0xe58a
movl $0x18, %edx
leaq 0x47b8(%rip), %rcx      # 0xe5cf
callq 0x3170
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
movl $0x1, %esi
callq 0x3180
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl %ecx, %eax
jge 0x9e61
callq 0x9fa0
movb %al, %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x9e39
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: dustin[P]kvtest/values.cc
// Function: kvtest::Values::nextValue()
const char *Values::nextValue() {
        const char *rv = *it;
        ++it;
        if (it == values.end()) {
            it = values.begin();
        }
        return rv;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x18, %rdi
callq 0x93d0
movq -0x30(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x10(%rbp)
addq $0x18, %rdi
callq 0x93f0
movq -0x30(%rbp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
callq 0x93a0
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x9410
testb $0x1, %al
jne 0x9f4c
jmp 0x9f68
movq -0x30(%rbp), %rdi
callq 0x9290
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dustin[P]kvtest/ep.cc
// Function: kvtest::EventuallyPersistentStore::EventuallyPersistentStore(kvtest::KVStore*, unsigned long)
EventuallyPersistentStore::EventuallyPersistentStore(KVStore *t,
                                                         size_t est) {

        pthread_mutex_init(&mutex, NULL);
        pthread_cond_init(&cond, NULL);
        est_size = est;
        towrite = NULL;
        initQueue();
        flusher = new Flusher(this);

        // Run in a thread...
        if(pthread_create(&thread, NULL, launch_flusher_thread, flusher)
           != 0) {
            throw std::runtime_error("Error initializing queue thread");
        }

        underlying = t;
        assert(underlying);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x38a0
movq -0x38(%rbp), %rdi
leaq 0xacd4(%rip), %rax      # 0x14d10
movq %rax, (%rdi)
addq $0x20, %rdi
movq %rdi, -0x30(%rbp)
movl $0x30005, %esi          # imm = 0x30005
movl $0xc1, %edx
callq 0xaef0
jmp 0xa058
movq -0x38(%rbp), %rax
movq %rax, %rdi
addq $0x48, %rdi
addq $0x70, %rax
movq %rax, -0x48(%rbp)
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0x40(%rbp)
callq 0x33e0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x3350
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, 0x10(%rdi)
movq $0x0, 0xa0(%rdi)
callq 0xa1e0
jmp 0xa0a3
movl $0x10, %edi
callq 0x3290
movq %rax, -0x50(%rbp)
jmp 0xa0b3
movq -0x38(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0xafa0
jmp 0xa0c2
movq -0x38(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq %rax, %rdi
addq $0xa8, %rdi
movq 0x18(%rax), %rcx
xorl %eax, %eax
movl %eax, %esi
leaq 0x199(%rip), %rdx       # 0xa280
callq 0x3480
cmpl $0x0, %eax
je 0xa185
movl $0x10, %edi
callq 0x3110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0x44fd(%rip), %rsi      # 0xe60d
callq 0x30c0
jmp 0xa117
movq -0x58(%rbp), %rdi
movq 0xaece(%rip), %rsi      # 0x14ff0
movq 0xae8f(%rip), %rdx      # 0x14fb8
callq 0x3430
jmp 0xa1da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xa1c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xa1bf
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x10, %esi
callq 0x32a0
jmp 0xa1bf
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x31d0
jmp 0xa1bf
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rax)
je 0xa19a
jmp 0xa1b9
leaq 0x448c(%rip), %rdi      # 0xe62d
leaq 0x4490(%rip), %rsi      # 0xe638
movl $0x23, %edx
leaq 0x448a(%rip), %rcx      # 0xe63e
callq 0x3170
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xafc0
movq -0x38(%rbp), %rdi
callq 0x3cd0
movq -0x20(%rbp), %rdi
callq 0x3450
nopw (%rax,%rax)
// File: dustin[P]kvtest/ep.cc
// Function: kvtest::launch_flusher_thread(void*)
static void* launch_flusher_thread(void* arg) {
        Flusher *flusher = (Flusher*) arg;
        try {
            flusher->run();
        } catch(...) {
            std::cerr << "Caught a fatal exception in the thread" << std::endl;
        }
        return NULL;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb8c0
jmp 0xa29f
jmp 0xa2e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30d0
movq 0xad2b(%rip), %rdi      # 0x14fe8
leaq 0x446d(%rip), %rsi      # 0xe731
callq 0x3280
movq %rax, -0x28(%rbp)
jmp 0xa2cf
movq -0x28(%rbp), %rdi
movq 0xacce(%rip), %rsi      # 0x14fa8
callq 0x32c0
jmp 0xa2e1
callq 0x3420
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3420
jmp 0xa301
jmp 0xa303
movq -0x18(%rbp), %rdi
callq 0x3450
movq %rax, %rdi
callq 0x3df0
nopw %cs:(%rax,%rax)
// File: dustin[P]kvtest/ep.cc
// Function: kvtest::EventuallyPersistentStore::~EventuallyPersistentStore()
EventuallyPersistentStore::~EventuallyPersistentStore() {
        LockHolder lh(&mutex);
        flusher->stop();
        if(pthread_cond_signal(&cond) != 0) {
            throw std::runtime_error("Error signaling change.");
        }
        lh.unlock();
        pthread_join(thread, NULL);
        delete flusher;
        delete towrite;
        pthread_cond_destroy(&cond);
        pthread_mutex_destroy(&mutex);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x20(%rbp)
leaq 0xa9d5(%rip), %rax      # 0x14d10
movq %rax, (%rsi)
addq $0x48, %rsi
leaq -0x18(%rbp), %rdi
callq 0x7b50
jmp 0xa34d
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xb060
jmp 0xa35c
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
callq 0x3030
cmpl $0x0, %eax
je 0xa3ac
movl $0x10, %edi
callq 0x3110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x4305(%rip), %rsi      # 0xe68e
callq 0x30c0
jmp 0xa390
movq -0x28(%rbp), %rdi
movq 0xac55(%rip), %rsi      # 0x14ff0
movq 0xac16(%rip), %rdx      # 0x14fb8
callq 0x3430
jmp 0xa469
leaq -0x18(%rbp), %rdi
callq 0x7c20
jmp 0xa3b7
movq -0x20(%rbp), %rax
movq 0xa8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3250
jmp 0xa3cd
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xa3f6
movq -0x30(%rbp), %rdi
callq 0xb080
movq -0x30(%rbp), %rdi
movl $0x10, %esi
callq 0x32a0
movq -0x20(%rbp), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xa422
movq -0x38(%rbp), %rdi
callq 0xb0a0
movq -0x38(%rbp), %rdi
movl $0x50, %esi
callq 0x32a0
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
callq 0x34d0
movq -0x20(%rbp), %rdi
addq $0x48, %rdi
callq 0x3330
leaq -0x18(%rbp), %rdi
callq 0x7bf0
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0xafc0
movq -0x20(%rbp), %rdi
callq 0x3cd0
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3df0
nopl (%rax)
// File: dustin[P]kvtest/ep.cc
// Function: kvtest::EventuallyPersistentStore::set(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, kvtest::Callback<bool>&)
void EventuallyPersistentStore::set(std::string &key, std::string &val,
                                        Callback<bool> &cb) {
        mutation_type_t mtype = storage.set(key, val);

        if (mtype == WAS_CLEAN || mtype == NOT_FOUND) {
            LockHolder lh(&mutex);
            queueDirty(key);
        }
        bool rv = true;
        cb.callback(rv);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xb0f0
movl %eax, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
je 0xa4e0
cmpl $0x0, -0x24(%rbp)
jne 0xa522
movq -0x50(%rbp), %rsi
addq $0x48, %rsi
leaq -0x38(%rbp), %rdi
callq 0x7b50
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa550
jmp 0xa500
leaq -0x38(%rbp), %rdi
callq 0x7bf0
jmp 0xa522
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7bf0
jmp 0xa53a
movb $0x1, -0x45(%rbp)
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
leaq -0x45(%rbp), %rsi
callq *0x10(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3450
nopw %cs:(%rax,%rax)
// File: dustin[P]kvtest/ep.cc
// Function: kvtest::EventuallyPersistentStore::queueDirty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void EventuallyPersistentStore::queueDirty(std::string &key) {
        // Assume locked.
        towrite->push(key);
        if(pthread_cond_signal(&cond) != 0) {
            throw std::runtime_error("Error signaling change.");
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0xa0(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xb7f0
movq -0x28(%rbp), %rdi
addq $0x70, %rdi
callq 0x3030
cmpl $0x0, %eax
je 0xa5da
movl $0x10, %edi
callq 0x3110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x40e9(%rip), %rsi      # 0xe68e
callq 0x30c0
jmp 0xa5ac
movq -0x30(%rbp), %rdi
movq 0xaa39(%rip), %rsi      # 0x14ff0
movq 0xa9fa(%rip), %rdx      # 0x14fb8
callq 0x3430
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31d0
jmp 0xa5e0
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3450
nopl (%rax)
// File: dustin[P]kvtest/ep.cc
// Function: kvtest::EventuallyPersistentStore::set(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const*, kvtest::Callback<bool>&)
void EventuallyPersistentStore::set(std::string &key, const char *val,
                                        Callback<bool> &cb) {
        mutation_type_t mtype = storage.set(key, val);

        if (mtype == WAS_CLEAN || mtype == NOT_FOUND) {
            LockHolder lh(&mutex);
            queueDirty(key);
        }
        bool rv = true;
        cb.callback(rv);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xb140
movl %eax, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
je 0xa630
cmpl $0x0, -0x24(%rbp)
jne 0xa672
movq -0x50(%rbp), %rsi
addq $0x48, %rsi
leaq -0x38(%rbp), %rdi
callq 0x7b50
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa550
jmp 0xa650
leaq -0x38(%rbp), %rdi
callq 0x7bf0
jmp 0xa672
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7bf0
jmp 0xa68a
movb $0x1, -0x45(%rbp)
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
leaq -0x45(%rbp), %rsi
callq *0x10(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3450
nopw %cs:(%rax,%rax)
// File: dustin[P]kvtest/ep.cc
// Function: kvtest::EventuallyPersistentStore::reset()
void EventuallyPersistentStore::reset() {
        flush(false);
        LockHolder lh(&mutex);
        underlying->reset();
        delete towrite;
        towrite = NULL;
        initQueue();
        storage.clear();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
xorl %esi, %esi
callq 0xa760
movq -0x30(%rbp), %rsi
addq $0x48, %rsi
leaq -0x18(%rbp), %rdi
callq 0x7b50
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0xa6df
movq -0x30(%rbp), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xa70b
movq -0x38(%rbp), %rdi
callq 0xb0a0
movq -0x38(%rbp), %rdi
movl $0x50, %esi
callq 0x32a0
movq -0x30(%rbp), %rdi
movq $0x0, 0xa0(%rdi)
callq 0xa1e0
jmp 0xa721
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
callq 0xb2c0
jmp 0xa730
leaq -0x18(%rbp), %rdi
callq 0x7bf0
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x7bf0
movq -0x20(%rbp), %rdi
callq 0x3450
nopl (%rax)
// File: dustin[P]kvtest/ep.cc
// Function: kvtest::EventuallyPersistentStore::del(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, kvtest::Callback<bool>&)
void EventuallyPersistentStore::del(std::string &key, Callback<bool> &cb) {
        bool existed = storage.del(key);
        if (existed) {
            queueDirty(key);
        }
        cb.callback(existed);
    }

// 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
movq %rdi, -0x28(%rbp)
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
callq 0xb620
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
je 0xace1
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa550
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
leaq -0x19(%rbp), %rsi
callq *0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dustin[P]kvtest/./ep.hh
// Function: kvtest::HashTable::HashTable(unsigned long, unsigned long)
HashTable(size_t s = 196613, size_t l = 193) {
            size = s;
            n_locks = l;
            active = true;
            values = (StoredValue**)calloc(s, sizeof(StoredValue**));
            mutexes = (pthread_mutex_t*)calloc(l, sizeof(pthread_mutex_t));
            for (int i = 0; i < (int)n_locks; i++) {
                pthread_mutex_init(&mutexes[i], NULL);
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, 0x10(%rax)
movq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x3180
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rdi
movl $0x28, %esi
callq 0x3180
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
movq 0x8(%rcx), %rcx
cmpl %ecx, %eax
jge 0xaf8e
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
movslq -0x1c(%rbp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x33e0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xaf58
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: dustin[P]kvtest/./ep.hh
// Function: kvtest::HashTable::~HashTable()
~HashTable() {
            clear();
            for (int i = 0; i < (int)n_locks; i++) {
                pthread_mutex_destroy(&mutexes[i]);
            }
            free(mutexes);
            free(values);
            mutexes = NULL;
            values = NULL;
            active = false;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xb2c0
jmp 0xafdb
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
movq 0x8(%rcx), %rcx
cmpl %ecx, %eax
jge 0xb014
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x3330
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xafe2
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3340
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3340
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq $0x0, 0x18(%rax)
movb $0x0, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3df0
nopw %cs:(%rax,%rax)
nop
// File: dustin[P]kvtest/./ep.hh
// Function: kvtest::HashTable::set(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const*)
mutation_type_t set(std::string &key, const char *val) {
            assert(active);
            mutation_type_t rv = NOT_FOUND;
            int bucket_num = bucket(key);
            LockHolder lh(getMutex(bucket_num));
            StoredValue *v = unlocked_find(key, bucket_num);
            if (v) {
                rv = v->isClean() ? WAS_CLEAN : WAS_DIRTY;
                v->setValue(val);
            } else {
                v = new StoredValue(key, val, values[bucket_num]);
                values[bucket_num] = v;
            }
            return rv;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
testb $0x1, 0x10(%rax)
je 0xb164
jmp 0xb183
leaq 0x364b(%rip), %rdi      # 0xe7b6
leaq 0x3620(%rip), %rsi      # 0xe792
movl $0x81, %edx
leaq 0x363f(%rip), %rcx      # 0xe7bd
callq 0x3170
movq -0x50(%rbp), %rdi
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rsi
callq 0xb3b0
movq -0x50(%rbp), %rdi
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %esi
callq 0xb470
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x7b50
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x20(%rbp), %edx
callq 0xb590
movq %rax, -0x58(%rbp)
jmp 0xb1c8
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xb21a
movq -0x38(%rbp), %rdi
callq 0xc0f0
movb %al, -0x59(%rbp)
jmp 0xb1e5
movb -0x59(%rbp), %al
movzbl %al, %ecx
andl $0x1, %ecx
movl $0x2, %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc110
jmp 0xb207
jmp 0xb287
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xb29f
movl $0x38, %edi
callq 0x3290
movq %rax, -0x68(%rbp)
jmp 0xb22a
movq -0x68(%rbp), %rdi
movq -0x50(%rbp), %rax
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq 0x18(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
callq 0xc150
jmp 0xb24d
movq -0x50(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq -0x38(%rbp), %rdx
movq 0x18(%rax), %rax
movslq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0xb287
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
movl $0x38, %esi
callq 0x32a0
jmp 0xb29f
movl -0x1c(%rbp), %eax
movl %eax, -0x6c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7bf0
movl -0x6c(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x7bf0
movq -0x40(%rbp), %rdi
callq 0x3450
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: dustin[P]kvtest/./ep.hh
// Function: kvtest::HashTable::clear()
void clear() {
            assert(active);
            for (int i = 0; i < (int)size; i++) {
                LockHolder lh(getMutex(i));
                while (values[i]) {
                    StoredValue *v = values[i];
                    values[i] = v->next;
                    delete v;
                }
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0x10(%rax)
je 0xb2dc
jmp 0xb2fb
leaq 0x34d3(%rip), %rdi      # 0xe7b6
leaq 0x34a8(%rip), %rsi      # 0xe792
movl $0x69, %edx
leaq 0x350b(%rip), %rcx      # 0xe801
callq 0x3170
movl $0x0, -0xc(%rbp)
movq -0x30(%rbp), %rcx
movl -0xc(%rbp), %eax
movq (%rcx), %rcx
cmpl %ecx, %eax
jge 0xb3a5
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xb470
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x7b50
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xb38e
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq 0x30(%rcx), %rdx
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xb38c
movq -0x38(%rbp), %rdi
callq 0xc200
movq -0x38(%rbp), %rdi
movl $0x38, %esi
callq 0x32a0
jmp 0xb32c
leaq -0x20(%rbp), %rdi
callq 0x7bf0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb302
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: dustin[P]kvtest/./ep.hh
// Function: kvtest::HashTable::bucket(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline int bucket(std::string &key) {
            assert(active);
            int h=5381;
            int i=0;
            const char *str=key.c_str();

            for(i=0; str[i] != 0x00; i++) {
                h = ((h << 5) + h) ^ str[i];
            }

            return abs(h) % (int)size;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x10(%rax)
je 0xb3d0
jmp 0xb3ef
leaq 0x33df(%rip), %rdi      # 0xe7b6
leaq 0x33b4(%rip), %rsi      # 0xe792
movl $0x9c, %edx
leaq 0x3437(%rip), %rcx      # 0xe821
callq 0x3170
movl $0x1505, -0x14(%rbp)    # imm = 0x1505
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30e0
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0xb447
movl -0x14(%rbp), %eax
shll $0x5, %eax
addl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
movslq -0x18(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xb411
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
movl %eax, %edx
negl %edx
cmovnsl %edx, %eax
movq (%rcx), %rcx
cltd
idivl %ecx
movl %edx, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dustin[P]kvtest/./ep.hh
// Function: kvtest::HashTable::getMutex(int)
inline pthread_mutex_t *getMutex(int bucket_num) {
            assert(active);
            assert(bucket_num < (int)size);
            assert(bucket_num >= 0);
            int lock_num = bucket_num % (int)n_locks;
            assert(lock_num < (int)n_locks);
            assert(lock_num >= 0);
            return &mutexes[lock_num];
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x10(%rax)
je 0xb48f
jmp 0xb4ae
leaq 0x3320(%rip), %rdi      # 0xe7b6
leaq 0x32f5(%rip), %rsi      # 0xe792
movl $0xaa, %edx
leaq 0x33a5(%rip), %rcx      # 0xe84e
callq 0x3170
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
movq (%rcx), %rcx
cmpl %ecx, %eax
jge 0xb4be
jmp 0xb4dd
leaq 0x33bb(%rip), %rdi      # 0xe880
leaq 0x32c6(%rip), %rsi      # 0xe792
movl $0xab, %edx
leaq 0x3376(%rip), %rcx      # 0xe84e
callq 0x3170
cmpl $0x0, -0xc(%rbp)
jl 0xb4e5
jmp 0xb504
leaq 0x33ab(%rip), %rdi      # 0xe897
leaq 0x329f(%rip), %rsi      # 0xe792
movl $0xac, %edx
leaq 0x334f(%rip), %rcx      # 0xe84e
callq 0x3170
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
movq 0x8(%rcx), %rdx
movl %edx, %esi
cltd
idivl %esi
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq 0x8(%rcx), %rcx
cmpl %ecx, %eax
jge 0xb524
jmp 0xb543
leaq 0x337c(%rip), %rdi      # 0xe8a7
leaq 0x3260(%rip), %rsi      # 0xe792
movl $0xae, %edx
leaq 0x3310(%rip), %rcx      # 0xe84e
callq 0x3170
cmpl $0x0, -0x10(%rbp)
jl 0xb54b
jmp 0xb56a
leaq 0x336d(%rip), %rdi      # 0xe8bf
leaq 0x3239(%rip), %rsi      # 0xe792
movl $0xaf, %edx
leaq 0x32e9(%rip), %rcx      # 0xe84e
callq 0x3170
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x10(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dustin[P]kvtest/./ep.hh
// Function: kvtest::HashTable::unlocked_find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int)
StoredValue *unlocked_find(std::string &key, int bucket_num) {
            StoredValue *v = values[bucket_num];
            while (v) {
                if (key.compare(v->key) == 0) {
                    return v;
                }
                v = v->next;
            }
            return NULL;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xb5ec
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
callq 0x3040
cmpl $0x0, %eax
jne 0xb5de
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb5f4
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xb5b7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: dustin[P]kvtest/./ep.hh
// Function: kvtest::Flusher::run()
void run() {
            try {
                while(running) {
                    store->flush(true);
                }
                std::cout << "Shutting down flusher." << std::endl;
            } catch(std::runtime_error &e) {
                std::cerr << "Exception in executor loop: "
                          << e.what() << std::endl;
                assert(false);
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb 0x8(%rax), %al
testb $0x1, %al
je 0xb98a
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0xa760
jmp 0xb8f6
jmp 0xb8d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xb9d2
movq -0x10(%rbp), %rdi
callq 0x30d0
movq %rax, -0x20(%rbp)
movq 0x96c0(%rip), %rdi      # 0x14fe8
leaq 0x2e40(%rip), %rsi      # 0xe76f
callq 0x3280
movq %rax, -0x30(%rbp)
jmp 0xb93a
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x3280
movq %rax, -0x38(%rbp)
jmp 0xb959
movq -0x38(%rbp), %rdi
movq 0x9644(%rip), %rsi      # 0x14fa8
callq 0x32c0
jmp 0xb96b
leaq 0x2e1a(%rip), %rdi      # 0xe78c
leaq 0x2e19(%rip), %rsi      # 0xe792
movl $0x11c, %edx            # imm = 0x11C
leaq 0x2e15(%rip), %rcx      # 0xe79a
callq 0x3170
movq 0x962f(%rip), %rdi      # 0x14fc0
leaq 0x2dc0(%rip), %rsi      # 0xe758
callq 0x3280
movq %rax, -0x40(%rbp)
jmp 0xb9a3
movq -0x40(%rbp), %rdi
movq 0x95fa(%rip), %rsi      # 0x14fa8
callq 0x32c0
jmp 0xb9b5
jmp 0xb9cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3420
jmp 0xb9ca
jmp 0xb9d2
addq $0x40, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x3450
movq %rax, %rdi
callq 0x3df0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dustin[P]kvtest/./ep.hh
// Function: kvtest::StoredValue::StoredValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const*, kvtest::StoredValue*)
StoredValue(std::string &k, const char *v, StoredValue *n) {
            key = k;
            value = NULL;
            setValue(v);
            dirty = true;
            next = n;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x8, %rdi
movq %rdi, -0x38(%rbp)
callq 0x33a0
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3050
jmp 0xc18c
movq -0x40(%rbp), %rdi
movq $0x0, 0x28(%rdi)
movq -0x18(%rbp), %rsi
callq 0xc110
jmp 0xc1a3
movq -0x40(%rbp), %rax
movb $0x1, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x30(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3160
movq -0x28(%rbp), %rdi
callq 0x3450
nopw %cs:(%rax,%rax)
// File: theuni[P]libbtcnet/tests/multinet.cpp
// Function: CConnman::OnNeedOutgoingConnections[abi:cxx11](int)
std::list<CConnection> OnNeedOutgoingConnections(int need_count) final
    {
        std::list<CConnection> ret;
        if (!m_connections.empty())
            ret.splice(ret.end(), m_connections);
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x5d80
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
callq 0x63f0
testb $0x1, %al
jne 0x5e3f
movq -0x40(%rbp), %rdi
callq 0x6450
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6480
movq -0x30(%rbp), %rdx
movq -0x40(%rbp), %rdi
addq $0x10, %rdx
movq -0x20(%rbp), %rsi
callq 0x6410
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x5e52
movq -0x40(%rbp), %rdi
callq 0x64a0
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: theuni[P]libbtcnet/tests/multinet.cpp
// Function: CConnman::OnOutgoingConnection(long, CConnection const&, CConnection const&)
bool OnOutgoingConnection(ConnID id, const CConnection& conn, const CConnection& resolved_conn) final
    {
        if (resolved_conn.GetNetConfig().message_start == mainnet_message_start)
            printf("mainnet connected first\n");
        else if (resolved_conn.GetNetConfig().message_start == testnet_message_start)
            printf("testnet connected first\n");
        Shutdown();
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa9e0
movq %rax, %rdi
addq $0x10, %rdi
leaq 0x32519(%rip), %rsi     # 0x38440
callq 0x6a80
testb $0x1, %al
jne 0x5f32
jmp 0x5f42
leaq 0x1f0d5(%rip), %rdi     # 0x2500e
movb $0x0, %al
callq 0x5070
jmp 0x5f74
movq -0x20(%rbp), %rdi
callq 0xa9e0
movq %rax, %rdi
addq $0x10, %rdi
leaq 0x324ff(%rip), %rsi     # 0x38458
callq 0x6a80
testb $0x1, %al
jne 0x5f64
jmp 0x5f72
leaq 0x1f0bc(%rip), %rdi     # 0x25027
movb $0x0, %al
callq 0x5070
jmp 0x5f74
movq -0x28(%rbp), %rdi
callq 0xc090
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: theuni[P]libbtcnet/src/connection.cpp
// Function: CConnectionBase::GetSockAddr(sockaddr*, int*) const
bool CConnectionBase::GetSockAddr(sockaddr* paddr, int* addrlen) const
{
    if (!addr.empty() && (addrlen != nullptr) && static_cast<size_t>(*addrlen) >= addr.size()) {
        memcpy(paddr, &addr[0], addr.size());
        *addrlen = addr.size();
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x28, %rdi
callq 0xaf30
testb $0x1, %al
jne 0x9d5d
cmpq $0x0, -0x20(%rbp)
je 0x9d5d
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x30(%rbp)
addq $0x28, %rdi
callq 0x6b00
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jb 0x9d5d
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xaf70
movq -0x28(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x28, %rdi
callq 0x6b00
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x5370
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x6b00
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x9d61
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: theuni[P]libbtcnet/src/connection.cpp
// Function: CConnectionBase::GetHost[abi:cxx11]() const
std::string CConnectionBase::GetHost() const
{
    if (isDns || isOnion)
        return host;

    std::string rethost;
    if (!addr.empty()) {
        std::array<char, NI_MAXHOST> hostbuf{};
        sockaddr_storage addr_stor;
        memset(&addr_stor, 0, sizeof(addr_stor));
        memcpy(&addr_stor, addr.data(), addr.size());
        if (getnameinfo(reinterpret_cast<sockaddr*>(&addr_stor), addr.size(), hostbuf.data(), hostbuf.size(), nullptr, 0, NI_NUMERICHOST) == 0)
            rethost.assign(hostbuf.data());
    }
    return rethost;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x520, %rsp            # imm = 0x520
movq %rdi, -0x4c8(%rbp)
movq %rdi, %rax
movq %rax, -0x4c0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x4b8(%rbp)
testb $0x1, 0x22(%rax)
jne 0x9dd2
movq -0x4b8(%rbp), %rax
testb $0x1, 0x23(%rax)
je 0x9dea
movq -0x4b8(%rbp), %rsi
movq -0x4c8(%rbp), %rdi
callq 0x51b0
jmp 0x9f86
movq -0x4c8(%rbp), %rdi
movb $0x0, -0x11(%rbp)
callq 0x5560
movq -0x4b8(%rbp), %rdi
addq $0x28, %rdi
callq 0xaf30
testb $0x1, %al
jne 0x9f6e
leaq -0x412(%rbp), %rdi
movq %rdi, -0x4f0(%rbp)
xorl %esi, %esi
movl %esi, -0x4d0(%rbp)
movl $0x401, %edx            # imm = 0x401
callq 0x5220
movq -0x4b8(%rbp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, -0x510(%rbp)
movaps %xmm0, -0x430(%rbp)
movaps %xmm0, -0x440(%rbp)
movaps %xmm0, -0x450(%rbp)
movaps %xmm0, -0x460(%rbp)
movaps %xmm0, -0x470(%rbp)
movaps %xmm0, -0x480(%rbp)
movaps %xmm0, -0x490(%rbp)
movaps %xmm0, -0x4a0(%rbp)
addq $0x28, %rdi
movq %rdi, -0x4f8(%rbp)
callq 0xaf90
movq -0x4f8(%rbp), %rdi
movq %rax, -0x500(%rbp)
callq 0x6b00
movq -0x500(%rbp), %rsi
movq %rax, %rdx
leaq -0x4a0(%rbp), %rdi
movq %rdi, -0x4e8(%rbp)
callq 0x5370
movq -0x4f8(%rbp), %rdi
callq 0x6b00
movq -0x4f0(%rbp), %rdi
movl %eax, -0x4dc(%rbp)
callq 0xafb0
movq -0x4f0(%rbp), %rdi
movq %rax, -0x4d8(%rbp)
callq 0xafd0
movq -0x4e8(%rbp), %rdi
movl -0x4dc(%rbp), %esi
movq -0x4d8(%rbp), %rdx
movl -0x4d0(%rbp), %r9d
movl %eax, %ecx
movq %rsp, %rax
movl $0x1, (%rax)
movl %r9d, %r8d
callq 0x52b0
movl %eax, -0x4cc(%rbp)
jmp 0x9f22
movl -0x4cc(%rbp), %eax
cmpl $0x0, %eax
jne 0x9f6c
leaq -0x412(%rbp), %rdi
callq 0xafb0
movq -0x4c8(%rbp), %rdi
movq %rax, %rsi
callq 0x57d0
jmp 0x9f4a
jmp 0x9f6c
movq -0x4c8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x4a8(%rbp)
movl %eax, -0x4ac(%rbp)
callq 0x52a0
jmp 0x9f96
jmp 0x9f6e
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x9f84
movq -0x4c8(%rbp), %rdi
callq 0x52a0
jmp 0x9f86
movq -0x4c0(%rbp), %rax
addq $0x520, %rsp            # imm = 0x520
popq %rbp
retq
movq -0x4a8(%rbp), %rdi
callq 0x5710
nopw %cs:(%rax,%rax)
// File: theuni[P]libbtcnet/src/connection.cpp
// Function: CConnectionBase::GetPort() const
unsigned short CConnectionBase::GetPort() const
{
    if (isDns || isOnion)
        return port;

    if (!addr.empty()) {
        std::array<char, NI_MAXSERV> servbuf{};
        sockaddr_storage addr_stor;
        memset(&addr_stor, 0, sizeof(addr_stor));
        memcpy(&addr_stor, addr.data(), addr.size());
        if (getnameinfo(reinterpret_cast<sockaddr*>(&addr_stor), addr.size(), nullptr, 0, servbuf.data(), servbuf.size(), NI_NUMERICSERV) == 0)
            return std::atoi(servbuf.data());
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
testb $0x1, 0x22(%rax)
jne 0x9fdd
movq -0xb8(%rbp), %rax
testb $0x1, 0x23(%rax)
je 0x9ff1
movq -0xb8(%rbp), %rax
movw 0x20(%rax), %ax
movw %ax, -0x2(%rbp)
jmp 0xa0e5
movq -0xb8(%rbp), %rdi
addq $0x28, %rdi
callq 0xaf30
testb $0x1, %al
jne 0xa0df
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x5220
leaq -0xb0(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x5220
movq -0xb8(%rbp), %rdi
addq $0x28, %rdi
callq 0xaf90
movq -0xb8(%rbp), %rdi
movq %rax, -0xd0(%rbp)
addq $0x28, %rdi
callq 0x6b00
movq -0xd0(%rbp), %rsi
movq %rax, %rdx
leaq -0xb0(%rbp), %rdi
callq 0x5370
movq -0xb8(%rbp), %rdi
addq $0x28, %rdi
callq 0x6b00
movl %eax, -0xc4(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xafe0
movq %rax, -0xc0(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xb000
movl -0xc4(%rbp), %esi
movq -0xc0(%rbp), %r8
movl %eax, %r9d
leaq -0xb0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
movl $0x2, (%rsp)
callq 0x52b0
cmpl $0x0, %eax
jne 0xa0dd
leaq -0x30(%rbp), %rdi
callq 0xafe0
movq %rax, %rdi
callq 0x5620
movw %ax, -0x2(%rbp)
jmp 0xa0e5
jmp 0xa0df
movw $0x0, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: theuni[P]libbtcnet/src/connection.cpp
// Function: CConnection::CanConnectDirect(sockaddr*, CConnectionOptions::Family)
bool CConnection::CanConnectDirect(sockaddr* sock, CConnectionOptions::Family family)
{
    assert(sock != nullptr);
#ifndef _WIN32
    if(sock->sa_family == AF_UNIX && (family & CConnectionOptions::UNIX) == CConnectionOptions::UNIX)
        return true;
#endif
    return (sock->sa_family == AF_INET && (family & CConnectionOptions::IPV4) == CConnectionOptions::IPV4) ||
           (sock->sa_family == AF_INET6 && (family & CConnectionOptions::IPV6) == CConnectionOptions::IPV6);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xaa18
jmp 0xaa37
leaq 0x1a709(%rip), %rdi     # 0x25128
leaq 0x1a712(%rip), %rsi     # 0x25138
movl $0x114, %edx            # imm = 0x114
leaq 0x1a719(%rip), %rcx     # 0x2514b
callq 0x52e0
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x1, %eax
jne 0xaa54
movl -0x14(%rbp), %eax
andl $0x8, %eax
cmpl $0x8, %eax
jne 0xaa54
movb $0x1, -0x1(%rbp)
jmp 0xaa9e
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x2, %eax
jne 0xaa70
movl -0x14(%rbp), %ecx
andl $0x2, %ecx
movb $0x1, %al
cmpl $0x2, %ecx
movb %al, -0x15(%rbp)
je 0xaa96
movq -0x10(%rbp), %rax
movzwl (%rax), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x16(%rbp)
jne 0xaa90
movl -0x14(%rbp), %eax
andl $0x4, %eax
cmpl $0x4, %eax
sete %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)