LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/lszp[P]SmallWebServer/././threadpool/threadpool.h
// Function: threadpool<http_conn>::run()
void threadpool<T>::run()
{
    while (true)
    {
        m_queuestat.wait();  // 信号量等待
        m_queuelocker.lock();
        if (m_workqueue.empty())
        {
            m_queuelocker.unlock();
            continue;
        }
        T *request = m_workqueue.front();  // 从请求队列中取出第一个任务
        m_workqueue.pop_front();  // 将任务从请求队列中删除
        m_queuelocker.unlock();
        if (!request)
            continue;
        if (1 == m_actor_model)
        {
            if (0 == request->m_state)
            {
                if (request->read_once())
                {
                    request->improv = 1;
                    connectionRAII mysqlcon(&request->mysql, m_connPool);
                    request->process();
                }
                else
                {
                    request->improv = 1;
                    request->timer_flag = 1;
                }
            }
            else
            {
                if (request->write())
                {
                    request->improv = 1;
                }
                else
                {
                    request->improv = 1;
                    request->timer_flag = 1;
                }
            }
        }
        else
        {
            connectionRAII mysqlcon(&request->mysql, m_connPool);
            request->process();
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x50(%rdi), %r14
leaq 0x28(%rdi), %r15
leaq 0x10(%rdi), %r12
movq %r14, %rdi
callq 0x3290
movq %r15, %rdi
callq 0x35f0
movq (%r12), %rbp
cmpq %r12, %rbp
je 0x8f6d
movq 0x10(%rbp), %r13
decq 0x20(%rbx)
movq %rbp, %rdi
callq 0x3690
movl $0x18, %esi
movq %rbp, %rdi
callq 0x3430
movq %r15, %rdi
callq 0x3350
testq %r13, %r13
je 0x8f07
cmpl $0x1, 0x78(%rbx)
jne 0x8f77
cmpl $0x0, 0x10(%r13)
je 0x8fa1
movq %r13, %rdi
callq 0x5bc2
movl $0x1, 0x4(%r13)
testb %al, %al
jne 0x8f07
jmp 0x8fd4
movq %r15, %rdi
callq 0x3350
jmp 0x8f07
leaq 0x8(%r13), %rsi
movq 0x70(%rbx), %rdx
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x79b6
movq %r13, %rdi
callq 0x61c4
movq %rbp, %rdi
callq 0x79dc
jmp 0x8f07
movq %r13, %rdi
callq 0x4a9c
movl $0x1, 0x4(%r13)
testb %al, %al
je 0x8fd4
leaq 0x8(%r13), %rsi
movq 0x70(%rbx), %rdx
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x79b6
movq %r13, %rdi
callq 0x61c4
jmp 0x8f94
movl $0x1, (%r13)
jmp 0x8f07
jmp 0x8fe3
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x79dc
movq %rbx, %rdi
callq 0x36e0
// File: /workspace/github_cpp_makefile_star2_O1/lszp[P]SmallWebServer/config.cpp
// Function: Config::parse_arg(int, char**)
void Config::parse_arg(int argc, char*argv[]){
    int opt;
    const char *str = "p:v:l:m:o:s:t:c:a:";
    while ((opt = getopt(argc, argv, str)) != -1)
    {
        switch (opt)
        {
        case 'p':
        {
            PORT = atoi(optarg);  // atoi : 字符串转换整型。含义为 ASCII to integer; optarg 指向选项 p 后面的参数。
            break;
        }
        case 'v':
        {
            SQLVerify = atoi(optarg);
            break;
        }
        case 'l':
        {
            LOGWrite = atoi(optarg);
            break;
        }
        case 'm':
        {
            TRIGMode = atoi(optarg);
            break;
        }
        case 'o':
        {
            OPT_LINGER = atoi(optarg);
            break;
        }
        case 's':
        {
            sql_num = atoi(optarg);
            break;
        }
        case 't':
        {
            thread_num = atoi(optarg);
            break;
        }
        case 'c':
        {
            close_log = atoi(optarg);
            break;
        }
        case 'a':
        {
            actor_model = atoi(optarg);
            break;
        }
        default:
            break;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r13
leaq 0x20(%rdi), %rax
movq %rax, 0x40(%rsp)
leaq 0x1c(%rdi), %rax
movq %rax, 0x38(%rsp)
leaq 0x18(%rdi), %rax
movq %rax, 0x30(%rsp)
leaq 0x14(%rdi), %rax
movq %rax, 0x28(%rsp)
leaq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
leaq 0xc(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0x8(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x4(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x1601(%rip), %r15      # 0xa678
leaq 0x15a2(%rip), %r12      # 0xa620
movl %ebp, %edi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x30b0
leal -0x61(%rax), %ecx
cmpl $0x15, %ecx
ja 0x90e9
movslq (%r12,%rcx,4), %rax
addq %r12, %rax
movq %r13, %r14
jmpq *%rax
movq 0x40(%rsp), %r14
jmp 0x90d5
movq 0x18(%rsp), %r14
jmp 0x90d5
movq 0x38(%rsp), %r14
jmp 0x90d5
movq 0x10(%rsp), %r14
jmp 0x90d5
movq 0x30(%rsp), %r14
jmp 0x90d5
movq 0x20(%rsp), %r14
jmp 0x90d5
movq 0x28(%rsp), %r14
jmp 0x90d5
movq 0x8(%rsp), %r14
movq 0x4ed4(%rip), %rax      # 0xdfb0
movq (%rax), %rdi
callq 0x3650
movl %eax, (%r14)
jmp 0x907e
cmpl $-0x1, %eax
jne 0x907e
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/NeoResearch[P]dbft3-spork-detect/main.cpp
// Function: printv(std::vector<int, std::allocator<int>>)
void printv(vector<int> v)
{
    cout << "v(" << v.size() << "): ";
    for (unsigned i = 0; i < v.size(); i++)
        cout << v[i] << " ";
    cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x6c14(%rip), %rbx      # 0x8fd8
leaq 0x3c65(%rip), %rsi      # 0x6030
movl $0x2, %edx
movq %rbx, %rdi
callq 0x2170
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x2, %rsi
movq %rbx, %rdi
callq 0x20d0
leaq 0x3c41(%rip), %rsi      # 0x6033
movl $0x3, %edx
movq %rax, %rdi
callq 0x2170
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x2452
movl $0x1, %r13d
xorl %ecx, %ecx
movq 0x6bc1(%rip), %r15      # 0x8fd8
leaq 0x3e98(%rip), %r12      # 0x62b6
movl (%rax,%rcx,4), %esi
movq %r15, %rdi
callq 0x2210
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2170
movl %r13d, %ecx
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
incl %r13d
cmpq %rcx, %rdx
ja 0x241e
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
// File: /workspace/github_cpp_makefile_star2_O1/NeoResearch[P]dbft3-spork-detect/main.cpp
// Function: getCancels(std::vector<int, std::allocator<int>>, std::vector<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>, std::allocator<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>>, int)
vector<int> getCancels(vector<int> choices, vector<vector<pair<int, int>>> selections, int f)
{
    int N = 3 * f + 1;
    vector<int> cancels(N, -2);
    // compute cancels for each replica
    // OLD // rule is: order by lowest to highest proposal, and take value 2*f
    // NEW RULE (simpler): if Prep0 has a non-faulty proposal, Cancel 0, otherwise Cancel 1
    for (unsigned i = 0; i < N; i++)
    {
        if (choices[i] == -2)
            continue;       // faulty node
        int count_zero = 0; // try to Cancel 0 (NEW RULE)
        //vector<int> responses;
        //responses.push_back(choices[i]); // own choice counts
        //for (unsigned j = 0; j < selections[i].size(); j++)
        //    responses.push_back(selections[i][j].second);
        ////cout << "RESPONSES FOR I=" << i << endl;
        ////printv(responses);
        //sort(responses.begin(), responses.end());
        //printv(responses);
        //int cancel = responses[2 * f - 1];
        for (unsigned j = 0; j < selections[i].size(); j++)
            if (selections[i][j].second == 0)
                count_zero++;
        if (choices[i] == 0)
            count_zero++;
        int cancel = 1;          // default one
        if (count_zero >= f + 1) // at least one trusted
            cancel = 0;

        ////cout << "cancel = " << cancel << endl;
        cancels[i] = cancel;
        // EXCEPTION: proposal j cannot Cancel more than j (otherwise it just assumes its "faultyness", what is absurd)
        if (i == 0)
            cancels[i] = 0; // FORCE. could do same for i=1 (but only two, so that's fine already)
    }

    return cancels;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leal (%rbx,%rbx,2), %r13d
leal 0x1(%r13), %eax
movslq %eax, %rsi
leaq -0x30(%rbp), %rdx
movl $0xfffffffe, (%rdx)     # imm = 0xFFFFFFFE
leaq -0x29(%rbp), %rcx
callq 0x4c6c
incl %r13d
je 0x2bf6
movl %r13d, %eax
xorl %ecx, %ecx
movq (%r12), %rdx
movl (%rdx,%rcx,4), %edx
cmpl $-0x2, %edx
je 0x2bee
movq (%r14), %rdi
leaq (%rcx,%rcx,2), %r8
movq (%rdi,%r8,8), %rsi
movq 0x8(%rdi,%r8,8), %rdi
subq %rsi, %rdi
je 0x2bca
sarq $0x3, %rdi
xorl %r9d, %r9d
xorl %r8d, %r8d
cmpl $0x1, 0x4(%rsi,%r9,8)
adcl $0x0, %r8d
incq %r9
movl %r9d, %r10d
cmpq %r10, %rdi
ja 0x2bb3
jmp 0x2bcd
xorl %r8d, %r8d
cmpl $0x1, %edx
adcl $0x0, %r8d
cmpl %ebx, %r8d
setle %dl
movq (%r15), %rsi
testq %rcx, %rcx
setne %dil
andb %dl, %dil
movzbl %dil, %edx
movl %edx, (%rsi,%rcx,4)
incq %rcx
cmpq %rax, %rcx
jne 0x2b88
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/NeoResearch[P]dbft3-spork-detect/main.cpp
// Function: printTable(std::vector<int, std::allocator<int>>, std::vector<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>, std::allocator<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>>, std::vector<int, std::allocator<int>>, int)
void printTable(vector<int> choices, vector<vector<pair<int, int>>> selections, vector<int> cancels, int f)
{
    int N = 3 * f + 1;
    for (unsigned i = 0; i < N; i++)
    {
        cout << "R_" << i << " | " << choices[i] << "(" << choices[i] << ") |\t";
        for (unsigned j = 0; j < selections[i].size(); j++)
            cout << selections[i][j].second << "(" << selections[i][j].first << ")\t";
        cout << "| Cancel " << cancels[i] << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
leal (%rcx,%rcx,2), %eax
incl %eax
je 0x2dde
movq %rsi, %r14
movl %eax, %eax
movq %rax, -0x38(%rbp)
xorl %r12d, %r12d
movq 0x6399(%rip), %rbx      # 0x8fd8
leaq 0x33eb(%rip), %r13      # 0x6031
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x3434(%rip), %rsi      # 0x6089
callq 0x2170
movq %rbx, %rdi
movq %r12, %rsi
callq 0x20d0
movq %rax, %r15
movl $0x3, %edx
movq %rax, %rdi
leaq 0x340e(%rip), %rsi      # 0x6085
callq 0x2170
movq -0x40(%rbp), %rbx
movq (%rbx), %rax
movl (%rax,%r12,4), %esi
movq %r15, %rdi
callq 0x2210
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2170
movq (%rbx), %rax
movl (%rax,%r12,4), %esi
movq %r15, %rdi
callq 0x2210
movl $0x4, %edx
movq %rax, %rdi
leaq 0x33cc(%rip), %rsi      # 0x608c
callq 0x2170
movq (%r14), %rcx
movq %r12, -0x30(%rbp)
leaq (%r12,%r12,2), %rdx
movq (%rcx,%rdx,8), %rax
cmpq %rax, 0x8(%rcx,%rdx,8)
je 0x2d6e
movl $0x1, %ebx
movq -0x30(%rbp), %rcx
leaq (,%rcx,8), %rcx
leaq (%rcx,%rcx,2), %rcx
movq %rcx, -0x50(%rbp)
xorl %r12d, %r12d
movl 0x4(%rax,%r12,8), %esi
movq 0x62d1(%rip), %rdi      # 0x8fd8
callq 0x2210
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
leaq 0x3313(%rip), %rsi      # 0x6031
callq 0x2170
movq (%r14), %rax
movq -0x50(%rbp), %r13
movq (%rax,%r13), %rax
movl (%rax,%r12,8), %esi
movq %r15, %rdi
leaq 0x3355(%rip), %r15      # 0x6091
callq 0x2210
movl $0x2, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2170
movl %ebx, %r12d
movq (%r14), %rcx
movq (%rcx,%r13), %rax
movq 0x8(%rcx,%r13), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
incl %ebx
cmpq %r12, %rcx
ja 0x2cfb
movl $0x9, %edx
movq 0x625e(%rip), %rbx      # 0x8fd8
movq %rbx, %rdi
leaq 0x3310(%rip), %rsi      # 0x6094
callq 0x2170
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %r12
movl (%rax,%r12,4), %esi
movq %rbx, %rdi
callq 0x2210
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
incq %r12
cmpq -0x38(%rbp), %r12
leaq 0x3259(%rip), %r13      # 0x6031
jne 0x2c46
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/NeoResearch[P]dbft3-spork-detect/main.cpp
// Function: verifyFastCommits(std::vector<int, std::allocator<int>>, std::vector<int, std::allocator<int>>, std::vector<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>, std::allocator<std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>>)
vector<int> verifyFastCommits(vector<int> cancels, vector<int> choices, vector<vector<pair<int, int>>> selections)
{
    int N = choices.size();
    int f = (N - 1) / 3;
    vector<int> fast(N, -2);
    for (unsigned i = 0; i < N; i++)
    {
        int sum_zeros = 0;
        int sum_ones = 0;
        if (choices[i] != -2) // exists
        {
            if (cancels[i] == 0)
                sum_zeros++;
            if (cancels[i] == 1)
                sum_ones++;
            for (unsigned k = 0; k < selections[i].size(); k++)
            {
                if (selections[i][k].second == 0)
                    sum_zeros++;
                if (selections[i][k].second == 1)
                    sum_ones++;
            }
        }
        // compute fast commits
        if (sum_ones >= 2 * f + 1) // fast
            fast[i] = 1;
        if (sum_zeros >= f + 1) // fast
            fast[i] = 0;
    }
    return fast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, -0x40(%rbp)
movq %rdx, %r12
movq %rsi, %r15
movq 0x8(%rdx), %r14
subq (%rdx), %r14
shrq $0x2, %r14
movslq %r14d, %r13
leal -0x1(%r14), %ebx
leaq -0x44(%rbp), %rdx
movl $0xfffffffe, (%rdx)     # imm = 0xFFFFFFFE
leaq -0x29(%rbp), %rcx
movq %rdi, -0x38(%rbp)
movq %r13, %rsi
callq 0x4c6c
cmpl $0x1, %r13d
jb 0x2f02
movslq %ebx, %rax
imulq $0x55555556, %rax, %rax # imm = 0x55555556
movq %rax, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rax
addl %ecx, %eax
movq (%r12), %rcx
leal (%rax,%rax), %edx
movq -0x38(%rbp), %rsi
movq (%rsi), %rsi
movl %r14d, %edi
xorl %r8d, %r8d
cmpl $-0x2, (%rcx,%r8,4)
movl $0x0, %r9d
movl $0x0, %r10d
je 0x2edc
movq (%r15), %r9
movl (%r9,%r8,4), %r11d
xorl %r9d, %r9d
testl %r11d, %r11d
sete %r9b
xorl %r10d, %r10d
cmpl $0x1, %r11d
sete %r10b
movq -0x40(%rbp), %r11
movq (%r11), %r14
leaq (%r8,%r8,2), %r12
movq (%r14,%r12,8), %r11
movq 0x8(%r14,%r12,8), %r12
subq %r11, %r12
je 0x2edc
sarq $0x3, %r12
xorl %r14d, %r14d
movl 0x4(%r11,%r14,8), %r13d
cmpl $0x1, %r13d
adcl $0x0, %r9d
xorl %ebx, %ebx
cmpl $0x1, %r13d
sete %bl
addl %ebx, %r10d
incq %r14
movl %r14d, %ebx
cmpq %rbx, %r12
ja 0x2eb8
cmpl %edx, %r10d
jle 0x2ee9
movl $0x1, (%rsi,%r8,4)
cmpl %eax, %r9d
jle 0x2ef6
movl $0x0, (%rsi,%r8,4)
incq %r8
cmpq %rdi, %r8
jne 0x2e69
movq -0x38(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Naomi1745698[P]BigPrac/test.cpp
// Function: test::meteorTesting()
void test::meteorTesting(){
	PASS = 0;
	std::cout << "the meteor size is: " << meteor1->getHealth() << std::endl;
	if(meteor1->getHealth() == 25){
		PASS++;
	}else{
		PASS--;
		std::cout << "ERROR meteorsize" << std::endl;
	};
	std::cout << "set meteor size to original + 20" << std::endl;
	meteor1->setHealth(20); //adds 20 to size
	std::cout << "the meteor size is: " << meteor1->getHealth() << std::endl;
	if(meteor1->getHealth() == 45){
		PASS++;
	}else{
		PASS--;
		std::cout << "ERROR set meteorsize" << std::endl;
	}
	if(PASS == 2){
		std::cout << "<---------------------PASS---------------->" << std::endl;		
	};
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x0, 0x74(%rdi)
movq 0x4be2(%rip), %rbx      # 0xcfd8
leaq 0x16cb(%rip), %rsi      # 0x9ac8
movl $0x14, %edx
movq %rbx, %rdi
callq 0x21e0
movq 0x38(%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rbx, %rdi
movl %eax, %esi
callq 0x2290
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r15, %rdi
callq 0x2050
movq %rax, %rdi
callq 0x20d0
movq 0x38(%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
movl 0x74(%r14), %ecx
cmpl $0x19, %eax
jne 0x8461
incl %ecx
movl %ecx, 0x74(%r14)
jmp 0x84a2
decl %ecx
movl %ecx, 0x74(%r14)
leaq 0x166f(%rip), %rsi      # 0x9add
movl $0x10, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2050
movq %rax, %rdi
callq 0x20d0
leaq 0x1645(%rip), %rsi      # 0x9aee
movl $0x20, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2050
movq %rax, %rdi
callq 0x20d0
movq 0x38(%r14), %rdi
movq (%rdi), %rax
movl $0x14, %esi
callq *0x10(%rax)
leaq 0x15d5(%rip), %rsi      # 0x9ac8
movl $0x14, %edx
movq %rbx, %rdi
callq 0x21e0
movq 0x38(%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rbx, %rdi
movl %eax, %esi
callq 0x2290
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r15, %rdi
callq 0x2050
movq %rax, %rdi
callq 0x20d0
movq 0x38(%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
movl 0x74(%r14), %ecx
cmpl $0x2d, %eax
jne 0x8557
incl %ecx
movl %ecx, 0x74(%r14)
jmp 0x8598
decl %ecx
movl %ecx, 0x74(%r14)
leaq 0x15ab(%rip), %rsi      # 0x9b0f
movl $0x14, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2050
movq %rax, %rdi
callq 0x20d0
cmpl $0x2, 0x74(%r14)
jne 0x85df
leaq 0x1493(%rip), %rsi      # 0x9a39
movl $0x2b, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2050
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x20d0
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Naomi1745698[P]BigPrac/test.cpp
// Function: test::~test()
test::~test(){
	delete playerShip;
	delete playerShip1;	
	delete planet1;
	delete meteor1;

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
testq %r14, %r14
je 0x860b
movq %r14, %rdi
callq 0x35c2
movl $0x40, %esi
movq %r14, %rdi
callq 0x21a0
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x8629
movq %r14, %rdi
callq 0x35c2
movl $0x40, %esi
movq %r14, %rdi
callq 0x21a0
movq 0x30(%rbx), %r14
testq %r14, %r14
je 0x8647
movq %r14, %rdi
callq 0x30b2
movl $0x38, %esi
movq %r14, %rdi
callq 0x21a0
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x8665
movq %r14, %rdi
callq 0x30b2
movl $0x38, %esi
movq %r14, %rdi
callq 0x21a0
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x867d
movq (%rax), %rsi
incq %rsi
callq 0x21a0
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x869b
movq (%rbx), %rsi
incq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH10_GenericAlgorithms/examples/equiv-istream-iter.cc
// Function: main
int main() {
	// use istream_iterator to initialize a vector
	istream_iterator<int> in_iter(cin), eof;  
	vector<int> vec(in_iter, eof);  

	for (auto it : vec)
		cout << it << " ";
	cout << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq 0x2d1e(%rip), %rax      # 0x3fe0
leaq -0x70(%rbp), %rbx
movq %rax, (%rbx)
movb $0x1, 0xc(%rbx)
movq %rbx, %rdi
callq 0x1440
movq (%rbx), %rax
leaq -0x60(%rbp), %rsi
movq %rax, (%rsi)
movl 0x8(%rbx), %eax
movl %eax, 0x8(%rsi)
movb 0xc(%rbx), %al
movb %al, 0xc(%rsi)
leaq -0x50(%rbp), %rdx
movq $0x0, (%rdx)
movl $0x0, 0x8(%rdx)
movb $0x0, 0xc(%rdx)
leaq -0x40(%rbp), %rbx
leaq -0x21(%rbp), %rcx
movq %rbx, %rdi
callq 0x13c4
movq (%rbx), %r15
movq 0x8(%rbx), %r12
cmpq %r12, %r15
je 0x134f
movq 0x2cac(%rip), %rbx      # 0x3fd0
leaq 0xcd9(%rip), %r14       # 0x2004
movl (%r15), %esi
movq %rbx, %rdi
callq 0x1140
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x10f0
addq $0x4, %r15
cmpq %r12, %r15
jne 0x132b
movq 0x2c7a(%rip), %rdi      # 0x3fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x10c0
movsbl %al, %esi
movq 0x2c5f(%rip), %rdi      # 0x3fd0
callq 0x1030
movq %rax, %rdi
callq 0x1090
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x1393
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x10e0
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13a4
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x13bc
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x10e0
movq %rbx, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O1/HQarroum[P]thread-pool/examples/one-producer-many-consumers/main.cpp
// Function: main
int main() {

  // A list of futures.
  std::list<std::future<void>> list;

  // Producer and consumer thread pools.
  thread::pool::parameterized_pool_t<1, 0> pool_of_consumers(std::thread::hardware_concurrency() + 1);

  // Scheduling the producers.
  for (size_t i = 0; i < work_to_spawn; ++i) {
    list.push_back(pool_of_consumers.schedule(static_void_function));
  }
  
  // Counting the start time.
  auto start = std::chrono::high_resolution_clock::now();

  // Waiting for the consumers to complete.
  for (std::future<void>& future : list) {
    future.wait();
  }

  // Measuring and dumping the elapsed time.
  auto end = std::chrono::high_resolution_clock::now();
  std::chrono::duration<double, std::milli> diff = end - start;
  std::cout << "Elasped time : " << diff.count() << " ms" << std::endl;

  return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp            # imm = 0x2C8
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq $0x0, 0x10(%rax)
callq 0x32d0
leal 0x1(%rax), %esi
leaq 0x30(%rsp), %rdi
callq 0x37f0
movl $0x2710, %r13d          # imm = 0x2710
leaq 0x169(%rip), %r14       # 0x37b9
leaq 0x8(%rsp), %r15
leaq 0x30(%rsp), %r12
xorl %ebp, %ebp
leaq 0x18(%rsp), %rbx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x38b8
movl $0x20, %edi
callq 0x3240
movq 0x8(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %rbp, 0x18(%rax)
movq 0x10(%rsp), %rcx
movq %rbp, 0x10(%rsp)
movq %rcx, 0x18(%rax)
movq %rbp, 0x8(%rsp)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3060
incq 0x28(%rsp)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x36b8
callq 0x3b16
decq %r13
jne 0x3661
callq 0x3050
movq %rax, %r14
movq %rbx, %r15
movq (%r15), %r15
cmpq %rbx, %r15
je 0x36db
leaq 0x10(%r15), %rdi
callq 0x3a7a
jmp 0x36c8
callq 0x3050
movq %rax, %rbx
movq 0x88ce(%rip), %rdi      # 0xbfb8
leaq 0x392f(%rip), %rsi      # 0x7020
movl $0xf, %edx
callq 0x3280
subq %r14, %rbx
cvtsi2sd %rbx, %xmm0
divsd 0x38fd(%rip), %xmm0     # 0x7008
movq 0x88a6(%rip), %rdi      # 0xbfb8
callq 0x3310
movq %rax, %rbx
leaq 0x390f(%rip), %rsi      # 0x7030
movl $0x3, %edx
movq %rax, %rdi
callq 0x3280
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3170
leaq 0x30(%rsp), %rdi
callq 0x3a92
leaq 0x18(%rsp), %rdi
callq 0x3b86
xorl %eax, %eax
addq $0x2c8, %rsp            # imm = 0x2C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x3793
jmp 0x3786
jmp 0x3786
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3a92
leaq 0x18(%rsp), %rdi
callq 0x3b86
movq %rbx, %rdi
callq 0x3390
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3789
callq 0x3b16
jmp 0x3789
// File: /workspace/github_cpp_makefile_star2_O1/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/thread_pool.hpp
// Function: std::future<std::result_of<void (& ())()>::type> thread::pool::parameterized_pool_t<1ul, 0l>::schedule<void (&)()>(void (&)())
std::future<typename std::result_of<F(Args...)>::type> schedule(F&& f, Args&&... args) {
        using return_type = typename std::result_of<F(Args...)>::type;
        auto task = std::make_shared<std::packaged_task<return_type()>>(
          std::bind(std::forward<F>(f), std::forward<Args>(args)...)
        );
        std::future<return_type> future = task->get_future();
        if (!tasks_.enqueue([task] () { (*task)(); })) {
          throw std::length_error("Couldn't enqueue the given callable object");
        }
        return (future);
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rcx
movq %rdx, (%rcx)
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rsi
callq 0x4d9a
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x4d2a
movq 0x10(%rsp), %r12
movq 0x18(%rsp), %r15
testq %r15, %r15
je 0x3922
movq 0x869e(%rip), %rax      # 0xbfb0
cmpb $0x0, (%rax)
je 0x391d
incl 0x8(%r15)
jmp 0x3922
lock
incl 0x8(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movl $0x10, %edi
callq 0x3240
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq %rax, 0x20(%rsp)
leaq 0x300e(%rip), %rax      # 0x695a
movq %rax, 0x38(%rsp)
leaq 0x3022(%rip), %rax      # 0x697a
movq %rax, 0x30(%rsp)
leaq 0x18(%r14), %rdi
callq 0x5b6a
testq %rax, %rax
je 0x397c
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x5e54
movl %eax, %ebp
jmp 0x397e
xorl %ebp, %ebp
testb %bpl, %bpl
je 0x3994
movq 0x288(%r14), %rdi
movl $0x1, %esi
callq 0x5afc
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x39ad
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
testb %bpl, %bpl
je 0x39d1
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x39c1
callq 0x3b16
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x3100
movq %rax, %r15
leaq 0x3d34(%rip), %rsi      # 0x7719
movq %rax, %rdi
callq 0x3290
movq 0x85dc(%rip), %rsi      # 0xbfd0
movq 0x85a5(%rip), %rdx      # 0xbfa0
movq %r15, %rdi
callq 0x3380
movq %rax, %r14
jmp 0x3a4d
movq %rax, %r14
movq %r15, %rdi
callq 0x3180
jmp 0x3a4d
jmp 0x3a72
movq %rax, %r14
jmp 0x3a40
movq %rax, %r14
jmp 0x3a5b
movq %rax, %r14
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x3a3d
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorl %r15d, %r15d
testq %r15, %r15
je 0x3a4d
movq %r15, %rdi
callq 0x3b16
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3a5b
callq 0x3b16
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x3a6a
callq 0x3b16
movq %r14, %rdi
callq 0x3390
movq %rax, %rdi
callq 0x3b0b
// File: /workspace/github_cpp_makefile_star2_O1/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/concurrent_queue.hpp
// Function: moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::ConcurrentQueue(unsigned long)
explicit ConcurrentQueue(size_t capacity = 6 * BLOCK_SIZE)
		: producerListTail(nullptr),
		producerCount(0),
		initialBlockPoolIndex(0),
		nextExplicitConsumerId(0),
		globalExplicitConsumerOffset(0)
	{
		implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
		populate_initial_implicit_producer_hash();
		populate_initial_block_list(capacity / BLOCK_SIZE + ((capacity & (BLOCK_SIZE - 1)) == 0 ? 0 : 1));
		
#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
		// Track all the producers using a fully-resolved typed list for
		// each kind; this makes it possible to debug them starting from
		// the root queue object (otherwise wacky casts are needed that
		// don't compile in the debugger's expression evaluator).
		explicitProducers.store(nullptr, std::memory_order_relaxed);
		implicitProducers.store(nullptr, std::memory_order_relaxed);
#endif
	}

// Assembly:
xorl %eax, %eax
movq %rax, (%rdi)
movl $0x0, 0x8(%rdi)
movq %rax, 0x10(%rdi)
movq %rax, 0x28(%rdi)
movl $0x60, %eax
movq $0x0, (%rdi,%rax)
addq $0x10, %rax
cmpq $0x260, %rax            # imm = 0x260
jne 0x3ecd
leaq 0x58(%rdi), %rcx
movq $0x0, 0x25c(%rdi)
movb $0x0, 0x258(%rdi)
movq $0x0, 0x38(%rdi)
leaq 0x40(%rdi), %rax
movq $0x20, 0x40(%rdi)
movq %rcx, 0x48(%rdi)
movl $0x58, %ecx
movq $0x0, (%rdi,%rcx)
addq $0x10, %rcx
cmpq $0x258, %rcx            # imm = 0x258
jne 0x3f14
movq $0x0, 0x50(%rdi)
movq %rax, 0x30(%rdi)
movq %rsi, %rax
shrq $0x5, %rax
andl $0x1f, %esi
cmpq $0x1, %rsi
sbbq $-0x1, %rax
movq %rax, %rsi
jmp 0x403e
nop
// File: /workspace/github_cpp_makefile_star2_O1/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/concurrent_queue.hpp
// Function: moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::~ConcurrentQueue()
~ConcurrentQueue()
	{
		// Destroy producers
		auto ptr = producerListTail.load(std::memory_order_relaxed);
		while (ptr != nullptr) {
			auto next = ptr->next_prod();
			if (ptr->token != nullptr) {
				ptr->token->producer = nullptr;
			}
			destroy(ptr);
			ptr = next;
		}
		
		// Destroy implicit producer hash tables
		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE != 0) {
			auto hash = implicitProducerHash.load(std::memory_order_relaxed);
			while (hash != nullptr) {
				auto prev = hash->prev;
				if (prev != nullptr) {		// The last hash is part of this object and was not allocated dynamically
					for (size_t i = 0; i != hash->capacity; ++i) {
						hash->entries[i].~ImplicitProducerKVP();
					}
					hash->~ImplicitProducerHash();
					(Traits::free)(hash);
				}
				hash = prev;
			}
		}
		
		// Destroy global free list
		auto block = freeList.head_unsafe();
		while (block != nullptr) {
			auto next = block->freeListNext.load(std::memory_order_relaxed);
			if (block->dynamicallyAllocated) {
				destroy(block);
			}
			block = next;
		}
		
		// Destroy initial free list
		destroy_array(initialBlockPool, initialBlockPoolSize);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x3fb6
movq 0x8(%r14), %r15
movq 0x18(%r14), %rax
leaq -0x8(%r15), %r12
testq %r15, %r15
cmoveq %r15, %r12
testq %rax, %rax
je 0x3f9e
movq $0x0, (%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq %r14, %rdi
callq 0x32a0
movq %r12, %r14
testq %r15, %r15
jne 0x3f7f
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x3fd9
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x3fd9
movq %rax, %r14
callq 0x32a0
movq 0x10(%r14), %rax
movq %r14, %rdi
jmp 0x3fc3
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x3fff
movq 0x438(%rdi), %r14
cmpb $0x1, 0x441(%rdi)
jne 0x3ff7
callq 0x32a0
movq %r14, %rdi
testq %r14, %r14
jne 0x3fe2
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x400f
cmpq $0x0, 0x20(%rbx)
je 0x401f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x32a0
leaq 0x300e(%rip), %rdi      # 0x7034
leaq 0x3011(%rip), %rsi      # 0x703e
leaq 0x30f7(%rip), %rcx      # 0x712b
movl $0xe1f, %edx            # imm = 0xE1F
callq 0x3150
// File: /workspace/github_cpp_makefile_star2_O1/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/concurrent_queue.hpp
// Function: moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::populate_initial_block_list(unsigned long)
void populate_initial_block_list(size_t blockCount)
	{
		initialBlockPoolSize = blockCount;
		if (initialBlockPoolSize == 0) {
			initialBlockPool = nullptr;
			return;
		}
		
		initialBlockPool = create_array<Block>(blockCount);
		if (initialBlockPool == nullptr) {
			initialBlockPoolSize = 0;
		}
		for (size_t i = 0; i < initialBlockPoolSize; ++i) {
			initialBlockPool[i].dynamicallyAllocated = false;
		}
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, 0x20(%rdi)
testq %rsi, %rsi
je 0x4096
movq %rsi, %r14
imulq $0x448, %rsi, %rdi      # imm = 0x448
callq 0x32c0
testq %rax, %rax
je 0x40a0
movq %rax, %rcx
addq $0x441, %rcx            # imm = 0x441
xorps %xmm0, %xmm0
movl $0x0, -0x11(%rcx)
movq $0x0, -0x9(%rcx)
movw $0x100, -0x1(%rcx)      # imm = 0x100
movups %xmm0, -0x41(%rcx)
addq $0x448, %rcx            # imm = 0x448
decq %r14
jne 0x406f
jmp 0x40a2
movq $0x0, 0x18(%rbx)
jmp 0x40d0
xorl %eax, %eax
movq %rax, 0x18(%rbx)
testq %rax, %rax
jne 0x40b3
movq $0x0, 0x20(%rbx)
movq 0x20(%rbx), %rcx
testq %rcx, %rcx
je 0x40d0
addq $0x441, %rax            # imm = 0x441
movb $0x0, (%rax)
addq $0x448, %rax            # imm = 0x448
decq %rcx
jne 0x40c2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/lightweight_semaphore.hpp
// Function: moodycamel::details::Semaphore::Semaphore(int)
Semaphore(int initialCount = 0)
	{
		assert(initialCount >= 0);
		int rc = sem_init(&m_sema, 0, static_cast<unsigned int>(initialCount));
		assert(rc == 0);
		(void)rc;
	}

// Assembly:
pushq %rax
testl %esi, %esi
js 0x4158
movl %esi, %edx
xorl %esi, %esi
callq 0x31c0
testl %eax, %eax
jne 0x4177
popq %rax
retq
leaq 0x2f05(%rip), %rdi      # 0x7064
leaq 0x2f10(%rip), %rsi      # 0x7076
leaq 0x2f87(%rip), %rcx      # 0x70f4
movl $0xb1, %edx
callq 0x3150
leaq 0x2fa5(%rip), %rdi      # 0x7123
leaq 0x2ef1(%rip), %rsi      # 0x7076
leaq 0x2f68(%rip), %rcx      # 0x70f4
movl $0xb3, %edx
callq 0x3150
// File: /workspace/github_cpp_makefile_star2_O1/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/lightweight_semaphore.hpp
// Function: moodycamel::LightweightSemaphore::waitMany(long, long)
ssize_t waitMany(ssize_t max, std::int64_t timeout_usecs)
	{
		assert(max >= 0);
		ssize_t result = tryWaitMany(max);
		if (result == 0 && max > 0)
			result = waitManyWithPartialSpinning(max, timeout_usecs);
		return result;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
js 0x4375
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x4584
testq %rax, %rax
setne %cl
testq %r14, %r14
sete %dl
orb %cl, %dl
jne 0x436f
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x45e0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2eb5(%rip), %rdi      # 0x7231
leaq 0x2cf3(%rip), %rsi      # 0x7076
leaq 0x2eb0(%rip), %rcx      # 0x723a
movl $0x17b, %edx            # imm = 0x17B
callq 0x3150
// File: /workspace/github_cpp_makefile_star2_O1/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/lightweight_semaphore.hpp
// Function: moodycamel::LightweightSemaphore::tryWaitMany(long)
ssize_t tryWaitMany(ssize_t max)
	{
		assert(max >= 0);
		ssize_t oldCount = m_count.load(std::memory_order_relaxed);
		while (oldCount > 0)
		{
			ssize_t newCount = oldCount > max ? oldCount - max : 0;
			if (m_count.compare_exchange_weak(oldCount, newCount, std::memory_order_acquire, std::memory_order_relaxed))
				return oldCount - newCount;
		}
		return 0;
	}

// Assembly:
testq %rsi, %rsi
js 0x45c0
movq (%rdi), %rax
xorl %edx, %edx
testq %rax, %rax
jle 0x45ba
movq %rax, %r8
subq %rsi, %r8
cmovleq %rdx, %r8
lock
cmpxchgq %r8, (%rdi)
sete %r9b
movq %rax, %r10
subq %r8, %r10
testb %r9b, %r9b
cmovneq %r10, %rcx
testb %r9b, %r9b
je 0x458e
jmp 0x45bc
xorl %ecx, %ecx
movq %rcx, %rax
retq
pushq %rax
leaq 0x2c69(%rip), %rdi      # 0x7231
leaq 0x2aa7(%rip), %rsi      # 0x7076
leaq 0x2cae(%rip), %rcx      # 0x7284
movl $0x16d, %edx            # imm = 0x16D
callq 0x3150
// File: /workspace/github_cpp_makefile_star2_O1/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/lightweight_semaphore.hpp
// Function: moodycamel::LightweightSemaphore::waitManyWithPartialSpinning(long, long)
ssize_t waitManyWithPartialSpinning(ssize_t max, std::int64_t timeout_usecs = -1)
	{
		assert(max > 0);
		ssize_t oldCount;
		int spin = m_maxSpins;
		while (--spin >= 0)
		{
			oldCount = m_count.load(std::memory_order_relaxed);
			if (oldCount > 0)
			{
				ssize_t newCount = oldCount > max ? oldCount - max : 0;
				if (m_count.compare_exchange_strong(oldCount, newCount, std::memory_order_acquire, std::memory_order_relaxed))
					return oldCount - newCount;
			}
			std::atomic_signal_fence(std::memory_order_acquire);
		}
		oldCount = m_count.fetch_sub(1, std::memory_order_acquire);
		if (oldCount <= 0)
		{
			if ((timeout_usecs == 0) || (timeout_usecs < 0 && !m_sema.wait()) || (timeout_usecs > 0 && !m_sema.timed_wait((std::uint64_t)timeout_usecs)))
			{
				while (true)
				{
					oldCount = m_count.load(std::memory_order_acquire);
					if (oldCount >= 0 && m_sema.try_wait())
						break;
					if (oldCount < 0 && m_count.compare_exchange_strong(oldCount, oldCount + 1, std::memory_order_relaxed, std::memory_order_relaxed))
						return 0;
				}
			}
		}
		if (max > 1)
			return 1 + tryWaitMany(max - 1);
		return 1;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rsi, %rsi
jle 0x46c3
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl 0x28(%rdi), %ecx
testl %ecx, %ecx
jle 0x4637
incl %ecx
xorl %edx, %edx
movq (%r14), %rax
testq %rax, %rax
jle 0x4630
movq %rax, %rsi
subq %rbx, %rsi
cmovleq %rdx, %rsi
lock
cmpxchgq %rsi, (%r14)
sete %dil
subq %rsi, %rax
testb %dil, %dil
cmovneq %rax, %r12
testb %dil, %dil
jne 0x465d
decl %ecx
cmpl $0x1, %ecx
jg 0x4606
lock
decq (%r14)
jl 0x466a
movl $0x1, %r12d
cmpq $0x1, %rbx
je 0x465d
decq %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4584
movq %rax, %r12
incq %r12
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
testq %r15, %r15
je 0x4693
jns 0x467e
leaq 0x8(%r14), %rdi
callq 0x46e2
testb %al, %al
je 0x4693
testq %r15, %r15
jle 0x463d
leaq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x470e
testb %al, %al
jne 0x463d
leaq 0x8(%r14), %r15
xorl %r12d, %r12d
movq (%r14), %r13
testq %r13, %r13
js 0x46ae
movq %r15, %rdi
callq 0x47ac
testb %al, %al
jne 0x463d
testq %r13, %r13
jns 0x469a
leaq 0x1(%r13), %rcx
movq %r13, %rax
lock
cmpxchgq %rcx, (%r14)
jne 0x469a
jmp 0x465d
leaq 0x2bf9(%rip), %rdi      # 0x72c3
leaq 0x29a5(%rip), %rsi      # 0x7076
leaq 0x2bf3(%rip), %rcx      # 0x72cb
movl $0x12c, %edx            # imm = 0x12C
callq 0x3150
// File: /workspace/github_cpp_makefile_star2_O1/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/lightweight_semaphore.hpp
// Function: moodycamel::details::Semaphore::timed_wait(unsigned long)
bool timed_wait(std::uint64_t usecs)
	{
		struct timespec ts;
		const int usecs_in_1_sec = 1000000;
		const int nsecs_in_1_sec = 1000000000;
		clock_gettime(CLOCK_REALTIME, &ts);
		ts.tv_sec += (time_t)(usecs / usecs_in_1_sec);
		ts.tv_nsec += (long)(usecs % usecs_in_1_sec) * 1000;
		// sem_timedwait bombs if you have more than 1e9 in tv_nsec
		// so we have to clean things up before passing it in
		if (ts.tv_nsec >= nsecs_in_1_sec) {
			ts.tv_nsec -= nsecs_in_1_sec;
			++ts.tv_sec;
		}

		int rc;
		do {
			rc = sem_timedwait(&m_sema, &ts);
		} while (rc == -1 && errno == EINTR);
		return rc == 0;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
xorl %edi, %edi
movq %r15, %rsi
callq 0x31f0
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
movq %r14, %rax
mulq %rcx
shrq $0x12, %rdx
imulq $0xf4240, %rdx, %rax    # imm = 0xF4240
addq (%r15), %rdx
movq %rdx, (%r15)
subq %rax, %r14
imulq $0x3e8, %r14, %rax      # imm = 0x3E8
addq 0x8(%r15), %rax
movq %rax, 0x8(%r15)
cmpq $0x3b9aca00, %rax       # imm = 0x3B9ACA00
jl 0x477b
addq $-0x3b9aca00, %rax      # imm = 0xC4653600
movq %rax, 0x10(%rsp)
incq %rdx
movq %rdx, 0x8(%rsp)
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3320
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x479c
callq 0x3040
cmpl $0x4, (%rax)
je 0x4780
testl %ebp, %ebp
sete %al
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/lightweight_semaphore.hpp
// Function: moodycamel::LightweightSemaphore::signal(long)
void signal(ssize_t count = 1)
	{
		assert(count >= 0);
		ssize_t oldCount = m_count.fetch_add(count, std::memory_order_release);
		ssize_t toRelease = -oldCount < count ? -oldCount : count;
		if (toRelease > 0)
		{
			m_sema.signal((int)toRelease);
		}
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
js 0x5b4a
movq %rdi, %rbx
movq %rsi, %r14
lock
xaddq %r14, (%rdi)
negq %r14
cmpq %rsi, %r14
cmovgeq %rsi, %r14
testq %r14, %r14
jle 0x5b42
testl %r14d, %r14d
jle 0x5b42
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x3360
cmpl $-0x1, %eax
je 0x5b28
leal -0x1(%r14), %eax
cmpl $0x1, %r14d
movl %eax, %r14d
jg 0x5b28
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x23bf(%rip), %rdi      # 0x7f10
leaq 0x151e(%rip), %rsi      # 0x7076
leaq 0x23bc(%rip), %rcx      # 0x7f1b
movl $0x18b, %edx            # imm = 0x18B
callq 0x3150
nop
// File: /workspace/github_cpp_makefile_star2_O1/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/concurrent_queue.hpp
// Function: moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::recycle_or_create_producer(bool, bool&)
ProducerBase* recycle_or_create_producer(bool isExplicit, bool& recycled)
	{
#ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODHASH
		debug::DebugLock lock(implicitProdMutex);
#endif
		// Try to re-use one first
		for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
			if (ptr->inactive.load(std::memory_order_relaxed) && ptr->isExplicit == isExplicit) {
				bool expected = true;
				if (ptr->inactive.compare_exchange_strong(expected, /* desired */ false, std::memory_order_acquire, std::memory_order_relaxed)) {
					// We caught one! It's been marked as activated, the caller can have it
					recycled = true;
					return ptr;
				}
			}
		}
		
		recycled = false;
		return add_producer(isExplicit ? static_cast<ProducerBase*>(create<ExplicitProducer>(this)) : create<ImplicitProducer>(this));
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rcx
testq %rcx, %rcx
sete %dil
je 0x605b
xorl %r8d, %r8d
movb 0x10(%rcx), %al
testb $0x1, %al
je 0x6044
cmpb %sil, 0x48(%rcx)
jne 0x6044
movb $0x1, %al
lock
cmpxchgb %r8b, 0x10(%rcx)
sete %al
jne 0x6040
movb $0x1, (%rdx)
movq %rcx, %r14
testb %al, %al
jne 0x605b
movq 0x8(%rcx), %rax
leaq -0x8(%rax), %rcx
testq %rax, %rax
sete %dil
cmoveq %rax, %rcx
jne 0x6020
jmp 0x605b
testb $0x1, %dil
je 0x6114
movb $0x0, (%rdx)
testb %sil, %sil
je 0x608c
movl $0x88, %edi
callq 0x32c0
testq %rax, %rax
je 0x60e3
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6120
jmp 0x60e6
movl $0x68, %edi
callq 0x32c0
testq %rax, %rax
je 0x60e3
movq %rax, %r14
xorl %eax, %eax
movq %rax, 0x8(%r14)
movb $0x0, 0x10(%r14)
movq %rax, 0x18(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r14)
movups %xmm0, 0x30(%r14)
movups %xmm0, 0x39(%r14)
movq %rbx, 0x50(%r14)
leaq 0x5c5e(%rip), %rcx      # 0xbd28
movq %rcx, (%r14)
movq $0x20, 0x58(%r14)
movq %rax, 0x60(%r14)
movq %r14, %rdi
callq 0x64a6
jmp 0x60e6
xorl %r14d, %r14d
testq %r14, %r14
je 0x6111
lock
incl 0x8(%rbx)
movq (%rbx), %rcx
leaq 0x8(%rcx), %rax
testq %rcx, %rcx
cmoveq %rcx, %rax
movq %rax, 0x8(%r14)
movq %rcx, %rax
lock
cmpxchgq %r14, (%rbx)
cmovneq %rax, %rcx
jne 0x60f2
jmp 0x6114
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/concurrent_queue.hpp
// Function: moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::ExplicitProducer::ExplicitProducer(moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>*)
explicit ExplicitProducer(ConcurrentQueue* parent_) :
			ProducerBase(parent_, true),
			blockIndex(nullptr),
			pr_blockIndexSlotsUsed(0),
			pr_blockIndexSize(EXPLICIT_INITIAL_INDEX_SIZE >> 1),
			pr_blockIndexFront(0),
			pr_blockIndexEntries(nullptr),
			pr_blockIndexRaw(nullptr)
		{
			size_t poolBasedIndexSize = details::ceil_to_pow_2(parent_->initialBlockPoolSize) >> 1;
			if (poolBasedIndexSize > pr_blockIndexSize) {
				pr_blockIndexSize = poolBasedIndexSize;
			}
			
			new_block_index(0);		// This creates an index with double the number of current entries, i.e. EXPLICIT_INITIAL_INDEX_SIZE
		}

// Assembly:
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movq %rax, 0x40(%rdi)
movb $0x1, 0x48(%rdi)
movq %rsi, 0x50(%rdi)
leaq 0x5b4c(%rip), %rcx      # 0xbc98
movq %rcx, (%rdi)
movups %xmm0, 0x58(%rdi)
movq $0x10, 0x68(%rdi)
movups %xmm0, 0x70(%rdi)
movq %rax, 0x80(%rdi)
movq 0x20(%rsi), %rax
decq %rax
movq %rax, %rcx
shrq %rcx
orq %rax, %rcx
movq %rcx, %rdx
shrq $0x2, %rdx
orq %rcx, %rdx
movq %rdx, %rax
shrq $0x4, %rax
orq %rdx, %rax
movl $0x1, %edx
movq %rax, %rsi
leal (,%rdx,8), %ecx
shrq %cl, %rax
orq %rsi, %rax
leaq (%rdx,%rdx), %rcx
cmpq $0x4, %rdx
movq %rcx, %rdx
jb 0x618f
incq %rax
cmpq $0x22, %rax
jb 0x61bc
shrq %rax
movq %rax, 0x68(%rdi)
xorl %esi, %esi
jmp 0x61c4
nop
// File: /workspace/github_cpp_makefile_star2_O1/HQarroum[P]thread-pool/examples/one-producer-many-consumers/./../../includes/concurrent_queue.hpp
// Function: moodycamel::ConcurrentQueue<std::function<void ()>, moodycamel::ConcurrentQueueDefaultTraits>::ExplicitProducer::new_block_index(unsigned long)
bool new_block_index(size_t numberOfFilledSlotsToExpose)
		{
			auto prevBlockSizeMask = pr_blockIndexSize - 1;
			
			// Create the new block
			pr_blockIndexSize <<= 1;
			auto newRawPtr = static_cast<char*>((Traits::malloc)(sizeof(BlockIndexHeader) + std::alignment_of<BlockIndexEntry>::value - 1 + sizeof(BlockIndexEntry) * pr_blockIndexSize));
			if (newRawPtr == nullptr) {
				pr_blockIndexSize >>= 1;		// Reset to allow graceful retry
				return false;
			}
			
			auto newBlockIndexEntries = reinterpret_cast<BlockIndexEntry*>(details::align_for<BlockIndexEntry>(newRawPtr + sizeof(BlockIndexHeader)));
			
			// Copy in all the old indices, if any
			size_t j = 0;
			if (pr_blockIndexSlotsUsed != 0) {
				auto i = (pr_blockIndexFront - pr_blockIndexSlotsUsed) & prevBlockSizeMask;
				do {
					newBlockIndexEntries[j++] = pr_blockIndexEntries[i];
					i = (i + 1) & prevBlockSizeMask;
				} while (i != pr_blockIndexFront);
			}
			
			// Update everything
			auto header = new (newRawPtr) BlockIndexHeader;
			header->size = pr_blockIndexSize;
			header->front.store(numberOfFilledSlotsToExpose - 1, std::memory_order_relaxed);
			header->entries = newBlockIndexEntries;
			header->prev = pr_blockIndexRaw;		// we link the new block to the old one so we can free it later
			
			pr_blockIndexFront = j;
			pr_blockIndexEntries = newBlockIndexEntries;
			pr_blockIndexRaw = newRawPtr;
			blockIndex.store(header, std::memory_order_release);
			
			return true;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x68(%rdi), %r12
leaq (%r12,%r12), %r15
movq %r15, 0x68(%rdi)
movq %r12, %rdi
shlq $0x5, %rdi
addq $0x27, %rdi
callq 0x32c0
testq %rax, %rax
je 0x6249
leaq 0x20(%rax), %rcx
negl %ecx
andl $0x7, %ecx
addq %rax, %rcx
addq $0x20, %rcx
movq 0x60(%rbx), %rdx
testq %rdx, %rdx
je 0x6254
decq %r12
movq 0x70(%rbx), %rsi
movq 0x78(%rbx), %rdi
movq %rsi, %r8
subq %rdx, %r8
andq %r12, %r8
xorl %edx, %edx
movq %rcx, %r9
movq %r8, %r10
shlq $0x4, %r10
incq %rdx
movups (%rdi,%r10), %xmm0
movups %xmm0, (%r9)
incq %r8
andq %r12, %r8
addq $0x10, %r9
cmpq %rsi, %r8
jne 0x6225
jmp 0x6256
btrq $0x3f, %r12
movq %r12, 0x68(%rbx)
jmp 0x6282
xorl %edx, %edx
movq %r15, (%rax)
decq %r14
movq %r14, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq 0x80(%rbx), %rsi
movq %rsi, 0x18(%rax)
movq %rdx, 0x70(%rbx)
movq %rcx, 0x78(%rbx)
movq %rax, 0x80(%rbx)
movq %rax, 0x58(%rbx)
testq %rax, %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq