LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/archit-p[P]bulletproofs-demo/src/num_theory.cpp
// Function: large_mod(int, int, int)
int large_mod(int a, int b, int p)
{
    int q = 1;
    while(b > 0) {
        if(b%2 == 1) {
            q *= a;
            q = q%p;
        }
        b /= 2;
        a = (a*a)%p;
    }
    return q;
}

// Assembly:
movl %edx, %ecx
movl %edi, %r8d
pushq $0x1
popq %rdi
testl %esi, %esi
jle 0x13d7
testb $0x1, %sil
je 0x13c5
imull %r8d, %edi
movl %edi, %eax
cltd
idivl %ecx
movl %edx, %edi
shrl %esi
imull %r8d, %r8d
movl %r8d, %eax
xorl %edx, %edx
idivl %ecx
movl %edx, %r8d
jmp 0x13b0
movl %edi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/archit-p[P]bulletproofs-demo/src/num_theory.cpp
// Function: haderson_product(std::vector<int, std::allocator<int>>, std::vector<int, std::allocator<int>>)
vector <int> haderson_product(vector <int> a, vector <int> b)
{
    vector <int> c;
    vector <int> :: iterator i = a.begin();
    vector <int> :: iterator j = b.begin();

    for(; i!= a.end(), j != b.end(); i++, j++)
        c.push_back((*i)*(*j));
    return c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq (%rsi), %r12
movq (%rdx), %r13
leaq 0xc(%rsp), %r15
cmpq 0x8(%r14), %r13
je 0x142b
movl (%r13), %eax
imull (%r12), %eax
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1602
addq $0x4, %r12
addq $0x4, %r13
jmp 0x1403
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x15ce
movq %r14, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O2/archit-p[P]bulletproofs-demo/src/num_theory.cpp
// Function: vector_power(std::vector<int, std::allocator<int>>, std::vector<int, std::allocator<int>>)
int vector_power(vector <int> a, vector <int> b)
{
    vector <int> :: iterator i;
    vector <int> :: iterator j;

    int power = 1;
    int vali;
    int valj;

    //assert (a.size() == b.size());
    for(i = a.begin(), j = b.begin(); i != a.end(), j != b.end(); i++, j++) {
        vali = *i;
        valj = *j;
        power *= pow(vali, valj);
    }
    return power;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %r14
movq (%rsi), %r15
pushq $0x1
popq %rbp
cmpq 0x8(%rbx), %r15
je 0x14ea
cvtsi2sdl (%r14), %xmm0
cvtsi2sdl (%r15), %xmm1
callq 0x1150
cvtsi2sd %ebp, %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %ebp
addq $0x4, %r14
addq $0x4, %r15
jmp 0x14bf
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/archit-p[P]bulletproofs-demo/src/num_theory.cpp
// Function: vector_power(std::vector<int, std::allocator<int>>, std::vector<int, std::allocator<int>>, int)
int vector_power(vector <int> a, vector <int> b, int order)
{
    vector <int> :: iterator i;
    vector <int> :: iterator j;

    int power = 1;
    int vali;
    int valj;

    //assert (a.size() == b.size());
    for(i = a.begin(), j = b.begin(); i != a.end(), j != b.end(); i++, j++) {
        vali = *i;
        valj = *j;
        power *= (int(pow(vali, valj))%order);
    }
    return power;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq (%rdi), %r15
movq (%rsi), %r12
pushq $0x1
popq %rbp
cmpq 0x8(%r14), %r12
je 0x1537
cvtsi2sdl (%r15), %xmm0
cvtsi2sdl (%r12), %xmm1
callq 0x1150
cvttsd2si %xmm0, %eax
cltd
idivl %ebx
imull %edx, %ebp
addq $0x4, %r15
addq $0x4, %r12
jmp 0x150d
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/archit-p[P]bulletproofs-demo/src/num_theory.cpp
// Function: vector_polynomial_product(std::vector<int, std::allocator<int>>, std::vector<int, std::allocator<int>>)
int modInverse(int a, int m)
{
    int m0 = m;
    int y = 0, x = 1;
    if (m == 1)
      return 0;
    while (a > 1)
    {
        int q = a / m;
        int temp = m;
        m = a % m, a = temp;
        temp = y;
        y = x - q * y;
        x = temp;
    }
    if (x < 0)
       x += m0;
    return x;
}

// Assembly:
xorl %ecx, %ecx
cmpl $0x1, %esi
je 0x1579
movl %edi, %eax
pushq $0x1
popq %rdi
xorl %r9d, %r9d
movl %esi, %edx
cmpl $0x2, %eax
jl 0x1570
movl %r9d, %r8d
movl %edx, %ecx
cltd
idivl %ecx
imull %r9d, %eax
subl %eax, %edi
movl %edi, %r9d
movl %r8d, %edi
movl %ecx, %eax
jmp 0x1553
movl %edi, %ecx
sarl $0x1f, %ecx
andl %esi, %ecx
addl %edi, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/archit-p[P]bulletproofs-demo/src/vector_util.cpp
// Function: get_half(std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&)
void get_half(vector <int>& a, vector <int>& b, vector <int>& c)
{
    //function clears the values in b and c
    b.clear();
    c.clear();
    vector <int> :: iterator i;
    int l, vali;

    for(i = a.begin(), l = 0; l < a.size(); l++, i++) {
        vali = *i;
        if(l < a.size()/2)
            b.push_back(vali);
        else
            c.push_back(vali);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x1799
movq %rax, 0x8(%r14)
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x17a6
movq %rax, 0x8(%rbx)
movq (%r15), %r13
xorl %ebp, %ebp
leaq 0x4(%rsp), %r12
movq %r13, %rcx
movq 0x8(%r15), %rax
subq %rcx, %rax
sarq $0x2, %rax
cmpq %rbp, %rax
jbe 0x17ea
movl (%r13,%rbp,4), %ecx
movl %ecx, 0x4(%rsp)
shrq %rax
movq %r14, %rdi
cmpq %rbp, %rax
ja 0x17da
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1c16
incq %rbp
movq (%r15), %rcx
jmp 0x17b3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/archit-p[P]bulletproofs-demo/src/vector_util.cpp
// Function: pprint_vector(std::vector<int, std::allocator<int>>)
void pprint_vector(vector <int> a)
{
    typename vector <int> :: iterator i;
    cout << "----------" << endl;
    for(i = a.begin(); i != a.end(); i++)
        cout << *i << " ";
    cout << endl << "----------" << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x57cd(%rip), %r14      # 0x6fd8
leaq 0x280c(%rip), %rsi      # 0x401e
movq %r14, %rdi
callq 0x10e0
movq %rax, %rdi
callq 0x1070
movq (%rbx), %r12
leaq 0x27fd(%rip), %r15      # 0x4029
cmpq 0x8(%rbx), %r12
je 0x184f
movl (%r12), %esi
movq %r14, %rdi
callq 0x1140
movq %rax, %rdi
movq %r15, %rsi
callq 0x10e0
addq $0x4, %r12
jmp 0x182c
movq 0x5782(%rip), %rdi      # 0x6fd8
callq 0x1070
leaq 0x27bc(%rip), %rsi      # 0x401e
movq %rax, %rdi
callq 0x10e0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1070
// File: /workspace/github_cpp_makefile_star2_O2/archit-p[P]bulletproofs-demo/src/vector_util.cpp
// Function: get_k_vector(int, int)
vector <int> get_k_vector(int k, int n)
{
    vector <int> ret;
    for(int i = n-1; i >= 0; i--)
        ret.push_back(pow(k, i));
    return ret;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
cvtsi2sd %esi, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x4(%rsp), %r14
testl %ebp, %ebp
jle 0x18ce
decl %ebp
cvtsi2sd %ebp, %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x1150
cvttsd2si %xmm0, %eax
movl %eax, 0x4(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1602
jmp 0x18a4
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x15ce
movq %r14, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O2/archit-p[P]bulletproofs-demo/src/vector_util.cpp
// Function: get_bit_vector(long)
vector <int> get_bit_vector(long v)
{
    vector <int> ret;
    int bit;
    while(v > 0) {
        bit = v&1;
        ret.push_back(bit);
        v >>= 1;
    }
    reverse(ret.begin(), ret.end());
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0xc(%rsp), %r15
testq %r14, %r14
jle 0x192b
movl %r14d, %eax
andl $0x1, %eax
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1c16
shrq %r14
jmp 0x190c
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x1cf6
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1946
movq %rax, %r14
movq %rbx, %rdi
callq 0x15ce
movq %r14, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O2/archit-p[P]bulletproofs-demo/src/vector_util.cpp
// Function: k_product_vector(std::vector<int, std::allocator<int>>, int, int)
vector <int> k_product_vector(vector <int> vec, int k, int order)
{
    for(int i = 0; i < vec.size(); i++) {
        vec[i] *= k;
        vec[i] = vec[i]%order;
    }
    return vec;
}

// Assembly:
pushq %rbx
movl %edx, %r8d
movq (%rsi), %r10
movq 0x8(%rsi), %r9
movq %r9, %r11
subq %r10, %r11
sarq $0x2, %r11
xorl %ebx, %ebx
cmpq %rbx, %r11
je 0x19d1
movl (%r10,%rbx,4), %eax
imull %r8d, %eax
cltd
idivl %ecx
movl %edx, (%r10,%rbx,4)
incq %rbx
jmp 0x19b8
movq %r10, (%rdi)
movq %r9, 0x8(%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movq %rdi, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/archit-p[P]bulletproofs-demo/src/vector_util.cpp
// Function: vector_diff(std::vector<int, std::allocator<int>>, std::vector<int, std::allocator<int>>)
vector <int> vector_diff(vector <int> a, vector <int> b)
{
    vector <int> c;
    for(int i = 0; i < a.size(); i++) 
        c.push_back(a[i]-b[i]);
    return c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %r13d, %r13d
leaq 0xc(%rsp), %r12
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0x1a4b
movl (%rax,%r13,4), %eax
movq (%r14), %rcx
subl (%rcx,%r13,4), %eax
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1602
incq %r13
jmp 0x1a19
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x15ce
movq %r14, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O2/archit-p[P]bulletproofs-demo/src/vector_util.cpp
// Function: vector_sum(std::vector<int, std::allocator<int>>, std::vector<int, std::allocator<int>>)
vector <int> vector_sum(vector <int> a, vector <int> b)
{
    vector <int> c;
    for(int i = 0; i < a.size(); i++) 
        c.push_back(a[i]+b[i]);
    return c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %r13d, %r13d
leaq 0xc(%rsp), %r12
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0x1aca
movq (%r14), %rcx
movl (%rcx,%r13,4), %ecx
addl (%rax,%r13,4), %ecx
movl %ecx, 0xc(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1602
incq %r13
jmp 0x1a98
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x15ce
movq %r14, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O2/archit-p[P]bulletproofs-demo/src/vector_util.cpp
// Function: vector_sum(std::vector<int, std::allocator<int>>, std::vector<int, std::allocator<int>>, int)
vector <int> vector_sum(vector <int> a, vector <int> b, int order)
{
    vector <int> c;
    for(int i = 0; i < a.size(); i++) 
        c.push_back((a[i]+b[i])%order);
    return c;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %r13d, %r13d
leaq 0x4(%rsp), %r12
movq (%r15), %rcx
movq 0x8(%r15), %rax
subq %rcx, %rax
sarq $0x2, %rax
cmpq %r13, %rax
jbe 0x1b4c
movq (%r14), %rax
movl (%rax,%r13,4), %eax
addl (%rcx,%r13,4), %eax
cltd
idivl %ebp
movl %edx, 0x4(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1602
incq %r13
jmp 0x1b17
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x15ce
movq %r14, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O2/archit-p[P]bulletproofs-demo/src/vector_util.cpp
// Function: random_vector(int, int)
vector <int> random_vector(int len, int order)
{
    vector <int> ret;
    for(int i = 0; i < len; i++)
        ret.push_back(rand()%order);
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
xorl %r15d, %r15d
testl %esi, %esi
cmovgl %esi, %r15d
leaq 0x4(%rsp), %r14
subl $0x1, %r15d
jb 0x1bb5
callq 0x1030
cltd
idivl %ebp
movl %edx, 0x4(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1602
jmp 0x1b96
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x15ce
movq %r14, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O2/archit-p[P]bulletproofs-demo/src/main.cpp
// Function: build_gen_vector(Group*, int)
vector <int> build_gen_vector(Group *g, int len)
{
    vector <int> ret;
    for(int i = 0; i < len; i++)
        ret.push_back(g->get_gen());
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
xorl %ebp, %ebp
testl %edx, %edx
cmovgl %edx, %ebp
leaq 0x4(%rsp), %r15
subl $0x1, %ebp
jb 0x1d56
movq %r14, %rdi
callq 0x393e
movl %eax, 0x4(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1602
jmp 0x1d38
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x15ce
movq %r14, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O2/archit-p[P]bulletproofs-demo/src/main.cpp
// Function: main
int main()
{
    //initialize a random number generator for future use
    srand(unsigned(std::time(NULL))); 
    Group *g = new Group(383);
    Prover *p = new Prover(9, 383, build_gen_vector(g, 4));
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
xorl %edi, %edi
callq 0x10c0
movl %eax, %edi
callq 0x10d0
pushq $0x38
popq %rdi
callq 0x10f0
movq %rax, %r15
movq %rax, %rdi
movl $0x17f, %esi            # imm = 0x17F
callq 0x37f8
movl $0xd8, %edi
callq 0x10f0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
pushq $0x4
popq %rdx
movq %r15, %rsi
callq 0x1d14
pushq $0x9
popq %rsi
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movl $0x17f, %edx            # imm = 0x17F
callq 0x1e20
leaq 0x8(%rsp), %rdi
callq 0x15ce
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x15ce
jmp 0x1e00
movq %rax, %r14
movl $0xd8, %esi
movq %rbx, %rdi
jmp 0x1e13
movq %rax, %r14
pushq $0x38
popq %rsi
movq %r15, %rdi
callq 0x1100
movq %r14, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O2/archit-p[P]bulletproofs-demo/src/prover.cpp
// Function: Prover::get_complement_vector(std::vector<int, std::allocator<int>>)
vector <int> Prover::get_complement_vector(vector <int> al)
{
    vector <int> ar;
    for(int i = 0; i < n; i++) {
        ar.push_back(al[i]-1);
    }
    return ar;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %r13d, %r13d
leaq 0xc(%rsp), %r12
movslq (%r15), %rax
cmpq %rax, %r13
jge 0x21f8
movq (%r14), %rax
movl (%rax,%r13,4), %eax
decl %eax
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1602
incq %r13
jmp 0x21d3
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x15ce
movq %r14, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O2/archit-p[P]bulletproofs-demo/src/prover.cpp
// Function: Prover::get_gen_vector(std::vector<int, std::allocator<int>>, int)
vector <int> Prover::get_gen_vector(vector <int> gens, int len)
{
    vector <int> ret;
    int gen;
    for(int i = 0; i < len; i++) {
        gen = gens[rand()%gens.size()];
        ret.push_back(gen);
    }
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ebp
leaq 0x4(%rsp), %r15
subl $0x1, %ebp
jb 0x2275
callq 0x1030
cltq
movq (%r14), %rcx
movq 0x8(%r14), %rsi
subq %rcx, %rsi
sarq $0x2, %rsi
xorl %edx, %edx
divq %rsi
movl (%rcx,%rdx,4), %eax
movl %eax, 0x4(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1c16
jmp 0x2242
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x15ce
movq %r14, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O2/archit-p[P]bulletproofs-demo/src/prover.cpp
// Function: Prover::calc_tau_x()
int Prover::calc_tau_x()
{
    if(x == -1 || z == -1) {
        cout << "Set the x and z values before calling";
        return -1;
    }
    return tau[1]*(int)pow(x, 2)+tau[0]*x+z*p;
}

// Assembly:
movl 0xc(%rdi), %ecx
cmpl $-0x1, %ecx
je 0x23f7
movl 0x14(%rdi), %eax
cmpl $-0x1, %eax
je 0x23f7
cvtsi2sd %ecx, %xmm0
mulsd %xmm0, %xmm0
cvttsd2si %xmm0, %edx
imull 0xd0(%rdi), %edx
imull 0xcc(%rdi), %ecx
imull 0x4(%rdi), %eax
addl %ecx, %eax
addl %edx, %eax
retq
pushq %rax
movq 0x4bd9(%rip), %rdi      # 0x6fd8
leaq 0x1c25(%rip), %rsi      # 0x402b
callq 0x10e0
pushq $-0x1
popq %rax
addq $0x8, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/archit-p[P]bulletproofs-demo/src/prover.cpp
// Function: Prover::calc_l()
vector <int> Prover::calc_l()
{
    if(x == -1 || z == -1) {
        cout << "Set the x and z values before calling";
        return {-1};
    }
    return vector_sum(vector_diff(al, k_product_vector(get_k_vector(1, n), z)), k_product_vector(sl, x));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
cmpl $-0x1, 0xc(%rsi)
je 0x24f7
movq %rsi, %r14
cmpl $-0x1, 0x14(%rsi)
je 0x24f7
leaq 0x18(%r14), %rsi
leaq 0x68(%rsp), %rdi
callq 0x2f60
movl (%r14), %edx
leaq 0x38(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x187d
movl 0x14(%r14), %edx
leaq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x1959
leaq 0x80(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x19f0
leaq 0x48(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x2f60
movl 0xc(%r14), %edx
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1959
leaq 0x80(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x1a6f
leaq 0x20(%rsp), %rdi
callq 0x15ce
leaq 0x8(%rsp), %rdi
callq 0x15ce
leaq 0x80(%rsp), %rdi
callq 0x15ce
leaq 0x50(%rsp), %rdi
callq 0x15ce
leaq 0x38(%rsp), %rdi
callq 0x15ce
leaq 0x68(%rsp), %rdi
callq 0x15ce
jmp 0x2522
movq 0x4ada(%rip), %rdi      # 0x6fd8
leaq 0x1b26(%rip), %rsi      # 0x402b
callq 0x10e0
leaq 0x4(%rsp), %rsi
orl $-0x1, (%rsi)
pushq $0x1
popq %rdx
leaq 0x3(%rsp), %rcx
movq %rbx, %rdi
callq 0x2fae
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x15ce
jmp 0x2542
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x15ce
jmp 0x2551
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x15ce
jmp 0x2563
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x15ce
jmp 0x2572
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x15ce
leaq 0x68(%rsp), %rdi
callq 0x15ce
movq %rbx, %rdi
callq 0x1160
movq %rax, %rbx
jmp 0x257c
nop
// File: /workspace/github_cpp_makefile_star2_O2/archit-p[P]bulletproofs-demo/src/serialize.hpp
// Function: serialize(std::vector<int, std::allocator<int>>)
char *serialize(std::vector <int> nums)
{
    char *temp, *p, *bytes = (char *)malloc(sizeof(int)* nums.size());
    p = bytes;
    for(int i = 0; i < nums.size(); i++, p += sizeof(int)) {
        temp = conv_to_bytes(nums[i]);
        std::copy_n(temp,
                     sizeof(int),
                      p);
    }
    return bytes;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r12
movq 0x8(%rdi), %r13
movq %r13, %rdi
subq %r12, %rdi
callq 0x1110
movq %rax, %r14
xorl %r15d, %r15d
subq %r12, %r13
sarq $0x2, %r13
cmpq %r15, %r13
jbe 0x312e
movl (%r12,%r15,4), %edi
callq 0x30d4
movl (%rax), %eax
movl %eax, (%r14,%r15,4)
incq %r15
movq (%rbx), %r12
movq 0x8(%rbx), %r13
jmp 0x3107
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/archit-p[P]bulletproofs-demo/src/serialize.hpp
// Function: deserialize(char*, int)
std::vector <int> deserialize(char *bytes, int num_bytes)
{
    std::vector <int> ret;
    int temp;
    num_bytes = num_bytes/sizeof(int);

    for(int i = 0; i < num_bytes; i++) {
        std::copy_n(static_cast<const int*>(static_cast<const void*>(bytes))+i,
                        1,
                            &temp);
        ret.push_back(temp);
    }

    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
sarl $0x2, %r14d
xorl %r13d, %r13d
testl %r14d, %r14d
cmovlel %r13d, %r14d
leaq 0xc(%rsp), %r12
cmpq %r13, %r14
je 0x318c
movl (%r15,%r13,4), %eax
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1c16
incq %r13
jmp 0x316f
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x15ce
movq %r14, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O2/archit-p[P]bulletproofs-demo/src/inner_product_arg.cpp
// Function: InnerProdArg::InnerProdArg(std::vector<int, std::allocator<int>>, std::vector<int, std::allocator<int>>, int, int, int)
InnerProdArg::InnerProdArg(vector <int> a, vector <int> b, int c, int order, int x) {
    if(a.size() != b.size())
        return;
    InnerProdArg::a = a;
    InnerProdArg::b = b;
    InnerProdArg::c = c;
    InnerProdArg::x = x;
    InnerProdArg::order = order;
    generate_argument();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
movq 0x8(%rdx), %rcx
subq (%rdx), %rcx
cmpq %rcx, %rax
jne 0x3212
movl %r9d, %r14d
movl %r8d, %ebp
movq %rdx, %r13
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
callq 0x36fc
movq %r12, %rdi
movq %r13, %rsi
callq 0x36fc
movl %r15d, 0x3c(%rbx)
movl %r14d, 0x40(%rbx)
movl %ebp, 0x38(%rbx)
movq %rbx, %rdi
callq 0x323c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r12, %rdi
callq 0x15ce
movq %rbx, %rdi
callq 0x15ce
movq %r14, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O2/archit-p[P]bulletproofs-demo/src/group.cpp
// Function: Group::Group(int)
Group::Group(int p) 
{
    order = p;
    for(long i = 1; i <= p; i++)
        group.push_back(i);
    generators = find_gens(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
leaq 0x8(%rdi), %rbx
leaq 0x20(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
movl %esi, (%rdi)
movslq %esi, %r12
pushq $0x1
popq %r13
movq %rsp, %r15
cmpq %r12, %r13
jg 0x3844
movl %r13d, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1602
incq %r13
jmp 0x382b
movq %rsp, %rdi
movl %ebp, %edx
callq 0x3890
movq %rsp, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2fe4
movq %rbx, %rdi
callq 0x15ce
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3875
movq %rax, %r15
movq %r14, %rdi
callq 0x15ce
movq %rbx, %rdi
callq 0x15ce
movq %r15, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O2/archit-p[P]bulletproofs-demo/src/group.cpp
// Function: Group::find_gens(int)
vector <int> Group::find_gens(int p)
{
    int q = (p-1)/2;
    int power_check_2, power_check_q;
    vector <int> gens;
    for(int i = 2; i < p; i++) {
        power_check_2 = large_mod(i, 2, p);
        power_check_q = large_mod(i, q, p);
        if(power_check_2 != 1 && power_check_q != 1)
            gens.push_back(i);
        }
    return gens;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rdi, %rbx
leal -0x1(%r14), %eax
pushq $0x2
popq %rbp
cltd
idivl %ebp
movl %eax, %r15d
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0x4(%rsp), %r12
movl %ebp, %edi
movl %edi, 0x4(%rsp)
cmpl %r14d, %edi
jge 0x3903
movl %ebp, %esi
movl %r14d, %edx
callq 0x13a8
movl %eax, %r13d
movl 0x4(%rsp), %edi
movl %r15d, %esi
movl %r14d, %edx
callq 0x13a8
cmpl $0x1, %r13d
je 0x38fb
cmpl $0x1, %eax
je 0x38fb
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1c16
movl 0x4(%rsp), %edi
incl %edi
jmp 0x38c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x15ce
movq %r14, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O2/arush15june[P]DFA-CPP/dfa.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
std::vector<std::string> split(const std::string &s, char delim) {
    std::stringstream ss(s);
    std::string item;
    std::vector<std::string> elems;
    while (std::getline(ss, item, delim)) {
        elems.push_back(item);
        // elems.push_back(std::move(item)); // if C++11 (based on comment from @mchiasson)
    }
    return elems;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movl %edx, %r15d
movq %rdi, %rbx
leaq -0x1c8(%rbp), %r14
pushq $0x18
popq %rdx
movq %r14, %rdi
callq 0x21e0
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movsbl %r15b, %r15d
leaq -0x40(%rbp), %r12
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x2220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x23e2
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2c22
jmp 0x23b9
leaq -0x40(%rbp), %rdi
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
callq 0x2110
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2c5e
leaq -0x40(%rbp), %rdi
callq 0x20c0
leaq -0x1c8(%rbp), %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/arush15june[P]DFA-CPP/dfa.cpp
// Function: main
int main(int argc, char** argv) {
    
    if(argc < 3) {
        std::cout<<"Invalid Input!"<<std::endl;
        std::cout<<"Usage: "<<std::endl;
        std::cout<<"./dfa <dfa_filename> <input_string>"<<std::endl;
        
        return 1;
    }

    std::string dfa_filename = std::string(argv[1]);
    std::string input_string = std::string(argv[2]);

    std::cout<<"Building DFA from "<<dfa_filename<<std::endl;
    auto dfa = build_dfa_from_file(dfa_filename);

    auto evaluate = dfa.execute(input_string);

    std::cout<<"Input: "<<input_string<<std::endl;
    if(evaluate) {
        std::cout<<"Evaluation: True"<<std::endl;
        return 0;
    }
    else {
        std::cout<<"Evaluation: False"<<std::endl;
        return 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x6e18, %rsp           # imm = 0x6E18
cmpl $0x2, %edi
jg 0x2a67
movq 0x35b6(%rip), %rbx      # 0x5fd0
leaq 0x15e3(%rip), %rsi      # 0x4004
movq %rbx, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
leaq 0x15db(%rip), %rsi      # 0x4013
movq %rbx, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
leaq 0x15cc(%rip), %rsi      # 0x401b
movq %rbx, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
pushq $0x1
popq %rbx
jmp 0x2b96
movq %rsi, %rbx
movq 0x8(%rsi), %rsi
leaq -0x48(%rbp), %rdi
leaq -0x6e18(%rbp), %rdx
callq 0x20a0
movq 0x10(%rbx), %rsi
leaq -0x28(%rbp), %rdi
leaq -0x6e18(%rbp), %rdx
callq 0x20a0
movq 0x3537(%rip), %rdi      # 0x5fd0
leaq 0x159f(%rip), %rsi      # 0x403f
callq 0x2160
leaq -0x48(%rbp), %rsi
movq %rax, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x20d0
leaq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x21a0
leaq -0x6e18(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x2432
leaq -0x88(%rbp), %rdi
callq 0x20c0
leaq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x21a0
leaq -0x6e18(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x2d0c
movl %eax, %ebx
leaq -0x68(%rbp), %rdi
callq 0x20c0
movq 0x34b9(%rip), %rdi      # 0x5fd0
leaq 0x1534(%rip), %rsi      # 0x4052
callq 0x2160
leaq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x20d0
testb %bl, %bl
je 0x2b5a
movq 0x348e(%rip), %rdi      # 0x5fd0
leaq 0x1511(%rip), %rsi      # 0x405a
callq 0x2160
xorl %ebx, %ebx
movq %rax, %rdi
callq 0x20d0
jmp 0x2b78
movq 0x346f(%rip), %rdi      # 0x5fd0
leaq 0x1503(%rip), %rsi      # 0x406b
callq 0x2160
movq %rax, %rdi
callq 0x20d0
pushq $0x1
popq %rbx
leaq -0x6e18(%rbp), %rdi
callq 0x32de
leaq -0x28(%rbp), %rdi
callq 0x20c0
leaq -0x48(%rbp), %rdi
callq 0x20c0
movl %ebx, %eax
addq $0x6e18, %rsp           # imm = 0x6E18
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x20c0
jmp 0x2bd0
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x20c0
jmp 0x2bdc
jmp 0x2bc8
movq %rax, %rbx
jmp 0x2be5
movq %rax, %rbx
jmp 0x2bdc
movq %rax, %rbx
leaq -0x6e18(%rbp), %rdi
callq 0x32de
leaq -0x28(%rbp), %rdi
callq 0x20c0
leaq -0x48(%rbp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/arush15june[P]DFA-CPP/dfa.cpp
// Function: StateDiagram::insertEdge(int, int, int)
void insertEdge(int state_no, int weight, int y) {
        /*
            Add edge to an adjacency list.

            @param int state_no: state to add to
            @param int weight: weight of edge
            @param int y: state no of edge
        */
        
        auto pair = std::make_pair(weight, y);
        auto& state = states[state_no];
        
        state.push_back(pair);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
shlq $0x20, %rcx
movl %edx, %edx
orq %rcx, %rdx
leaq -0x8(%rbp), %rax
movq %rdx, (%rax)
movslq %esi, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rdi
movq %rax, %rsi
callq 0x2e88
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/arush15june[P]DFA-CPP/dfa.cpp
// Function: DFA::execute(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool execute(std::string input) {
        /*
        Execute the DFA over the input string.

        TODO: Templatize for any type of vector of input symbols

        Algorithm
            1) set current state to q i.e initial state of DFA.
            2) Iterate over the string.
                a) get the adjacency list for the current state.
                b) Iterate over the adjancency list
                    i) if the state's weight is same as the current symbols ASCII value
                        set the current state to the state's no and break the iteration.
            3) If the current state is same as the final state, set the final_state_reached flag true
            4) return final_state_reached

        @param std::string input: Input string to execute DFA on.
        @return bool final_state_reached: True if the final state was reached, else False.
        */

        bool final_state_reached = false;
        int current_state = q; 

        for(char symbol: input) {
            auto symbol_val = int(symbol);
            auto curr_adj_list = state_diagram.getState(current_state);

            for(auto &state: curr_adj_list) {
                if(state.first == symbol_val and state.second != current_state) {
                    current_state = state.second;
                    break;
                }
            }
        }


        if(current_state == f) final_state_reached = true;

        return final_state_reached;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, -0x30(%rbp)
movl 0x6d88(%rdi), %r14d
movq (%rsi), %r12
movq 0x8(%rsi), %r13
addq %r12, %r13
leaq -0x48(%rbp), %r15
cmpq %r13, %r12
je 0x2d88
movsbl (%r12), %ebx
movq %r15, %rdi
movq -0x30(%rbp), %rsi
movl %r14d, %edx
callq 0x3306
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
cmpq %rcx, %rax
je 0x2d7b
movl 0x4(%rax), %edx
cmpl %ebx, (%rax)
setne %sil
cmpl %r14d, %edx
sete %dil
orb %sil, %dil
addq $0x8, %rax
testb %dil, %dil
jne 0x2d57
movl %edx, %r14d
movq %r15, %rdi
callq 0x3296
incq %r12
jmp 0x2d36
movq -0x30(%rbp), %rax
cmpl 0x6d8c(%rax), %r14d
sete %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/arush15june[P]DFA-CPP/dfa.cpp
// Function: StateDiagram::getState(int)
std::vector<std::pair<int, int> > getState(int index) {
        /*
            get the adjacency list vector for a certain state

            @param int index: state no
            @return std::vector<std::pair<int, int>> adjList: adjacency list of state `index`
        */

        return states[index];
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %edx, %rax
imulq $0x18, %rax, %rax
addq %rax, %rsi
callq 0x3246
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/shuhaosun[P]ECM-Sketch/./ECM_Sketch.h
// Function: ECM_Sketch::ECM_Sketch(int, int)
ECM_Sketch(int _w, int _d)
	{
		mem_acc = 0;
		counter_index_size = 20;
		w = _w;
		d = _d;
		
		for(int i = 0; i < d; i++)	
		{
			counter[i] = new Counter[w];
			memset(counter[i], -1, sizeof(Counter) * w);
		}

		MAX_CNT = (1 << COUNTER_SIZE) - 1;

		for(int i = 0; i < d; i++)
		{
			bobhash32[i] = new BOBHash32(i);
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
andl $0x0, 0x1a8(%rdi)
movl $0x14, 0x19c(%rdi)
movl %esi, 0x190(%rdi)
movl %edx, 0x194(%rdi)
movslq %esi, %rax
movl $0x4b4, %ecx            # imm = 0x4B4
mulq %rcx
movq %rax, %r15
pushq $-0x1
popq %r12
cmovnoq %rax, %r12
xorl %r13d, %r13d
testl %ebx, %ebx
cmovlel %r13d, %ebx
cmpq %r13, %rbx
je 0x1a06
movq %r12, %rdi
callq 0x1030
movq %rax, 0xf0(%r14,%r13,8)
movq %rax, %rdi
movl $0xff, %esi
movq %r15, %rdx
callq 0x10d0
incq %r13
jmp 0x19dc
movl $0xffff, 0x198(%r14) # imm = 0xFFFF
xorl %r12d, %r12d
pushq $0x4
popq %r15
cmpq %r12, %rbx
je 0x1a31
movq %r15, %rdi
callq 0x1130
movl %r12d, (%rax)
movq %rax, (%r14,%r12,8)
incq %r12
jmp 0x1a18
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/shuhaosun[P]ECM-Sketch/./ECM_Sketch.h
// Function: ECM_Sketch::Insert(char const*, int)
void Insert(const char * str, int t)
	{
		for(int i = 0; i < d; i++)
		{
			index[i] = (bobhash32[i]->run(str, strlen(str))) % w;

			Expire_bucket(i, index[i], t);
			Insert_bucket(i, index[i], t);

			mem_acc ++;
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movslq 0x194(%r15), %rax
cmpq %rax, %r12
jge 0x1ab4
movq (%r15,%r12,8), %r13
movq %r14, %rdi
callq 0x10a0
movq %r13, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x13a8
xorl %edx, %edx
divl 0x190(%r15)
movl %edx, 0xa0(%r15,%r12,4)
movq %r15, %rdi
movl %r12d, %esi
movl %ebx, %ecx
callq 0x1c02
movl 0xa0(%r15,%r12,4), %edx
movq %r15, %rdi
movl %r12d, %esi
movl %ebx, %ecx
callq 0x1c5e
incl 0x1a8(%r15)
incq %r12
jmp 0x1a50
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/shuhaosun[P]ECM-Sketch/./ECM_Sketch.h
// Function: ECM_Sketch::Query(char const*, int)
int Query(const char *str, int t)
	{
		int min_value = MAX_CNT;
		int temp;
		for(int i = 0; i < d; i++)
		{
			index[i] = (bobhash32[i]->run(str, strlen(str))) % w;
			Expire_bucket(i, index[i], t);
			temp = Bucket_sum(i, index[i], t);
			min_value = temp < min_value ? temp : min_value;
		}
		return min_value;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl 0x198(%rdi), %ebp
xorl %r12d, %r12d
movslq 0x194(%r15), %rax
cmpq %rax, %r12
jge 0x1b3c
movq (%r15,%r12,8), %r13
movq %r14, %rdi
callq 0x10a0
movq %r13, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x13a8
xorl %edx, %edx
divl 0x190(%r15)
movl %edx, 0xa0(%r15,%r12,4)
movq %r15, %rdi
movl %r12d, %esi
movl %ebx, %ecx
callq 0x1c02
movl 0xa0(%r15,%r12,4), %edx
movq %r15, %rdi
movl %r12d, %esi
movl %ebx, %ecx
callq 0x1e48
cmpl %ebp, %eax
cmovll %eax, %ebp
incq %r12
jmp 0x1ada
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/shuhaosun[P]ECM-Sketch/./ECM_Sketch.h
// Function: ECM_Sketch::Expire_bucket(int, int, int)
void Expire_bucket(int i, int j, int t)
	{
		int z = counter[i][j].number - 1;
		if (z != -2)
		{
			for (int q = z; q >= 0; q--)
			{
				if (counter[i][j].bucket[q].end <= (t - WINDOW_SIZE))
				{
					counter[i][j].bucket[q].exponent = -1;
					counter[i][j].bucket[q].start = -1;
					counter[i][j].bucket[q].end = -1;
					counter[i][j].number--;
				}
				else
				{
					break;
				}
			}
		}
	}

// Assembly:
movslq %esi, %rax
movq 0xf0(%rdi,%rax,8), %rax
movslq %edx, %rdx
imulq $0x4b4, %rdx, %rdi      # imm = 0x4B4
movl 0x4b0(%rax,%rdi), %edx
decl %edx
cmpl $-0x2, %edx
jne 0x1c26
retq
leaq (%rax,%rdi), %rsi
addq $0x4b0, %rsi            # imm = 0x4B0
addq %rdi, %rax
addl $0xfffb6c20, %ecx       # imm = 0xFFFB6C20
testl %edx, %edx
js 0x1c25
movl %edx, %edi
imulq $0xc, %rdi, %rdi
cmpl %ecx, 0x4(%rax,%rdi)
jg 0x1c25
leaq (%rax,%rdi), %r8
orl $-0x1, (%r8)
orq $-0x1, 0x4(%rax,%rdi)
movl %edx, (%rsi)
decl %edx
jmp 0x1c3a
// File: /workspace/github_cpp_makefile_star2_O2/shuhaosun[P]ECM-Sketch/./ECM_Sketch.h
// Function: ECM_Sketch::Bucket_sum(int, int, int)
int Bucket_sum(int i, int j, int t)
	{
		int z = counter[i][j].number;
		if (z == -1)
		{
			return 0;
		}
		else
		{
			int exp;
			int count_bucket = 1;
			int count = 0;
			int q;
			for (q = 0; q < z - 1; ++q)
			{
				exp = counter[i][j].bucket[q].exponent;
				for (int k = 0; k < exp; ++k)
				{
					count_bucket = 2 * count_bucket;
				}
				count = count + count_bucket;
				count_bucket = 1;
			}
			for (int k = 0; k < counter[i][j].bucket[q].exponent; ++k)
			{
				count_bucket = 2 * count_bucket;
			}
			
			count = count + count_bucket / 2;

			return count;
		}
	}

// Assembly:
movslq %esi, %rax
movq 0xf0(%rdi,%rax,8), %rax
movslq %edx, %rcx
imulq $0x4b4, %rcx, %rcx      # imm = 0x4B4
movl 0x4b0(%rax,%rcx), %edx
cmpl $-0x1, %edx
je 0x1ec7
addq %rcx, %rax
cmpl $0x2, %edx
pushq $0x1
popq %rsi
cmovll %esi, %edx
decl %edx
xorl %edi, %edi
xorl %r8d, %r8d
xorl %ecx, %ecx
cmpq %rdx, %r8
je 0x1ea8
imulq $0xc, %r8, %r9
movl (%rax,%r9), %r9d
testl %r9d, %r9d
cmovlel %edi, %r9d
movl %esi, %r10d
subl $0x1, %r9d
jb 0x1ea0
addl %r10d, %r10d
jmp 0x1e95
addl %r10d, %ecx
incq %r8
jmp 0x1e7e
imulq $0xc, %rdx, %rdx
movl (%rax,%rdx), %eax
xorl %edx, %edx
testl %eax, %eax
cmovgl %eax, %edx
pushq $0x1
popq %rax
subl $0x1, %edx
jb 0x1ec2
addl %eax, %eax
jmp 0x1eb9
shrl %eax
addl %ecx, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/sotrteacher[P]1MM1INTRO/20190820_1MM1_INTRO/main.c
// Function: main
int main(void){
  int result=printf("mcd(32,132)=%d\n",mcd(32,132));
  printf("mcd(8,64)=%d\n",mcd(8,64));
  printf("mcd(65,2048)=%d\n",mcd(65,2048));

  int m=mcd(32,132);
  int arr[]={32,132};
  simplificar(arr);
  printf("32/132=%d/%d\n",arr[0],arr[1]);
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
pushq $0x20
popq %r14
movl %r14d, %edi
movl $0x84, %esi
callq 0x1270
leaq 0xe2d(%rip), %rdi       # 0x2014
movl %eax, %esi
xorl %eax, %eax
callq 0x1030
movl %eax, %ebx
pushq $0x8
popq %rdi
pushq $0x40
popq %rsi
callq 0x1270
leaq 0xe20(%rip), %rdi       # 0x2024
movl %eax, %esi
xorl %eax, %eax
callq 0x1030
pushq $0x41
popq %rdi
movl $0x800, %esi            # imm = 0x800
callq 0x1270
leaq 0xe11(%rip), %rdi       # 0x2032
movl %eax, %esi
xorl %eax, %eax
callq 0x1030
movl %r14d, %edi
movl $0x84, %esi
callq 0x1270
movabsq $0x8400000020, %rax     # imm = 0x8400000020
leaq -0x18(%rbp), %r14
movq %rax, (%r14)
movq %r14, %rdi
callq 0x113c
movl (%r14), %esi
movl 0x4(%r14), %edx
leaq 0xde5(%rip), %rdi       # 0x2043
xorl %eax, %eax
callq 0x1030
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sotrteacher[P]1MM1INTRO/20190820_1MM1_INTRO/otro.c
// Function: mcd
int mcd(int n,int d)
{
  int N,D,R;
  N=abs(n);
  D=abs(d);
  R=D%N;
  if(!R) goto fin;
#ifdef PRELIMINAR
  printf("%d = %d(%d)+%d\n",D,D/N,N,R);
#endif /*PRELIMINAR*/
  D=N;
  N=R;
  R=D%N;
  if(!R) goto fin;
#ifdef PRELIMINAR
  printf("%d = %d(%d)+%d\n",D,D/N,N,R);
#endif /*PRELIMINAR*/
  D=N;
  N=R;
  R=D%N;
  if(!R) goto fin;
#ifdef PRELIMINAR
  printf("%d = %d(%d)+%d\n",D,D/N,N,R);
#endif /*PRELIMINAR*/
  D=N;
  N=R;
  R=D%N;
  if(!R) goto fin;
#ifdef PRELIMINAR
  printf("%d = %d(%d)+%d\n",D,D/N,N,R);
#endif /*PRELIMINAR*/
fin:
  return N;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
negl %ebx
cmovsl %edi, %ebx
movl %esi, %ecx
negl %ecx
cmovsl %esi, %ecx
movl %ecx, %eax
xorl %edx, %edx
divl %ebx
testl %edx, %edx
je 0x132a
movl %edx, %r14d
leaq 0xd64(%rip), %rdi       # 0x2004
movl %ecx, %esi
movl %eax, %edx
movl %ebx, %ecx
movl %r14d, %r8d
xorl %eax, %eax
callq 0x1030
movl %ebx, %eax
xorl %edx, %edx
divl %r14d
testl %edx, %edx
je 0x1322
movl %edx, %r15d
leaq 0xd3f(%rip), %rdi       # 0x2004
movl %ebx, %esi
movl %eax, %edx
movl %r14d, %ecx
movl %r15d, %r8d
xorl %eax, %eax
callq 0x1030
movl %r14d, %eax
xorl %edx, %edx
divl %r15d
testl %edx, %edx
je 0x1327
movl %edx, %ebx
leaq 0xd19(%rip), %rdi       # 0x2004
movl %r14d, %esi
movl %eax, %edx
movl %r15d, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0x1030
movl %r15d, %eax
xorl %edx, %edx
divl %ebx
testl %edx, %edx
je 0x132a
movl %edx, %r8d
leaq 0xcf2(%rip), %rdi       # 0x2004
movl %r15d, %esi
movl %eax, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1030
jmp 0x132a
movl %r14d, %ebx
jmp 0x132a
movl %r15d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH18_ToolsForLargePrograms/examples/class.cc
// Function: main
int main()
{
    std::string s;

    // ok: calls std::getline(std::istream&, const std::string&)
    getline(std::cin, s);

	std::cout << s << std::endl;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
leaq -0x18(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x2de4(%rip), %rdi      # 0x3fe0
leaq -0x28(%rbp), %rsi
callq 0x1030
movq 0x2dc4(%rip), %rdi      # 0x3fd0
leaq -0x28(%rbp), %rsi
callq 0x1070
movq %rax, %rdi
callq 0x1050
leaq -0x28(%rbp), %rdi
callq 0x1040
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/server.cpp
// Function: (anonymous namespace)::goto_next_map()
void goto_next_map()
{
	intermission = false;
	turns_lagged = 0;
	Game::start();
	last_clock.update();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x0, 0x326cf(%rip)     # 0x3d400
andw $0x0, 0x32d87(%rip)     # 0x3dac0
callq 0x15dcc
leaq 0x32d6b(%rip), %rdi     # 0x3dab0
popq %rbp
jmp 0x246c0
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/server.cpp
// Function: (anonymous namespace)::goto_intermission(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void goto_intermission(const string &loadmap)
{
	intermission = true;
	Game::next_map(loadmap);
	if(turns_lagged)
	{
		string str = "Warning: the server lagged "
			+ lex_cast(turns_lagged) + " turns this map.";
		to_log(str);
	}
	interm_over = time(NULL) + Config::int_settings[Config::IS_INTERM_SECS];
	Network::clocksync(interm_over - time(NULL), 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
movb $0x1, 0x326a5(%rip)     # 0x3d400
callq 0x14e90
movswl 0x32d59(%rip), %esi     # 0x3dac0
testl %esi, %esi
je 0xadc2
leaq -0x68(%rbp), %rbx
movq %rbx, %rdi
callq 0x24fde
leaq 0x1b47f(%rip), %rsi     # 0x261fd
leaq -0x28(%rbp), %rdi
movq %rbx, %rdx
callq 0xb332
leaq 0x1b488(%rip), %rdx     # 0x26219
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xb309
leaq -0x28(%rbp), %rdi
callq 0x47e8
leaq -0x68(%rbp), %rdi
callq 0x47e8
leaq -0x48(%rbp), %rdi
callq 0x10b68
leaq -0x48(%rbp), %rdi
callq 0x47e8
xorl %edi, %edi
callq 0x43c0
leaq 0x34ac0(%rip), %rcx     # 0x3f890
movl 0x18(%rcx), %ebx
addq %rax, %rbx
movq %rbx, 0x32ccb(%rip)     # 0x3daa8
xorl %edi, %edi
callq 0x43c0
subl %eax, %ebx
movzwl %bx, %edi
xorl %esi, %esi
callq 0xc3b8
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
jmp 0xae15
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x47e8
jmp 0xae11
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x47e8
movq %rbx, %rdi
callq 0x4710
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/network.cpp
// Function: Network::shutdown()
void Network::shutdown()
{
	send_buffer.clear();
	send_buffer.add((unsigned char)MID_QUIT);
	broadcast();
	close(s_me);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x32b2e(%rip), %rbx     # 0x3e118
movq %rbx, %rdi
callq 0x24712
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x24724
movl $0xffff, %edi           # imm = 0xFFFF
movq %rbx, %rsi
callq 0xb61b
movl 0x33b28(%rip), %edi     # 0x3f138
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x47a0