LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Mirrvin[P]DragonsResurrectingInc/./specialists/TailSpecialist.cpp
// Function: TailSpecialist::handleFreeOrderPriority(packet_t)
bool handleFreeOrderPriority(packet_t packet) {
        if(this->availableOrders > 0) this->availableOrders -= 1;
        if(this->getIndexFromOrderPriority(packet.status.MPI_SOURCE) < this->bodyList.size()) {
            this->orderPriority.erase(
                this->orderPriority.begin() + 
                this->getIndexFromOrderPriority(packet.status.MPI_SOURCE));
        }
        if(this->gettingResurrectionOrder && this->availableOrders > 0) {
            this->tryToAcceptOrder();
        }
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, 0x24(%rax)
jle 0x1201f
movq -0x30(%rbp), %rax
movl 0x24(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x24(%rax)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x12510
movq -0x30(%rbp), %rdi
movl %eax, %eax
movq %rax, -0x40(%rbp)
addq $0x48, %rdi
callq 0xf4c0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x120ac
movq -0x30(%rbp), %rdi
movq %rdi, %rax
addq $0x60, %rax
movq %rax, -0x48(%rbp)
addq $0x60, %rdi
callq 0xf3c0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x20(%rbp)
movl 0x10(%rax), %esi
callq 0x12510
movl %eax, %eax
movl %eax, %esi
leaq -0x20(%rbp), %rdi
callq 0x10270
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x11350
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x112e0
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
testb $0x1, 0x29(%rax)
je 0x120c9
movq -0x30(%rbp), %rax
cmpl $0x0, 0x24(%rax)
jle 0x120c9
movq -0x30(%rbp), %rdi
callq 0x123f0
movb $0x1, %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Mirrvin[P]DragonsResurrectingInc/./specialists/TailSpecialist.cpp
// Function: TailSpecialist::handleNewOrder(packet_t)
bool handleNewOrder(packet_t packet) {
        this->availableOrders += 1;
        if(this->gettingResurrectionOrder)  {
            this->tryToAcceptOrder();
        }
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
testb $0x1, 0x29(%rax)
je 0x1210c
movq -0x10(%rbp), %rdi
callq 0x123f0
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Mirrvin[P]DragonsResurrectingInc/./specialists/TailSpecialist.cpp
// Function: TailSpecialist::handleResurrectionFinished(packet_t)
bool handleResurrectionFinished(packet_t packet) {
        printf("%u: --- Dragon resurrected by team head: %d, body: %d, tail: %d ---\n", Monitor::getLamport(), this->headRank, this->bodyRank, this->rank);
        this->sendMessage(RESURRECTION_FINISHED, this->headRank);
        this->sendMessage(RESURRECTION_FINISHED, this->bodyRank);  
        this->sendMessage(RESURRECTION_FINISHED, ISSUER);      
        this->resurrecting = false;
        this->inTeam = false;
        this->headRank = 0;
        this->bodyRank = 0;
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
callq 0x12e00
movl %eax, %esi
movq -0x88(%rbp), %rax
movl 0x18(%rax), %edx
movl 0x1c(%rax), %ecx
movl 0x8(%rax), %r8d
leaq 0x318a(%rip), %rdi      # 0x15323
movb $0x0, %al
callq 0x8040
movq -0x88(%rbp), %rsi
movl 0x18(%rsi), %ecx
leaq -0x30(%rbp), %rdi
movl $0x77, %edx
callq 0x13e90
movq -0x88(%rbp), %rsi
movl 0x1c(%rsi), %ecx
leaq -0x58(%rbp), %rdi
movl $0x77, %edx
callq 0x13e90
movq -0x88(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movl $0x77, %edx
xorl %ecx, %ecx
callq 0x13e90
movq -0x88(%rbp), %rax
movb $0x0, 0x2a(%rax)
movb $0x0, 0x10(%rax)
movl $0x0, 0x18(%rax)
movl $0x0, 0x1c(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Mirrvin[P]DragonsResurrectingInc/./specialists/TailSpecialist.cpp
// Function: TailSpecialist::handleNeedTailPositive(packet_t)
bool handleNeedTailPositive(packet_t packet) {
        this->bodyRank = packet.status.MPI_SOURCE;
        this->sendMessage(AVENGERS_ASSEMBLED, this->rank);
        this->sendMessage(AVENGERS_ASSEMBLED, this->headRank);
        this->handlingNeedTail = false;
        this->inTeam = true;
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x60(%rbp)
movl 0x10(%rax), %eax
movl %eax, 0x1c(%rsi)
movl 0x8(%rsi), %ecx
leaq -0x30(%rbp), %rdi
movl $0x71, %edx
callq 0x13e90
movq -0x60(%rbp), %rsi
movl 0x18(%rsi), %ecx
leaq -0x58(%rbp), %rdi
movl $0x71, %edx
callq 0x13e90
movq -0x60(%rbp), %rax
movb $0x0, 0x28(%rax)
movb $0x1, 0x10(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Mirrvin[P]DragonsResurrectingInc/./specialists/TailSpecialist.cpp
// Function: TailSpecialist::handleNeedTailNegative(packet_t)
bool handleNeedTailNegative(packet_t packet) {
        this->headRank = 0;
        this->handlingNeedTail = false;
        this->inTeam = false;
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movb $0x0, 0x28(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Mirrvin[P]DragonsResurrectingInc/./specialists/TailSpecialist.cpp
// Function: TailSpecialist::getSelfIndexFromTailList()
unsigned int getSelfIndexFromTailList() {
        for(unsigned int i=0; i<this->tailList.size(); i++) {
            if(this->rank == this->tailList[i].status.MPI_SOURCE){
                return i;
            }
        }
        return this->bodyList.size();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x28(%rbp)
addq $0x30, %rdi
callq 0xf4c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x12323
movq -0x20(%rbp), %rdi
movl 0x8(%rdi), %eax
movl %eax, -0x2c(%rbp)
addq $0x30, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0xf970
movq %rax, %rcx
movl -0x2c(%rbp), %eax
cmpl 0x10(%rcx), %eax
jne 0x12316
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x12333
jmp 0x12318
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x122cb
movq -0x20(%rbp), %rdi
addq $0x48, %rdi
callq 0xf4c0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Mirrvin[P]DragonsResurrectingInc/./specialists/TailSpecialist.cpp
// Function: TailSpecialist::tryToAcceptOrder()
void tryToAcceptOrder() {
        std::sort(this->orderPriority.begin(), this->orderPriority.end(), comparePacketsLamport);
        unsigned int me = this->getIndexFromOrderPriority(this->rank);
        if(me == 0 && this->availableOrders > 0) { 
            printf("%u: Got the order , rank: %d\n",Monitor::getLamport(), this->rank);
            if(this->availableOrders > 0) 
                this->availableOrders -= 1;
            this->gettingResurrectionOrder = false;
            this->resurrecting = true;
            this->broadcastMessage(FREE_ORDER_PRIORITY, TAIL);
            this->orderPriority.erase(
                this->orderPriority.begin() + me);
            this->beginDragonResurrection();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x60, %rdi
callq 0xf3c0
movq -0x70(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0x60, %rdi
callq 0xf230
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x12d4(%rip), %rdx     # 0x11160
callq 0xf7f0
movq -0x70(%rbp), %rdi
movl 0x8(%rdi), %esi
callq 0x12510
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x12507
movq -0x70(%rbp), %rax
cmpl $0x0, 0x24(%rax)
jle 0x12507
callq 0x12e00
movl %eax, %esi
movq -0x70(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x2e90(%rip), %rdi      # 0x15305
movb $0x0, %al
callq 0x8040
movq -0x70(%rbp), %rax
cmpl $0x0, 0x24(%rax)
jle 0x12493
movq -0x70(%rbp), %rax
movl 0x24(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x24(%rax)
movq -0x70(%rbp), %rsi
movb $0x0, 0x29(%rsi)
movb $0x1, 0x2a(%rsi)
leaq -0x48(%rbp), %rdi
movl $0x74, %edx
movl $0x3, %ecx
callq 0x140e0
movq -0x70(%rbp), %rdi
movq %rdi, %rax
addq $0x60, %rax
movq %rax, -0x78(%rbp)
addq $0x60, %rdi
callq 0xf3c0
movq %rax, -0x60(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %esi
leaq -0x60(%rbp), %rdi
callq 0x10270
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x11350
movq -0x78(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x112e0
movq -0x70(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x125a0
addq $0x80, %rsp
popq %rbp
retq
// File: Mirrvin[P]DragonsResurrectingInc/./specialists/TailSpecialist.cpp
// Function: TailSpecialist::getIndexFromOrderPriority(int)
unsigned int getIndexFromOrderPriority(int rank) {
        for(unsigned int i=0; i<this->orderPriority.size(); i++) {
            if(rank == this->orderPriority[i].status.MPI_SOURCE){
                return i;
            }
        }
        return this->orderPriority.size();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %eax
movq %rax, -0x28(%rbp)
addq $0x60, %rdi
callq 0xf4c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x12586
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
addq $0x60, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0xf970
movq %rax, %rcx
movl -0x2c(%rbp), %eax
cmpl 0x10(%rcx), %eax
jne 0x12579
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x12596
jmp 0x1257b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1252e
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
callq 0xf4c0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Mirrvin[P]DragonsResurrectingInc/Monitor.cpp
// Function: Monitor::receiveMessage()
packet_t Monitor::receiveMessage() {
    packet_t packet;
    MPI_Status status;
    MPI_Recv( &packet, sizeof(packet_t), MPI_BYTE, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &status);
    packet.status = status;
    Monitor::incrementLamportOnReceive(packet);
    return packet;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movl $0x28, %esi
movq 0xa316(%rip), %rdx      # 0x1cfb8
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq 0xa319(%rip), %r9       # 0x1cfc8
leaq -0x18(%rbp), %rax
movl %r8d, %ecx
movq %rax, (%rsp)
callq 0x84c0
movq -0x50(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, 0x10(%rsi)
movq -0x10(%rbp), %rax
movq %rax, 0x18(%rsi)
movq -0x8(%rbp), %rax
movq %rax, 0x20(%rsi)
leaq -0x40(%rbp), %rdi
movl $0x28, %edx
callq 0x84d0
movq -0x20(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x40(%rbp), %xmm0
movups -0x30(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x12bd0
movq -0x48(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Mirrvin[P]DragonsResurrectingInc/Monitor.cpp
// Function: Monitor::listen()
void Monitor::listen() {
    Monitor::listening = true;
    packet_t packet;
    while(Monitor::listening) {
        packet = Monitor::receiveMessage();   
        pthread_mutex_lock(&Monitor::messageQueueMutex); // dostęp do kolejki wiadomości
        Monitor::messageQueue.push(packet);
        pthread_mutex_unlock(&Monitor::messageQueueMutex);
        pthread_mutex_unlock(&Monitor::handleMutex); // odblokowanie handleLoop
        if(packet.status.MPI_TAG == END)
            listening = false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb $0x1, 0xa8dd(%rip)      # 0x1d60c
testb $0x1, 0xa8d6(%rip)      # 0x1d60c
je 0x12d96
leaq -0x50(%rbp), %rdi
callq 0x12c80
leaq -0x28(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x28, %edx
callq 0x84d0
leaq 0xa90e(%rip), %rdi      # 0x1d668
callq 0x88a0
leaq 0xa97a(%rip), %rdi      # 0x1d6e0
leaq -0x28(%rbp), %rsi
callq 0x12ea0
leaq 0xa8f2(%rip), %rdi      # 0x1d668
callq 0x8400
leaq 0xa8be(%rip), %rdi      # 0x1d640
callq 0x8400
cmpl $0x65, -0x14(%rbp)
jne 0x12d94
movb $0x0, 0xa878(%rip)      # 0x1d60c
jmp 0x12d2f
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: Mirrvin[P]DragonsResurrectingInc/Monitor.cpp
// Function: Monitor::incrementLamportOnSend()
unsigned int Monitor::incrementLamportOnSend() {
    pthread_mutex_lock(&Monitor::lamportMutex);
    Monitor::lamport += 1;
    unsigned int incrementedLamport = Monitor::lamport;
    pthread_mutex_unlock(&Monitor::lamportMutex);
    return incrementedLamport;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xa859(%rip), %rdi      # 0x1d618
callq 0x88a0
movl 0xa846(%rip), %eax      # 0x1d610
addl $0x1, %eax
movl %eax, 0xa83d(%rip)      # 0x1d610
movl 0xa837(%rip), %eax      # 0x1d610
movl %eax, -0x4(%rbp)
leaq 0xa835(%rip), %rdi      # 0x1d618
callq 0x8400
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Mirrvin[P]DragonsResurrectingInc/specialists/Specialist.cpp
// Function: Specialist::Specialist(int, int)
Specialist::Specialist(int rank, int size) { 
    this->rank = rank;
    this->size = size;
    this->resurrectionCounter = 0;
    this->inTeam = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
leaq 0x8f1f(%rip), %rcx      # 0x1cd48
addq $0x10, %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl $0x0, 0x14(%rax)
movb $0x0, 0x10(%rax)
popq %rbp
retq
nopl (%rax)
// File: Mirrvin[P]DragonsResurrectingInc/specialists/Specialist.cpp
// Function: Specialist::createSelfPacket()
packet_t Specialist::createSelfPacket() {
    packet_t packet;
    packet.ressurectCounter = this->resurrectionCounter;
    packet.status.MPI_SOURCE = this->rank;
    packet.lamport = Monitor::getLamport();
    return packet;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
movl %ecx, 0x4(%rdi)
movl 0x8(%rax), %eax
movl %eax, 0x10(%rdi)
callq 0x12e00
movq -0x18(%rbp), %rdi
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Mirrvin[P]DragonsResurrectingInc/specialists/Specialist.cpp
// Function: Specialist::broadcastMessage(packet_t, int)
packet_t Specialist::broadcastMessage(packet_t packet, int tag) {
    packet.lamport = Monitor::incrementLamportOnSend();
    for(int i=1;i<this->size;i++){
        if(i != this->rank) {
            MPI_Send(&packet, sizeof(packet_t), MPI_BYTE, i, tag, MPI_COMM_WORLD);
        }
    }
    return packet;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x12db0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl $0x1, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x140c4
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x8(%rcx), %eax
je 0x140b7
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %ecx
movl -0xc(%rbp), %r8d
movl $0x28, %esi
movq 0x8f0d(%rip), %rdx      # 0x1cfb8
movq 0x8f16(%rip), %r9       # 0x1cfc8
callq 0x81d0
jmp 0x140b9
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1407c
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdi
movl $0x28, %edx
callq 0x84d0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: Mirrvin[P]DragonsResurrectingInc/specialists/Specialist.cpp
// Function: Specialist::broadcastMessage(packet_t, int, int)
packet_t Specialist::broadcastMessage(packet_t packet, int tag, int targetType) {
    packet.lamport = Monitor::incrementLamportOnSend();
    for(int i=1;i<this->size;i++){
        if(i != this->rank && (i%3 + 1) == targetType) {
            MPI_Send(&packet, sizeof(packet_t), MPI_BYTE, i, tag, MPI_COMM_WORLD);
        }
    }
    return packet;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x12db0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movl $0x1, -0x14(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x141fa
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
je 0x141ed
movl -0x14(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
addl $0x1, %edx
cmpl -0x10(%rbp), %edx
jne 0x141ed
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %ecx
movl -0xc(%rbp), %r8d
movl $0x28, %esi
movq 0x8dd7(%rip), %rdx      # 0x1cfb8
movq 0x8de0(%rip), %r9       # 0x1cfc8
callq 0x81d0
jmp 0x141ef
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1419f
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdi
movl $0x28, %edx
callq 0x84d0
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: porzell[P]PTest/examples/../include/ptest.hpp
// Function: PTest::SetConsoleColor(PTest::PColor)
void SetConsoleColor(PColor color) {
#ifdef __linux__
		switch (color) {
		case PColor::Red:		printf("\x1b[31m"); break;
		case PColor::Green:	printf("\x1b[32m"); break;
		case PColor::Blue:	printf("\x1b[36m"); break;
		default:						printf("\x1B[0m");
		}
#endif
#ifdef _WIN32
		static HANDLE handle = 0;
		if (!handle) {
			handle = GetStdHandle(STD_OUTPUT_HANDLE);
			CONSOLE_SCREEN_BUFFER_INFO csbi;
			GetConsoleScreenBufferInfo(handle, &csbi);
		}
		WORD attributes;
		switch (color) {
		case PColor::Red: attributes = FOREGROUND_RED; break;
		case PColor::Blue: attributes = FOREGROUND_BLUE | FOREGROUND_GREEN; break;
		case PColor::Green: attributes = FOREGROUND_GREEN; break;
		default: attributes = FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN;
		}
		SetConsoleTextAttribute(handle, attributes);
#endif
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $0x1, %eax
je 0x24ec
jmp 0x24c8
movl -0x8(%rbp), %eax
subl $0x2, %eax
je 0x24fc
jmp 0x24d2
movl -0x8(%rbp), %eax
subl $0x3, %eax
jne 0x250c
jmp 0x24dc
leaq 0x6b44(%rip), %rdi      # 0x9027
movb $0x0, %al
callq 0x2040
jmp 0x251a
leaq 0x6b3a(%rip), %rdi      # 0x902d
movb $0x0, %al
callq 0x2040
jmp 0x251a
leaq 0x6b30(%rip), %rdi      # 0x9033
movb $0x0, %al
callq 0x2040
jmp 0x251a
leaq 0x6b26(%rip), %rdi      # 0x9039
movb $0x0, %al
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
// File: porzell[P]PTest/examples/custom_main_test.cpp
// Function: CanReserveVector23()
P_TEST(CanReserveVector) {
	std::vector<int> vec;
	vec.reserve(10);

	P_ASSERT(vec.capacity() >= 10);
	P_ASSERT(vec.size() == 0);

	for (int i = 0; i < 11; ++i) {
		vec.push_back(3);
	}

	P_ASSERT(vec.capacity() > 10);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
leaq -0x18(%rbp), %rdi
movq %rdi, -0x198(%rbp)
callq 0x64f0
movq -0x198(%rbp), %rdi
movl $0xa, %esi
callq 0x7b70
jmp 0x297e
leaq -0x18(%rbp), %rdi
callq 0x7c70
subq $0xa, %rax
setae -0x25(%rbp)
callq 0x3020
movq %rax, -0x1a0(%rbp)
jmp 0x299d
movzbl -0x25(%rbp), %esi
andl $0x1, %esi
leaq 0x6729(%rip), %rdx      # 0x90d4
leaq 0x6840(%rip), %r8       # 0x91f2
xorl %eax, %eax
movl %eax, %r9d
leaq -0x98(%rbp), %rdi
movl $0x1b, %ecx
callq 0x66a0
jmp 0x29ca
movq -0x1a0(%rbp), %rdi
leaq -0x98(%rbp), %rsi
xorl %edx, %edx
callq 0x6560
jmp 0x29e1
leaq -0x98(%rbp), %rdi
callq 0x59b0
testb $0x1, -0x25(%rbp)
jne 0x2a30
movl $0x1, -0x9c(%rbp)
jmp 0x2bc9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2bdb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x59b0
jmp 0x2bdb
leaq -0x18(%rbp), %rdi
callq 0x6540
testq %rax, %rax
sete -0x9d(%rbp)
callq 0x3020
movq %rax, -0x1a8(%rbp)
jmp 0x2a51
movzbl -0x9d(%rbp), %esi
andl $0x1, %esi
leaq 0x6672(%rip), %rdx      # 0x90d4
leaq 0x679e(%rip), %r8       # 0x9207
xorl %eax, %eax
movl %eax, %r9d
leaq -0x110(%rbp), %rdi
movl $0x1c, %ecx
callq 0x66a0
jmp 0x2a81
movq -0x1a8(%rbp), %rdi
leaq -0x110(%rbp), %rsi
xorl %edx, %edx
callq 0x6560
jmp 0x2a98
leaq -0x110(%rbp), %rdi
callq 0x59b0
testb $0x1, -0x9d(%rbp)
jne 0x2ad9
movl $0x1, -0x9c(%rbp)
jmp 0x2bc9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x59b0
jmp 0x2bdb
movl $0x0, -0x114(%rbp)
cmpl $0xb, -0x114(%rbp)
jge 0x2b1b
movl $0x3, -0x118(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x6510
jmp 0x2b08
jmp 0x2b0a
movl -0x114(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x114(%rbp)
jmp 0x2ae3
leaq -0x18(%rbp), %rdi
callq 0x7c70
subq $0xb, %rax
setae -0x119(%rbp)
callq 0x3020
movq %rax, -0x1b0(%rbp)
jmp 0x2b3d
movzbl -0x119(%rbp), %esi
andl $0x1, %esi
leaq 0x6586(%rip), %rdx      # 0x90d4
leaq 0x66c2(%rip), %r8       # 0x9217
xorl %eax, %eax
movl %eax, %r9d
leaq -0x190(%rbp), %rdi
movl $0x22, %ecx
callq 0x66a0
jmp 0x2b6d
movq -0x1b0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
xorl %edx, %edx
callq 0x6560
jmp 0x2b84
leaq -0x190(%rbp), %rdi
callq 0x59b0
testb $0x1, -0x119(%rbp)
jne 0x2bbf
movl $0x1, -0x9c(%rbp)
jmp 0x2bc9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x59b0
jmp 0x2bdb
movl $0x0, -0x9c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6810
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0x6810
movq -0x20(%rbp), %rdi
callq 0x2240
nopl (%rax)
// File: porzell[P]PTest/examples/custom_main_test.cpp
// Function: CanInsertVector37()
P_TEST(CanInsertVector) {
	std::vector<int> vec;

	for (int i = 0; i < 10; ++i) {
		vec.push_back(i);
	}

	for (int i = 0; i < 10; ++i) {
		P_ASSERT(vec[i] == i);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq -0x18(%rbp), %rdi
callq 0x64f0
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x2c3e
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x7c90
jmp 0x2c20
jmp 0x2c22
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2c0b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x2d1d
movl $0x0, -0x30(%rbp)
cmpl $0xa, -0x30(%rbp)
jge 0x2d01
movslq -0x30(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x7d00
movl (%rax), %eax
movl -0x30(%rbp), %ecx
subl %ecx, %eax
sete -0x31(%rbp)
callq 0x3020
movq %rax, -0xb8(%rbp)
jmp 0x2c75
movzbl -0x31(%rbp), %esi
andl $0x1, %esi
leaq 0x6451(%rip), %rdx      # 0x90d4
leaq 0x65b1(%rip), %r8       # 0x923b
xorl %eax, %eax
movl %eax, %r9d
leaq -0xa8(%rbp), %rdi
movl $0x2d, %ecx
callq 0x66a0
jmp 0x2ca2
movq -0xb8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
xorl %edx, %edx
callq 0x6560
jmp 0x2cb9
leaq -0xa8(%rbp), %rdi
callq 0x59b0
testb $0x1, -0x31(%rbp)
jne 0x2cf1
movl $0x1, -0xac(%rbp)
jmp 0x2d0b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x59b0
jmp 0x2d1d
jmp 0x2cf3
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2c45
movl $0x0, -0xac(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6810
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0x6810
movq -0x28(%rbp), %rdi
callq 0x2240
nop
// File: porzell[P]PTest/examples/custom_main_test.cpp
// Function: TestExpect49()
P_TEST(TestExpect) {
	int i = 0;

	for (int i = 0; i < 3; ++i)
	{
		P_EXPECT(i == i - 1);
	}

	P_ASSERT(i == 0);

	P_ASSERT(i == 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x3, -0x8(%rbp)
jge 0x2dce
callq 0x3020
movq %rax, -0x180(%rbp)
leaq 0x6372(%rip), %rdx      # 0x90d4
leaq 0x64de(%rip), %r8       # 0x9247
xorl %esi, %esi
movl %esi, %r9d
leaq -0x78(%rbp), %rdi
movq %rdi, -0x178(%rbp)
movl $0x36, %ecx
callq 0x66a0
movq -0x180(%rbp), %rdi
movq -0x178(%rbp), %rsi
movl $0x1, %edx
callq 0x6560
jmp 0x2d9d
leaq -0x78(%rbp), %rdi
callq 0x59b0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x2d49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x59b0
jmp 0x2f22
movl -0x4(%rbp), %eax
testl %eax, %eax
sete -0x85(%rbp)
callq 0x3020
movq %rax, -0x198(%rbp)
movzbl -0x85(%rbp), %esi
andl $0x1, %esi
leaq 0x62dd(%rip), %rdx      # 0x90d4
leaq 0x6454(%rip), %r8       # 0x9252
xorl %eax, %eax
movl %eax, -0x184(%rbp)
movl %eax, %r9d
leaq -0xf8(%rbp), %rdi
movq %rdi, -0x190(%rbp)
movl $0x39, %ecx
callq 0x66a0
movq -0x198(%rbp), %rdi
movq -0x190(%rbp), %rsi
movl -0x184(%rbp), %edx
callq 0x6560
jmp 0x2e3c
leaq -0xf8(%rbp), %rdi
callq 0x59b0
testb $0x1, -0x85(%rbp)
jne 0x2e76
jmp 0x2f19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0x59b0
jmp 0x2f22
movl -0x4(%rbp), %eax
subl $0x1, %eax
sete -0xf9(%rbp)
callq 0x3020
movq %rax, -0x1b0(%rbp)
movzbl -0xf9(%rbp), %esi
andl $0x1, %esi
leaq 0x6234(%rip), %rdx      # 0x90d4
leaq 0x63b2(%rip), %r8       # 0x9259
xorl %eax, %eax
movl %eax, -0x19c(%rbp)
movl %eax, %r9d
leaq -0x170(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
movl $0x3b, %ecx
callq 0x66a0
movq -0x1b0(%rbp), %rdi
movq -0x1a8(%rbp), %rsi
movl -0x19c(%rbp), %edx
callq 0x6560
jmp 0x2ee5
leaq -0x170(%rbp), %rdi
callq 0x59b0
testb $0x1, -0xf9(%rbp)
jne 0x2f19
jmp 0x2f19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x170(%rbp), %rdi
callq 0x59b0
jmp 0x2f22
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x2240
nopl (%rax,%rax)
// File: porzell[P]PTest/examples/../include/ptest.hpp
// Function: PTest::PTestRegistrar::PTestRegistrar(char const*, void (*)())
PTestRegistrar(const char* testName, P_TEST_FUNC testFunc) {
			SetConsoleColor(PColor::Blue);
			printf("Found test %s...\n", testName);
			SetConsoleColor(PColor::Normal);
			PTestRegistry::Get().AddTest(PTest(testName, testFunc));
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x2, %edi
callq 0x24b0
movq -0x10(%rbp), %rsi
leaq 0x60ed(%rip), %rdi      # 0x9079
xorl %eax, %eax
movl %eax, -0xb4(%rbp)
callq 0x2040
movl -0xb4(%rbp), %edi
callq 0x24b0
callq 0x3020
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x90(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3520
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x32a0
jmp 0x2fe0
leaq -0x90(%rbp), %rdi
callq 0x3620
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x3620
movq -0x98(%rbp), %rdi
callq 0x2240
nop
// File: porzell[P]PTest/examples/../include/ptest.hpp
// Function: PTest::PTestRegistry::AddTest(PTest::PTest&&)
void AddTest(PTest&& ptest) {
			std::string name;
			if (ptest.HasFixture()) {
				name = ptest.GetFixtureName() + "." + ptest.GetName();
			} else {
				name = ptest.GetName();
			}

			if (testMap_.find(name) != testMap_.end()) {
				SetConsoleColor(PColor::Red);
				printf("[DUPLICATE TESTS FOUND for \"%s!\" ABORTING...]\n", name.c_str());
				SetConsoleColor(PColor::Normal);
				return;
			}

			index_.push_back(testMap_.insert(testMap_.cbegin(), { name, ptest }));
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x150(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x21d0
movq -0x10(%rbp), %rdi
callq 0x3660
movb %al, -0x141(%rbp)
jmp 0x32d8
movb -0x141(%rbp), %al
testb $0x1, %al
jne 0x32e7
jmp 0x3386
movq -0x10(%rbp), %rdi
callq 0x3750
movq %rax, -0x158(%rbp)
jmp 0x32f9
movq -0x158(%rbp), %rsi
leaq 0x5fd9(%rip), %rdx      # 0x92e0
leaq -0x80(%rbp), %rdi
callq 0x36d0
jmp 0x3312
movq -0x10(%rbp), %rdi
callq 0x3770
movq %rax, -0x160(%rbp)
jmp 0x3324
movq -0x160(%rbp), %rdx
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x3680
jmp 0x333a
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2180
leaq -0x60(%rbp), %rdi
callq 0x2100
leaq -0x80(%rbp), %rdi
callq 0x2100
jmp 0x33ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3506
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x2100
jmp 0x3506
movq -0x10(%rbp), %rdi
callq 0x3770
movq %rax, -0x168(%rbp)
jmp 0x3398
movq -0x168(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x2030
jmp 0x33aa
jmp 0x33ac
movq -0x150(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x37b0
movq %rax, -0x170(%rbp)
jmp 0x33c5
movq -0x150(%rbp), %rdi
movq -0x170(%rbp), %rax
movq %rax, -0x88(%rbp)
callq 0x37e0
movq %rax, -0x90(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x3780
testb $0x1, %al
jne 0x33ff
jmp 0x343f
movl $0x3, %edi
callq 0x24b0
jmp 0x340b
leaq -0x30(%rbp), %rdi
callq 0x20a0
movq %rax, %rsi
leaq 0x5c6d(%rip), %rdi      # 0x908b
xorl %eax, %eax
callq 0x2040
jmp 0x3427
xorl %edi, %edi
callq 0x24b0
jmp 0x3430
movl $0x1, -0x94(%rbp)
jmp 0x34dc
movq -0x150(%rbp), %rdi
movq %rdi, %rax
addq $0x38, %rax
movq %rax, -0x180(%rbp)
movq %rdi, %rax
movq %rax, -0x178(%rbp)
callq 0x3880
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rdx
leaq -0x140(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x38b0
jmp 0x3480
movq -0x178(%rbp), %rdi
movq -0xa8(%rbp), %rsi
leaq -0x140(%rbp), %rdx
callq 0x3840
movq %rax, -0x188(%rbp)
jmp 0x34a3
movq -0x180(%rbp), %rdi
movq -0x188(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0xa0(%rbp), %rsi
callq 0x3810
jmp 0x34c6
leaq -0x140(%rbp), %rdi
callq 0x3910
movl $0x0, -0x94(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2100
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x140(%rbp), %rdi
callq 0x3910
leaq -0x30(%rbp), %rdi
callq 0x2100
movq -0x38(%rbp), %rdi
callq 0x2240
nopl (%rax,%rax)
// File: porzell[P]PTest/examples/../include/ptest.hpp
// Function: PTest::PTestRegistry::AddAssertion(PTest::PAssertion, bool)
void AddAssertion(PAssertion assertion, bool is_expect = false) {
			if (currentTest_) {
				currentTest_->AddAssertion(assertion, is_expect);
			}
			else {
				SetConsoleColor(PColor::Red);
				printf("ASSERTION \"%s\" on line %u of %s:\n\tINVALID OUTSIDE OF TEST CASE\n",
					assertion.GetCondition().c_str(), assertion.GetLine(), assertion.GetFile().c_str());
				SetConsoleColor(PColor::Normal);
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xa8(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
cmpq $0x0, 0x50(%rax)
je 0x660c
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0xb8(%rbp)
leaq -0x88(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x58a0
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movzbl -0x11(%rbp), %edx
andl $0x1, %edx
callq 0x70d0
jmp 0x65db
leaq -0x88(%rbp), %rdi
callq 0x59b0
jmp 0x667c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x59b0
jmp 0x6685
movl $0x3, %edi
callq 0x24b0
movq -0xa8(%rbp), %rdi
callq 0x71d0
movq %rax, %rdi
callq 0x20a0
movq -0xa8(%rbp), %rdi
movq %rax, -0xc8(%rbp)
callq 0x71f0
movq -0xa8(%rbp), %rdi
movl %eax, -0xbc(%rbp)
callq 0x7210
movq %rax, %rdi
callq 0x20a0
movq -0xc8(%rbp), %rsi
movl -0xbc(%rbp), %edx
movq %rax, %rcx
leaq 0x2adb(%rip), %rdi      # 0x9149
movb $0x0, %al
callq 0x2040
xorl %edi, %edi
callq 0x24b0
addq $0xd0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x2240
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: porzell[P]PTest/examples/../include/ptest.hpp
// Function: PTest::PTest::AddAssertion(PTest::PAssertion, bool)
void AddAssertion(PAssertion assertion, bool is_expect = false) {
			assertions_.push_back(assertion);
			if (!assertion) {
				SetConsoleColor(PColor::Red); putchar('\n'); PrintBars();
				if (is_expect) {
					printf("Expectation Failure in %s (Line %u)\n", assertion.GetFile().c_str(), assertion.GetLine());
				}
				else {
					printf("Assertion Failure in %s (Line %u)\n", assertion.GetFile().c_str(), assertion.GetLine());
				}
				printf("     Condition not met:\n\t");
				SetConsoleColor(PColor::Normal); printf("(%s)\n\n", assertion.GetCondition().c_str());
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x20(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
addq $0x58, %rdi
callq 0x7230
movq -0x20(%rbp), %rdi
callq 0x72a0
testb $0x1, %al
jne 0x71ca
movl $0x3, %edi
callq 0x24b0
movl $0xa, %edi
callq 0x21e0
movl $0x2, %edi
callq 0x2460
testb $0x1, -0x11(%rbp)
je 0x7161
movq -0x20(%rbp), %rdi
callq 0x7210
movq %rax, %rdi
callq 0x20a0
movq -0x20(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x71f0
movq -0x28(%rbp), %rsi
movl %eax, %edx
leaq 0x2031(%rip), %rdi      # 0x9189
movb $0x0, %al
callq 0x2040
jmp 0x7193
movq -0x20(%rbp), %rdi
callq 0x7210
movq %rax, %rdi
callq 0x20a0
movq -0x20(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x71f0
movq -0x30(%rbp), %rsi
movl %eax, %edx
leaq 0x2022(%rip), %rdi      # 0x91ae
movb $0x0, %al
callq 0x2040
leaq 0x2037(%rip), %rdi      # 0x91d1
movb $0x0, %al
callq 0x2040
xorl %edi, %edi
callq 0x24b0
movq -0x20(%rbp), %rdi
callq 0x71d0
movq %rax, %rdi
callq 0x20a0
movq %rax, %rsi
leaq 0x2028(%rip), %rdi      # 0x91eb
movb $0x0, %al
callq 0x2040
addq $0x30, %rsp
popq %rbp
retq
// File: porzell[P]PTest/examples/../include/ptest.hpp
// Function: PTest::PTestRegistry::~PTestRegistry()
~PTestRegistry() {
			// Free all test fixtures
			for (auto& it : index_) {
				auto& ptest = it->second;
				if(ptest.HasFixture()) {
					delete(ptest.GetFixture());
				}
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x38, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x43b0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4240
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8290
testb $0x1, %al
jne 0x7f79
jmp 0x7fd7
leaq -0x18(%rbp), %rdi
callq 0x82d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x82f0
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3660
testb $0x1, %al
jne 0x7fa6
jmp 0x7fca
movq -0x30(%rbp), %rdi
callq 0x8320
movq %rax, -0x40(%rbp)
jmp 0x7fb5
movq -0x40(%rbp), %rax
cmpq $0x0, %rax
je 0x7fc8
movq -0x40(%rbp), %rdi
callq 0x2150
jmp 0x7fca
jmp 0x7fcc
leaq -0x18(%rbp), %rdi
callq 0x8340
jmp 0x7f66
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
callq 0x8360
movq -0x38(%rbp), %rdi
callq 0x83c0
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3b50
nopl (%rax,%rax)
// File: LandonSwartz[P]TheGreatEncryptor/main.cpp
// Function: readFile(void*)
void *readFile(void *arg)
{
	int i; int c;
	struct ft* fi = (struct ft*)arg;
	string filename = fi->file.getFilename();
	cout<<"Filename is: "<< filename<<endl;
	ifstream in(filename);
	if(!in)
	{
		cout<<"Failure to open file, try again. Spelling counts"<<endl;
		return NULL;
	}
	string word;
	while(in>>word)
	{
		fi->fileVector.push_back(word);
	}
	in.close();
	cout<<"File was read!"<<endl;

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp            # imm = 0x2C0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
addq $0x18, %rsi
leaq -0x40(%rbp), %rdi
callq 0x31e0
movq 0x99d9(%rip), %rdi      # 0xbfc8
leaq 0x5a1e(%rip), %rsi      # 0x8014
callq 0x2180
movq %rax, -0x288(%rbp)
jmp 0x2604
movq -0x288(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2160
movq %rax, -0x290(%rbp)
jmp 0x261d
movq -0x290(%rbp), %rdi
movq 0x998d(%rip), %rsi      # 0xbfb8
callq 0x21b0
jmp 0x2632
leaq -0x258(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x8, %edx
callq 0x2280
jmp 0x2649
movq -0x258(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x258(%rbp,%rax), %rdi
callq 0x20d0
movb %al, -0x291(%rbp)
jmp 0x2669
movb -0x291(%rbp), %al
testb $0x1, %al
jne 0x2675
jmp 0x26df
movq 0x994c(%rip), %rdi      # 0xbfc8
leaq 0x599f(%rip), %rsi      # 0x8022
callq 0x2180
movq %rax, -0x2a0(%rbp)
jmp 0x2691
movq -0x2a0(%rbp), %rdi
movq 0x9919(%rip), %rsi      # 0xbfb8
callq 0x21b0
jmp 0x26a6
movq $0x0, -0x8(%rbp)
movl $0x1, -0x25c(%rbp)
jmp 0x27bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x27ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x27de
leaq -0x280(%rbp), %rdi
callq 0x2230
leaq -0x258(%rbp), %rdi
leaq -0x280(%rbp), %rsi
callq 0x2200
movq %rax, -0x2a8(%rbp)
jmp 0x2707
movq -0x2a8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x21f0
movb %al, -0x2a9(%rbp)
jmp 0x2725
movb -0x2a9(%rbp), %al
testb $0x1, %al
jne 0x2731
jmp 0x275f
movq -0x20(%rbp), %rdi
leaq -0x280(%rbp), %rsi
callq 0x3220
jmp 0x2743
jmp 0x26eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x280(%rbp), %rdi
callq 0x2120
jmp 0x27de
leaq -0x258(%rbp), %rdi
callq 0x2070
jmp 0x276d
movq 0x9854(%rip), %rdi      # 0xbfc8
leaq 0x58d8(%rip), %rsi      # 0x8053
callq 0x2180
movq %rax, -0x2b8(%rbp)
jmp 0x2789
movq -0x2b8(%rbp), %rdi
movq 0x9821(%rip), %rsi      # 0xbfb8
callq 0x21b0
jmp 0x279e
movq $0x0, -0x8(%rbp)
movl $0x1, -0x25c(%rbp)
leaq -0x280(%rbp), %rdi
callq 0x2120
leaq -0x258(%rbp), %rdi
callq 0x2080
leaq -0x40(%rbp), %rdi
callq 0x2120
movq -0x8(%rbp), %rax
addq $0x2c0, %rsp            # imm = 0x2C0
popq %rbp
retq
leaq -0x258(%rbp), %rdi
callq 0x2080
leaq -0x40(%rbp), %rdi
callq 0x2120
movq -0x48(%rbp), %rdi
callq 0x2300
nopl (%rax)
// File: LandonSwartz[P]TheGreatEncryptor/main.cpp
// Function: newFile(void*)
void *newFile(void *arg)
{
	ofstream file;
	struct ft* fi = (struct ft*)arg;

	file.open("NewFile.txt");
	ostream_iterator<string> output_iterator(file, "\n");
	copy(fi->fileVector.begin(), fi->fileVector.end(), output_iterator);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x8(%rbp)
leaq -0x208(%rbp), %rdi
movq %rdi, -0x268(%rbp)
callq 0x22c0
movq -0x268(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x210(%rbp)
leaq 0x5827(%rip), %rsi      # 0x8062
movl $0x10, %edx
callq 0x2040
jmp 0x2847
leaq 0x5820(%rip), %rdx      # 0x806e
leaq -0x230(%rbp), %rdi
leaq -0x208(%rbp), %rsi
callq 0x3290
jmp 0x2863
movq -0x210(%rbp), %rdi
callq 0x3340
movq %rax, -0x238(%rbp)
movq -0x210(%rbp), %rdi
callq 0x3370
movq %rax, -0x240(%rbp)
leaq -0x250(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x33a0
jmp 0x289e
movq -0x238(%rbp), %rsi
movq -0x240(%rbp), %rdx
leaq -0x260(%rbp), %rdi
leaq -0x250(%rbp), %rcx
callq 0x32c0
jmp 0x28c1
leaq -0x208(%rbp), %rdi
callq 0x2250
xorl %eax, %eax
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x2250
movq -0x218(%rbp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
// File: LandonSwartz[P]TheGreatEncryptor/main.cpp
// Function: printMenu()
void printMenu()
{
	cout<<"----------MENU----------"<<endl;
	cout<<"1. Choose file to hash and/or encrypt"<<endl;
	cout<<"2. Encrypt File"<<endl;
	cout<<"3. Decrypt file"<<endl;
	cout<<"4. Exit program"<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x96ad(%rip), %rdi      # 0xbfc8
leaq 0x574e(%rip), %rsi      # 0x8070
callq 0x2180
movq %rax, %rdi
movq 0x9687(%rip), %rsi      # 0xbfb8
callq 0x21b0
movq 0x968b(%rip), %rdi      # 0xbfc8
leaq 0x5745(%rip), %rsi      # 0x8089
callq 0x2180
movq %rax, %rdi
movq 0x9665(%rip), %rsi      # 0xbfb8
callq 0x21b0
movq 0x9669(%rip), %rdi      # 0xbfc8
leaq 0x5749(%rip), %rsi      # 0x80af
callq 0x2180
movq %rax, %rdi
movq 0x9643(%rip), %rsi      # 0xbfb8
callq 0x21b0
movq 0x9647(%rip), %rdi      # 0xbfc8
leaq 0x5737(%rip), %rsi      # 0x80bf
callq 0x2180
movq %rax, %rdi
movq 0x9621(%rip), %rsi      # 0xbfb8
callq 0x21b0
movq 0x9625(%rip), %rdi      # 0xbfc8
leaq 0x5725(%rip), %rsi      # 0x80cf
callq 0x2180
movq %rax, %rdi
movq 0x95ff(%rip), %rsi      # 0xbfb8
callq 0x21b0
popq %rbp
retq
// File: LandonSwartz[P]TheGreatEncryptor/./EncryptionClass.cpp
// Function: encryption_base::get_encrypted_data[abi:cxx11]()
vector<string>* get_encrypted_data() {
        if (data_state == 1)
            return this->data;
        else if (data_state == 2) {
            this->encrypt_data();
            return this->data;
        } else if (data_state == 0) {
            return nullptr;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x1, (%rax)
jne 0x37b7
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x37f0
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x37d7
movq -0x18(%rbp), %rdi
callq 0x3a80
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x37f0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x37ea
movq $0x0, -0x8(%rbp)
jmp 0x37f0
jmp 0x37ec
jmp 0x37ee
ud2
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: LandonSwartz[P]TheGreatEncryptor/./EncryptionClass.cpp
// Function: encryption_base::get_decrypted_data[abi:cxx11]()
vector<string>* get_decrypted_data() {
        if (data_state == 2)
            return this->data;
        else if (data_state == 1) {
            this->decrypt_data();
            return this->data;
        } else if (data_state == 0) {
            return nullptr;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x2, (%rax)
jne 0x3847
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3880
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x3867
movq -0x18(%rbp), %rdi
callq 0x56e0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3880
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x387a
movq $0x0, -0x8(%rbp)
jmp 0x3880
jmp 0x387c
jmp 0x387e
ud2
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: LandonSwartz[P]TheGreatEncryptor/./EncryptionClass.cpp
// Function: encryption_base::decryption_algorithm(void*)
static void * decryption_algorithm(void * params_void) {
        // Encryption algorithm, basic code necessary for other implementations of this function
        algorithm_parameters * params = static_cast<algorithm_parameters *>(params_void);

        // Calculate the cipher offset.
        int cipher_offset = params->hash_key % 255;

        // Traverse through each string this thread is responsible for.
        for (int i = params->start_index; i <= params->end_index; i++) {
            // The syntax below explained:
                // params is a reference to a struct
                // use -> notation because params is a reference to retrieve data member of struct
                // data member of struct is reference to a vector object of strings, so dereference it
                // use [] notation to access index of given string from dereferenced vector object
                // after the string is indexed, get its address so the string can be modified
            string * current_string = &((*(params->data))[i]);
            // At this point, we have a reference to the string that should be encrypted.
            for (int c = 0; c < current_string->length(); c++) {
                // Iterate through every character in the string, apply the cipher.
                int current_char = ((int)((*current_string)[c]));
                current_char -= cipher_offset;
                if (current_char < 0)
                    current_char += 255;
                (*current_string)[c] = (char)current_char;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl $0xff, %ecx
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jg 0x5cba
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x18(%rbp), %rsi
callq 0x4dc0
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2260
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x5caa
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x2340
movsbl (%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x14(%rbp), %ecx
movl -0x28(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jge 0x5c87
movl -0x28(%rbp), %eax
addl $0xff, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movb %al, -0x31(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x2340
movb -0x31(%rbp), %cl
movb %cl, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5c3b
jmp 0x5cac
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5c10
ud2
nopl (%rax)
// File: wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: AtomicAction::Execute(Agent&) const
bool AtomicAction::Execute(Agent &agent) const {
  if (mSucceed || !mSucceed) { //先不管succeed为false的情况
    switch (mType) {
    case CT_Turn:
      return agent.Turn(mTurnAngle);
    case CT_Dash:
      return agent.Dash(mDashPower, mDashDir);
    case CT_Kick:
      return agent.Kick(mKickVel.Mod(), mKickVel.Dir());
    default:
      return true;
    }
  } else
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, (%rax)
jne 0xbf1a
movq -0x20(%rbp), %rax
testb $0x1, (%rax)
jne 0xbfbb
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x1, %eax
je 0xbf3f
jmp 0xbf2b
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0xbf58
jmp 0xbf35
movl -0x24(%rbp), %eax
subl $0x6, %eax
je 0xbf76
jmp 0xbfb5
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movsd 0x18(%rax), %xmm0
callq 0x10430
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xbfbf
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movsd 0x20(%rax), %xmm0
movsd 0x28(%rax), %xmm1
callq 0x10460
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xbfbf
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x8, %rdi
callq 0x104e0
movq -0x20(%rbp), %rdi
movsd %xmm0, -0x30(%rbp)
addq $0x8, %rdi
callq 0x10520
movq -0x38(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
callq 0x104a0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xbfbf
movb $0x1, -0x1(%rbp)
jmp 0xbfbf
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)