LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/SethKasmann[P]clever-girl/src/search.cpp
// Function: interrupt(SearchInfo&)
bool interrupt(SearchInfo& si)
{
    // Check to see if we have run out of time.
    if (si.clock.elapsed<std::chrono::milliseconds>() >= si.moveTime
        && !si.infinite)
    {
        si.quit = true;
        return true;
    }

    if (input_waiting())
    {
        std::string command(get_input());
        if (command == "quit" || command == "stop")
        {
            si.quit = true;
            return true;
        }
    }

    // The GUI should be able to send quit commands as well.
    // I may need multiple threads for this.
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
callq 0x4060
subq 0x30(%rbx), %rax
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x12, %rdx
addq %rax, %rdx
cmpq 0x28(%rbx), %rdx
jl 0x14fba
cmpb $0x0, 0x38(%rbx)
je 0x15106
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x40(%r14)
movaps %xmm0, 0x50(%r14)
movaps %xmm0, 0x60(%r14)
movaps %xmm0, 0x70(%r14)
movq 0xff9a(%rip), %r15      # 0x24f88
movq (%r15), %rdi
callq 0x4280
leal 0x3f(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
andl $0xc0, %ecx
subl %ecx, %eax
movl $0x1, %r12d
movl %eax, %ecx
shlq %cl, %r12
movq (%r15), %rdi
callq 0x4280
leal 0x3f(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
sarl $0x6, %ecx
movslq %ecx, %rax
orq %r12, (%rsp,%rax,8)
leaq 0x80(%rsp), %r8
xorps %xmm0, %xmm0
movaps %xmm0, (%r8)
movl $0x10, %edi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4210
movq (%r15), %rdi
callq 0x4280
leal 0x3f(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
sarl $0x6, %ecx
movslq %ecx, %rax
movq (%rsp,%rax,8), %r14
movq (%r15), %rdi
callq 0x4280
btq %rax, %r14
jae 0x15102
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq 0xff4d(%rip), %rdi      # 0x24fe0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x4230
movsbl %al, %edx
movq 0xff32(%rip), %rdi      # 0x24fe0
movq %rsp, %rsi
callq 0x43d0
leaq 0x9183(%rip), %rsi      # 0x1e240
movq %rsp, %rdi
callq 0x4090
testl %eax, %eax
je 0x150df
leaq 0x9175(%rip), %rsi      # 0x1e245
movq %rsp, %rdi
callq 0x4090
movb $0x1, %bpl
testl %eax, %eax
jne 0x150e5
movb $0x1, 0x3a(%rbx)
xorl %ebp, %ebp
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x150fb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4250
movb $0x1, %al
testb %bpl, %bpl
je 0x1510c
xorl %eax, %eax
jmp 0x1510c
movb $0x1, 0x3a(%rbx)
movb $0x1, %al
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x15135
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4250
movq %rbx, %rdi
callq 0x43b0
// File: /workspace/github_cpp_makefile_star2_O3/SethKasmann[P]clever-girl/src/search.cpp
// Function: setup_search(State&, SearchInfo&)
void setup_search(State& s, SearchInfo& si)
{
    //ttable.setAncient();
    ttable.clear();
    lineManager.clearPv();
    init_eval();
    history.clear();
    iterative_deepening(s, si);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x14e3ab(%rip), %rcx    # 0x1645f0
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
cmpq %rcx, %rax
je 0x16274
xorl %edx, %edx
movq %rdx, (%rax)
movw $0x0, 0x8(%rax)
movq %rdx, 0xc(%rax)
movl $0x0, 0x14(%rax)
movb $0x1, 0x18(%rax)
addq $0x20, %rax
cmpq %rcx, %rax
jne 0x16253
leaq 0x13f465(%rip), %rdi    # 0x1556e0
callq 0xf946
leaq 0x144419(%rip), %rdi    # 0x15a6a0
callq 0x14924
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x15eae
// File: /workspace/github_cpp_makefile_star2_O3/SethKasmann[P]clever-girl/src/state.cpp
// Function: State::init()
void State::init()
{
    mUs = white;
    mThem = black;
    mFiftyMoveRule = 0;
    mCastleRights = 0;
    mKey = 0;
    mPawnKey = 0;
    mCheckers = 0;
    mEnPassant = 0;
    mCheckSquares.fill({});
    mPinned.fill({});
    mOccupancy.fill({});
    mPieceIndex.fill({});
    mBoard.fill(none);
    mPieces.fill({});
    mPieceCount.fill({});
    mPstScore.fill({});
    for (auto i = mPieceList.begin(); i != mPieceList.end(); ++i)
        for (auto j = i->begin(); j != i->end(); ++j)
            j->fill(no_sq);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0x7895(%rip), %xmm0     # 0x1e2d0
movups %xmm0, (%rdi)
addq $0x18, %rdi
xorl %r14d, %r14d
movl $0x170, %edx            # imm = 0x170
xorl %esi, %esi
callq 0x4120
movaps 0x7898(%rip), %xmm0     # 0x1e2f0
movups %xmm0, 0x188(%rbx,%r14,4)
addq $0x4, %r14
cmpq $0x40, %r14
jne 0x16a58
xorps %xmm0, %xmm0
movups %xmm0, 0x2a8(%rbx)
movups %xmm0, 0x298(%rbx)
movups %xmm0, 0x288(%rbx)
movups %xmm0, 0x2b8(%rbx)
movups %xmm0, 0x2c8(%rbx)
movups %xmm0, 0x2d8(%rbx)
movups %xmm0, 0x2e8(%rbx)
xorl %eax, %eax
movq %rax, 0x2f8(%rbx)
movups %xmm0, 0x300(%rbx)
movq %rax, 0x310(%rbx)
leaq 0x328(%rbx), %rax
movups %xmm0, 0x318(%rbx)
movl $0x328, %ecx            # imm = 0x328
movdqa 0x782f(%rip), %xmm0     # 0x1e300
movdqa 0x7837(%rip), %xmm1     # 0x1e310
movdqa 0x783f(%rip), %xmm2     # 0x1e320
movdqa 0x7847(%rip), %xmm3     # 0x1e330
pshufd $0xf5, %xmm3, %xmm4     # xmm4 = xmm3[1,1,3,3]
movq %rax, %rdx
leaq (%rbx,%rcx), %rax
addq $0xf0, %rax
addq $0xf0, %rcx
xorl %esi, %esi
movq %rsi, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm1, %xmm6
pxor %xmm2, %xmm6
movdqa %xmm3, %xmm7
pcmpgtd %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm6     # xmm6 = xmm6[1,1,3,3]
pcmpeqd %xmm4, %xmm6
pand %xmm7, %xmm6
movd %xmm6, %edi
testb $0x1, %dil
je 0x16b40
movl $0x40, (%rdx,%rsi,4)
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0x16b53
movl $0x40, 0x4(%rdx,%rsi,4)
por %xmm0, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm3, %xmm6
pcmpgtd %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm5     # xmm5 = xmm5[1,1,3,3]
pcmpeqd %xmm4, %xmm5
pand %xmm6, %xmm5
pextrw $0x0, %xmm5, %edi
testb $0x1, %dil
je 0x16b83
movl $0x40, 0x8(%rdx,%rsi,4)
pextrw $0x4, %xmm5, %edi
testb $0x1, %dil
je 0x16b96
movl $0x40, 0xc(%rdx,%rsi,4)
addq $0x4, %rsi
cmpq $0xc, %rsi
jne 0x16b04
addq $0x28, %rdx
cmpq %rax, %rdx
jne 0x16b02
cmpq $0x508, %rcx            # imm = 0x508
jne 0x16aee
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/SethKasmann[P]clever-girl/src/state.cpp
// Function: State::makeNull()
void State::makeNull()
{
    assert(mCheckers == 0);
    // Remove the ep file and castle rights from the zobrist key.
    if (mEnPassant)
        mKey ^= Zobrist::key(get_file(mEnPassant));

    // Reset the en-passant square.
    mEnPassant = 0;

    // Swap the turn.
    swapTurn();

    // Set check squares.
    mCheckSquares[pawn] = getAttackBB<pawn>(getKingSquare(mThem), mThem);
    mCheckSquares[knight] = getAttackBB<knight>(getKingSquare(mThem));
    mCheckSquares[bishop] = getAttackBB<bishop>(getKingSquare(mThem));
    mCheckSquares[rook] = getAttackBB<rook>(getKingSquare(mThem));
    mCheckSquares[queen] = mCheckSquares[bishop] | mCheckSquares[rook];
}

// Assembly:
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x18601
bsfq %rax, %rcx
andl $0x7, %ecx
leaq 0x14e859(%rip), %rdx    # 0x166e50
movq 0x18(%rdi), %rax
xorq (%rdx,%rcx,8), %rax
jmp 0x18605
movq 0x18(%rdi), %rax
movq $0x0, 0x30(%rdi)
leaq 0x14e8fc(%rip), %rcx    # 0x166f10
xorq (%rcx), %rax
movq %rax, 0x18(%rdi)
movl (%rdi), %ecx
xorl %eax, %eax
testq %rcx, %rcx
sete %al
movl %ecx, 0x4(%rdi)
movl %eax, (%rdi)
imulq $0xf0, %rcx, %rax
movl 0x3f0(%rdi,%rax), %eax
shlq $0x9, %rcx
addq 0xc96d(%rip), %rcx      # 0x24fb0
movq (%rcx,%rax,8), %rcx
movq %rcx, 0x38(%rdi)
leaq 0x33ee(%rip), %rcx      # 0x1ba40
movq (%rcx,%rax,8), %rcx
movq %rcx, 0x40(%rdi)
movq 0x80(%rdi), %rdx
orq 0x78(%rdi), %rdx
leaq 0xcba4(%rip), %rcx      # 0x25210
movq (%rcx,%rax,8), %rsi
leaq 0x31c9(%rip), %rcx      # 0x1b840
movq (%rcx,%rax,8), %r8
andq %rdx, %r8
leaq 0x2fbb(%rip), %rcx      # 0x1b640
imulq (%rcx,%rax,8), %r8
leaq 0x2eaf(%rip), %rcx      # 0x1b540
movb (%rcx,%rax,4), %cl
shrq %cl, %r8
movq (%rsi,%r8,8), %rsi
movq %rsi, 0x48(%rdi)
leaq 0xcd6a(%rip), %rcx      # 0x25410
movq (%rcx,%rax,8), %r8
leaq 0x2c8f(%rip), %rcx      # 0x1b340
andq (%rcx,%rax,8), %rdx
leaq 0x2a84(%rip), %rcx      # 0x1b140
imulq (%rcx,%rax,8), %rdx
leaq 0x2978(%rip), %rcx      # 0x1b040
movb (%rcx,%rax,4), %cl
shrq %cl, %rdx
movq (%r8,%rdx,8), %rax
movq %rax, 0x50(%rdi)
orq %rsi, %rax
movq %rax, 0x58(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/SethKasmann[P]clever-girl/src/state.h
// Function: State::attacked(Square) const
inline
bool State::attacked(Square s) const
{
    return getAttackBB< pawn >(s, mUs) &  getPieceBB< pawn >(mThem)
        || getAttackBB<knight>(s) &  getPieceBB<knight>(mThem)
        || getAttackBB<bishop>(s) & (getPieceBB<bishop>(mThem) | getPieceBB<queen>(mThem))
        || getAttackBB< rook >(s) & (getPieceBB< rook >(mThem) | getPieceBB<queen>(mThem));
}

// Assembly:
movl (%rdi), %ecx
movl 0x4(%rdi), %eax
movl %esi, %edx
shlq $0x9, %rcx
addq 0xc32c(%rip), %rcx      # 0x24fb0
leaq (%rax,%rax,2), %rsi
shlq $0x4, %rsi
movq 0x288(%rdi,%rsi), %r8
movb $0x1, %al
testq %r8, (%rcx,%rdx,8)
je 0x18c9d
retq
leaq 0x288(%rdi), %r8
leaq 0x2d95(%rip), %rcx      # 0x1ba40
movq 0x8(%r8,%rsi), %r9
testq %r9, (%rcx,%rdx,8)
jne 0x18c9c
movq 0x80(%rdi), %r9
orq 0x78(%rdi), %r9
leaq 0xc548(%rip), %rcx      # 0x25210
leaq 0x2b71(%rip), %rdi      # 0x1b840
movq (%rdi,%rdx,8), %r10
andq %r9, %r10
leaq 0x2963(%rip), %rdi      # 0x1b640
imulq (%rdi,%rdx,8), %r10
movq (%rcx,%rdx,8), %r11
leaq 0x2853(%rip), %rcx      # 0x1b540
movb (%rcx,%rdx,4), %cl
shrq %cl, %r10
movq 0x20(%r8,%rsi), %rdi
movq 0x10(%r8,%rsi), %rcx
orq %rdi, %rcx
testq %rcx, (%r11,%r10,8)
jne 0x18c9c
leaq 0x2633(%rip), %rax      # 0x1b340
andq (%rax,%rdx,8), %r9
leaq 0x2428(%rip), %rax      # 0x1b140
imulq (%rax,%rdx,8), %r9
leaq 0x231c(%rip), %rax      # 0x1b040
movb (%rax,%rdx,4), %cl
shrq %cl, %r9
leaq 0xc6df(%rip), %rax      # 0x25410
orq 0x18(%r8,%rsi), %rdi
movq (%rax,%rdx,8), %rax
testq %rdi, (%rax,%r9,8)
setne %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/SethKasmann[P]clever-girl/src/uci.cpp
// Function: get_uci_move(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, State&)
Move get_uci_move(std::string & token, State & s)
{
    Move m;

    token.erase(std::remove(token.begin(), token.end(), ','),
                    token.end());
    MoveList mlist(s);
    while (mlist.size() > 0)
    {
        m = mlist.pop();
        if (toString(m) == token)
            return m;
        if (mlist.size() == 0)
            return nullMove;
    }
    return nullMove;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x878, %rsp            # imm = 0x878
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
addq %rdi, %rsi
leaq 0x20(%rsp), %r14
movb $0x2c, (%r14)
movq %r14, %rdx
callq 0x1a0ff
movq %rax, %rcx
subq (%rbx), %rcx
movq %rcx, 0x8(%rbx)
movb $0x0, (%rax)
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x10b60
movq %rsp, %r15
movq %r14, %rdi
callq 0xfd8e
testq %rax, %rax
je 0x19328
movq %r14, %rdi
callq 0xfdae
movl %eax, %ebp
movzwl %ax, %esi
movq %r15, %rdi
callq 0xfb3b
movq 0x8(%rsp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x192ec
movq (%rsp), %r12
testq %rdx, %rdx
je 0x192f5
movq (%rbx), %rsi
movq %r12, %rdi
callq 0x4270
testl %eax, %eax
sete %r13b
jmp 0x192f8
movq (%rsp), %r12
xorl %r13d, %r13d
jmp 0x192f8
movb $0x1, %r13b
leaq 0x10(%rsp), %rax
cmpq %rax, %r12
je 0x19312
movq 0x10(%rsp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x4250
testb %r13b, %r13b
jne 0x1932a
movq %r14, %rdi
callq 0xfd8e
testq %rax, %rax
jne 0x192a3
xorl %ebp, %ebp
movq 0x850(%rsp), %rdi
testq %rdi, %rdi
je 0x19347
movq 0x860(%rsp), %rsi
subq %rdi, %rsi
callq 0x4250
movl %ebp, %eax
addq $0x878, %rsp            # imm = 0x878
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1935d
movq %rax, %rbx
movq 0x850(%rsp), %rdi
testq %rdi, %rdi
je 0x1937d
movq 0x860(%rsp), %rsi
subq %rdi, %rsi
callq 0x4250
movq %rbx, %rdi
callq 0x43b0
// File: /workspace/github_cpp_makefile_star2_O3/SethKasmann[P]clever-girl/src/uci.cpp
// Function: set_option(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void set_option(std::string & name, std::string & value)
{
    if (name == "Hash")
        ttable.resize(std::stoi(value));
    else if (name == "ClearHash")
        ttable.clear();

    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x69c6(%rip), %rsi      # 0x20456
callq 0x4090
testl %eax, %eax
je 0x19aed
leaq 0x69b1(%rip), %rsi      # 0x20451
movq %rbx, %rdi
callq 0x4090
testl %eax, %eax
jne 0x19ae2
leaq 0x14ab3d(%rip), %rcx    # 0x1645f0
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
cmpq %rcx, %rax
je 0x19ae2
xorl %edx, %edx
movq %rdx, (%rax)
movw $0x0, 0x8(%rax)
movq %rdx, 0xc(%rax)
movl $0x0, 0x14(%rax)
movb $0x1, 0x18(%rax)
addq $0x20, %rax
cmpq %rcx, %rax
jne 0x19ac1
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %r14
callq 0x4050
movq %rax, %rbx
movl (%rax), %ebp
movl $0x0, (%rax)
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x42e0
cmpq %r14, (%r15)
je 0x19b45
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x19b51
movl (%rbx), %ecx
cmpl $0x22, %ecx
je 0x19b51
testl %ecx, %ecx
jne 0x19b2d
movl %ebp, (%rbx)
leaq 0x14aabc(%rip), %rdi    # 0x1645f0
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1a0a8
leaq 0x69a0(%rip), %rdi      # 0x204ec
callq 0x4130
leaq 0x6994(%rip), %rdi      # 0x204ec
callq 0x4300
cmpl $0x0, (%rbx)
jne 0x19b64
movl %ebp, (%rbx)
movq %rax, %rdi
callq 0x43b0
// File: /workspace/github_cpp_makefile_star2_O3/SethKasmann[P]clever-girl/src/history.h
// Function: History::init()
void init()
	{
		mKillers = {};
		mHistory = {};
		mGameHistory.clear();
		for (std::array<int, Board_size>& arr : mButterfly)
			arr.fill(1);
	}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl $0xc8, %edx
xorl %esi, %esi
callq 0x4120
movl $0x6, %eax
movl -0x10(%rsp,%rax,4), %ecx
movl %ecx, (%rbx,%rax,4)
incq %rax
cmpq $0x38, %rax
jne 0x1a039
leaq 0x40e0(%rbx), %rdi
movl $0x4000, %edx           # imm = 0x4000
xorl %esi, %esi
callq 0x4120
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x1a069
movq %rax, 0x8(%rbx)
addq $0xe0, %rbx
movl $0xe0, %eax
movaps 0x3ea4(%rip), %xmm0     # 0x1df20
movl $0x100, %ecx            # imm = 0x100
xorl %edx, %edx
movups %xmm0, (%rbx,%rdx,4)
addq $0x4, %rdx
cmpq $0x40, %rdx
jne 0x1a083
addq %rcx, %rax
addq %rcx, %rbx
cmpq $0x40e0, %rax           # imm = 0x40E0
jne 0x1a081
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/SethKasmann[P]clever-girl/src/zobrist.cpp
// Function: Zobrist::init()
void init()
	{
		srand(6736199);
		for (PieceType p = pawn; p < none; ++p)
		{
			for (Square s = first_sq; s <= last_sq; ++s)
			{
				piece_rand[white][p][s] = rand_64();
				piece_rand[black][p][s] = rand_64();
			}
		}
		for (File f = a_file; f <= h_file; ++f)
		{
			ep_file_rand[f] = rand_64();
		}
		for (int i = 0; i < 16; ++i)
		{
			castle_rand[i] = rand_64();
		}
		side_to_move_rand = rand_64();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0x66c947, %edi         # imm = 0x66C947
callq 0x4220
leaq 0x14bf0f(%rip), %r14    # 0x166250
xorl %r15d, %r15d
xorl %r12d, %r12d
callq 0x4070
movl %eax, %ebx
shlq $0x20, %rbx
callq 0x4070
cltq
orq %rbx, %rax
movq %rax, -0xc00(%r14,%r12,8)
callq 0x4070
movl %eax, %ebx
shlq $0x20, %rbx
callq 0x4070
cltq
orq %rbx, %rax
movq %rax, (%r14,%r12,8)
incq %r12
cmpq $0x40, %r12
jne 0x1a347
incq %r15
addq $0x200, %r14            # imm = 0x200
cmpq $0x6, %r15
jne 0x1a344
xorl %r14d, %r14d
leaq 0x14cab0(%rip), %r15    # 0x166e50
callq 0x4070
movl %eax, %ebx
shlq $0x20, %rbx
callq 0x4070
cltq
orq %rbx, %rax
movq %rax, (%r14,%r15)
addq $0x8, %r14
cmpq $0x40, %r14
jne 0x1a3a0
xorl %r14d, %r14d
leaq 0x14cac3(%rip), %r15    # 0x166e90
callq 0x4070
movl %eax, %ebx
shlq $0x20, %rbx
callq 0x4070
cltq
orq %rbx, %rax
movq %rax, (%r14,%r15)
addq $0x8, %r14
cmpq $0x80, %r14
jne 0x1a3cd
callq 0x4070
movl %eax, %ebx
shlq $0x20, %rbx
callq 0x4070
cltq
orq %rbx, %rax
movq %rax, 0x14cb01(%rip)    # 0x166f10
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/WeihuaZhu[P]hpc_prog2/./io.h
// Function: std::vector<double, std::allocator<double>> read_binary_file<double>(char const*)
std::vector<T> read_binary_file(const char* filename)
{
    // get file size
    std::ifstream in(filename, std::ios::binary | std::ios::ate);
    if (!(in.good() && in.is_open()))
        throw std::runtime_error(std::string("Couldn't open file ") + filename);
    std::size_t nbytes = in.tellg();
    in.close();
    // open again, this time at the beginning
    std::ifstream infile(filename, std::ios::binary);

    // create vector of the correct size
    std::size_t n = nbytes / sizeof(T);
    std::vector<T> result(n);
    // read file into vector:
    infile.read((char*) &result[0], nbytes);
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x430, %rsp            # imm = 0x430
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x228(%rsp), %r15
movq %r15, %rdi
movl $0x6, %edx
callq 0x2430
movq (%r15), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x248(%rsp,%rax)
jne 0x366c
leaq 0x2a0(%rsp), %rdi
callq 0x2090
testb %al, %al
je 0x366c
leaq 0x228(%rsp), %rdi
callq 0x23e0
movq %rax, %r15
leaq 0x228(%rsp), %rdi
callq 0x2070
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movl $0x4, %edx
callq 0x2430
movq %r15, %rsi
shrq $0x3, %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x34d6
movq (%rbx), %rsi
leaq 0x20(%rsp), %rdi
movq %r15, %rdx
callq 0x22d0
leaq 0x20(%rsp), %rdi
callq 0x20a0
leaq 0x228(%rsp), %rdi
callq 0x20a0
movq %rbx, %rax
addq $0x430, %rsp            # imm = 0x430
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x2120
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1c9f(%rip), %rsi      # 0x5328
leaq 0x1cab(%rip), %rdx      # 0x533b
movq %rsp, %rdi
callq 0x3994
movq %rsp, %rdi
movq %r14, %rsi
callq 0x2450
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x36c6
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x36d3
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x23b0
xorl %ebp, %ebp
movq 0x38ed(%rip), %rsi      # 0x6ff0
movq 0x38b6(%rip), %rdx      # 0x6fc0
movq %rbx, %rdi
callq 0x23d0
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x372c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2260
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3742
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2260
testb %bpl, %bpl
jne 0x3798
jmp 0x37a0
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3798
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2260
jmp 0x3798
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3780
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2260
jmp 0x3780
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x20a0
jmp 0x37a0
jmp 0x3790
jmp 0x3790
movq %rax, %r14
jmp 0x37a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2190
leaq 0x228(%rsp), %rdi
callq 0x20a0
movq %r14, %rdi
callq 0x23f0
// File: /workspace/github_cpp_makefile_star2_O3/WeihuaZhu[P]hpc_prog2/./io.h
// Function: void write_binary_file<double>(char const*, std::vector<double, std::allocator<double>> const&)
void write_binary_file(const char* filename, const std::vector<T>& data)
{
    // open file in binary mode
    std::ofstream out(filename, std::ios::binary);
    if (!(out.good() && out.is_open()))
        throw std::runtime_error(std::string("Couldn't open file ") + filename);
    // write data to file
    out.write(reinterpret_cast<const char*>(&data[0]), sizeof(T)*data.size());
    out.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x240, %rsp            # imm = 0x240
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x4, %edx
callq 0x2270
movq (%r15), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x60(%rsp,%rax)
jne 0x385e
leaq 0xb0(%rsp), %rdi
callq 0x2090
testb %al, %al
je 0x385e
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
subq %rsi, %rdx
leaq 0x40(%rsp), %rdi
callq 0x22e0
leaq 0x40(%rsp), %rdi
callq 0x2330
movq 0x3785(%rip), %rax      # 0x6fa8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x48(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x40(%rsp,%rcx)
callq 0x2200
leaq 0x138(%rsp), %rdi
callq 0x20d0
addq $0x240, %rsp            # imm = 0x240
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x2120
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1aad(%rip), %rsi      # 0x5328
leaq 0x1ab9(%rip), %rdx      # 0x533b
movq %rsp, %rdi
callq 0x3994
movq %rsp, %rdi
movq %r14, %rsi
callq 0x2450
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x38b8
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x38c5
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x23b0
xorl %ebp, %ebp
movq 0x36fb(%rip), %rsi      # 0x6ff0
movq 0x36c4(%rip), %rdx      # 0x6fc0
movq %rbx, %rdi
callq 0x23d0
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x391e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2260
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3934
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2260
testb %bpl, %bpl
jne 0x3959
jmp 0x3966
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3959
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2260
jmp 0x3959
movq %rax, %r14
movq %rbx, %rdi
callq 0x2190
jmp 0x3966
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x2350
movq %r14, %rdi
callq 0x23f0
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/examples/K2-24/kima_setup.cpp
// Function: main
int main(int argc, char** argv)
{
    datafile = "K2-24.rv"; // set the RV data file
    load(datafile, "ms", 1);

    /// set the sampler and run it!
    Sampler<RVmodel> sampler = setup<RVmodel>(argc, argv);
    sampler.run(50); // the optional argument to run() sets the print thining

    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x6c0, %rsp            # imm = 0x6C0
movq %rsi, %rbx
movl %edi, %ebp
movq 0x2f9cf(%rip), %rdx     # 0x50548
leaq 0x2f9c0(%rip), %r14     # 0x50540
leaq 0x21d79(%rip), %rcx     # 0x42900
movl $0x8, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x6600
leaq 0x8(%rsp), %rdx
movl $0x1, (%rdx)
leaq 0x1c968(%rip), %rsi     # 0x3d511
movq %r14, %rdi
callq 0x20da9
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x20eac
movq %r14, %rdi
movl $0x32, %esi
callq 0x20f7e
leaq 0x8(%rsp), %rdi
callq 0x2115c
xorl %eax, %eax
addq $0x6c0, %rsp            # imm = 0x6C0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2115c
movq %rbx, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O3/zengfenfei[P]codility/src/MaxCounters.cpp
// Function: main
int main() {
	vector<int> A(7);
	A[0] = 3;
	A[1] = 4;
	A[2] = 4;
	A[3] = 6;
	A[4] = 1;
	A[5] = 4;
	A[6] = 4;
	vector<int> counters = solution(5, A);
	for (int i = 0; i < counters.size(); i++) {
		cout << counters[i] << ',';
	}
	cout << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl $0x1c, %edi
callq 0x1070
movq %rax, %rbx
leaq -0x58(%rbp), %rdx
movq %rax, (%rdx)
addq $0x1c, %rax
movq %rax, 0x10(%rdx)
movq %rax, 0x8(%rdx)
movaps 0xcfb(%rip), %xmm0      # 0x2010
movups %xmm0, (%rbx)
movabsq $0x400000001, %rax      # imm = 0x400000001
movq %rax, 0x10(%rbx)
movl $0x4, 0x18(%rbx)
leaq -0x40(%rbp), %rdi
movl $0x5, %esi
callq 0x121c
movq -0x40(%rbp), %rax
cmpq %rax, -0x38(%rbp)
je 0x138a
xorl %r12d, %r12d
movq 0x2c89(%rip), %r14      # 0x3fd8
leaq -0x21(%rbp), %r15
movl (%rax,%r12,4), %esi
movq %r14, %rdi
callq 0x10b0
movb $0x2c, -0x21(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x1090
incq %r12
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
ja 0x1353
leaq -0x21(%rbp), %rsi
movb $0xa, (%rsi)
movq 0x2c40(%rip), %rdi      # 0x3fd8
movl $0x1, %edx
callq 0x1090
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x13b7
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x1080
movl $0x1c, %esi
movq %rbx, %rdi
callq 0x1080
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13da
movq %rax, %r14
jmp 0x13f2
movq %rax, %r14
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x13f2
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x1080
movl $0x1c, %esi
movq %rbx, %rdi
callq 0x1080
movq %r14, %rdi
callq 0x10c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::AutoReg::registerTestCase(Catch::ITestCase*, char const*, Catch::NameAndDesc const&, Catch::SourceLineInfo const&)
void AutoReg::registerTestCase( ITestCase* testCase,
                                    char const* classOrQualifiedMethodName,
                                    NameAndDesc const& nameAndDesc,
                                    SourceLineInfo const& lineInfo ) {

        getMutableRegistryHub().registerTest
            ( makeTestCase( testCase,
                            extractClassName( classOrQualifiedMethodName ),
                            nameAndDesc.name,
                            nameAndDesc.description,
                            lineInfo ) );
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
callq 0xa35b
movq %rax, %rbx
leaq 0x70(%rsp), %rbp
leaq 0xf(%rsp), %rdx
movq %rbp, %rdi
movq %r13, %rsi
callq 0xfeba
leaq 0x50(%rsp), %rdi
movq %rbp, %rsi
callq 0xfd7b
movq (%r12), %rsi
leaq 0x30(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0xfeba
movq 0x8(%r12), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xd(%rsp), %rdx
callq 0xfeba
leaq 0x90(%rsp), %rdi
leaq 0x50(%rsp), %rdx
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %r15, %rsi
movq %r14, %r9
callq 0xa421
movq (%rbx), %rax
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq *0x18(%rax)
movq 0x1a0(%rsp), %rdi
testq %rdi, %rdi
je 0xa222
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x90(%rsp), %rdi
callq 0x101e0
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa24a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x9330
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa265
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x9330
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa280
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x9330
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa2a1
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x9330
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0xffa7
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xfef8
jmp 0xa2d0
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa2f0
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x9330
jmp 0xa2f0
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa310
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x9330
jmp 0xa310
movq %rax, %rbx
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa330
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x9330
jmp 0xa330
movq %rax, %rbx
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa351
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x9330
movq %rbx, %rdi
callq 0x95c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::getRegistryHub()
inline RegistryHub*& getTheRegistryHub() {
            static RegistryHub* theRegistryHub = NULL;
            if( !theRegistryHub )
                theRegistryHub = new RegistryHub();
            return theRegistryHub;
        }

// Assembly:
movq 0x4bc5d(%rip), %rax     # 0x56408
testq %rax, %rax
je 0xa7b1
retq
pushq %rax
movl $0xd8, %edi
callq 0x9310
leaq 0x4a9fd(%rip), %rcx     # 0x551c0
movq %rcx, (%rax)
leaq 0x4aa43(%rip), %rcx     # 0x55210
movq %rcx, 0x8(%rax)
leaq 0x49c40(%rip), %rcx     # 0x54418
movq %rcx, 0x10(%rax)
leaq 0x20(%rax), %rcx
xorl %edx, %edx
movl %edx, 0x20(%rax)
movq %rdx, 0x28(%rax)
movq %rcx, 0x30(%rax)
movq %rcx, 0x38(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x50(%rax)
movups %xmm0, 0x60(%rax)
movups %xmm0, 0x70(%rax)
leaq 0x4abf5(%rip), %rcx     # 0x55400
movq %rcx, 0x80(%rax)
leaq 0x90(%rax), %rcx
movl %edx, 0x90(%rax)
movq %rdx, 0x98(%rax)
movq %rcx, 0xa0(%rax)
movq %rcx, 0xa8(%rax)
movq %rdx, 0xb0(%rax)
leaq 0x4ac06(%rip), %rcx     # 0x55448
movq %rcx, 0xb8(%rax)
movq %rdx, 0xd0(%rax)
movups %xmm0, 0xc0(%rax)
movq %rax, 0x4bbaa(%rip)     # 0x56408
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::Stream::release()
void Stream::release() {
        if( isOwned ) {
            delete streamBuf;
            streamBuf = NULL;
            isOwned = false;
        }
    }

// Assembly:
cmpb $0x1, 0x8(%rdi)
jne 0xac3e
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xac32
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rbx)
movb $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::createStream(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Stream createStream( std::string const& streamName ) {
        if( streamName == "stdout" ) return Stream( std::cout.rdbuf(), false );
        if( streamName == "stderr" ) return Stream( std::cerr.rdbuf(), false );
        if( streamName == "debug" ) return Stream( new StreamBufImpl<OutputDebugWriter>, true );

        throw std::domain_error( "Unknown stream: " + streamName );
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0x32a34(%rip), %rsi     # 0x3d6db
callq 0x90d0
testl %eax, %eax
je 0xad36
leaq 0x32a27(%rip), %rsi     # 0x3d6e2
movq %r14, %rdi
callq 0x90d0
testl %eax, %eax
je 0xad3f
leaq 0x32a1b(%rip), %rsi     # 0x3d6e9
movq %r14, %rdi
callq 0x90d0
testl %eax, %eax
jne 0xad63
movl $0x148, %edi            # imm = 0x148
callq 0x9310
movq %rax, %rbx
movq 0x4b296(%rip), %rax     # 0x55f88
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x38(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x28(%rbx)
callq 0x9660
leaq 0x4acb0(%rip), %rax     # 0x559c8
movq %rax, (%rbx)
leaq 0x40(%rbx), %rax
leaq 0x140(%rbx), %rcx
movq %rax, 0x28(%rbx)
movq %rax, 0x20(%rbx)
movq %rcx, 0x30(%rbx)
movb $0x1, %dl
jmp 0xad57
movq 0x4b283(%rip), %rax     # 0x55fc0
jmp 0xad46
movq 0x4b2a2(%rip), %rax     # 0x55fe8
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq 0xe8(%rax,%rcx), %rbx
xorl %edx, %edx
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x9160
movq %rax, %rbx
leaq 0x32978(%rip), %rsi     # 0x3d6ef
movq %rsp, %rdi
movq %r14, %rdx
callq 0xff1f
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x93c0
xorl %ebp, %ebp
movq 0x4b1e7(%rip), %rsi     # 0x55f80
movq 0x4b200(%rip), %rdx     # 0x55fa0
movq %rbx, %rdi
callq 0x9580
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xadc6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9330
testb %bpl, %bpl
jne 0xadd0
jmp 0xadd8
movq %rax, %r14
movq %rbx, %rdi
callq 0x9270
movq %r14, %rdi
callq 0x95c0
// File: /workspace/github_cpp_makefile_star2_O3/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::toString(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&)
std::string toString( std::wstring const& value ) {

    std::string s;
    s.reserve( value.size() );
    for(size_t i = 0; i < value.size(); ++i )
        s += value[i] <= 0xff ? static_cast<char>( value[i] ) : '?';
    return toString( s );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x8(%rsi), %rsi
leaq 0x8(%rsp), %rdi
callq 0x94c0
cmpq $0x0, 0x8(%r14)
je 0xd4fd
xorl %r13d, %r13d
movl $0x3f, %ebp
leaq 0x8(%rsp), %r15
movq (%r14), %rax
movl (%rax,%r13,4), %eax
cmpl $0x100, %eax            # imm = 0x100
cmovgel %ebp, %eax
movsbl %al, %esi
movq %r15, %rdi
callq 0x92d0
incq %r13
cmpq 0x8(%r14), %r13
jb 0xd4da
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xd01d
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xd521
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9330
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd535
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xd54f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9330
movq %rbx, %rdi
callq 0x95c0
// File: /workspace/github_cpp_makefile_star2_O3/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::toString[abi:cxx11](unsigned long)
std::string toString( unsigned long value ) {
    std::ostringstream oss;
    if( value > 8192 )
        oss << "0x" << std::hex << value;
    else
        oss << value;
    return oss.str();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x9400
cmpq $0x2001, %r14           # imm = 0x2001
jb 0xd7a8
leaq 0x2ffa6(%rip), %rsi     # 0x3d72b
movq %rsp, %rdi
movl $0x2, %edx
callq 0x9390
movq (%rsp), %rax
movq -0x18(%rax), %rax
movl 0x18(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rsp,%rax)
movq %rsp, %rdi
movq %r14, %rsi
callq 0x9200
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x94d0
movq 0x487e9(%rip), %rsi     # 0x55fb0
movq %rsp, %rdi
callq 0x9180
leaq 0x70(%rsp), %rdi
callq 0x90f0
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x487bf(%rip), %rsi     # 0x55fb0
movq %rsp, %rdi
callq 0x9180
leaq 0x70(%rsp), %rdi
callq 0x90f0
movq %rbx, %rdi
callq 0x95c0
// File: /workspace/github_cpp_makefile_star2_O3/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::ResultBuilder::captureExpression()
void ResultBuilder::captureExpression() {
        AssertionResult result = build();
        getResultCapture().assertionEnded( result );

        if( !result.isOk() ) {
            if( getCurrentContext().getConfig()->shouldDebugBreak() )
                m_shouldDebugBreak = true;
            if( getCurrentContext().getRunner()->aborting() || m_assertionInfo.resultDisposition == ResultDisposition::Normal )
                m_shouldThrow = true;
        }
    }

// Assembly:
pushq %rbp
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0xc41a
callq 0xa0bc
movq (%rax), %rcx
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq *0x10(%rcx)
testb $0x10, 0xc0(%rsp)
je 0xdc56
movl 0x78(%rsp), %eax
andl $0x4, %eax
jne 0xdc56
callq 0xac3f
movq (%rax), %rcx
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq *0x30(%rcx)
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, %ebp
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xdc1f
movq (%rdi), %rax
callq *0x18(%rax)
testb %bpl, %bpl
je 0xdc2b
movb $0x1, 0x298(%rbx)
callq 0xac3f
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
cmpl $0x0, 0x68(%rbx)
sete %cl
orb %cl, %al
cmpb $0x1, %al
jne 0xdc56
movb $0x1, 0x299(%rbx)
leaq 0x10(%rsp), %rdi
callq 0xb15a
addq $0xc8, %rsp
popq %rbx
popq %rbp
retq
jmp 0xdc81
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xdc8e
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0xdc8e
movq %rax, %rdi
callq 0xffa7
jmp 0xdc8b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xb15a
movq %rbx, %rdi
callq 0x95c0
// File: /workspace/github_cpp_makefile_star2_O3/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::RegistrarForTagAliases::RegistrarForTagAliases(char const*, char const*, Catch::SourceLineInfo const&)
RegistrarForTagAliases::RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) {
        try {
            TagAliasRegistry::get().add( alias, tag, lineInfo );
        }
        catch( std::exception& ex ) {
            Colour colourGuard( Colour::Red );
            std::cerr << ex.what() << std::endl;
            exit(1);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
callq 0xf1b4
leaq 0x471c6(%rip), %rdi     # 0x563c8
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xeaf0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0xf286
movq %rbx, %rdi
callq 0x9130
movq %rax, %rbx
movb $0x0, 0xf(%rsp)
callq 0xae3a
movq (%rax), %rcx
movq %rax, %rdi
movl $0x2, %esi
callq *0x10(%rcx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x46d93(%rip), %rdi     # 0x55fe8
movq %rax, %rsi
callq 0x9300
movq %rax, %rdi
callq 0x9150
movl $0x1, %edi
callq 0x93d0
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0xae1a
jmp 0xf281
movq %rax, %rbx
callq 0x9540
movq %rbx, %rdi
callq 0x95c0
movq %rax, %rdi
callq 0xffa7
// File: /workspace/github_cpp_makefile_star2_O3/minimind[P]simple-graph/unittest/main.cpp
// Function: ensureGraphTestLink()
void ensureGraphTestLink()
{
  ensureGraphConstructionTestLink();
  ensureGraphVisitorTestLink();
  ensureGraphCopyTopologyTestLink();
  ensureGraphAddTestLink();
  ensureGraphVisitorIgnoreKeyTestLink();
}

// Assembly:
pushq %rax
callq 0x318f2
callq 0x3bf1e
callq 0x3643b
callq 0x2d382
popq %rax
jmp 0x38e90
nop
// File: /workspace/github_cpp_makefile_star2_O3/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::enforceNotReservedTag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::SourceLineInfo const&)
inline void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
        if( isReservedTag( tag ) ) {
            {
                Colour colourGuard( Colour::Red );
                std::cerr
                    << "Tag name [" << tag << "] not allowed.\n"
                    << "Tag names starting with non alpha-numeric characters are reserved\n";
            }
            {
                Colour colourGuard( Colour::FileName );
                std::cerr << _lineInfo << std::endl;
            }
            exit(1);
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x15481
testb %al, %al
jne 0x10101
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb $0x0, 0x7(%rsp)
callq 0xae3a
movq (%rax), %rcx
movq %rax, %rdi
movl $0x2, %esi
callq *0x10(%rcx)
movq 0x45ec8(%rip), %rdi     # 0x55fe8
leaq 0x2d804(%rip), %rsi     # 0x3d92b
movl $0xa, %edx
callq 0x9390
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x45ea9(%rip), %rdi     # 0x55fe8
callq 0x9390
movq %rax, %r14
leaq 0x2d7e8(%rip), %rsi     # 0x3d936
movl $0xf, %edx
movq %rax, %rdi
callq 0x9390
leaq 0x2d7e4(%rip), %rsi     # 0x3d946
movl $0x42, %edx
movq %r14, %rdi
callq 0x9390
leaq 0x7(%rsp), %rdi
callq 0xae1a
movb $0x0, 0x6(%rsp)
callq 0xae3a
movq (%rax), %rcx
movq %rax, %rdi
movl $0x17, %esi
callq *0x10(%rcx)
movq 0x45e50(%rip), %rdi     # 0x55fe8
movq %rbx, %rsi
callq 0xabbc
movq 0x45e41(%rip), %rdi     # 0x55fe8
callq 0x9150
leaq 0x6(%rsp), %rdi
callq 0xae1a
movl $0x1, %edi
callq 0x93d0
movq %rax, %rbx
leaq 0x6(%rsp), %rdi
jmp 0x101d2
movq %rax, %rbx
leaq 0x7(%rsp), %rdi
callq 0xae1a
movq %rbx, %rdi
callq 0x95c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::Session::Session()
Session()
        : m_cli( makeCommandLineParser() ) {
            if( alreadyInstantiated ) {
                std::string msg = "Only one instance of Catch::Session can ever be used";
                std::cerr << msg << std::endl;
                throw std::logic_error( msg );
            }
            alreadyInstantiated = true;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x15acd
xorl %eax, %eax
movb %al, 0x80(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rbx)
movups %xmm0, 0x60(%rbx)
movsd 0x2c480(%rip), %xmm1    # 0x3d030
movups %xmm1, 0x84(%rbx)
leaq 0xa8(%rbx), %rcx
movq %rcx, 0x98(%rbx)
movq %rax, 0xa0(%rbx)
movb %al, 0xa8(%rbx)
leaq 0xc8(%rbx), %rcx
movq %rcx, 0xb8(%rbx)
movq %rax, 0xc0(%rbx)
movb %al, 0xc8(%rbx)
leaq 0xe8(%rbx), %rcx
movq %rcx, 0xd8(%rbx)
movq %rax, 0xe0(%rbx)
movb %al, 0xe8(%rbx)
leaq 0x108(%rbx), %rcx
movq %rcx, 0xf8(%rbx)
movq %rax, 0x100(%rbx)
movb %al, 0x108(%rbx)
movups %xmm0, 0x118(%rbx)
movups %xmm0, 0x128(%rbx)
cmpb $0x1, 0x45762(%rip)     # 0x5639a
je 0x10c4d
movb $0x1, 0x45759(%rip)     # 0x5639a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2cd55(%rip), %rsi     # 0x3d9b3
leaq 0x2cd82(%rip), %rdx     # 0x3d9e7
leaq 0x8(%rsp), %rdi
callq 0x2ace6
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x45368(%rip), %rdi     # 0x55fe8
callq 0x9390
movq %rax, %rdi
callq 0x9150
movl $0x10, %edi
callq 0x9160
movq %rax, %r15
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x9460
movq 0x45322(%rip), %rsi     # 0x55fd0
movq 0x45303(%rip), %rdx     # 0x55fb8
movq %r15, %rdi
callq 0x9580
movq %rax, %r14
movq %r15, %rdi
callq 0x9270
jmp 0x10ccd
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x10ce9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9330
jmp 0x10ce9
movq %rax, %r14
movq 0x130(%rbx), %rdi
testq %rdi, %rdi
je 0x10cfb
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x60(%rbx), %r15
leaq 0x78(%rbx), %rdi
callq 0x16d8c
movq %r15, %rdi
callq 0x16e06
movq %rbx, %rdi
callq 0x16e64
movq %r14, %rdi
callq 0x95c0
movq %rax, %rdi
callq 0xffa7
// File: /workspace/github_cpp_makefile_star2_O3/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::Session::run(int, char* const*)
int run( int argc, char* const argv[] ) {

            int returnCode = applyCommandLine( argc, argv );
            if( returnCode == 0 )
                returnCode = run();
            return returnCode;
        }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %ecx
callq 0x1951a
testl %eax, %eax
je 0x10d3c
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x19734
nop
// File: /workspace/github_cpp_makefile_star2_O3/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::TestSpec::NamePattern::matches(Catch::TestCaseInfo const&) const
virtual bool matches( TestCaseInfo const& testCase ) const {
                switch( m_wildcard ) {
                    case NoWildcard:
                        return m_name == toLower( testCase.name );
                    case WildcardAtStart:
                        return endsWith( toLower( testCase.name ), m_name );
                    case WildcardAtEnd:
                        return startsWith( toLower( testCase.name ), m_name );
                    case WildcardAtBothEnds:
                        return contains( toLower( testCase.name ), m_name );
                }

#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunreachable-code"
#endif
                throw std::logic_error( "Unknown enum" );
#ifdef __clang__
#pragma clang diagnostic pop
#endif
            }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl 0x30(%rdi), %eax
cmpq $0x3, %rax
ja 0x1134b
movq %rdi, %rbx
leaq 0x2be38(%rip), %rcx     # 0x3d088
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xba07
movq 0x18(%rbx), %rdx
cmpq 0x8(%r14), %rdx
jne 0x1131c
movq 0x8(%rsp), %r14
testq %rdx, %rdx
je 0x11325
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x9350
testl %eax, %eax
sete %bl
jmp 0x11327
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xba07
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb564
jmp 0x11302
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xba07
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x95a0
cmpq $-0x1, %rax
setne %bl
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
jmp 0x1130d
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xba07
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc894
movl %eax, %ebx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11341
movq 0x18(%rsp), %rsi
incq %rsi
jmp 0x1133c
movq 0x8(%rsp), %r14
xorl %ebx, %ebx
jmp 0x11327
movb $0x1, %bl
leaq 0x18(%rsp), %rax
cmpq %rax, %r14
je 0x11341
movq 0x18(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x9330
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x9160
movq %rax, %r14
leaq 0x2ce4e(%rip), %rsi     # 0x3e1ad
movq %rax, %rdi
callq 0x9430
movq 0x44c62(%rip), %rsi     # 0x55fd0
movq 0x44c43(%rip), %rdx     # 0x55fb8
movq %r14, %rdi
callq 0x9580
movq %rax, %rbx
movq %r14, %rdi
callq 0x9270
jmp 0x113aa
jmp 0x1138c
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x113aa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9330
movq %rbx, %rdi
callq 0x95c0
// File: /workspace/github_cpp_makefile_star2_O3/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::CumulativeReporterBase::testRunEnded(Catch::TestRunStats const&)
virtual void testRunEnded( TestRunStats const& testRunStats ) {
            Ptr<TestRunNode> node = new TestRunNode( testRunStats );
            node->children.swap( m_testGroups );
            m_testRuns.push_back( node );
            testRunEndedCumulative();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x88, %edi
callq 0x9310
movq %rax, %r14
movl $0x0, 0x8(%rax)
leaq 0x438f0(%rip), %rax     # 0x55980
movq %rax, (%r14)
leaq 0x420d6(%rip), %rax     # 0x54170
movq %rax, 0x10(%r14)
leaq 0x18(%r14), %rdi
leaq 0x28(%r14), %rax
movq %rax, 0x18(%r14)
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
callq 0x2ac50
movb 0x58(%r15), %al
movb %al, 0x68(%r14)
movups 0x28(%r15), %xmm0
movups 0x38(%r15), %xmm1
movups 0x48(%r15), %xmm2
movups %xmm2, 0x58(%r14)
movups %xmm1, 0x48(%r14)
movups %xmm0, 0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%r14)
movq $0x0, 0x80(%r14)
leaq 0x8(%rsp), %r15
movq %r14, (%r15)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq 0x80(%r14), %rax
movups 0x68(%rbx), %xmm0
movq 0x78(%rbx), %rcx
movq %rcx, 0x80(%r14)
movups 0x70(%r14), %xmm1
movups %xmm0, 0x70(%r14)
movups %xmm1, 0x68(%rbx)
movq %rax, 0x78(%rbx)
leaq 0x80(%rbx), %rdi
movq %r15, %rsi
callq 0x252ca
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x80(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x12157
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x12190
movq %rax, %rbx
movl $0x88, %esi
movq %r14, %rdi
callq 0x9330
jmp 0x12188
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x12188
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0x95c0
movq %rax, %rdi
callq 0xffa7