LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: lipiji[P]PG_DEEP/deep.cpp
// Function: Conf::Conf(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, int, int*, int, double, int, int, double)
Conf::Conf(string ftx, string fty, int epc, int bs, int *hls, int k, double lr, int n_ly, int n_lb, double lbd)
{
    f_train_x = ftx;
    f_train_y = fty;
    epoch = epc;
    batch_size = bs;
    hidden_layer_size = hls;
    cd_k = k;
    learning_rate = lr;
    n_layers = n_ly;
    n_labels = n_lb;
    lamda = lbd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x80(%rbp)
movq %rsi, -0x50(%rbp)
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movsd %xmm0, -0x30(%rbp)
movsd %xmm1, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
callq 0x2300
movq -0x58(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x70(%rbp)
callq 0x2300
movq -0x58(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x68(%rbp)
callq 0x2300
movq -0x58(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x60(%rbp)
callq 0x2300
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x2040
jmp 0x4c03
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
callq 0x2040
jmp 0x4c16
movq -0x78(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, 0x80(%rax)
movl -0x20(%rbp), %ecx
movl %ecx, 0x84(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x88(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x90(%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x98(%rax)
movl 0x18(%rbp), %ecx
movl %ecx, 0xa0(%rax)
movl 0x20(%rbp), %ecx
movl %ecx, 0xa4(%rax)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0xa8(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x2140
movq -0x68(%rbp), %rdi
callq 0x2140
movq -0x70(%rbp), %rdi
callq 0x2140
movq -0x58(%rbp), %rdi
callq 0x2140
movq -0x40(%rbp), %rdi
callq 0x23a0
nop
// File: lipiji[P]PG_DEEP/deep.cpp
// Function: RBM::activate_hidden(double*, double*, int*, int, int)
void RBM::activate_hidden(double *v_prob, double *h_prob, int *h_state, int n_visible, int n_hidden)
{	
    //v->h
    for(int i=0; i<n_hidden; i++)
    {
        double vh_prob = 0;
        for(int j=0; j<n_visible; j++)
        {
            // prob or state?
            vh_prob += v_prob[j] * W[i][j];
        }
        vh_prob += hbias[i];
        h_prob[i] = sigmoid(vh_prob);
        if(h_state != NULL)
            h_state[i] = binomial(1, h_prob[i]);
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x5f62
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x5ef5
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x3c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x10(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x38(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x5eaa
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x4990
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
cmpq $0x0, -0x20(%rbp)
je 0x5f52
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movl $0x1, %edi
callq 0x49e0
movl %eax, %edx
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x5f54
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5e8f
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lipiji[P]PG_DEEP/deep.cpp
// Function: RBM::activate_visible(int*, double*, int*, int, int)
void RBM::activate_visible(int *h_state, double *v_prob, int *v_state, int n_hidden, int n_visible)
{	
    //h->v
    for(int i=0; i<n_visible; i++)
    {
        double hv_prob = 0;
        for(int j=0; j<n_hidden; j++)
        {
            hv_prob += h_state[j] * W[j][i];
        }
        hv_prob += vbias[i];
        v_prob[i] = sigmoid(hv_prob);
        v_state[i] = binomial(1, v_prob[i]);
    }	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x6069
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x6005
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x3c(%rbp), %rdx
cvtsi2sdl (%rcx,%rdx,4), %xmm0
movq 0x10(%rax), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x38(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x5fba
movq -0x48(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x4990
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movl $0x1, %edi
callq 0x49e0
movl %eax, %edx
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5f9f
addq $0x50, %rsp
popq %rbp
retq
nop
// File: lipiji[P]PG_DEEP/deep.cpp
// Function: RBM::~RBM()
RBM::~RBM()
{
    for(int i=0; i < n_hidden; i++)
        delete[] W[i];
    delete[] W;
    delete[] hbias;
    delete[] vbias;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x6517
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x650a
movq -0x20(%rbp), %rdi
callq 0x22e0
jmp 0x650c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x64db
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x6532
movq -0x28(%rbp), %rdi
callq 0x22e0
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x654d
movq -0x30(%rbp), %rdi
callq 0x22e0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x6568
movq -0x38(%rbp), %rdi
callq 0x22e0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: lipiji[P]PG_DEEP/deep.cpp
// Function: LR::LR(Dataset, Conf)
LR::LR(Dataset data, Conf conf)
{
    n_samples = data.N;
    n_features = data.n_f;
    n_labels = conf.n_labels;
    lamda = conf.lamda;

    W = new double*[n_labels];
    for(int i=0; i<n_labels; i++)
        W[i] = new double[n_features];
    b = new double[n_labels];

    for(int i=0; i<n_labels; i++)
    {
        for(int j=0; j<n_features; j++)
            W[i][j] = 0;
        b[i] = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl (%rsi), %ecx
movl %ecx, (%rax)
movl 0x4(%rsi), %ecx
movl %ecx, 0x4(%rax)
movl 0xa4(%rdx), %ecx
movl %ecx, 0x8(%rax)
movsd 0xa8(%rdx), %xmm0
movsd %xmm0, 0x10(%rax)
movslq 0x8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x6636
movq -0x30(%rbp), %rax
movslq 0x4(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x65e3
movq -0x30(%rbp), %rax
movslq 0x8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x66d6
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x66b7
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6684
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x20(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6671
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: lipiji[P]PG_DEEP/deep.cpp
// Function: LR::LR(int, int, int, double)
LR::LR(int N, int n_f, int n_lb, double lbd)
{
    n_samples = N;
    n_features = n_f;
    n_labels = n_lb;
    lamda = lbd;

    W = new double*[n_labels];
    for(int i=0; i<n_labels; i++)
        W[i] = new double[n_features];
    b = new double[n_labels];

    for(int i=0; i<n_labels; i++)
    {
        for(int j=0; j<n_features; j++)
            W[i][j] = 0;
        b[i] = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x8(%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x10(%rax)
movslq 0x8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x0, -0x24(%rbp)
movq -0x38(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x67a7
movq -0x38(%rbp), %rax
movslq 0x4(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rdx
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6754
movq -0x38(%rbp), %rax
movslq 0x8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x0, -0x28(%rbp)
movq -0x38(%rbp), %rcx
movl -0x28(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x6847
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x6828
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x67f5
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x28(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x67e2
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: lipiji[P]PG_DEEP/deep.cpp
// Function: LR::~LR()
LR::~LR()
{
    for(int i=0; i<n_labels; i++)
        delete[] W[i];
    delete[] W;
    delete[] b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x68a7
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x689a
movq -0x20(%rbp), %rdi
callq 0x22e0
jmp 0x689c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x686b
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x68c2
movq -0x28(%rbp), %rdi
callq 0x22e0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x68dd
movq -0x30(%rbp), %rdi
callq 0x22e0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lipiji[P]PG_DEEP/deep.cpp
// Function: LR::softmax(double*)
void LR::softmax(double *x)
{
    double sum = 0.0;
    for(int i=0; i<n_labels; i++) 
    {
        x[i] = exp(x[i]);
        sum += x[i];
    } 

    for(int i=0; i<n_labels; i++) 
        x[i] /= sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x6c14
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x23c0
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6bc7
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x6c4d
movsd -0x18(%rbp), %xmm1
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6c1b
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lipiji[P]PG_DEEP/deep.cpp
// Function: LR::predict(double*, double*)
void LR::predict(double *x, double *y)
{
    for(int i=0; i<n_labels; i++) 
    {
        y[i] = 0;
        for(int j=0; j<n_features; j++) 
        {
            y[i] += W[i][j] * x[j];
        }
        y[i] += b[i];
    }
    softmax(y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x6d32
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x6d01
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6caa
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6c83
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6ba0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lipiji[P]PG_DEEP/deep.cpp
// Function: DBN::~DBN()
DBN::~DBN()
{
    for(int i=0; i<n_layers; i++)
        delete rbm_layers[i];
    delete[] rbm_layers;
    delete lr_layer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x8e55
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x8e48
movq -0x20(%rbp), %rdi
callq 0x64c0
movq -0x20(%rbp), %rdi
movl $0x40, %esi
callq 0x2230
jmp 0x8e4a
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8e0b
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x8e70
movq -0x28(%rbp), %rdi
callq 0x22e0
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x8e99
movq -0x30(%rbp), %rdi
callq 0x6850
movq -0x30(%rbp), %rdi
movl $0x28, %esi
callq 0x2230
addq $0x30, %rsp
popq %rbp
retq
nop
// File: jacky860226[P]JinkelaSat/src/main.cpp
// Function: adapteInput(MiniSat::JinkelaSat&, DIMACS::CNF::Input const&)
void adapteInput(MiniSat::JinkelaSat &Solver, const DIMACS::CNF::Input &Input) {
  for (auto &ClauseRaw : Input.getClauses()) {
    std::vector<MiniSat::Literal> Clause;
    for (int RawLit : ClauseRaw) {
      Clause.emplace_back(std::abs(RawLit) - 1, RawLit < 0);
    }
    Solver.addClause(std::move(Clause));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x27c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x27e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2810
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2840
testb $0x1, %al
jne 0x24c0
jmp 0x258e
leaq -0x20(%rbp), %rdi
callq 0x2880
movq %rax, -0x30(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x28a0
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x28c0
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x28f0
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2920
testb $0x1, %al
jne 0x250b
jmp 0x2568
leaq -0x58(%rbp), %rdi
callq 0x2960
movl (%rax), %eax
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
decl %eax
movl %eax, -0x68(%rbp)
movl -0x64(%rbp), %eax
shrl $0x1f, %eax
movb %al, -0x69(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x69(%rbp), %rdx
callq 0x2980
jmp 0x2544
jmp 0x2546
leaq -0x58(%rbp), %rdi
callq 0x2a00
jmp 0x24f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2db0
jmp 0x2597
movq -0x8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2a20
jmp 0x2577
leaq -0x48(%rbp), %rdi
callq 0x2db0
leaq -0x20(%rbp), %rdi
callq 0x2e10
jmp 0x24aa
addq $0x80, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x22f0
// File: jacky860226[P]JinkelaSat/src/main.cpp
// Function: to_ostream(MiniSat::JinkelaSat&, MiniSat::Status, std::ostream&)
void to_ostream(MiniSat::JinkelaSat &Solver, const MiniSat::Status Result,
                std::ostream &Out) {
  if (Result == MiniSat::Status::True) {
    Out << "SAT\n";
    size_t VarCnt = 1;
    for (auto VarStatus : Solver.getModel()) {
      Out << (VarStatus == MiniSat::Status::False ? "-" : "") << VarCnt++
          << ' ';
    }
    Out << "0\n";
  } else {
    Out << "UNSAT\n";
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x1, %eax
jne 0x2686
movq -0x18(%rbp), %rdi
leaq 0x19acd(%rip), %rsi     # 0x1c09b
callq 0x21b0
movq $0x1, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2e30
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2e50
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2e80
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2eb0
testb $0x1, %al
jne 0x2615
jmp 0x2674
leaq -0x30(%rbp), %rdi
callq 0x2ef0
movb (%rax), %al
movb %al, -0x39(%rbp)
movq -0x18(%rbp), %rdi
movsbl -0x39(%rbp), %ecx
leaq 0x19a66(%rip), %rsi     # 0x1c098
leaq 0x19a5b(%rip), %rax     # 0x1c094
cmpl $0x0, %ecx
cmoveq %rax, %rsi
callq 0x21b0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
callq 0x2060
movq %rax, %rdi
movl $0x20, %esi
callq 0x2210
leaq -0x30(%rbp), %rdi
callq 0x2f10
jmp 0x2602
movq -0x18(%rbp), %rdi
leaq 0x19a17(%rip), %rsi     # 0x1c096
callq 0x21b0
jmp 0x2696
movq -0x18(%rbp), %rdi
leaq 0x19a08(%rip), %rsi     # 0x1c099
callq 0x21b0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: jacky860226[P]JinkelaSat/src/main.cpp
// Function: main
int main() {
  DIMACS::CNF::Parser Parser;
  auto Input = std::move(Parser.parse(std::cin));

  MiniSat::JinkelaSat Solver;
  adapteInput(Solver, Input);

  auto Result = Solver.solve();
  to_ostream(Solver, Result, std::cout);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movl $0x0, -0x4(%rbp)
movq 0x28927(%rip), %rdx     # 0x2afe0
leaq -0x48(%rbp), %rdi
movq %rdi, -0x278(%rbp)
leaq -0x5(%rbp), %rsi
callq 0x2f30
movq -0x278(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x3260
jmp 0x26df
leaq -0x48(%rbp), %rdi
callq 0x32a0
leaq -0x268(%rbp), %rdi
callq 0x32c0
jmp 0x26f6
leaq -0x268(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2470
jmp 0x2708
leaq -0x268(%rbp), %rdi
callq 0x3470
movb %al, -0x279(%rbp)
jmp 0x271c
movb -0x279(%rbp), %al
movb %al, -0x269(%rbp)
movsbl -0x269(%rbp), %esi
movq 0x2889a(%rip), %rdx     # 0x2afd0
leaq -0x268(%rbp), %rdi
callq 0x25a0
jmp 0x2744
movl $0x0, -0x4(%rbp)
leaq -0x268(%rbp), %rdi
callq 0x35c0
leaq -0x28(%rbp), %rdi
callq 0x32a0
movl -0x4(%rbp), %eax
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x32a0
jmp 0x27b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x27a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x268(%rbp), %rdi
callq 0x35c0
leaq -0x28(%rbp), %rdi
callq 0x32a0
movq -0x50(%rbp), %rdi
callq 0x22f0
nopl (%rax,%rax)
// File: jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::solve()
Status solve() {
    if (!ok)
      return Status::False;
    max_learnts = nClauses() * learntsize_factor;
    learntsize_adjust_confl = learntsize_adjust_start_confl;
    learntsize_adjust_cnt = learntsize_adjust_start_confl;
    Status status = Status::Undef;
    int curr_restarts = 0;
    do {
      double rest_base = luby(restart_inc, curr_restarts);
      status = search(rest_base * restart_first);
      ++curr_restarts;
    } while (status == Status::Undef);
    model = assigns;
    cancelUntil(0);
    return status;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x208(%rax)
jne 0x3496
movb $0x0, -0x1(%rbp)
jmp 0x35b5
movq -0x28(%rbp), %rdi
callq 0x13020
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, %xmm0
movaps 0x18bae(%rip), %xmm2    # 0x1c060
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0x18bb2(%rip), %xmm1    # 0x1c070
subpd %xmm1, %xmm0
movaps %xmm0, %xmm3
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm3, %xmm0
movsd 0x170(%rax), %xmm3
mulsd %xmm3, %xmm0
movsd %xmm0, 0x1c0(%rax)
movq 0x188(%rax), %xmm0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, 0x1c8(%rax)
movq 0x188(%rax), %rcx
movq %rcx, 0x1d0(%rax)
movb $0x2, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rax
movsd 0x178(%rax), %xmm0
movl -0x18(%rbp), %edi
callq 0x13040
movq -0x28(%rbp), %rdi
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movq 0x180(%rdi), %xmm1
movaps 0x18b12(%rip), %xmm2    # 0x1c060
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x18b16(%rip), %xmm2    # 0x1c070
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %esi
callq 0x130d0
movb %al, -0x11(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x2, %eax
je 0x351d
movq -0x28(%rbp), %rdi
movq %rdi, %rsi
addq $0x68, %rsi
addq $0x158, %rdi            # imm = 0x158
callq 0x13400
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x13630
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::newVar()
int newVar() {
    int v = next_var++;
    assigns.emplace_back(Status::Undef);
    vardata.emplace_back(nullptr, 0);
    activity.emplace_back(0);
    seen.emplace_back(0);
    polarity.emplace_back(true);
    insertVarOrder(v);
    return v;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq 0x1e8(%rdi), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x1e8(%rdi)
movl %eax, -0xc(%rbp)
addq $0x68, %rdi
movb $0x2, -0xd(%rbp)
leaq -0xd(%rbp), %rsi
callq 0x4440
movq -0x40(%rbp), %rdi
addq $0x80, %rdi
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
leaq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x44c0
movq -0x40(%rbp), %rdi
addq $0x98, %rdi
movl $0x0, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x4540
movq -0x40(%rbp), %rdi
addq $0xd8, %rdi
movl $0x0, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x45c0
movq -0x40(%rbp), %rdi
addq $0xb0, %rdi
movb $0x1, -0x25(%rbp)
leaq -0x25(%rbp), %rsi
callq 0x4640
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movl -0xc(%rbp), %esi
callq 0x4690
movl -0xc(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::attachClause(MiniSat::Clause*)
void attachClause(Clause *cr) {
    const Clause &c = *cr;
    watches[~c[0]].emplace_back(cr, c[1]);
    watches[~c[1]].emplace_back(cr, c[0]);
    if (c.learnt())
      learnts_literals += c.size();
    else
      num_clauses++, clauses_literals += c.size();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
addq $0x120, %rax            # imm = 0x120
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xf630
movq %rax, %rdi
callq 0x39f0
movl %eax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x39e0
movq -0x50(%rbp), %rdi
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0xc180
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0xf630
movq -0x48(%rbp), %rdi
movq %rax, %rdx
leaq -0x10(%rbp), %rsi
callq 0xf650
movq -0x40(%rbp), %rax
addq $0x120, %rax            # imm = 0x120
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0xf630
movq %rax, %rdi
callq 0x39f0
movl %eax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x39e0
movq -0x38(%rbp), %rdi
movl %eax, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0xc180
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xf630
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq -0x10(%rbp), %rsi
callq 0xf650
movq -0x18(%rbp), %rdi
callq 0xf6d0
testb $0x1, %al
jne 0x433d
jmp 0x435d
movq -0x18(%rbp), %rdi
callq 0x3b30
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq 0x200(%rax), %rcx
movq %rcx, 0x200(%rax)
jmp 0x4391
movq -0x40(%rbp), %rax
movq 0x1f0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x1f0(%rax)
movq -0x18(%rbp), %rdi
callq 0x3b30
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq 0x1f8(%rax), %rcx
movq %rcx, 0x1f8(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::luby(double, int)
inline double luby(double y, int x) {
  int size, seq;
  for (size = 1, seq = 0; size < x + 1; seq++, size = 2 * size + 1)
    ;
  while (size - 1 != x) {
    size = (size - 1) >> 1;
    seq--;
    x = x % size;
  }
  return pow(y, seq);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x13083
jmp 0x1306d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
shll %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1305e
jmp 0x13085
movl -0x10(%rbp), %eax
subl $0x1, %eax
cmpl -0xc(%rbp), %eax
je 0x130b0
movl -0x10(%rbp), %eax
subl $0x1, %eax
sarl %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
cltd
idivl -0x10(%rbp)
movl %edx, -0xc(%rbp)
jmp 0x13085
movsd -0x8(%rbp), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
callq 0x22e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::cancelUntil(unsigned long)
void cancelUntil(size_t level) {
    if (decisionLevel() > level) {
      for (int c = int(trail.size()) - 1; c >= trail_lim[level]; c--) {
        int x = trail[c].var();
        assigns[x] = Status::Undef;
        polarity[x] = trail[c].sign();
        insertVarOrder(x);
      }
      qhead = trail_lim[level];
      trail.resize(trail_lim[level]);
      trail_lim.resize(level);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xbe90
cmpq -0x10(%rbp), %rax
jbe 0x13776
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x3b30
subl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
callq 0x1a930
movq %rax, %rcx
movl -0x34(%rbp), %eax
cmpl (%rcx), %eax
jl 0x13726
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x3a20
movq %rax, %rdi
callq 0x37d0
movq -0x30(%rbp), %rdi
movl %eax, -0x18(%rbp)
addq $0x68, %rdi
movslq -0x18(%rbp), %rsi
callq 0xbe70
movq -0x30(%rbp), %rdi
movb $0x2, (%rax)
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x3a20
movq %rax, %rdi
callq 0xa9f0
movq -0x30(%rbp), %rdi
movb %al, -0x35(%rbp)
addq $0xb0, %rdi
movslq -0x18(%rbp), %rsi
callq 0x19d20
movq %rax, %rcx
movb -0x35(%rbp), %al
movq %rcx, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movzbl %al, %esi
andl $0x1, %esi
leaq -0x28(%rbp), %rdi
callq 0x6c30
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x4690
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1366a
movq -0x30(%rbp), %rdi
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
callq 0x1a930
movq -0x30(%rbp), %rdi
movslq (%rax), %rax
movq %rax, (%rdi)
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
callq 0x1a930
movq -0x40(%rbp), %rdi
movslq (%rax), %rsi
callq 0x3a40
movq -0x30(%rbp), %rdi
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
callq 0x1a950
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::claBumpActivity(MiniSat::Clause&)
void claBumpActivity(Clause &c) {
    if ((c.activity() += cla_inc) > 1e20) {
      for (auto &l : learnts)
        l->activity() *= 1e-20;
      cla_inc *= 1e-20;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movsd 0x1b0(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16ea0
movsd -0x38(%rbp), %xmm1
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rax)
cvtss2sd %xmm0, %xmm0
movsd 0x824d(%rip), %xmm1     # 0x1c040
ucomisd %xmm1, %xmm0
jbe 0x13e97
movq -0x40(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xed60
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xea00
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x16ec0
testb $0x1, %al
jne 0x13e36
jmp 0x13e7b
leaq -0x20(%rbp), %rdi
callq 0xfa00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x16f00
movq %rax, %rdi
callq 0x16ea0
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x81e4(%rip), %xmm1     # 0x1c048
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rax)
leaq -0x20(%rbp), %rdi
callq 0x16f20
jmp 0x13e23
movq -0x40(%rbp), %rax
movsd 0x81c1(%rip), %xmm0     # 0x1c048
mulsd 0x1b0(%rax), %xmm0
movsd %xmm0, 0x1b0(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::simplify()
bool simplify() {
    if (propagate() != nullptr)
      return false;
    if (int(nAssigns()) == simpDB_assigns || (simpDB_props > 0))
      return true;
    removeSatisfied(learnts);
    rebuildOrderHeap();
    simpDB_assigns = nAssigns();
    simpDB_props = clauses_literals + learnts_literals;
    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x3c10
cmpq $0x0, %rax
je 0x13f25
movb $0x0, -0x1(%rbp)
jmp 0x13f96
movq -0x18(%rbp), %rdi
callq 0x13fb0
movq -0x18(%rbp), %rcx
cmpl 0x1d8(%rcx), %eax
je 0x13f48
movq -0x18(%rbp), %rax
cmpq $0x0, 0x1e0(%rax)
jle 0x13f4e
movb $0x1, -0x1(%rbp)
jmp 0x13f96
movq -0x18(%rbp), %rdi
movq %rdi, %rsi
addq $0x38, %rsi
callq 0x16f40
movq -0x18(%rbp), %rdi
callq 0x14db0
movq -0x18(%rbp), %rdi
callq 0x13fb0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movl %ecx, 0x1d8(%rax)
movq 0x1f8(%rax), %rcx
addq 0x200(%rax), %rcx
movq %rcx, 0x1e0(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::reduceDB()
void reduceDB() {
    size_t j = 0;
    double extra_lim = cla_inc / learnts.size();
    std::sort(learnts.begin(), learnts.end(), reduceDB_cmp);
    for (size_t i = 0; i < learnts.size(); i++) {
      auto &c = learnts[i];
      if (c->size() > 2 && !locked(c.get()) &&
          (i < learnts.size() / 2 || c->activity() < extra_lim)) {
        removeClause(c);
      } else
        learnts[j++] = std::move(c);
    }
    learnts.resize(j);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq $0x0, -0x10(%rbp)
movsd 0x1b0(%rdi), %xmm0
movsd %xmm0, -0x48(%rbp)
addq $0x38, %rdi
callq 0xeeb0
movsd -0x48(%rbp), %xmm0
movq -0x40(%rbp), %rdi
movq %rax, %xmm1
movaps 0x8049(%rip), %xmm2     # 0x1c060
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x804d(%rip), %xmm2     # 0x1c070
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
addq $0x38, %rdi
callq 0xed60
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x38, %rdi
callq 0xea00
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq 0x44c8(%rip), %rdx      # 0x18530
callq 0x184e0
movq $0x0, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x38, %rdi
callq 0xeeb0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x14179
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
movq -0x30(%rbp), %rsi
callq 0x172c0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x16f00
movq %rax, %rdi
callq 0x3b30
cmpq $0x2, %rax
jbe 0x14136
movq -0x38(%rbp), %rdi
callq 0x43e0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x174d0
testb $0x1, %al
jne 0x14136
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x38, %rdi
callq 0xeeb0
movq %rax, %rcx
movq -0x58(%rbp), %rax
shrq %rcx
cmpq %rcx, %rax
jb 0x14127
movq -0x38(%rbp), %rdi
callq 0x16f00
movq %rax, %rdi
callq 0x16ea0
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x14136
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x171c0
jmp 0x14166
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
callq 0x172c0
movq -0x60(%rbp), %rsi
movq %rax, %rdi
callq 0x172e0
jmp 0x14168
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x14075
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
callq 0x17310
addq $0x60, %rsp
popq %rbp
retq
// File: jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::pickBranchLit()
Literal pickBranchLit() {
    const int VarUndef = -1;
    int next = VarUndef;
    while (next == VarUndef || value(next) != Status::Undef)
      if (order_heap.empty()) {
        next = VarUndef;
        break;
      } else {
        next = (*--order_heap.end()).second;
        order_heap.erase(--order_heap.end());
      }
    if (next == VarUndef)
      return Literal();
    return Literal(next, polarity[next]);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movb $0x1, %al
cmpl $-0x1, -0x18(%rbp)
movb %al, -0x51(%rbp)
je 0x141d5
movq -0x50(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xa9c0
movsbl %al, %eax
cmpl $0x2, %eax
setne %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x141e1
jmp 0x14272
movq -0x50(%rbp), %rdi
addq $0xf0, %rdi
callq 0x19c40
testb $0x1, %al
jne 0x141f7
jmp 0x14200
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
jmp 0x14272
movq -0x50(%rbp), %rdi
addq $0xf0, %rdi
callq 0x19c60
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x19c90
movq %rax, %rdi
callq 0x19cc0
movq -0x50(%rbp), %rdi
movl 0x8(%rax), %eax
movl %eax, -0x18(%rbp)
movq %rdi, %rax
addq $0xf0, %rax
movq %rax, -0x60(%rbp)
addq $0xf0, %rdi
callq 0x19c60
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x19c90
movq -0x60(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x19ce0
movq %rax, -0x38(%rbp)
jmp 0x141b2
cmpl $-0x1, -0x18(%rbp)
jne 0x14283
leaq -0x4(%rbp), %rdi
callq 0x3940
jmp 0x142c0
movq -0x50(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x64(%rbp)
addq $0xb0, %rdi
movslq -0x18(%rbp), %rsi
callq 0x19d20
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x7a30
movl -0x64(%rbp), %esi
movzbl %al, %edx
andl $0x1, %edx
leaq -0x4(%rbp), %rdi
callq 0x19d80
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::varBumpActivity(int)
void varBumpActivity(int v) {
    auto ori = activity[v];
    if ((activity[v] += var_inc) > 1e100) {
      for (auto &act : activity)
        act *= 1e-100;
      var_inc *= 1e-100;
      rebuildOrderHeap();
    } else {
      if (order_heap.count({ori, v})) {
        order_heap.erase({ori, v});
        order_heap.emplace(activity[v], v);
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
addq $0x98, %rdi
movslq -0xc(%rbp), %rsi
callq 0x8900
movq -0x78(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x1b8(%rdi), %xmm0
movsd %xmm0, -0x70(%rbp)
addq $0x98, %rdi
movslq -0xc(%rbp), %rsi
callq 0x8900
movsd -0x70(%rbp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movsd 0x7bf7(%rip), %xmm1     # 0x1c050
ucomisd %xmm1, %xmm0
jbe 0x144f0
movq -0x78(%rbp), %rax
addq $0x98, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5db0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5bf0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x14d50
testb $0x1, %al
jne 0x1449e
jmp 0x144ca
leaq -0x28(%rbp), %rdi
callq 0x6230
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movsd 0x7ba1(%rip), %xmm0     # 0x1c058
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
leaq -0x28(%rbp), %rdi
callq 0x14d90
jmp 0x1448b
movq -0x78(%rbp), %rdi
movsd 0x7b82(%rip), %xmm0     # 0x1c058
mulsd 0x1b8(%rdi), %xmm0
movsd %xmm0, 0x1b8(%rdi)
callq 0x14db0
jmp 0x14594
movq -0x78(%rbp), %rax
addq $0xf0, %rax
movq %rax, -0x80(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0xc(%rbp), %rdx
callq 0x8920
movq -0x80(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x88a0
cmpq $0x0, %rax
je 0x14592
movq -0x78(%rbp), %rax
addq $0xf0, %rax
movq %rax, -0x90(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0xc(%rbp), %rdx
callq 0x8920
movq -0x90(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x14e60
movq -0x78(%rbp), %rdi
movq %rdi, %rax
addq $0xf0, %rax
movq %rax, -0x88(%rbp)
addq $0x98, %rdi
movslq -0xc(%rbp), %rsi
callq 0x8900
movq -0x88(%rbp), %rdi
movq %rax, %rsi
leaq -0xc(%rbp), %rdx
callq 0x8950
movq %rax, -0x68(%rbp)
movb %dl, -0x60(%rbp)
jmp 0x14594
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::rebuildOrderHeap()
void rebuildOrderHeap() {
    order_heap.clear();
    for (size_t v = 0; v < nVars(); ++v)
      if (value(v) == Status::Undef)
        order_heap.emplace(activity[v], v);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0xf0, %rdi
callq 0x14e90
movq $0x0, -0x10(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x37f0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x14e54
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movl %eax, %esi
callq 0xa9c0
movsbl %al, %eax
cmpl $0x2, %eax
jne 0x14e44
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0xf0, %rax
movq %rax, -0x38(%rbp)
addq $0x98, %rdi
movq -0x10(%rbp), %rsi
callq 0x8900
movq -0x38(%rbp), %rdi
movq %rax, %rsi
leaq -0x10(%rbp), %rdx
callq 0x14eb0
movq %rax, -0x20(%rbp)
movb %dl, -0x18(%rbp)
jmp 0x14e46
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x14dd8
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::removeSatisfied(std::vector<std::unique_ptr<MiniSat::Clause, std::default_delete<MiniSat::Clause>>, std::allocator<std::unique_ptr<MiniSat::Clause, std::default_delete<MiniSat::Clause>>>>&)
void removeSatisfied(std::vector<Clause::Ptr> &cs) {
    size_t j = 0;
    for (auto &c : cs) {
      if (satisfied(*c))
        removeClause(c);
      else {
        for (size_t k = 2; k < c->size(); ++k)
          if (value(c->at(k)) == Status::False) {
            c->at(k--) = c->back();
            c->pop_back();
          }
        cs[j++] = std::move(c);
      }
    }
    cs.resize(j);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xed60
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xea00
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x16ec0
testb $0x1, %al
jne 0x16f98
jmp 0x170ce
leaq -0x28(%rbp), %rdi
callq 0xfa00
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x17190
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x170f0
testb $0x1, %al
jne 0x16fc0
jmp 0x16fd2
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x171c0
jmp 0x170be
movq $0x2, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rdi
callq 0x16f00
movq %rax, %rdi
callq 0x3b30
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x17092
movq -0x38(%rbp), %rdi
callq 0x16f00
movq %rax, %rdi
movq -0x40(%rbp), %rsi
callq 0x17250
movq -0x50(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %esi
callq 0x3960
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x1707f
movq -0x38(%rbp), %rdi
callq 0x16f00
movq %rax, %rdi
callq 0xc120
movq %rax, -0x60(%rbp)
movq -0x38(%rbp), %rdi
callq 0x16f00
movq %rax, %rdi
movq -0x40(%rbp), %rsi
movq %rsi, %rax
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
callq 0x17250
movq -0x60(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x38(%rbp), %rdi
callq 0x16f00
movq %rax, %rdi
callq 0x17290
jmp 0x17081
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x16fda
movq -0x38(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
callq 0x172c0
movq -0x68(%rbp), %rsi
movq %rax, %rdi
callq 0x172e0
jmp 0x170c0
leaq -0x28(%rbp), %rdi
callq 0x16f20
jmp 0x16f82
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x17310
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::satisfied(MiniSat::Clause const&) const
bool satisfied(const Clause &c) const {
    for (auto l : c)
      if (value(l) == Status::True)
        return true;
    return false;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xbde0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xbe10
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x15a30
testb $0x1, %al
jne 0x1713d
jmp 0x17178
leaq -0x28(%rbp), %rdi
callq 0x15a90
movq -0x40(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %esi
callq 0x3960
movsbl %al, %eax
cmpl $0x1, %eax
jne 0x1716b
movb $0x1, -0x1(%rbp)
jmp 0x1717c
jmp 0x1716d
leaq -0x28(%rbp), %rdi
callq 0x15ab0
jmp 0x1712a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::removeClause(std::unique_ptr<MiniSat::Clause, std::default_delete<MiniSat::Clause>>&)
void removeClause(Clause::Ptr &cr) {
    Clause &c = *cr;
    detachClause(&c);
    if (locked(&c))
      vardata[c[0].var()].reason = nullptr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x17190
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x173a0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x174d0
testb $0x1, %al
jne 0x17205
jmp 0x1723b
movq -0x20(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3a20
movq %rax, %rdi
callq 0x37d0
movq -0x28(%rbp), %rdi
movslq %eax, %rsi
callq 0xbeb0
movq $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: jacky860226[P]JinkelaSat/src/include/JinkelaSat.hpp
// Function: MiniSat::JinkelaSat::detachClause(MiniSat::Clause*)
void detachClause(Clause *cr) {
    const Clause &c = *cr;
    watcheErase(watches[~c[0]], cr);
    watcheErase(watches[~c[1]], cr);
    if (c.learnt())
      learnts_literals -= c.size();
    else
      num_clauses++, clauses_literals -= c.size();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
addq $0x120, %rax            # imm = 0x120
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xf630
movq %rax, %rdi
callq 0x39f0
movl %eax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x39e0
movq -0x40(%rbp), %rdi
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0xc180
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0x17580
movq -0x30(%rbp), %rax
addq $0x120, %rax            # imm = 0x120
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0xf630
movq %rax, %rdi
callq 0x39f0
movl %eax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x39e0
movq -0x38(%rbp), %rdi
movl %eax, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0xc180
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0x17580
movq -0x18(%rbp), %rdi
callq 0xf6d0
testb $0x1, %al
jne 0x1746a
jmp 0x1748d
movq -0x18(%rbp), %rdi
callq 0x3b30
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq 0x200(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x200(%rax)
jmp 0x174c4
movq -0x30(%rbp), %rax
movq 0x1f0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x1f0(%rax)
movq -0x18(%rbp), %rdi
callq 0x3b30
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq 0x1f8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x1f8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)