LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: manschga[P]M5GB/other_fct.cpp
// Function: isDivisible(std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&)
bool isDivisible(const vector<int>& term, const vector<int>& divisor)
{
  /*
  if (term.size() != divisor.size())
    {
      cout << "term size: " << term.size() << endl;
      cout << "divisor size: " << divisor.size() << endl;
      cout << "Error!" << endl;
    }
  */
  int n = term.size();
  for (int i = 0; i < n; ++i)
    {
      if(term[i] < divisor[i])
	{
	  return false;
	}
    }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3260
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x58e7
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x5fd0
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x5fd0
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl (%rcx), %eax
jge 0x58da
movb $0x0, -0x1(%rbp)
jmp 0x58eb
jmp 0x58dc
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x58a3
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: manschga[P]M5GB/other_fct.cpp
// Function: next_term(std::vector<int, std::allocator<int>>&)
void next_term(vector<int>& term) //degree revers lex, change if needed!
{
  //get degree
  int degree = 0;
  for (int i = 0; i < term.size(); ++i)
    {
      degree += term[i];
    }
  if (degree == 0) //term = 1
    {
      term[term.size()-1] = 1; //new term = x_n
      return;
    }
  //get frist non-zero entry which is not x_1
  int non_zero_idx = 0;
  for (int i = 1; i < term.size(); ++i)
    {
      if (term[i] > 0)
	{
	  non_zero_idx = i;
	  break;
	}
    }
  if (non_zero_idx == 0)//term = x_1^degree
    {
      term[0] = 0;
      term[term.size()-1] = degree+1; //new term = x_n^(degree+1)
      return;
    }
  int temp = term[0];
  term[0] = 0;
  term[non_zero_idx] --;
  term[non_zero_idx-1] ++;
  term[non_zero_idx-1] += temp;

      //}

  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3260
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x5cf7
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0x3280
movl (%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5cba
cmpl $0x0, -0xc(%rbp)
jne 0x5d29
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3260
movq -0x30(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x3280
movl $0x1, (%rax)
jmp 0x5e36
movl $0x0, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movslq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3260
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x5d7b
movq -0x8(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x3280
cmpl $0x0, (%rax)
jle 0x5d6e
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x5d7b
jmp 0x5d70
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5d37
cmpl $0x0, -0x14(%rbp)
jne 0x5dc5
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3280
movl $0x0, (%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3260
movq -0x48(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x3280
movl -0x3c(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x5e36
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3280
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3280
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3280
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x3280
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x3280
movl -0x4c(%rbp), %ecx
addl (%rax), %ecx
movl %ecx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: manschga[P]M5GB/lab_poly.cpp
// Function: spol(Lab_poly const&, Lab_poly const&)
Lab_poly spol(const Lab_poly& F, const Lab_poly& G)
{
  pair<int,vector<int>> u,v;
  //cout << "in spol-comp!" << endl;
  lcm(u,F.Get_LM(),v,G.Get_LM());
  return F.Multiply(u.second).Multiply(u.first,true) - G.Multiply(v.second).Multiply(v.first,true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x158(%rbp)
movq %rdi, %rax
movq %rax, -0x150(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xb8f0
leaq -0x58(%rbp), %rdi
callq 0xb8f0
jmp 0x9eec
movq -0x10(%rbp), %rdi
callq 0xb930
movq %rax, -0x160(%rbp)
jmp 0x9efe
movq -0x18(%rbp), %rdi
callq 0xb930
movq %rax, -0x168(%rbp)
jmp 0x9f10
movq -0x168(%rbp), %rcx
movq -0x160(%rbp), %rsi
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x26090
jmp 0x9f2d
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0xd8(%rbp), %rdi
callq 0xb960
jmp 0x9f43
movl -0x38(%rbp), %edx
leaq -0xa0(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
movl $0x1, %ecx
callq 0xba10
jmp 0x9f60
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0x148(%rbp), %rdi
callq 0xb960
jmp 0x9f76
movl -0x58(%rbp), %edx
leaq -0x110(%rbp), %rdi
leaq -0x148(%rbp), %rsi
movl $0x1, %ecx
callq 0xba10
jmp 0x9f93
movq -0x158(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
leaq -0x110(%rbp), %rdx
callq 0xbb80
jmp 0x9faf
leaq -0x110(%rbp), %rdi
callq 0xbc80
leaq -0x148(%rbp), %rdi
callq 0xbc80
leaq -0xa0(%rbp), %rdi
callq 0xbc80
leaq -0xd8(%rbp), %rdi
callq 0xbc80
leaq -0x58(%rbp), %rdi
callq 0xbca0
leaq -0x38(%rbp), %rdi
callq 0xbca0
movq -0x150(%rbp), %rax
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xa08c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xa083
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xa077
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xa06b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xa05f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x110(%rbp), %rdi
callq 0xbc80
leaq -0x148(%rbp), %rdi
callq 0xbc80
leaq -0xa0(%rbp), %rdi
callq 0xbc80
leaq -0xd8(%rbp), %rdi
callq 0xbc80
leaq -0x58(%rbp), %rdi
callq 0xbca0
leaq -0x38(%rbp), %rdi
callq 0xbca0
movq -0x60(%rbp), %rdi
callq 0x2300
nop
// File: manschga[P]M5GB/lab_poly.cpp
// Function: spair(Lab_poly const&, Lab_poly const&)
pair<Lab_poly,Lab_poly> spair(const Lab_poly& F, const Lab_poly& G)
{
  #ifdef Null
  cout << "Spair construction: " << endl;
  cout << "F: " << F << endl;
  cout << "G: " << G << endl;
  #endif
  pair<int,vector<int>> u,v;
  //  monomial u,v;
  lcm(u,F.Get_LM(),v,G.Get_LM());
  //for case p = 2 works, else need coeff!
  #ifdef Null
  cout << "uF: " << F.Multiply(u.second).Multiply(u.first,true);
  cout << "vG:"  << G.Multiply(v.second).Multiply(v.first,true);
  #endif
  return make_pair(F.Multiply(u.second).Multiply(u.first,true),G.Multiply(v.second).Multiply(v.first,true));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x158(%rbp)
movq %rdi, %rax
movq %rax, -0x150(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xb8f0
leaq -0x58(%rbp), %rdi
callq 0xb8f0
jmp 0xa0dc
movq -0x10(%rbp), %rdi
callq 0xb930
movq %rax, -0x160(%rbp)
jmp 0xa0ee
movq -0x18(%rbp), %rdi
callq 0xb930
movq %rax, -0x168(%rbp)
jmp 0xa100
movq -0x168(%rbp), %rcx
movq -0x160(%rbp), %rsi
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x26090
jmp 0xa11d
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0xd8(%rbp), %rdi
callq 0xb960
jmp 0xa133
movl -0x38(%rbp), %edx
leaq -0xa0(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
movl $0x1, %ecx
callq 0xba10
jmp 0xa150
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0x148(%rbp), %rdi
callq 0xb960
jmp 0xa166
movl -0x58(%rbp), %edx
leaq -0x110(%rbp), %rdi
leaq -0x148(%rbp), %rsi
movl $0x1, %ecx
callq 0xba10
jmp 0xa183
movq -0x158(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
leaq -0x110(%rbp), %rdx
callq 0xbcc0
jmp 0xa19f
leaq -0x110(%rbp), %rdi
callq 0xbc80
leaq -0x148(%rbp), %rdi
callq 0xbc80
leaq -0xa0(%rbp), %rdi
callq 0xbc80
leaq -0xd8(%rbp), %rdi
callq 0xbc80
leaq -0x58(%rbp), %rdi
callq 0xbca0
leaq -0x38(%rbp), %rdi
callq 0xbca0
movq -0x150(%rbp), %rax
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xa27c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xa273
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xa267
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xa25b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xa24f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x110(%rbp), %rdi
callq 0xbc80
leaq -0x148(%rbp), %rdi
callq 0xbc80
leaq -0xa0(%rbp), %rdi
callq 0xbc80
leaq -0xd8(%rbp), %rdi
callq 0xbc80
leaq -0x58(%rbp), %rdi
callq 0xbca0
leaq -0x38(%rbp), %rdi
callq 0xbca0
movq -0x60(%rbp), %rdi
callq 0x2300
nop
// File: manschga[P]M5GB/lab_poly.cpp
// Function: poly(std::vector<Lab_poly, std::allocator<Lab_poly>> const&)
vector<polynomial> poly(const vector<Lab_poly>& G)
{
  vector<polynomial> basis = {};
  for (int g = 0; g < G.size(); ++g)
    {
      basis.emplace_back(G[g].Get_poly());
    }
  return basis;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x20e0
movq -0x30(%rbp), %rdi
callq 0xbd00
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbd20
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0xa336
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0xbdd0
movq %rax, %rdi
callq 0xb8c0
movq %rax, -0x48(%rbp)
jmp 0xa303
movq -0x48(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0xbd50
jmp 0xa312
jmp 0xa314
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xa2cb
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3300
jmp 0xa353
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xa349
movq -0x30(%rbp), %rdi
callq 0x3300
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2300
nopl (%rax)
// File: manschga[P]M5GB/lab_poly.cpp
// Function: Smaller_pair(std::pair<Lab_poly, Lab_poly> const&, std::pair<Lab_poly, Lab_poly> const&)
bool Smaller_pair(const pair<Lab_poly,Lab_poly>& one, const pair<Lab_poly,Lab_poly>& two)
{
  if (one.first.Get_sign() == two.first.Get_sign())
    {
      if (one.second.Get_sign() == two.second.Get_sign())
	{
	  return (one.second.Get_sign() < two.second.Get_sign());
	}
    }
  //else
  return (one.first.Get_sign() < two.first.Get_sign());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb8d0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb8d0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0xbe50
testb $0x1, %al
jne 0xa418
jmp 0xa47b
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0xb8d0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0xb8d0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0xbe50
testb $0x1, %al
jne 0xa448
jmp 0xa479
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0xb8d0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0xb8d0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xbea0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xa4a2
jmp 0xa47b
movq -0x10(%rbp), %rdi
callq 0xb8d0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb8d0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xbea0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: manschga[P]M5GB/./lab_poly.h
// Function: Lab_poly::Multiply(int, bool) const
Lab_poly Multiply(const int t, bool is_constant) const //multiply with constant / term
  {
    if (is_constant) //mutliply with constant
      {
	return Lab_poly(this->_poly.Multiply(t,is_constant),this->_signature);
      }
    else //multiply with term
      {
	return Lab_poly(this->_poly.Multiply(t,is_constant),this->_signature.Multiply(t));
      }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa8(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
testb $0x1, -0x15(%rbp)
je 0xbac3
movq -0x98(%rbp), %rsi
movl -0x14(%rbp), %edx
movzbl -0x15(%rbp), %ecx
andl $0x1, %ecx
leaq -0x38(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xd4a0
movq -0x98(%rbp), %rax
movq -0xa8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movups 0x20(%rax), %xmm0
movaps %xmm0, -0x50(%rbp)
movl -0x50(%rbp), %edx
movq -0x48(%rbp), %rcx
callq 0x9d90
jmp 0xba9b
leaq -0x38(%rbp), %rdi
callq 0x44a0
jmp 0xbb5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x44a0
jmp 0xbb6b
movq -0x98(%rbp), %rsi
movl -0x14(%rbp), %edx
movzbl -0x15(%rbp), %ecx
andl $0x1, %ecx
leaq -0x80(%rbp), %rdi
callq 0xd4a0
movq -0x98(%rbp), %rdi
addq $0x20, %rdi
movslq -0x14(%rbp), %rsi
callq 0xd5a0
movq %rdx, -0xc0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0xbb00
movq -0xa8(%rbp), %rdi
movq -0xc0(%rbp), %rax
movl -0xb4(%rbp), %ecx
movl %ecx, -0x90(%rbp)
movq %rax, -0x88(%rbp)
movl -0x90(%rbp), %edx
movq -0x88(%rbp), %rcx
leaq -0x80(%rbp), %rsi
callq 0x9d90
jmp 0xbb39
leaq -0x80(%rbp), %rdi
callq 0x44a0
jmp 0xbb5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x44a0
jmp 0xbb6b
movq -0xa0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
nop
// File: manschga[P]M5GB/./lab_poly.h
// Function: Lab_poly::operator-(Lab_poly const&) const
Lab_poly operator-(const Lab_poly& G) const
  {
     
    //create new polynomial poly(F) - poly(G)
    polynomial new_poly = this->_poly - G._poly;
    //create new signature max(S(F),S(G))
    signature new_signature = max(this->_signature,G._signature);
    
    return Lab_poly(new_poly,new_signature);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xa0(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0xd790
movq -0xa0(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
callq 0x2a400
movq %rax, -0x98(%rbp)
jmp 0xbbe1
movq -0x98(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x50(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xd980
jmp 0xbbfe
movq -0xb0(%rbp), %rdi
movaps -0x50(%rbp), %xmm0
movaps %xmm0, -0x90(%rbp)
movl -0x90(%rbp), %edx
movq -0x88(%rbp), %rcx
leaq -0x80(%rbp), %rsi
callq 0x9d90
jmp 0xbc28
leaq -0x80(%rbp), %rdi
callq 0x44a0
leaq -0x38(%rbp), %rdi
callq 0x44a0
movq -0xa8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xbc6d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x44a0
leaq -0x38(%rbp), %rdi
callq 0x44a0
movq -0x58(%rbp), %rdi
callq 0x2300
nop
// File: manschga[P]M5GB/./poly.h
// Function: polynomial::Multiply(std::vector<int, std::allocator<int>> const&) const
polynomial Multiply(const term_vec& t) const//multiply with term t in vector formulation
  {
    vector<monomial> mons = this->_monomials;
    for (int i = 0; i < mons.size(); ++i)
      {
	//cout << "multiplication takes place!" << endl;
	mons[i] = mons[i].Multiply(t); //is_constant
	//determines whether term or constant multiplication
      }
    return polynomial(mons);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xd190
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xc4b0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0xd084
movslq -0x34(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xd280
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0xd2a0
movq %rdx, -0x80(%rbp)
movq %rax, -0x78(%rbp)
jmp 0xd036
movq -0x80(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq %rax, -0x40(%rbp)
movslq -0x34(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xd280
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xcff6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x44c0
jmp 0xd0a9
movq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x25f60
jmp 0xd093
leaq -0x30(%rbp), %rdi
callq 0x44c0
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: manschga[P]M5GB/./signature.h
// Function: signature::Multiply(std::vector<int, std::allocator<int>> const&) const
signature Multiply(const term_vec& t) const//multiply with term t in vector formulation
{
  term_int result = this->_term; //monomial in integer format
  for (int i = 0; i < t.size(); ++i)
	{
	  for (int j = 0; j < t[i]; ++j) //read up from mult table
	    {
	      result = table[result].second[i]; //multiply with x_i+1
	      // cout << "before term" << new_term[i] << endl;
	  //cout << "t[i]" << t[i] << endl;
	  //cout << "after term" << new_term[i] << endl;
	    }
	}
  return signature(result,this->_index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3260
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0xd167
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x5fd0
movq %rax, %rcx
movl -0x44(%rbp), %eax
cmpl (%rcx), %eax
jge 0xd15a
movq -0x28(%rbp), %rsi
leaq 0x330ad(%rip), %rdi     # 0x401e0
callq 0xd480
movq %rax, %rdi
addq $0x18, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x61c0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xd10b
jmp 0xd15c
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xd0e7
movq -0x38(%rbp), %rax
movl -0x28(%rbp), %esi
movl (%rax), %edx
leaq -0x10(%rbp), %rdi
callq 0x2a3a0
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: manschga[P]M5GB/./poly.h
// Function: monomial::Multiply(std::vector<int, std::allocator<int>> const&) const
monomial Multiply(const term_vec& t) const//multiply with term t in vector formulation
{
  /*
  cout << "new multiplication!" << endl;
  cout << "t in multply: " << endl;
  for (int i = 0; i < t.size(); ++i)
    {
      cout << t[i] << ",";
    }
  cout << endl;
  */
  int result = this->_term; //monomial in integer format
  for (int i = 0; i < t.size(); ++i)
	{
	  for (int j = 0; j < t[i]; ++j) //read up from mult table
	    {
	      //cout << "result before multiplication: " << result <<  endl;
	      result = table[result].second[i]; //multiply with x_i+1
	      //cout << "result after multiplication: " << result << endl;
	  // cout << "before term" << new_term[i] << endl;
	  //cout << "t[i]" << t[i] << endl;
	      //	  new_term[i] += t_vec[i];
	  //cout << "after term" << new_term[i] << endl;
	    }
	}
  return monomial(result,this->_coeff,this->_p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq (%rax), %rax
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movslq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3260
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0xd344
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x5fd0
movq %rax, %rcx
movl -0x44(%rbp), %eax
cmpl (%rcx), %eax
jge 0xd337
movslq -0x24(%rbp), %rsi
leaq 0x32ecf(%rip), %rdi     # 0x401e0
callq 0xd480
movq %rax, %rdi
addq $0x18, %rdi
movslq -0x28(%rbp), %rsi
callq 0x61c0
movq (%rax), %rax
movl %eax, -0x24(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xd2e9
jmp 0xd339
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xd2c5
movq -0x38(%rbp), %rax
movslq -0x24(%rbp), %rsi
movl 0x8(%rax), %edx
movl 0xc(%rax), %ecx
leaq -0x10(%rbp), %rdi
callq 0x25de0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: manschga[P]M5GB/./poly.h
// Function: polynomial::Multiply(int, bool) const
polynomial Multiply(const int t, bool is_constant) const//multiply with constant / term
      {
	//if (is_constant)
	//{
	    vector<monomial> mons = this->_monomials;
	    for (int i = 0; i < mons.size(); ++i)
	      {
		mons[i] = mons[i].Multiply(t,is_constant); //is_constant
		//determines whether term or constant multiplication
	      }
	    return polynomial(mons);
	    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xd190
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xc4b0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0xd571
movslq -0x34(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xd280
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
movzbl -0x15(%rbp), %edx
andl $0x1, %edx
callq 0xd630
movq %rdx, -0x80(%rbp)
movq %rax, -0x78(%rbp)
jmp 0xd523
movq -0x80(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq %rax, -0x40(%rbp)
movslq -0x34(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xd280
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xd4dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x44c0
jmp 0xd596
movq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x25f60
jmp 0xd580
leaq -0x30(%rbp), %rdi
callq 0x44c0
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x2300
nop
// File: manschga[P]M5GB/./poly.h
// Function: monomial::Multiply(long, bool) const
monomial Multiply(const term_int t, bool is_constant) const//multiply with constant / term, can remove table for constant case
{
  if (is_constant)//multiply with constant
    {
      return monomial(this->_term,(this->_coeff*t) % (this->_p),this->_p);
    }
  else {
    term_vec t_vec = table[t].first; //get vector repr of t
    term_int result = this->_term; //monomial in integer format
    for (int i = 0; i < t_vec.size(); ++i)
      {
	for (int j = 0; j < t_vec[i]; ++j) //read up from mult table
	  {
	    
	    result = table[result].second[i]; //multiply with x_i+1
	  }
      }
    return monomial(result,this->_coeff,this->_p);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %dl, %al
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
testb $0x1, -0x21(%rbp)
je 0xd686
movq -0x68(%rbp), %rcx
movq (%rcx), %rsi
movslq 0x8(%rcx), %rax
imulq -0x20(%rbp), %rax
movslq 0xc(%rcx), %rcx
cqto
idivq %rcx
movq -0x68(%rbp), %rax
movl 0xc(%rax), %ecx
leaq -0x10(%rbp), %rdi
callq 0x25de0
jmp 0xd76f
movq -0x20(%rbp), %rsi
leaq 0x32b4f(%rip), %rdi     # 0x401e0
callq 0xd480
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x5ff0
movq -0x68(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movslq -0x4c(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3260
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0xd734
movl $0x0, -0x50(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x74(%rbp)
movslq -0x4c(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x3280
movq %rax, %rcx
movl -0x74(%rbp), %eax
cmpl (%rcx), %eax
jge 0xd727
movq -0x48(%rbp), %rsi
leaq 0x32ae0(%rip), %rdi     # 0x401e0
callq 0xd480
movq %rax, %rdi
addq $0x18, %rdi
movslq -0x4c(%rbp), %rsi
callq 0x61c0
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0xd6d8
jmp 0xd729
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0xd6b4
movq -0x68(%rbp), %rax
movq -0x48(%rbp), %rsi
movl 0x8(%rax), %edx
movl 0xc(%rax), %ecx
leaq -0x10(%rbp), %rdi
callq 0x25de0
jmp 0xd74d
leaq -0x40(%rbp), %rdi
callq 0x3b70
jmp 0xd76f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3b70
jmp 0xd780
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x2300
nopl (%rax)
// File: manschga[P]M5GB/./poly.h
// Function: polynomial::operator-(polynomial const&) const
polynomial operator-(const polynomial& rhs) const
  {
    
    //construct -rhs and call f + -rhs
    vector<monomial> minus_mon_rhs = {};
    for (int i = 0; i < rhs.Get_monomials().size(); ++i)
      {
	minus_mon_rhs.emplace_back(monomial(rhs.Get_monomials()[i].Get_term(),(rhs.Get_p()-rhs.Get_monomials()[i].Get_coeff()) % rhs.Get_p(),rhs.Get_monomials()[i].Get_p()));
      }
    polynomial minus_rhs(minus_mon_rhs);
    
    //cout << "succesful until subtraction!" << endl;
    return (*this + minus_rhs);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x20e0
leaq -0x30(%rbp), %rdi
callq 0xd9c0
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31f0
movq %rax, %rdi
callq 0xc4b0
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jae 0xd909
movq -0x18(%rbp), %rdi
callq 0x31f0
movq %rax, %rdi
movslq -0x34(%rbp), %rsi
callq 0x3200
movq %rax, %rdi
callq 0xda60
movq %rax, -0xa0(%rbp)
jmp 0xd835
movq -0x18(%rbp), %rdi
callq 0xb890
movl %eax, -0xa4(%rbp)
jmp 0xd846
movq -0x18(%rbp), %rdi
callq 0x31f0
movq %rax, %rdi
movslq -0x34(%rbp), %rsi
callq 0x3200
movq %rax, %rdi
callq 0x3220
movl %eax, -0xa8(%rbp)
jmp 0xd86b
movl -0xa8(%rbp), %ecx
movl -0xa4(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xb0(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb890
movl %eax, -0xac(%rbp)
jmp 0xd890
movl -0xac(%rbp), %ecx
movl -0xb0(%rbp), %eax
cltd
idivl %ecx
movl %edx, -0xb4(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31f0
movq %rax, %rdi
movslq -0x34(%rbp), %rsi
callq 0x3200
movq %rax, %rdi
callq 0xcfa0
movq -0xa0(%rbp), %rsi
movl -0xb4(%rbp), %edx
movl %eax, %ecx
leaq -0x48(%rbp), %rdi
callq 0x25de0
jmp 0xd8dc
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xd9e0
jmp 0xd8eb
jmp 0xd8ed
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xd7e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xd965
leaq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x25f60
jmp 0xd918
movq -0x80(%rbp), %rsi
movq -0x90(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0xda80
jmp 0xd92e
leaq -0x78(%rbp), %rdi
callq 0x44a0
leaq -0x30(%rbp), %rdi
callq 0x44c0
movq -0x88(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x44a0
leaq -0x30(%rbp), %rdi
callq 0x44c0
movq -0x50(%rbp), %rdi
callq 0x2300
nopw (%rax,%rax)
// File: manschga[P]M5GB/./poly.h
// Function: monomial::operator<(monomial const&) const
bool operator < (const monomial &rhs) const
  {
    if (this->_term < rhs._term)
    {
      return true;
      }
    if (this->_term == rhs._term)
      {
	//same terms
	return (this->_coeff < rhs._coeff);
      }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jge 0xf166
movb $0x1, -0x1(%rbp)
jmp 0xf192
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xf18e
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xf192
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: manschga[P]M5GB/M5GB.cpp
// Function: Syzygy(signature const&, std::vector<std::vector<long, std::allocator<long>>, std::allocator<std::vector<long, std::allocator<long>>>> const&)
bool Syzygy(const signature& sign, const Syzygies& H)
{
  int i = sign.Get_index();
  //  int sign_term = S.Get_term();
  //checks if S is known syzygy, order H by term, then faster!
  for (auto it = H[i].begin(); it != H[i].end(); ++it)
    {
      if (*it == sign.Get_term()) //fast check, if H > S then H does not divide S
	{
	  return true;
	}
    }
  for (auto it = H[i].begin(); it != H[i].end(); ++it)
    {
      if (*it < sign.Get_term()) //fast check, if H > S then H does not divide S
	{
	  if (isDivisible(table[sign.Get_term()].first,table[*it].first)) //look it up or faster by memory?
	    {
	      //cout << "signature H_i: " << H[i] << endl;
	      //cout << "signature from Spol: " << S << endl;
	      return true;
	    }
	}
    }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x170b0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x173f0
movq %rax, %rdi
callq 0x6900
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x173f0
movq %rax, %rdi
callq 0x6930
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x17410
testb $0x1, %al
jne 0x116f1
jmp 0x1172c
leaq -0x28(%rbp), %rdi
callq 0x17450
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16b30
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jne 0x1171f
movb $0x1, -0x1(%rbp)
jmp 0x117fb
jmp 0x11721
leaq -0x28(%rbp), %rdi
callq 0x17470
jmp 0x116c5
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x173f0
movq %rax, %rdi
callq 0x6900
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x173f0
movq %rax, %rdi
callq 0x6930
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x17410
testb $0x1, %al
jne 0x11774
jmp 0x117f7
leaq -0x38(%rbp), %rdi
callq 0x17450
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16b30
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jge 0x117e7
movq -0x10(%rbp), %rdi
callq 0x16b30
movq %rax, %rsi
leaq 0x2ea34(%rip), %rdi     # 0x401e0
callq 0xd480
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x17450
movq (%rax), %rsi
leaq 0x2ea18(%rip), %rdi     # 0x401e0
callq 0xd480
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x5880
testb $0x1, %al
jne 0x117df
jmp 0x117e5
movb $0x1, -0x1(%rbp)
jmp 0x117fb
jmp 0x117e7
jmp 0x117e9
leaq -0x38(%rbp), %rdi
callq 0x17470
jmp 0x11745
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: manschga[P]M5GB/M5GB.cpp
// Function: Update_syz(Lab_poly const&)
void Update_syz(const Lab_poly& Spol)
{
  for (auto& it : LT_G) 
    {
      //cout << "update syz" << Spol.Get_sign().Multiply(it.first) << it.second.Multiply(Spol.Get_LT())<< endl;
      signature temp = max(Spol.Get_sign().Multiply(it.first),it.second.Multiply(Spol.Get_LT()));
      H[temp.Get_index()].emplace_back(temp.Get_term());
    }
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2d89d(%rip), %rax     # 0x402c0
movq %rax, -0x10(%rbp)
leaq 0x2d892(%rip), %rdi     # 0x402c0
callq 0x16ff0
movq %rax, -0x18(%rbp)
leaq 0x2d882(%rip), %rdi     # 0x402c0
callq 0x17020
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x17050
testb $0x1, %al
jne 0x12a5d
jmp 0x12b11
leaq -0x18(%rbp), %rdi
callq 0x17080
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0xb8d0
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0xd5a0
movl %eax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16d80
movq -0x70(%rbp), %rdi
movslq %eax, %rsi
callq 0xd5a0
movl %eax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2a400
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x170b0
movslq %eax, %rsi
leaq 0x2d9d8(%rip), %rdi     # 0x404b8
callq 0x61a0
movq %rax, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x16b30
movq -0x68(%rbp), %rdi
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x7750
leaq -0x18(%rbp), %rdi
callq 0x17140
jmp 0x12a47
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: manschga[P]M5GB/M5GB.cpp
// Function: Add_to_M(Lab_poly const&)
void Add_to_M(const Lab_poly& F)
{
  term_int LT = F.Get_LT();
  M_conv[LT] = make_pair(table[LT].first,F.Get_sign());
  M.erase(LT);
  M[LT] = F.Get_poly();
  Generations_M.erase(LT);
  Generations_M[LT] = G_.size();
  Flags_M.erase(LT);
  Flags_M[LT] = Create_Flag(F.Get_poly());
  LT_M.erase(LT);
  LT_M[LT] = F.Get_sign();
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16d80
cltq
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x2d0d7(%rip), %rdi     # 0x401e0
callq 0xd480
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
callq 0xb8d0
movq -0x68(%rbp), %rsi
movq %rax, %rdx
leaq -0x38(%rbp), %rdi
callq 0x16e00
leaq 0x2d156(%rip), %rdi     # 0x40288
leaq -0x10(%rbp), %rsi
callq 0x16e40
movq %rax, -0x60(%rbp)
jmp 0x13141
movq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x16e70
leaq -0x38(%rbp), %rdi
callq 0x16eb0
leaq 0x2d20a(%rip), %rdi     # 0x40368
leaq -0x10(%rbp), %rsi
callq 0x16ed0
movq -0x8(%rbp), %rdi
callq 0xb8c0
movq %rax, -0x80(%rbp)
leaq 0x2d1ed(%rip), %rdi     # 0x40368
leaq -0x10(%rbp), %rsi
callq 0x16f00
movq -0x80(%rbp), %rsi
movq %rax, %rdi
callq 0xb850
leaq 0x2d2b1(%rip), %rdi     # 0x40448
leaq -0x10(%rbp), %rsi
callq 0x16f30
leaq 0x2d189(%rip), %rdi     # 0x40330
callq 0x16cc0
movl %eax, -0x74(%rbp)
leaq 0x2d292(%rip), %rdi     # 0x40448
leaq -0x10(%rbp), %rsi
callq 0x16f60
movl -0x74(%rbp), %ecx
movl %ecx, (%rax)
leaq 0x2d20d(%rip), %rdi     # 0x403d8
leaq -0x10(%rbp), %rsi
callq 0x16f90
movq -0x8(%rbp), %rdi
callq 0xb8c0
movq %rax, %rdi
callq 0x13600
movl %eax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
leaq 0x2d1e5(%rip), %rdi     # 0x403d8
leaq -0x10(%rbp), %rsi
callq 0x16fc0
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
leaq 0x2d0e6(%rip), %rdi     # 0x402f8
leaq -0x10(%rbp), %rsi
callq 0x16f90
movq -0x8(%rbp), %rdi
callq 0xb8d0
movq %rax, -0x70(%rbp)
leaq 0x2d0c9(%rip), %rdi     # 0x402f8
leaq -0x10(%rbp), %rsi
callq 0x16fc0
movq -0x70(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x16eb0
movq -0x40(%rbp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
// File: manschga[P]M5GB/M5GB.cpp
// Function: Add_to_G(Lab_poly const&)
void Add_to_G(const Lab_poly& F)
{
  term_int LT = F.Get_LT();
  G_conv[LT] = make_pair(table[LT].first,F.Get_sign());
  G_[LT] = F.Get_poly();
  Generations_G[LT] = G_.size();
  LT_G[LT] = F.Get_sign();
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16d80
cltq
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x2cf3a(%rip), %rdi     # 0x401e0
callq 0xd480
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
callq 0xb8d0
movq -0x58(%rbp), %rsi
movq %rax, %rdx
leaq -0x38(%rbp), %rdi
callq 0x16e00
leaq 0x2cf81(%rip), %rdi     # 0x40250
leaq -0x10(%rbp), %rsi
callq 0x16e40
movq %rax, -0x50(%rbp)
jmp 0x132de
movq -0x50(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x16e70
leaq -0x38(%rbp), %rdi
callq 0x16eb0
movq -0x8(%rbp), %rdi
callq 0xb8c0
movq %rax, -0x70(%rbp)
leaq 0x2d028(%rip), %rdi     # 0x40330
leaq -0x10(%rbp), %rsi
callq 0x16f00
movq -0x70(%rbp), %rsi
movq %rax, %rdi
callq 0xb850
leaq 0x2d00c(%rip), %rdi     # 0x40330
callq 0x16cc0
movl %eax, -0x64(%rbp)
leaq 0x2d0dd(%rip), %rdi     # 0x40410
leaq -0x10(%rbp), %rsi
callq 0x16f60
movl -0x64(%rbp), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
callq 0xb8d0
movq %rax, -0x60(%rbp)
leaq 0x2cf6b(%rip), %rdi     # 0x402c0
leaq -0x10(%rbp), %rsi
callq 0x16fc0
movq -0x60(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x16eb0
movq -0x40(%rbp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
// File: manschga[P]M5GB/M5GB.cpp
// Function: Poly(std::unordered_map<long, polynomial, std::hash<long>, std::equal_to<long>, std::allocator<std::pair<long const, polynomial>>> const&, int, int)
vector<polynomial> Poly(const Basis& G, int n, int p)
{
  vector<polynomial> G_poly = {};
  G_poly.reserve(G_.size());// = {};
  for (auto it : G_) 
    {
      G_poly.emplace_back(it.second);
    }
  return G_poly;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0xbd00
leaq 0x2cf4e(%rip), %rdi     # 0x40330
callq 0x16cc0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x17dc0
jmp 0x133f5
leaq 0x2cf34(%rip), %rax     # 0x40330
movq %rax, -0x38(%rbp)
leaq 0x2cf29(%rip), %rdi     # 0x40330
callq 0x17ec0
movq %rax, -0x40(%rbp)
leaq 0x2cf19(%rip), %rdi     # 0x40330
callq 0x17ef0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x17f20
testb $0x1, %al
jne 0x13433
jmp 0x13492
leaq -0x40(%rbp), %rdi
callq 0x17f50
movq %rax, %rsi
leaq -0x70(%rbp), %rdi
callq 0x17f80
jmp 0x1344a
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x17fc0
jmp 0x13459
leaq -0x70(%rbp), %rdi
callq 0x18040
leaq -0x40(%rbp), %rdi
callq 0x18060
jmp 0x13420
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x134b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x18040
jmp 0x134b2
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x134a5
movq -0x78(%rbp), %rdi
callq 0x3300
movq -0x80(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x3300
movq -0x28(%rbp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
// File: manschga[P]M5GB/M5GB.cpp
// Function: Interreduce(std::vector<polynomial, std::allocator<polynomial>>&)
void Interreduce(vector<polynomial>& system)
{
  int size = 0;
  int size_before = 1;
  while(size != size_before)
    {
      cout << "reduction step: " << system.size() << endl;
      size_before = system.size();
      int reductions = reduce(system); //get the (unique) reduced gröbner basis
      cout << "after reduce: " << system.size() << endl;
      size = system.size();//maybe the size drops
      number_of_reductions += reductions;
    }
  cout << "end of reduction!" << endl;
  //sort(system); //test if this speeds up
  reverse(system.begin(),system.end());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0x135a4
movq 0x2cadb(%rip), %rdi     # 0x3ffd8
leaq 0x17ee5(%rip), %rsi     # 0x2b3e9
callq 0x2190
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3180
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x2070
movq %rax, %rdi
movq 0x2ca9c(%rip), %rsi     # 0x3ffc8
callq 0x21d0
movq -0x8(%rbp), %rdi
callq 0x3180
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x26a30
movl %eax, -0x14(%rbp)
movq 0x2ca88(%rip), %rdi     # 0x3ffd8
leaq 0x17ea3(%rip), %rsi     # 0x2b3fa
callq 0x2190
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3180
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x2070
movq %rax, %rdi
movq 0x2ca49(%rip), %rsi     # 0x3ffc8
callq 0x21d0
movq -0x8(%rbp), %rdi
callq 0x3180
movl %eax, -0xc(%rbp)
movl -0x14(%rbp), %eax
addl 0x2cc8f(%rip), %eax     # 0x40228
movl %eax, 0x2cc89(%rip)     # 0x40228
jmp 0x134ea
movq 0x2ca2d(%rip), %rdi     # 0x3ffd8
leaq 0x17e57(%rip), %rsi     # 0x2b409
callq 0x2190
movq %rax, %rdi
movq 0x2ca07(%rip), %rsi     # 0x3ffc8
callq 0x21d0
movq -0x8(%rbp), %rdi
callq 0xfd40
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0xfb80
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x179a0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: manschga[P]M5GB/M5GB.cpp
// Function: Create_Flag(polynomial const&)
signature Create_Flag(const polynomial& f)
{
  signature flag(table.size(),m); //cheap workaround, infinite signature
  for (auto monom = ++f.Get_monomials().begin(); monom != f.Get_monomials().end(); ++monom) //leave out LT, need to stay at that datastructure, otherwise for-loop! (poss error source)
    {
      term_int t = monom->Get_term();
      if (Generations_T.find(t)->second < G_.size()) //only do something then
	flag = min(flag,Create_term_flag(t));
      else
	flag = min(flag,Flags_T.find(t)->second);
    }
  return flag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
leaq 0x2cbcd(%rip), %rdi     # 0x401e0
callq 0x30a0
movl %eax, %esi
movl 0x2cc00(%rip), %edx     # 0x40220
leaq -0x10(%rbp), %rdi
callq 0x2a3a0
movq -0x18(%rbp), %rdi
callq 0x31f0
movq %rax, %rdi
callq 0xc5c0
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xca80
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31f0
movq %rax, %rdi
callq 0xc5f0
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xc9f0
testb $0x1, %al
jne 0x13679
jmp 0x13745
leaq -0x20(%rbp), %rdi
callq 0x173d0
movq %rax, %rdi
callq 0xda60
movq %rax, -0x38(%rbp)
leaq 0x2cdeb(%rip), %rdi     # 0x40480
leaq -0x38(%rbp), %rsi
callq 0x17220
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x17250
movslq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
leaq 0x2cc76(%rip), %rdi     # 0x40330
callq 0x16cc0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x136f9
movq -0x38(%rbp), %rdi
callq 0x13a00
movl %eax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2a490
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x13735
leaq 0x2cca0(%rip), %rdi     # 0x403a0
leaq -0x38(%rbp), %rsi
callq 0x17170
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x171a0
movq %rax, %rsi
addq $0x8, %rsi
leaq -0x10(%rbp), %rdi
callq 0x2a490
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x13737
leaq -0x20(%rbp), %rdi
callq 0xca80
jmp 0x1364e
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: manschga[P]M5GB/M5GB.cpp
// Function: Create_term_flag(long)
signature Create_term_flag(const term_int t)
{
  vector<int> t_ = table[t].first;
  signature flag(table.size(),m); //cheap workaround, infinite signature
  for (auto& it : G_conv)
    {
      if (isDivisible(t_,it.second.first))//compute function to get remainder straight
	{
	  signature candidate = it.second.second.Multiply(get_remainder(t_, it.second.first));//if divisor divides term, then term = divisor*remainder;
	  flag = min(flag,candidate);
	}
    }
  return flag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x2c7c6(%rip), %rdi     # 0x401e0
movq %rdi, -0xc0(%rbp)
callq 0xd480
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x5ff0
movq -0xc0(%rbp), %rdi
callq 0x30a0
movl %eax, %esi
movl 0x2c7da(%rip), %edx     # 0x40220
leaq -0x10(%rbp), %rdi
callq 0x2a3a0
jmp 0x13a51
leaq 0x2c7f8(%rip), %rax     # 0x40250
movq %rax, -0x48(%rbp)
leaq 0x2c7ed(%rip), %rdi     # 0x40250
callq 0x172e0
movq %rax, -0x50(%rbp)
leaq 0x2c7dd(%rip), %rdi     # 0x40250
callq 0x17310
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x17340
testb $0x1, %al
jne 0x13a92
jmp 0x13c0e
leaq -0x50(%rbp), %rdi
callq 0x17370
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rsi
addq $0x8, %rsi
leaq -0x30(%rbp), %rdi
callq 0x5880
movb %al, -0xc1(%rbp)
jmp 0x13ab8
movb -0xc1(%rbp), %al
testb $0x1, %al
jne 0x13ac7
jmp 0x13bfe
movq -0x60(%rbp), %rax
addq $0x20, %rax
movq %rax, -0xd0(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5ff0
jmp 0x13ae8
movq -0x60(%rbp), %rsi
addq $0x8, %rsi
leaq -0xb8(%rbp), %rdi
callq 0x5ff0
jmp 0x13afe
leaq -0x88(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0x262f0
jmp 0x13b1a
movq -0xd0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xd0c0
movq %rdx, -0xe0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x13b3c
movq -0xe0(%rbp), %rax
movl -0xd4(%rbp), %ecx
movl %ecx, -0x70(%rbp)
movq %rax, -0x68(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x3b70
leaq -0xb8(%rbp), %rdi
callq 0x3b70
leaq -0xa0(%rbp), %rdi
callq 0x3b70
leaq -0x10(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2a490
movq %rax, -0xe8(%rbp)
jmp 0x13b8a
movq -0xe8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x13bfe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x13c27
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x13bf0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x13be4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x3b70
leaq -0xb8(%rbp), %rdi
callq 0x3b70
leaq -0xa0(%rbp), %rdi
callq 0x3b70
jmp 0x13c27
jmp 0x13c00
leaq -0x50(%rbp), %rdi
callq 0x173a0
jmp 0x13a7c
leaq -0x30(%rbp), %rdi
callq 0x3b70
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x3b70
movq -0x38(%rbp), %rdi
callq 0x2300
nopl (%rax)
// File: manschga[P]M5GB/M5GB.cpp
// Function: First_Buchberger(std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&)
bool First_Buchberger(const vector<int>& LT_F, const vector<int>& LT_G)
{
  int n = LT_F.size();
  for (int i = 0; i < n; ++i)
    {
      if (LT_F[i] > 0 && LT_G[i] > 0)
	{
	  return false;
	}
    }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3260
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x151c2
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x5fd0
cmpl $0x0, (%rax)
jle 0x151b5
movq -0x18(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x5fd0
cmpl $0x0, (%rax)
jle 0x151b5
movb $0x0, -0x1(%rbp)
jmp 0x151c6
jmp 0x151b7
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x15183
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)