LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/reddragon[P]packed-memory-array/impl2.cpp
// Function: PMA::init_vars(int)
void
    init_vars(int capacity) {
        this->chunk_size = 1 << log2(log2(capacity) * 2);
        assert(this->chunk_size == (1 << log2(this->chunk_size)));
        this->nchunks = capacity / this->chunk_size;
        this->nlevels = log2(this->nchunks);
        this->lgn = log2(capacity);
        dprintf("init_vars::capacity: %d, nelems: %d, chunk_size: %d, nchunks: %d\n", capacity, nelems, chunk_size, nchunks);
    }

// Assembly:
xorl %ecx, %ecx
movl $0x0, %eax
cmpl $0x2, %esi
jl 0x2460
xorl %eax, %eax
movl %esi, %r8d
movl %esi, %edx
shrl %edx
incl %eax
cmpl $0x3, %r8d
movl %edx, %r8d
ja 0x2453
testl %eax, %eax
jle 0x2475
addl %eax, %eax
xorl %ecx, %ecx
movl %eax, %edx
shrl %edx
incl %ecx
cmpl $0x3, %eax
movl %edx, %eax
ja 0x246a
movl $0x1, %r8d
shll %cl, %r8d
movl $0x1, %eax
movl %r8d, 0x48(%rdi)
xorl %ecx, %ecx
cmpl $0x2, %r8d
jl 0x24a4
xorl %ecx, %ecx
movl %r8d, %r9d
movl %r8d, %edx
shrl %edx
incl %ecx
cmpl $0x3, %r9d
movl %edx, %r9d
ja 0x2497
shll %cl, %eax
cmpl %eax, %r8d
jne 0x24ed
movl %esi, %eax
cltd
idivl %r8d
movl %eax, 0x4c(%rdi)
xorl %ecx, %ecx
movl $0x0, %edx
cmpl $0x2, %eax
jl 0x24d2
xorl %edx, %edx
movl %eax, %r8d
shrl %r8d
incl %edx
cmpl $0x3, %eax
movl %r8d, %eax
ja 0x24c5
movl %edx, 0x50(%rdi)
cmpl $0x2, %esi
jl 0x24e9
xorl %ecx, %ecx
movl %esi, %eax
shrl %eax
incl %ecx
cmpl $0x3, %esi
movl %eax, %esi
ja 0x24de
movl %ecx, 0x54(%rdi)
retq
pushq %rax
leaq 0xd0a(%rip), %rdi       # 0x31ff
leaq 0xb6d(%rip), %rsi       # 0x3069
leaq 0xd2e(%rip), %rcx       # 0x3231
movl $0x76, %edx
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O1/archit-p[P]bulletproofs-demo/src/num_theory.cpp
// Function: is_prime(long)
bool is_prime(long int n)
{
    if (n <= 1)  return false;
    if (n <= 3)  return true;

    if (n%2 == 0 || n%3 == 0) return false;
 
    for (int i=5; i*i<=n; i=i+6)
        if (n%i == 0 || n%(i+2) == 0)
           return false;
 
    return true;
}

