LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x98, %rsp
movl $0x0, 0x94(%rsp)
movl %edi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movl $0x1f4, 0x84(%rsp) # imm = 0x1F4
movl $0x19, 0x80(%rsp)
movl $0x190, 0x7c(%rsp)      # imm = 0x190
movabsq $0x3fb5c28f5c28f5c3, %rax # imm = 0x3FB5C28F5C28F5C3
movq %rax, 0x70(%rsp)
movabsq $0x3f647ae147ae147b, %rax # imm = 0x3F647AE147AE147B
movq %rax, 0x68(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x2370
movq 0x28(%rsp), %rdx
leaq 0x479c(%rip), %rsi      # 0x8274
leaq 0x48(%rsp), %rdi
callq 0x22b0
jmp 0x3ae4
leaq 0x47(%rsp), %rdi
callq 0x2220
movb $0x0, 0x33(%rsp)
movb $0x0, 0x32(%rsp)
movb $0x0, 0x31(%rsp)
movl 0x90(%rsp), %edi
movq 0x88(%rsp), %rsi
movq %rsp, %rax
leaq 0x32(%rsp), %rcx
movq %rcx, 0x18(%rax)
leaq 0x31(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x33(%rsp), %rcx
movq %rcx, 0x8(%rax)
leaq 0x7c(%rsp), %rcx
movq %rcx, (%rax)
leaq 0x84(%rsp), %rdx
leaq 0x70(%rsp), %rcx
leaq 0x80(%rsp), %r8
leaq 0x68(%rsp), %r9
callq 0x25a0
jmp 0x3b53
movl 0x84(%rsp), %esi
movsd 0x70(%rsp), %xmm0
movsd 0x68(%rsp), %xmm1
movl 0x80(%rsp), %edx
movl 0x7c(%rsp), %ecx
movzbl 0x31(%rsp), %r9d
movzbl 0x33(%rsp), %r8d
movzbl 0x32(%rsp), %edi
andl $0x1, %edi
movq %rsp, %rax
movl %edi, (%rax)
andl $0x1, %r8d
andl $0x1, %r9d
leaq 0x48(%rsp), %rdi
callq 0x3450
jmp 0x3b9e
movl $0x0, 0x94(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2190
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x47(%rsp), %rdi
callq 0x2220
jmp 0x3bf4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2190
movq 0x38(%rsp), %rdi
callq 0x2360
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x4b20
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq 0x38(%rsp), %rdi
callq 0x4b20
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x4(%rax)
movq %rax, %rdi
addq $0x8, %rdi
movq %rdi, 0x18(%rsp)
movl 0x4(%rax), %esi
callq 0x4b50
movl $0x0, 0x34(%rsp)
movq 0x10(%rsp), %rcx
movl 0x34(%rsp), %eax
cmpl 0x4(%rcx), %eax
jge 0x460c
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movl 0x34(%rsp), %esi
callq 0x4b90
movq %rax, 0x8(%rsp)
jmp 0x45d2
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x4bb0
jmp 0x45e3
jmp 0x45e5
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x45ab
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x4eb0
jmp 0x4611
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x2360
nopl (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl %edx, 0x48(%rsp)
movl %ecx, 0x44(%rsp)
movsd %xmm0, 0x38(%rsp)
movsd %xmm1, 0x30(%rsp)
movl %r8d, 0x2c(%rsp)
movl %r9d, 0x28(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x0, (%rdi)
movl 0x4c(%rsp), %eax
movl %eax, 0x4(%rdi)
addq $0x8, %rdi
movq %rdi, 0x10(%rsp)
movl 0x4c(%rsp), %esi
callq 0x4b50
movl 0x4c(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x4c(%rsp)
cmpl $0x0, %eax
je 0x46eb
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movl 0x4c(%rsp), %esi
callq 0x4b90
movq %rax, %rdi
movl 0x48(%rsp), %esi
movl 0x44(%rsp), %edx
movsd 0x38(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
movl 0x2c(%rsp), %ecx
movl 0x28(%rsp), %r8d
callq 0x5140
jmp 0x46cf
jmp 0x4684
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x4eb0
jmp 0x46f0
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x2360
nopw (%rax,%rax)
// File: 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:
subq $0x98, %rsp
movb %r8b, %al
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movl %ecx, 0x7c(%rsp)
andb $0x1, %al
movb %al, 0x7b(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x88(%rsp), %rax
movl (%rax), %esi
leaq 0x68(%rsp), %rdi
callq 0x40f0
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
cmpl 0x68(%rsp), %eax
jge 0x47ad
movl 0x64(%rsp), %esi
movl %esi, 0x3c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x4220
movq %rax, 0x40(%rsp)
jmp 0x4778
movq 0x40(%rsp), %rax
movl 0x3c(%rsp), %ecx
movl %ecx, (%rax)
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x4755
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x4520
jmp 0x48b7
jmp 0x47af
movl 0x7c(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x7c(%rsp)
cmpl $0x0, %eax
je 0x48a5
testb $0x1, 0x7b(%rsp)
je 0x47da
leaq 0x68(%rsp), %rdi
callq 0x3c50
jmp 0x47d8
jmp 0x47da
movl $0x0, 0x50(%rsp)
movl 0x50(%rsp), %eax
movq 0x88(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x4894
movq 0x88(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x50(%rsp), %esi
leaq 0x68(%rsp), %rdi
callq 0x4220
movq %rax, 0x30(%rsp)
jmp 0x4818
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rax
movl (%rax), %esi
callq 0x4160
movq %rax, 0x20(%rsp)
jmp 0x4830
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x50(%rsp), %esi
leaq 0x68(%rsp), %rdi
callq 0x4220
movq %rax, 0x18(%rsp)
jmp 0x4852
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movl (%rax), %esi
callq 0x4220
movq %rax, 0x8(%rsp)
jmp 0x486a
movq 0x20(%rsp), %rsi
movq 0x48(%rsp), %rdi
movq 0x8(%rsp), %rax
movl (%rax), %edx
callq 0x53a0
jmp 0x4882
jmp 0x4884
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x47e2
movq 0x48(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x47af
leaq 0x68(%rsp), %rdi
callq 0x4520
addq $0x98, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x2360
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x495d
movq 0x28(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x4160
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x5cd0
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x4220
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x48fd
cvtsi2sdl 0x1c(%rsp), %xmm0
movq 0x28(%rsp), %rax
cvtsi2sdl (%rax), %xmm1
divsd %xmm1, %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: adrianphoulady[P]weighted-tsetlin-machine-cpp/./multiweightm.h
// Function: multiweightm::serialize(std::ostream&)
void serialize(std::ostream &os) {
        put(os, epoch);
        put(os, classes);
        for (int c = 0; c < classes; ++c)
            machine(c).serialize(os);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl (%rax), %esi
callq 0x5da0
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rdi
movl 0x4(%rax), %esi
callq 0x5da0
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x4(%rcx), %eax
jge 0x49f8
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movl 0x14(%rsp), %esi
callq 0x4b90
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x5dd0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x49be
addq $0x28, %rsp
retq
nopl (%rax)
// File: adrianphoulady[P]weighted-tsetlin-machine-cpp/./array.h
// Function: array3d<unsigned int>::array3d(int, int, int)
array3d(int aisles, int rows, int columns)
    : aisles{aisles},
    rows{rows},
    columns{columns},
    data{(T*) new char[aisles * rows * columns * sizeof(T)]} {
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %ecx
movl %ecx, (%rax)
movl 0x18(%rsp), %ecx
movl %ecx, 0x4(%rax)
movl 0x14(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl 0x1c(%rsp), %eax
imull 0x18(%rsp), %eax
imull 0x14(%rsp), %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x2030
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x4(%rax), %edi
subl $0x1, %edi
callq 0x3420
movq (%rsp), %rdi
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %eax
cmpl 0xc(%rsp), %eax
setge %al
andb $0x1, %al
movzbl %al, %eax
addl 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
addq $0x8, %rdi
movl 0x10(%rsp), %esi
callq 0x4b90
movq %rax, %rdi
movq 0x18(%rsp), %rsi
xorl %edx, %edx
callq 0x5440
movq (%rsp), %rdi
addq $0x8, %rdi
movl 0xc(%rsp), %esi
callq 0x4b90
movq %rax, %rdi
movq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x5440
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
cvtsi2sdl 0x24(%rsp), %xmm1
movsd 0x2c0e(%rip), %xmm0     # 0x8078
subsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq 0x28(%rsp), %rsi
movl $0x1, %edx
callq 0x5530
movsd (%rsp), %xmm1
movq 0x8(%rsp), %rax
mulsd %xmm0, %xmm1
cvtsi2sdl 0x18(%rax), %xmm0
divsd %xmm0, %xmm1
movsd 0x2bd7(%rip), %xmm0     # 0x8078
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x4(%rcx), %eax
jge 0x551d
callq 0x3cc0
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x550e
movl 0x24(%rsp), %eax
movl 0x14(%rsp), %ecx
andl $0x1, %ecx
cmpl %ecx, %eax
je 0x54f9
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x28(%rsp), %rdx
callq 0x55d0
jmp 0x550c
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x28(%rsp), %rdx
callq 0x5760
jmp 0x550e
jmp 0x5510
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x54b3
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x4(%rcx), %eax
jge 0x55c1
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x28(%rsp), %rdx
movb 0x27(%rsp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x5860
cmpl $0x0, %eax
je 0x55b2
movq 0x8(%rsp), %rdi
addq $0x60, %rdi
movl 0x14(%rsp), %esi
callq 0x5090
movsd (%rax), %xmm0
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x55b4
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x5561
movsd 0x18(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x5990
movq 0x20(%rsp), %rdi
addq $0x50, %rdi
movl 0x3c(%rsp), %esi
callq 0x4220
cmpl $0x0, (%rax)
je 0x56eb
movq 0x20(%rsp), %rdi
movsd 0x2a6f(%rip), %xmm0     # 0x8088
addsd 0x10(%rdi), %xmm0
movsd %xmm0, 0x18(%rsp)
addq $0x60, %rdi
movl 0x3c(%rsp), %esi
callq 0x5090
movsd 0x18(%rsp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0x20(%rcx), %eax
jge 0x56e9
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
movl 0x3c(%rsp), %esi
movl 0x2c(%rsp), %edx
callq 0x5ba0
movq 0x20(%rsp), %rdi
movq %rax, %rsi
movq 0x30(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movl (%rax,%rcx,4), %edx
callq 0x5ad0
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
movl 0x3c(%rsp), %esi
movl 0x2c(%rsp), %edx
callq 0x5ba0
movq 0x20(%rsp), %rdi
movq %rax, 0x10(%rsp)
addq $0x40, %rdi
movl 0x2c(%rsp), %esi
callq 0x5cb0
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl (%rax), %edx
movq 0x30(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
xorl $-0x1, %eax
andl %eax, %edx
callq 0x5be0
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x5647
jmp 0x574e
movl $0x0, 0x28(%rsp)
movq 0x20(%rsp), %rcx
movl 0x28(%rsp), %eax
cmpl 0x20(%rcx), %eax
jge 0x574c
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
movl 0x3c(%rsp), %esi
movl 0x28(%rsp), %edx
callq 0x5ba0
movq 0x20(%rsp), %rdi
movq %rax, 0x8(%rsp)
addq $0x40, %rdi
movl 0x28(%rsp), %esi
callq 0x5cb0
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl (%rax), %edx
callq 0x5be0
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x56f3
jmp 0x574e
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: adrianphoulady[P]weighted-tsetlin-machine-cpp/./weightm.h
// Function: weightm::clearer(int, unsigned int const*)
void clearer(int c, word const *x) {
        if (clause(c)) {
            weight(c) /= 1 + gamma;
            for (int l = 0; l < literals; ++l)
                add(state(c, l), ~state(c, l, states - 1) & ~x[l]);
        }
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x50, %rdi
movl 0x2c(%rsp), %esi
callq 0x4220
cmpl $0x0, (%rax)
je 0x584f
movq 0x10(%rsp), %rdi
movsd 0x28e9(%rip), %xmm0     # 0x8088
addsd 0x10(%rdi), %xmm0
movsd %xmm0, 0x8(%rsp)
addq $0x60, %rdi
movl 0x2c(%rsp), %esi
callq 0x5090
movsd 0x8(%rsp), %xmm1
movsd (%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x20(%rcx), %eax
jge 0x584d
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
movl 0x2c(%rsp), %esi
movl 0x1c(%rsp), %edx
callq 0x5ba0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rsp)
movq %rax, %rdi
addq $0x28, %rdi
movl 0x2c(%rsp), %esi
movl 0x1c(%rsp), %edx
movl 0x1c(%rax), %ecx
subl $0x1, %ecx
callq 0x5050
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movl (%rax), %edx
xorl $-0x1, %edx
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
xorl $-0x1, %eax
andl %eax, %edx
callq 0x5ad0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x57d1
jmp 0x584f
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x48, %rsp
movb %cl, %al
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x20(%rsp)
movl 0x24(%rax), %ecx
movl %ecx, 0x14(%rsp)
movq %rax, %rdi
addq $0x28, %rdi
movl 0x34(%rsp), %esi
movl 0x20(%rax), %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x5050
movl 0x14(%rsp), %ecx
andl (%rax), %ecx
movl %ecx, (%rax)
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x20(%rcx), %eax
jge 0x5943
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x28, %rdi
movl 0x34(%rsp), %esi
movl 0x1c(%rsp), %edx
movl 0x1c(%rax), %ecx
subl $0x1, %ecx
callq 0x5050
movl (%rax), %eax
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq 0x28(%rsp), %rcx
movslq 0x1c(%rsp), %rdx
andl (%rcx,%rdx,4), %eax
cmpl 0x18(%rsp), %eax
je 0x5927
movq 0x8(%rsp), %rdi
addq $0x50, %rdi
movl 0x34(%rsp), %esi
callq 0x4220
movl $0x0, (%rax)
movl $0x0, 0x44(%rsp)
jmp 0x5986
movl 0x18(%rsp), %eax
orl 0x20(%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x58bb
movb $0x1, %al
testb $0x1, 0x27(%rsp)
movb %al, 0x7(%rsp)
jne 0x595c
cmpl $0x0, 0x20(%rsp)
setne %al
movb %al, 0x7(%rsp)
movq 0x8(%rsp), %rdi
movb 0x7(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, (%rsp)
addq $0x50, %rdi
movl 0x34(%rsp), %esi
callq 0x4220
movq %rax, %rcx
movl (%rsp), %eax
movl %eax, (%rcx)
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nop
// File: adrianphoulady[P]weighted-tsetlin-machine-cpp/./weightm.h
// Function: weightm::literal_mask()
void literal_mask() {
        int n = features << 1, flips = binomial(p, n);
        bool const target = flips <= features;
        // if flips are more than half, do it the other way; make 0s in an all-1 sequence
        if (!target)
            flips = n - flips;
        std::fill(&lmask(0), &lmask(literals), target - 1);
        while (flips) {
            auto l = fastrandrange(n), w = l / word_bits, b = l % word_bits;
            if ((lmask(w) >> b & 1) == target)
                continue;
            lmask(w) ^= (word) 1 << b;
            --flips;
        }
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movl (%rax), %ecx
shll %ecx
movl %ecx, 0x3c(%rsp)
movsd 0x8(%rax), %xmm0
movl 0x3c(%rsp), %edi
callq 0x3ce0
movq 0x18(%rsp), %rcx
movl %eax, 0x38(%rsp)
movl 0x38(%rsp), %eax
cmpl (%rcx), %eax
setle %al
andb $0x1, %al
movb %al, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x59e4
movl 0x3c(%rsp), %eax
subl 0x38(%rsp), %eax
movl %eax, 0x38(%rsp)
movq 0x18(%rsp), %rdi
addq $0x40, %rdi
xorl %esi, %esi
callq 0x5cb0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rsp)
movq %rax, %rdi
addq $0x40, %rdi
movl 0x20(%rax), %esi
callq 0x5cb0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movb 0x37(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
subl $0x1, %eax
movl %eax, 0x30(%rsp)
leaq 0x30(%rsp), %rdx
callq 0x4130
cmpl $0x0, 0x38(%rsp)
je 0x5ac6
movl 0x3c(%rsp), %edi
callq 0x3420
movq 0x18(%rsp), %rdi
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
shrl $0x5, %eax
movl %eax, 0x28(%rsp)
movl 0x2c(%rsp), %eax
andl $0x1f, %eax
movl %eax, 0x24(%rsp)
addq $0x40, %rdi
movl 0x28(%rsp), %esi
callq 0x5cb0
movl (%rax), %eax
movl 0x24(%rsp), %ecx
shrl %cl, %eax
andl $0x1, %eax
movb 0x37(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x5a8d
jmp 0x5a32
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0xc(%rsp)
addq $0x40, %rdi
movl 0x28(%rsp), %esi
callq 0x5cb0
movl 0xc(%rsp), %ecx
xorl (%rax), %ecx
movl %ecx, (%rax)
movl 0x38(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x5a32
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movl $0x0, -0x18(%rsp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rsp)
movb %al, -0x29(%rsp)
je 0x5b10
movq -0x28(%rsp), %rcx
movl -0x18(%rsp), %eax
cmpl 0x1c(%rcx), %eax
setl %al
movb %al, -0x29(%rsp)
movb -0x29(%rsp), %al
testb $0x1, %al
jne 0x5b1a
jmp 0x5b54
movl -0x14(%rsp), %edx
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
movl (%rax,%rcx,4), %eax
xorl -0x14(%rsp), %eax
andl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x5af0
cmpl $0x0, -0x14(%rsp)
je 0x5b94
movl $0x0, -0x1c(%rsp)
movq -0x28(%rsp), %rcx
movl -0x1c(%rsp), %eax
cmpl 0x1c(%rcx), %eax
jge 0x5b92
movl -0x14(%rsp), %edx
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x5b63
jmp 0x5b94
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movl $0x0, -0x18(%rsp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rsp)
movb %al, -0x29(%rsp)
je 0x5c20
movq -0x28(%rsp), %rcx
movl -0x18(%rsp), %eax
cmpl 0x1c(%rcx), %eax
setl %al
movb %al, -0x29(%rsp)
movb -0x29(%rsp), %al
testb $0x1, %al
jne 0x5c2a
jmp 0x5c67
movl -0x14(%rsp), %edx
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
movl (%rax,%rcx,4), %eax
xorl -0x14(%rsp), %eax
xorl $-0x1, %eax
andl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x5c00
cmpl $0x0, -0x14(%rsp)
je 0x5ca7
movl $0x0, -0x1c(%rsp)
movq -0x28(%rsp), %rcx
movl -0x1c(%rsp), %eax
cmpl 0x1c(%rcx), %eax
jge 0x5ca5
movl -0x14(%rsp), %edx
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x5c76
jmp 0x5ca7
retq
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x0, 0x34(%rsp)
addq $0x8, %rdi
xorl %esi, %esi
callq 0x4b90
movq %rax, %rdi
movq 0x38(%rsp), %rsi
xorl %edx, %edx
callq 0x5530
movsd %xmm0, 0x28(%rsp)
movl $0x1, 0x1c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x4(%rcx), %eax
jge 0x5d88
movq 0x10(%rsp), %rdi
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
addq $0x8, %rdi
movl 0x1c(%rsp), %esi
callq 0x4b90
movq %rax, %rdi
movq 0x38(%rsp), %rsi
xorl %edx, %edx
callq 0x5530
movsd 0x8(%rsp), %xmm1
movsd %xmm0, 0x20(%rsp)
ucomisd %xmm1, %xmm0
jbe 0x5d79
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x5d7b
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x5d18
movl 0x34(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl (%rax), %esi
callq 0x5da0
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rdi
movl 0x4(%rax), %esi
callq 0x5da0
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rdi
movsd 0x8(%rax), %xmm0
callq 0x5f60
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rdi
movsd 0x10(%rax), %xmm0
callq 0x5f60
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rdi
movl 0x18(%rax), %esi
callq 0x5da0
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rdi
movl 0x1c(%rax), %esi
callq 0x5da0
movq 0x28(%rsp), %rdi
movq 0x6392(%rip), %rsi      # 0xc1f0
callq 0x5f90
movl $0x0, 0x24(%rsp)
movq 0x10(%rsp), %rcx
movl 0x24(%rsp), %eax
cmpl 0x4(%rcx), %eax
jge 0x5f07
movl $0x0, 0x20(%rsp)
movq 0x10(%rsp), %rcx
movl 0x20(%rsp), %eax
cmpl 0x20(%rcx), %eax
jge 0x5ef5
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x1c(%rcx), %eax
jge 0x5ee6
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x28, %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movl 0x1c(%rsp), %ecx
callq 0x5050
movq 0x8(%rsp), %rdi
movl (%rax), %esi
callq 0x5fc0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x5e9b
jmp 0x5ee8
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x5e85
jmp 0x5ef7
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x5e6b
movl $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rcx
movl 0x18(%rsp), %eax
cmpl 0x4(%rcx), %eax
jge 0x5f52
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
addq $0x60, %rdi
movl 0x18(%rsp), %esi
callq 0x5090
movq (%rsp), %rdi
movsd (%rax), %xmm0
callq 0x5f60
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x5f0f
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/gen-bases.c
// Function: ulog2
unsigned int
ulog2 (unsigned int x)
{
  unsigned int i;
  for (i = 0;  x != 0;  i++)
    x >>= 1;
  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0xb847
movl -0x4(%rbp), %eax
shrl %eax
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xb82e
movl -0x8(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x4(%rbp), %eax
subl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
leaq 0x784f(%rip), %rdi      # 0x130c0
movl $0x1, %esi
callq 0x3370
movslq -0x10(%rbp), %rdx
leaq 0x783a(%rip), %rsi      # 0x130c0
movq %rsi, %rdi
callq 0x5020
leaq 0x783b(%rip), %rdi      # 0x130d0
movl $0x1, %esi
callq 0x3370
movl $0x0, 0x7837(%rip)      # 0x130e0
movslq -0xc(%rbp), %rdx
leaq 0x781c(%rip), %rsi      # 0x130d0
movq %rsi, %rdi
callq 0x4d70
leaq 0x780d(%rip), %rdi      # 0x130d0
leaq 0x77f6(%rip), %rsi      # 0x130c0
callq 0x41d0
cmpl $0x0, %eax
jle 0xb8d6
jmp 0xb8e7
movl 0x7804(%rip), %eax      # 0x130e0
addl $0x1, %eax
movl %eax, 0x77fb(%rip)      # 0x130e0
jmp 0xb8a9
movslq -0xc(%rbp), %rsi
movslq 0x77ee(%rip), %rdx      # 0x130e0
leaq 0x77d7(%rip), %rdi      # 0x130d0
callq 0x7720
movslq -0x4(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x77c3(%rip), %rdi      # 0x130d0
movl $0x2, %esi
callq 0x8250
movq %rax, %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movl %eax, 0x77bd(%rip)      # 0x130e4
leaq 0x7792(%rip), %rdi      # 0x130c0
movl $0x1, %esi
callq 0x3370
movl -0x4(%rbp), %eax
shll %eax
subl 0x77a1(%rip), %eax      # 0x130e4
movslq %eax, %rdx
leaq 0x7773(%rip), %rsi      # 0x130c0
movq %rsi, %rdi
callq 0x5020
leaq 0x7794(%rip), %rdi      # 0x130f0
leaq 0x775d(%rip), %rsi      # 0x130c0
leaq 0x7766(%rip), %rdx      # 0x130d0
callq 0x57e0
leaq 0x774a(%rip), %rdi      # 0x130c0
movl $0x1, %esi
callq 0x3370
movslq -0x4(%rbp), %rdx
leaq 0x7735(%rip), %rsi      # 0x130c0
movq %rsi, %rdi
callq 0x5020
leaq 0x7756(%rip), %rsi      # 0x130f0
leaq 0x771f(%rip), %rdx      # 0x130c0
movq %rsi, %rdi
callq 0x4c70
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
subl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl $0xa, %edx
callq 0xb850
leaq 0x3186(%rip), %rdi      # 0xeb64
movb $0x0, %al
callq 0x1070
leaq 0x3312(%rip), %rdi      # 0xecfe
movb $0x0, %al
callq 0x1070
movl -0xc(%rbp), %esi
leaq 0x31a0(%rip), %rdi      # 0xeb9d
movb $0x0, %al
callq 0x1070
movl -0xc(%rbp), %esi
leaq 0x31a8(%rip), %rdi      # 0xebb6
movb $0x0, %al
callq 0x1070
leaq 0x31c2(%rip), %rdi      # 0xebde
movb $0x0, %al
callq 0x1070
leaq 0x32d4(%rip), %rdi      # 0xecfe
movb $0x0, %al
callq 0x1070
leaq 0x31ae(%rip), %rdi      # 0xebe6
movb $0x0, %al
callq 0x1070
movl 0x769b(%rip), %esi      # 0x130e0
leaq 0x31c6(%rip), %rdi      # 0xec12
movb $0x0, %al
callq 0x1070
leaq 0x31e4(%rip), %rdi      # 0xec3e
movb $0x0, %al
callq 0x1070
movq 0x7570(%rip), %rax      # 0x12fd8
movq (%rax), %rdi
movl $0x10, %esi
leaq 0x7659(%rip), %rdx      # 0x130d0
callq 0xacf0
leaq 0x31f0(%rip), %rdi      # 0xec73
movb $0x0, %al
callq 0x1070
leaq 0x31e5(%rip), %rdi      # 0xec76
movb $0x0, %al
callq 0x1070
movq 0x7539(%rip), %rax      # 0x12fd8
movq (%rax), %rdi
movl $0x10, %esi
leaq 0x7642(%rip), %rdx      # 0x130f0
callq 0xacf0
leaq 0x31b9(%rip), %rdi      # 0xec73
movb $0x0, %al
callq 0x1070
movl 0x761d(%rip), %esi      # 0x130e4
leaq 0x31dd(%rip), %rdi      # 0xecab
movb $0x0, %al
callq 0x1070
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x3540
leaq -0x20(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl -0x10(%rbp), %eax
addl $0x10, %eax
movslq %eax, %rdx
callq 0x5020
leaq -0x30(%rbp), %rdi
callq 0x3200
leaq -0x40(%rbp), %rdi
movl $0x2, %esi
callq 0x3540
leaq -0x40(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl -0x10(%rbp), %eax
addl $0x10, %eax
movslq %eax, %rdx
callq 0x5020
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3370
leaq -0x50(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x3540
leaq -0x50(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl -0x10(%rbp), %eax
addl $0x10, %eax
movslq %eax, %rdx
callq 0x5020
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
jl 0xbc0c
leaq -0x50(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl -0x10(%rbp), %eax
addl $0x10, %eax
movslq %eax, %rdx
callq 0x5020
leaq -0x50(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x8500
leaq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x4e90
leaq -0x30(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl -0x10(%rbp), %eax
addl $0x10, %eax
movslq %eax, %rdx
callq 0x5ba0
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x41d0
cmpl $0x0, %eax
jge 0xbbfc
movq -0x8(%rbp), %rdi
movslq -0x54(%rbp), %rsi
callq 0x7440
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x33b0
jmp 0xbbfe
movl -0x54(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0xbb7c
leaq -0x20(%rbp), %rdi
callq 0x32e0
leaq -0x30(%rbp), %rdi
callq 0x32e0
leaq -0x40(%rbp), %rdi
callq 0x32e0
leaq -0x50(%rbp), %rdi
callq 0x32e0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x7193(%rip), %rdi      # 0x130d0
callq 0x3200
leaq 0x71a7(%rip), %rdi      # 0x130f0
callq 0x3200
leaq 0x716b(%rip), %rdi      # 0x130c0
callq 0x3200
cmpl $0x4, -0x8(%rbp)
je 0xbf82
movq 0x7091(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0x2e1e(%rip), %rsi      # 0xed8f
movb $0x0, %al
callq 0x10a0
movl $0x1, %edi
callq 0x10e0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10d0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x10d0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0xbfb6
cmpl $0x0, -0x18(%rbp)
jl 0xbfb6
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0xbfde
movq 0x703b(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
leaq 0x2df9(%rip), %rsi      # 0xedc6
movb $0x0, %al
callq 0x10a0
movl $0x1, %edi
callq 0x10e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x2df8(%rip), %rsi      # 0xede5
callq 0x1090
cmpl $0x0, %eax
jne 0xc004
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
callq 0xb9b0
jmp 0xc056
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x2dd9(%rip), %rsi      # 0xedec
callq 0x1090
cmpl $0x0, %eax
jne 0xc02a
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
callq 0xbc40
jmp 0xc054
movq 0x6fc7(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x2daf(%rip), %rsi      # 0xedf2
movb $0x0, %al
callq 0x10a0
movl $0x1, %edi
callq 0x10e0
jmp 0xc056
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
cmpb $0x0, 0x577e7(%rip)     # 0x6b8f8
jne 0x14164
leaq 0x577de(%rip), %rdi     # 0x6b8f8
callq 0x67c0
cmpl $0x0, %eax
je 0x14164
leaq 0x577ad(%rip), %rdi     # 0x6b8d8
leaq 0x3634d(%rip), %rsi     # 0x4a47f
movl $0x10, %edx
callq 0x14f60
jmp 0x1413e
leaq 0xebb(%rip), %rdi       # 0x15000
leaq 0x5778c(%rip), %rsi     # 0x6b8d8
leaq 0x57305(%rip), %rdx     # 0x6b458
callq 0x63d0
leaq 0x57799(%rip), %rdi     # 0x6b8f8
callq 0x62e0
movq $0x0, -0x20(%rbp)
movq -0xa8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0xb0(%rbp)
addq $0x20, %rdi
callq 0x11210
movq %rax, %rcx
movq -0xb0(%rbp), %rax
cmpq %rcx, %rax
jae 0x1432f
movq -0xa8(%rbp), %rdi
addq $0x20, %rdi
movq -0x20(%rbp), %rsi
callq 0x162c0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x5771b(%rip), %rsi     # 0x6b8d8
xorl %edx, %edx
callq 0x162e0
testb $0x1, %al
jne 0x141cd
jmp 0x1431e
movq -0xa8(%rbp), %rax
addq $0x68, %rax
movq %rax, -0xc8(%rbp)
movq -0x28(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x6640
movq -0xc0(%rbp), %rsi
movq %rax, %rcx
decq %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x70(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x6460
movq -0xb8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
leaq -0x20(%rbp), %rdx
callq 0x16370
jmp 0x14226
movq -0xc8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x16330
movb %dl, -0xd1(%rbp)
movq %rax, -0xd0(%rbp)
jmp 0x14245
movb -0xd1(%rbp), %al
movq -0xd0(%rbp), %rcx
movq %rcx, -0x80(%rbp)
movb %al, -0x78(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x163b0
leaq -0x70(%rbp), %rdi
callq 0x62a0
movq -0xa8(%rbp), %rdi
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0xe0(%rbp)
addq $0x20, %rdi
callq 0xf7d0
movq %rax, -0x98(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0xf800
movq %rax, -0x90(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0xf880
movq -0xe0(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x163d0
movq %rax, -0xa0(%rbp)
jmp 0x1432a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq 0x5760f(%rip), %rdi     # 0x6b8f8
callq 0x62d0
jmp 0x14338
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x14313
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x163b0
leaq -0x70(%rbp), %rdi
callq 0x62a0
jmp 0x14338
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1416c
addq $0xe0, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x6790
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpb $0x0, 0x575b2(%rip)     # 0x6b920
jne 0x143c1
leaq 0x575a9(%rip), %rdi     # 0x6b920
callq 0x67c0
cmpl $0x0, %eax
je 0x143c1
leaq 0x57578(%rip), %rdi     # 0x6b900
leaq 0x360f7(%rip), %rsi     # 0x4a486
movl $0x10, %edx
callq 0x14f60
jmp 0x1439b
leaq 0xc5e(%rip), %rdi       # 0x15000
leaq 0x57557(%rip), %rsi     # 0x6b900
leaq 0x570a8(%rip), %rdx     # 0x6b458
callq 0x63d0
leaq 0x57564(%rip), %rdi     # 0x6b920
callq 0x62e0
cmpb $0x0, 0x57580(%rip)     # 0x6b948
jne 0x1441b
leaq 0x57577(%rip), %rdi     # 0x6b948
callq 0x67c0
cmpl $0x0, %eax
je 0x1441b
leaq 0x57546(%rip), %rdi     # 0x6b928
leaq 0x360ab(%rip), %rsi     # 0x4a494
movl $0x10, %edx
callq 0x14f60
jmp 0x143f5
leaq 0xc04(%rip), %rdi       # 0x15000
leaq 0x57525(%rip), %rsi     # 0x6b928
leaq 0x5704e(%rip), %rdx     # 0x6b458
callq 0x63d0
leaq 0x57532(%rip), %rdi     # 0x6b948
callq 0x62e0
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
callq 0xf7d0
movq %rax, -0x20(%rbp)
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
callq 0xf9c0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xf980
testb $0x1, %al
jne 0x14453
jmp 0x14523
leaq -0x20(%rbp), %rdi
callq 0xf9f0
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
leaq 0x57496(%rip), %rdx     # 0x6b900
leaq 0x36006(%rip), %rcx     # 0x4a477
xorl %r8d, %r8d
callq 0x151b0
leaq -0x20(%rbp), %rdi
callq 0xf9f0
movq %rax, %rdi
leaq -0x48(%rbp), %rsi
callq 0x6520
leaq -0x48(%rbp), %rdi
callq 0x62a0
leaq -0x20(%rbp), %rdi
callq 0xf9f0
movq %rax, %rsi
leaq -0x68(%rbp), %rdi
leaq 0x5747a(%rip), %rdx     # 0x6b928
leaq 0x35fc2(%rip), %rcx     # 0x4a477
xorl %r8d, %r8d
callq 0x151b0
leaq -0x20(%rbp), %rdi
callq 0xf9f0
movq %rax, %rdi
leaq -0x68(%rbp), %rsi
callq 0x6520
leaq -0x68(%rbp), %rdi
callq 0x62a0
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0xfa10
movq %rax, -0x70(%rbp)
jmp 0x1442c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq 0x5741e(%rip), %rdi     # 0x6b920
callq 0x62d0
jmp 0x1452c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq 0x5742c(%rip), %rdi     # 0x6b948
callq 0x62d0
jmp 0x1452c
addq $0x80, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x6790
nopw %cs:(%rax,%rax)
// File: 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
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1e8(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x15550
movq -0x1e8(%rbp), %rsi
movl %eax, %edx
leaq -0x190(%rbp), %rdi
callq 0x6690
leaq -0x1b0(%rbp), %rdi
callq 0x65f0
leaq -0x190(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
movl $0xa, %edx
callq 0x67e0
movq %rax, -0x1f0(%rbp)
jmp 0x145ab
movq -0x1f0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x6550
movb %al, -0x1f1(%rbp)
jmp 0x145c9
movb -0x1f1(%rbp), %al
testb $0x1, %al
jne 0x145d8
jmp 0x146ae
leaq -0x1b0(%rbp), %rdi
movq %rdi, -0x208(%rbp)
callq 0x63c0
movq -0x208(%rbp), %rdi
movq %rax, -0x1c8(%rbp)
callq 0x6260
movq -0x208(%rbp), %rdi
movq %rax, -0x1d0(%rbp)
callq 0x63c0
movq %rax, -0x1d8(%rbp)
movq -0x1c8(%rbp), %rdi
movq -0x1d0(%rbp), %rsi
movq -0x1d8(%rbp), %rdx
movq 0x56974(%rip), %rcx     # 0x6afa8
callq 0x16440
movq %rax, -0x200(%rbp)
jmp 0x14642
movq -0x200(%rbp), %rax
movq %rax, -0x1e0(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x6640
cmpq $0x1, %rax
jbe 0x146a9
movq -0x1e8(%rbp), %rdi
addq $0x20, %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x164c0
jmp 0x1467b
jmp 0x146a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x62a0
leaq -0x190(%rbp), %rdi
callq 0x6360
jmp 0x146cf
jmp 0x1458a
leaq -0x1b0(%rbp), %rdi
callq 0x62a0
leaq -0x190(%rbp), %rdi
callq 0x6360
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0x1b8(%rbp), %rdi
callq 0x6790
nopl (%rax,%rax)