LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sbme-tutorials[P]huffman-encoding/huffman.cpp
// Function: Huffman::encode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Huffman::encode(std::string outputFile)
{
    readInput();
    computeProb();
    buildTree();
    sizeOfEncoded = 0;
    for (auto element : input)
    {
        if (codeTable.find(element) != codeTable.end())
        {
            std::string binaryCode = codeTable[element];
            encoded += binaryCode;
        }
    }
    encoded.erase(std::remove(encoded.begin(), encoded.end(), '\0'), encoded.end());
    sizeOfEncoded = encoded.length();
    outputEncoded(outputFile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rsi, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x5030
movq -0xd8(%rbp), %rdi
callq 0x50e0
movq -0xd8(%rbp), %rdi
callq 0x5280
movq -0xd8(%rbp), %rax
movq $0x0, 0xf0(%rax)
addq $0x58, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6eb0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6ee0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6f10
testb $0x1, %al
jne 0x57bc
jmp 0x588a
leaq -0x20(%rbp), %rdi
callq 0x6f50
movq -0xd8(%rbp), %rdi
movb (%rax), %al
movb %al, -0x29(%rbp)
addq $0xa0, %rdi
leaq -0x29(%rbp), %rsi
callq 0x7310
movq -0xd8(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0xa0, %rdi
callq 0x7340
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x72e0
testb $0x1, %al
jne 0x580f
jmp 0x587a
movq -0xd8(%rbp), %rdi
addq $0xa0, %rdi
leaq -0x29(%rbp), %rsi
callq 0x7200
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x3130
movq -0xd8(%rbp), %rdi
movq -0xe8(%rbp), %rsi
addq $0xd0, %rdi
callq 0x3390
jmp 0x5855
leaq -0x60(%rbp), %rdi
callq 0x31d0
jmp 0x587a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x31d0
jmp 0x59ad
jmp 0x587c
leaq -0x20(%rbp), %rdi
callq 0x7050
jmp 0x57a6
movq -0xd8(%rbp), %rdi
addq $0xd0, %rdi
movq %rdi, -0xf8(%rbp)
callq 0x3270
movq -0xf8(%rbp), %rdi
movq %rax, -0x88(%rbp)
callq 0x3190
movq %rax, -0x90(%rbp)
movb $0x0, -0x91(%rbp)
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rsi
leaq -0x91(%rbp), %rdx
callq 0x7370
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x73c0
movq -0xf8(%rbp), %rdi
callq 0x3190
movq %rax, -0xa8(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x73c0
movq -0xf8(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0xa0(%rbp), %rdx
callq 0x30a0
movq -0xf8(%rbp), %rdi
movq %rax, -0xb0(%rbp)
callq 0x3430
movq -0xe0(%rbp), %rsi
movq %rax, %rcx
movq -0xd8(%rbp), %rax
movq %rcx, 0xf0(%rax)
leaq -0xd0(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x3130
movq -0xd8(%rbp), %rdi
movq -0xf0(%rbp), %rsi
callq 0x59c0
jmp 0x5980
leaq -0xd0(%rbp), %rdi
callq 0x31d0
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x31d0
movq -0x68(%rbp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH15_ObjectOrientedProgramming/examples/useQuote.cc
// Function: main
int main()
{
	Quote base("0-201-82470-1", 50);
	print_total(cout, base, 10);    // calls Quote::net_price
	
	Bulk_quote derived("0-201-82470-1", 50, 5, .19);
	print_total(cout, derived, 10); // calls Bulk_quote::net_price
	
	Quote *baseP = &derived;
	
	// calls the version from the base class 
	// regardless of the dynamic type of baseP
	double undiscounted = baseP->Quote::net_price(42);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
leaq -0x51(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x2100
movq -0xe8(%rbp), %rdx
leaq 0xd77(%rip), %rsi       # 0x3040
leaq -0x50(%rbp), %rdi
callq 0x20d0
jmp 0x22d4
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movsd 0xd24(%rip), %xmm0      # 0x3008
callq 0x24a0
jmp 0x22eb
leaq -0x50(%rbp), %rdi
callq 0x2050
leaq -0x51(%rbp), %rdi
callq 0x20c0
movq 0x2cd4(%rip), %rdi      # 0x4fd8
leaq -0x30(%rbp), %rsi
movl $0xa, %edx
callq 0x2750
jmp 0x2314
leaq -0xc9(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x2100
movq -0xf0(%rbp), %rdx
leaq 0xd0b(%rip), %rsi       # 0x3040
leaq -0xc8(%rbp), %rdi
callq 0x20d0
jmp 0x2343
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
movsd 0xcaf(%rip), %xmm0      # 0x3008
movl $0x5, %edx
movsd 0xcaa(%rip), %xmm1      # 0x3010
callq 0x24f0
jmp 0x236d
leaq -0xc8(%rbp), %rdi
callq 0x2050
leaq -0xc9(%rbp), %rdi
callq 0x20c0
movq 0x2c4c(%rip), %rdi      # 0x4fd8
leaq -0xa8(%rbp), %rsi
movl $0xa, %edx
callq 0x2750
jmp 0x239f
leaq -0xa8(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0xd8(%rbp), %rdi
movl $0x2a, %esi
callq 0x2550
movsd %xmm0, -0xf8(%rbp)
jmp 0x23c8
movsd -0xf8(%rbp), %xmm0
movsd %xmm0, -0xe0(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x2590
leaq -0x30(%rbp), %rdi
callq 0x25b0
xorl %eax, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x241b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2050
leaq -0x51(%rbp), %rdi
callq 0x20c0
jmp 0x2489
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x2480
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x245a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x2050
leaq -0xc9(%rbp), %rdi
callq 0x20c0
jmp 0x2480
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x2590
leaq -0x30(%rbp), %rdi
callq 0x25b0
movq -0x60(%rbp), %rdi
callq 0x20f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH01_GettingStarted/examples/mysum.cc
// Function: main
int main() 
{
	int sum = 0, value = 0;

	// read until end-of-file, calculating a running total of all values read
	while (std::cin >> value) 
		sum += value; // equivalent to sum = sum + value

	std::cout << "Sum is: " << sum << std::endl;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq 0x2ddc(%rip), %rdi      # 0x3fe0
leaq -0xc(%rbp), %rsi
callq 0x1030
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x1070
testb $0x1, %al
jne 0x1222
jmp 0x122d
movl -0xc(%rbp), %eax
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x11fd
movq 0x2d9c(%rip), %rdi      # 0x3fd0
leaq 0xdc9(%rip), %rsi       # 0x2004
callq 0x1050
movq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x1090
movq %rax, %rdi
movq 0x2d6b(%rip), %rsi      # 0x3fc0
callq 0x1060
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: Kobzol[P]sigmod-2016/src/graph.cpp
// Function: Graph::add_edge(unsigned int, unsigned int)
void Graph::add_edge(sigint from, sigint to)
{
    if (from == to) return;
    if (!this->has_vertex(from)) this->add_vertex(from);
    if (!this->has_vertex(to)) this->add_vertex(to);

    Vertex& dest = this->nodes.at(to);

#ifdef CHECK_UNIQUE_EDGES
    for (Vertex* edge : this->nodes.at(from).edges_out)
    {
        if (edge == &dest)
        {
            this->non_unique++;
            return;
        }
    }
#endif

    Vertex& src = this->nodes.at(from);

    src.edges_out.push_back(&dest);
#ifdef USE_UNION_FIND
    src.join(*this, dest);
#endif
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x28(%rsp), %eax
jne 0x261a
jmp 0x26b3
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x2860
testb $0x1, %al
jne 0x263a
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x26c0
movq 0x8(%rsp), %rdi
movl 0x28(%rsp), %esi
callq 0x2860
testb $0x1, %al
jne 0x265a
movq 0x8(%rsp), %rdi
movl 0x28(%rsp), %esi
callq 0x26c0
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2890
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
leaq 0x2c(%rsp), %rsi
callq 0x2890
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x28c0
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rdx
callq 0x9f50
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: Kobzol[P]sigmod-2016/src/graph.cpp
// Function: Graph::remove_edge(unsigned int, unsigned int)
void Graph::remove_edge(sigint from, sigint to)
{
    if (!this->has_vertex(from)) return;

    std::vector<Vertex*>& edges = this->nodes.at(from).edges_out;
    Vertex* address = &this->nodes.at(to);

#ifdef CHECK_UNIQUE_EDGES   // je kontrola uz pri vkladani, neni potreba prochazet vsechny
    size_t size = edges.size();

    for (size_t i = 0; i < size; i++)
    {
        if (edges[i] == address)
        {
            edges.erase(edges.begin() + i);
            return;
        }
    }
#else
    for (size_t i = 0; i < edges.size(); i++)
    {
        if (edges[i] == address)
        {
            edges.erase(edges.begin() + i);
            i--;
        }
    }
#endif
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movl %edx, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl 0x5c(%rsp), %esi
callq 0x2860
testb $0x1, %al
jne 0x271d
jmp 0x2803
movq 0x18(%rsp), %rdi
leaq 0x5c(%rsp), %rsi
callq 0x2890
movq 0x18(%rsp), %rdi
addq $0x8, %rax
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rsi
callq 0x2890
movq %rax, 0x48(%rsp)
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
callq 0x28f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x2803
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x2910
movq (%rax), %rax
cmpq 0x48(%rsp), %rax
jne 0x27ee
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
callq 0x29a0
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x29d0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2a10
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x2930
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x27f0
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x2752
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: Kobzol[P]sigmod-2016/src/thread_pool.h
// Function: Thread::thread_fn()
void thread_fn()
    {
        while (!this->terminated)
        {
            //std::cerr << "Thread " << this->id << " waiting for job" << std::endl;
            Job job = jobQueue.pop_job();
            //std::cerr << "Thread " << this->id << " got job" << std::endl;

#ifndef THREAD_USE_JOB_SYNC
            if (job.type == JobType::Invalid)
            {
                std::this_thread::sleep_for(std::chrono::milliseconds(1));
                continue;
            }
#endif

            int64_t result = 0;
            if (job.type == JobType::AddEdge)
            {
                graph.add_edge(job.from, job.to);
            }
            else if (job.type == JobType::RemoveEdge)
            {
                graph.remove_edge(job.from, job.to);
            }
            else
            {
                result = GraphEvaluator::query(job.from, job.to, job.id, this->id);
            }

            //std::cerr << "Thread " << this->id << " giving job" << std::endl;
            jobQueue.add_result(job, result);
            //std::cerr << "Thread " << this->id << " gave job" << std::endl;
        }
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movb 0x8(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x6364
jmp 0x63f3
leaq 0x10(%rsp), %rdi
leaq 0x3184e8(%rip), %rsi    # 0x31e858
callq 0x64f0
movq $0x0, 0x8(%rsp)
cmpl $0x1, 0x18(%rsp)
jne 0x639b
movl 0x1c(%rsp), %esi
movl 0x20(%rsp), %edx
leaq 0x31825c(%rip), %rdi    # 0x31e5f0
callq 0x25f0
jmp 0x63d8
cmpl $0x2, 0x18(%rsp)
jne 0x63b8
movl 0x1c(%rsp), %esi
movl 0x20(%rsp), %edx
leaq 0x31823f(%rip), %rdi    # 0x31e5f0
callq 0x26f0
jmp 0x63d6
movq (%rsp), %rax
movl 0x1c(%rsp), %edi
movl 0x20(%rsp), %esi
movq 0x10(%rsp), %rdx
movq (%rax), %rcx
callq 0x6620
movq %rax, 0x8(%rsp)
jmp 0x63d8
movq 0x8(%rsp), %rdx
leaq 0x318474(%rip), %rdi    # 0x31e858
leaq 0x10(%rsp), %rsi
callq 0x6900
jmp 0x6352
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: Kobzol[P]sigmod-2016/src/job.h
// Function: JobQueue::pop_job()
Job pop_job()
    {
        std::unique_lock<std::mutex> guard(this->lock);

#ifdef THREAD_USE_JOB_SYNC
        this->bufferEmpty.wait(guard, [this] { return this->is_job_available(); });
#else
        if (!this->is_job_available())
        {
            return Job(JobType::Invalid);
        }
#endif

        Job job = this->jobs[this->start];

        this->start = (this->start + 1) % this->jobs.size;
        this->size--;
        this->jobs_in_work++;

#ifdef THREAD_USE_JOB_SYNC
        if (this->size == this->jobs.capacity - 1)
        {
            this->bufferFull.notify_one();
        }
#endif

        return job;
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x50(%rsp), %rsi
movq %rsi, 0x18(%rsp)
addq $0xb0, %rsi
leaq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x5e40
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rsi
movq %rax, %rdi
addq $0x68, %rdi
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdx
callq 0x6a80
jmp 0x6545
movq 0x18(%rsp), %rax
movq %rax, %rdi
addq $0xd8, %rdi
movl 0xa0(%rax), %esi
callq 0x6ad0
movq %rax, (%rsp)
jmp 0x6565
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
movl $0x30, %edx
callq 0x2190
movq 0x18(%rsp), %rcx
movq 0xa0(%rcx), %rax
addq $0x1, %rax
xorl %edx, %edx
divq 0xd8(%rcx)
movq %rdx, 0xa0(%rcx)
movq 0x98(%rcx), %rax
addq $-0x1, %rax
movq %rax, 0x98(%rcx)
movq (%rcx), %rax
addq $0x1, %rax
movq %rax, (%rcx)
movq 0x98(%rcx), %rax
movq 0xe0(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x65f8
movq 0x18(%rsp), %rdi
addq $0x130, %rdi            # imm = 0x130
callq 0x20d0
jmp 0x65f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5fe0
jmp 0x660c
leaq 0x40(%rsp), %rdi
callq 0x5fe0
movq 0x10(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x2310
nopw %cs:(%rax,%rax)
// File: Kobzol[P]sigmod-2016/src/job.h
// Function: JobQueue::add_result(Job&, long)
void add_result(Job& job, int64_t result)
    {
        std::lock_guard<std::mutex> guard(this->lock);

        if (job.type == JobType::Query)
        {
            this->results.insert({job.id, result});
        }

        job.modifyBarrier->pop();

        this->jobs_in_work--;

#ifdef THREAD_USE_JOB_SYNC
        this->bufferEmpty.notify_one();
#endif

        if (this->batchEnded && this->size == 0 && this->jobs_in_work == 0)
        {
            std::unique_lock<std::mutex> lock(this->jobMutex);
            this->batchEndCV.notify_one();
            this->reset();
        }
    }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rsi
movq %rsi, 0x20(%rsp)
addq $0xb0, %rsi
leaq 0x68(%rsp), %rdi
callq 0x86b0
movq 0x78(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x69a9
movq 0x20(%rsp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, 0x18(%rsp)
movq 0x78(%rsp), %rsi
leaq 0x58(%rsp), %rdi
leaq 0x70(%rsp), %rdx
callq 0x8730
jmp 0x6968
movq 0x18(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x86e0
movb %dl, 0xf(%rsp)
movq %rax, 0x10(%rsp)
jmp 0x6982
movb 0xf(%rsp), %al
movq 0x10(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movb %al, 0x40(%rsp)
jmp 0x69a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x6a5d
movq 0x78(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x8760
jmp 0x69b9
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
addq $-0x1, %rax
movq %rax, (%rdi)
addq $0x68, %rdi
callq 0x20d0
movq 0x20(%rsp), %rax
testb $0x1, 0x60(%rax)
je 0x6a4b
movq 0x20(%rsp), %rax
cmpq $0x0, 0x98(%rax)
jne 0x6a4b
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x6a4b
movq 0x20(%rsp), %rsi
addq $0x8, %rsi
leaq 0x28(%rsp), %rdi
callq 0x5e40
jmp 0x6a0b
movq 0x20(%rsp), %rdi
addq $0x30, %rdi
callq 0x20d0
movq 0x20(%rsp), %rdi
callq 0x8780
jmp 0x6a25
leaq 0x28(%rsp), %rdi
callq 0x5fe0
jmp 0x6a4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x5fe0
jmp 0x6a5d
leaq 0x68(%rsp), %rdi
callq 0x87c0
addq $0x88, %rsp
retq
leaq 0x68(%rsp), %rdi
callq 0x87c0
movq 0x50(%rsp), %rdi
callq 0x2310
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Kobzol[P]sigmod-2016/src/job.h
// Function: JobQueue::reset()
void reset()
    {
        this->batchEnded = false;
        BarrierMemory[0].modification = false;
        BarrierMemory[0].waiting = 0;
        BarrierIndex = 1;
        this->barrier = &BarrierMemory[0];
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movb $0x0, 0x60(%rax)
movb $0x0, 0x8a4b(%rip)      # 0x111e0
movq $0x0, 0x8a48(%rip) # 0x111e8
movq $0x1, 0x315e35(%rip) # 0x31e5e0
leaq 0x8a2e(%rip), %rcx      # 0x111e0
movq %rcx, 0xf0(%rax)
retq
nopw (%rax,%rax)
// File: Kobzol[P]sigmod-2016/src/vector.h
// Function: Vector<Job>::reallocate(unsigned long)
void reallocate(size_t capacity)
	{
		if (this->data != nullptr)
		{
			T* new_data = new T[capacity];
			memcpy(new_data, this->data, this->size * sizeof(T));

			delete[] this->data;

			this->data = new_data;
		}
		else this->data = new T[capacity];

		this->capacity = capacity;

	}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x10(%rax)
je 0x9970
movq 0x78(%rsp), %rax
movq %rax, 0x48(%rsp)
movl $0x30, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x50(%rsp)
cmpq $0x0, %rax
je 0x9901
movq 0x50(%rsp), %rax
movq 0x48(%rsp), %rcx
imulq $0x30, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, 0x38(%rsp)
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x9a40
jmp 0x98e9
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %rax
addq $0x30, %rax
cmpq %rcx, %rax
movq %rax, 0x40(%rsp)
jne 0x98d8
movq 0x58(%rsp), %rax
movq 0x50(%rsp), %rcx
movq %rcx, 0x70(%rsp)
movq 0x70(%rsp), %rdi
movq 0x10(%rax), %rsi
imulq $0x30, (%rax), %rdx
callq 0x2190
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x9940
movq 0x28(%rsp), %rdi
callq 0x2240
movq 0x58(%rsp), %rax
movq 0x70(%rsp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x9a1d
movq 0x50(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
callq 0x2240
jmp 0x9a33
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x30, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x20(%rsp)
cmpq $0x0, %rax
je 0x99f3
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
imulq $0x30, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x9a40
jmp 0x99dc
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
addq $0x30, %rax
cmpq %rcx, %rax
movq %rax, 0x10(%rsp)
jne 0x99cc
movq 0x58(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x9a1d
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
callq 0x2240
jmp 0x9a33
movq 0x58(%rsp), %rax
movq 0x78(%rsp), %rcx
movq %rcx, 0x8(%rax)
addq $0x88, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x2310
nopl (%rax)
// File: Kobzol[P]sigmod-2016/src/vertex.cpp
// Function: Vertex::join(Graph&, Vertex&)
void Vertex::join(Graph& graph, Vertex& vertex)
{
    sigint thisParentId = this->get_parent(graph);
    sigint otherParentId = vertex.get_parent(graph);

    if (thisParentId == otherParentId) return;

    Vertex& thisParent = graph.nodes[thisParentId];
    Vertex& otherParent = graph.nodes[otherParentId];

    if (thisParent.rank < otherParent.rank)
    {
        thisParent.parent = otherParentId;
    }
    else if (thisParent.rank > otherParent.rank)
    {
        otherParent.parent = thisParentId;
    }
    else
    {
        otherParent.parent = thisParentId;
        thisParent.rank++;
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x9ef0
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x9ef0
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x18(%rsp), %eax
jne 0x9f98
jmp 0xa03e
movq 0x28(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x6be0
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x6be0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0xe8(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0xe8(%rcx), %rax
jae 0x9feb
movl 0x18(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xe0(%rax)
jmp 0xa03e
movq 0x10(%rsp), %rax
movq 0xe8(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0xe8(%rcx), %rax
jbe 0xa016
movl 0x1c(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0xe0(%rax)
jmp 0xa03c
movl 0x1c(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0xe0(%rax)
movq 0x10(%rsp), %rax
movq 0xe8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe8(%rax)
jmp 0xa03e
addq $0x38, %rsp
retq
// File: Jiro-iwai[P]yuv2psnr/yuv2psnr.cpp
// Function: MSE(unsigned char*, unsigned char*, unsigned int, double&)
void MSE
( unsigned char* c0
, unsigned char* c1
, unsigned int min_read_unit
, double& MSE
)
{
  for( int i = 0; i < min_read_unit; i++ ) {
    unsigned char I = c0[i];
    unsigned char K = c1[i];
    int diff = I - K;
    MSE += diff*diff;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq %rcx, -0x20(%rsp)
movl $0x0, -0x24(%rsp)
movl -0x24(%rsp), %eax
cmpl -0x14(%rsp), %eax
jae 0x584e
movq -0x8(%rsp), %rax
movslq -0x24(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x25(%rsp)
movq -0x10(%rsp), %rax
movslq -0x24(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x26(%rsp)
movzbl -0x25(%rsp), %eax
movzbl -0x26(%rsp), %ecx
subl %ecx, %eax
movl %eax, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
imull -0x2c(%rsp), %eax
cvtsi2sd %eax, %xmm0
movq -0x20(%rsp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x57eb
retq
nop
// File: Jiro-iwai[P]yuv2psnr/yuv2psnr.cpp
// Function: MSE2PSNR(double, double)
double MSE2PSNR
( double MSE
, double MAX
)
{
  double PSNR = INFINITY;

  if( DBL_EPSILON < MSE ) {
    PSNR = 10 * log10( (MAX*MAX)/MSE );
  }

  return PSNR;
}

// Assembly:
subq $0x18, %rsp
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd 0xe7a8(%rip), %xmm0     # 0x14010
movsd %xmm0, (%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0xe78d(%rip), %xmm1     # 0x14008
ucomisd %xmm1, %xmm0
jbe 0x58ac
movsd 0x8(%rsp), %xmm0
mulsd 0x8(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
callq 0x51c0
movaps %xmm0, %xmm1
movsd 0xe775(%rip), %xmm0     # 0x14018
mulsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Ahhgust[P]STRaitRazor/str8.cpp
// Function: initQvalLUT(char)
void
initQvalLUT(char qtype) {
  unsigned i;


  if (qtype == EDGAR_QUALITY) {
    // standard quality to probability (of error) computation
    // see https://en.wikipedia.org/wiki/Phred_quality_score
    // we do this A LOT
    // so let's make a LUT
    for(i = 0; i < MAXQVAL; ++i) {
      QUALITY_TO_ERRORPROB[i] = pow(10, i/-10.0);
    }

  } else if (qtype == EXPECT_QUALITY) {

    // we want exp( sum(log( prob correct )) ==
    // prod(prob correct) ==
    // prod(1.0 - prob incorrect)
    for(i = 0; i < MAXQVAL; ++i) {
      QUALITY_TO_ERRORPROB[i] = log(1.0 - pow(10, i/-10.0));
    }

  } else {
    fprintf(stderr, "Illegal quality flag: %u", (int)qtype);
    exit(EXIT_FAILURE);
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %eax
cmpl $0x1, %eax
jne 0x3a66
movl $0x0, -0x8(%rbp)
cmpl $0x100, -0x8(%rbp)      # imm = 0x100
jae 0x3a61
movl -0x8(%rbp), %eax
cvtsi2sd %rax, %xmm0
movsd 0x105d9(%rip), %xmm1    # 0x14010
divsd %xmm1, %xmm0
movl $0xa, %edi
callq 0x8630
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x63312f(%rip), %rax    # 0x636b80
movsd %xmm0, (%rax,%rcx,8)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3a1e
jmp 0x3af7
movsbl -0x1(%rbp), %eax
cmpl $0x2, %eax
jne 0x3acf
movl $0x0, -0x8(%rbp)
cmpl $0x100, -0x8(%rbp)      # imm = 0x100
jae 0x3acd
movl -0x8(%rbp), %eax
cvtsi2sd %rax, %xmm0
movsd 0x10581(%rip), %xmm1    # 0x14010
divsd %xmm1, %xmm0
movl $0xa, %edi
callq 0x8630
movaps %xmm0, %xmm1
movsd 0x10560(%rip), %xmm0    # 0x14008
subsd %xmm1, %xmm0
callq 0x3220
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x6330c3(%rip), %rax    # 0x636b80
movsd %xmm0, (%rax,%rcx,8)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3a76
jmp 0x3af5
movq 0x184f2(%rip), %rax     # 0x1bfc8
movq (%rax), %rdi
movsbl -0x1(%rbp), %edx
leaq 0x10570(%rip), %rsi     # 0x14054
movb $0x0, %al
callq 0x3390
movl $0x1, %edi
callq 0x3330
jmp 0x3af7
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ahhgust[P]STRaitRazor/str8.cpp
// Function: getProbCorrect(char const*, unsigned int)
double
getProbCorrect(const char *qseq, unsigned stop) {

  unsigned i = 0;
  unsigned qval;

  double logsum=0.;

  for(i=0; i < stop && *qseq; ++i, ++qseq) {
    qval = *qseq - PHREDMINUS;
    if (qval < 0)
      qval = 0;
    else if (qval >= MAXQVAL)
      qval = MAXQVAL-1;
    // equivalent to: += log(1-error prob)
    // note that QUALITY_TO_ERRORPROB is constructed differently in this case
    logsum += QUALITY_TO_ERRORPROB[ qval ];
  }
  
  return exp(logsum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %ecx
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0x21(%rbp)
jae 0x3baf
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x3bb8
jmp 0x3c1b
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
subl $0x21, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jae 0x3bd4
movl $0x0, -0x14(%rbp)
jmp 0x3be6
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jb 0x3be4
movl $0xff, -0x14(%rbp)
jmp 0x3be6
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x632f8e(%rip), %rax    # 0x636b80
movsd (%rax,%rcx,8), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x3b95
movsd -0x20(%rbp), %xmm0
callq 0x34b0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Ahhgust[P]STRaitRazor/str8.cpp
// Function: getProbCorrectEdgar(char const*, unsigned int)
double
getProbCorrectEdgar(const char *qseq, unsigned stop) {

  double errorSum=0.;

  unsigned i = 0;
  unsigned qval;
  // From Edgar:
  // Error filtering, pair assembly and error correction for next-generation sequencing reads
  // Expected number of errors for a given (substring of a ) read is
  // the sum of the error probabilities
  for(i=0; i < stop && *qseq; ++i, ++qseq) {

    qval = *qseq - PHREDMINUS;
    if (qval < 0)
      qval = 0;
    else if (qval >= MAXQVAL)
      qval = MAXQVAL-1;

        
    errorSum += QUALITY_TO_ERRORPROB[ qval ];
  }

  if (errorSum >= 1.)
    return 0.;
  
  return 1.0-errorSum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x29(%rbp)
jae 0x3c6b
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x3c74
jmp 0x3cd7
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
subl $0x21, %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jae 0x3c90
movl $0x0, -0x28(%rbp)
jmp 0x3ca2
cmpl $0x100, -0x28(%rbp)     # imm = 0x100
jb 0x3ca0
movl $0xff, -0x28(%rbp)
jmp 0x3ca2
movl -0x28(%rbp), %eax
movl %eax, %ecx
leaq 0x632ed2(%rip), %rax    # 0x636b80
movsd (%rax,%rcx,8), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3c51
movsd -0x20(%rbp), %xmm0
movsd 0x10324(%rip), %xmm1    # 0x14008
ucomisd %xmm1, %xmm0
jb 0x3cf4
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x3d06
movsd 0x1030c(%rip), %xmm0    # 0x14008
subsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: Ahhgust[P]STRaitRazor/str8.cpp
// Function: printReportsMT(_IO_FILE*)
void
printReportsMT(FILE *stream) {
  int i;
  // merge the maps
  for (i=1 ; i < opt.numThreads; ++i) {
    Matches::iterator itr = matches[i].begin();
    // sum up all of the unique haplotypes itr->first
    // with their associated frequency counts
    for( ; itr != matches[i].end(); ++itr) {
      matches[0][ itr->first ].first += itr->second.first;
      matches[0][ itr->first ].second += itr->second.second;
    }
  }
  printReports(stream, matches[0], opt.minPrint,opt.noReverseComplement);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x17a9c(%rip), %eax     # 0x1c2f8
jge 0x4937
movq 0x632b67(%rip), %rdi    # 0x6373d0
movslq -0xc(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
callq 0x8660
movq %rax, -0x18(%rbp)
movq 0x632b4c(%rip), %rdi    # 0x6373d0
movslq -0xc(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
callq 0x8690
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8930
testb $0x1, %al
jne 0x48ab
jmp 0x4927
leaq -0x18(%rbp), %rdi
callq 0x8960
movl 0x18(%rax), %eax
movl %eax, -0x34(%rbp)
movq 0x632b0f(%rip), %rax    # 0x6373d0
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x8960
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x8980
movl -0x34(%rbp), %ecx
addl (%rax), %ecx
movl %ecx, (%rax)
leaq -0x18(%rbp), %rdi
callq 0x8960
movl 0x1c(%rax), %eax
movl %eax, -0x24(%rbp)
movq 0x632ad9(%rip), %rax    # 0x6373d0
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x8960
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x8980
movl -0x24(%rbp), %ecx
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
leaq -0x18(%rbp), %rdi
callq 0x8a60
jmp 0x487d
jmp 0x4929
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4853
movq -0x8(%rbp), %rdi
movq 0x632a8e(%rip), %rsi    # 0x6373d0
movl 0x17990(%rip), %edx     # 0x1c2d8
movb 0x17991(%rip), %al      # 0x1c2df
andb $0x1, %al
movzbl %al, %ecx
callq 0x3d10
addq $0x40, %rsp
popq %rbp
retq
nop
// File: Ahhgust[P]STRaitRazor/str8.cpp
// Function: revcompCstring(char const*, int)
char *
revcompCstring(const char *dna, int len) {
  char *revcompd = new char[ len + 1 ];
  revcompd[len]=0;
  int j=len-1;
  int i=0;
  char c;
  for ( ; i < len; ++i, --j) {
    c = dna[j];
    if (c=='A')
      revcompd[i] = 'T';
    else if (c=='T')
      revcompd[i] = 'A';
    else if (c=='G')
      revcompd[i] = 'C';
    else if (c=='C')
      revcompd[i] = 'G';
    else
      revcompd[i] = c;

  }
  return revcompd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x3030
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4c50
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x41, %eax
jne 0x4bde
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x54, (%rax,%rcx)
jmp 0x4c37
movsbl -0x21(%rbp), %eax
cmpl $0x54, %eax
jne 0x4bf5
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x41, (%rax,%rcx)
jmp 0x4c35
movsbl -0x21(%rbp), %eax
cmpl $0x47, %eax
jne 0x4c0c
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x43, (%rax,%rcx)
jmp 0x4c33
movsbl -0x21(%rbp), %eax
cmpl $0x43, %eax
jne 0x4c23
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x47, (%rax,%rcx)
jmp 0x4c31
movb -0x21(%rbp), %dl
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x4c33
jmp 0x4c35
jmp 0x4c37
jmp 0x4c39
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4bad
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ahhgust[P]STRaitRazor/str8.cpp
// Function: findMatchesOneThread()
void
findMatchesOneThread() {

  bool done=false;

    // a ceiling on the number of matches you can find on a single pass through the trie
  unsigned *matchIds = new unsigned[ numStrs * 4];
  unsigned char *matchTypes = new unsigned char[ numStrs * 4];
  
  records = MEM; // we're only using one of the buffers...
  qrecords=QMEM;
  while (!done) {
    done = buffer(MEM, QMEM);
    processDNA_Trie(0, matchIds, matchTypes);
  }
    
  delete [] matchIds;
  delete [] matchTypes;

  printReports(opt.out, matches[0], opt.minPrint,opt.noReverseComplement);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb $0x0, -0x1(%rbp)
movl 0x630cae(%rip), %eax    # 0x637390
shll $0x2, %eax
movl %eax, %eax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, -0x10(%rbp)
movl 0x630c7e(%rip), %eax    # 0x637390
shll $0x2, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x3030
movq %rax, -0x18(%rbp)
leaq 0x15be7(%rip), %rax     # 0x1c310
movq %rax, 0x6303e0(%rip)    # 0x636b10
leaq 0x322fd9(%rip), %rax    # 0x329710
movq %rax, 0x6303da(%rip)    # 0x636b18
movb -0x1(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x6749
jmp 0x6772
leaq 0x15bc0(%rip), %rdi     # 0x1c310
leaq 0x322fb9(%rip), %rsi    # 0x329710
callq 0x4960
andb $0x1, %al
movb %al, -0x1(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %edi, %edi
callq 0x51d0
jmp 0x673e
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x6789
movq -0x20(%rbp), %rdi
callq 0x3350
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x67a0
movq -0x28(%rbp), %rdi
callq 0x3350
movq 0x15b41(%rip), %rdi     # 0x1c2e8
movq 0x630c22(%rip), %rsi    # 0x6373d0
movl 0x15b24(%rip), %edx     # 0x1c2d8
movb 0x15b25(%rip), %al      # 0x1c2df
andb $0x1, %al
movzbl %al, %ecx
callq 0x3d10
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Ahhgust[P]STRaitRazor/str8.cpp
// Function: writerThread(void*)
void *
writerThread(void *arg) {
  
  done=buffer(MEM, QMEM); // read in a bunch of data
  if (done)
    nextdone = true;

  records = MEM; // set up the pointer
  qrecords=QMEM;
  
  workersWorking= opt.numThreads; // let the workers start processing the data

  unsigned i=0;
  while (! nextdone) {
    ++i;

    if (records == MEM) 
      nextdone=buffer(OTHERMEM, OTHERQMEM);
    else 
      nextdone=buffer(MEM, QMEM);

    buffered=1; // the double buffer is set up

    if (nextdone) {
      break; // no sense waiting...
    }

#ifdef OSX
    sem_wait(writersLock); // wait for the readers to finish reading *records
#else
    sem_wait(&writersLock); // wait for the readers to finish reading *records
#endif
  }

  return NULL;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x14c7d(%rip), %rdi     # 0x1c310
leaq 0x322076(%rip), %rsi    # 0x329710
callq 0x4960
movzbl %al, %esi
andl $0x1, %esi
leaq 0x14c5c(%rip), %rdi     # 0x1c308
callq 0x92d0
leaq 0x14c50(%rip), %rdi     # 0x1c308
callq 0x9180
testb $0x1, %al
jne 0x76c3
jmp 0x76d4
leaq 0x14c3f(%rip), %rdi     # 0x1c309
movl $0x1, %esi
callq 0x92d0
leaq 0x14c35(%rip), %rax     # 0x1c310
movq %rax, 0x62f42e(%rip)    # 0x636b10
leaq 0x322027(%rip), %rax    # 0x329710
movq %rax, 0x62f428(%rip)    # 0x636b18
movl 0x14c02(%rip), %esi     # 0x1c2f8
leaq 0x62f473(%rip), %rdi    # 0x636b70
callq 0x9240
movl $0x0, -0xc(%rbp)
leaq 0x14bf9(%rip), %rdi     # 0x1c309
callq 0x9180
xorb $-0x1, %al
testb $0x1, %al
jne 0x7720
jmp 0x77bb
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
leaq 0x14be0(%rip), %rax     # 0x1c310
cmpq %rax, 0x62f3d9(%rip)    # 0x636b10
jne 0x7760
leaq 0x19b5d0(%rip), %rdi    # 0x1a2d10
leaq 0x4a89c9(%rip), %rsi    # 0x4b0110
callq 0x4960
movzbl %al, %esi
andl $0x1, %esi
leaq 0x14bb0(%rip), %rdi     # 0x1c309
callq 0x92d0
jmp 0x7785
leaq 0x14ba9(%rip), %rdi     # 0x1c310
leaq 0x321fa2(%rip), %rsi    # 0x329710
callq 0x4960
movzbl %al, %esi
andl $0x1, %esi
leaq 0x14b89(%rip), %rdi     # 0x1c309
callq 0x92d0
leaq 0x62f3e8(%rip), %rdi    # 0x636b74
movl $0x1, %esi
callq 0x92d0
leaq 0x14b6c(%rip), %rdi     # 0x1c309
callq 0x9180
testb $0x1, %al
jne 0x77a8
jmp 0x77aa
jmp 0x77bb
leaq 0x62f39f(%rip), %rdi    # 0x636b50
callq 0x3180
jmp 0x7709
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ahhgust[P]STRaitRazor/parseConfig.cpp
// Function: validDNAWithAmbiguities(char const*)
bool
validDNAWithAmbiguities(const char* c) {

    while (*c) {
      if (*c != 'A' && *c != 'C' && *c != 'T' && *c != 'G' && 
	  *c != 'R' && *c != 'Y' && *c != 'S' && *c != 'W' && *c != 'K' && *c != 'M')
	return false;
      ++c;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0xf534
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x41, %eax
je 0xf523
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x43, %eax
je 0xf523
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x54, %eax
je 0xf523
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x47, %eax
je 0xf523
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x52, %eax
je 0xf523
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x59, %eax
je 0xf523
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x53, %eax
je 0xf523
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x57, %eax
je 0xf523
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4b, %eax
je 0xf523
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4d, %eax
je 0xf523
movb $0x0, -0x1(%rbp)
jmp 0xf538
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xf498
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: Ahhgust[P]STRaitRazor/parseConfig.cpp
// Function: validDNA(char const*)
bool
validDNA(const char* c) {

    while (*c) {
      if (*c != 'A' && *c != 'C' && *c != 'T' && *c != 'G')
	return false;
      ++c;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0xf595
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x41, %eax
je 0xf587
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x43, %eax
je 0xf587
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x54, %eax
je 0xf587
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x47, %eax
je 0xf587
movb $0x0, -0x1(%rbp)
jmp 0xf599
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xf548
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
// File: Ahhgust[P]STRaitRazor/lookup.cpp
// Function: setLetter(unsigned long, char, unsigned int)
binaryword
setLetter(binaryword w, char letter, unsigned pos) {


  pos = MAXWORD - 2 - (pos + pos);
  

  if (letter == 'A') { // clear two bits
    w &= ~( ((binaryword)3) << pos);
  } else if (letter == 'C') { // C is 01 in this schema
    w |= ((binaryword)1) << (pos); // set 1 bit to 1
    w &= ~( ((binaryword)1) << (pos+1)); // set the next bit to 0
  } else if (letter == 'G') {
    w |= ((binaryword)1) << (pos+1); //  and vice versa
    w &= ~( ((binaryword)1) << (pos)); //
  } else { // setting two bits
    w |= ((binaryword)3) << (pos);
  }

  return w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %ecx
addl -0x10(%rbp), %ecx
movl $0x3e, %eax
subl %ecx, %eax
movl %eax, -0x10(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x41, %eax
jne 0x10ee8
movl -0x10(%rbp), %eax
movl %eax, %ecx
movl $0x3, %eax
shlq %cl, %rax
xorq $-0x1, %rax
andq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10f7d
movsbl -0x9(%rbp), %eax
cmpl $0x43, %eax
jne 0x10f26
movl -0x10(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
xorq $-0x1, %rax
andq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10f7b
movsbl -0x9(%rbp), %eax
cmpl $0x47, %eax
jne 0x10f64
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
xorq $-0x1, %rax
andq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10f79
movl -0x10(%rbp), %eax
movl %eax, %ecx
movl $0x3, %eax
shlq %cl, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10f7b
jmp 0x10f7d
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ahhgust[P]STRaitRazor/lookup.cpp
// Function: getLetter(unsigned long, unsigned int)
char
getLetter(binaryword w, unsigned pos) {

  pos = MAXWORD - 2 - (pos + pos);  

  binaryword twobit = (w >> pos) & ((binaryword)3);
  if (twobit==0) {
    return 'A';
  } else if (twobit == 1) {
    return 'C';
  } else if (twobit == 2) {
    return 'G';
  }
  return 'T';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %ecx
addl -0x14(%rbp), %ecx
movl $0x3e, %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
shrq %cl, %rax
andq $0x3, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x10fca
movb $0x41, -0x1(%rbp)
jmp 0x10fec
cmpq $0x1, -0x20(%rbp)
jne 0x10fd7
movb $0x43, -0x1(%rbp)
jmp 0x10fec
cmpq $0x2, -0x20(%rbp)
jne 0x10fe4
movb $0x47, -0x1(%rbp)
jmp 0x10fec
jmp 0x10fe6
jmp 0x10fe8
movb $0x54, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ahhgust[P]STRaitRazor/lookup.cpp
// Function: gatcToLong(char*, unsigned int)
binaryword
gatcToLong(char *s, unsigned numChars) {

  unsigned i;
  binaryword num=0;


  for (i=0; i < numChars; ++i, ++s) {
    num = setLetter(num, *s, i);
  }

  return num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x11056
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movb (%rax), %al
movl -0x10(%rbp), %edx
movsbl %al, %esi
callq 0x10ea0
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x1101e
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: Ahhgust[P]STRaitRazor/lookup.cpp
// Function: longToGatc(unsigned long, unsigned int, char*)
void
longToGatc(binaryword num, unsigned numChars, char *buffer) {
  unsigned i;

  memset(buffer, 'A', numChars); // initialize to 'A' (ie, 0)
  
  for (i=0; i < numChars; ++i, ++buffer) {
    *buffer = getLetter(num, i);
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %edx
movl $0x41, %esi
callq 0x3160
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x110c0
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x10f90
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1108d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ahhgust[P]STRaitRazor/lookup.cpp
// Function: reverseComplement(unsigned long*, unsigned long*, unsigned int)
void
reverseComplement(binaryword *in, binaryword *out, unsigned numBases) {

  unsigned j, i = numBases-1;
  unsigned inIndex, inBase, outIndex, outBase, prevOutIndex=UINT_MAX;

  char c;
  for (j=0 ; j < numBases; --i, ++j) {
    inIndex = i/(MAXWORD/2);
    inBase = i % (MAXWORD/2);
    c = getLetter(in[inIndex], inBase);
    if (c == 'A') {
      c = 'T';
    } else if (c == 'T') {
      c = 'A';
    } else if (c == 'G') {
      c = 'C';
    } else if (c == 'C') {
      c = 'G';
    } else {
      fprintf(stderr, "Cannot happen! Got letter: %c\n", c);
      exit(EXIT_FAILURE);
    }


    outIndex = j / (MAXWORD/2);
    outBase = j %  (MAXWORD/2);

    if (outIndex != prevOutIndex)
      out[outIndex] = 0;

    out[outIndex] = setLetter(out[outIndex], c, outBase);
    prevOutIndex = outIndex;
  }


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x11263
movl -0x1c(%rbp), %eax
shrl $0x5, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movl -0x24(%rbp), %esi
callq 0x10f90
movb %al, -0x31(%rbp)
movsbl -0x31(%rbp), %eax
cmpl $0x41, %eax
jne 0x1119d
movb $0x54, -0x31(%rbp)
jmp 0x111f6
movsbl -0x31(%rbp), %eax
cmpl $0x54, %eax
jne 0x111ac
movb $0x41, -0x31(%rbp)
jmp 0x111f4
movsbl -0x31(%rbp), %eax
cmpl $0x47, %eax
jne 0x111bb
movb $0x43, -0x31(%rbp)
jmp 0x111f2
movsbl -0x31(%rbp), %eax
cmpl $0x43, %eax
jne 0x111ca
movb $0x47, -0x31(%rbp)
jmp 0x111f0
movq 0xadf7(%rip), %rax      # 0x1bfc8
movq (%rax), %rdi
movsbl -0x31(%rbp), %edx
leaq 0x3c24(%rip), %rsi      # 0x14e03
movb $0x0, %al
callq 0x3390
movl $0x1, %edi
callq 0x3330
jmp 0x111f2
jmp 0x111f4
jmp 0x111f6
movl -0x18(%rbp), %eax
shrl $0x5, %eax
movl %eax, -0x28(%rbp)
movl -0x18(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x30(%rbp), %eax
je 0x1121f
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movb -0x31(%rbp), %al
movl -0x2c(%rbp), %edx
movsbl %al, %esi
callq 0x10ea0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1115a
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ahhgust[P]STRaitRazor/trie.cpp
// Function: Trie::initMem(unsigned int)
void
Trie::initMem(unsigned num_nodes) {
  
  unsigned i;
  mem = new TrieNode[num_nodes];
  TrieNode *head = mem;
  for (i=0; i < num_nodes; ++i, ++head) {
    (*head).a =     (*head).c =    (*head).g =     (*head).t = NULL;
    (*head).id = NULL;
    (*head).type = NULL;
  }

  numNodes = num_nodes;
  root = mem;
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl $0x30, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x117cb
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x18(%rbp)
jmp 0x11765
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x10(%rax)
movq 0x8(%rax), %rcx
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)