LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/fltflt[P]Tinyhttpd_with_threadpool_epoll/./ThreadPool.h
// Function: std::future<std::result_of<void* (& (void*))(void*)>::type> ThreadPool::enqueue<void* (&)(void*), void*>(void* (&)(void*), void*&&)
auto ThreadPool::enqueue(F&& f, Args&&... args) 
    -> std::future<typename std::result_of<F(Args...)>::type>
{
    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> res = task->get_future();
    {
        std::unique_lock<std::mutex> lock(queue_mutex);

        // don't allow enqueueing after stopping the pool
        if(stop)
            throw std::runtime_error("enqueue on stopped ThreadPool");

        tasks.emplace([task](){ (*task)(); });
    }
    condition.notify_one();
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x48(%rbp), %rax
movq %rdx, (%rax)
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
leaq -0x30(%rbp), %rdi
movq $0x0, -0x8(%rdi)
leaq -0x38(%rbp), %r15
leaq -0x28(%rbp), %rdx
movq %r15, %rsi
movq %rax, %rcx
callq 0x557e
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x550c
leaq 0x68(%r14), %rax
leaq -0x48(%rbp), %rdi
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
callq 0x5188
movb $0x1, -0x40(%rbp)
cmpb $0x1, 0xc0(%r14)
je 0x4b38
leaq 0x18(%r14), %rdi
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq %rax, -0x20(%rbp)
testq %rax, %rax
je 0x4aed
movq 0x64d9(%rip), %rcx      # 0xafb8
cmpb $0x0, (%rcx)
je 0x4ae9
incl 0x8(%rax)
jmp 0x4aed
lock
incl 0x8(%rax)
leaq -0x28(%rbp), %rsi
callq 0x6390
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x4b04
callq 0x54a0
leaq -0x48(%rbp), %rdi
callq 0x516e
addq $0x90, %r14
movq %r14, %rdi
callq 0x31a0
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x4b2a
callq 0x54a0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x3190
movq %rax, %r15
leaq 0x284c(%rip), %rsi      # 0x7398
movq %rax, %rdi
callq 0x3130
movq 0x6495(%rip), %rsi      # 0xaff0
movq 0x6446(%rip), %rdx      # 0xafa8
movq %r15, %rdi
callq 0x3520
movq %rax, %r14
jmp 0x4b8d
movq %rax, %r14
movq %r15, %rdi
callq 0x3220
jmp 0x4b8d
movq %rax, %r14
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x4b8d
callq 0x54a0
leaq -0x48(%rbp), %rdi
callq 0x516e
jmp 0x4b9b
movq %rax, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x4bae
callq 0x54a0
jmp 0x4bae
movq %rax, %r14
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x4bbc
callq 0x54a0
movq %r14, %rdi
callq 0x3530
// File: /workspace/github_cpp_makefile_star2_O3/adrianphoulady[P]weighted-tsetlin-machine-cpp/./utils.h
// Function: getopt(int, char* const*, char const*, char*&)
char getopt(int argc, char * const argv[], char const *optstr, char *&optarg) {
    static int optind = 1;
    if (optind >= argc || *argv[optind] != '-')
        return -1;
    auto opt = *(argv[optind++] + 1);
    auto p = strchr(optstr, opt);
    if (!p)
        return '?';
    if (p[1] == ':') {
        if (optind >= argc)
            return ':';
        optarg = argv[optind++];
    }
    return opt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0x5d3a(%rip), %r15      # 0x81a8
movb $-0x1, %al
cmpl %edi, %r15d
jge 0x24cc
movq %rcx, %rbx
movq %rsi, %r14
movq (%rsi,%r15,8), %rcx
cmpb $0x2d, (%rcx)
jne 0x24cc
movl %edi, %ebp
leal 0x1(%r15), %r13d
movl %r13d, 0x5d17(%rip)     # 0x81a8
movb 0x1(%rcx), %r12b
movsbl %r12b, %esi
movq %rdx, %rdi
callq 0x20d0
testq %rax, %rax
je 0x24ca
cmpb $0x3a, 0x1(%rax)
jne 0x24c5
movb $0x3a, %al
cmpl %ebp, %r13d
jge 0x24cc
leal 0x2(%r15), %eax
movl %eax, 0x5ceb(%rip)      # 0x81a8
movq 0x8(%r14,%r15,8), %rax
movq %rax, (%rbx)
movl %r12d, %eax
jmp 0x24cc
movb $0x3f, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/adrianphoulady[P]weighted-tsetlin-machine-cpp/implementations.cpp
// Function: main
int main(int argc, char * const argv[]) {
#if defined imdb
    int clauses = 3200, threshold = 12, epochs = 35;
    double p = .012, gamma = .0006;
    std::string const experiment = "imdb";
#elif defined connect4
    int clauses = 200, threshold = 12, epochs = 200;
    double p = .037, gamma = .0001;
    std::string const experiment = "con4";
#else // default: mnist
    int clauses = 500, threshold = 25, epochs = 400;
    double p = .085, gamma = .0025;
    std::string const experiment = "mnist";
#endif

    bool shuffle = false, resume = false, write = false;
    update(argc, argv, clauses, p, threshold, gamma, epochs, shuffle, write, resume);
    fit(experiment, clauses, p, gamma, threshold, epochs, shuffle, write, resume);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbp
movl %edi, %r12d
leaq 0x14(%rsp), %rax
movl $0x1f4, (%rax)          # imm = 0x1F4
leaq 0x10(%rsp), %rax
movl $0x19, (%rax)
leaq 0xc(%rsp), %rax
movl $0x190, (%rax)          # imm = 0x190
movabsq $0x3fb5c28f5c28f5c3, %rax # imm = 0x3FB5C28F5C28F5C3
leaq 0x18(%rsp), %rcx
movq %rax, (%rcx)
movabsq $0x3f647ae147ae147b, %rax # imm = 0x3F647AE147AE147B
leaq 0x40(%rsp), %r13
movq %rax, (%r13)
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x1da7(%rip), %rsi      # 0x5277
leaq 0x1da5(%rip), %rdx      # 0x527c
leaq 0x20(%rsp), %rdi
callq 0x490a
xorl %eax, %eax
leaq 0xb(%rsp), %rbx
movb %al, (%rbx)
leaq 0xa(%rsp), %r14
movb %al, (%r14)
leaq 0x9(%rsp), %r15
movb %al, (%r15)
movl %r12d, %edi
movq %rbp, %rsi
leaq 0x14(%rsp), %rdx
leaq 0x18(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %r13, %r9
pushq %r14
pushq %r15
pushq %rbx
leaq 0x24(%rsp), %rax
pushq %rax
callq 0x24db
addq $0x20, %rsp
leaq 0x14(%rsp), %rax
movl (%rax), %esi
leaq 0x18(%rsp), %rax
movsd (%rax), %xmm0
movsd (%r13), %xmm1
leaq 0x10(%rsp), %rax
movl (%rax), %edx
leaq 0xc(%rsp), %rax
movl (%rax), %ecx
movzbl (%rbx), %r8d
movzbl (%r15), %r9d
movzbl (%r14), %eax
subq $0x8, %rsp
leaq 0x28(%rsp), %rdi
pushq %rax
callq 0x2f85
addq $0x10, %rsp
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x357d
callq 0x21b0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x35a5
callq 0x21b0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/adrianphoulady[P]weighted-tsetlin-machine-cpp/./multiweightm.h
// Function: multiweightm::multiweightm(std::istream&)
explicit multiweightm(std::istream &is)
    : epoch{get<int>(is)},
    classes{get<int>(is)},
    machine{classes} {
        for (int c = 0; c < classes; ++c)
            new (&machine(c)) weightm(is);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movl $0x4, %edx
movq %rsi, %rdi
movq %r15, %rsi
callq 0x2220
movl (%r15), %eax
movl %eax, (%rbx)
leaq 0x4(%rsp), %r15
movl $0x4, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2220
movslq (%r15), %r15
movl %r15d, 0x4(%rbx)
movl %r15d, 0x8(%rbx)
imulq $0x70, %r15, %rdi
callq 0x2030
movq %rax, 0x10(%rbx)
testq %r15, %r15
jle 0x3725
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x10(%rbx), %rdi
addq %r15, %rdi
movq %r14, %rsi
callq 0x3aa2
incq %r12
movslq 0x4(%rbx), %rax
addq $0x70, %r15
cmpq %rax, %r12
jl 0x3706
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x3742
callq 0x2230
movq %r14, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/adrianphoulady[P]weighted-tsetlin-machine-cpp/./multiweightm.h
// Function: multiweightm::multiweightm(int, int, int, double, double, int, int)
multiweightm(int classes, int features, int clauses, double p, double gamma, int threshold, int state_bits = 8)
    : epoch{0},
    classes{classes},
    machine{classes} {
        while (classes--)
            new (&machine(classes)) weightm(features, clauses, p, gamma, threshold, state_bits);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0x4(%rsp)
movl %r8d, (%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movl %ecx, %r15d
movl %edx, %r12d
movq %rdi, %r14
movl $0x0, (%rdi)
movl %esi, 0x4(%rdi)
movl %esi, 0x8(%rdi)
movslq %esi, %rbx
imulq $0x70, %rbx, %r13
movq %r13, %rdi
callq 0x2030
movq %rax, 0x10(%r14)
incq %rbx
addq $-0x70, %r13
decq %rbx
je 0x37d0
leaq -0x70(%r13), %rbp
addq 0x10(%r14), %r13
movq %r13, %rdi
movl %r12d, %esi
movl %r15d, %edx
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movl (%rsp), %ecx
movl 0x4(%rsp), %r8d
callq 0x3d22
movq %rbp, %r13
jmp 0x379c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x37f0
callq 0x2230
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/adrianphoulady[P]weighted-tsetlin-machine-cpp/./multiweightm.h
// Function: multiweightm::fit(array2d<unsigned int>&, array1d<int>&, int, bool)
void fit(array2d<word> &x, array1d<int> &y, int epochs, bool mix = false) {
        array1d<int> idx{x.rows};
        // no need to serialize
        for (int i = 0; i < idx.columns; ++i)
            idx(i) = i;
        while (epochs--) {
            if (mix)
                shuffle(idx);
            for (int i = 0; i < x.rows; ++i)
                train(x(idx(i)), y(idx(i)));
            ++epoch;
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, 0xc(%rsp)
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movslq (%rsi), %rbp
leaq (,%rbp,4), %rdi
callq 0x2030
movq %rax, %r13
movq %rbp, 0x10(%rsp)
testq %rbp, %rbp
jle 0x38ca
movq 0x10(%rsp), %rcx
leal 0x1(%rcx), %eax
andl $-0x2, %eax
decq %rcx
movq %rcx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0x1819(%rip), %xmm1     # 0x5070
xorl %ecx, %ecx
movdqa 0x181f(%rip), %xmm2     # 0x5080
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x181f(%rip), %xmm4     # 0x5090
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %edx
notl %edx
testb $0x1, %dl
je 0x38a7
movl %ecx, (%r13,%rcx,4)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %edx
testb $0x1, %dl
je 0x38bd
leal 0x1(%rcx), %edx
movl %edx, 0x4(%r13,%rcx,4)
addq $0x2, %rcx
paddq %xmm4, %xmm1
cmpq %rcx, %rax
jne 0x3871
testl %ebx, %ebx
je 0x399b
movq 0x10(%rsp), %rax
testl %eax, %eax
setne %cl
andb 0xc(%rsp), %cl
movb %cl, 0xb(%rsp)
movabsq $0x5851f42d4c957f2d, %rbp # imm = 0x5851F42D4C957F2D
cmpb $0x0, 0xb(%rsp)
je 0x3950
movq 0x48b4(%rip), %rdx      # 0x81b0
movq 0x10(%rsp), %rdi
movq %rdi, %rsi
movq %rdx, %rcx
movl %edi, %r8d
imulq %rbp, %rdx
movq %rcx, %r9
shrq $0x16, %r9
xorq %rcx, %r9
shrq $0x3d, %rcx
addb $0x16, %cl
shrq %cl, %r9
movl %r9d, %ecx
imulq %r8, %rcx
sarq $0x20, %rcx
movl -0x4(%r13,%rdi,4), %r8d
movl (%r13,%rcx,4), %r9d
movl %r9d, -0x4(%r13,%rdi,4)
movl %r8d, (%r13,%rcx,4)
decq %rsi
movq %rsi, %rdi
jne 0x3904
movq %rdx, 0x4860(%rip)      # 0x81b0
testl %eax, %eax
jle 0x398d
movl %ebx, 0xc(%rsp)
xorl %ebx, %ebx
movslq (%r13,%rbx,4), %rax
movslq 0x4(%r15), %rsi
imulq %rax, %rsi
shlq $0x2, %rsi
addq 0x8(%r15), %rsi
movq 0x8(%r14), %rcx
movl (%rcx,%rax,4), %edx
movq %r12, %rdi
callq 0x3f68
incq %rbx
movslq (%r15), %rax
cmpq %rax, %rbx
jl 0x395a
movl 0xc(%rsp), %ebx
decl %ebx
incl (%r12)
testl %ebx, %ebx
jne 0x38ee
movq %r13, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2230
movq %rax, %rbx
movq %r13, %rdi
callq 0x2230
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/adrianphoulady[P]weighted-tsetlin-machine-cpp/./multiweightm.h
// Function: multiweightm::evaluate(array2d<unsigned int>&, array1d<int>&)
double evaluate(array2d<word> &x, array1d<int> &y) {
        int correct = 0;
        for (int i = 0; i < x.rows; ++i)
            correct += predict(x(i)) == y(i);
        return (double) correct / x.rows;
    }

// Assembly:
movl (%rsi), %eax
testl %eax, %eax
jle 0x3a23
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
xorl %ebp, %ebp
movslq 0x4(%r14), %rax
movslq %r12d, %rsi
imulq %rax, %rsi
shlq $0x2, %rsi
addq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x4702
movq 0x8(%rbx), %rcx
xorl %edx, %edx
cmpl (%rcx,%r12,4), %eax
sete %dl
addl %edx, %ebp
incq %r12
movslq (%r14), %rax
cmpq %rax, %r12
jl 0x39e0
cvtsi2sd %ebp, %xmm0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3a27
xorpd %xmm0, %xmm0
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/adrianphoulady[P]weighted-tsetlin-machine-cpp/./multiweightm.h
// Function: multiweightm::train(unsigned int*, int)
void train(word *x, int y) {
        int zero = fastrandrange(classes - 1), one = y;
        zero += zero >= one;
        machine(zero).train(x, 0);
        machine(one).train(x, 1);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rdi), %eax
decl %eax
movq 0x4230(%rip), %rcx      # 0x81b0
movabsq $0x5851f42d4c957f2d, %rdx # imm = 0x5851F42D4C957F2D
imulq %rcx, %rdx
movq %rcx, %rsi
shrq $0x16, %rsi
xorq %rcx, %rsi
shrq $0x3d, %rcx
addb $0x16, %cl
shrq %cl, %rsi
movq %rdx, 0x4207(%rip)      # 0x81b0
movl %esi, %ecx
imulq %rax, %rcx
shrq $0x20, %rcx
xorl %eax, %eax
cmpl %ebp, %ecx
setge %al
addl %ecx, %eax
cltq
imulq $0x70, %rax, %rdi
addq 0x10(%r14), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3fec
movslq %ebp, %rax
imulq $0x70, %rax, %rdi
addq 0x10(%r14), %rdi
movq %rbx, %rsi
movl $0x1, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x3fec
// File: /workspace/github_cpp_makefile_star2_O3/adrianphoulady[P]weighted-tsetlin-machine-cpp/./weightm.h
// Function: weightm::train(unsigned int const*, int)
void train(word const *x, int y) {
        double const diversion = .5 + (.5 - y) * infer(x, true) / threshold;
        for (int c = 0; c < clauses; ++c)
            if (fastrandom() < diversion)
                y != (c & 1)? setter(c, x): clearer(c, x);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edx
callq 0x40d6
cmpl $0x0, 0x4(%r15)
jle 0x40c8
cvtsi2sd %ebx, %xmm1
movsd 0x10af(%rip), %xmm2     # 0x50d0
movapd %xmm2, %xmm3
subsd %xmm1, %xmm3
mulsd %xmm0, %xmm3
xorps %xmm0, %xmm0
cvtsi2sdl 0x18(%r15), %xmm0
divsd %xmm0, %xmm3
addsd %xmm2, %xmm3
xorl %ebp, %ebp
movabsq $0x5851f42d4c957f2d, %r12 # imm = 0x5851F42D4C957F2D
movsd 0x1086(%rip), %xmm1     # 0x50d8
movsd %xmm3, 0x8(%rsp)
movq 0x4151(%rip), %rcx      # 0x81b0
movq %rcx, %rax
movq %rcx, %rdx
shrq $0x16, %rdx
xorq %rcx, %rdx
shrq $0x3d, %rcx
addb $0x16, %cl
shrq %cl, %rdx
imulq %r12, %rax
movl %edx, %ecx
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
movq %rax, 0x4125(%rip)      # 0x81b0
mulsd %xmm1, %xmm0
ucomisd %xmm0, %xmm3
jbe 0x40c0
movl %ebp, %eax
andl $0x1, %eax
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
cmpl %ebx, %eax
jne 0x40ad
callq 0x4252
jmp 0x40b2
callq 0x4148
movsd 0x8(%rsp), %xmm3
movsd 0x1018(%rip), %xmm1     # 0x50d8
incl %ebp
cmpl 0x4(%r15), %ebp
jl 0x4058
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/adrianphoulady[P]weighted-tsetlin-machine-cpp/./weightm.h
// Function: weightm::infer(unsigned int const*, bool)
double infer(word const *x, bool training = false) {
        double inference = 0;
        for (int c = 0; c < clauses; ++c)
            if (value(c, x, training))
                inference += weight(c);
        return inference;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0x4(%rdi)
jle 0x412e
movq %rsi, %rbx
movq %rdi, %r14
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
xorl %r15d, %r15d
movzbl %dl, %ebp
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x42e6
testl %eax, %eax
je 0x4120
movq 0x68(%r14), %rax
movsd (%rsp), %xmm0
addsd (%rax,%r15,8), %xmm0
movsd %xmm0, (%rsp)
incq %r15
movslq 0x4(%r14), %rax
cmpq %rax, %r15
jl 0x40f8
jmp 0x4137
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/adrianphoulady[P]weighted-tsetlin-machine-cpp/./weightm.h
// Function: weightm::setter(int, unsigned int const*)
void setter(int c, word const *x) {
        literal_mask();
        if (clause(c)) {
            weight(c) *= 1 + gamma;
            for (int l = 0; l < literals; ++l) {
                add(state(c, l), x[l]);
                subtract(state(c, l), lmask(l) & ~x[l]);
            }
        }
        else
            for (int l = 0; l < literals; ++l)
                subtract(state(c, l), lmask(l));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
callq 0x4378
movq 0x58(%r14), %rcx
movslq %ebx, %rax
cmpl $0x0, (%rcx,%rax,4)
je 0x4202
movsd 0x10(%r14), %xmm0
addsd 0xf64(%rip), %xmm0      # 0x50e0
movq 0x68(%r14), %rcx
mulsd (%rcx,%rax,8), %xmm0
movsd %xmm0, (%rcx,%rax,8)
cmpl $0x0, 0x20(%r14)
jle 0x4245
xorl %r12d, %r12d
movl 0x2c(%r14), %eax
imull %ebx, %eax
addl %r12d, %eax
movslq 0x30(%r14), %rcx
movslq %eax, %rsi
imulq %rcx, %rsi
shlq $0x2, %rsi
addq 0x38(%r14), %rsi
movl (%r15,%r12,4), %edx
movq %r14, %rdi
callq 0x4638
movl 0x2c(%r14), %eax
imull %ebx, %eax
addl %r12d, %eax
movslq 0x30(%r14), %rcx
movslq %eax, %rsi
imulq %rcx, %rsi
shlq $0x2, %rsi
addq 0x38(%r14), %rsi
movq 0x48(%r14), %rax
movl (%r15,%r12,4), %edx
notl %edx
andl (%rax,%r12,4), %edx
movq %r14, %rdi
callq 0x469c
incq %r12
movslq 0x20(%r14), %rax
cmpq %rax, %r12
jl 0x4198
jmp 0x4245
cmpl $0x0, 0x20(%r14)
jle 0x4245
xorl %r15d, %r15d
movl 0x2c(%r14), %eax
imull %ebx, %eax
addl %r15d, %eax
movslq 0x30(%r14), %rcx
movslq %eax, %rsi
imulq %rcx, %rsi
shlq $0x2, %rsi
addq 0x38(%r14), %rsi
movq 0x48(%r14), %rax
movl (%rax,%r15,4), %edx
movq %r14, %rdi
callq 0x469c
incq %r15
movslq 0x20(%r14), %rax
cmpq %rax, %r15
jl 0x420c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/adrianphoulady[P]weighted-tsetlin-machine-cpp/./weightm.h
// Function: weightm::value(int, unsigned int const*, bool)
int value(int c, word const *x, bool training = false) {
        word active = 0;
        state(c, literals, -1) &= actmask; // == state(c, literals - 1, states - 1)
        for (int l = 0; l < literals; ++l) {
            auto s = state(c, l, states - 1); // bit (states - 1) is the action bit of the automata
            if ((s & x[l]) != s)
                return clause(c) = 0;
            active |= s;
        }
        return clause(c) = training || active;
    }

// Assembly:
pushq %rbp
pushq %rbx
movl 0x24(%rdi), %eax
movslq 0x20(%rdi), %r8
movq 0x38(%rdi), %r10
movslq 0x2c(%rdi), %r9
movslq %esi, %rsi
imulq %rsi, %r9
addq %r8, %r9
movslq 0x30(%rdi), %r8
imulq %r9, %r8
andl %eax, -0x4(%r10,%r8,4)
movslq 0x20(%rdi), %r8
xorl %eax, %eax
testq %r8, %r8
jle 0x4362
movslq 0x1c(%rdi), %r11
movslq 0x2c(%rdi), %rbx
imulq %rsi, %rbx
movslq 0x30(%rdi), %r9
imulq %r9, %rbx
shlq $0x2, %r11
leaq (%r11,%rbx,4), %r11
addq %r11, %r10
addq $-0x4, %r10
shlq $0x2, %r9
xorl %r11d, %r11d
movl (%r10), %ebx
movl (%rdx,%r11,4), %ebp
notl %ebp
testl %ebp, %ebx
jne 0x436c
orl %ebx, %eax
incq %r11
addq %r9, %r10
cmpq %r11, %r8
jne 0x4343
testl %eax, %eax
setne %al
orb %al, %cl
movzbl %cl, %eax
andl $0x1, %eax
jmp 0x436e
xorl %eax, %eax
movq 0x58(%rdi), %rcx
movl %eax, (%rcx,%rsi,4)
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/adrianphoulady[P]weighted-tsetlin-machine-cpp/./weightm.h
// Function: weightm::add(unsigned int*, unsigned int)
void add(word *state_word, word addend) {
        for (int b = 0; addend && b < states; ++b) {
            state_word[b] ^= addend;
            addend &= state_word[b] ^ addend;
        }
        if (addend)
            for (int b = 0; b < states; ++b)
                state_word[b] ^= addend;
    }

// Assembly:
testl %edx, %edx
setne %al
movl 0x1c(%rdi), %ecx
testl %ecx, %ecx
setg %r8b
andb %al, %r8b
cmpb $0x1, %r8b
jne 0x467e
movl $0x1, %r8d
movl %edx, %eax
movl -0x4(%rsi,%r8,4), %edx
movl %edx, %ecx
xorl %eax, %ecx
movl %ecx, -0x4(%rsi,%r8,4)
movl 0x1c(%rdi), %ecx
andl %eax, %edx
setne %al
je 0x467e
leaq 0x1(%r8), %r9
movslq %ecx, %r10
cmpq %r10, %r8
movq %r9, %r8
jl 0x4655
testl %ecx, %ecx
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x469b
xorl %eax, %eax
xorl %edx, (%rsi,%rax,4)
incq %rax
movslq 0x1c(%rdi), %rcx
cmpq %rcx, %rax
jl 0x468c
retq
// File: /workspace/github_cpp_makefile_star2_O3/adrianphoulady[P]weighted-tsetlin-machine-cpp/./weightm.h
// Function: weightm::subtract(unsigned int*, unsigned int)
void subtract(word *state_word, word subtrahend) {
        for (int b = 0; subtrahend && b < states; ++b) {
            state_word[b] ^= subtrahend;
            subtrahend &= ~(state_word[b] ^ subtrahend);
        }
        if (subtrahend)
            for (int b = 0; b < states; ++b)
                state_word[b] ^= subtrahend;
    }

// Assembly:
testl %edx, %edx
setne %al
movl 0x1c(%rdi), %ecx
testl %ecx, %ecx
setg %r8b
andb %al, %r8b
cmpb $0x1, %r8b
jne 0x46e4
movl $0x1, %r8d
movl %edx, %eax
movl -0x4(%rsi,%r8,4), %edx
movl %edx, %ecx
xorl %eax, %ecx
movl %ecx, -0x4(%rsi,%r8,4)
notl %edx
movl 0x1c(%rdi), %ecx
andl %eax, %edx
setne %al
je 0x46e4
leaq 0x1(%r8), %r9
movslq %ecx, %r10
cmpq %r10, %r8
movq %r9, %r8
jl 0x46b9
testl %ecx, %ecx
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x4701
xorl %eax, %eax
xorl %edx, (%rsi,%rax,4)
incq %rax
movslq 0x1c(%rdi), %rcx
cmpq %rcx, %rax
jl 0x46f2
retq
// File: /workspace/github_cpp_makefile_star2_O3/adrianphoulady[P]weighted-tsetlin-machine-cpp/./multiweightm.h
// Function: multiweightm::predict(unsigned int*)
int predict(word *input) {
        int mxi = 0;
        double mxv = machine(0).infer(input), v;
        for (int m = 1; m < classes; ++m)
            if (mxv < (v = machine(m).infer(input))) {
                mxv = v;
                mxi = m;
            }
        return mxi;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
xorl %ebp, %ebp
xorl %edx, %edx
callq 0x40d6
cmpl $0x2, 0x4(%r14)
jl 0x476f
xorl %ebp, %ebp
movl $0x1, %r15d
movl $0x70, %r12d
movsd %xmm0, 0x8(%rsp)
movq 0x10(%r14), %rdi
addq %r12, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x40d6
movsd 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm0
maxsd %xmm1, %xmm0
cmoval %r15d, %ebp
incq %r15
movslq 0x4(%r14), %rax
addq $0x70, %r12
cmpq %rax, %r15
jl 0x4736
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/adrianphoulady[P]weighted-tsetlin-machine-cpp/./weightm.h
// Function: weightm::serialize(std::ostream&)
void serialize(std::ostream &os) {
        put(os, features);
        put(os, clauses);
        put(os, p);
        put(os, gamma);
        put(os, threshold);
        put(os, states);
        put(os, mcg_state);
        for (int c = 0; c < clauses; ++c)
            for (int l = 0; l < literals; ++l)
                for (int b = 0; b < states; ++b)
                    put(os, state(c, l, b));
        for (int c = 0; c < clauses; ++c)
            put(os, weight(c));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
movq %rsp, %r15
movl %eax, (%r15)
movl $0x4, %edx
movq %rsi, %rdi
movq %r15, %rsi
callq 0x2240
movl 0x4(%r14), %eax
movl %eax, (%r15)
movq %rsp, %r15
movl $0x4, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2240
movsd 0x8(%r14), %xmm0
movsd %xmm0, (%r15)
movq %rsp, %r15
movl $0x8, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2240
movsd 0x10(%r14), %xmm0
movsd %xmm0, (%r15)
movq %rsp, %r15
movl $0x8, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2240
movl 0x18(%r14), %eax
movl %eax, (%r15)
movq %rsp, %r15
movl $0x4, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2240
movl 0x1c(%r14), %eax
movl %eax, (%r15)
movq %rsp, %r15
movl $0x4, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2240
movq 0x3978(%rip), %rax      # 0x81b0
movq %rax, (%r15)
movq %rsp, %rsi
movl $0x8, %edx
movq %rbx, %rdi
callq 0x2240
movl 0x4(%r14), %ecx
testl %ecx, %ecx
jle 0x48fb
movl 0x20(%r14), %eax
xorl %r12d, %r12d
movq %rsp, %r15
testl %eax, %eax
jle 0x48be
movl 0x1c(%r14), %ecx
xorl %ebp, %ebp
testl %ecx, %ecx
jle 0x48b4
xorl %r13d, %r13d
movq 0x38(%r14), %rax
movslq 0x30(%r14), %rcx
movl 0x2c(%r14), %edx
imull %r12d, %edx
addl %ebp, %edx
movslq %edx, %rdx
imulq %rcx, %rdx
addq %r13, %rdx
movl (%rax,%rdx,4), %eax
movl %eax, (%rsp)
movl $0x4, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2240
movl 0x1c(%r14), %ecx
incq %r13
cmpl %ecx, %r13d
jl 0x4872
movl 0x20(%r14), %eax
incl %ebp
cmpl %eax, %ebp
jl 0x486b
movl 0x4(%r14), %ecx
incl %r12d
cmpl %ecx, %r12d
jl 0x4861
testl %ecx, %ecx
jle 0x48fb
xorl %r12d, %r12d
movq %rsp, %r15
movq 0x68(%r14), %rax
movsd (%rax,%r12,8), %xmm0
movsd %xmm0, (%rsp)
movl $0x8, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2240
incq %r12
movslq 0x4(%r14), %rax
cmpq %rax, %r12
jl 0x48d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/3rdparty/gmp/gen-bases.c
// Function: generate
void
generate (int limb_bits, int nail_bits, int base)
{
  int  numb_bits = limb_bits - nail_bits;

  mpz_set_ui (t, 1L);
  mpz_mul_2exp (t, t, numb_bits);
  mpz_set_ui (big_base, 1L);
  chars_per_limb = 0;
  for (;;)
    {
      mpz_mul_ui (big_base, big_base, (long) base);
      if (mpz_cmp (big_base, t) > 0)
        break;
      chars_per_limb++;
    }

  mpz_ui_pow_ui (big_base, (long) base, (long) chars_per_limb);

  normalization_steps = limb_bits - mpz_sizeinbase (big_base, 2);

  mpz_set_ui (t, 1L);
  mpz_mul_2exp (t, t, 2*limb_bits - normalization_steps);
  mpz_tdiv_q (big_base_inverted, t, big_base);
  mpz_set_ui (t, 1L);
  mpz_mul_2exp (t, t, limb_bits);
  mpz_sub (big_base_inverted, big_base_inverted, t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r15d
movl %edi, %ebx
movl %edi, %eax
subl %esi, %eax
leaq 0x6795(%rip), %rdi      # 0xf0d0
movq 0x6796(%rip), %rcx      # 0xf0d8
movl $0x1, %r12d
movq %r12, (%rcx)
movl $0x1, %r14d
movl %r14d, 0x677c(%rip)     # 0xf0d4
movslq %eax, %rdx
movq %rdi, %rsi
callq 0x365c
leaq 0x6776(%rip), %r13      # 0xf0e0
movq 0x6777(%rip), %rax      # 0xf0e8
movq %r12, (%rax)
movl %r14d, 0x6769(%rip)     # 0xf0e4
movslq %r15d, %r15
movl $0x0, 0x6768(%rip)      # 0xf0f0
movq %r13, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x3471
movq %r13, %rdi
leaq 0x6730(%rip), %rsi      # 0xf0d0
callq 0x2d2b
testl %eax, %eax
jg 0x89da
leaq 0x6730(%rip), %r12      # 0xf0e0
leaq 0x6719(%rip), %r13      # 0xf0d0
incl 0x6733(%rip)            # 0xf0f0
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3471
movq %r12, %rdi
movq %r13, %rsi
callq 0x2d2b
testl %eax, %eax
jle 0x89b7
movslq 0x670f(%rip), %rdx      # 0xf0f0
leaq -0x30(%rbp), %rax
movq %r15, (%rax)
leaq -0x40(%rbp), %rsi
movl $0x0, (%rsi)
movq %rax, 0x8(%rsi)
xorl %eax, %eax
testl %r15d, %r15d
setne %al
movl %eax, 0x4(%rsi)
leaq 0x66d8(%rip), %rdi      # 0xf0e0
callq 0x559b
movl 0x66d1(%rip), %eax      # 0xf0e4
testl %eax, %eax
je 0x8a3d
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
movq 0x66c3(%rip), %rax      # 0xf0e8
leaq -0x1(%rcx), %r15
shll $0x6, %r15d
movq -0x8(%rax,%rcx,8), %rdi
callq 0x791b
movq %rax, %r14
addl %r15d, %r14d
movslq %ebx, %r15
movl %ebx, %eax
subl %r14d, %eax
movl %eax, 0x66a9(%rip)      # 0xf0f4
leaq 0x667e(%rip), %r14      # 0xf0d0
movq 0x667f(%rip), %rcx      # 0xf0d8
movl $0x1, %r12d
movq %r12, (%rcx)
movl $0x1, %r13d
movl %r13d, 0x6665(%rip)     # 0xf0d4
addl %ebx, %ebx
subl %eax, %ebx
movslq %ebx, %rdx
movq %r14, %rdi
movq %r14, %rsi
callq 0x365c
leaq 0x6678(%rip), %rbx      # 0xf100
leaq 0x6651(%rip), %rcx      # 0xf0e0
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
movl $0x2, %r8d
callq 0x3973
movq 0x662f(%rip), %rax      # 0xf0d8
movq %r12, (%rax)
movl %r13d, 0x6621(%rip)     # 0xf0d4
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x365c
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x33ff
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/3rdparty/gmp/gen-bases.c
// Function: header
void
header (int limb_bits, int nail_bits)
{
  int  numb_bits = limb_bits - nail_bits;

  generate (limb_bits, nail_bits, 10);

  printf ("/* This file generated by gen-bases.c - DO NOT EDIT. */\n");
  printf ("\n");
  printf ("#if GMP_NUMB_BITS != %d\n", numb_bits);
  printf ("Error, error, this data is for %d bits\n", numb_bits);
  printf ("#endif\n");
  printf ("\n");
  printf ("/* mp_bases[10] data, as literal values */\n");
  printf ("#define MP_BASES_CHARS_PER_LIMB_10      %d\n", chars_per_limb);
  printf ("#define MP_BASES_BIG_BASE_10            CNST_LIMB(0x");
  mpz_out_str (stdout, 16, big_base);
  printf (")\n");
  printf ("#define MP_BASES_BIG_BASE_INVERTED_10   CNST_LIMB(0x");
  mpz_out_str (stdout, 16, big_base_inverted);
  printf (")\n");
  printf ("#define MP_BASES_NORMALIZATION_STEPS_10 %d\n", normalization_steps);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
subl %esi, %ebx
movl $0xa, %edx
callq 0x891a
leaq 0x2a4b(%rip), %rdi      # 0xb545
callq 0x1060
movl $0xa, %edi
callq 0x1040
leaq 0x1fd3(%rip), %rdi      # 0xaae3
movl %ebx, %esi
xorl %eax, %eax
callq 0x1080
leaq 0x1fdc(%rip), %rdi      # 0xaafc
movl %ebx, %esi
xorl %eax, %eax
callq 0x1080
leaq 0x2a74(%rip), %rdi      # 0xb5a4
callq 0x1060
movl $0xa, %edi
callq 0x1040
leaq 0x29d4(%rip), %rdi      # 0xb51a
callq 0x1060
movl 0x659f(%rip), %esi      # 0xf0f0
leaq 0x1fcc(%rip), %rdi      # 0xab24
xorl %eax, %eax
callq 0x1080
leaq 0x1fea(%rip), %rdi      # 0xab50
xorl %eax, %eax
callq 0x1080
movq 0x6464(%rip), %r14      # 0xefd8
movq (%r14), %rdi
leaq 0x6562(%rip), %rdx      # 0xf0e0
movl $0x10, %esi
callq 0x802f
leaq 0x1db4(%rip), %rbx      # 0xa943
movq %rbx, %rdi
callq 0x1060
leaq 0x1fe7(%rip), %rdi      # 0xab85
xorl %eax, %eax
callq 0x1080
movq (%r14), %rdi
leaq 0x6551(%rip), %rdx      # 0xf100
movl $0x10, %esi
callq 0x802f
movq %rbx, %rdi
callq 0x1060
movl 0x652d(%rip), %esi      # 0xf0f4
leaq 0x1fec(%rip), %rdi      # 0xabba
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1080
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/3rdparty/gmp/gen-bases.c
// Function: mp_2logb
void
mp_2logb (mpz_t r, int bi, int prec)
{
  mpz_t t, t2, two, b;
  int i;

  mpz_init_set_ui (t, 1);
  mpz_mul_2exp (t, t, prec+EXTRA);

  mpz_init (t2);

  mpz_init_set_ui (two, 2);
  mpz_mul_2exp (two, two, prec+EXTRA);

  mpz_set_ui (r, 0);

  mpz_init_set_ui (b, bi);
  mpz_mul_2exp (b, b, prec+EXTRA);

  for (i = prec-1; i >= 0; i--)
    {
      mpz_mul_2exp (b, b, prec+EXTRA);
      mpz_sqrt (b, b);

      mpz_mul (t2, t, b);
      mpz_tdiv_q_2exp (t2, t2, prec+EXTRA);

      if (mpz_cmp (t2, two) < 0)	/* not too large? */
	{
	  mpz_setbit (r, i);		/* set next less significant bit */
	  mpz_set (t, t2);		/* new value acceptable */
	}
    }

  mpz_clear (t);
  mpz_clear (t2);
  mpz_clear (two);
  mpz_clear (b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %r14d
movl %esi, -0x2c(%rbp)
movq %rdi, %r15
movl $0x1, %r13d
leaq -0x80(%rbp), %r12
movl %r13d, (%r12)
movl $0x8, %edi
callq *0x649c(%rip)           # 0xf0a8
movq %rax, 0x8(%r12)
movl $0x1, %ebx
movq %rbx, (%rax)
movl %r13d, 0x4(%r12)
movq %r14, -0x58(%rbp)
leal 0x10(%r14), %eax
movslq %eax, %r14
movq %r12, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x365c
movq %rbx, -0x50(%rbp)
movl $0x8, %edi
callq *0x6462(%rip)           # 0xf0a8
movq %rax, -0x48(%rbp)
leaq -0x70(%rbp), %r12
movl %r13d, (%r12)
movl $0x8, %edi
callq *0x644b(%rip)           # 0xf0a8
movq %rax, 0x8(%r12)
movq $0x2, (%rax)
movl %r13d, 0x4(%r12)
movq %r12, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x365c
movq %r15, -0x60(%rbp)
movl $0x0, 0x4(%r15)
movl %r13d, -0x40(%rbp)
movl $0x8, %edi
callq *0x6411(%rip)           # 0xf0a8
movl -0x2c(%rbp), %ecx
movq %rax, -0x38(%rbp)
testl %ecx, %ecx
je 0x8caa
movslq %ecx, %rcx
movq %rcx, (%rax)
jmp 0x8cad
xorl %r13d, %r13d
leaq -0x40(%rbp), %rdi
movl %r13d, 0x4(%rdi)
movq %rdi, %rsi
movq %r14, %rdx
callq 0x365c
movq -0x58(%rbp), %rax
testl %eax, %eax
jle 0x8d4f
movl %eax, %ebx
incq %rbx
leaq -0x40(%rbp), %r15
leaq -0x50(%rbp), %r12
leaq -0x80(%rbp), %r13
movq %r15, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x365c
movl $0x2, %ecx
movq %r15, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x5fcc
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x3542
movq %r12, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl $0x2, %ecx
callq 0x3e83
movq %r12, %rdi
leaq -0x70(%rbp), %rsi
callq 0x2d2b
testl %eax, %eax
jns 0x8d46
leaq -0x2(%rbx), %rsi
movq -0x60(%rbp), %rdi
callq 0x5335
movq %r13, %rdi
movq %r12, %rsi
callq 0x24d2
decq %rbx
cmpq $0x1, %rbx
ja 0x8cdd
movq -0x78(%rbp), %rdi
xorl %esi, %esi
callq *0x635d(%rip)           # 0xf0b8
movq -0x48(%rbp), %rdi
xorl %esi, %esi
callq *0x6351(%rip)           # 0xf0b8
movq -0x68(%rbp), %rdi
xorl %esi, %esi
callq *0x6345(%rip)           # 0xf0b8
movq -0x38(%rbp), %rdi
xorl %esi, %esi
callq *0x6339(%rip)           # 0xf0b8
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/marxn[P]pupp/3rdparty/gmp/gen-bases.c
// Function: main
int
main (int argc, char **argv)
{
  int  limb_bits, nail_bits;

  mpz_init (big_base);
  mpz_init (big_base_inverted);
  mpz_init (t);

  if (argc != 4)
    {
      fprintf (stderr, "Usage: gen-bases <header|table> <limbbits> <nailbits>\n");
      exit (1);
    }

  limb_bits = atoi (argv[2]);
  nail_bits = atoi (argv[3]);

  if (limb_bits <= 0
      || nail_bits < 0
      || nail_bits >= limb_bits)
    {
      fprintf (stderr, "Invalid limb/nail bits: %d %d\n",
               limb_bits, nail_bits);
      exit (1);
    }

  if (strcmp (argv[1], "header") == 0)
    header (limb_bits, nail_bits);
  else if (strcmp (argv[1], "table") == 0)
    table (limb_bits, nail_bits);
  else
    {
      fprintf (stderr, "Invalid header/table choice: %s\n", argv[1]);
      exit (1);
    }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
movl $0x1, %r15d
movq %r15, 0x602b(%rip)      # 0xf0e0
movl $0x8, %edi
callq *0x5fe8(%rip)           # 0xf0a8
movq %rax, 0x6021(%rip)      # 0xf0e8
movq %r15, 0x6032(%rip)      # 0xf100
movl $0x8, %edi
callq *0x5fcf(%rip)           # 0xf0a8
movq %rax, 0x6028(%rip)      # 0xf108
movq %r15, 0x5fe9(%rip)      # 0xf0d0
movl $0x8, %edi
callq *0x5fb6(%rip)           # 0xf0a8
movq %rax, 0x5fdf(%rip)      # 0xf0d8
cmpl $0x4, %r14d
jne 0x9175
movq 0x10(%rbx), %rdi
callq 0x10f0
movl %eax, %r14d
movq 0x18(%rbx), %rdi
callq 0x10f0
movl %eax, %r15d
testl %r14d, %r14d
jle 0x917a
testl %r15d, %r15d
js 0x917a
cmpl %r14d, %r15d
jge 0x917a
movq 0x8(%rbx), %rbx
leaq 0x1b94(%rip), %rsi      # 0xacc5
movq %rbx, %rdi
callq 0x10b0
testl %eax, %eax
je 0x915d
leaq 0x1b88(%rip), %rsi      # 0xaccc
movq %rbx, %rdi
callq 0x10b0
testl %eax, %eax
jne 0x9185
movl %r14d, %edi
movl %r15d, %esi
callq 0x8d8e
jmp 0x9168
movl %r14d, %edi
movl %r15d, %esi
callq 0x8ade
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x12a8
movl %r14d, %edi
movl %r15d, %esi
callq 0x12d0
movq %rbx, %rdi
callq 0x12f8
// File: /workspace/github_cpp_makefile_star2_O3/pollow[P]MIPSClide/assembler.cpp
// Function: Assembler::calc_label()
void Assembler::calc_label() {
    static regex label_regex("(\\w+):");
    size_t i = 0;
    while ( i < statements.size() ) {
        string &str = statements[i];
        if ( regex_match(str, label_regex) ) {
            labels.insert( {str.substr(0, str.length()-1), i} );
            statements.erase( statements.begin() + i );
        } else i++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movb 0x1ed98(%rip), %al      # 0x2b7b8
testb %al, %al
movq %rdi, -0x30(%rbp)
je 0xcb73
movq 0x20(%rbx), %r12
cmpq %r12, 0x28(%rbx)
je 0xcb64
leaq 0x20(%rbx), %rax
movq %rax, -0x88(%rbp)
leaq 0x68(%rbx), %rax
movq %rax, -0x90(%rbp)
leaq -0x50(%rbp), %r13
xorl %r14d, %r14d
movq %r13, %rbx
movq %r14, %r15
shlq $0x5, %r15
movq (%r12,%r15), %rdi
movq 0x8(%r12,%r15), %rsi
addq %rdi, %rsi
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
leaq -0x60(%rbp), %rdx
leaq 0x1ed15(%rip), %rcx     # 0x2b798
xorl %r8d, %r8d
callq 0x1c1c4
movl %eax, %r13d
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0xca9c
callq 0x52d0
testb %r13b, %r13b
je 0xcadc
addq %r15, %r12
movq 0x8(%r12), %rcx
decq %rcx
leaq -0x80(%rbp), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x5340
movq %rbx, %r13
movq %rbx, -0x60(%rbp)
movq -0x80(%rbp), %rax
leaq -0x70(%rbp), %r12
cmpq %r12, %rax
je 0xcae4
movq %rax, -0x60(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0xcaee
incq %r14
movq %rbx, %r13
jmp 0xcb48
movups (%r12), %xmm0
movups %xmm0, (%r13)
movq -0x78(%rbp), %rax
movq %rax, -0x58(%rbp)
movq %r12, -0x80(%rbp)
movq $0x0, -0x78(%rbp)
movb $0x0, -0x70(%rbp)
movl %r14d, -0x40(%rbp)
movq -0x90(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1c9b8
movq -0x60(%rbp), %rdi
cmpq %r13, %rdi
je 0xcb28
callq 0x52d0
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0xcb36
callq 0x52d0
movq -0x88(%rbp), %rdi
addq (%rdi), %r15
movq %r15, %rsi
callq 0x1caea
movq -0x30(%rbp), %rax
movq 0x20(%rax), %r12
movq 0x28(%rax), %rax
subq %r12, %rax
sarq $0x5, %rax
cmpq %rax, %r14
jb 0xca57
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ec3e(%rip), %rdi     # 0x2b7b8
callq 0x5580
testl %eax, %eax
je 0xca2c
leaq 0x1ec0a(%rip), %rdi     # 0x2b798
leaq 0x14876(%rip), %rsi     # 0x2140b
movl $0x10, %edx
callq 0xd6b0
leaq 0xb76(%rip), %rdi       # 0xd71c
leaq 0x1ebeb(%rip), %rsi     # 0x2b798
leaq 0x1e764(%rip), %rdx     # 0x2b318
callq 0x52b0
leaq 0x1ebf8(%rip), %rdi     # 0x2b7b8
callq 0x5200
movq -0x30(%rbp), %rbx
jmp 0xca2c
movq %rax, %rbx
leaq 0x1ebe0(%rip), %rdi     # 0x2b7b8
callq 0x51f0
jmp 0xcc10
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r13, %rdi
je 0xcbf0
callq 0x52d0
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rax
cmpq %rax, %rdi
jne 0xcc0b
jmp 0xcc10
movq %rax, %rbx
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0xcc10
callq 0x52d0
movq %rbx, %rdi
callq 0x5560
// File: /workspace/github_cpp_makefile_star2_O3/pollow[P]MIPSClide/assembler.cpp
// Function: Assembler::trim()
void Assembler::trim() {
    static regex trim("(^\\s+)|(\\s+$)");
    static regex comment("\\s*#.*");
    for(auto i=statements.begin(); i!=statements.end(); i++) {
        *i = regex_replace(*i, trim, "");
        *i = regex_replace(*i, comment, "");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movb 0x1ebae(%rip), %al      # 0x2b7e0
testb %al, %al
je 0xcd20
movb 0x1ebc8(%rip), %al      # 0x2b808
testb %al, %al
je 0xcd77
movq 0x20(%rbx), %r14
cmpq 0x28(%rbx), %r14
je 0xcd11
leaq -0x38(%rbp), %r15
leaq 0x147a2(%rip), %r12     # 0x21403
leaq -0x48(%rbp), %r13
movq %r15, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movl $0x0, (%rsp)
movq %r13, %rdi
leaq 0x1eb30(%rip), %rcx     # 0x2b7c0
movq %r12, %r8
xorl %r9d, %r9d
callq 0x1952b
movq %r14, %rdi
movq %r13, %rsi
callq 0x53c0
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xccb4
callq 0x52d0
movq %r15, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movl $0x0, (%rsp)
movq %r13, %rdi
leaq 0x1eb09(%rip), %rcx     # 0x2b7e8
movq %r12, %r8
xorl %r9d, %r9d
callq 0x1952b
movq %r14, %rdi
movq %r13, %rsi
callq 0x53c0
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xcd03
callq 0x52d0
addq $0x20, %r14
cmpq 0x28(%rbx), %r14
jne 0xcc65
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1eab9(%rip), %rdi     # 0x2b7e0
callq 0x5580
testl %eax, %eax
je 0xcc3a
leaq 0x1ea85(%rip), %rdi     # 0x2b7c0
leaq 0x146d0(%rip), %rsi     # 0x21412
movl $0x10, %edx
callq 0xd6b0
leaq 0x9c9(%rip), %rdi       # 0xd71c
leaq 0x1ea66(%rip), %rsi     # 0x2b7c0
leaq 0x1e5b7(%rip), %rdx     # 0x2b318
callq 0x52b0
leaq 0x1ea73(%rip), %rdi     # 0x2b7e0
callq 0x5200
jmp 0xcc3a
leaq 0x1ea8a(%rip), %rdi     # 0x2b808
callq 0x5580
testl %eax, %eax
je 0xcc48
leaq 0x1ea56(%rip), %rdi     # 0x2b7e8
leaq 0x14687(%rip), %rsi     # 0x21420
movl $0x10, %edx
callq 0xd6b0
leaq 0x972(%rip), %rdi       # 0xd71c
leaq 0x1ea37(%rip), %rsi     # 0x2b7e8
leaq 0x1e560(%rip), %rdx     # 0x2b318
callq 0x52b0
leaq 0x1ea44(%rip), %rdi     # 0x2b808
callq 0x5200
jmp 0xcc48
movq %rax, %rbx
leaq 0x1ea30(%rip), %rdi     # 0x2b808
jmp 0xcde4
movq %rax, %rbx
leaq 0x1e9fc(%rip), %rdi     # 0x2b7e0
callq 0x51f0
jmp 0xcdfe
jmp 0xcded
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xcdfe
callq 0x52d0
movq %rbx, %rdi
callq 0x5560
// File: /workspace/github_cpp_makefile_star2_O3/pollow[P]MIPSClide/assembler.cpp
// Function: Assembler::split()
void Assembler::split() {
    stringstream buffer( content );
    string item;
    while( getline(buffer, item, '\n') ) {
        transform(item.begin(), item.end(), item.begin(), ::tolower);
        if (item.length() > 1) statements.push_back(item);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, %rbx
leaq -0x1d8(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x18, %edx
callq 0x54a0
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rbx
movq %rbx, -0x30(%rbp)
leaq -0x50(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x5590
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
movq -0x50(%rbp), %r12
jne 0xceab
movq -0x48(%rbp), %r13
testq %r13, %r13
je 0xce53
xorl %ebx, %ebx
movsbl (%r12,%rbx), %edi
callq 0x5430
movb %al, (%r12,%rbx)
incq %rbx
cmpq %rbx, %r13
jne 0xce80
cmpq $0x2, -0x48(%rbp)
jb 0xce53
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0xe036
jmp 0xce53
leaq -0x40(%rbp), %rax
cmpq %rax, %r12
je 0xcebc
movq %r12, %rdi
callq 0x52d0
movq 0x1e0a5(%rip), %rsi     # 0x2af68
leaq -0x1d8(%rbp), %rdi
callq 0x5270
leaq -0x158(%rbp), %rdi
callq 0x50e0
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0xcf02
callq 0x52d0
movq 0x1e05f(%rip), %rsi     # 0x2af68
leaq -0x1d8(%rbp), %rdi
callq 0x5270
leaq -0x158(%rbp), %rdi
callq 0x50e0
movq %rbx, %rdi
callq 0x5560
nop
// File: /workspace/github_cpp_makefile_star2_O3/pollow[P]MIPSClide/./instruction.h
// Function: Instruction::Instruction(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, int, char)
Instruction(string &&_command, string &&_reg1, string &&_reg2, int num, char _type) :
        command(_command), reg1(_reg1), reg2(_reg2), type(_type) {
            if ( command == "sll" || command == "sra" || command == "srl" ) {
                // special case for shamt
                type = 'R';
                shamt = num;
                has_shamt = true;
            } else if ( type == 'I' ) {
                imm = num;
            }
            reg_num = 2;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, -0x30(%rbp)
movl %r8d, -0x2c(%rbp)
movq %rcx, %r13
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x38(%rbp)
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x9dfc
leaq 0x20(%rbx), %r12
leaq 0x30(%rbx), %r14
movq %r14, 0x20(%rbx)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x9dfc
leaq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
movq %rax, 0x40(%rbx)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
callq 0x9dfc
leaq 0x70(%rbx), %rax
movq %rax, 0x60(%rbx)
movq $0x0, 0x68(%rbx)
xorl %eax, %eax
movb %al, 0x70(%rbx)
movl $0x0, 0x8c(%rbx)
movl -0x30(%rbp), %ecx
movb %cl, 0x90(%rbx)
movw $0x0, 0x91(%rbx)
movb %al, 0x93(%rbx)
leaq 0x13bc3(%rip), %rsi     # 0x214bc
movq %rbx, %rdi
callq 0x50b0
testl %eax, %eax
je 0xd940
leaq 0x13bb4(%rip), %rsi     # 0x214c0
movq %rbx, %rdi
callq 0x50b0
testl %eax, %eax
je 0xd940
leaq 0x13ba5(%rip), %rsi     # 0x214c4
movq %rbx, %rdi
callq 0x50b0
testl %eax, %eax
je 0xd940
cmpb $0x49, 0x90(%rbx)
jne 0xd960
movl -0x2c(%rbp), %eax
movw %ax, 0x88(%rbx)
jmp 0xd960
movw $0x152, 0x90(%rbx)      # imm = 0x152
movl 0x86(%rbx), %eax
movl -0x2c(%rbp), %ecx
andl $0x1f, %ecx
andl $-0x20, %eax
orl %ecx, %eax
movl %eax, 0x86(%rbx)
movl $0x2, 0x80(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r12), %rdi
cmpq %r14, %rdi
je 0xd98f
callq 0x52d0
jmp 0xd98f
movq %rax, %r15
movq (%rbx), %rdi
cmpq -0x38(%rbp), %rdi
je 0xd99d
callq 0x52d0
movq %r15, %rdi
callq 0x5560
nop
// File: /workspace/github_cpp_makefile_star2_O3/alexandres[P]terashuf/terashuf.cc
// Function: shufFlushBuf(char*, std::vector<unsigned long, std::allocator<unsigned long>>&, std::mersenne_twister_engine<unsigned long, 64ul, 312ul, 156ul, 31ul, 13043109905998158313ul, 29ul, 6148914691236517205ul, 17ul, 8202884508482404352ul, 37ul, 18444473444759240704ul, 43ul, 6364136223846793005ul>&, char, _IO_FILE*)
ll shufFlushBuf(char *buf, std::vector<ll> &shufIndexes, std::mt19937_64 &rng, char sep, FILE *f)
{
    std::shuffle(shufIndexes.begin(), shufIndexes.end(), rng);
    ll bytesWritten = 0;
    for (auto line : shufIndexes)
    {
        ll j = 0;
        while (*(buf + line + j) != sep)
            j++;
        ll bytesToWrite = j + 1;
        bytesWritten += bytesToWrite;
        if (fwrite(buf + line, sizeof(char), bytesToWrite, f) !=
            size_t(bytesToWrite))
        {
            fprintf(stderr, "\nFATAL ERROR: failed to write line to disk. is there space left in $TMPDIR?\n");
            exit(1);
        }
    }
    return bytesWritten;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, (%rsp)
movl %ecx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
callq 0x1f38
movq (%r15), %r13
movq 0x8(%r15), %rbx
cmpq %rbx, %r13
je 0x1cee
xorl %eax, %eax
movq %rax, %r15
movq (%r13), %rdi
addq %r14, %rdi
xorl %r12d, %r12d
movq %r12, %rax
incq %r12
cmpb %bpl, (%rdi,%rax)
jne 0x1cba
movl $0x1, %esi
movq %r12, %rdx
movq (%rsp), %rcx
callq 0x1200
cmpq %r12, %rax
jne 0x1d03
leaq (%r15,%r12), %rax
addq $0x8, %r13
cmpq %rbx, %r13
jne 0x1cad
addq %r12, %r15
jmp 0x1cf1
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1a0b
// File: /workspace/github_cpp_makefile_star2_O3/alexandres[P]terashuf/terashuf.cc
// Function: bufferedFgetc(TmpFile&)
char bufferedFgetc(TmpFile &f)
{
    if (!f.eof && f.bufPos == f.bufN)
    {
        f.bufN = fread(f.buf, sizeof(char), IO_CHUNK, f.f);
        f.bufPos = 0;
        if (!f.bufN)
            f.eof = true;
    }
    if (f.eof)
        return EOF;
    return f.buf[f.bufPos++];
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb 0x30(%rdi), %cl
testb %cl, %cl
jne 0x1d47
movq 0x20(%rbx), %rax
cmpq 0x28(%rbx), %rax
jne 0x1d47
movq (%rbx), %rcx
movq 0x18(%rbx), %rdi
movl $0x1, %esi
movl $0x10000, %edx          # imm = 0x10000
callq 0x11a0
movq %rax, 0x28(%rbx)
movq $0x0, 0x20(%rbx)
testq %rax, %rax
je 0x1d63
movb 0x30(%rbx), %cl
movb $-0x1, %al
testb $0x1, %cl
jne 0x1d61
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rbx)
movb (%rax,%rcx), %al
popq %rbx
retq
movb $0x1, 0x30(%rbx)
movb $-0x1, %al
jmp 0x1d61