LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/sgielen[P]clife/multicolor.cpp
// Function: MulticolorValue::print(std::ostream&) const
void print(std::ostream &os) const {
		if(value && to_ledscreen) {
			os << red << green << blue;
		} else if(value) {
			double brightness = std::max(0.3, 1 - age / 20.);

			uint8_t redval = (red * brightness) / 43;
			uint8_t greenval = (green * brightness) / 43;
			uint8_t blueval = (blue * brightness) / 43;
			uint8_t code = 16 + 36 * redval + 6 * greenval + blueval;
			os << "\x1b[38;5;" << int(code) << "mo\x1b[m";
		} else if(to_ledscreen) {
			os << '\x00' << '\x00' << '\x00';
		} else {
			os << ' ';
		}
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x1, (%rdi)
jne 0x65a9
movzbl 0x4(%rdi), %eax
cvtsi2sd %eax, %xmm0
divsd 0xbae(%rip), %xmm0      # 0x70a8
addsd 0xbae(%rip), %xmm0      # 0x70b0
maxsd 0xbae(%rip), %xmm0      # 0x70b8
movzbl 0x3(%rdi), %eax
cvtsi2sd %eax, %xmm1
mulsd %xmm0, %xmm1
divsd 0xba2(%rip), %xmm1      # 0x70c0
cvttsd2si %xmm1, %eax
movzwl 0x1(%rdi), %ecx
movd %ecx, %xmm1
pxor %xmm2, %xmm2
punpcklbw %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1],xmm1[2],xmm2[2],xmm1[3],xmm2[3],xmm1[4],xmm2[4],xmm1[5],xmm2[5],xmm1[6],xmm2[6],xmm1[7],xmm2[7]
punpcklwd %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1],xmm1[2],xmm2[2],xmm1[3],xmm2[3]
cvtdq2pd %xmm1, %xmm1
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm1, %xmm0
divpd 0xb16(%rip), %xmm0      # 0x7060
cvttpd2dq %xmm0, %xmm0
pshuflw $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3,4,5,6,7]
pmullw 0xb15(%rip), %xmm0      # 0x7070
movd %xmm0, %r14d
addl %r14d, %eax
shrl $0x10, %r14d
addb %al, %r14b
addb $0x10, %r14b
leaq 0xd69(%rip), %rsi       # 0x72de
movl $0x7, %edx
movq %rbx, %rdi
callq 0x21d0
movzbl %r14b, %esi
movq %rbx, %rdi
callq 0x22a0
leaq 0xd51(%rip), %rsi       # 0x72e6
movl $0x5, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21d0
leaq 0x7(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x21d0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/switch-st[P]SimpleThreadPool/./SimpleThreadPool.hpp
// Function: Switch::Tool::SimpleThreadPool<double>::SimpleThreadPool(unsigned int, unsigned int)
SimpleThreadPool(unsigned int max_thread_size, unsigned int max_job_size)
	{
		m_oTrdList.set_thread_func(boost::bind(&SimpleThreadPool::dispatch_thread, this));
		m_oTrdList.set_max_thread_num(max_thread_size);
		m_oJobList.set_max_job_num(max_job_size);
		m_bStopFlag = false;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %rbx
callq 0x69fe
leaq 0x28(%rbx), %r14
movq %r14, %rdi
callq 0x6a80
leaq 0x170(%rbx), %r15
movq %r15, %rdi
callq 0x6b44
leaq 0xe91(%rip), %rax       # 0x6c0e
movq %rsp, %rsi
movq %rax, 0x8(%rsi)
movq $0x0, 0x10(%rsi)
movq %rbx, 0x18(%rsi)
leaq 0xc98a(%rip), %rax      # 0x12721
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x6ba6
movq %rsp, %rdi
callq 0x6cc0
movq %r15, %rdi
movl %r12d, %esi
callq 0x6cf8
movq %r14, %rdi
movl %ebp, %esi
callq 0x6db8
movb $0x0, 0x1d8(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %rsp, %rdi
callq 0x6cc0
jmp 0x5ded
movq %rax, %r12
jmp 0x5df5
movq %rax, %r12
jmp 0x5dfd
movq %rax, %r12
movq %r15, %rdi
callq 0x6e02
movq %r14, %rdi
callq 0x6f14
movq %rbx, %rdi
callq 0x6f54
movq %r12, %rdi
callq 0x53f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/switch-st[P]SimpleThreadPool/./SimpleThreadPool.hpp
// Function: Switch::Tool::SimpleThreadPool<double>::add_job_block(Switch::Tool::SimpleJob<void> const&)
bool add_job_block(const SimpleJob< void >& job)
	{
		m_oJobList.lock_add_job();
		m_oJobList.wait_add_job();
		if (m_bStopFlag)
		{
			m_oJobList.unlock_add_job();
			return false;
		}
		bool ret = m_oJobList.push_back(job);
		m_oJobList.unlock_add_job();
		if (ret)
		{
			m_oJobList.notify_one_get_job();
		}

		return ret;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rdi), %r12
leaq 0x68(%rdi), %r14
movq %r14, %rdi
callq 0x781a
movq %r12, %rdi
callq 0x9436
cmpb $0x1, 0x1d8(%rbx)
jne 0x5f47
movq %r14, %rdi
callq 0x7dec
jmp 0x5f74
movq %r12, %rdi
movq %r15, %rsi
callq 0x946c
movl %eax, %ebp
movq %r14, %rdi
callq 0x7dec
testb %bpl, %bpl
je 0x5f74
addq $0x110, %rbx            # imm = 0x110
movq %rbx, %rdi
callq 0x95da
movb $0x1, %al
jmp 0x5f76
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/switch-st[P]SimpleThreadPool/./SimpleThreadPool.hpp
// Function: Switch::Tool::SimpleThreadPool<float>::SetMaxPoolSize(unsigned int)
int SetMaxPoolSize(unsigned int size)
	{
        m_TMutex.lock();
        if (size > m_nMaxPoolSize || size >= m_lpThread.size())
        {
            m_nMaxPoolSize = size;
            m_TMutex.unlock();
            return 0;
        }
        m_TMutex.unlock();

        return -1;
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0x781a
cmpl %ebp, 0x48(%rbx)
jb 0x6051
movl %ebp, %eax
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmpq %rax, 0x38(%rbx)
ja 0x6057
movl %ebp, 0x48(%rbx)
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x7dec
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/switch-st[P]SimpleThreadPool/./SimpleThreadPool.hpp
// Function: int Switch::Tool::SimpleThreadPool<float>::AddThread<boost::_bi::bind_t<double, double (*)(void*), boost::_bi::list1<boost::_bi::value<void*>>>>(boost::_bi::bind_t<double, double (*)(void*), boost::_bi::list1<boost::_bi::value<void*>>>)
int	AddThread(T func)
	{
	    m_TMutex.lock();
		if (m_lpThread.size() >= m_nMaxPoolSize) {
            m_TMutex.unlock();
			return -1;
		}

        m_lpThread.push_back(new boost::thread(func));
        m_TMutex.unlock();

		return 0;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsi, (%rsp)
movq %rdx, 0x8(%rsp)
callq 0x781a
movl 0x48(%rbx), %eax
cmpq %rax, 0x38(%rbx)
jae 0x60d0
movl $0x10, %edi
callq 0x5250
movq %rax, %r14
movq %rsp, %rsi
movq %rax, %rdi
callq 0xac52
leaq 0x28(%rbx), %r15
movl $0x18, %edi
callq 0x5250
movq %r14, 0x10(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x5050
incq 0x38(%rbx)
movq %rbx, %rdi
callq 0x7dec
xorl %eax, %eax
jmp 0x60dd
movq %rbx, %rdi
callq 0x7dec
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x53f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/switch-st[P]SimpleThreadPool/./SimpleThreadPool.hpp
// Function: Switch::Tool::SimpleThreadPool<float>::~SimpleThreadPool()
~SimpleThreadPool(void)
	{
	    m_pJoinThread->interrupt();
	    m_pJoinThread->join();
	    delete m_pJoinThread;

        StopThreadPool();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
callq 0x5300
movq 0x40(%rbx), %r14
movq %r14, %rdi
callq 0x5070
movq %rax, %r15
callq 0x5220
cmpq %r15, %rax
je 0x62f3
movq %r14, %rdi
callq 0x52f0
movq 0x40(%rbx), %r14
testq %r14, %r14
je 0x62ab
movq %r14, %rdi
callq 0x9418
movl $0x10, %esi
movq %r14, %rdi
callq 0x5270
movq %rbx, %rdi
callq 0x6196
leaq 0x28(%rbx), %r14
movq 0x28(%rbx), %rdi
cmpq %r14, %rdi
je 0x62e2
movq (%rdi), %r15
movl $0x18, %esi
callq 0x5270
movq %r15, %rdi
cmpq %r14, %r15
jne 0x62cd
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x6f54
leaq 0x64c6(%rip), %rsi      # 0xc7c0
movq %rsp, %rdi
callq 0x5420
movabsq $0x100000023, %rax      # imm = 0x100000023
leaq 0x30(%rsp), %rcx
movq %rax, -0x20(%rcx)
leaq 0xbf5c(%rip), %rax      # 0x12278
movq %rax, -0x18(%rcx)
movq %rcx, -0x10(%rcx)
movq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
leaq 0xc0a2(%rip), %rax      # 0x123d8
movq %rax, -0x30(%rcx)
movq %rsp, %rdi
callq 0x6f8a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6444
jmp 0x635a
movq %rax, %rdi
callq 0x5c48
movq %rax, %rbx
movq %rbx, %rdi
callq 0x5c48
// File: /workspace/github_cpp_makefile_star2_O3/switch-st[P]SimpleThreadPool/./SimpleThreadPool.hpp
// Function: Switch::Tool::SimpleThreadPool<double>::dispatch_thread()
void dispatch_thread(void)
	{
		SimpleJob< void > job;

		while (1)
		{
			m_oJobList.lock_get_job();
			m_oJobList.wait_get_job();
			if (m_bStopFlag)
			{
				m_oJobList.unlock_get_job();
				return;
			}
			m_oJobList.pop_front(job);
			m_oJobList.unlock_get_job();
			m_oJobList.notify_all_add_job();
			job.CallJob();
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x7e22
leaq 0x28(%rbx), %r12
leaq 0xe8(%rbx), %r15
leaq 0x90(%rbx), %r13
movq %r15, %rdi
callq 0x781a
movq %r12, %rdi
callq 0x7e54
cmpb $0x1, 0x1d8(%rbx)
je 0x6c79
movq %r12, %rdi
movq %r14, %rsi
callq 0x7e90
movq %r15, %rdi
callq 0x7dec
movq %r13, %rdi
callq 0x86fa
movq %r14, %rdi
callq 0x7f14
jmp 0x6c3b
movq %r15, %rdi
callq 0x7dec
leaq 0x20(%rsp), %rdi
callq 0x6f54
movq %rsp, %rdi
callq 0x6cc0
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x6ca3
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6f54
movq %rsp, %rdi
callq 0x6cc0
movq %rbx, %rdi
callq 0x53f0
// File: /workspace/github_cpp_makefile_star2_O3/switch-st[P]SimpleThreadPool/./SimpleThreadList.hpp
// Function: Switch::Tool::SimpleThreadList::set_max_thread_num(unsigned int)
bool set_max_thread_num(unsigned int max)
    {
        boost::lock_guard< boost::mutex > guard(m_oMutex);

        if (m_bStopFlag || max <= m_nMaxThreadNum)
        {
            return false;
        }

        for (unsigned int i = m_nMaxThreadNum; i < max; ++i)
        {
            m_lpThread.push_back(new boost::thread(m_oFunc));
        }
        m_nMaxThreadNum = max;

        return true;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x781a
cmpb $0x0, 0x64(%r14)
jne 0x6d6e
movl 0x60(%r14), %r13d
cmpl %ebp, %r13d
jae 0x6d6e
leaq 0x40(%r14), %r15
movl $0x10, %edi
callq 0x5250
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x8c44
movl $0x18, %edi
callq 0x5250
movq %r12, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x5050
incq 0x10(%r14)
incl %r13d
cmpl %r13d, %ebp
jne 0x6d28
movl %ebp, 0x60(%r14)
movb $0x1, %bpl
jmp 0x6d70
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x7dec
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6db0
movq %rax, %r14
movl $0x10, %esi
movq %r12, %rdi
callq 0x5270
jmp 0x6da0
movq %rax, %r14
movq %rbx, %rdi
callq 0x7dec
movq %r14, %rdi
callq 0x53f0
movq %rax, %rdi
callq 0x5c48
// File: /workspace/github_cpp_makefile_star2_O3/switch-st[P]SimpleThreadPool/./SimpleJob.hpp
// Function: Switch::Tool::SimpleJobList::set_max_job_num(unsigned int)
bool set_max_job_num(unsigned int max)
    {
        boost::lock_guard< boost::mutex > guard(m_oMutex);

        if (max <= m_nMaxJobNum)
        {
            return false;
        }
        m_nMaxJobNum = max;

        return true;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
leaq 0x18(%rdi), %r14
movq %r14, %rdi
callq 0x781a
movl 0x140(%r15), %ebp
cmpl %ebx, %ebp
jae 0x6de2
movl %ebx, 0x140(%r15)
movq %r14, %rdi
callq 0x7dec
cmpl %ebx, %ebp
setb %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x5c48
// File: /workspace/github_cpp_makefile_star2_O3/switch-st[P]SimpleThreadPool/./SimpleThreadList.hpp
// Function: Switch::Tool::SimpleThreadList::~SimpleThreadList()
~SimpleThreadList(void)
    {
    	iterator iter, end;
    	end = m_lpThread.end();
    	for (iter = m_lpThread.begin(); iter != end; ++iter)
		{
			(*iter)->join();
			delete (*iter);
		}
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq (%rdi), %r12
cmpq %rdi, %r12
je 0x6e62
movq 0x10(%r12), %r14
movq %r14, %rdi
callq 0x5070
movq %rax, %r15
callq 0x5220
cmpq %r15, %rax
je 0x6e9d
movq %r14, %rdi
callq 0x52f0
movq 0x10(%r12), %r14
testq %r14, %r14
je 0x6e4c
movq %r14, %rdi
callq 0x9418
movl $0x10, %esi
movq %r14, %rdi
callq 0x5270
movq (%r12), %r12
cmpq %rbx, %r12
jne 0x6e18
leaq 0x40(%rbx), %rdi
callq 0x6cc0
leaq 0x18(%rbx), %rdi
callq 0x6f54
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x6e91
movq (%rdi), %r14
movl $0x18, %esi
callq 0x5270
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x6e7c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x591c(%rip), %rsi      # 0xc7c0
leaq 0x8(%rsp), %rdi
callq 0x5420
movabsq $0x100000023, %rax      # imm = 0x100000023
leaq 0x38(%rsp), %rcx
movq %rax, -0x20(%rcx)
leaq 0xb3b0(%rip), %rax      # 0x12278
movq %rax, -0x18(%rcx)
movq %rcx, -0x10(%rcx)
movq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
leaq 0xb4f6(%rip), %rax      # 0x123d8
movq %rax, -0x30(%rcx)
leaq 0x8(%rsp), %rdi
callq 0x6f8a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6444
jmp 0x6f0c
jmp 0x6f09
movq %rax, %rdi
callq 0x5c48
movq %rax, %rbx
movq %rbx, %rdi
callq 0x5c48
// File: /workspace/github_cpp_makefile_star2_O3/switch-st[P]SimpleThreadPool/./SimpleJob.hpp
// Function: Switch::Tool::SimpleJobList::pop_front(Switch::Tool::SimpleJob<void>&)
bool pop_front(SimpleJob< void >& job)
    {
		boost::lock_guard< boost::mutex > guard(m_oMutex);

		if (!m_bStopFlag || m_lJobList.size() > 0)
		{
			job = m_lJobList.front();
			m_lJobList.pop_front();

			return true;
		}

		return false;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x781a
cmpq $0x0, 0x10(%r14)
sete %bpl
andb 0x144(%r14), %bpl
jne 0x7ee0
movq (%r14), %r12
leaq 0x10(%r12), %rsi
movq %r15, %rdi
callq 0x77a4
movl 0x58(%r12), %eax
movl %eax, 0x48(%r15)
movq (%r14), %rsi
movq %r14, %rdi
callq 0x86be
movq %rbx, %rdi
callq 0x7dec
xorb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7dec
movq %r14, %rdi
callq 0x53f0
jmp 0x7f0c
movq %rax, %rdi
callq 0x5c48
// File: /workspace/github_cpp_makefile_star2_O3/switch-st[P]SimpleThreadPool/./SimpleJob.hpp
// Function: Switch::Tool::SimpleJob<void>::CallJob()
void CallJob(void)
    {
        m_oMutex.lock();
        m_eStat = SJS_CALL;
        m_oMutex.unlock();

        m_oFunc();

        m_oMutex.lock();
        m_eStat = SJS_DONE;
        m_oMutex.unlock();
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x781a
movl $0x2, 0x48(%rbx)
movq %r14, %rdi
callq 0x7dec
movq %rbx, %rdi
callq 0x87d6
movq %r14, %rdi
callq 0x781a
movl $0x3, 0x48(%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7dec
// File: /workspace/github_cpp_makefile_star2_O3/switch-st[P]SimpleThreadPool/./SimpleJob.hpp
// Function: Switch::Tool::SimpleJobList::push_back(Switch::Tool::SimpleJob<void> const&)
bool push_back(const SimpleJob< void >& job)
    {
        boost::lock_guard< boost::mutex > guard(m_oMutex);

        if (m_bStopFlag || m_lJobList.size() >= m_nMaxJobNum)
        {
            return false;
        }

        m_lJobList.push_back(job);

        return true;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x781a
cmpb $0x0, 0x144(%r14)
jne 0x94bb
movl 0x140(%r14), %eax
cmpq %rax, 0x10(%r14)
jae 0x94bb
movq %r14, %rdi
movq %r15, %rsi
callq 0x9540
movq %rax, %rdi
movq %r14, %rsi
callq 0x5050
incq 0x10(%r14)
movb $0x1, %bpl
jmp 0x94bd
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x7dec
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7dec
movq %r14, %rdi
callq 0x53f0
jmp 0x94e7
movq %rax, %rdi
callq 0x5c48
nop
// File: /workspace/github_cpp_makefile_star2_O3/switch-st[P]SimpleThreadPool/./SimpleJob.hpp
// Function: Switch::Tool::SimpleJobList::stop()
void stop(void)
    {
    	boost::lock_guard< boost::mutex > guard(m_oMutex);
    	m_bStopFlag = true;
		notify_all_add_job();
		notify_all_get_job();
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq %r14, %rdi
callq 0x781a
movb $0x1, 0x144(%rbx)
leaq 0x68(%rbx), %rdi
callq 0x86fa
addq $0xe8, %rbx
movq %rbx, %rdi
callq 0x86fa
movq %r14, %rdi
callq 0x7dec
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x5c48
// File: /workspace/github_cpp_makefile_star2_O3/switch-st[P]SimpleThreadPool/./SimpleThreadList.hpp
// Function: Switch::Tool::SimpleThreadList::stop()
void stop(void)
    {
    	boost::lock_guard< boost::mutex > guard(m_oMutex);
    	m_bStopFlag = true;

    	iterator iter, end;
    	end = m_lpThread.end();
    	for (iter = m_lpThread.begin(); iter != end; ++iter)
		{
			(*iter)->join();
			delete (*iter);
		}
		m_lpThread.clear();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x781a
movb $0x1, 0x64(%r14)
movq (%r14), %r13
cmpq %r14, %r13
je 0x96ea
movq 0x10(%r13), %r15
movq %r15, %rdi
callq 0x5070
movq %rax, %r12
callq 0x5220
cmpq %r12, %rax
je 0x9708
movq %r15, %rdi
callq 0x52f0
movq 0x10(%r13), %r15
testq %r15, %r15
je 0x96d7
movq %r15, %rdi
callq 0x9418
movl $0x10, %esi
movq %r15, %rdi
callq 0x5270
movq (%r13), %r13
jmp 0x96a0
movq %r14, %rdi
callq 0x9786
movq %rbx, %rdi
callq 0x7dec
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x30b1(%rip), %rsi      # 0xc7c0
movq %rsp, %rdi
callq 0x5420
movabsq $0x100000023, %rax      # imm = 0x100000023
leaq 0x30(%rsp), %rcx
movq %rax, -0x20(%rcx)
leaq 0x8b47(%rip), %rax      # 0x12278
movq %rax, -0x18(%rcx)
movq %rcx, -0x10(%rcx)
movq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
leaq 0x8c8d(%rip), %rax      # 0x123d8
movq %rax, -0x30(%rcx)
movq %rsp, %rdi
callq 0x6f8a
jmp 0x977d
movq %rax, %r14
movq %rsp, %rdi
callq 0x6444
jmp 0x976d
jmp 0x976a
jmp 0x977d
movq %rax, %r14
movq %rbx, %rdi
callq 0x7dec
movq %r14, %rdi
callq 0x53f0
movq %rax, %rdi
callq 0x5c48
nop
// File: /workspace/github_cpp_makefile_star2_O3/switch-st[P]SimpleThreadPool/./SimpleThreadPool.hpp
// Function: Switch::Tool::SimpleThreadPool<float>::ThreadJoin()
void ThreadJoin(void)
    {
        std::list< boost::thread* >::iterator iter, end;

        while(1)
        {
            m_TMutex.lock();
            end = m_lpThread.end();
            for (iter = m_lpThread.begin(); iter != end;)
            {
                if ((*iter)->timed_join(boost::posix_time::microseconds(1)))
                {
                    boost::thread* p = *iter;
                    iter = m_lpThread.erase(iter);
                    delete p;
                }
                else
                {
                    ++iter;
                }
            }
            m_TMutex.unlock();

            boost::this_thread::sleep(boost::posix_time::milliseconds(1));
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x28(%rdi), %r13
movq %rsp, %r14
movq %rbx, %rdi
callq 0x781a
movq 0x28(%rbx), %r15
cmpq %r13, %r15
je 0x9847
movq 0x10(%r15), %rdi
movq $0x1, (%rsp)
movq %r14, %rsi
callq 0x98fe
testb %al, %al
je 0x983c
movq (%r15), %rbp
movq 0x10(%r15), %r12
decq 0x38(%rbx)
movq %r15, %rdi
callq 0x53b0
movl $0x18, %esi
movq %r15, %rdi
callq 0x5270
testq %r12, %r12
je 0x982d
movq %r12, %rdi
callq 0x9418
movl $0x10, %esi
movq %r12, %rdi
callq 0x5270
jmp 0x983f
movq (%r15), %rbp
movq %rbp, %r15
cmpq %r13, %rbp
jne 0x97e8
movq %rbx, %rdi
callq 0x7dec
movq $0x3e8, (%rsp)          # imm = 0x3E8
movq %r14, %rdi
callq 0x9a2b
jmp 0x97d7
// File: /workspace/github_cpp_makefile_star2_O3/t0mm4rx[P]piscine_cpp/day04/ex03/Character.cpp
// Function: Character::Character(Character const&)
Character::Character(const Character &other):
	name(other.name), equipped(0)
{
	for (int i = 0; i < other.equipped; i++)
		this->equip(other.inventory[i]->clone());
	for (int i = this->equipped; i < 4; i++)
		this->inventory[i] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x36fb(%rip), %rax      # 0x5c78
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
leaq 0x18(%rdi), %r12
movq %r12, 0x8(%rdi)
movq 0x8(%rsi), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x247a
movl $0x0, 0x28(%rbx)
cmpl $0x0, 0x28(%r15)
jle 0x25ea
xorl %r13d, %r13d
movq 0x30(%r15,%r13,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x18(%rcx)
incq %r13
movslq 0x28(%r15), %rax
cmpq %rax, %r13
jl 0x25b0
movl 0x28(%rbx), %eax
cmpl $0x3, %eax
jle 0x25ec
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
cltq
leaq (%rbx,%rax,8), %rdi
addq $0x30, %rdi
movl $0x3, %ecx
subl %eax, %ecx
leaq 0x8(,%rcx,8), %rdx
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2050
movq %rax, %rbx
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x2631
movq (%r12), %rsi
incq %rsi
callq 0x20d0
movq %rbx, %rdi
callq 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O3/t0mm4rx[P]piscine_cpp/day04/ex03/Character.cpp
// Function: Character::operator=(Character const&)
Character &Character::operator=(const Character &other)
{
	this->name = other.name;
	for (int i = 0; i < this->equipped; i++)
		delete this->inventory[i];
	this->equipped = 0;
	for (int i = 0; i < other.equipped; i++)
		this->equip(other.inventory[i]->clone());
	for (int i = this->equipped; i < 4; i++)
		this->inventory[i] = 0;
	return (*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x2040
movl 0x28(%rbx), %eax
testl %eax, %eax
jle 0x26ff
xorl %r15d, %r15d
movq 0x30(%rbx,%r15,8), %rdi
testq %rdi, %rdi
je 0x26f4
movq (%rdi), %rax
callq *0x8(%rax)
movl 0x28(%rbx), %eax
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0x26e1
movl $0x0, 0x28(%rbx)
cmpl $0x0, 0x28(%r14)
jle 0x273d
xorl %r15d, %r15d
movq 0x30(%r14,%r15,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x18(%rcx)
incq %r15
movslq 0x28(%r14), %rax
cmpq %rax, %r15
jl 0x2710
movl 0x28(%rbx), %eax
cmpl $0x3, %eax
jle 0x273f
jmp 0x275f
xorl %eax, %eax
cltq
leaq (%rbx,%rax,8), %rdi
addq $0x30, %rdi
movl $0x3, %ecx
subl %eax, %ecx
leaq 0x8(,%rcx,8), %rdx
xorl %esi, %esi
callq 0x2050
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/t0mm4rx[P]piscine_cpp/day04/ex03/Character.cpp
// Function: Character::equip(AMateria*)
void Character::equip(AMateria *m)
{
	if (m == 0)
		return ;
	if (this->equipped == 4)
		return ;
	for (int i = 0; i < this->equipped; i++)
	{
		if (this->inventory[i] == m)
			return ;
	}
	this->inventory[this->equipped++] = m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
je 0x27ac
movl 0x28(%rdi), %eax
cmpq $0x4, %rax
je 0x27ac
testl %eax, %eax
jle 0x279f
xorl %ecx, %ecx
cmpq %rsi, 0x30(%rdi,%rcx,8)
je 0x27ac
incq %rcx
cmpq %rcx, %rax
jne 0x2790
cltq
leal 0x1(%rax), %ecx
movl %ecx, 0x28(%rdi)
movq %rsi, 0x30(%rdi,%rax,8)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/t0mm4rx[P]piscine_cpp/day04/ex03/Character.cpp
// Function: Character::unequip(int)
void Character::unequip(int idx)
{
	if (idx < 0 || idx >= this->equipped || this->inventory[idx] == 0)
		return ;
	for (int i = idx; i < 3; i++)
	{
		this->inventory[i] = this->inventory[i + 1];
		this->inventory[i + 1] = 0;
	}
	this->equipped--;
}

// Assembly:
testl %esi, %esi
js 0x27f5
movl 0x28(%rdi), %eax
cmpl %esi, %eax
jle 0x27f5
movl %esi, %ecx
cmpq $0x0, 0x30(%rdi,%rcx,8)
je 0x27f5
cmpl $0x2, %esi
ja 0x27f0
pushq %rbp
movq %rsp, %rbp
decl %esi
leaq (%rdi,%rcx,8), %rcx
addq $0x38, %rcx
movq (%rcx), %rdx
movq %rdx, -0x8(%rcx)
movq $0x0, (%rcx)
incl %esi
addq $0x8, %rcx
cmpl $0x2, %esi
jl 0x27d6
popq %rbp
decl %eax
movl %eax, 0x28(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/t0mm4rx[P]piscine_cpp/day04/ex03/MateriaSource.cpp
// Function: MateriaSource::MateriaSource(MateriaSource const&)
MateriaSource::MateriaSource(const MateriaSource &other):
	current(0)
{
	for (int i = 0; i < other.current; i++)
		this->learnMateria(other.sources[i]->clone());
	for (int i = 0; i < 4; i++)
		this->sources[i] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x303a(%rip), %rax      # 0x5d70
movq %rax, (%rdi)
movl $0x0, 0x8(%rdi)
cmpl $0x0, 0x8(%rsi)
jle 0x2d6f
movq %rsi, %r14
xorl %r15d, %r15d
movq 0x10(%r14,%r15,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
incq %r15
movslq 0x8(%r14), %rax
cmpq %rax, %r15
jl 0x2d4c
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/t0mm4rx[P]piscine_cpp/day04/ex03/MateriaSource.cpp
// Function: MateriaSource::operator=(MateriaSource const&)
MateriaSource &MateriaSource::operator=(const MateriaSource &other)
{
	for (int i = 0; i < this->current; i++)
		delete this->sources[i];
	this->current = 0;
	for (int i = 0; i < other.current; i++)
		this->learnMateria(other.sources[i]->clone());
	for (int i = 0; i < 4; i++)
		this->sources[i] = 0;
	return (*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %eax
testl %eax, %eax
jle 0x2e4e
xorl %r15d, %r15d
movq 0x10(%rbx,%r15,8), %rdi
testq %rdi, %rdi
je 0x2e43
movq (%rdi), %rax
callq *0x8(%rax)
movl 0x8(%rbx), %eax
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0x2e30
movl $0x0, 0x8(%rbx)
cmpl $0x0, 0x8(%r14)
jle 0x2e82
xorl %r15d, %r15d
movq 0x10(%r14,%r15,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
incq %r15
movslq 0x8(%r14), %rax
cmpq %rax, %r15
jl 0x2e5f
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/t0mm4rx[P]piscine_cpp/day04/ex03/MateriaSource.cpp
// Function: MateriaSource::learnMateria(AMateria*)
void MateriaSource::learnMateria(AMateria *m)
{
	if (this->current  == 4 || m == 0)
		return ;
	for (int i = 0; i < this->current; i++)
	{
		if (this->sources[i] == m)
			return ;
	}
	this->sources[this->current++] = m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x8(%rdi), %eax
cmpq $0x4, %rax
sete %cl
testq %rsi, %rsi
sete %dl
orb %cl, %dl
jne 0x2ed6
testl %eax, %eax
jle 0x2ec9
xorl %ecx, %ecx
cmpq %rsi, 0x10(%rdi,%rcx,8)
je 0x2ed6
incq %rcx
cmpq %rcx, %rax
jne 0x2eba
cltq
leal 0x1(%rax), %ecx
movl %ecx, 0x8(%rdi)
movq %rsi, 0x10(%rdi,%rax,8)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/t0mm4rx[P]piscine_cpp/day04/ex03/MateriaSource.cpp
// Function: MateriaSource::createMateria(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
AMateria* MateriaSource::createMateria(const std::string &type)
{
	for (int i = 0; i < this->current; i++)
	{
		if (this->sources[i]->getType() == type)
			return (this->sources[i]->clone());
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0x8(%rdi)
jle 0x2f25
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0x10(%rbx,%r15,8), %rdi
callq 0x2434
movq 0x8(%rax), %rdx
cmpq 0x8(%r14), %rdx
jne 0x2f19
testq %rdx, %rdx
je 0x2f32
movq (%r14), %rsi
movq (%rax), %rdi
callq 0x20e0
testl %eax, %eax
je 0x2f32
incq %r15
movslq 0x8(%rbx), %rax
cmpq %rax, %r15
jl 0x2ef1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rbx,%r15,8), %rdi
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *0x10(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O3/Windfisch[P]production-flow/factory.cpp
// Function: Factory::collect_relevant_facilities(item_t) const
vector<size_t> Factory::collect_relevant_facilities(item_t item) const
{
	vector<size_t> relevant_facilities;

	for (size_t facility_id = 0; facility_id < facilities.size(); facility_id++)
	{
		const auto& facility = facilities[facility_id];

		if (facility.items.find(item) != facility.items.end())
		{
			relevant_facilities.push_back(facility_id);
		}
		#ifndef NDEBUG
		else // assert that there is no `item`-edge from or to that facility
		{
			for (const auto& transport_line : transport_lines)
				if (transport_line.item_type == item)
					assert(transport_line.from != facility_id
						&& transport_line.to != facility_id);
		}
		#endif
	}
	
	return relevant_facilities;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rax, 0x8(%rsp)
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
cmpq %rax, %rcx
je 0x5241
movl %edx, %ebp
movq %rsi, %r14
xorl %edx, %edx
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
leaq 0x8(%rsp), %r15
leaq (%rdx,%rdx,4), %rdi
shlq $0x4, %rdi
movq 0x30(%rax,%rdi), %rsi
testq %rsi, %rsi
je 0x51d1
leaq (%rax,%rdi), %r8
addq $0x28, %r8
movq %r8, %rdi
xorl %r9d, %r9d
cmpl %ebp, 0x20(%rsi)
setl %r9b
cmovgeq %rsi, %rdi
movq 0x10(%rsi,%r9,8), %rsi
testq %rsi, %rsi
jne 0x51af
cmpq %r8, %rdi
je 0x51d1
cmpl %ebp, 0x20(%rdi)
jle 0x51f4
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rdi
cmpq %rdi, %rsi
je 0x521d
cmpl %ebp, (%rsi)
jne 0x51ee
cmpq %rdx, 0x8(%rsi)
je 0x5251
cmpq %rdx, 0x10(%rsi)
je 0x5251
addq $0x30, %rsi
jmp 0x51d9
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x520b
movq %rdx, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x521d
movq %rbx, %rdi
movq %r15, %rdx
callq 0x6b84
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq 0x8(%rsp), %rdx
incq %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x4, %rsi
imulq %r12, %rsi
cmpq %rsi, %rdx
jb 0x5192
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa031(%rip), %rdi      # 0xf289
leaq 0xa071(%rip), %rsi      # 0xf2d0
leaq 0xa076(%rip), %rcx      # 0xf2dc
movl $0x2d, %edx
callq 0x3180
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5287
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x3250
movq %r14, %rdi
callq 0x3400
nop
// File: /workspace/github_cpp_makefile_star2_O3/Windfisch[P]production-flow/factory.cpp
// Function: Factory::build_facility_itemset()
void Factory::build_facility_itemset()
{
	for (const auto& tl : transport_lines)
	{
		facilities[tl.from].items.insert(tl.item_type);
		facilities[tl.to].items.insert(tl.item_type);
	}

	for (auto& fac : facilities)
		fac.most_advanced_item_involved = *fac.items.rbegin();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movq 0x20(%rdi), %r15
cmpq %r15, %r14
je 0x5303
movq 0x8(%r14), %rax
movq (%rbx), %rcx
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%rcx,%rax), %rdi
addq $0x20, %rdi
movq %r14, %rsi
callq 0x67ba
movq 0x10(%r14), %rax
movq (%rbx), %rcx
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%rcx,%rax), %rdi
addq $0x20, %rdi
movq %r14, %rsi
callq 0x67ba
addq $0x30, %r14
jmp 0x52ba
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
cmpq %rbx, %r14
je 0x5332
addq $0x28, %r14
movq %r14, %rdi
callq 0x3170
movl 0x20(%rax), %eax
movl %eax, -0x10(%r14)
leaq 0x50(%r14), %rax
addq $0x28, %r14
cmpq %rbx, %r14
movq %rax, %r14
jne 0x5313
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Windfisch[P]production-flow/factory.cpp
// Function: Factory::build_edge_table()
void Factory::build_edge_table()
{
	edge_table_per_item.resize(MAX_ITEM);
	edge_table_per_item_inv.resize(MAX_ITEM);

	for (size_t item = 0; item < MAX_ITEM; item++)
	{
		edge_table_per_item[item].clear();
		edge_table_per_item_inv[item].resize(transport_lines.size());

		for (size_t i = 0; i < transport_lines.size(); i++)
			if (transport_lines[i].item_type == item)
			{
				edge_table_per_item[item].push_back(i);
				edge_table_per_item_inv[item][i] = edge_table_per_item[item].size()-1;
			}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x60(%rdi), %r14
movl $0xb, %esi
movq %r14, %rdi
callq 0x61a6
leaq 0x78(%rbx), %r15
movl $0xb, %esi
movq %r15, %rdi
callq 0x61a6
xorl %r13d, %r13d
movabsq $-0x5555555555555555, %rbp # imm = 0xAAAAAAAAAAAAAAAB
movq (%r14), %rax
leaq (,%r13,2), %r12
addq %r13, %r12
movq (%rax,%r12,8), %rcx
cmpq %rcx, 0x8(%rax,%r12,8)
je 0x57a8
leaq (%rax,%r12,8), %rax
movq %rcx, 0x8(%rax)
leaq (,%r12,8), %rdi
addq 0x78(%rbx), %rdi
movq 0x20(%rbx), %rsi
subq 0x18(%rbx), %rsi
sarq $0x4, %rsi
imulq %rbp, %rsi
callq 0x61e2
movq $0x0, (%rsp)
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
cmpq %rax, %rcx
je 0x5874
xorl %edx, %edx
leaq (%rdx,%rdx,2), %rsi
shlq $0x4, %rsi
movslq (%rax,%rsi), %rsi
cmpq %rsi, %r13
jne 0x5856
movq (%r14), %r8
leaq (%r8,%r12,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x5813
movq %rdx, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x582c
movq %rsp, %rdx
callq 0x6b84
movq 0x60(%rbx), %r8
movq 0x8(%r8,%r12,8), %rsi
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
leaq (,%r13,8), %rdx
leaq (%rdx,%rdx,2), %rdx
subq (%r8,%rdx), %rsi
sarq $0x3, %rsi
decq %rsi
movq (%r15), %rdi
movq (%rsp), %r8
movq (%rdi,%rdx), %rdx
movq %rsi, (%rdx,%r8,8)
movq (%rsp), %rdx
incq %rdx
movq %rdx, (%rsp)
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x4, %rsi
imulq %rbp, %rsi
cmpq %rsi, %rdx
jb 0x57e4
incq %r13
cmpq $0xb, %r13
jne 0x5787
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Windfisch[P]production-flow/flowgraph.cpp
// Function: FlowGraph::Node::update_backward()
void FlowGraph::Node::update_backward()
{
	if (excess <= 0)
		return;

	int amount = incoming() - excess;

	multimap<int, Edge*> sorted_edges;
	for (Edge* edge : incoming_edges)
		sorted_edges.insert( std::pair<int, Edge*>(edge->actual_flow, edge) );

	size_t edges_remaining = sorted_edges.size();
	int amount_remaining = amount;

	for (auto& it : sorted_edges)
	{
		Edge* edge = it.second;
		auto capacity = it.first;

		int fair_share = amount_remaining / edges_remaining; // beware: integer division
		if (fair_share < capacity)
			edge->actual_capacity = fair_share;
		else
		{
			edge->actual_capacity = capacity; // set edge flow to maximum possible value
			amount_remaining -= capacity; // the remaining amount must now be shared over even less edges
			edges_remaining--;
		}

		assert(amount_remaining >= 0);
	}

	assert(edges_remaining > 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl 0x8(%rdi), %eax
testl %eax, %eax
jle 0x7b7c
movq 0x10(%rdi), %r13
movq 0x18(%rdi), %rbp
cmpq %rbp, %r13
je 0x7baa
xorl %ebx, %ebx
movq %r13, %rcx
movq (%rcx), %rdx
addl 0x8(%rdx), %ebx
addq $0x8, %rcx
cmpq %rbp, %rcx
jne 0x7ab1
xorl %ecx, %ecx
leaq 0x20(%rsp), %r12
movl $0x0, (%r12)
movq %rcx, 0x8(%r12)
movq %r12, 0x10(%r12)
movq %r12, 0x18(%r12)
movq %rcx, 0x20(%r12)
cmpq %rbp, %r13
je 0x7bc7
subl %eax, %ebx
leaq 0x18(%rsp), %r14
leaq 0x8(%rsp), %r15
movq (%r13), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x9aec
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x7af8
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %r14
cmpq %r12, %rdi
je 0x7b6d
movq 0x28(%rdi), %rsi
movl 0x20(%rdi), %ecx
movslq %ebx, %rbx
movq %rbx, %rax
xorl %edx, %edx
divq %r14
cmpl %eax, %ecx
movl %eax, %edx
cmovll %ecx, %edx
movl $0x0, %r8d
cmovlel %ecx, %r8d
subl %r8d, %ebx
movl %edx, 0x4(%rsi)
js 0x7b8b
xorl %edx, %edx
cmpl %eax, %ecx
setle %dl
subq %rdx, %r14
callq 0x31b0
movq %rax, %rdi
cmpq %r12, %rax
jne 0x7b2b
testq %r14, %r14
je 0x7bc7
leaq 0x18(%rsp), %rdi
callq 0x9a9c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7997(%rip), %rdi      # 0xf529
leaq 0x79a6(%rip), %rsi      # 0xf53f
leaq 0x79d4(%rip), %rcx      # 0xf574
movl $0x78, %edx
callq 0x3180
leaq 0x20(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x79ce(%rip), %rdi      # 0xf59c
leaq 0x796a(%rip), %rsi      # 0xf53f
leaq 0x7998(%rip), %rcx      # 0xf574
movl $0x7b, %edx
callq 0x3180
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x9a9c
movq %rbx, %rdi
callq 0x3400
nop
// File: /workspace/github_cpp_makefile_star2_O3/Windfisch[P]production-flow/flowgraph.cpp
// Function: FlowGraph::calculate()
void FlowGraph::calculate()
{
	//dump("initial");
	bool done;
	int i = 0;
	do
	{
		for (auto& node : nodes)
			node.update_forward();

		//dump("it"+to_string(i));

		for (auto& node : nodes)
			node.update_backward();

		done = true;
		for (auto& node : nodes)
			if (node.excess > 0)
				done = false;

		//dump("it"+to_string(i)+".5");
		i++;
	} while(!done);
	dump("FINAL");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r15
cmpq %r15, %r14
je 0x7c2c
movq %r14, %rdi
callq 0x78f8
addq $0x40, %r14
cmpq %r15, %r14
jne 0x7c14
movq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x7c49
movq %r14, %rdi
callq 0x7a82
addq $0x40, %r14
cmpq %r15, %r14
jne 0x7c31
movq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x7c69
movb $0x1, %al
movq %r14, %rcx
cmpl $0x0, 0x8(%rcx)
setle %dl
andb %dl, %al
addq $0x40, %rcx
cmpq %r15, %rcx
jne 0x7c53
testb %al, %al
je 0x7c0f
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7937(%rip), %rsi      # 0xf5b0
leaq 0x7935(%rip), %rdx      # 0xf5b5
movq %rsp, %r14
movq %r14, %rdi
callq 0x4f96
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7cd8
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x7cac
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3250
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x7ccf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3250
movq %rbx, %rdi
callq 0x3400
nop
// File: /workspace/github_cpp_makefile_star2_O3/Windfisch[P]production-flow/flowgraph.cpp
// Function: FlowGraph::edge_from(FlowGraph::Edge const*) const
size_t FlowGraph::edge_from(const Edge* edge) const
{
	for (size_t i=0; i<nodes.size(); i++)
	{
		for (const Edge* e : nodes[i].outgoing_edges)
			if (e == edge)
				return i;
	}

	throw runtime_error("FlowGraph is corrupt");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
je 0x98cb
sarq $0x6, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %eax, %eax
movq %rax, %r8
shlq $0x6, %r8
movq 0x28(%rcx,%r8), %rdi
movq 0x30(%rcx,%r8), %r8
cmpq %r8, %rdi
je 0x98c3
cmpq %rsi, (%rdi)
je 0x98fd
addq $0x8, %rdi
jmp 0x98b3
incq %rax
cmpq %rdx, %rax
jne 0x98a2
movl $0x10, %edi
callq 0x3120
movq %rax, %rbx
leaq 0x5d0a(%rip), %rsi      # 0xf5e9
movq %rax, %rdi
callq 0x30e0
movq 0xb702(%rip), %rsi      # 0x14ff0
movq 0xb6cb(%rip), %rdx      # 0x14fc0
movq %rbx, %rdi
callq 0x33e0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x31d0
movq %r14, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O3/Windfisch[P]production-flow/flowgraph.cpp
// Function: FlowGraph::edge_to(FlowGraph::Edge const*) const
size_t FlowGraph::edge_to(const Edge* edge) const
{
	for (size_t i=0; i<nodes.size(); i++)
	{
		for (const Edge* e : nodes[i].incoming_edges)
			if (e == edge)
				return i;
	}

	throw runtime_error("FlowGraph is corrupt");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
je 0x995f
sarq $0x6, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %eax, %eax
movq %rax, %r8
shlq $0x6, %r8
movq 0x10(%rcx,%r8), %rdi
movq 0x18(%rcx,%r8), %r8
cmpq %r8, %rdi
je 0x9957
cmpq %rsi, (%rdi)
je 0x9991
addq $0x8, %rdi
jmp 0x9947
incq %rax
cmpq %rdx, %rax
jne 0x9936
movl $0x10, %edi
callq 0x3120
movq %rax, %rbx
leaq 0x5c76(%rip), %rsi      # 0xf5e9
movq %rax, %rdi
callq 0x30e0
movq 0xb66e(%rip), %rsi      # 0x14ff0
movq 0xb637(%rip), %rdx      # 0x14fc0
movq %rbx, %rdi
callq 0x33e0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x31d0
movq %r14, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O3/markondej[P]phase_correl/phase_correl.c
// Function: gen2fftorder
unsigned *gen2fftorder(unsigned size) {
    unsigned *offset = (unsigned *)malloc(sizeof(unsigned) * size),
        stride = 1, step;

    memset(offset, 0xff, sizeof(unsigned) * size);
    offset[0] = 0;

    for (step = size >> 1; step > 0; step >>= 1) {
        unsigned base = 0, i;
        for (i = 0; i < size; i += step) {
            if (offset[i] != UINT_MAX) {
                base = offset[i];
            } else {
                offset[i] = base + stride;
            }
        }
        stride <<= 1;
    }

    return offset;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
movl %edi, %r15d
shlq $0x2, %r15
movq %r15, %rdi
callq 0x1080
movq %rax, %r14
movq %rax, %rdi
movl $0xff, %esi
movq %r15, %rdx
callq 0x1060
movl $0x0, (%r14)
cmpl $0x2, %ebx
jb 0x1379
movl $0x1, %eax
movl %ebx, %ecx
movl %ebx, %edx
shrl %edx
xorl %esi, %esi
xorl %edi, %edi
movl %esi, %esi
movl (%r14,%rsi,4), %r8d
cmpl $-0x1, %r8d
jne 0x1367
leal (%rdi,%rax), %r8d
movl %r8d, (%r14,%rsi,4)
movl %edi, %r8d
addl %edx, %esi
movl %r8d, %edi
cmpl %ebx, %esi
jb 0x1350
addl %eax, %eax
cmpl $0x3, %ecx
movl %edx, %ecx
ja 0x134a
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/markondej[P]phase_correl/phase_correl.c
// Function: dit2fft
void dit2fft(const double *input, double *output, unsigned size, int inverse) {
    unsigned *offset = gen2fftorder(size >> 1),
        stride = 1, i;

    while (size > 2) {
        stride <<= 1;
        size >>= 1;
    }

    for (i = 0; i < stride; i++) {
        radix2fft(&input[offset[i] << 1], &output[(i * 2) << 1], stride);
    }

    free(offset);

    while (stride > 1) {
        stride >>= 1;
        size <<= 1;
        for (i = 0; i < stride; i++) {
            sum2fft(&output[(i * size) << 1], &output[(i * size) << 1], size >> 1, inverse);
        }
    }

    if (inverse) {
        for (i = 0; i < size; i++) {
            output[i << 1] /= (double)size;
            output[(i << 1) + 1] /= (double)size;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r12
movl %edx, %edi
shrl %edi
callq 0x130c
movl $0x1, %r13d
cmpl $0x3, %ebp
jb 0x13ca
movl $0x1, %r13d
movl %ebp, %ecx
addl %r13d, %r13d
shrl %ebp
cmpl $0x5, %ecx
ja 0x13b5
testl %r13d, %r13d
je 0x14c2
movl %ebp, %r14d
leal (,%r13,2), %ecx
leal 0x1(,%r13,2), %edx
movl %r13d, %esi
xorl %edi, %edi
movl (%rax,%rdi), %r8d
addl %r8d, %r8d
leaq (%r12,%r8,8), %r8
movl %edi, %r9d
movsd (%r8), %xmm0
addsd (%r8,%rcx,8), %xmm0
andl $-0x4, %r9d
movsd %xmm0, (%rbx,%r9,8)
movsd 0x8(%r8), %xmm0
addsd (%r8,%rdx,8), %xmm0
movsd %xmm0, 0x8(%rbx,%r9,8)
movsd (%r8), %xmm0
subsd (%r8,%rcx,8), %xmm0
movsd %xmm0, 0x10(%rbx,%r9,8)
movsd 0x8(%r8), %xmm0
subsd (%r8,%rdx,8), %xmm0
movsd %xmm0, 0x18(%rbx,%r9,8)
addq $0x4, %rdi
decq %rsi
jne 0x13e2
movq %rax, %rdi
callq 0x1030
cmpl $0x2, %r13d
jb 0x14bd
movl %r15d, %eax
leal (%r14,%r14), %ebp
cmpl $0x2, %r13d
jb 0x14cd
movl %ebp, 0xc(%rsp)
movq %r13, 0x10(%rsp)
movl %r13d, %eax
shrl %eax
leal (,%r14,4), %r12d
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
movl %eax, 0x8(%rsp)
movl %eax, %r13d
xorl %ebp, %ebp
movl %ebp, %eax
leaq (%rbx,%rax,8), %rdi
movq %rdi, %rsi
movl %r14d, %edx
movl %r15d, %ecx
callq 0x11da
addl %r12d, %ebp
decq %r13
jne 0x1487
movl %r15d, %eax
movl 0xc(%rsp), %ebp
movl %ebp, %r14d
cmpl $0x4, 0x10(%rsp)
movl 0x8(%rsp), %ecx
movl %ecx, %r13d
jae 0x1457
jmp 0x14cd
movl %r14d, %ebp
jmp 0x14ca
movq %rax, %rdi
callq 0x1030
movl %r15d, %eax
testl %eax, %eax
setne %al
testl %ebp, %ebp
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x150d
movl %ebp, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
addq %rax, %rax
xorl %ecx, %ecx
movl %ecx, %edx
andl $-0x2, %edx
movupd (%rbx,%rdx,8), %xmm1
divpd %xmm0, %xmm1
movupd %xmm1, (%rbx,%rdx,8)
addq $0x2, %rcx
cmpq %rcx, %rax
jne 0x14f1
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/markondej[P]phase_correl/phase_correl.c
// Function: computeNormalized
void computeNormalized(const double *f, const double *g, double *r) {
    double a1 = (f[1] != 0.0) ? ((f[0] != 0.0) ? atan(f[1] / f[0]) : copysign(M_PI, f[1]) / 2.0) : 0.0;
    if (f[0] < 0.0) {
        a1 = copysign(M_PI, f[1]) + a1;
    }

    double a2 = (g[1] != 0.0) ? ((g[0] != 0.0) ? atan(g[1] / g[0]) : copysign(M_PI, g[1]) / 2.0) : 0.0;
    if (g[0] < 0.0) {
        a2 = copysign(M_PI, g[1]) + a2;
    }

    r[0] = cos(a1 - a2);
    r[1] = sin(a1 - a2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd 0x8(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
xorpd %xmm3, %xmm3
jne 0x176f
jnp 0x1791
movsd (%r15), %xmm1
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jne 0x1780
jnp 0x17b4
divsd %xmm1, %xmm0
callq 0x1040
xorpd %xmm1, %xmm1
movapd %xmm0, %xmm3
ucomisd (%r15), %xmm1
jbe 0x17d0
movsd 0x8(%r15), %xmm0
andpd 0x87a(%rip), %xmm0      # 0x2020
orpd 0x882(%rip), %xmm0      # 0x2030
addsd %xmm0, %xmm3
jmp 0x17d0
andpd 0x864(%rip), %xmm0      # 0x2020
orpd 0x86c(%rip), %xmm0      # 0x2030
mulsd 0x944(%rip), %xmm0      # 0x2110
movapd %xmm0, %xmm3
movsd 0x8(%r14), %xmm1
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
xorpd %xmm0, %xmm0
jne 0x17e6
jnp 0x1810
movsd (%r14), %xmm0
ucomisd %xmm2, %xmm0
jne 0x17f3
jnp 0x1833
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movsd %xmm3, 0x8(%rsp)
callq 0x1040
xorpd %xmm2, %xmm2
movsd 0x8(%rsp), %xmm3
ucomisd (%r14), %xmm2
jbe 0x184f
movsd 0x8(%r14), %xmm1
andpd 0x7fb(%rip), %xmm1      # 0x2020
orpd 0x803(%rip), %xmm1      # 0x2030
addsd %xmm1, %xmm0
jmp 0x184f
andpd 0x7e5(%rip), %xmm1      # 0x2020
orpd 0x7ed(%rip), %xmm1      # 0x2030
mulsd 0x8c5(%rip), %xmm1      # 0x2110
movapd %xmm1, %xmm0
subsd %xmm0, %xmm3
movsd %xmm3, 0x8(%rsp)
movapd %xmm3, %xmm0
callq 0x1070
movsd %xmm0, (%rbx)
movsd 0x8(%rsp), %xmm0
callq 0x1090
movsd %xmm0, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq