LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: andresziemecki[P]MQTT/mqtt.cpp
// Function: SimPublisher::Publish()
void SimPublisher::Publish (void){
        // Empezar a publicar valores
    for (unsigned int i=0; i<Par_del_client.time_conection; ++i){
        std::this_thread::sleep_for (std::chrono::seconds(1));
        brops->sendMsg(PublishMsg(Par_del_client.topic_name, to_string(rand()%Par_del_client.error - Par_del_client.error/2 + Par_del_client.topic_value), Par_del_client.retain));
    }
    // Disconnect luego del tiempo de vida
    brops->sendMsg(DisconnectMsg{});
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe0(%rbp)
movl $0x0, -0xc(%rbp)
movq -0xe0(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x88(%rcx), %eax
jae 0x6ab0
movl $0x1, -0x1c(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x71d0
movq -0xf8(%rbp), %rdi
callq 0x7120
movq -0xe0(%rbp), %rsi
movq 0xf8(%rsi), %rax
movq %rax, -0xf0(%rbp)
addq $0x58, %rsi
leaq -0x98(%rbp), %rdi
callq 0x30e0
callq 0x3070
movq -0xe0(%rbp), %rcx
movl 0x7c(%rcx), %edx
movl %edx, -0xe4(%rbp)
movl 0x80(%rcx), %ecx
cltd
idivl %ecx
movl -0xe4(%rbp), %eax
movl %edx, %esi
movl %ecx, %edx
shrl $0x1f, %edx
addl %edx, %ecx
sarl %ecx
subl %ecx, %esi
addl %eax, %esi
leaq -0xb8(%rbp), %rdi
callq 0x86d0
jmp 0x69e4
movq -0xe0(%rbp), %rax
movzbl 0x84(%rax), %ecx
andl $0x1, %ecx
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0x8030
jmp 0x6a0e
movq -0xf0(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq -0x78(%rbp), %rsi
callq *%rax
jmp 0x6a24
leaq -0x78(%rbp), %rdi
callq 0x80f0
leaq -0xb8(%rbp), %rdi
callq 0x3160
leaq -0x98(%rbp), %rdi
callq 0x3160
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6941
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x6aa2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x6a96
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x80f0
leaq -0xb8(%rbp), %rdi
callq 0x3160
leaq -0x98(%rbp), %rdi
callq 0x3160
jmp 0x6b24
movq -0xe0(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x108(%rbp)
leaq -0xd8(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x87f0
movq -0x108(%rbp), %rdi
movq -0x100(%rbp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0x6af1
leaq -0xd8(%rbp), %rdi
callq 0x8830
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x8830
movq -0xc0(%rbp), %rdi
callq 0x3340
// File: andresziemecki[P]MQTT/mqtt.cpp
// Function: SimPublisher::recvMsg(Message const&)
void SimPublisher::recvMsg(const Message &m){
    switch (m.getType()){
        case Message::Type::CONNACK:
        {
            ConnAckMsg *M = (ConnAckMsg *)&m;
            recvConnack(M);
            break;
        }
        case Message::Type::PUBLISH:{
            PublishMsg *M = (PublishMsg *)&m;
            recvPublishMsg(M);
            break;
        }
        default:{ // Cualquier otro tipo de mensae recibido es indeseado
            mutex_cout.lock();
            cout << "Error al recibir Mensaje del Client: " << usuario_pass.username << endl;
            mutex_cout.unlock();
            return;}
    }
}

// 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)
movq -0x10(%rbp), %rdi
callq 0x7670
movl %eax, %ecx
movl %ecx, -0x24(%rbp)
subl $0x1, %eax
je 0x6c17
jmp 0x6c0d
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x6c2e
jmp 0x6c45
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x6ca0
jmp 0x6c8f
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x6dd0
jmp 0x6c8f
leaq 0x1559c(%rip), %rdi     # 0x1c1e8
callq 0x76c0
movq 0x15380(%rip), %rdi     # 0x1bfd8
leaq 0xb5a5(%rip), %rsi      # 0x12204
callq 0x3200
movq -0x30(%rbp), %rsi
movq %rax, %rdi
addq $0x10, %rsi
callq 0x31d0
movq %rax, %rdi
movq 0x15342(%rip), %rsi     # 0x1bfc0
callq 0x3220
leaq 0x1555e(%rip), %rdi     # 0x1c1e8
callq 0x7720
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: andresziemecki[P]MQTT/mqtt.cpp
// Function: SimPublisher::recvConnack(ConnAckMsg*)
void SimPublisher::recvConnack(ConnAckMsg *M){
    
    switch ((int)(M->getStatusType())){
        case 0: // LOGIN_OK
        {
            mutex_cout.lock();
            cout << "From Client\tMessage: CONNACK\tto: "<< usuario_pass.username << " -> OK" << endl;
            mutex_cout.unlock();
            connack_value = true;
            ready = true;
            cond_var.notify_one();
            break;
        }
        case 1:{ // LOGIN ERROR
            mutex_cout.lock();
            cout << "From Client\tMessage: CONNACK\tto: "<< usuario_pass.username << " -> ERROR" << endl;
            mutex_cout.unlock();
            connack_value = false;
            ready = true;
            cond_var.notify_one();
            break;}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8900
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
testl %eax, %eax
je 0x6cd9
jmp 0x6ccc
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x6d52
jmp 0x6dc9
leaq 0x15508(%rip), %rdi     # 0x1c1e8
callq 0x76c0
movq 0x152ec(%rip), %rdi     # 0x1bfd8
leaq 0xb537(%rip), %rsi      # 0x1222a
callq 0x3200
movq -0x20(%rbp), %rsi
movq %rax, %rdi
addq $0x10, %rsi
callq 0x31d0
movq %rax, %rdi
leaq 0xb53a(%rip), %rsi      # 0x1224c
callq 0x3200
movq %rax, %rdi
movq 0x1529f(%rip), %rsi     # 0x1bfc0
callq 0x3220
leaq 0x154bb(%rip), %rdi     # 0x1c1e8
callq 0x7720
movq -0x20(%rbp), %rdi
movb $0x1, 0x90(%rdi)
movb $0x1, 0xf0(%rdi)
addq $0xc0, %rdi
callq 0x3120
jmp 0x6dc9
leaq 0x1548f(%rip), %rdi     # 0x1c1e8
callq 0x76c0
movq 0x15273(%rip), %rdi     # 0x1bfd8
leaq 0xb4be(%rip), %rsi      # 0x1222a
callq 0x3200
movq -0x20(%rbp), %rsi
movq %rax, %rdi
addq $0x10, %rsi
callq 0x31d0
movq %rax, %rdi
leaq 0xb4c8(%rip), %rsi      # 0x12253
callq 0x3200
movq %rax, %rdi
movq 0x15226(%rip), %rsi     # 0x1bfc0
callq 0x3220
leaq 0x15442(%rip), %rdi     # 0x1c1e8
callq 0x7720
movq -0x20(%rbp), %rdi
movb $0x0, 0x90(%rdi)
movb $0x1, 0xf0(%rdi)
addq $0xc0, %rdi
callq 0x3120
addq $0x20, %rsp
popq %rbp
retq
nop
// File: andresziemecki[P]MQTT/mqtt.cpp
// Function: SimPublisher::recvPublishMsg(PublishMsg*) const
void SimPublisher::recvPublishMsg(PublishMsg *M) const{
    mutex_cout.lock();
    cout << "From Client\tMessage: PUBLISH\tto: "<< usuario_pass.username <<"\t" << "Topic " << M->getTopic() << ": " << M->getValue() << endl;
    mutex_cout.unlock();
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq 0x153f6(%rip), %rdi     # 0x1c1e8
callq 0x76c0
movq 0x151da(%rip), %rdi     # 0x1bfd8
leaq 0xb458(%rip), %rsi      # 0x1225d
callq 0x3200
movq -0x80(%rbp), %rsi
movq %rax, %rdi
addq $0x10, %rsi
callq 0x31d0
movq %rax, %rdi
leaq 0xb2f8(%rip), %rsi      # 0x1211c
callq 0x3200
movq %rax, %rdi
leaq 0xb2eb(%rip), %rsi      # 0x1211e
callq 0x3200
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x77c0
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x31d0
movq %rax, -0x68(%rbp)
jmp 0x6e60
movq -0x68(%rbp), %rdi
leaq 0xb2e0(%rip), %rsi      # 0x1214b
callq 0x3200
movq %rax, -0x88(%rbp)
jmp 0x6e79
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x77f0
jmp 0x6e88
movq -0x88(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x31d0
movq %rax, -0x90(%rbp)
jmp 0x6ea1
movq -0x90(%rbp), %rdi
movq 0x15111(%rip), %rsi     # 0x1bfc0
callq 0x3220
jmp 0x6eb6
leaq -0x60(%rbp), %rdi
callq 0x3160
leaq -0x30(%rbp), %rdi
callq 0x3160
leaq 0x15319(%rip), %rdi     # 0x1c1e8
callq 0x7720
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x6f00
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3160
leaq -0x30(%rbp), %rdi
callq 0x3160
movq -0x38(%rbp), %rdi
callq 0x3340
nopw %cs:(%rax,%rax)
// File: andresziemecki[P]MQTT/./queue.h
// Function: cola<Message*, 100ul>::push(Message* const&)
void push(const T &t)
		{
			unique_lock<mutex> lock(m);
			while( q.size() == N ){
			  cond_var_put.wait(lock);
			}
			q.push(t);
			lock.unlock();
			cond_var_get.notify_one();
		}

// 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 $0x50, %rsi
leaq -0x20(%rbp), %rdi
callq 0x85a0
movq -0x38(%rbp), %rdi
callq 0xbd50
movq %rax, -0x40(%rbp)
jmp 0x7534
movq -0x40(%rbp), %rax
cmpq $0x64, %rax
jne 0x7568
movq -0x38(%rbp), %rdi
addq $0x78, %rdi
leaq -0x20(%rbp), %rsi
callq 0x30a0
jmp 0x7525
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x85e0
jmp 0x75a1
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xbd70
jmp 0x7577
leaq -0x20(%rbp), %rdi
callq 0xbda0
jmp 0x7582
movq -0x38(%rbp), %rdi
addq $0xa8, %rdi
callq 0x3120
leaq -0x20(%rbp), %rdi
callq 0x85e0
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3340
nopw (%rax,%rax)
// File: andresziemecki[P]MQTT/./queue.h
// Function: cola<Message*, 100ul>::pop(Message**)
void pop(T *t)
		{
			unique_lock<mutex>lock(m);
			while(q.size() == 0){
				cond_var_get.wait(lock);
			}
			lock.unlock();
			cond_var_put.notify_one();
			*t = q.front();
			q.pop();
			return;
		}

// 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 $0x50, %rsi
leaq -0x20(%rbp), %rdi
callq 0x85a0
movq -0x38(%rbp), %rdi
callq 0xbd50
cmpq $0x0, %rax
jne 0x75fa
movq -0x38(%rbp), %rdi
addq $0xa8, %rdi
leaq -0x20(%rbp), %rsi
callq 0x30a0
jmp 0x75d5
leaq -0x20(%rbp), %rdi
callq 0xbda0
jmp 0x7605
movq -0x38(%rbp), %rdi
addq $0x78, %rdi
callq 0x3120
movq -0x38(%rbp), %rdi
callq 0xc640
movq %rax, -0x40(%rbp)
jmp 0x7621
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
callq 0xc660
jmp 0x763a
leaq -0x20(%rbp), %rdi
callq 0x85e0
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x85e0
movq -0x28(%rbp), %rdi
callq 0x3340
nopw (%rax,%rax)
// File: andresziemecki[P]MQTT/mqtt.cpp
// Function: ConnAckMsg::ConnAckMsg(ConnAckMsg::Status)
ConnAckMsg(Status b){
            Message::type = Message::Type::CONNACK;
            if(b==Status::CONNECTION_OK)
                status = Status::CONNECTION_OK;
            else
                status = Status::LOGIN_ERROR;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x91c0
movq -0x18(%rbp), %rax
leaq 0x143b1(%rip), %rcx     # 0x1bb18
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x1, 0x8(%rax)
cmpl $0x0, -0xc(%rbp)
jne 0x7788
movq -0x18(%rbp), %rax
movl $0x0, 0xc(%rax)
jmp 0x7793
movq -0x18(%rbp), %rax
movl $0x1, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::zcount(double, double, bool, bool)
unsigned long zcount(double min, double max, bool minex = false, bool maxex = false) {
        RangeSpec range(min, max, minex, maxex);
        SkipListNode *zn;
        unsigned long rank;
        unsigned long count = 0;

        /* Find first element in range */
        zn = first_in_range(range);

        /* Use rank of first element, if any, to determine preliminary count */
        if (zn != NULL) {
            rank = get_rank(zn->mScore, zn->mKey);
            count = (mLength - (rank - 1));

            /* Find last element in range */
            zn = last_in_range(range);

            /* Use rank of last element, if any, to determine the actual count */
            if (zn != NULL) {
                rank = get_rank(zn->mScore, zn->mKey);
                count -= (mLength - rank);
            }
        }
        return count;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
andb $0x1, %cl
movb %cl, -0x19(%rbp)
andb $0x1, %al
movb %al, -0x1a(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movb -0x19(%rbp), %cl
movb -0x1a(%rbp), %al
leaq -0x38(%rbp), %rdi
andb $0x1, %cl
andb $0x1, %al
movzbl %cl, %esi
movzbl %al, %edx
callq 0x5620
movq -0x58(%rbp), %rdi
movq $0x0, -0x50(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x5670
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x1de7
movq -0x58(%rbp), %rdi
movq -0x40(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x40(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x57b0
movq -0x58(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq 0x10(%rdi), %rax
movq -0x48(%rbp), %rcx
subq $0x1, %rcx
subq %rcx, %rax
movq %rax, -0x50(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x58c0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x1de5
movq -0x58(%rbp), %rdi
movq -0x40(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x40(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x57b0
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x48(%rbp)
movq 0x10(%rax), %rcx
subq -0x48(%rbp), %rcx
movq -0x50(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x50(%rbp)
jmp 0x1de7
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::zrem(int)
void zrem(KeyType key) {
        DictTypeIterator it = mDict.find(key);
        if (it != mDict.end()) {
            double score = it->second;
            private_delete(score, key);
            mDict.erase(it);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x20, %rdi
leaq -0xc(%rbp), %rsi
callq 0x3040
movq -0x60(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
addq $0x20, %rdi
callq 0x3120
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x30f0
testb $0x1, %al
jne 0x1e54
jmp 0x1ea5
leaq -0x20(%rbp), %rdi
callq 0x3160
movq -0x60(%rbp), %rdi
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movl -0xc(%rbp), %esi
callq 0x3180
movq -0x60(%rbp), %rdi
addq $0x20, %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x5b50
movq %rax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::zscore(int, double&)
bool zscore(KeyType key, double &score) {
        DictTypeConstIterator it = mDict.find(key);
        if (it != mDict.end()) {
            score = it->second;
            return true;
        }
        else {
            return false;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x20, %rdi
leaq -0x14(%rbp), %rsi
callq 0x3040
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5d20
movq -0x58(%rbp), %rdi
addq $0x20, %rdi
callq 0x3120
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x30f0
testb $0x1, %al
jne 0x1f45
jmp 0x1f61
leaq -0x30(%rbp), %rdi
callq 0x5d50
movsd 0x8(%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x1f65
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
// File: helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::zremrangebyrank(long, long)
void zremrangebyrank(long start, long end) {
        long llen = length();
        if (start < 0) start = llen + start;
        if (end < 0) end = llen + end;
        if (start < 0) start = 0;
        /* Invariant: start >= 0, so this test will be true when end < 0.
         * The range is empty when start > end or start >= length. */
        if (start > end || start >= llen) {
            return;
        }
        if (end >= llen) end = llen - 1;
        /* Correct for 1-based rank. */
        private_delete_range_by_rank(start+1, end+1);
    }

// 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)
callq 0x4b90
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jge 0x20a8
movq -0x20(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x20bb
movq -0x20(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jge 0x20ca
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jg 0x20de
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jl 0x20e0
jmp 0x2113
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jl 0x20f6
movq -0x20(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
addq $0x1, %rax
movl %eax, %esi
movq -0x18(%rbp), %rax
addq $0x1, %rax
movl %eax, %edx
callq 0x6040
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::~SortedSet()
~SortedSet() 
    {
        SkipListNode *node = mHeader->mLevel[0].mForward, *next;
        delete mHeader;
        while (node) {
            next = node->mLevel[0].mForward;
            delete node;
            node = next;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rax), %rcx
movq 0x20(%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x21c1
movq -0x20(%rbp), %rdi
callq 0x2ee0
movq -0x20(%rbp), %rdi
callq 0x10e0
jmp 0x21c3
cmpq $0x0, -0x10(%rbp)
je 0x2203
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x21f9
movq -0x30(%rbp), %rdi
callq 0x2ee0
movq -0x30(%rbp), %rdi
callq 0x10e0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x21c3
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x2430
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::zadd_generic(int, double, bool)
void zadd_generic(KeyType key, double score, bool incr) {
        DictTypeIterator it = mDict.find(key);
        if (it != mDict.end()) {
            double curscore = it->second;
            if (incr) {
                score += curscore;
            }
            if (score != curscore) {
                private_delete(curscore, key);
                private_insert(score, key);
                mDict[key] = score;
            }
        }
        else {
            private_insert(score, key);
            mDict[key] = score;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x20, %rdi
leaq -0xc(%rbp), %rsi
callq 0x3040
movq -0x50(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
addq $0x20, %rdi
callq 0x3120
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x30f0
testb $0x1, %al
jne 0x2f83
jmp 0x3003
leaq -0x30(%rbp), %rdi
callq 0x3160
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
testb $0x1, -0x19(%rbp)
je 0x2fab
movsd -0x48(%rbp), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
ucomisd -0x48(%rbp), %xmm0
jne 0x2fbb
jp 0x2fbb
jmp 0x3001
movq -0x50(%rbp), %rdi
movsd -0x48(%rbp), %xmm0
movl -0xc(%rbp), %esi
callq 0x3180
movq -0x50(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movl -0xc(%rbp), %esi
callq 0x3320
movq -0x50(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
addq $0x20, %rdi
leaq -0xc(%rbp), %rsi
callq 0x37f0
movsd -0x58(%rbp), %xmm0
movsd %xmm0, (%rax)
jmp 0x3038
movq -0x50(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movl -0xc(%rbp), %esi
callq 0x3320
movq -0x50(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
addq $0x20, %rdi
leaq -0xc(%rbp), %rsi
callq 0x37f0
movsd -0x60(%rbp), %xmm0
movsd %xmm0, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nop
// File: helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::private_delete(double, int)
bool private_delete(double score, KeyType key) 
    {
        SkipListNode *update[SKIPLIST_MAXLEVEL], *x;
        int i;
        x = mHeader;
        for (i = mLevel-1; i >= 0; i--) {
            while (x->mLevel[i].mForward && x->mLevel[i].mForward->mScore < score)
                x = x->mLevel[i].mForward;
            update[i] = x;
        }
        /* We may have multiple elements with the same score, what we need
         * is to find the element with both the right score and key. */
        x = x->mLevel[0].mForward;
        if (x && score == x->mScore && x->mKey == key) {
            private_delete_node(x, update);
            delete x;
            return true;
        } 
        else {
            return false; /* not found */
        }
        return false; /* not found */
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x138(%rbp)
movq (%rax), %rcx
movq %rcx, -0x128(%rbp)
movl 0x18(%rax), %eax
subl $0x1, %eax
movl %eax, -0x12c(%rbp)
cmpl $0x0, -0x12c(%rbp)
jl 0x327f
jmp 0x31c7
movq -0x128(%rbp), %rax
movq 0x20(%rax), %rcx
movslq -0x12c(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x139(%rbp)
je 0x3221
movq -0x128(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x12c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movsd 0x8(%rax), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
seta %al
movb %al, -0x139(%rbp)
movb -0x139(%rbp), %al
testb $0x1, %al
jne 0x322d
jmp 0x3255
movq -0x128(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x12c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x128(%rbp)
jmp 0x31c7
movq -0x128(%rbp), %rcx
movslq -0x12c(%rbp), %rax
movq %rcx, -0x120(%rbp,%rax,8)
movl -0x12c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x12c(%rbp)
jmp 0x31b8
movq -0x128(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq %rax, -0x128(%rbp)
cmpq $0x0, -0x128(%rbp)
je 0x330e
movsd -0x18(%rbp), %xmm0
movq -0x128(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
jne 0x330e
jp 0x330e
movq -0x128(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x330e
movq -0x138(%rbp), %rdi
movq -0x128(%rbp), %rsi
leaq -0x120(%rbp), %rdx
callq 0x3b40
movq -0x128(%rbp), %rax
movq %rax, -0x148(%rbp)
cmpq $0x0, %rax
je 0x3308
movq -0x148(%rbp), %rdi
callq 0x2ee0
movq -0x148(%rbp), %rdi
callq 0x10e0
movb $0x1, -0x1(%rbp)
jmp 0x3312
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
// File: helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::randomlevel()
int randomlevel() 
    {
        int level = 1;
        while ((random()&0xFFFF) < (0.25/*SKIPLIST_P*/ * 0xFFFF))
            level += 1;
        return (level<SKIPLIST_MAXLEVEL) ? level : SKIPLIST_MAXLEVEL;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
callq 0x1090
andq $0xffff, %rax           # imm = 0xFFFF
cvtsi2sd %rax, %xmm1
movsd 0x3345(%rip), %xmm0     # 0x7040
ucomisd %xmm1, %xmm0
jbe 0x3d0c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3ce3
cmpl $0x20, -0xc(%rbp)
jge 0x3d1a
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x3d24
movl $0x20, %eax
movl %eax, -0x10(%rbp)
jmp 0x3d24
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::get_element_by_rank(unsigned long)
SkipListNode* get_element_by_rank(unsigned long rank) {
        SkipListNode *x;
        unsigned long traversed = 0;
        int i;

        x = mHeader;
        for (i = mLevel-1; i >= 0; i--) {
            while (x->mLevel[i].mForward && (traversed + x->mLevel[i].mSpan) <= rank)
            {
                traversed += x->mLevel[i].mSpan;
                x = x->mLevel[i].mForward;
            }
            if (traversed == rank) {
                return x;
            }
        }
        return NULL;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, -0x28(%rbp)
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
movl 0x18(%rax), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x4c93
jmp 0x4be4
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movslq -0x2c(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x2d(%rbp)
je 0x4c29
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x20(%rcx), %rcx
movslq -0x2c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movl 0x8(%rcx), %ecx
addq %rcx, %rax
cmpq -0x18(%rbp), %rax
setbe %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x4c32
jmp 0x4c6f
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x4be4
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x4c83
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4c9b
jmp 0x4c85
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4bd8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::first_in_range(SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::RangeSpec const&)
SkipListNode* first_in_range(const RangeSpec &range) {
        SkipListNode *x;
        int i;
    
        /* If everything is out of range, return early. */
        if (!is_in_range(range)) return NULL;
    
        x = mHeader;
        for (i = mLevel-1; i >= 0; i--) {
            /* Go forward while *OUT* of range. */
            while (x->mLevel[i].mForward && !score_gte_min(x->mLevel[i].mForward->mScore, range))
                x = x->mLevel[i].mForward;
        }
    
        /* This is an inner range, so the next node cannot be NULL. */
        x = x->mLevel[0].mForward;
        assert(x != NULL);

        /* Check if score <= max. */
        if (!score_lte_max(x->mScore, range)) return NULL;
        return x;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rsi
callq 0x59e0
testb $0x1, %al
jne 0x56a2
movq $0x0, -0x8(%rbp)
jmp 0x5799
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
movl 0x18(%rax), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x573a
jmp 0x56be
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movslq -0x24(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x31(%rbp)
je 0x5705
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rdi
callq 0x5ab0
xorb $-0x1, %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x570e
jmp 0x572a
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x56be
jmp 0x572c
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x56b6
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5752
jmp 0x5771
leaq 0x19df(%rip), %rdi      # 0x7138
leaq 0x190d(%rip), %rsi      # 0x706d
movl $0xd8, %edx
leaq 0x19d6(%rip), %rcx      # 0x7142
callq 0x10b0
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rdi
callq 0x5b00
testb $0x1, %al
jne 0x5791
movq $0x0, -0x8(%rbp)
jmp 0x5799
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::get_rank(double, int)
unsigned long get_rank(double score, KeyType key) {
        SkipListNode *x;
        unsigned long rank = 0;
        int i;

        x = mHeader;
        for (i = mLevel-1; i >= 0; i--) {
            while (x->mLevel[i].mForward && x->mLevel[i].mForward->mScore <= score) {
                rank += x->mLevel[i].mSpan;
                x = x->mLevel[i].mForward;
            }

            /* x might be equal to mHeader, so test if is header */
            if (not x->mIsHeader && x->mKey == key) {
                return rank;
            }
        }
        return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, -0x30(%rbp)
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movl 0x18(%rax), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0x58a5
jmp 0x57e8
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rcx
movslq -0x34(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x35(%rbp)
je 0x5830
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x34(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movsd 0x8(%rax), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
setae %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x5839
jmp 0x5876
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x34(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x34(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x57e8
movq -0x28(%rbp), %rax
testb $0x1, (%rax)
jne 0x5895
movq -0x28(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x5895
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x58ad
jmp 0x5897
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x57dc
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::last_in_range(SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::RangeSpec const&)
SkipListNode* last_in_range(const RangeSpec &range) {
        SkipListNode *x;
        int i;
    
        /* If everything is out of range, return early. */
        if (!is_in_range(range)) return NULL;
    
        x = mHeader;
        for (i = mLevel-1; i >= 0; i--) {
            /* Go forward while *IN* range. */
            while (x->mLevel[i].mForward && score_lte_max(x->mLevel[i].mForward->mScore, range))
                x = x->mLevel[i].mForward;
        }
    
        /* This is an inner range, so this node cannot be NULL. */
        assert(x != NULL);
    
        /* Check if score >= min. */
        if (!score_gte_min(x->mScore, range)) return NULL;
        return x;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rsi
callq 0x59e0
testb $0x1, %al
jne 0x58f2
movq $0x0, -0x8(%rbp)
jmp 0x59d5
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
movl 0x18(%rax), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x5985
jmp 0x590e
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movslq -0x24(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x31(%rbp)
je 0x5953
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rdi
callq 0x5b00
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x595c
jmp 0x5978
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x590e
jmp 0x597a
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5906
cmpq $0x0, -0x20(%rbp)
je 0x598e
jmp 0x59ad
leaq 0x17a3(%rip), %rdi      # 0x7138
leaq 0x16d1(%rip), %rsi      # 0x706d
movl $0xf0, %edx
leaq 0x1827(%rip), %rcx      # 0x71cf
callq 0x10b0
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rdi
callq 0x5ab0
testb $0x1, %al
jne 0x59cd
movq $0x0, -0x8(%rbp)
jmp 0x59d5
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::is_in_range(SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::RangeSpec const&)
bool is_in_range(const RangeSpec &range) {
        SkipListNode *x;
        /* Test for ranges that will always be empty. */
        if (range.mMin > range.mMax || (range.mMin == range.mMax && (range.mMinex || range.mMaxex)))
            return false;
        x = mTail;
        if (x == NULL || !score_gte_min(x->mScore, range))
            return false;
        x = mHeader->mLevel[0].mForward;
        if (x == NULL || !score_lte_max(x->mScore, range))
            return false;
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
ja 0x5a34
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
jne 0x5a3a
jp 0x5a3a
movq -0x18(%rbp), %rax
testb $0x1, 0x10(%rax)
jne 0x5a34
movq -0x18(%rbp), %rax
testb $0x1, 0x11(%rax)
je 0x5a3a
movb $0x0, -0x1(%rbp)
jmp 0x5aa2
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5a63
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rdi
callq 0x5ab0
testb $0x1, %al
jne 0x5a69
movb $0x0, -0x1(%rbp)
jmp 0x5aa2
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5a98
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rdi
callq 0x5b00
testb $0x1, %al
jne 0x5a9e
movb $0x0, -0x1(%rbp)
jmp 0x5aa2
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: helayzhang[P]sorted_set/./sorted_set.hh
// Function: SortedSet<int, std::tr1::hash<int>, std::equal_to<int>>::zrank_generic(int, bool, unsigned long&)
bool zrank_generic(KeyType key, bool reverse, unsigned long &rank) {
        unsigned long llen = length();
        DictTypeIterator it = mDict.find(key);
        if (it != mDict.end()) {
            double score = it->second;
            rank = get_rank(score, key);
            if (reverse) {
                rank = llen - rank;
            }
            else {
                rank -= 1;
            }
            return true;
        }
        else {
            return false;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x4b90
movq -0x58(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x20, %rdi
leaq -0x14(%rbp), %rsi
callq 0x3040
movq -0x58(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
addq $0x20, %rdi
callq 0x3120
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x30f0
testb $0x1, %al
jne 0x5ddc
jmp 0x5e38
leaq -0x38(%rbp), %rdi
callq 0x3160
movq -0x58(%rbp), %rdi
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
movl -0x14(%rbp), %esi
callq 0x57b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
testb $0x1, -0x15(%rbp)
je 0x5e24
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
subq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x5e32
movq -0x20(%rbp), %rax
movq (%rax), %rcx
subq $0x1, %rcx
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x5e3c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: devernay[P]vlpovutils/./vlpov.hpp
// Function: VLPovImage<double>::save(char const*)
int save(const char *filename) { // should be const, but no because of endianness stuff
        if (_width <= 0 || _height <= 0) {
            return -1;
        }
        unsigned int siz = _width*_height;
        std::FILE *const nfile = std::fopen(filename,"wb");
        if (!nfile) {
            return -1;
        }
        if (!endianness()) {
            invert_endianness();
        }
        size_t nw = std::fwrite(_data,sizeof(T),siz,nfile);
        std::fclose(nfile);
        if (nw != siz) {
            return -1;
        }
        if (!endianness()) {
            invert_endianness();
        }
        return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, (%rax)
jle 0x4ac7
movq -0x38(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jg 0x4ad3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4b74
movq -0x38(%rbp), %rcx
movl (%rcx), %eax
imull 0x4(%rcx), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xb981(%rip), %rsi      # 0x1046c
callq 0x32a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4b04
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4b74
movq -0x38(%rbp), %rdi
callq 0x6090
testb $0x1, %al
jne 0x4b1a
movq -0x38(%rbp), %rdi
callq 0x60b0
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %edx
movq -0x28(%rbp), %rcx
movl $0x8, %esi
callq 0x3470
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x31d0
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpq %rcx, %rax
je 0x4b57
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4b74
movq -0x38(%rbp), %rdi
callq 0x6090
testb $0x1, %al
jne 0x4b6d
movq -0x38(%rbp), %rdi
callq 0x60b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: jamesgrimmett[P]orbital_determination/ex10-2_linear_least_squares.cc
// Function: propagate(std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>>)
std::vector<double> propagate(std::vector<double> state_, 
                                   std::vector<double> xobs_) {
  // Propagate the observed x value using the state vector
  // to calculate the expected y values.

  int i;
  std::vector<double> yexp_(xobs_.size(), 0.0);

  for (i = 0; i < xobs_.size(); i++) {
    yexp_[i] = state_[0] + state_[1] * xobs_[i];   
  }

  return yexp_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x68(%rbp)
movq %rsi, -0x70(%rbp)
movq %rdi, %rax
movq -0x68(%rbp), %rdi
movq %rax, -0x58(%rbp)
movq %rax, %rcx
movq %rcx, -0x60(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movb $0x0, -0x1d(%rbp)
callq 0x37a0
movq %rax, -0x50(%rbp)
movq $0x0, -0x28(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x36e0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rcx
leaq -0x28(%rbp), %rdx
callq 0x37c0
jmp 0x31ba
leaq -0x29(%rbp), %rdi
callq 0x3780
movl $0x0, -0x1c(%rbp)
movq -0x68(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x37a0
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x3287
movq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3860
movq -0x70(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x88(%rbp)
movl $0x1, %esi
callq 0x3860
movq -0x68(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x90(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x3860
movsd -0x90(%rbp), %xmm0
movsd -0x88(%rbp), %xmm1
movq -0x58(%rbp), %rdi
movsd (%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x80(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x3860
movsd -0x80(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x31ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x3780
jmp 0x32a7
movb $0x1, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0x329a
movq -0x58(%rbp), %rdi
callq 0x3b30
movq -0x60(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x1140
// File: jamesgrimmett[P]orbital_determination/ex10-2_linear_least_squares.cc
// Function: residuals(std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>>)
std::vector<double> residuals(std::vector<double> yobs_, 
                                 std::vector<double> yexp_) {
  // calculate the residuals (observed  - expected)

  // residuals vector
  std::vector<double> res_(yobs_.size(), 0.0);

  std::transform(yobs_.cbegin(), yobs_.cend(), 
                   yexp_.cbegin(), res_.begin(), std::minus<double>());

  return res_;  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0xa0(%rbp)
movq %rsi, -0x98(%rbp)
movq %rdi, %rax
movq -0x98(%rbp), %rdi
movq %rax, -0x88(%rbp)
movq %rax, %rcx
movq %rcx, -0x90(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x37a0
movq %rax, -0x80(%rbp)
movq $0x0, -0x28(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x36e0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rcx
leaq -0x28(%rbp), %rdx
callq 0x37c0
jmp 0x332c
leaq -0x29(%rbp), %rdi
callq 0x3780
movq -0x98(%rbp), %rdi
callq 0x4160
movq -0x98(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x4190
movq -0xa0(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x4160
movq -0x88(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x38f0
movq %rax, -0x60(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq -0x60(%rbp), %rcx
callq 0x40c0
movq %rax, -0xa8(%rbp)
jmp 0x3393
movq -0xa8(%rbp), %rax
movq %rax, -0x70(%rbp)
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x33e7
jmp 0x33db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x3780
jmp 0x33f7
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x3b30
jmp 0x33f7
movq -0x88(%rbp), %rdi
callq 0x3b30
movq -0x90(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x1140
// File: jamesgrimmett[P]orbital_determination/ex10-2_linear_least_squares.cc
// Function: root_mean_sq(std::vector<double, std::allocator<double>>)
double root_mean_sq(std::vector<double> res_) {
  // Calculate the square root of the mean expected squared value
  double rms_;
  std::vector<double> ressq(res_.size(), 0.0);
  std::transform(res_.cbegin(), res_.cend(),
                   res_.cbegin(), ressq.begin(), std::multiplies<double>());
  rms_ = std::accumulate(ressq.begin(), ressq.end(), 0.0) / res_.size();
  rms_ = std::sqrt(rms_);

  return rms_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x37a0
movq %rax, -0x98(%rbp)
movq $0x0, -0x30(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x36e0
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rcx
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x37c0
jmp 0x3457
leaq -0x31(%rbp), %rdi
callq 0x3780
movq -0xa0(%rbp), %rdi
callq 0x4160
movq -0xa0(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x4190
movq -0xa0(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x4160
movq %rax, -0x60(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x38f0
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq -0x68(%rbp), %rcx
callq 0x41c0
movq %rax, -0xa8(%rbp)
jmp 0x34bb
movq -0xa8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x38f0
movq -0xb8(%rbp), %rdi
movq %rax, -0x80(%rbp)
callq 0x3df0
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rsi
xorps %xmm0, %xmm0
callq 0x4260
movsd %xmm0, -0xb0(%rbp)
jmp 0x350a
movq -0xa0(%rbp), %rdi
callq 0x37a0
movsd -0xb0(%rbp), %xmm0
movq %rax, %xmm1
movaps 0x3af6(%rip), %xmm2     # 0x7020
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x3afa(%rip), %xmm2     # 0x7030
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x1080
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0xc0(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3b30
movsd -0xc0(%rbp), %xmm0
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x3780
jmp 0x35b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3b30
movq -0x40(%rbp), %rdi
callq 0x1140
nopl (%rax)
// File: brianwu02[P]ImageProcessing/halftone.cpp
// Function: main
int main(int argc, char** argv) {
    int m;
    double gamma;
    imageP I1, I2;

    cout << "argv[1] infile: " << argv[1] << endl;
    cout << "argv[2] m:      " << argv[2] << endl;
    cout << "argv[3] gamma:  " << argv[3] << endl;
    cout << "argv[4] outfile " << argv[4] << endl;

    I1 = IP_readImage(argv[1]);
    I2 = NEWIMAGE;

    m = atoi(argv[2]);
    gamma = atof(argv[3]);

    halftone(I1, m, gamma, I2);
    IP_saveImage(I2, argv[4]);

    IP_freeImage(I1);
    IP_freeImage(I2);
    
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x2c73(%rip), %rdi      # 0x3fd0
leaq 0xcb4(%rip), %rsi       # 0x2018
callq 0x10b0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x10b0
movq %rax, %rdi
movq 0x2c3d(%rip), %rsi      # 0x3fc0
callq 0x10c0
movq 0x2c41(%rip), %rdi      # 0x3fd0
leaq 0xc93(%rip), %rsi       # 0x2029
callq 0x10b0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x10b0
movq %rax, %rdi
movq 0x2c0b(%rip), %rsi      # 0x3fc0
callq 0x10c0
movq 0x2c0f(%rip), %rdi      # 0x3fd0
leaq 0xc72(%rip), %rsi       # 0x203a
callq 0x10b0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x10b0
movq %rax, %rdi
movq 0x2bd9(%rip), %rsi      # 0x3fc0
callq 0x10c0
movq 0x2bdd(%rip), %rdi      # 0x3fd0
leaq 0xc51(%rip), %rsi       # 0x204b
callq 0x10b0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x10b0
movq %rax, %rdi
movq 0x2ba7(%rip), %rsi      # 0x3fc0
callq 0x10c0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x18b0
movq %rax, -0x28(%rbp)
movl $0x10, %edi
callq 0x1130
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1170
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1100
movsd %xmm0, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
movsd -0x20(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x30(%rbp), %rdx
callq 0x14b0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x1bd0
movq -0x28(%rbp), %rdi
callq 0x1dd0
movq -0x30(%rbp), %rdi
callq 0x1dd0
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)