LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ctSkennerton[P]fxtract/util/rollhash_x.c
// Function: main
int main(void)
{
    plan_tests(14);

    uint8_t test[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    uint32_t i, arg = rollhash_arg(12), roll = rollhash_init(test, 12);

    for (i = 0; i < 26 - 12; i++) {
        uint hash = rollhash_init(test + i + 1, 12);
        roll = rollhash_step(arg, roll, test[i], test[i+12]);
        ok(roll == hash, "-%c +%c", test[i], test[i+12]);
    }   

    return exit_status();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
movl $0x0, -0xc(%rbp)
movl $0xe, %edi
callq 0x21c0
movq 0x1d8f(%rip), %rax      # 0x3010
movq %rax, -0x30(%rbp)
movq 0x1d8c(%rip), %rax      # 0x3018
movq %rax, -0x28(%rbp)
movq 0x1d89(%rip), %rax      # 0x3020
movq %rax, -0x20(%rbp)
movw 0x1d86(%rip), %ax       # 0x3028
movw %ax, -0x18(%rbp)
movb 0x1d7e(%rip), %al       # 0x302a
movb %al, -0x16(%rbp)
movl $0xc, %edi
callq 0x1400
movl %eax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movl $0xc, %esi
callq 0x1440
movl %eax, -0x3c(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0xe, -0x34(%rbp)
jae 0x13f0
leaq -0x30(%rbp), %rdi
movl -0x34(%rbp), %eax
addq %rax, %rdi
addq $0x1, %rdi
movl $0xc, %esi
callq 0x1440
movl %eax, -0x40(%rbp)
movl -0x38(%rbp), %edi
movl -0x3c(%rbp), %esi
movl -0x34(%rbp), %eax
movb -0x30(%rbp,%rax), %cl
movl -0x34(%rbp), %eax
addl $0xc, %eax
movl %eax, %eax
movzbl %cl, %edx
movzbl -0x30(%rbp,%rax), %ecx
callq 0x1490
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x40(%rbp), %eax
jne 0x1386
movl -0x34(%rbp), %eax
movzbl -0x30(%rbp,%rax), %r10d
movl -0x34(%rbp), %eax
addl $0xc, %eax
movl %eax, %eax
movzbl -0x30(%rbp,%rax), %eax
xorl %edi, %edi
movl $0x1, %esi
xorl %ecx, %ecx
movl %ecx, %r8d
leaq 0x1cdc(%rip), %r9       # 0x302b
leaq 0x1cda(%rip), %rbx      # 0x3030
leaq 0x1ce0(%rip), %r11      # 0x303d
movq %r8, %rdx
movq %r8, %rcx
movq %rbx, (%rsp)
movl $0xe, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movl %r10d, 0x18(%rsp)
movl %eax, 0x20(%rsp)
movb $0x0, %al
callq 0x14e0
jmp 0x13e2
movl -0x34(%rbp), %eax
movzbl -0x30(%rbp,%rax), %r10d
movl -0x34(%rbp), %eax
addl $0xc, %eax
movl %eax, %eax
movzbl -0x30(%rbp,%rax), %eax
xorl %edi, %edi
xorl %ecx, %ecx
movl %ecx, %r8d
leaq 0x1c81(%rip), %r9       # 0x302b
leaq 0x1c7f(%rip), %rbx      # 0x3030
leaq 0x1c85(%rip), %r11      # 0x303d
movq %r8, %rsi
movq %r8, %rdx
movq %r8, %rcx
movq %rbx, (%rsp)
movl $0xe, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movl %r10d, 0x18(%rsp)
movl %eax, 0x20(%rsp)
movb $0x0, %al
callq 0x14e0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x12d4
callq 0x2510
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: eschwabe[P]interview-practice/src/stringcombinations.cpp
// Function: combinations(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long)
void combinations(string source, string str, size_t target_len) {
    if(str.size() == target_len) {
        cout << str << endl;
    }
    else {
        string tmpsource = source;
        while(tmpsource.size() > 0) {
            string tmpstr = str;
            tmpstr.push_back(tmpsource.at(0));
            tmpsource.erase(0, 1);
            combinations(tmpsource, tmpstr, target_len);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xc0(%rbp)
movq %rdi, %rax
movq -0xc0(%rbp), %rdi
movq %rax, -0xb8(%rbp)
movq %rdi, -0xb0(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x20b0
cmpq -0x18(%rbp), %rax
jne 0x23a8
movq -0xb0(%rbp), %rsi
movq 0x2c49(%rip), %rdi      # 0x4fd8
callq 0x2110
movq %rax, %rdi
movq 0x2c2a(%rip), %rsi      # 0x4fc8
callq 0x2120
jmp 0x24ee
movq -0xb8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x2070
leaq -0x38(%rbp), %rdi
callq 0x20b0
cmpq $0x0, %rax
jbe 0x24d8
movq -0xb0(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x2070
jmp 0x23dd
xorl %eax, %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
callq 0x21e0
movq %rax, -0xc8(%rbp)
jmp 0x23f3
movq -0xc8(%rbp), %rax
movsbl (%rax), %esi
leaq -0x58(%rbp), %rdi
callq 0x20f0
jmp 0x2408
xorl %eax, %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
movl $0x1, %edx
callq 0x2040
jmp 0x241c
leaq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2070
jmp 0x242e
leaq -0xa8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2070
jmp 0x2440
movq -0x18(%rbp), %rdx
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x2340
jmp 0x2459
leaq -0xa8(%rbp), %rdi
callq 0x2090
leaq -0x88(%rbp), %rdi
callq 0x2090
leaq -0x58(%rbp), %rdi
callq 0x2090
jmp 0x23b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x24e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x24cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x24c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x2090
leaq -0x88(%rbp), %rdi
callq 0x2090
leaq -0x58(%rbp), %rdi
callq 0x2090
jmp 0x24e3
leaq -0x38(%rbp), %rdi
callq 0x2090
jmp 0x24ee
leaq -0x38(%rbp), %rdi
callq 0x2090
jmp 0x24f7
addq $0xd0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x21b0
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
callq 0xa700
movq -0x78(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x70(%rbp)
callq 0xa780
jmp 0x756c
movq -0x80(%rbp), %rdi
addq $0x170, %rdi            # imm = 0x170
movq %rdi, -0x88(%rbp)
callq 0xa8a0
jmp 0x7585
movq -0x80(%rbp), %rcx
movq %rcx, %rax
addq $0x170, %rax            # imm = 0x170
movq %rax, -0x90(%rbp)
leaq 0x34b0(%rip), %rax      # 0xaa50
movq %rax, -0x68(%rbp)
movq $0x0, -0x60(%rbp)
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0xa9c0
jmp 0x75bf
movq -0x48(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0x58(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0xab20
jmp 0x75de
movq -0x90(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xa930
jmp 0x75f0
leaq -0x40(%rbp), %rdi
callq 0xab80
movq -0x80(%rbp), %rdi
addq $0x170, %rdi            # imm = 0x170
movl -0xc(%rbp), %esi
callq 0xaba0
jmp 0x760e
movq -0x80(%rbp), %rdi
addq $0x28, %rdi
movl -0x10(%rbp), %esi
callq 0xacb0
jmp 0x7620
movq -0x80(%rbp), %rax
movb $0x0, 0x1d8(%rax)
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x7688
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x767f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x7673
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xab80
movq -0x88(%rbp), %rdi
callq 0xad20
movq -0x70(%rbp), %rdi
callq 0xae10
movq -0x78(%rbp), %rdi
callq 0xae80
movq -0x18(%rbp), %rdi
callq 0x6530
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x28, %rdi
callq 0x11390
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x113b0
movq -0x28(%rbp), %rax
testb $0x1, 0x1d8(%rax)
je 0x784e
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x11430
movb $0x0, -0x1(%rbp)
jmp 0x788c
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
callq 0x11450
movq -0x28(%rbp), %rdi
andb $0x1, %al
movb %al, -0x19(%rbp)
addq $0x28, %rdi
callq 0x11430
testb $0x1, -0x19(%rbp)
je 0x7884
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x11500
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xc460
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x48(%rcx), %eax
ja 0x7a38
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x28(%rbp)
addq $0x28, %rdi
callq 0x138d0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jb 0x7a50
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, 0x48(%rdi)
callq 0xce10
movl $0x0, -0x4(%rbp)
jmp 0x7a60
movq -0x20(%rbp), %rdi
callq 0xce10
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0xc460
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
callq 0x138d0
movq -0x40(%rbp), %rcx
movl 0x48(%rcx), %ecx
cmpq %rcx, %rax
jb 0x7abc
movq -0x40(%rbp), %rdi
callq 0xce10
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7b2a
movq -0x40(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x50(%rbp)
movl $0x10, %edi
callq 0x62e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x15ad0
jmp 0x7ae7
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0xf120
movq -0x40(%rbp), %rdi
callq 0xce10
movl $0x0, -0x4(%rbp)
jmp 0x7b2a
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x10, %esi
callq 0x6300
jmp 0x7b33
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x6530
nopl (%rax)
// File: switch-st[P]SimpleThreadPool/./SimpleThreadPool.hpp
// Function: Switch::Tool::SimpleThreadPool<float>::GetPoolSize()
int GetPoolSize(void)
	{
	    m_TMutex.lock();
	    int size = m_lpThread.size();
	    m_TMutex.unlock();

		return size;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xc460
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x138d0
movq -0x18(%rbp), %rdi
movl %eax, -0xc(%rbp)
callq 0xce10
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: switch-st[P]SimpleThreadPool/./SimpleThreadPool.hpp
// Function: Switch::Tool::SimpleThreadPool<float>::StopThreadPool()
int StopThreadPool(void)
	{
        std::list< boost::thread* >::iterator iter, end;

        end = m_lpThread.end();
        for (iter = m_lpThread.begin(); iter != end;)
        {
            boost::thread* p = *iter;
            p->interrupt();
            p->join();
            delete p;
        }

        return 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x11130
leaq -0x18(%rbp), %rdi
callq 0x11130
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
callq 0xf250
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x28, %rdi
callq 0x11150
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x11180
testb $0x1, %al
jne 0x7d1b
jmp 0x7d64
leaq -0x10(%rbp), %rdi
callq 0x111b0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x6410
movq -0x30(%rbp), %rdi
callq 0x111d0
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x7d62
movq -0x40(%rbp), %rdi
callq 0x11270
movq -0x40(%rbp), %rdi
movl $0x10, %esi
callq 0x6300
jmp 0x7d08
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x40(%rax), %rdi
callq 0x6410
jmp 0x7d8f
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x111d0
jmp 0x7d9e
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x7dc7
movq -0x18(%rbp), %rdi
callq 0x11270
movq -0x18(%rbp), %rdi
movl $0x10, %esi
callq 0x6300
movq -0x10(%rbp), %rdi
callq 0x7cb0
jmp 0x7dd2
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0xc080
movq -0x10(%rbp), %rdi
callq 0xae80
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x7320
nopw %cs:(%rax,%rax)
// File: switch-st[P]SimpleThreadPool/./SimpleThreadList.hpp
// Function: Switch::Tool::SimpleThreadList::set_thread_func(boost::function<void ()> const&)
bool set_thread_func(const boost::function< void() >& func)
    {
        boost::lock_guard< boost::mutex > guard(m_oMutex);

        if (m_bStopFlag)
		{
			return false;
		}
        m_oFunc = func;

        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x40(%rbp)
addq $0x18, %rsi
leaq -0x20(%rbp), %rdi
callq 0xc390
movq -0x40(%rbp), %rax
testb $0x1, 0x64(%rax)
je 0xa96c
movb $0x0, -0x1(%rbp)
movl $0x1, -0x24(%rbp)
jmp 0xa9a3
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x40, %rdi
callq 0xc3c0
jmp 0xa97f
movb $0x1, -0x1(%rbp)
movl $0x1, -0x24(%rbp)
jmp 0xa9a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc430
jmp 0xa9b7
leaq -0x20(%rbp), %rdi
callq 0xc430
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x6530
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xcf60
jmp 0xaa6f
movq -0x70(%rbp), %rdi
addq $0x28, %rdi
callq 0xcfb0
jmp 0xaa7e
movq -0x70(%rbp), %rdi
addq $0x28, %rdi
callq 0xcfe0
jmp 0xaa8d
movq -0x70(%rbp), %rax
testb $0x1, 0x1d8(%rax)
je 0xaacf
movq -0x70(%rbp), %rdi
addq $0x28, %rdi
callq 0xd060
jmp 0xaaa9
leaq -0x58(%rbp), %rdi
callq 0x78a0
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x78a0
jmp 0xab10
movq -0x70(%rbp), %rdi
addq $0x28, %rdi
leaq -0x58(%rbp), %rsi
callq 0xd090
jmp 0xaae2
movq -0x70(%rbp), %rdi
addq $0x28, %rdi
callq 0xd060
jmp 0xaaf1
movq -0x70(%rbp), %rdi
addq $0x28, %rdi
callq 0xd140
jmp 0xab00
leaq -0x58(%rbp), %rdi
callq 0xd160
jmp 0xab0b
jmp 0xaa6d
movq -0x60(%rbp), %rdi
callq 0x6530
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x48(%rbp)
addq $0x18, %rsi
leaq -0x20(%rbp), %rdi
callq 0xc390
movq -0x48(%rbp), %rax
testb $0x1, 0x64(%rax)
jne 0xabda
movq -0x48(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x60(%rcx), %eax
ja 0xabea
movb $0x0, -0x1(%rbp)
movl $0x1, -0x24(%rbp)
jmp 0xac8a
movq -0x48(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0xac75
movq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x10, %edi
callq 0x62e0
movq %rax, -0x50(%rbp)
jmp 0xac14
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0x40, %rsi
callq 0xf160
jmp 0xac27
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0xf120
jmp 0xac3e
jmp 0xac40
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xabf4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xac9e
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x10, %esi
callq 0x6300
jmp 0xac9e
movq -0x48(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x60(%rax)
movb $0x1, -0x1(%rbp)
movl $0x1, -0x24(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc430
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0xc430
movq -0x38(%rbp), %rdi
callq 0x6530
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x30(%rbp)
addq $0x18, %rsi
leaq -0x20(%rbp), %rdi
callq 0xc390
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x140(%rcx), %eax
ja 0xacf0
movb $0x0, -0x1(%rbp)
movl $0x1, -0x24(%rbp)
jmp 0xad08
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x140(%rax)
movb $0x1, -0x1(%rbp)
movl $0x1, -0x24(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc430
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x11130
leaq -0x18(%rbp), %rdi
callq 0x11130
movq -0x30(%rbp), %rdi
callq 0xf250
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x11150
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x11180
testb $0x1, %al
jne 0xad83
jmp 0xadd0
leaq -0x10(%rbp), %rdi
callq 0x111b0
movq (%rax), %rdi
callq 0x111d0
jmp 0xad96
leaq -0x10(%rbp), %rdi
callq 0x111b0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xadc3
movq -0x38(%rbp), %rdi
callq 0x11270
movq -0x38(%rbp), %rdi
movl $0x10, %esi
callq 0x6300
jmp 0xadc5
leaq -0x10(%rbp), %rdi
callq 0x112b0
jmp 0xad70
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
callq 0xab80
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0xae80
movq -0x30(%rbp), %rdi
callq 0xc080
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x7320
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x38(%rbp)
addq $0x18, %rsi
leaq -0x20(%rbp), %rdi
callq 0xc390
movq -0x38(%rbp), %rax
testb $0x1, 0x144(%rax)
je 0xd0d1
movq -0x38(%rbp), %rdi
callq 0xe050
cmpq $0x0, %rax
jbe 0xd115
movq -0x38(%rbp), %rdi
callq 0xe0c0
movq %rax, %rsi
movq -0x18(%rbp), %rdi
callq 0xe0f0
jmp 0xd0e8
movq -0x38(%rbp), %rdi
callq 0xe130
movb $0x1, -0x1(%rbp)
movl $0x1, -0x30(%rbp)
jmp 0xd120
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc430
jmp 0xd134
movb $0x0, -0x1(%rbp)
movl $0x1, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc430
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x6530
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x20, %rdi
callq 0xc460
movq -0x10(%rbp), %rdi
movl $0x2, 0x48(%rdi)
addq $0x20, %rdi
callq 0xce10
movq -0x10(%rbp), %rdi
callq 0xe410
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0xc460
movq -0x10(%rbp), %rdi
movl $0x3, 0x48(%rdi)
addq $0x20, %rdi
callq 0xce10
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x40(%rbp)
addq $0x18, %rsi
leaq -0x20(%rbp), %rdi
callq 0xc390
movq -0x40(%rbp), %rax
testb $0x1, 0x144(%rax)
jne 0x1149a
movq -0x40(%rbp), %rdi
callq 0xe050
movq -0x40(%rbp), %rcx
movl 0x140(%rcx), %ecx
cmpq %rcx, %rax
jb 0x114a7
movb $0x0, -0x1(%rbp)
movl $0x1, -0x24(%rbp)
jmp 0x114da
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x115a0
jmp 0x114b6
movb $0x1, -0x1(%rbp)
movl $0x1, -0x24(%rbp)
jmp 0x114da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc430
jmp 0x114ee
leaq -0x20(%rbp), %rdi
callq 0xc430
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x6530
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x28(%rbp)
addq $0x18, %rsi
leaq -0x10(%rbp), %rdi
callq 0xc390
movq -0x28(%rbp), %rdi
movb $0x1, 0x144(%rdi)
callq 0xd140
movq -0x28(%rbp), %rdi
callq 0x11b80
jmp 0x11a4c
leaq -0x10(%rbp), %rdi
callq 0xc430
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xc430
movq -0x18(%rbp), %rdi
callq 0x6530
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x48(%rbp)
addq $0x18, %rsi
leaq -0x10(%rbp), %rdi
callq 0xc390
movq -0x48(%rbp), %rax
movb $0x1, 0x64(%rax)
leaq -0x18(%rbp), %rdi
callq 0x11130
leaq -0x20(%rbp), %rdi
callq 0x11130
movq -0x48(%rbp), %rdi
callq 0xf250
movq -0x48(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x11150
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x11180
testb $0x1, %al
jne 0x11af8
jmp 0x11b5c
leaq -0x18(%rbp), %rdi
callq 0x111b0
movq (%rax), %rdi
callq 0x111d0
jmp 0x11b0b
leaq -0x18(%rbp), %rdi
callq 0x111b0
movq (%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x11b38
movq -0x50(%rbp), %rdi
callq 0x11270
movq -0x50(%rbp), %rdi
movl $0x10, %esi
callq 0x6300
jmp 0x11b3a
leaq -0x18(%rbp), %rdi
callq 0x112b0
jmp 0x11ae5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xc430
jmp 0x11b74
movq -0x48(%rbp), %rdi
callq 0x11bb0
leaq -0x10(%rbp), %rdi
callq 0xc430
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6530
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x11130
leaq -0x18(%rbp), %rdi
callq 0x11130
movq -0x68(%rbp), %rdi
callq 0xc460
movq -0x68(%rbp), %rdi
addq $0x28, %rdi
callq 0xf250
movq -0x68(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x28, %rdi
callq 0x11150
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x11180
testb $0x1, %al
jne 0x11d0a
jmp 0x11dbf
leaq -0x10(%rbp), %rdi
callq 0x111b0
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movl $0x1, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x34(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x11fb0
movq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x11f50
testb $0x1, %al
jne 0x11d45
jmp 0x11db1
leaq -0x10(%rbp), %rdi
callq 0x111b0
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x40(%rbp)
addq $0x28, %rax
movq %rax, -0x80(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x12050
movq -0x80(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x12000
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, %rax
je 0x11daf
movq -0x78(%rbp), %rdi
callq 0x11270
movq -0x78(%rbp), %rdi
movl $0x10, %esi
callq 0x6300
jmp 0x11dba
leaq -0x10(%rbp), %rdi
callq 0x112b0
jmp 0x11cf4
movq -0x68(%rbp), %rdi
callq 0xce10
movl $0x1, -0x5c(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x5c(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x12150
leaq -0x58(%rbp), %rdi
callq 0x12070
jmp 0x11cb9
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x2b80
movq -0x38(%rbp), %rdi
leaq 0x54b8(%rip), %rax      # 0x7c00
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x2070
jmp 0x2762
movq -0x38(%rbp), %rax
movl $0x0, 0x28(%rax)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x27e1
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq 0x30(%rax,%rcx,8), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, -0x40(%rbp)
jmp 0x279c
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
jmp 0x27af
jmp 0x27b1
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2774
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x2813
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x20a0
jmp 0x2813
movq -0x38(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x4, -0x24(%rbp)
jge 0x280d
movq -0x38(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq $0x0, 0x30(%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x27eb
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2ba0
movq -0x18(%rbp), %rdi
callq 0x2210
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x2030
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0x296a
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x30(%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x295d
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x295f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2930
movq -0x28(%rbp), %rax
movl $0x0, 0x28(%rax)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x29b3
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq 0x30(%rax,%rcx,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x297c
movq -0x28(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x29df
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq $0x0, 0x30(%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x29bd
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2a2d
jmp 0x2a89
movq -0x20(%rbp), %rax
cmpl $0x4, 0x28(%rax)
jne 0x2a39
jmp 0x2a89
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0x2a6e
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x30(%rax,%rcx,8), %rax
cmpq -0x10(%rbp), %rax
jne 0x2a61
jmp 0x2a89
jmp 0x2a63
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2a40
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdx
movl 0x28(%rax), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x28(%rax)
movslq %ecx, %rcx
movq %rdx, 0x30(%rax,%rcx,8)
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x2ac5
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0x2ac5
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, 0x30(%rax,%rcx,8)
jne 0x2ac7
jmp 0x2b18
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0x3, -0x10(%rbp)
jge 0x2b0b
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq 0x30(%rax,%rcx,8), %rdx
movslq -0x10(%rbp), %rcx
movq %rdx, 0x30(%rax,%rcx,8)
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq $0x0, 0x30(%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2acd
movq -0x18(%rbp), %rax
movl 0x28(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x28(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x3860
movq -0x30(%rbp), %rax
leaq 0x4820(%rip), %rcx      # 0x7d28
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x357c
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, -0x38(%rbp)
jmp 0x3545
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0x3558
jmp 0x355a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x351d
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3910
jmp 0x35ab
movl $0x0, -0x28(%rbp)
cmpl $0x4, -0x28(%rbp)
jge 0x35a5
movq -0x30(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq $0x0, 0x10(%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3583
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2210
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x36c9
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x36bc
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x36be
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x368f
movq -0x28(%rbp), %rax
movl $0x0, 0x8(%rax)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x3712
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x36db
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x373b
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq $0x0, 0x10(%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3719
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x4, 0x8(%rax)
je 0x3771
cmpq $0x0, -0x10(%rbp)
jne 0x3773
jmp 0x37c3
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x37a8
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rax
cmpq -0x10(%rbp), %rax
jne 0x379b
jmp 0x37c3
jmp 0x379d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x377a
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdx
movl 0x8(%rax), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x8(%rax)
movslq %ecx, %rcx
movq %rdx, 0x10(%rax,%rcx,8)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x3845
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rdi
callq 0x2600
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3880
testb $0x1, %al
jne 0x381f
jmp 0x3838
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, -0x8(%rbp)
jmp 0x384d
jmp 0x383a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x37ef
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x5930
movq $0x0, -0x20(%rbp)
movq -0x70(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x88(%rbp)
callq 0x5710
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jae 0x815c
movq -0x70(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9bf0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
leaq -0x14(%rbp), %rsi
callq 0x9c40
movq %rax, -0x90(%rbp)
jmp 0x802c
movq -0x90(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x9c70
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x9c10
testb $0x1, %al
jne 0x805b
jmp 0x8089
movq -0x80(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x9ca0
jmp 0x806a
jmp 0x8149
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x5af0
jmp 0x817c
movq -0x70(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x9d10
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x9d40
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x9d70
testb $0x1, %al
jne 0x80c5
jmp 0x8147
leaq -0x58(%rbp), %rdi
callq 0x9db0
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x8137
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x91(%rbp)
je 0x8108
movq -0x68(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x20(%rbp), %rax
setne %al
movb %al, -0x91(%rbp)
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x8114
jmp 0x8116
jmp 0x8135
leaq 0x1d178(%rip), %rdi     # 0x25295
leaq 0x1d1b8(%rip), %rsi     # 0x252dc
movl $0x2d, %edx
leaq 0x1d1b8(%rip), %rcx     # 0x252e8
callq 0x31e0
jmp 0x8137
jmp 0x8139
leaq -0x58(%rbp), %rdi
callq 0x9dd0
jmp 0x80af
jmp 0x8149
jmp 0x814b
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x7fda
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x816f
movq -0x80(%rbp), %rdi
callq 0x5af0
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9df0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9e20
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x9e50
testb $0x1, %al
jne 0x821c
jmp 0x8284
leaq -0x18(%rbp), %rdi
callq 0x9e90
movq -0x78(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x9eb0
movq %rax, %rdi
addq $0x20, %rdi
movq -0x28(%rbp), %rsi
callq 0x9ed0
movq -0x78(%rbp), %rdi
movq %rax, -0x38(%rbp)
movb %dl, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x9eb0
movq %rax, %rdi
addq $0x20, %rdi
movq -0x28(%rbp), %rsi
callq 0x9ed0
movq %rax, -0x48(%rbp)
movb %dl, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x9f20
jmp 0x8209
movq -0x78(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x9f40
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x9f70
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x9fa0
testb $0x1, %al
jne 0x82b9
jmp 0x82f4
leaq -0x58(%rbp), %rdi
callq 0x9fe0
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rsi
addq $0x20, %rsi
leaq -0x70(%rbp), %rdi
callq 0xa000
leaq -0x70(%rbp), %rdi
callq 0xa030
movl (%rax), %ecx
movq -0x68(%rbp), %rax
movl %ecx, 0x18(%rax)
leaq -0x58(%rbp), %rdi
callq 0xa060
jmp 0x82a6
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x60, %rdi
movl $0xb, %esi
callq 0xa080
movq -0x20(%rbp), %rdi
addq $0x78, %rdi
movl $0xb, %esi
callq 0xa080
movq $0x0, -0x10(%rbp)
cmpq $0xb, -0x10(%rbp)
jae 0x89fd
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movq -0x10(%rbp), %rsi
callq 0x5850
movq %rax, %rdi
callq 0xa110
movq -0x20(%rbp), %rdi
addq $0x78, %rdi
movq -0x10(%rbp), %rsi
callq 0x5850
movq -0x20(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x18, %rdi
callq 0x5770
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0xa130
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x18, %rdi
callq 0x5770
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x89ea
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0xa270
movslq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x89d7
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movq -0x10(%rbp), %rsi
callq 0x5850
movq %rax, %rdi
leaq -0x18(%rbp), %rsi
callq 0x9ca0
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movq -0x10(%rbp), %rsi
callq 0x5850
movq %rax, %rdi
callq 0x5870
movq -0x20(%rbp), %rdi
subq $0x1, %rax
movq %rax, -0x38(%rbp)
addq $0x78, %rdi
movq -0x10(%rbp), %rsi
callq 0x5850
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x5890
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x89d9
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x8936
jmp 0x89ec
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x88dc
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)