LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2ac7
leaq 0x10(%rbp), %rax
leaq 0x4595(%rip), %rdx      # 0x7004
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
cmpl $0x0, 0x18(%rbx)
jne 0x2b54
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5df6
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 0x6002
jmp 0x2b54
cmpl $0x65, %r14d
je 0x2b29
cmpl $0x77, %r14d
jne 0x2af0
movb $0x0, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
movl 0x8(%rbx), %ecx
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
movl $0x68, %edx
jmp 0x2b4f
callq 0x58c2
leaq 0x46d3(%rip), %rdi      # 0x71cf
movl %eax, %esi
movl %r14d, %edx
xorl %eax, %eax
callq 0x2030
jmp 0x2b54
movl 0x10(%rax), %eax
movl %eax, 0x1c(%rbx)
jmp 0x2b54
movl 0x10(%rax), %ecx
cmpb $0x0, 0x10(%rbx)
je 0x2b3c
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
movl $0x6c, %edx
jmp 0x2b4f
movq %rbx, %rdi
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x6100
movl %ecx, 0x18(%rbx)
movb $0x1, 0x10(%rbx)
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
movl $0x6b, %edx
callq 0x5d68
movb $0x1, %al
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2f79
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x24(%rdi)
jne 0x2f37
movb $0x1, 0x24(%rbx)
movq 0x40(%rbx), %rax
cmpq %rax, 0x48(%rbx)
je 0x2e9d
movq %rax, 0x48(%rbx)
movq 0x28(%rbx), %rax
cmpq %rax, 0x30(%rbx)
je 0x2eab
movq %rax, 0x30(%rbx)
leaq -0x88(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5df6
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 0x6002
movq 0x48(%rbx), %rsi
cmpq 0x50(%rbx), %rsi
je 0x2f16
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 0x2f23
leaq 0x40(%rbx), %rdi
leaq -0x38(%rbp), %rdx
callq 0x3834
movl 0x8(%rbx), %ecx
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
movl $0x6a, %edx
callq 0x5d68
leaq 0x10(%rbp), %rdx
movq 0x30(%rbx), %rsi
cmpq 0x38(%rbx), %rsi
je 0x2f62
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 0x2f6e
addq $0x28, %rbx
movq %rbx, %rdi
callq 0x3834
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3745
leaq -0x28(%rbp), %rdi
movl $0x70, %edx
jmp 0x3755
movl %ecx, 0x1c(%rsi)
movb $0x1, 0x10(%rsi)
leaq -0x28(%rbp), %rdi
movl $0x6f, %edx
callq 0x5d68
movb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5f92
movq 0x60(%rbx), %rsi
cmpq 0x68(%rbx), %rsi
je 0x381d
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 0x3829
leaq 0x58(%rbx), %rdi
movq %r14, %rdx
callq 0x3834
movb $0x1, 0x25(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x47ab
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x28(%rdi)
jne 0x4769
movb $0x1, 0x28(%rbx)
movq 0x30(%rbx), %rax
cmpq %rax, 0x38(%rbx)
je 0x46cf
movq %rax, 0x38(%rbx)
movq 0x48(%rbx), %rax
cmpq %rax, 0x50(%rbx)
je 0x46dd
movq %rax, 0x50(%rbx)
leaq -0x88(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5df6
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 0x6002
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x4748
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 0x4755
leaq 0x30(%rbx), %rdi
leaq -0x38(%rbp), %rdx
callq 0x3834
movl 0x8(%rbx), %ecx
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
movl $0x6e, %edx
callq 0x5d68
leaq 0x10(%rbp), %rdx
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x4794
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 0x47a0
addq $0x48, %rbx
movq %rbx, %rdi
callq 0x3834
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x58c2
movl 0x8(%rbx), %r8d
movl 0x18(%rbx), %edx
movl 0x1c(%rbx), %ecx
leaq 0x2339(%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 0x4fd0
leaq -0x30(%rbp), %rdi
movq %rbx, %rsi
movl $0x72, %edx
movl $0x3, %ecx
callq 0x5f92
movq 0x68(%rbx), %rsi
cmpq 0x70(%rbx), %rsi
je 0x4fe6
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 0x4ff6
movl 0x8(%rbx), %ecx
leaq -0x30(%rbp), %rdi
movq %rbx, %rsi
movl $0x73, %edx
callq 0x5d68
jmp 0x4ff6
addq $0x60, %rbx
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x3834
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rbp), %rdi
movl 0x24(%rbx), %eax
testl %eax, %eax
jle 0x5081
decl %eax
movl %eax, 0x24(%rbx)
movq 0x60(%rbx), %rcx
movq 0x68(%rbx), %rdx
movq %rdx, %rsi
subq %rcx, %rsi
sarq $0x3, %rsi
movabsq $-0x3333333333333333, %r8 # imm = 0xCCCCCCCCCCCCCCCD
imulq %r8, %rsi
movl 0x10(%rdi), %edi
cmpq %rcx, %rdx
je 0x50bf
xorl %r9d, %r9d
leaq (%r9,%r9,4), %r10
cmpl %edi, 0x10(%rcx,%r10,8)
je 0x50c2
incl %r9d
cmpq %r9, %rsi
ja 0x50ac
movl %esi, %r9d
movq 0x50(%rbx), %r10
subq 0x48(%rbx), %r10
movl %r9d, %r9d
sarq $0x3, %r10
imulq %r8, %r10
cmpq %r9, %r10
jbe 0x5127
cmpq %rcx, %rdx
je 0x50f5
xorl %r8d, %r8d
leaq (%r8,%r8,4), %r9
cmpl %edi, 0x10(%rcx,%r9,8)
je 0x50f8
incl %r8d
cmpq %r8, %rsi
ja 0x50e2
movl %esi, %r8d
movl %r8d, %esi
leaq (%rsi,%rsi,4), %rdi
leaq (%rcx,%rdi,8), %rsi
addq $0x28, %rsi
cmpq %rdx, %rsi
je 0x511f
leaq (%rcx,%rdi,8), %rdi
subq %rsi, %rdx
callq 0x21b0
movq 0x68(%rbx), %rdx
movl 0x24(%rbx), %eax
addq $-0x28, %rdx
movq %rdx, 0x68(%rbx)
cmpb $0x1, 0x29(%rbx)
jne 0x5139
testl %eax, %eax
jle 0x5139
movq %rbx, %rdi
callq 0x52ac
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x58c2
movl 0x8(%rbx), %r8d
movl 0x18(%rbx), %edx
movl 0x1c(%rbx), %ecx
leaq 0x2199(%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 0x5d68
movl 0x1c(%rbx), %ecx
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
movl $0x77, %edx
callq 0x5d68
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
movl $0x77, %edx
xorl %ecx, %ecx
callq 0x5d68
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_O3/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), %rax
subq %rcx, %rax
je 0x5202
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rdx
movl 0x8(%rdi), %esi
xorl %eax, %eax
leaq (%rax,%rax,4), %r8
cmpl 0x10(%rcx,%r8,8), %esi
je 0x5214
incl %eax
cmpq %rax, %rdx
ja 0x51f0
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_O3/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 0x488b(%rip), %rdx      # 0x9fc0
movq 0x4894(%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 0x49d4(%rip), %r14      # 0xa140
movq %r14, %rdi
callq 0x2180
movl 0x49be(%rip), %eax      # 0xa138
cmpl %eax, %r15d
cmoval %r15d, %eax
incl %eax
movl %eax, 0x49af(%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_O3/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, 0x497c(%rip)      # 0xa134
leaq -0x78(%rbp), %rbx
leaq 0x49cd(%rip), %r14      # 0xa190
leaq 0x4a3e(%rip), %r15      # 0xa208
leaq -0x50(%rbp), %r12
leaq 0x4993(%rip), %r13      # 0xa168
movq %rbx, %rdi
callq 0x5716
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 0x4a34(%rip), %rax      # 0xa238
movq 0x4a3d(%rip), %rcx      # 0xa248
addq $-0x28, %rcx
cmpq %rcx, %rax
je 0x5835
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, 0x4a05(%rip)     # 0xa238
jmp 0x5840
movq %r15, %rdi
movq %r12, %rsi
callq 0x5af6
movq %r14, %rdi
callq 0x20c0
movq %r13, %rdi
callq 0x20c0
cmpl $0x65, -0x3c(%rbp)
je 0x5865
testb $0x1, 0x48d7(%rip)      # 0xa134
jne 0x57d5
jmp 0x586c
movb $0x0, 0x48c8(%rip)      # 0xa134
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x48a8(%rip), %rbx      # 0xa140
movq %rbx, %rdi
callq 0x2180
movl 0x4891(%rip), %r14d     # 0xa138
incl %r14d
movl %r14d, 0x4887(%rip)     # 0xa138
movq %rbx, %rdi
callq 0x20c0
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x402d(%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_O3/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 0x58c2
movl %eax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x588a
movl %eax, 0x8(%r14)
movl 0xc(%r12), %eax
cmpl $0x2, %eax
jl 0x5f5b
movl $0x1, %r13d
cmpl 0x8(%r12), %r13d
je 0x5f53
movq %r14, %rdi
movl $0x28, %esi
movq 0x4084(%rip), %rdx      # 0x9fc0
movl %r13d, %ecx
movl %r15d, %r8d
movq 0x4087(%rip), %r9       # 0x9fd0
callq 0x2070
movl 0xc(%r12), %eax
incl %r13d
cmpl %eax, %r13d
jl 0x5f26
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
// File: /workspace/github_cpp_makefile_star2_O3/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 0x588a
movl %eax, 0x8(%r14)
movl 0xc(%r12), %eax
cmpl $0x2, %eax
jl 0x609d
movl $0x2, %r15d
subl %r13d, %r15d
movl $0x1, %r13d
movl $0xaaaaaaab, %esi       # imm = 0xAAAAAAAB
cmpl 0x8(%r12), %r13d
je 0x6095
movl %r13d, %ecx
imulq %rsi, %rcx
shrq $0x21, %rcx
leal (%rcx,%rcx,2), %ecx
movl %r15d, %edx
subl %ecx, %edx
addl %r13d, %edx
cmpl $0x1, %edx
jne 0x6095
movq %r14, %rdi
movl $0x28, %esi
movq 0x3f48(%rip), %rdx      # 0x9fc0
movl %r13d, %ecx
movl -0x2c(%rbp), %r8d
movq 0x3f4a(%rip), %r9       # 0x9fd0
callq 0x2070
movl $0xaaaaaaab, %esi       # imm = 0xAAAAAAAB
movl 0xc(%r12), %eax
incl %r13d
cmpl %eax, %r13d
jl 0x6047
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
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4400
movq -0x30(%rbp), %r15
subq -0x40(%rbp), %r15
xorl %r14d, %r14d
cmpq $0x25, %r15
setae %r14b
callq 0x2ccc
movq %rax, %rbx
leaq 0x2903(%rip), %rdx      # 0x50fe
leaq 0x2a03(%rip), %r8       # 0x5205
leaq -0x198(%rbp), %rdi
movl %r14d, %esi
movl $0x1b, %ecx
xorl %r9d, %r9d
callq 0x3d74
leaq -0x198(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3c3a
leaq -0x198(%rbp), %rdi
callq 0x39e4
cmpq $0x24, %r15
jbe 0x2941
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %r12
xorl %r14d, %r14d
cmpq %r15, %r12
sete %r14b
callq 0x2ccc
movq %rax, %rbx
leaq 0x289d(%rip), %rdx      # 0x50fe
leaq 0x29b2(%rip), %r8       # 0x521a
leaq -0x128(%rbp), %rdi
movl %r14d, %esi
movl $0x1c, %ecx
xorl %r9d, %r9d
callq 0x3d74
leaq -0x128(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3c3a
leaq -0x128(%rbp), %rdi
callq 0x39e4
cmpq %r15, %r12
jne 0x2941
movl $0xb, %r15d
leaq -0x40(%rbp), %rbx
leaq -0x44(%rbp), %r14
movl $0x3, -0x44(%rbp)
movq -0x38(%rbp), %rsi
cmpq -0x30(%rbp), %rsi
je 0x28d4
movl $0x3, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x38(%rbp)
jmp 0x28df
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3e3c
decl %r15d
jne 0x28b3
movq -0x30(%rbp), %rax
subq -0x40(%rbp), %rax
xorl %r14d, %r14d
cmpq $0x29, %rax
setae %r14b
callq 0x2ccc
movq %rax, %rbx
leaq 0x27f8(%rip), %rdx      # 0x50fe
leaq 0x291d(%rip), %r8       # 0x522a
leaq -0xb8(%rbp), %rdi
movl %r14d, %esi
movl $0x22, %ecx
xorl %r9d, %r9d
callq 0x3d74
leaq -0xb8(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3c3a
leaq -0xb8(%rbp), %rdi
callq 0x39e4
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x294f
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 0x2985
jmp 0x2990
movq %rax, %rbx
leaq -0x128(%rbp), %rdi
jmp 0x2985
jmp 0x2990
movq %rax, %rbx
leaq -0x198(%rbp), %rdi
callq 0x39e4
jmp 0x2993
jmp 0x2990
jmp 0x2990
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x29a1
callq 0x2140
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O3/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 0x29f2
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x29fd
movq %rbx, %rdi
movq %r14, %rdx
callq 0x449c
movl -0x2c(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x9, %ecx
jl 0x29dc
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 0x2ccc
movq %rax, %r12
movq %r15, %rdi
movl %r13d, %esi
leaq 0x26c3(%rip), %rdx      # 0x50fe
movl $0x2d, %ecx
leaq 0x2807(%rip), %r8       # 0x524e
xorl %r9d, %r9d
callq 0x3d74
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3c3a
movq %r15, %rdi
callq 0x39e4
cmpq %r14, %rbx
jne 0x2a76
leaq 0x1(%rbx), %rax
cmpq $0x9, %rbx
movq %rax, %rbx
jne 0x2a14
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x2a84
callq 0x2140
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a98
movq %rax, %rbx
jmp 0x2aac
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
callq 0x39e4
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x2aba
callq 0x2140
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O3/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 0x261b(%rip), %r14      # 0x50fe
leaq 0x2770(%rip), %r15      # 0x525a
leaq -0x178(%rbp), %rbx
callq 0x2ccc
movq %rax, %r12
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
movl $0x36, %ecx
movq %r15, %r8
xorl %r9d, %r9d
callq 0x3d74
movq %r12, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x3c3a
movq %rbx, %rdi
callq 0x39e4
decl %r13d
jne 0x2af1
callq 0x2ccc
movq %rax, %r14
leaq 0x25c1(%rip), %rdx      # 0x50fe
leaq 0x2721(%rip), %r8       # 0x5265
leaq -0x108(%rbp), %rbx
movq %rbx, %rdi
movl $0x1, %esi
movl $0x39, %ecx
xorl %r9d, %r9d
callq 0x3d74
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3c3a
leaq -0x108(%rbp), %rdi
callq 0x39e4
callq 0x2ccc
movq %rax, %r14
leaq 0x2576(%rip), %rdx      # 0x50fe
leaq 0x26dd(%rip), %r8       # 0x526c
leaq -0x98(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
movl $0x3b, %ecx
xorl %r9d, %r9d
callq 0x3d74
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3c3a
leaq -0x98(%rbp), %rdi
callq 0x39e4
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2bd7
jmp 0x2bd7
movq %rax, %r14
movq %rbx, %rdi
callq 0x39e4
movq %r14, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2416(%rip), %rdi      # 0x5033
xorl %r13d, %r13d
xorl %eax, %eax
callq 0x2030
leaq 0x244b(%rip), %rdi      # 0x5079
movq %r14, %rsi
xorl %eax, %eax
callq 0x2030
leaq 0x23fa(%rip), %rdi      # 0x5039
xorl %eax, %eax
callq 0x2030
callq 0x2ccc
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 0x2ec2
leaq -0xa8(%rbp), %rdi
callq 0x30d6
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x30d6
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2f63
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x323c
leaq 0x23c0(%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 0x2f71
movq %rdx, -0x100(%rbp)
movq (%rcx), %rdx
movq %rdx, -0xf0(%rbp)
jmp 0x2f79
leaq -0x68(%rbp), %rdi
movq %r14, %rsi
callq 0x20d0
jmp 0x2fc2
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 0x2fb0
callq 0x2140
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x2fc2
callq 0x2140
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
callq 0x32da
testq %rax, %rax
je 0x3003
leaq 0x204d(%rip), %rdi      # 0x5027
xorl %eax, %eax
callq 0x2030
movq -0x68(%rbp), %rsi
leaq 0x209f(%rip), %rdi      # 0x508b
xorl %eax, %eax
callq 0x2030
leaq 0x203f(%rip), %rdi      # 0x5039
xorl %eax, %eax
callq 0x2030
jmp 0x3071
leaq -0x100(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movq %r14, %rdx
callq 0x3114
leaq -0x100(%rbp), %rsi
movq %rbx, %rdi
callq 0x354a
movq %rax, -0x48(%rbp)
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0x303d
movq %rax, (%rsi)
addq $0x8, 0x40(%rbx)
jmp 0x304d
addq $0x38, %rbx
leaq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0x340e
leaq -0xe0(%rbp), %rbx
movq %rbx, %rdi
callq 0x30d6
movq -0x20(%rbx), %rdi
leaq -0xf0(%rbp), %rax
cmpq %rax, %rdi
je 0x3071
callq 0x2140
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x307f
callq 0x2140
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x30bd
jmp 0x30bd
movq %rax, %rbx
leaq -0x100(%rbp), %rdi
callq 0x3202
jmp 0x30c0
jmp 0x30a8
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x30c0
callq 0x2140
jmp 0x30c0
jmp 0x30bd
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x30ce
callq 0x2140
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3cef
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 0x323c
leaq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x28(%r15), %rsi
movq 0x30(%r15), %rdx
addq %rsi, %rdx
callq 0x323c
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 0x323c
movzbl %bl, %edx
leaq -0x98(%rbp), %rsi
movq %r14, %rdi
callq 0x3f74
leaq -0x98(%rbp), %rdi
callq 0x39e4
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1331(%rip), %rdi      # 0x5027
xorl %eax, %eax
callq 0x2030
movl 0x48(%r15), %edx
movq 0x8(%r15), %rsi
movq 0x28(%r15), %rcx
leaq 0x144c(%rip), %rdi      # 0x515c
xorl %eax, %eax
callq 0x2030
leaq 0x131b(%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 0x39e4
jmp 0x3d6b
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x3d5a
callq 0x2140
jmp 0x3d5a
movq %rax, %rbx
movq -0x90(%rbp), %rdi
cmpq %r12, %rdi
je 0x3d6b
callq 0x2140
movq %rbx, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x400c
cmpb $0x0, (%rbx)
je 0x3f94
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x108c(%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 0x11d8(%rip), %rax      # 0x519c
leaq 0x11f6(%rip), %rdi      # 0x51c1
testb %r14b, %r14b
cmovneq %rax, %rdi
xorl %eax, %eax
callq 0x2030
leaq 0x1204(%rip), %rdi      # 0x51e4
xorl %eax, %eax
callq 0x2030
leaq 0x104b(%rip), %rdi      # 0x5039
xorl %eax, %eax
callq 0x2030
movq 0x8(%rbx), %rsi
leaq 0x11fe(%rip), %rdi      # 0x51fe
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x2030
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x45a8
movq (%r14), %rax
movq 0x70(%rax), %rdi
testq %rdi, %rdi
je 0x459b
callq 0x2140
addq $0x8, %r14
cmpq %r15, %r14
jne 0x458a
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x45b5
movq %r14, %rdi
callq 0x2140
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x45c8
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x401c
addq $0x20, %rbx
decq %r12
cmpq $0x1, %r12
ja 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_O3/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 0x3757
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 0x372e
incq %rcx
jmp 0x3714
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl 0x4(%rdi), %eax
cmpl $0x6, %eax
je 0xb377
cmpl $0x2, %eax
je 0xb343
cmpl $0x1, %eax
jne 0xb3c7
movsd 0x18(%rdi), %xmm0
movsd %xmm0, -0x10(%rbp)
movq %rbx, %rdi
callq 0xee28
movq %rax, %rdi
movsd -0x10(%rbp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0xbb88
movsd 0x20(%rdi), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x28(%rdi), %xmm0
movsd %xmm0, -0x18(%rbp)
movq %rbx, %rdi
callq 0xee28
movq %rax, %rdi
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0xbc88
leaq 0x8(%rdi), %rax
movsd 0x8(%rdi), %xmm0
movsd 0x10(%rdi), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq %rax, %rdi
callq 0xe702
movsd %xmm0, -0x18(%rbp)
movq %rbx, %rdi
callq 0xee28
movq %rax, %rdi
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0xc284
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetTurnAction(double)
bool ActionEffector::SetTurnAction(AngleDeg turn_angle) {
  if (mIsTurn == true || mIsMutex == true) {
    return false;
  }

  AngleDeg moment = GetTurnMoment(turn_angle, mSelfState.GetPlayerType(),
                                  mSelfState.GetVel().Mod());

  moment = GetNormalizeMoment(moment);

  if (fabs(moment) < FLOAT_EPS) {
    return false;
  }

  mTurn.Plan(moment);
  mTurn.Execute(mCommandQueue);
  ++mTurnCount;
  mIsTurn = true;
  mIsMutex = true;
  return true;
}

// Assembly:
cmpb $0x0, 0xe91(%rdi)
je 0xbb94
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpb $0x0, 0xe90(%rdi)
jne 0xbc7d
movq 0x20(%rbx), %rax
movslq 0x114(%rax), %r14
movsd %xmm0, -0x20(%rbp)
movsd 0x30(%rax), %xmm0
movsd 0x38(%rax), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x43dce
movq 0x5c38(%rax), %rax
imulq $0x3700, %r14, %rcx     # imm = 0x3700
movsd -0x18(%rbp), %xmm0
mulsd 0x3028(%rax,%rcx), %xmm0
addsd 0x5d451(%rip), %xmm0    # 0x69058
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x49360
movq %rax, %r14
callq 0x49360
movsd -0x18(%rbp), %xmm1
maxsd 0x3148(%r14), %xmm1
movsd 0x3140(%rax), %xmm0
minsd %xmm1, %xmm0
movapd 0x5d3d0(%rip), %xmm1    # 0x69010
andpd %xmm0, %xmm1
movsd 0x5d3f4(%rip), %xmm2    # 0x69040
ucomisd %xmm1, %xmm2
ja 0xbc7d
leaq 0x40(%rbx), %r14
movq %r14, %rdi
callq 0xf67a
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf5c8
incl 0xe40(%rbx)
movw $0x101, 0xe90(%rbx)     # imm = 0x101
movb $0x1, %al
jmp 0xbc7f
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetTurnNeckAction(double)
bool ActionEffector::SetTurnNeckAction(AngleDeg angle) {
  if (mIsTurnNeck == true) {
    return false;
  }

  if (angle < ServerParam::instance().minNeckMoment() ||
      angle > ServerParam::instance().maxNeckMoment()) {
    return false;
  }

  mTurnNeck.Plan(angle);
  mTurnNeck.Execute(mCommandQueue);
  ++mTurnNeckCount;
  mIsTurnNeck = true;
  return true;
}

// Assembly:
cmpb $0x0, 0xe93(%rdi)
je 0xc044
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd %xmm0, -0x18(%rbp)
callq 0x49360
movsd 0x3158(%rax), %xmm0
ucomisd -0x18(%rbp), %xmm0
ja 0xc07f
callq 0x49360
movsd -0x18(%rbp), %xmm0
ucomisd 0x3150(%rax), %xmm0
jbe 0xc083
xorl %eax, %eax
jmp 0xc0ad
leaq 0x140(%rbx), %r14
movq %r14, %rdi
callq 0xf984
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf5c8
incl 0xe48(%rbx)
movb $0x1, 0xe93(%rbx)
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetSayAction(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool ActionEffector::SetSayAction(std::string msg) {
  if (mIsSay == true) {
    return false;
  }

  if (PlayerParam::instance().isCoach()) {
    if (msg.length() > ServerParam::instance().freeformMsgSize()) {
      // false;
    }
  } else {
    if (msg.length() > ServerParam::instance().sayMsgSize()) {
      return false;
    }
  }

  mSay.Plan(msg);
  mSay.Execute(mCommandQueue);
  ++mSayCount;
  mIsSay = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpb $0x0, 0xe94(%rdi)
je 0xc0d5
xorl %eax, %eax
jmp 0xc165
movq %rsi, %r15
movq %rdi, %rbx
callq 0x43dce
cmpb $0x1, 0x31a5(%rax)
jne 0xc0f0
callq 0x49360
jmp 0xc104
movq 0x8(%r15), %r14
callq 0x49360
movl 0x32e8(%rax), %eax
cmpq %rax, %r14
ja 0xc0ce
leaq 0x1c0(%rbx), %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0xefd6
movq %r14, %rdi
movq %r15, %rsi
callq 0xfaf4
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xc14a
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x94e0
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0xf5c8
incl 0xe4c(%rbx)
movb $0x1, 0xe94(%rbx)
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xc18a
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x94e0
movq %rbx, %rdi
callq 0x98b0
// File: /workspace/github_cpp_makefile_star2_O3/wrighteagle2d[P]wrighteaglebase/Debug/../src/ActionEffector.cpp
// Function: ActionEffector::SetAttentiontoAction(int)
bool ActionEffector::SetAttentiontoAction(Unum num) {
  if (mIsAttentionto == true) {
    return false;
  }

  if (num == 0 || num == mAgent.GetSelfUnum() || num < -TEAMSIZE ||
      num > TEAMSIZE) {
    return false;
  }

  if (mAgent.GetSelf().GetFocusOnUnum() == num) {
    mIsAttentionto = true; // 本周期不再attentionto
    return false;
  }

  mAttentionto.Plan(true, num);
  mAttentionto.Execute(mCommandQueue);
  ++mAttentiontoCount;
  mIsAttentionto = true;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %r14d, %r14d
testl %esi, %esi
je 0xc20b
movq %rdi, %rbx
cmpb $0x0, 0xe95(%rdi)
jne 0xc20b
movl %esi, %r15d
leal -0xc(%r15), %eax
xorl %r14d, %r14d
cmpl $-0x17, %eax
jb 0xc20b
movq 0x8(%rbx), %rdi
cmpl %r15d, 0x8(%rdi)
je 0xc20b
callq 0xe75a
cmpl %r15d, 0xfc(%rax)
setne %r14b
je 0xc204
leaq 0x240(%rbx), %r12
movq %r12, %rdi
movl $0x1, %esi
movl %r15d, %edx
callq 0xfc80
leaq 0x28(%rbx), %rsi
movq %r12, %rdi
callq 0xf5c8
incl 0xe50(%rbx)
movb $0x1, 0xe95(%rbx)
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop