LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Mirrvin[P]DragonsResurrectingInc/./specialists/HeadSpecialist.cpp
// Function: HeadSpecialist::handle(packet_t)
bool handle(packet_t packet) {    
        bool success = true;
        switch(packet.status.MPI_TAG){
            case AVENGERS_ASSEMBLE:
                success = this->handleAvengersAssemble(packet); break;
            case NEED_BODY_POSITIVE:
                success = this->handleNeedBodyPositive(packet); break;
            case NEED_BODY_NEGATIVE:
                success = this->handleNeedBodyNegative(packet); break;
            case AVENGERS_ASSEMBLED:
                success = this->handleAvengersAssembled(packet); break;
            case RESURRECTION_FINISHED:
                success = this->handleResurrectionFinished(packet); break;
            case END:
                success = this->handleEnd(packet); break;
            default: 
                printf("%u: No handler for tag %d in HeadSpecialist\n", Monitor::getLamport(), packet.status.MPI_TAG); break;
        }
        return success;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movl 0x24(%rbp), %r14d
leal -0x68(%r14), %ecx
cmpl $0x9, %ecx
ja 0x2ad5
leaq 0x10(%rbp), %rax
leaq 0x4587(%rip), %rdx      # 0x7004
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
cmpl $0x0, 0x18(%rbx)
jne 0x2b62
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6032
movq 0x20(%r14), %rax
movq %rax, 0x20(%rsp)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
movl $0x66, %edx
movl $0x2, %ecx
callq 0x623a
jmp 0x2b62
cmpl $0x65, %r14d
je 0x2b37
cmpl $0x77, %r14d
jne 0x2afe
movb $0x0, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
movl 0x8(%rbx), %ecx
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
movl $0x68, %edx
jmp 0x2b5d
callq 0x5b08
leaq 0x46c5(%rip), %rdi      # 0x71cf
movl %eax, %esi
movl %r14d, %edx
xorl %eax, %eax
callq 0x2030
jmp 0x2b62
movl 0x10(%rax), %eax
movl %eax, 0x1c(%rbx)
jmp 0x2b62
movl 0x10(%rax), %ecx
cmpb $0x0, 0x10(%rbx)
je 0x2b4a
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
movl $0x6c, %edx
jmp 0x2b5d
movq %rbx, %rdi
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x6334
movl %ecx, 0x18(%rbx)
movb $0x1, 0x10(%rbx)
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
movl $0x6b, %edx
callq 0x5fa0
movb $0x1, %al
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Mirrvin[P]DragonsResurrectingInc/./specialists/BodySpecialist.cpp
// Function: BodySpecialist::handleNeedBody(packet_t)
bool handleNeedBody(packet_t packet) {    
        if(this->headRank == 0) {
            if(!handlingNeedBody) {
                this->handlingNeedBody = true;
                this->bodyList.clear();
                this->headList.clear();
                packet_t packet = this->createSelfPacket();
                packet_t sentPacket = this->broadcastMessage(packet, NEED_BODY_ACK, BODY);
                this->bodyList.push_back(sentPacket);
                this->sendMessage(FINISH_NEED_BODY, this->rank);
            }
            this->headList.push_back(packet);
        }
        return true;
    }

// Assembly:
cmpl $0x0, 0x18(%rdi)
jne 0x2f87
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x24(%rdi)
jne 0x2f45
movb $0x1, 0x24(%rbx)
movq 0x40(%rbx), %rax
cmpq %rax, 0x48(%rbx)
je 0x2eab
movq %rax, 0x48(%rbx)
movq 0x28(%rbx), %rax
cmpq %rax, 0x30(%rbx)
je 0x2eb9
movq %rax, 0x30(%rbx)
leaq -0x88(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6032
movq 0x20(%r14), %rax
movq %rax, 0x20(%rsp)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
movl $0x69, %edx
movl $0x2, %ecx
callq 0x623a
movq 0x48(%rbx), %rsi
cmpq 0x50(%rbx), %rsi
je 0x2f24
movq -0x18(%rbp), %rax
movq %rax, 0x20(%rsi)
movups -0x38(%rbp), %xmm0
movups -0x28(%rbp), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x28, 0x48(%rbx)
jmp 0x2f31
leaq 0x40(%rbx), %rdi
leaq -0x38(%rbp), %rdx
callq 0x390c
movl 0x8(%rbx), %ecx
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
movl $0x6a, %edx
callq 0x5fa0
leaq 0x10(%rbp), %rdx
movq 0x30(%rbx), %rsi
cmpq 0x38(%rbx), %rsi
je 0x2f70
movq 0x20(%rdx), %rax
movq %rax, 0x20(%rsi)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x28, 0x30(%rbx)
jmp 0x2f7c
addq $0x28, %rbx
movq %rbx, %rdi
callq 0x390c
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/Mirrvin[P]DragonsResurrectingInc/./specialists/BodySpecialist.cpp
// Function: BodySpecialist::handleNeedTailPositive(packet_t)
bool handleNeedTailPositive(packet_t packet) {
        if(this->tailRank == 0) {           
            this->tailRank = packet.status.MPI_SOURCE;
            this->inTeam = true;
            this->sendMessage(NEED_TAIL_POSITIVE, packet.status.MPI_SOURCE);
        } else {
            this->sendMessage(NEED_TAIL_NEGATIVE, packet.status.MPI_SOURCE);
        }
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, %rsi
cmpl $0x0, 0x1c(%rdi)
movl 0x20(%rbp), %ecx
je 0x381d
leaq -0x28(%rbp), %rdi
movl $0x70, %edx
jmp 0x382d
movl %ecx, 0x1c(%rsi)
movb $0x1, 0x10(%rsi)
leaq -0x28(%rbp), %rdi
movl $0x6f, %edx
callq 0x5fa0
movb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Mirrvin[P]DragonsResurrectingInc/./specialists/BodySpecialist.cpp
// Function: BodySpecialist::handleDoPaperwork(packet_t)
bool handleDoPaperwork(packet_t packet) {
        this->needDeskReplyCounter = 1/3*(this->size+1)-1;
        packet = this->broadcastMessage(NEED_DESK_REQUEST, BODY); // mowi innym BODY, zeby go dodali do kolejki
        deskPriority.push_back(packet); // dodaje siebie
        this->gettingDesk = true;
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rbp), %r14
movl $0xffffffff, 0x20(%rdi) # imm = 0xFFFFFFFF
movq %r14, %rdi
movq %rbx, %rsi
movl $0x78, %edx
movl $0x2, %ecx
callq 0x61ca
movq 0x60(%rbx), %rsi
cmpq 0x68(%rbx), %rsi
je 0x38f5
movq 0x20(%r14), %rax
movq %rax, 0x20(%rsi)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x28, 0x60(%rbx)
jmp 0x3901
leaq 0x58(%rbx), %rdi
movq %r14, %rdx
callq 0x390c
movb $0x1, 0x25(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Mirrvin[P]DragonsResurrectingInc/./specialists/TailSpecialist.cpp
// Function: TailSpecialist::handleNeedTail(packet_t)
bool handleNeedTail(packet_t packet) {
        if(!this->inTeam) {
            if(!handlingNeedTail) {
                this->handlingNeedTail = true;
                this->tailList.clear();
                this->bodyList.clear();
                packet_t packet = this->createSelfPacket();
                packet_t sentPacket = this->broadcastMessage(packet, NEED_TAIL_ACK, TAIL);
                this->tailList.push_back(sentPacket);
                this->sendMessage(FINISH_NEED_TAIL, this->rank);
            }
            this->bodyList.push_back(packet);
        }
        return true;
    }

// Assembly:
cmpb $0x0, 0x10(%rdi)
jne 0x48eb
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x28(%rdi)
jne 0x48a9
movb $0x1, 0x28(%rbx)
movq 0x30(%rbx), %rax
cmpq %rax, 0x38(%rbx)
je 0x480f
movq %rax, 0x38(%rbx)
movq 0x48(%rbx), %rax
cmpq %rax, 0x50(%rbx)
je 0x481d
movq %rax, 0x50(%rbx)
leaq -0x88(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6032
movq 0x20(%r14), %rax
movq %rax, 0x20(%rsp)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
movl $0x6d, %edx
movl $0x3, %ecx
callq 0x623a
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x4888
movq -0x18(%rbp), %rax
movq %rax, 0x20(%rsi)
movups -0x38(%rbp), %xmm0
movups -0x28(%rbp), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x28, 0x38(%rbx)
jmp 0x4895
leaq 0x30(%rbx), %rdi
leaq -0x38(%rbp), %rdx
callq 0x390c
movl 0x8(%rbx), %ecx
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
movl $0x6e, %edx
callq 0x5fa0
leaq 0x10(%rbp), %rdx
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x48d4
movq 0x20(%rdx), %rax
movq %rax, 0x20(%rsi)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x28, 0x50(%rbx)
jmp 0x48e0
addq $0x48, %rbx
movq %rbx, %rdi
callq 0x390c
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/Mirrvin[P]DragonsResurrectingInc/./specialists/TailSpecialist.cpp
// Function: TailSpecialist::handleAvengersAssembled(packet_t)
bool handleAvengersAssembled(packet_t packet) {
        printf("%u: --- Team assembled. Squad members: head %d, body %d, tail %d ---\n",Monitor::getLamport(),this->headRank, this->bodyRank, this->rank);
        this->gettingResurrectionOrder = true;
        this->orderPriorityReplyCounter = (this->size)/3 - 1;
        if(this->orderPriorityReplyCounter > 0) {
            packet_t packet = this->broadcastMessage(REQUEST_ORDER_PRIORITY, TAIL);
            this->orderPriority.push_back(packet);
        } else {
            this->sendMessage(REPLY_ORDER_PRIORITY, this->rank);
        }
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x5b08
movl 0x8(%rbx), %r8d
movl 0x18(%rbx), %edx
movl 0x1c(%rbx), %ecx
leaq 0x2157(%rip), %rdi      # 0x729b
movl %eax, %esi
xorl %eax, %eax
callq 0x2030
movb $0x1, 0x29(%rbx)
movslq 0xc(%rbx), %rax
imulq $0x55555556, %rax, %rcx # imm = 0x55555556
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
addl %edx, %ecx
decl %ecx
movl %ecx, 0x20(%rbx)
cmpq $0x6, %rax
jl 0x51b2
leaq -0x30(%rbp), %rdi
movq %rbx, %rsi
movl $0x72, %edx
movl $0x3, %ecx
callq 0x61ca
movq 0x68(%rbx), %rsi
cmpq 0x70(%rbx), %rsi
je 0x51c8
movq -0x10(%rbp), %rax
movq %rax, 0x20(%rsi)
movups -0x30(%rbp), %xmm0
movups -0x20(%rbp), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x28, 0x68(%rbx)
jmp 0x51d8
movl 0x8(%rbx), %ecx
leaq -0x30(%rbp), %rdi
movq %rbx, %rsi
movl $0x73, %edx
callq 0x5fa0
jmp 0x51d8
addq $0x60, %rbx
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x390c
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rbp), %rdx
movl 0x24(%rdi), %eax
testl %eax, %eax
jle 0x5264
decl %eax
movl %eax, 0x24(%rbx)
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rdi
movq %rdi, %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %r8 # imm = 0xCCCCCCCCCCCCCCCD
imulq %r8, %rcx
xorl %r9d, %r9d
movl 0x10(%rdx), %edx
cmpq %rax, %rdi
setne %sil
movl %esi, %r10d
je 0x52bf
cmpl %edx, 0x10(%rax)
je 0x52bf
movl $0x1, %r11d
movl %r11d, %r9d
movl %r11d, %r11d
cmpq %r11, %rcx
seta %r10b
jbe 0x52bf
leaq (%r11,%r11,4), %r14
leal 0x1(%r9), %r11d
cmpl %edx, 0x10(%rax,%r14,8)
jne 0x52a1
testb %r10b, %r10b
cmovel %ecx, %r9d
movq 0x50(%rbx), %r10
subq 0x48(%rbx), %r10
sarq $0x3, %r10
imulq %r8, %r10
cmpq %r9, %r10
jbe 0x5337
xorl %r8d, %r8d
cmpq %rax, %rdi
je 0x530a
cmpl %edx, 0x10(%rax)
je 0x530a
movl $0x1, %edi
movl %edi, %r8d
movl %edi, %edi
cmpq %rdi, %rcx
seta %sil
jbe 0x530a
leaq (%rdi,%rdi,4), %r9
leal 0x1(%r8), %edi
cmpl %edx, 0x10(%rax,%r9,8)
jne 0x52ed
testb %sil, %sil
cmovel %ecx, %r8d
leaq (%r8,%r8,4), %rcx
leaq (%rax,%rcx,8), %rsi
addq $0x28, %rsi
movq 0x68(%rbx), %rdx
cmpq %rdx, %rsi
je 0x5332
leaq (%rax,%rcx,8), %rdi
subq %rsi, %rdx
callq 0x21b0
addq $-0x28, 0x68(%rbx)
cmpb $0x1, 0x29(%rbx)
jne 0x534b
cmpl $0x0, 0x24(%rbx)
jle 0x534b
movq %rbx, %rdi
callq 0x54dc
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0x5b08
movl 0x8(%rbx), %r8d
movl 0x18(%rbx), %edx
movl 0x1c(%rbx), %ecx
leaq 0x1f89(%rip), %rdi      # 0x72ff
xorl %r14d, %r14d
movl %eax, %esi
xorl %eax, %eax
callq 0x2030
movl 0x18(%rbx), %ecx
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
movl $0x77, %edx
callq 0x5fa0
movl 0x1c(%rbx), %ecx
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
movl $0x77, %edx
callq 0x5fa0
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
movl $0x77, %edx
xorl %ecx, %ecx
callq 0x5fa0
movb %r14b, 0x2a(%rbx)
movb %r14b, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x30(%rdi), %rcx
movq 0x38(%rdi), %r9
subq %rcx, %r9
setne %sil
je 0x5426
movl 0x8(%rdi), %edx
xorl %eax, %eax
cmpl 0x10(%rcx), %edx
je 0x5421
sarq $0x3, %r9
movabsq $-0x3333333333333333, %r8 # imm = 0xCCCCCCCCCCCCCCCD
imulq %r9, %r8
xorl %eax, %eax
incl %eax
cmpq %rax, %r8
seta %sil
jbe 0x5426
leaq (%rax,%rax,4), %r9
cmpl 0x10(%rcx,%r9,8), %edx
jne 0x540b
testb %sil, %sil
jne 0x5438
movq 0x50(%rdi), %rax
subq 0x48(%rdi), %rax
shrq $0x3, %rax
imull $0xcccccccd, %eax, %eax # imm = 0xCCCCCCCD
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %r14
movq %r14, (%rsp)
movq 0x4643(%rip), %rdx      # 0x9fc0
movq 0x464c(%rip), %r9       # 0x9fd0
movl $0x28, %esi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x20f0
movups (%r14), %xmm0
movups %xmm0, 0x10(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x20(%rbx)
movl 0x8(%rbx), %r15d
leaq 0x478c(%rip), %r14      # 0xa140
movq %r14, %rdi
callq 0x2180
movl 0x4776(%rip), %eax      # 0xa138
cmpl %eax, %r15d
cmoval %r15d, %eax
incl %eax
movl %eax, 0x4767(%rip)      # 0xa138
movq %r14, %rdi
callq 0x20c0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movb $0x1, 0x4734(%rip)      # 0xa134
leaq -0x78(%rbp), %rbx
leaq 0x4785(%rip), %r14      # 0xa190
leaq 0x47f6(%rip), %r15      # 0xa208
leaq -0x50(%rbp), %r12
leaq 0x474b(%rip), %r13      # 0xa168
movq %rbx, %rdi
callq 0x595e
movq -0x58(%rbp), %rax
movq %rax, -0x30(%rbp)
movups -0x78(%rbp), %xmm0
movups -0x68(%rbp), %xmm1
movaps %xmm1, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movq %r14, %rdi
callq 0x2180
movq 0x47ec(%rip), %rax      # 0xa238
movq 0x47f5(%rip), %rcx      # 0xa248
addq $-0x28, %rcx
cmpq %rcx, %rax
je 0x5a7d
movq -0x30(%rbp), %rcx
movq %rcx, 0x20(%rax)
movaps -0x50(%rbp), %xmm0
movaps -0x40(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
addq $0x28, 0x47bd(%rip)     # 0xa238
jmp 0x5a88
movq %r15, %rdi
movq %r12, %rsi
callq 0x5d30
movq %r14, %rdi
callq 0x20c0
movq %r13, %rdi
callq 0x20c0
cmpl $0x65, -0x3c(%rbp)
jne 0x5aa5
movb $0x0, 0x468f(%rip)      # 0xa134
cmpb $0x0, 0x4688(%rip)      # 0xa134
jne 0x5a1d
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
leaq 0x4662(%rip), %rbx      # 0xa140
movq %rbx, %rdi
callq 0x2180
movl 0x464b(%rip), %r14d     # 0xa138
incl %r14d
movl %r14d, 0x4641(%rip)     # 0xa138
movq %rbx, %rdi
callq 0x20c0
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq 0x3df5(%rip), %rax      # 0x9d68
movq %rax, (%rdi)
movl %esi, 0x8(%rdi)
movl %edx, 0xc(%rdi)
movl $0x0, 0x14(%rdi)
movb $0x0, 0x10(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x14(%rsi), %eax
movl %eax, 0x4(%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0x10(%rdi)
callq 0x5b08
movl %eax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rbp), %r14
callq 0x5ad0
movl %eax, 0x8(%r14)
cmpl $0x2, 0xc(%r12)
jl 0x6192
movl $0x1, %r13d
cmpl 0x8(%r12), %r13d
je 0x6188
movq %r14, %rdi
movl $0x28, %esi
movq 0x3e4a(%rip), %rdx      # 0x9fc0
movl %r13d, %ecx
movl %r15d, %r8d
movq 0x3e4d(%rip), %r9       # 0x9fd0
callq 0x2070
incl %r13d
cmpl 0xc(%r12), %r13d
jl 0x6160
movq 0x20(%r14), %rax
movq %rax, 0x20(%rbx)
movq (%r14), %rax
movl 0x8(%r14), %ecx
movl 0xc(%r14), %edx
movups 0x10(%r14), %xmm0
movups %xmm0, 0x10(%rbx)
movq %rax, (%rbx)
movl %ecx, 0x8(%rbx)
movl %edx, 0xc(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r13d
movl %edx, -0x2c(%rbp)
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rbp), %r14
callq 0x5ad0
movl %eax, 0x8(%r14)
cmpl $0x2, 0xc(%r12)
jl 0x62d0
movl $0x2, %r15d
subl %r13d, %r15d
movl $0x1, %r13d
movl $0xaaaaaaab, %edx       # imm = 0xAAAAAAAB
cmpl 0x8(%r12), %r13d
je 0x62c6
movl %r13d, %eax
imulq %rdx, %rax
shrq $0x21, %rax
leal (%rax,%rax,2), %eax
movl %r15d, %ecx
subl %eax, %ecx
addl %r13d, %ecx
cmpl $0x1, %ecx
jne 0x62c6
movq %r14, %rdi
movl $0x28, %esi
movq 0x3d12(%rip), %rdx      # 0x9fc0
movl %r13d, %ecx
movl -0x2c(%rbp), %r8d
movq 0x3d14(%rip), %r9       # 0x9fd0
callq 0x2070
movl $0xaaaaaaab, %edx       # imm = 0xAAAAAAAB
incl %r13d
cmpl 0xc(%r12), %r13d
jl 0x627d
movq 0x20(%r14), %rax
movq %rax, 0x20(%rbx)
movq (%r14), %rax
movl 0x8(%r14), %ecx
movl 0xc(%r14), %edx
movups 0x10(%r14), %xmm0
movups %xmm0, 0x10(%rbx)
movq %rax, (%rbx)
movl %ecx, 0x8(%rbx)
movl %edx, 0xc(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0xa, %esi
callq 0x44c0
movq -0x30(%rbp), %r15
subq -0x40(%rbp), %r15
xorl %r14d, %r14d
cmpq $0x25, %r15
setae %r14b
callq 0x2da6
movq %rax, %rbx
leaq 0x2829(%rip), %rdx      # 0x50fe
leaq 0x2929(%rip), %r8       # 0x5205
leaq -0x198(%rbp), %rdi
movl %r14d, %esi
movl $0x1b, %ecx
xorl %r9d, %r9d
callq 0x3e44
leaq -0x198(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3d0a
leaq -0x198(%rbp), %rdi
callq 0x3abe
cmpq $0x24, %r15
jbe 0x2a1b
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %r12
xorl %r14d, %r14d
cmpq %r15, %r12
sete %r14b
callq 0x2da6
movq %rax, %rbx
leaq 0x27c3(%rip), %rdx      # 0x50fe
leaq 0x28d8(%rip), %r8       # 0x521a
leaq -0x128(%rbp), %rdi
movl %r14d, %esi
movl $0x1c, %ecx
xorl %r9d, %r9d
callq 0x3e44
leaq -0x128(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3d0a
leaq -0x128(%rbp), %rdi
callq 0x3abe
cmpq %r15, %r12
jne 0x2a1b
movl $0xb, %r15d
leaq -0x40(%rbp), %rbx
leaq -0x44(%rbp), %r14
movl $0x3, -0x44(%rbp)
movq -0x38(%rbp), %rsi
cmpq -0x30(%rbp), %rsi
je 0x29ae
movl $0x3, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x38(%rbp)
jmp 0x29b9
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3f0c
decl %r15d
jne 0x298d
movq -0x30(%rbp), %rax
subq -0x40(%rbp), %rax
xorl %r14d, %r14d
cmpq $0x29, %rax
setae %r14b
callq 0x2da6
movq %rax, %rbx
leaq 0x271e(%rip), %rdx      # 0x50fe
leaq 0x2843(%rip), %r8       # 0x522a
leaq -0xb8(%rbp), %rdi
movl %r14d, %esi
movl $0x22, %ecx
xorl %r9d, %r9d
callq 0x3e44
leaq -0xb8(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3d0a
leaq -0xb8(%rbp), %rdi
callq 0x3abe
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x2a29
callq 0x2140
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
jmp 0x2a5f
jmp 0x2a6a
movq %rax, %rbx
leaq -0x128(%rbp), %rdi
jmp 0x2a5f
jmp 0x2a6a
movq %rax, %rbx
leaq -0x198(%rbp), %rdi
callq 0x3abe
jmp 0x2a6d
jmp 0x2a6a
jmp 0x2a6a
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x2a7b
callq 0x2140
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x2c(%rbp), %r14
movl $0x0, (%r14)
xorl %eax, %eax
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x2acc
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x2ad7
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4558
movl -0x2c(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x9, %ecx
jl 0x2ab6
xorl %ebx, %ebx
leaq -0xc0(%rbp), %r15
movq -0x50(%rbp), %rax
movl (%rax,%rbx,4), %r14d
xorl %r13d, %r13d
cmpq %r14, %rbx
sete %r13b
callq 0x2da6
movq %rax, %r12
movq %r15, %rdi
movl %r13d, %esi
leaq 0x25e9(%rip), %rdx      # 0x50fe
movl $0x2d, %ecx
leaq 0x272d(%rip), %r8       # 0x524e
xorl %r9d, %r9d
callq 0x3e44
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3d0a
movq %r15, %rdi
callq 0x3abe
cmpq %r14, %rbx
jne 0x2b50
leaq 0x1(%rbx), %rax
cmpq $0x9, %rbx
movq %rax, %rbx
jne 0x2aee
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x2b5e
callq 0x2140
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b72
movq %rax, %rbx
jmp 0x2b86
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
callq 0x3abe
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x2b94
callq 0x2140
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movl $0x3, %r13d
leaq 0x2541(%rip), %r14      # 0x50fe
leaq 0x2696(%rip), %r15      # 0x525a
leaq -0x178(%rbp), %rbx
callq 0x2da6
movq %rax, %r12
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
movl $0x36, %ecx
movq %r15, %r8
xorl %r9d, %r9d
callq 0x3e44
movq %r12, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x3d0a
movq %rbx, %rdi
callq 0x3abe
decl %r13d
jne 0x2bcb
callq 0x2da6
movq %rax, %r14
leaq 0x24e7(%rip), %rdx      # 0x50fe
leaq 0x2647(%rip), %r8       # 0x5265
leaq -0x108(%rbp), %rbx
movq %rbx, %rdi
movl $0x1, %esi
movl $0x39, %ecx
xorl %r9d, %r9d
callq 0x3e44
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3d0a
leaq -0x108(%rbp), %rdi
callq 0x3abe
callq 0x2da6
movq %rax, %r14
leaq 0x249c(%rip), %rdx      # 0x50fe
leaq 0x2603(%rip), %r8       # 0x526c
leaq -0x98(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
movl $0x3b, %ecx
xorl %r9d, %r9d
callq 0x3e44
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3d0a
leaq -0x98(%rbp), %rdi
callq 0x3abe
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2cb1
jmp 0x2cb1
movq %rax, %r14
movq %rbx, %rdi
callq 0x3abe
movq %r14, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x233c(%rip), %rdi      # 0x5033
xorl %r13d, %r13d
xorl %eax, %eax
callq 0x2030
leaq 0x2371(%rip), %rdi      # 0x5079
movq %r14, %rsi
xorl %eax, %eax
callq 0x2030
leaq 0x2320(%rip), %rdi      # 0x5039
xorl %eax, %eax
callq 0x2030
callq 0x2da6
movq %rax, %r15
leaq -0xa8(%rbp), %r12
leaq -0x29(%rbp), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x2090
leaq -0x78(%rbp), %rax
movq %rax, -0x10(%rax)
movq %r13, -0x8(%rax)
movb $0x0, (%rax)
movq %rbx, 0x10(%rax)
movq %r13, 0x18(%rax)
movw $0x0, 0x20(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x2f9c
leaq -0xa8(%rbp), %rdi
callq 0x31b4
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x31b4
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
cmpq $0x0, 0x48(%rsi)
je 0x303d
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x331a
leaq 0x22e6(%rip), %rsi      # 0x52dc
leaq -0x48(%rbp), %rdi
callq 0x2230
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq -0x48(%rbp), %rdi
callq 0x2070
leaq -0xf0(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x304b
movq %rdx, -0x100(%rbp)
movq (%rcx), %rdx
movq %rdx, -0xf0(%rbp)
jmp 0x3053
leaq -0x68(%rbp), %rdi
movq %r14, %rsi
callq 0x20d0
jmp 0x309c
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq -0x100(%rbp), %r15
movq %rdx, 0x8(%r15)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0x2170
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x308a
callq 0x2140
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x309c
callq 0x2140
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
callq 0x33b4
testq %rax, %rax
je 0x30dd
leaq 0x1f73(%rip), %rdi      # 0x5027
xorl %eax, %eax
callq 0x2030
movq -0x68(%rbp), %rsi
leaq 0x1fc5(%rip), %rdi      # 0x508b
xorl %eax, %eax
callq 0x2030
leaq 0x1f65(%rip), %rdi      # 0x5039
xorl %eax, %eax
callq 0x2030
jmp 0x314f
leaq -0x100(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movq %r14, %rdx
callq 0x31f2
leaq -0x100(%rbp), %rsi
movq %rbx, %rdi
callq 0x3624
movq %rax, -0x48(%rbp)
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0x311b
movq -0x48(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x40(%rbx)
jmp 0x312b
addq $0x38, %rbx
leaq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0x34e8
leaq -0xe0(%rbp), %rbx
movq %rbx, %rdi
callq 0x31b4
movq -0x20(%rbx), %rdi
leaq -0xf0(%rbp), %rax
cmpq %rax, %rdi
je 0x314f
callq 0x2140
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x315d
callq 0x2140
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x319b
jmp 0x319b
movq %rax, %rbx
leaq -0x100(%rbp), %rdi
callq 0x32e0
jmp 0x319e
jmp 0x3186
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x319e
callq 0x2140
jmp 0x319e
jmp 0x319b
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x31ac
callq 0x2140
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r15
movq 0x50(%rdi), %r14
testq %r14, %r14
je 0x3dbf
movl %edx, %ebx
movb (%r15), %al
leaq -0x90(%rbp), %rdi
movb %al, -0x8(%rdi)
leaq -0x80(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
callq 0x331a
leaq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x28(%r15), %rsi
movq 0x30(%r15), %rdx
addq %rsi, %rdx
callq 0x331a
movl 0x48(%r15), %eax
leaq -0x48(%rbp), %rdi
movl %eax, -0x8(%rdi)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq 0x50(%r15), %rsi
movq 0x58(%r15), %rdx
addq %rsi, %rdx
callq 0x331a
movzbl %bl, %edx
leaq -0x98(%rbp), %rsi
movq %r14, %rdi
callq 0x4044
leaq -0x98(%rbp), %rdi
callq 0x3abe
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1261(%rip), %rdi      # 0x5027
xorl %eax, %eax
callq 0x2030
movl 0x48(%r15), %edx
movq 0x8(%r15), %rsi
movq 0x28(%r15), %rcx
leaq 0x137c(%rip), %rdi      # 0x515c
xorl %eax, %eax
callq 0x2030
leaq 0x124b(%rip), %rdi      # 0x5039
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2030
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x3abe
jmp 0x3e3b
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x3e2a
callq 0x2140
jmp 0x3e2a
movq %rax, %rbx
movq -0x90(%rbp), %rdi
cmpq %r12, %rdi
je 0x3e3b
callq 0x2140
movq %rbx, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rsi, %rbx
addq $0x58, %rdi
callq 0x40dc
cmpb $0x0, (%rbx)
je 0x4064
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xfbc(%rip), %rdi       # 0x5027
xorl %eax, %eax
callq 0x2030
movl $0xa, %edi
callq 0x2190
movl $0x2, %edi
callq 0x24bc
movq 0x28(%rbx), %rsi
movl 0x48(%rbx), %edx
leaq 0x1108(%rip), %rax      # 0x519c
leaq 0x1126(%rip), %rdi      # 0x51c1
testb %r14b, %r14b
cmovneq %rax, %rdi
xorl %eax, %eax
callq 0x2030
leaq 0x1134(%rip), %rdi      # 0x51e4
xorl %eax, %eax
callq 0x2030
leaq 0xf7b(%rip), %rdi       # 0x5039
xorl %eax, %eax
callq 0x2030
movq 0x8(%rbx), %rsi
leaq 0x112e(%rip), %rdi      # 0x51fe
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x2030
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %r14
movq 0x40(%rdi), %r15
cmpq %r15, %r14
je 0x465d
movq (%r14), %rax
movq 0x70(%rax), %rdi
testq %rdi, %rdi
je 0x4657
callq 0x2140
addq $0x8, %r14
jmp 0x4641
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x466b
callq 0x2140
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x467e
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x228(%rdi), %rsi
movq 0x230(%rdi), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x3d4a
movq 0x5a85(%rip), %rdi      # 0x7fd0
leaq 0x2ade(%rip), %rsi      # 0x5030
movl $0xd, %edx
callq 0x21e0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x5a63(%rip), %rdi      # 0x7fd0
callq 0x21e0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2130
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0x2250
movq 0x48(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x68(%rsp,%rax)
je 0x260b
movq 0x5a09(%rip), %rbx      # 0x7fd0
leaq 0x2a70(%rip), %rsi      # 0x503e
movl $0x30, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq 0x59d7(%rip), %rdi      # 0x7fd0
callq 0x2030
movq %rax, %rdi
callq 0x2130
jmp 0x26b8
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq 0x48(%rsp), %r14
leaq 0x28(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2200
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2651
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31fe
jmp 0x262b
leaq 0x48(%rsp), %rdi
callq 0x2070
movq 0x596e(%rip), %rbx      # 0x7fd0
leaq 0x2a06(%rip), %rsi      # 0x506f
movl $0xe, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq 0x593c(%rip), %rdi      # 0x7fd0
callq 0x2030
movq %rax, %rdi
callq 0x2130
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x26b8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21d0
leaq 0x48(%rsp), %rdi
callq 0x2090
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x26d9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
xorl %eax, %eax
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x26f5
jmp 0x26fa
movq %rax, %rbx
jmp 0x2714
movq %rax, %rbx
jmp 0x271e
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x2714
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21d0
leaq 0x48(%rsp), %rdi
callq 0x2090
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2735
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdi, %r14
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x2290
leaq 0x291c(%rip), %rsi      # 0x507e
movq %r15, %rdi
movl $0x10, %edx
callq 0x2040
movq (%r14), %rbx
movq 0x8(%r14), %r12
movq %r15, 0x8(%rsp)
leaq 0x2908(%rip), %rax      # 0x508a
movq %rax, 0x10(%rsp)
subq %rbx, %r12
sarq $0x5, %r12
testq %r12, %r12
jle 0x27b3
incq %r12
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x405c
addq $0x20, %rbx
decq %r12
cmpq $0x1, %r12
jg 0x279b
movq 0x5806(%rip), %rax      # 0x7fc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x20(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x18(%rsp,%rcx)
callq 0x2180
leaq 0x110(%rsp), %rdi
callq 0x20b0
xorl %eax, %eax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x27f8
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2230
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O1/LandonSwartz[P]TheGreatEncryptor/./EncryptionClass.cpp
// Function: encryption_base::encryption_algorithm(void*)
static void * encryption_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.
        //cout << "hash key is " << params->hash_key;
        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++) {
            //cout << "encrypting string" << endl;
            // 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
            //cout << "cipher_offset is " << cipher_offset << endl;
            string * current_string = &((*(params->data))[i]);
            //cout << "working on string " << *current_string << endl; 
            // 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.
                //cout << "applying cipher to character" << endl;
                int current_char = ((int)((*current_string)[c]));
                //cout << "character before cipher: " << current_char << endl;
                current_char += cipher_offset;
                //cout << "character after cipher: " << current_char << endl;
                if (current_char > 255)
                    current_char -= 255;
                //cout << "character after correction: " << current_char << endl;
                (*current_string)[c] = (char)current_char;
            }
        }
    }

// Assembly:
movslq 0x10(%rdi), %rcx
imulq $-0x7f7f7f7f, %rcx, %rax # imm = 0x80808081
shrq $0x20, %rax
addl %ecx, %eax
movl %eax, %edx
shrl $0x1f, %edx
sarl $0x7, %eax
addl %edx, %eax
movl %eax, %edx
shll $0x8, %edx
subl %edx, %eax
addl %ecx, %eax
movslq 0x8(%rdi), %rcx
movq (%rdi), %rdx
movq (%rdx), %rdx
movq %rcx, %rsi
shlq $0x5, %rsi
cmpq $0x0, 0x8(%rdx,%rsi)
je 0x375b
addq %rsi, %rdx
xorl %esi, %esi
movq (%rdx), %r8
movsbl (%r8,%rsi), %r9d
addl %eax, %r9d
xorl %r10d, %r10d
cmpl $0x100, %r9d            # imm = 0x100
setge %r10b
addl %r9d, %r10d
movb %r10b, (%r8,%rsi)
incq %rsi
cmpq %rsi, 0x8(%rdx)
ja 0x3732
incq %rcx
jmp 0x3718
// File: /workspace/github_cpp_makefile_star2_O1/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:
movslq 0x10(%rdi), %rcx
imulq $-0x7f7f7f7f, %rcx, %rax # imm = 0x80808081
shrq $0x20, %rax
addl %ecx, %eax
movl %eax, %edx
shrl $0x1f, %edx
sarl $0x7, %eax
addl %edx, %eax
movl %eax, %edx
shll $0x8, %edx
subl %edx, %eax
addl %ecx, %eax
movslq 0x8(%rdi), %rcx
movq (%rdi), %rdx
movq (%rdx), %rdx
movq %rcx, %rsi
shlq $0x5, %rsi
cmpq $0x0, 0x8(%rdx,%rsi)
je 0x3d2d
addq %rsi, %rdx
xorl %esi, %esi
movq (%rdx), %r8
movsbl (%r8,%rsi), %r9d
subl %eax, %r9d
leal -0x1(%r9), %r10d
testl %r9d, %r9d
movzbl %r10b, %r10d
cmovnsl %r9d, %r10d
movb %r10b, (%r8,%rsi)
incq %rsi
cmpq %rsi, 0x8(%rdx)
ja 0x3d06
incq %rcx
jmp 0x3cec
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl 0x4(%rdi), %eax
cmpl $0x6, %eax
je 0xb40d
cmpl $0x2, %eax
je 0xb3d7
cmpl $0x1, %eax
jne 0xb437
movsd 0x18(%rdi), %xmm0
movsd %xmm0, -0x18(%rbp)
movq %rbx, %rdi
callq 0xef28
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xbc38
movsd 0x20(%rdi), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x28(%rdi), %xmm0
movsd %xmm0, -0x20(%rbp)
movq %rbx, %rdi
callq 0xef28
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xbd54
leaq 0x8(%rdi), %r14
movsd 0x8(%rdi), %xmm0
movsd 0x10(%rdi), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xb442
sqrtsd %xmm0, %xmm0
jmp 0xb447
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x93c0
movsd %xmm0, -0x18(%rbp)
movq %r14, %rdi
callq 0xe804
movsd %xmm0, -0x20(%rbp)
movq %rbx, %rdi
callq 0xef28
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xc352
nop