// Assembly:
cmpq $0x2, %rdi
jge 0x13d6
xorl %ecx, %ecx
jmp 0x13de
movb $0x1, %cl
cmpq $0x4, %rdi
jge 0x13e4
andb $0x1, %cl
movl %ecx, %eax
retq
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
movq %rdi, %rax
mulq %rcx
xorl %ecx, %ecx
testb $0x1, %dil
je 0x13de
shrq %rdx
leaq (%rdx,%rdx,2), %rax
movq %rdi, %rdx
subq %rax, %rdx
je 0x13de
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
movq %rdi, %rax
mulq %rcx
cmpq $0x19, %rdi
setl %cl
jl 0x13de
shrq $0x2, %rdx
leaq (%rdx,%rdx,4), %rax
movq %rdi, %rdx
subq %rax, %rdx
je 0x13de
movl $0xb, %esi
leaq -0x4(%rsi), %r8
movq %rdi, %rax
xorl %edx, %edx
divq %r8
testq %rdx, %rdx
je 0x13de
movq %rsi, %rax
imulq %rsi, %rax
cmpq %rdi, %rax
setg %cl
jg 0x13de
movq %rdi, %rax
xorl %edx, %edx
divq %rsi
addq $0x6, %rsi
testq %rdx, %rdx
jne 0x1439
jmp 0x13de
// File: /workspace/github_cpp_makefile_star2_O1/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:
testl %esi, %esi
jle 0x14b5
movl %edx, %ecx
movl %edi, %r8d
movl $0x1, %edi
testb $0x1, %sil
je 0x1497
imull %r8d, %edi
movl %edi, %eax
cltd
idivl %ecx
movl %edx, %edi
movl %esi, %r9d
shrl %r9d
imull %r8d, %r8d
movl %r8d, %eax
xorl %edx, %edx
idivl %ecx
movl %edx, %r8d
cmpl $0x1, %esi
movl %r9d, %esi
ja 0x1486
jmp 0x14ba
movl $0x1, %edi
movl %edi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rdx), %r12
cmpq 0x8(%rdx), %r12
je 0x152b
movq %rdx, %r14
movq (%rsi), %r13
leaq 0xc(%rsp), %r15
movl (%r12), %eax
imull (%r13), %eax
movl %eax, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1512
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x151d
movq %rbx, %rdi
movq %r15, %rdx
callq 0x175a
addq $0x4, %r13
addq $0x4, %r12
cmpq 0x8(%r14), %r12
jne 0x14ef
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1553
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x1100
movq %r14, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O1/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 0x16ca
movl %edi, %eax
movl $0x1, %edi
cmpl $0x2, %eax
jl 0x16c1
xorl %r8d, %r8d
movl $0x1, %ecx
movl %esi, %r9d
cltd
idivl %r9d
movl %r8d, %edi
imull %r8d, %eax
movl %ecx, %r8d
subl %eax, %r8d
movl %r9d, %eax
movl %edi, %ecx
cmpl $0x1, %r9d
movl %edx, %r9d
jg 0x16a2
movl %edi, %ecx
sarl $0x1f, %ecx
andl %esi, %ecx
addl %edi, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18b9
movq %rax, 0x8(%r14)
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x18c6
movq %rax, 0x8(%rbx)
movq 0x8(%r15), %rax
subq (%r15), %rax
je 0x193d
sarq $0x2, %rax
movq (%r15), %r13
xorl %ebp, %ebp
leaq 0x4(%rsp), %r12
movl (%r13,%rbp,4), %ecx
movl %ecx, 0x4(%rsp)
shrq %rax
cmpq %rbp, %rax
jbe 0x1904
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x191a
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0x192a
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x191f
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x192a
movq %r14, %rdi
jmp 0x1922
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1f62
incq %rbp
movq 0x8(%r15), %rax
subq (%r15), %rax
sarq $0x2, %rax
cmpq %rbp, %rax
ja 0x18dd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0x6679(%rip), %rbx      # 0x7fd8
leaq 0x36b8(%rip), %rsi      # 0x501e
movl $0xa, %edx
movq %rbx, %rdi
callq 0x1110
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1080
movq (%r14), %r13
cmpq 0x8(%r14), %r13
je 0x19d7
movq 0x662e(%rip), %r15      # 0x7fd8
leaq 0x3678(%rip), %r12      # 0x5029
movl (%r13), %esi
movq %r15, %rdi
callq 0x1150
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x1110
addq $0x4, %r13
cmpq 0x8(%r14), %r13
jne 0x19b1
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1080
movq %rax, %rbx
leaq 0x3616(%rip), %rsi      # 0x501e
movl $0xa, %edx
movq %rax, %rdi
callq 0x1110
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1080
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
testl %edx, %edx
jle 0x1ac5
movl %edx, %r14d
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
movsd %xmm0, 0x8(%rsp)
incl %r14d
leaq 0x4(%rsp), %r15
leal -0x2(%r14), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x1160
cvttsd2si %xmm0, %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1ab1
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1abc
movq %rbx, %rdi
movq %r15, %rdx
callq 0x175a
decl %r14d
cmpl $0x1, %r14d
jg 0x1a7d
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1ae9
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x1100
movq %r14, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
testq %rsi, %rsi
jle 0x1b52
movq %rsi, %r14
leaq 0xc(%rsp), %r15
movl %r14d, %eax
andl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1b38
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1b43
movq %rbx, %rdi
movq %r15, %rdx
callq 0x1f62
movq %r14, %rax
shrq %rax
cmpq $0x2, %r14
movq %rax, %r14
jae 0x1b18
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
setne %dl
addq $-0x4, %rcx
cmpq %rax, %rcx
seta %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x1b91
addq $0x4, %rax
movl -0x4(%rax), %edx
movl (%rcx), %esi
movl %esi, -0x4(%rax)
movl %edx, (%rcx)
addq $-0x4, %rcx
leaq 0x4(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0x1b77
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1bb5
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x1100
movq %r14, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq (%rsi), %r10
movq 0x8(%rsi), %r9
movq %r9, %r11
subq %r10, %r11
je 0x1c49
pushq %rbx
movl %edx, %r8d
sarq $0x2, %r11
cmpq $0x1, %r11
adcq $0x0, %r11
xorl %ebx, %ebx
movl (%r10,%rbx,4), %eax
imull %r8d, %eax
cltd
idivl %ecx
movl %edx, (%r10,%rbx,4)
incq %rbx
cmpq %rbx, %r11
jne 0x1c31
popq %rbx
movq %r10, (%rdi)
movq %r9, 0x8(%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %rdi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x1ce5
movq %rdx, %r14
movq %rsi, %r15
xorl %r13d, %r13d
leaq 0xc(%rsp), %r12
movl (%rax,%r13,4), %eax
movq (%r14), %rcx
subl (%rcx,%r13,4), %eax
movl %eax, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1cc4
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1ccf
movq %rbx, %rdi
movq %r12, %rdx
callq 0x175a
incq %r13
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
ja 0x1c9f
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1d0d
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x1100
movq %r14, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x1d90
movq %rdx, %r14
movq %rsi, %r15
xorl %r13d, %r13d
leaq 0xc(%rsp), %r12
movq (%r14), %rcx
movl (%rcx,%r13,4), %ecx
addl (%rax,%r13,4), %ecx
movl %ecx, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1d6f
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1d7a
movq %rbx, %rdi
movq %r12, %rdx
callq 0x175a
incq %r13
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
ja 0x1d4a
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1db8
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x1100
movq %r14, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rcx
cmpq %rcx, 0x8(%rsi)
je 0x1e3e
movq %rdx, %r14
movq %rsi, %r15
xorl %r13d, %r13d
leaq 0x4(%rsp), %r12
movq (%r14), %rax
movl (%rax,%r13,4), %eax
addl (%rcx,%r13,4), %eax
cltd
idivl %ebp
movl %edx, 0x4(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1e1d
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1e28
movq %rbx, %rdi
movq %r12, %rdx
callq 0x175a
incq %r13
movq (%r15), %rcx
movq 0x8(%r15), %rax
subq %rcx, %rax
sarq $0x2, %rax
cmpq %r13, %rax
ja 0x1df5
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
testq %rdi, %rdi
je 0x1e67
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x1100
movq %r14, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
testl %esi, %esi
jle 0x1ec7
movl %edx, %ebp
movl %esi, %r14d
leaq 0x4(%rsp), %r15
callq 0x1040
cltd
idivl %ebp
movl %edx, 0x4(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1eb7
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1ec2
movq %rbx, %rdi
movq %r15, %rdx
callq 0x175a
decl %r14d
jne 0x1e95
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1eec
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x1100
movq %r14, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
testl %edx, %edx
jle 0x2097
movl %edx, %ebp
movq %rsi, %r14
leaq 0x4(%rsp), %r15
movq %r14, %rdi
callq 0x4874
movl %eax, 0x4(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2088
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2093
movq %rbx, %rdi
movq %r15, %rdx
callq 0x175a
decl %ebp
jne 0x2066
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x20bc
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x1100
movq %r14, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x38, %edi
callq 0x10f0
movq %rax, %r15
movq %rax, %rdi
movl $0x17f, %esi            # imm = 0x17F
callq 0x46a0
movl $0xd8, %edi
callq 0x10f0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movl $0x4, %edx
callq 0x2040
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movl $0x9, %esi
movl $0x17f, %edx            # imm = 0x17F
callq 0x2190
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2142
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x216d
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
jmp 0x216d
movq %rax, %r14
movl $0xd8, %esi
movq %rbx, %rdi
jmp 0x2182
movq %rax, %r14
movl $0x38, %esi
movq %r15, %rdi
callq 0x1100
movq %r14, %rdi
callq 0x1170
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpl $0x0, (%rsi)
jle 0x26f4
movq %rdx, %r14
movq %rsi, %r15
xorl %r13d, %r13d
leaq 0xc(%rsp), %r12
movq (%r14), %rax
movl (%rax,%r13,4), %eax
decl %eax
movl %eax, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x26de
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x26e9
movq %rbx, %rdi
movq %r12, %rdx
callq 0x175a
incq %r13
movslq (%r15), %rax
cmpq %rax, %r13
jl 0x26bb
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x271c
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x1100
movq %r14, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
testl %ecx, %ecx
jle 0x2790
movl %ecx, %ebp
movq %rdx, %r14
leaq 0x4(%rsp), %r15
callq 0x1040
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 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2781
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x278c
movq %rbx, %rdi
movq %r15, %rdx
callq 0x1f62
decl %ebp
jne 0x274a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x27b5
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x1100
movq %r14, %rdi
callq 0x1170
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %eax
cmpl $-0x1, %eax
je 0x298d
cmpl $-0x1, 0x14(%rdi)
je 0x298d
cvtsi2sd %eax, %xmm0
mulsd %xmm0, %xmm0
cvttsd2si %xmm0, %ecx
imull 0xd0(%rdi), %ecx
movl 0x4(%rdi), %eax
movl 0xc(%rdi), %edx
imull 0xcc(%rdi), %edx
imull 0x14(%rdi), %eax
addl %edx, %eax
addl %ecx, %eax
retq
pushq %rax
movq 0x5643(%rip), %rdi      # 0x7fd8
leaq 0x268f(%rip), %rsi      # 0x502b
movl $0x25, %edx
callq 0x1110
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0xa8, %rsp
movq %rdi, %rbx
cmpl $-0x1, 0xc(%rsi)
je 0x2ae9
movq %rsi, %r14
cmpl $-0x1, 0x14(%rsi)
je 0x2ae9
leaq 0x18(%r14), %rsi
leaq 0x70(%rsp), %rdi
callq 0x3a82
movl (%r14), %edx
leaq 0x40(%rsp), %rdi
movl $0x1, %esi
callq 0x1a45
movl 0x14(%r14), %edx
leaq 0x58(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x1bbd
leaq 0x88(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0x1c6a
leaq 0x48(%r14), %rsi
leaq 0x10(%rsp), %rdi
callq 0x3a82
movl 0xc(%r14), %edx
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1bbd
leaq 0x88(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x1d15
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x2a6b
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2a82
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x2a9f
movq 0x98(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x2ab6
movq 0x68(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x2acd
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x2b21
movq 0x80(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
jmp 0x2b21
movq 0x54e8(%rip), %rdi      # 0x7fd8
leaq 0x2534(%rip), %rsi      # 0x502b
movl $0x25, %edx
callq 0x1110
leaq 0xa4(%rsp), %rsi
movl $0xffffffff, (%rsi)     # imm = 0xFFFFFFFF
leaq 0xf(%rsp), %rcx
movl $0x1, %edx
movq %rbx, %rdi
callq 0x3b02
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x2b4e
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
jmp 0x2b4e
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2b6a
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
jmp 0x2b6a
movq %rax, %rbx
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x2b8c
movq 0x98(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
jmp 0x2b8c
movq %rax, %rbx
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x2ba8
movq 0x68(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
jmp 0x2ba8
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x2bc4
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
jmp 0x2bc4
movq %rax, %rbx
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x2bde
movq 0x80(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
sarl $0x2, %edx
testl %edx, %edx
jle 0x3cd5
movq %rsi, %r14
movl %edx, %r12d
xorl %r13d, %r13d
leaq 0xc(%rsp), %r15
movl (%r14,%r13,4), %eax
movl %eax, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3cc2
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x3ccd
movq %rbx, %rdi
movq %r15, %rdx
callq 0x1f62
incq %r13
cmpq %r13, %r12
jne 0x3ca0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3cfd
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x1100
movq %r14, %rdi
callq 0x1170
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3d68
movl %r9d, %r14d
movl %r8d, %ebp
movq %rdx, %r13
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
callq 0x45ca
movq %r12, %rdi
movq %r13, %rsi
callq 0x45ca
movl %r15d, 0x3c(%rbx)
movl %r14d, 0x40(%rbx)
movl %ebp, 0x38(%rbx)
movq %rbx, %rdi
callq 0x3da0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r12), %rdi
testq %rdi, %rdi
je 0x3d8f
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x1100
movq %rbx, %rdi
callq 0x11d4
movq %r14, %rdi
callq 0x1170
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x20(%rdi), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
movl %esi, (%rdi)
testl %esi, %esi
jle 0x470f
movl %ebp, %r13d
xorl %r15d, %r15d
leaq 0x10(%rsp), %r12
incq %r15
movl %r15d, 0x10(%rsp)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x46ff
movl %r15d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x10(%rbx)
jmp 0x470a
movq %r14, %rdi
movq %r12, %rdx
callq 0x175a
cmpq %r15, %r13
jne 0x46e0
leaq 0x10(%rsp), %rdi
movl %ebp, %edx
callq 0x478c
leaq 0x10(%rsp), %rbx
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x3b48
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4742
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4753
movq %rax, %r12
movq 0x8(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x476f
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x1100
movq (%r14), %rdi
testq %rdi, %rdi
je 0x4783
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x1100
movq %r12, %rdi
callq 0x1170
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x2, 0xc(%rsp)
cmpl $0x3, %edx
jl 0x482f
movl %edx, %r14d
leal -0x1(%r14), %eax
shrl $0x1f, %eax
leal (%r14,%rax), %ebp
decl %ebp
sarl %ebp
movl $0x2, %edi
leaq 0xc(%rsp), %r15
movl $0x2, %esi
movl %r14d, %edx
callq 0x1478
movl %eax, %r12d
movl 0xc(%rsp), %edi
movl %ebp, %esi
movl %r14d, %edx
callq 0x1478
cmpl $0x1, %r12d
je 0x4820
cmpl $0x1, %eax
je 0x4820
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4815
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x4820
movq %rbx, %rdi
movq %r15, %rdx
callq 0x1f62
movl 0xc(%rsp), %edi
incl %edi
movl %edi, 0xc(%rsp)
cmpl %r14d, %edi
jl 0x47d2
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4856
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x1100
movq %r14, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %edx, %r15d
movq %rdi, %rbx
leaq -0x1d0(%rbp), %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0x21e0
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
xorl %eax, %eax
movq %rax, -0x8(%r13)
movb $0x0, (%r13)
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movsbl %r15b, %r15d
leaq -0x48(%rbp), %r12
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x2230
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2478
movq %rbx, %rdi
movq %r12, %rsi
callq 0x32ae
jmp 0x244f
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x248d
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2170
movq 0x3b2c(%rip), %rsi      # 0x5fc0
leaq -0x1d0(%rbp), %rdi
callq 0x2110
leaq -0x150(%rbp), %rdi
callq 0x2080
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x32fa
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x24e1
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2170
movq 0x3ad8(%rip), %rsi      # 0x5fc0
leaq -0x1d0(%rbp), %rdi
callq 0x2110
leaq -0x150(%rbp), %rdi
callq 0x2080
movq %r14, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/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, %eax
orq %rcx, %rax
movq %rax, -0x8(%rbp)
movslq %esi, %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rdi,%rcx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x3398
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x33a1
leaq -0x8(%rbp), %rdx
callq 0x345e
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x18, %rsp
movq %rdi, %rbx
movl 0x6d88(%rdi), %r15d
movq 0x8(%rsi), %r12
testq %r12, %r12
je 0x3437
movq (%rsi), %r13
addq %r13, %r12
movsbl (%r13), %r14d
movslq %r15d, %rax
leaq (%rax,%rax,2), %rax
leaq (%rbx,%rax,8), %rsi
leaq -0x40(%rbp), %rdi
callq 0x36c0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x341e
movq %rdi, %rcx
movl 0x4(%rcx), %edx
cmpl %r15d, %edx
setne %sil
cmpl %r14d, (%rcx)
sete %r8b
cmovel %edx, %r15d
testb %sil, %r8b
jne 0x341e
addq $0x8, %rcx
cmpq %rax, %rcx
jne 0x33fb
testq %rdi, %rdi
je 0x342f
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x2170
incq %r13
cmpq %r12, %r13
jne 0x33d2
cmpl 0x6d8c(%rbx), %r15d
sete %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
movl $0x0, 0x1a8(%rdi)
movl $0x14, 0x19c(%rdi)
movl %esi, 0x190(%rdi)
movl %edx, 0x194(%rdi)
movl %edx, %r12d
testl %edx, %edx
jle 0x1a76
movslq %esi, %rcx
movl $0x4b4, %edx            # imm = 0x4B4
movq %rcx, %rax
mulq %rdx
movq $-0x1, %r14
cmovnoq %rax, %r14
imulq $0x4b4, %rcx, %r15      # imm = 0x4B4
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x1030
movq %rax, 0xf0(%rbx,%r13,8)
movq %rax, %rdi
movl $0xff, %esi
movq %r15, %rdx
callq 0x10a0
incq %r13
cmpq %r13, %r12
jne 0x1a4e
movl $0xffff, 0x198(%rbx)    # imm = 0xFFFF
testl %ebp, %ebp
jle 0x1aa0
xorl %r14d, %r14d
movl $0x4, %edi
callq 0x1120
movl %r14d, (%rax)
movq %rax, (%rbx,%r14,8)
incq %r14
cmpq %r14, %r12
jne 0x1a87
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x0, 0x194(%rdi)
jle 0x1b38
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %r13
movq %r14, %rdi
callq 0x1090
movq %r13, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x13bc
xorl %edx, %edx
divl 0x190(%r15)
movl %edx, 0xa0(%r15,%r12,4)
movq %r15, %rdi
movl %r12d, %esi
movl %ebx, %ecx
callq 0x1c70
movl 0xa0(%r15,%r12,4), %edx
movq %r15, %rdi
movl %r12d, %esi
movl %ebx, %ecx
callq 0x1cd0
incl 0x1a8(%r15)
incq %r12
movslq 0x194(%r15), %rax
cmpq %rax, %r12
jl 0x1acd
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x198(%rdi), %ebx
cmpl $0x0, 0x194(%rdi)
jle 0x1bbf
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %r13
movq %r14, %rdi
callq 0x1090
movq %r13, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x13bc
xorl %edx, %edx
divl 0x190(%r15)
movl %edx, 0xa0(%r15,%r12,4)
movq %r15, %rdi
movl %r12d, %esi
movl %ebp, %ecx
callq 0x1c70
movl 0xa0(%r15,%r12,4), %edx
movq %r15, %rdi
movl %r12d, %esi
movl %ebp, %ecx
callq 0x1f02
cmpl %ebx, %eax
cmovll %eax, %ebx
incq %r12
movslq 0x194(%r15), %rax
cmpq %rax, %r12
jl 0x1b5f
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpl $-0x1, %edx
je 0x1cce
testl %edx, %edx
jle 0x1cce
leaq (%rax,%rdi), %rsi
addq $0x4b0, %rsi            # imm = 0x4B0
addq %rdi, %rax
addl $0xfffb6c20, %ecx       # imm = 0xFFFB6C20
leal -0x1(%rdx), %edi
leaq (%rdi,%rdi,2), %rdi
cmpl %ecx, 0x4(%rax,%rdi,4)
jg 0x1cce
leaq (%rax,%rdi,4), %rdi
movl $0xffffffff, (%rdi)     # imm = 0xFFFFFFFF
movq $-0x1, 0x4(%rdi)
decl (%rsi)
decl %edx
jg 0x1ca9
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %rsi
movslq %edx, %rax
imulq $0x4b4, %rax, %rdx      # imm = 0x4B4
movl 0x4b0(%rsi,%rdx), %edi
xorl %eax, %eax
cmpl $-0x1, %edi
je 0x1f84
cmpl $0x2, %edi
jl 0x1f5d
decl %edi
leaq (%rsi,%rdx), %r8
xorl %r9d, %r9d
xorl %ecx, %ecx
leaq (%r9,%r9,2), %r10
movl (%r8,%r10,4), %r11d
movl $0x1, %r10d
testl %r11d, %r11d
jle 0x1f50
addl %r10d, %r10d
decl %r11d
jne 0x1f48
addl %r10d, %ecx
incq %r9
cmpq %rdi, %r9
jne 0x1f35
jmp 0x1f61
xorl %ecx, %ecx
xorl %edi, %edi
addq %rdx, %rsi
leaq (%rdi,%rdi,2), %rdx
movl (%rsi,%rdx,4), %edx
testl %edx, %edx
jle 0x1f82
movl $0x1, %esi
movl %esi, %eax
leal (%rax,%rax), %esi
decl %edx
jne 0x1f74
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addl %ecx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x20, %edi
movl $0x84, %esi
callq 0x1298
leaq 0xe0f(%rip), %rdi       # 0x2014
movl %eax, %esi
xorl %eax, %eax
callq 0x1030
movl %eax, %ebx
movl $0x8, %edi
movl $0x40, %esi
callq 0x1298
leaq 0xdfe(%rip), %rdi       # 0x2024
movl %eax, %esi
xorl %eax, %eax
callq 0x1030
movl $0x41, %edi
movl $0x800, %esi            # imm = 0x800
callq 0x1298
leaq 0xded(%rip), %rdi       # 0x2032
movl %eax, %esi
xorl %eax, %eax
callq 0x1030
movl $0x20, %edi
movl $0x84, %esi
callq 0x1298
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 0xdbf(%rip), %rdi       # 0x2043
xorl %eax, %eax
callq 0x1030
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1352
movl %edx, %r14d
leaq 0xd3c(%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 0x134a
movl %edx, %r15d
leaq 0xd17(%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 0x134f
movl %edx, %ebx
leaq 0xcf1(%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 0x1352
movl %edx, %r8d
leaq 0xcca(%rip), %rdi       # 0x2004
movl %r15d, %esi
movl %eax, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1030
jmp 0x1352
movl %r14d, %ebx
jmp 0x1352
movl %r15d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x20, %rsp
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq 0x2dbe(%rip), %rdi      # 0x3fe0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %edx
movq 0x2da3(%rip), %rdi      # 0x3fe0
leaq -0x30(%rbp), %rsi
callq 0x10b0
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq 0x2d7b(%rip), %rdi      # 0x3fd0
callq 0x1080
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x1299
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x1070
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x12bc
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x1070
movq %rbx, %rdi
callq 0x10a0
// File: /workspace/github_cpp_makefile_star2_O1/lotuskip[P]yuxtapa/server/server.cpp
// Function: next_map_forced(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void next_map_forced(const string &loadmap)
{
	if(intermission && loadmap.empty())
		goto_next_map();
	else
		goto_intermission(loadmap);
}

// Assembly:
cmpb $0x1, 0x32c6d(%rip)     # 0x40410
jne 0xd7d2
cmpq $0x0, 0x8(%rdi)
jne 0xd7d2
pushq %rbp
movq %rsp, %rbp
movb $0x0, 0x32c59(%rip)     # 0x40410
movw $0x0, 0x33310(%rip)     # 0x40ad0
callq 0x1b0a0
leaq 0x332f4(%rip), %rdi     # 0x40ac0
popq %rbp
jmp 0x2b2dc