LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: manschga[P]M5GB/M5GB.cpp
// Function: Basic_poly(std::vector<polynomial, std::allocator<polynomial>> const&, int)
vector<Lab_poly> Basic_poly(const vector<polynomial>& system_, int n)
{
  vector<Lab_poly> F = {};
  F.reserve(m);//(m);
  for (int i = 0; i < m; i++)
    {
      #ifdef LTPOT
      Lab_poly F_i(system_[i],signature(system_[i].Get_LT(),i));
      #endif
      #ifdef DPOT
      Lab_poly F_i(system_[i],signature(0,i));
      #endif
      //Lab_poly F_i(system_[i],signature(0,i)); -> is worse by a test!
      F.emplace_back(F_i);
    }
  return F;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x17a60
movq -0x98(%rbp), %rdi
movslq 0x2aca4(%rip), %rsi     # 0x40220
callq 0x17a80
jmp 0x15583
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl 0x2ac8d(%rip), %eax     # 0x40220
jge 0x15672
movq -0x10(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x17b80
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
callq 0xd980
jmp 0x155b4
movq -0x10(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x17b80
movq %rax, %rdi
callq 0x17490
movl %eax, -0xa4(%rbp)
jmp 0x155d1
movl -0xa4(%rbp), %esi
movl -0x28(%rbp), %edx
leaq -0x90(%rbp), %rdi
callq 0x2a3a0
jmp 0x155e8
movl -0x90(%rbp), %edx
movq -0x88(%rbp), %rcx
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x9d90
jmp 0x15604
leaq -0x80(%rbp), %rdi
callq 0x44a0
movq -0x98(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x17ba0
jmp 0x1561f
leaq -0x60(%rbp), %rdi
callq 0xbc80
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1558a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x15698
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x44a0
jmp 0x15698
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xbc80
jmp 0x15698
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x15688
movq -0x98(%rbp), %rdi
callq 0x17940
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x17940
movq -0x20(%rbp), %rdi
callq 0x2300
nopl (%rax)
// File: manschga[P]M5GB/M5GB.cpp
// Function: Init_LT_G(std::vector<Lab_poly, std::allocator<Lab_poly>> const&)
void Init_LT_G(const vector<Lab_poly> & F)
{
  for (auto it = F.begin(); it != F.end(); ++it)
    {
      LT_G[it->Get_LT()] = it->Get_sign();
      G_conv[it->Get_LT()] = make_pair(table[it->Get_LT()].first,it->Get_sign());
      M_conv[it->Get_LT()] = make_pair(table[it->Get_LT()].first,it->Get_sign());
    }
  //return LT_G;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x17c20
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x17c90
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x17c50
testb $0x1, %al
jne 0x156ef
jmp 0x158f7
leaq -0x10(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x17cc0
movq %rax, %rdi
callq 0xb8d0
movq -0xa0(%rbp), %rdi
movq %rax, -0xb0(%rbp)
callq 0x17cc0
movq %rax, %rdi
callq 0x16d80
cltq
movq %rax, -0x20(%rbp)
leaq 0x2ab91(%rip), %rdi     # 0x402c0
leaq -0x20(%rbp), %rsi
callq 0x172b0
movq -0xb0(%rbp), %rcx
movq -0xa0(%rbp), %rdi
movups (%rcx), %xmm0
movups %xmm0, (%rax)
callq 0x17cc0
movq %rax, %rdi
callq 0x16d80
movslq %eax, %rsi
leaq 0x2aa7d(%rip), %rdi     # 0x401e0
callq 0xd480
movq -0xa0(%rbp), %rdi
movq %rax, -0xa8(%rbp)
callq 0x17cc0
movq %rax, %rdi
callq 0xb8d0
movq -0xa8(%rbp), %rsi
movq %rax, %rdx
leaq -0x48(%rbp), %rdi
callq 0x16e00
movq -0xa0(%rbp), %rdi
callq 0x17cc0
movq %rax, %rdi
callq 0x16d80
movl %eax, -0x94(%rbp)
jmp 0x157b2
movl -0x94(%rbp), %eax
cltq
movq %rax, -0x50(%rbp)
leaq 0x2aa8b(%rip), %rdi     # 0x40250
leaq -0x50(%rbp), %rsi
callq 0x18090
movq %rax, -0xb8(%rbp)
jmp 0x157d7
movq -0xb8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movq %rsi, -0xd8(%rbp)
callq 0x16e70
movq -0xd8(%rbp), %rdi
callq 0x16eb0
leaq -0x10(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x17cc0
movq %rax, %rdi
callq 0x16d80
movslq %eax, %rsi
leaq 0x2a9c4(%rip), %rdi     # 0x401e0
callq 0xd480
movq -0xc8(%rbp), %rdi
movq %rax, -0xd0(%rbp)
callq 0x17cc0
movq %rax, %rdi
callq 0xb8d0
movq -0xd0(%rbp), %rsi
movq %rax, %rdx
leaq -0x88(%rbp), %rdi
callq 0x16e00
movq -0xc8(%rbp), %rdi
callq 0x17cc0
movq %rax, %rdi
callq 0x16d80
movl %eax, -0xbc(%rbp)
jmp 0x1586e
movl -0xbc(%rbp), %eax
cltq
movq %rax, -0x90(%rbp)
leaq 0x2aa04(%rip), %rdi     # 0x40288
leaq -0x90(%rbp), %rsi
callq 0x18090
movq %rax, -0xe0(%rbp)
jmp 0x15899
movq -0xe0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x16e70
leaq -0x88(%rbp), %rdi
callq 0x16eb0
leaq -0x10(%rbp), %rdi
callq 0x17d10
jmp 0x156cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x16eb0
jmp 0x15900
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x16eb0
jmp 0x15900
addq $0xe0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x2300
nopl (%rax)
// File: manschga[P]M5GB/M5GB.cpp
// Function: Init_G(std::vector<Lab_poly, std::allocator<Lab_poly>> const&)
Basis Init_G(const vector<Lab_poly>& F)
{
  Basis G_ = {};
  for (auto it = F.begin(); it != F.end(); ++it)
    {
      G_[it->Get_LT()] = it->Get_poly(); //check: what if same LT in G_?
    }
  return G_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
xorl %esi, %esi
movl $0x38, %edx
callq 0x20e0
movq -0x48(%rbp), %rdi
callq 0x16900
movq -0x10(%rbp), %rdi
callq 0x17c20
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x17c90
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x17c50
testb $0x1, %al
jne 0x15971
jmp 0x159f0
leaq -0x20(%rbp), %rdi
callq 0x17cc0
movq %rax, %rdi
callq 0xb8c0
movq %rax, -0x58(%rbp)
jmp 0x15988
leaq -0x20(%rbp), %rdi
callq 0x17cc0
movq %rax, %rdi
callq 0x16d80
movl %eax, -0x5c(%rbp)
jmp 0x1599e
movq -0x48(%rbp), %rdi
movl -0x5c(%rbp), %eax
cltq
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x17ce0
movq %rax, -0x68(%rbp)
jmp 0x159ba
movq -0x58(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0xb850
jmp 0x159c9
jmp 0x159cb
leaq -0x20(%rbp), %rdi
callq 0x17d10
jmp 0x15951
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x16920
jmp 0x15a0d
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x15a03
movq -0x48(%rbp), %rdi
callq 0x16920
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
// File: manschga[P]M5GB/M5GB.cpp
// Function: Init_Syzygies(std::vector<Lab_poly, std::allocator<Lab_poly>> const&)
Syzygies Init_Syzygies(const vector<Lab_poly> &F)
{
  int k = F.size();
  Syzygies H(k);
  for (int i = 0; i < k; ++i)
    {
      H[i].reserve(i);
    }
  
  for (int i = 0; i < F.size(); ++i)
    {
      for (int j = i+1; j < F.size(); ++j)
	{
	  H[j].emplace_back(F[j].Multiply(F[i].Get_LT(),false).Get_sign().Get_term()); //should i do without LT? check after!
	}
    }
  return H;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbd20
movl %eax, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x16(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x6590
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
callq 0x18140
jmp 0x15e4f
leaq -0x16(%rbp), %rdi
callq 0x3880
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x15ebd
movq -0x88(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x61a0
movq %rax, %rdi
movslq -0x28(%rbp), %rsi
callq 0x181b0
jmp 0x15e85
jmp 0x15e87
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x15e5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x16(%rbp), %rdi
callq 0x3880
jmp 0x16031
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x16025
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbd20
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jae 0x15fff
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movslq -0x30(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbd20
movq %rax, %rcx
movq -0xa0(%rbp), %rax
cmpq %rcx, %rax
jae 0x15fef
movq -0x88(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x61a0
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0xbdd0
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0xbdd0
movq %rax, %rdi
callq 0x16d80
movl %eax, -0xa4(%rbp)
jmp 0x15f63
movl -0xa4(%rbp), %edx
movq -0xb0(%rbp), %rsi
leaq -0x70(%rbp), %rdi
xorl %ecx, %ecx
callq 0xba10
jmp 0x15f7d
leaq -0x70(%rbp), %rdi
callq 0xb8d0
movq %rax, -0xc0(%rbp)
jmp 0x15f8f
movq -0xc0(%rbp), %rdi
callq 0x16b30
movq %rax, -0xc8(%rbp)
jmp 0x15fa4
movq -0xb8(%rbp), %rdi
movq -0xc8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x7750
jmp 0x15fc1
leaq -0x70(%rbp), %rdi
callq 0xbc80
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x15ef4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xbc80
jmp 0x16025
jmp 0x15ff1
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x15ec4
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x16015
movq -0x88(%rbp), %rdi
callq 0x2fb0
movq -0x90(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x2fb0
movq -0x20(%rbp), %rdi
callq 0x2300
nopw (%rax,%rax)
// File: manschga[P]M5GB/M5GB.cpp
// Function: Create_basis(std::vector<Lab_poly, std::allocator<Lab_poly>> const&)
Basis Create_basis(const vector<Lab_poly>& F)
{
  Basis basis;
  for (auto it = F.begin(); it != F.end(); ++it)
    {
      basis[it->Get_LT()] = it->Get_poly();
    }
  return basis;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x16900
movq -0x10(%rbp), %rdi
callq 0x17c20
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x17c90
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x17c50
testb $0x1, %al
jne 0x16161
jmp 0x161e0
leaq -0x20(%rbp), %rdi
callq 0x17cc0
movq %rax, %rdi
callq 0xb8c0
movq %rax, -0x58(%rbp)
jmp 0x16178
leaq -0x20(%rbp), %rdi
callq 0x17cc0
movq %rax, %rdi
callq 0x16d80
movl %eax, -0x5c(%rbp)
jmp 0x1618e
movq -0x50(%rbp), %rdi
movl -0x5c(%rbp), %eax
cltq
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x17ce0
movq %rax, -0x68(%rbp)
jmp 0x161aa
movq -0x58(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0xb850
jmp 0x161b9
jmp 0x161bb
leaq -0x20(%rbp), %rdi
callq 0x17d10
jmp 0x16141
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x16920
jmp 0x161fd
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x161f3
movq -0x50(%rbp), %rdi
callq 0x16920
movq -0x48(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
// File: manschga[P]M5GB/M5GB.cpp
// Function: is_more_reduced(polynomial const&, polynomial const&)
bool is_more_reduced(const polynomial& one, const polynomial& two)
{
  if (two.Get_monomials().size() == 0) //starting off
    return true;
  term_int LT_1 = one.Get_LT();
  term_int LT_2 = two.Get_LT();
#ifdef LARGE_GEN
  return (Generations_M.find(LT_1)->second > Generations_M.find(LT_2)->second); //break ties arbitrarily
#endif
#ifdef LARGEST_LT
  return (LT_1 > LT_2);
#endif
#ifdef SMALLEST_REMAINDER
  return (LT_1 > LT_2);
#endif
#ifdef SMALLEST_LT
  return (LT_1 < LT_2);
#endif
#ifdef LARGEST_FLAG
  return (Flags_M.find(LT_1)->second > Flags_M.find(LT_2)->second);
#endif
#ifdef NUMBER_OF_TERMS
  return (LT_1 < LT_2);
  //return (M.find(LT_1)->second.Get_monomials().size() < M.find(LT_2)->second.Get_monomials().size());
#endif  
  
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31f0
movq %rax, %rdi
callq 0xc4b0
cmpq $0x0, %rax
jne 0x1683d
movb $0x1, -0x1(%rbp)
jmp 0x1686b
movq -0x10(%rbp), %rdi
callq 0x17490
cltq
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x17490
cltq
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: manschga[P]M5GB/./lab_poly.h
// Function: Lab_poly::Get_LT() const
int Get_LT() const
  {
    //cout << "LT called!" << endl;
    //not necessary!
    if (this->_poly.size() == 0)
      {
	cout << "term empty!" << endl;
	return 0;
      }
    return (this->_poly).Get_monomials()[0].Get_term();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x17120
cmpl $0x0, %eax
jne 0x16dc9
movq 0x29233(%rip), %rdi     # 0x3ffd8
leaq 0x1466f(%rip), %rsi     # 0x2b41b
callq 0x2190
movq %rax, %rdi
movq 0x2920d(%rip), %rsi     # 0x3ffc8
callq 0x21d0
movl $0x0, -0x4(%rbp)
jmp 0x16de9
movq -0x18(%rbp), %rdi
callq 0x31f0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3200
movq %rax, %rdi
callq 0xda60
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: manschga[P]M5GB/./poly.h
// Function: monomial::operator==(monomial const&) const
bool operator == (const monomial &rhs) const
 {
   bool one = (*this > rhs);
   bool two = (*this<rhs);
   bool result = (!(*this>rhs)) && (!(*this<rhs));
   return result;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x23140
movq -0x20(%rbp), %rdi
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rsi
callq 0xf140
movq -0x20(%rbp), %rdi
andb $0x1, %al
movb %al, -0x12(%rbp)
movq -0x10(%rbp), %rsi
callq 0x23140
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x14(%rbp)
jne 0x23123
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf140
xorb $-0x1, %al
movb %al, -0x14(%rbp)
movb -0x14(%rbp), %al
andb $0x1, %al
movb %al, -0x13(%rbp)
movb -0x13(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: manschga[P]M5GB/./M5GB.h
// Function: Pair_compare::operator()(std::pair<Lab_poly, Lab_poly> const&, std::pair<Lab_poly, Lab_poly> const&) const
bool operator()(const pair<Lab_poly,Lab_poly>& one, const pair<Lab_poly,Lab_poly>& two) const{
  if (one.first.Get_sign() == two.first.Get_sign())
    {
      if (one.second.Get_sign() == two.second.Get_sign())
	{
	  /*
	  if (one.second.Get_poly() ==  two.second.Get_poly()); //break tie arbitrarily
	  {
	    cout << "Problem encountered!" << endl;
	  }
	  */
	  return (one.first.Get_poly() < two.first.Get_poly()); //break tie arbitrarily
	}
    }
  //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 %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb8d0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xb8d0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0xbe50
testb $0x1, %al
jne 0x24fcc
jmp 0x25027
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0xb8d0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
callq 0xb8d0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xbe50
testb $0x1, %al
jne 0x24ffc
jmp 0x25025
movq -0x18(%rbp), %rdi
callq 0xb8c0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0xb8c0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x22ce0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2504e
jmp 0x25027
movq -0x18(%rbp), %rdi
callq 0xb8d0
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0xb8d0
movq -0x40(%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/poly.cpp
// Function: operator<<(std::ostream&, polynomial const&)
ostream& operator<<(ostream& s, const polynomial& rhs)
{
  for (int i = 0; i < rhs.size()-1; ++i)
    {
      cout << rhs._monomials[i] << "+";
    }
  cout << rhs._monomials[rhs.size()-1] <<",";
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x17120
movl %eax, %ecx
movl -0x18(%rbp), %eax
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x26048
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3200
movq %rax, %rsi
movq 0x19faf(%rip), %rdi     # 0x3ffd8
callq 0x25e10
movq %rax, %rdi
leaq 0x5021(%rip), %rsi      # 0x2b059
callq 0x2190
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x25ff7
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x17120
movq -0x20(%rbp), %rdi
subl $0x1, %eax
movslq %eax, %rsi
callq 0x3200
movq %rax, %rsi
movq 0x19f66(%rip), %rdi     # 0x3ffd8
callq 0x25e10
movq %rax, %rdi
leaq 0x4fda(%rip), %rsi      # 0x2b05b
callq 0x2190
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: manschga[P]M5GB/poly.cpp
// Function: get_remainder(std::vector<int, std::allocator<int>>, std::vector<int, std::allocator<int>>)
term_vec get_remainder(term_vec term, term_vec divisor)//if divisor divides term, then term = divisor*remainder, is only on term level!
{
  //cout << "in remainder " << endl;
  //  int rem_coeff = mon.Get_coeff()*Inverse(divisor.Get_coeff(),divisor.Get_p());
  /*
  cout << "term_size: " << term.size() << endl;
  cout << "divisor size: " << divisor.size() << endl;
  cout << "in remainder " << endl;
  */
  term_vec rem_vec = {};
  if (term.size() != divisor.size())
    {
      cout << "Error in Remainder computation!" << endl;
    }
  for (int i = 0; i < term.size(); ++i)
    {
      //cout << "before emplace " << endl;
      rem_vec.emplace_back(term[i]-divisor[i]);
      //cout << "after emplace " << endl;
    }
  return rem_vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x48(%rbp)
movq %rsi, -0x50(%rbp)
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x20e0
movq -0x58(%rbp), %rdi
callq 0x61e0
movq -0x50(%rbp), %rdi
callq 0x3260
movq -0x48(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x3260
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
je 0x2639c
movq 0x19c7c(%rip), %rdi     # 0x3ffd8
leaq 0x50c7(%rip), %rsi      # 0x2b42a
callq 0x2190
movq %rax, -0x68(%rbp)
jmp 0x2636e
movq -0x68(%rbp), %rdi
movq 0x19c4f(%rip), %rsi     # 0x3ffc8
callq 0x21d0
jmp 0x26380
jmp 0x2639c
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3b70
jmp 0x26428
movl $0x0, -0x30(%rbp)
movq -0x50(%rbp), %rdi
movslq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0x3260
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x26408
movq -0x50(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x3280
movq -0x48(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x74(%rbp)
movslq -0x30(%rbp), %rsi
callq 0x3280
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl -0x74(%rbp), %eax
movl (%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x34(%rbp)
leaq -0x34(%rbp), %rsi
callq 0x8770
jmp 0x263fb
jmp 0x263fd
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x263a3
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x2641b
movq -0x58(%rbp), %rdi
callq 0x3b70
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
// File: manschga[P]M5GB/poly.cpp
// Function: poly_from_vec(std::vector<int, std::allocator<int>> const&, int, int)
polynomial poly_from_vec(const vector<int>& vec, int n, int p)
{
  //  monomial constant(0,vec[vec.size()-1],p);
  vector<monomial> monomials = {};
  for (int i = 0; i < vec.size(); ++i)
    {
      if ((vec[i])%p > 0)
	{
	  monomials.emplace_back(monomial(vec.size()-i-1,(vec[i]),p));//new term with coefficient
	}
    }
  return polynomial(monomials);//.update();
}

// 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)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%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, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3260
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x267ef
movq -0x10(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x5fd0
movl (%rax), %eax
cltd
idivl -0x18(%rbp)
cmpl $0x0, %edx
jle 0x267df
movq -0x10(%rbp), %rdi
callq 0x3260
movq %rax, %rcx
movslq -0x34(%rbp), %rsi
movq %rsi, %rax
notq %rax
addq %rcx, %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5fd0
movq -0x78(%rbp), %rsi
movl (%rax), %edx
movl -0x18(%rbp), %ecx
leaq -0x48(%rbp), %rdi
callq 0x25de0
jmp 0x267b7
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xd9e0
jmp 0x267c6
jmp 0x267df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x44c0
jmp 0x26814
jmp 0x267e1
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x26744
movq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x25f60
jmp 0x267fe
leaq -0x30(%rbp), %rdi
callq 0x44c0
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x2300
nopl (%rax)
// File: manschga[P]M5GB/poly.cpp
// Function: vec_from_poly(polynomial const&, int)
vector<vector<int>> vec_from_poly(const polynomial& poly, int n)
{
  vector<vector<int>> poly_vec = {};
  //assume poly is correctly ordered, else call poly.update() -> no more const
  //first extra, get size
  if (poly.size() == 0)
    {
      cout << "empty polynomial!" << endl;
      return {};
    }
  //  vector<int> vec(max_size,0);
  for (int i = 0; i < poly.Get_monomials().size(); ++i)
    {
      if (poly.Get_monomials()[i].Get_coeff() > 0)
	{
	  vector<int> term_i = table[poly.Get_monomials()[i].Get_term()].first;
	  poly_vec.emplace_back(term_i);
	}
    }
  return poly_vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x28620
movq -0x10(%rbp), %rdi
callq 0x17120
movl %eax, -0x64(%rbp)
jmp 0x26867
movl -0x64(%rbp), %eax
cmpl $0x0, %eax
jne 0x268d0
movq 0x19762(%rip), %rdi     # 0x3ffd8
leaq 0x4be1(%rip), %rsi      # 0x2b45e
callq 0x2190
movq %rax, -0x80(%rbp)
jmp 0x26888
movq -0x80(%rbp), %rdi
movq 0x19735(%rip), %rsi     # 0x3ffc8
callq 0x21d0
jmp 0x2689a
movq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x20e0
movq -0x78(%rbp), %rdi
callq 0x28620
movl $0x1, -0x40(%rbp)
jmp 0x269fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x26a13
movl $0x0, -0x44(%rbp)
movslq -0x44(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31f0
movq %rax, -0x88(%rbp)
jmp 0x268f4
movq -0x88(%rbp), %rdi
callq 0xc4b0
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jae 0x269e9
movq -0x10(%rbp), %rdi
callq 0x31f0
movq %rax, -0x98(%rbp)
jmp 0x26925
movq -0x98(%rbp), %rdi
movslq -0x44(%rbp), %rsi
callq 0x3200
movq %rax, %rdi
callq 0x3220
movl %eax, -0x9c(%rbp)
jmp 0x26945
movl -0x9c(%rbp), %eax
cmpl $0x0, %eax
jle 0x269d9
movq -0x10(%rbp), %rdi
callq 0x31f0
movq %rax, -0xa8(%rbp)
jmp 0x26966
movq -0xa8(%rbp), %rdi
movslq -0x44(%rbp), %rsi
callq 0x3200
movq %rax, %rdi
callq 0xda60
movq %rax, -0xb0(%rbp)
jmp 0x26987
movq -0xb0(%rbp), %rsi
leaq 0x1984b(%rip), %rdi     # 0x401e0
callq 0xd480
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0x5ff0
jmp 0x269a8
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x28640
jmp 0x269b7
leaq -0x60(%rbp), %rdi
callq 0x3b70
jmp 0x269d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3b70
jmp 0x26a13
jmp 0x269db
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x268d7
movq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x286c0
movl $0x1, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x32a0
movq -0x70(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x32a0
movq -0x38(%rbp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
// File: manschga[P]M5GB/poly.cpp
// Function: Tail(polynomial const&)
polynomial Tail(const polynomial& f) //returns all except leading monomial
{
  
  //cout << "Tail computation begin!" << endl;
  vector<monomial> tails = f.Get_monomials();
  //int n = tails[0].Get_term().size();
  if (tails.size() == 0)
    {
      cout << "Error in Tail! Empty polynomial!" << endl;
    }
  int p = tails[0].Get_p();
  //cout << "size of tails before removing: " << tails.size() << endl;
  tails.erase(tails.begin()); //remove LM
  //cout << "size of tails after removing: " << tails.size() << endl;
  if (tails.size() > 0)
    return polynomial(tails);
  else
    {// cout << "possible seg fault in Tail!" << endl;
      return polynomial({monomial(0, 0, p)});//construct zero polynomial
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31f0
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0xd190
leaq -0x28(%rbp), %rdi
callq 0xc4b0
cmpq $0x0, %rax
jne 0x2700c
movq 0x19009(%rip), %rdi     # 0x3ffd8
leaq 0x449a(%rip), %rsi      # 0x2b470
callq 0x2190
movq %rax, -0xb0(%rbp)
jmp 0x26fe4
movq -0xb0(%rbp), %rdi
movq 0x18fd6(%rip), %rsi     # 0x3ffc8
callq 0x21d0
jmp 0x26ff9
jmp 0x2700c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x27173
xorl %eax, %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0xd280
movq %rax, %rdi
callq 0xcfa0
movl %eax, -0xb4(%rbp)
jmp 0x27029
movl -0xb4(%rbp), %eax
movl %eax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0xc6d0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x28810
movq -0xc8(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x287a0
movq %rax, -0xc0(%rbp)
jmp 0x2706c
movq -0xc0(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xc4b0
cmpq $0x0, %rax
jbe 0x270a4
movq -0xa8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x25f60
jmp 0x27098
movl $0x1, -0x54(%rbp)
jmp 0x2715a
movl -0x38(%rbp), %ecx
xorl %edx, %edx
movl %edx, %esi
leaq -0x90(%rbp), %rdi
callq 0x25de0
jmp 0x270b9
leaq -0x90(%rbp), %rax
movq %rax, -0x80(%rbp)
movq $0x1, -0x78(%rbp)
leaq -0x91(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0xe930
movq -0xd0(%rbp), %rcx
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0xeaa0
jmp 0x270f9
movq -0xa8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x25f60
jmp 0x2710b
leaq -0x70(%rbp), %rdi
callq 0x44c0
leaq -0x91(%rbp), %rdi
callq 0x46a0
movl $0x1, -0x54(%rbp)
jmp 0x2715a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2714c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x44c0
leaq -0x91(%rbp), %rdi
callq 0x46a0
jmp 0x27173
leaq -0x28(%rbp), %rdi
callq 0x44c0
movq -0xa0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x44c0
movq -0x30(%rbp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
// File: manschga[P]M5GB/poly.cpp
// Function: is_Smaller(polynomial const&, polynomial const&)
bool is_Smaller(const polynomial &one , const polynomial &two)
{
  if (one.Get_LT() < two.Get_LT())
    {
      return true;
    }
  if (two.Get_LT() < one.Get_LT())
    {
      return false;
    }
  //else
  return is_Smaller(Tail(one),Tail(two));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x17490
movl %eax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
callq 0x17490
movl %eax, %ecx
movl -0x68(%rbp), %eax
cmpl %ecx, %eax
jge 0x27247
movb $0x1, -0x1(%rbp)
jmp 0x272e3
movq -0x18(%rbp), %rdi
callq 0x17490
movl %eax, -0x6c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x17490
movl %eax, %ecx
movl -0x6c(%rbp), %eax
cmpl %ecx, %eax
jge 0x2726b
movb $0x0, -0x1(%rbp)
jmp 0x272e3
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x26f80
movq -0x18(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x26f80
jmp 0x27287
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x27210
movb %al, -0x6d(%rbp)
jmp 0x27299
movb -0x6d(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x44a0
leaq -0x38(%rbp), %rdi
callq 0x44a0
jmp 0x272e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x272d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x44a0
leaq -0x38(%rbp), %rdi
callq 0x44a0
jmp 0x272ee
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x2300
nopw (%rax,%rax)
// File: manschga[P]M5GB/signature.cpp
// Function: max(signature const&, signature const&)
const signature& max(const signature& one, const signature& two)
{
  if (Smaller_sign (one,two))
    {
      return two;
    }
  //else
  if (Smaller_sign (two, one))
    {
      return one;
    }
  //else same signature!
  //cout << "Possible signature drop!" << endl;
  return one;  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a460
testb $0x1, %al
jne 0x2a423
jmp 0x2a42d
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2a452
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2a460
testb $0x1, %al
jne 0x2a440
jmp 0x2a44a
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2a452
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: manschga[P]M5GB/signature.cpp
// Function: min(signature const&, signature const&)
const signature& min(const signature& one, const signature& two)
{
  if (Smaller_sign (one,two))
    {
      return one;
    }
  //else
  if (Smaller_sign (two, one))
    {
      return two;
    }
  //else same signature!
  //cout << "Possible signature drop!" << endl;
  return one;  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a460
testb $0x1, %al
jne 0x2a4b3
jmp 0x2a4bd
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2a4e2
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2a460
testb $0x1, %al
jne 0x2a4d0
jmp 0x2a4da
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2a4e2
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Finsenty54[P]fast_collision/my_first_try.cpp
// Function: main
int main()
{
    seed32_1=uint32(time(NULL));
    seed32_2=0x12345678;
    //MD5已经定义值
    uint32 IV[4] = { MD5IV[0], MD5IV[1], MD5IV[2], MD5IV[3] };
    //两个消息，每个有两个512bit块
	//16 * 32 = 512
	uint32 msg1block0[16]={0};
	uint32 msg1block1[16]={0};
	uint32 msg2block0[16]={0};
	uint32 msg2block1[16]={0};

	//计时器？？
	boost::timer::auto_cpu_timer runtime;
	find_collision(IV, msg1block0, msg1block1, msg2block0, msg2block1,true);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movl $0x0, -0x4(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x10c0
movl %eax, %ecx
leaq 0x14c4c(%rip), %rax     # 0x160d0
movl %ecx, (%rax)
leaq 0x14c47(%rip), %rax     # 0x160d4
movl $0x12345678, (%rax)     # imm = 0x12345678
movaps 0x11b76(%rip), %xmm0    # 0x13010
movaps %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x190(%rbp)
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
movaps %xmm0, -0x90(%rbp)
movaps %xmm0, -0xa0(%rbp)
movaps %xmm0, -0xb0(%rbp)
movaps %xmm0, -0xc0(%rbp)
movaps %xmm0, -0xd0(%rbp)
movaps %xmm0, -0xe0(%rbp)
movaps %xmm0, -0xf0(%rbp)
movaps %xmm0, -0x100(%rbp)
movaps %xmm0, -0x110(%rbp)
movaps %xmm0, -0x120(%rbp)
leaq -0x168(%rbp), %rdi
movl $0x6, %esi
callq 0x1060
leaq -0x20(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
leaq -0xe0(%rbp), %rcx
leaq -0x120(%rbp), %r8
movl $0x1, %r9d
callq 0x1590
jmp 0x1541
movl $0x0, -0x4(%rbp)
leaq -0x168(%rbp), %rdi
callq 0x1120
movl -0x4(%rbp), %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x170(%rbp)
movl %eax, -0x174(%rbp)
leaq -0x168(%rbp), %rdi
callq 0x1120
movq -0x170(%rbp), %rdi
callq 0x1150
nopw (%rax,%rax)
// File: Finsenty54[P]fast_collision/./main.hpp
// Function: xrng64()
inline uint32 xrng64()
{
  //seed1 = time
	uint32 t = seed32_1 ^ (seed32_1 << 10);
	seed32_1 = seed32_2;
	seed32_2 = (seed32_2^(seed32_2>>10))^(t^(t>>13));
  //交互返回
	return seed32_1; //return seed32_2
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x11bd6(%rip), %eax     # 0x160d0
movl 0x11bd0(%rip), %ecx     # 0x160d0
shll $0xa, %ecx
xorl %ecx, %eax
movl %eax, -0x4(%rbp)
movl 0x11bc6(%rip), %eax     # 0x160d4
movl %eax, 0x11bbc(%rip)     # 0x160d0
movl 0x11bba(%rip), %eax     # 0x160d4
movl 0x11bb4(%rip), %ecx     # 0x160d4
shrl $0xa, %ecx
xorl %ecx, %eax
movl -0x4(%rbp), %ecx
movl -0x4(%rbp), %edx
shrl $0xd, %edx
xorl %edx, %ecx
xorl %ecx, %eax
movl %eax, 0x11b9c(%rip)     # 0x160d4
movl 0x11b92(%rip), %eax     # 0x160d0
popq %rbp
retq
// File: j84guo[P]cake/cake.cpp
// Function: operator<<(std::ostream&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
ostream& operator<<(ostream& out, const vector<string>& v)
{
    out << "[";
    for (auto it=v.begin(); it!=v.end(); ++it) {
        out << *it;
        if (it + 1 != v.end())
            out << ", ";
    }
    out << "]";
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x5af4(%rip), %rsi      # 0x804f
callq 0x2210
movq -0x10(%rbp), %rdi
callq 0x36b0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3720
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x36e0
testb $0x1, %al
jne 0x258d
jmp 0x25fc
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3750
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x21f0
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x3770
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3720
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x36e0
testb $0x1, %al
jne 0x25dc
jmp 0x25ec
movq -0x8(%rbp), %rdi
leaq 0x5a21(%rip), %rsi      # 0x8008
callq 0x2210
jmp 0x25ee
leaq -0x18(%rbp), %rdi
callq 0x37b0
jmp 0x256d
movq -0x8(%rbp), %rdi
leaq 0x5a04(%rip), %rsi      # 0x800b
callq 0x2210
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: j84guo[P]cake/cake.cpp
// Function: trimmed(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string trimmed(const string& str, const string& rem=" ")
{
    string::size_type begin = str.find_first_not_of(rem);
    if (begin == string::npos)
        return "";
    return str.substr(begin, str.find_last_not_of(rem) - begin + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x21c0
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
jne 0x2710
leaq -0x21(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x23a0
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x59d1(%rip), %rsi      # 0x80b8
callq 0x37d0
jmp 0x26ee
leaq -0x21(%rbp), %rdi
callq 0x2270
jmp 0x2750
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x2270
jmp 0x275a
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq $-0x1, %rdx
callq 0x23d0
movq -0x48(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq %rax, %rcx
subq -0x20(%rbp), %rcx
addq $0x1, %rcx
callq 0x2240
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2390
nopw %cs:(%rax,%rax)
// File: j84guo[P]cake/cake.cpp
// Function: readFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
bool readFile(const string& path, vector<string>& lines)
{
    ifstream file(path);
    if (!file)
        return false;

    string line;
    while (getline(file, line))
        lines.push_back(trimmed(line));
    return !file.bad();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp            # imm = 0x2C0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x220(%rbp), %rdi
movl $0x8, %edx
callq 0x2370
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x2100
movb %al, -0x292(%rbp)
jmp 0x27b8
movb -0x292(%rbp), %al
testb $0x1, %al
jne 0x27c4
jmp 0x27ee
movb $0x0, -0x1(%rbp)
movl $0x1, -0x230(%rbp)
jmp 0x29a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x29bb
leaq -0x250(%rbp), %rdi
callq 0x2320
leaq -0x220(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x2040
movq %rax, -0x2a0(%rbp)
jmp 0x2816
movq -0x2a0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x22e0
movb %al, -0x2a1(%rbp)
jmp 0x2834
movb -0x2a1(%rbp), %al
testb $0x1, %al
jne 0x2843
jmp 0x294e
movq -0x18(%rbp), %rax
movq %rax, -0x2b8(%rbp)
leaq -0x291(%rbp), %rdi
movq %rdi, -0x2b0(%rbp)
callq 0x23a0
movq -0x2b0(%rbp), %rdx
leaq 0x579a(%rip), %rsi      # 0x8009
leaq -0x290(%rbp), %rdi
callq 0x37d0
jmp 0x287d
leaq -0x270(%rbp), %rdi
leaq -0x250(%rbp), %rsi
leaq -0x290(%rbp), %rdx
callq 0x2690
jmp 0x2899
movq -0x2b8(%rbp), %rdi
leaq -0x270(%rbp), %rsi
callq 0x3880
jmp 0x28ae
leaq -0x270(%rbp), %rdi
callq 0x2140
leaq -0x290(%rbp), %rdi
callq 0x2140
leaq -0x291(%rbp), %rdi
callq 0x2270
jmp 0x27fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x2993
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x2940
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x2934
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x270(%rbp), %rdi
callq 0x2140
leaq -0x290(%rbp), %rdi
callq 0x2140
leaq -0x291(%rbp), %rdi
callq 0x2270
jmp 0x2993
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x23c0
movb %al, -0x2b9(%rbp)
jmp 0x296e
movb -0x2b9(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl $0x1, -0x230(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x2140
jmp 0x29a1
leaq -0x250(%rbp), %rdi
callq 0x2140
jmp 0x29bb
leaq -0x220(%rbp), %rdi
callq 0x2070
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x2c0, %rsp            # imm = 0x2C0
popq %rbp
retq
leaq -0x220(%rbp), %rdi
callq 0x2070
movq -0x228(%rbp), %rdi
callq 0x2390
nopw %cs:(%rax,%rax)
// File: j84guo[P]cake/cake.cpp
// Function: parseAdjacent(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Target&)
void parseAdjacent(string adj, Target& tgt)
{
    string::size_type pos;

    while ((pos = adj.find(" ")) != string::npos) {
        string token = adj.substr(0, pos);
        adj.erase(0, pos + 1);
        if (token.size())
            tgt.adjacent.push_back(token);
    }

    if (adj.size())
        tgt.adjacent.push_back(adj);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x50(%rbp), %rdi
leaq 0x552a(%rip), %rsi      # 0x8009
xorl %eax, %eax
movl %eax, %edx
callq 0x23f0
movq %rax, -0x18(%rbp)
cmpq $-0x1, %rax
je 0x2b6a
movq -0x50(%rbp), %rsi
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2240
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x18(%rbp), %rdx
incq %rdx
callq 0x2060
jmp 0x2b21
leaq -0x38(%rbp), %rdi
callq 0x2160
cmpq $0x0, %rax
je 0x2b5c
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
leaq -0x38(%rbp), %rsi
callq 0x38b0
jmp 0x2b43
jmp 0x2b5c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2140
jmp 0x2b90
leaq -0x38(%rbp), %rdi
callq 0x2140
jmp 0x2ad4
movq -0x50(%rbp), %rdi
callq 0x2160
cmpq $0x0, %rax
je 0x2b8a
movq -0x50(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x38b0
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2390
nopl (%rax)
// File: j84guo[P]cake/cake.cpp
// Function: parseTask(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
bool parseTask(const string& t, vector<string>& tasks)
{
    if (t.find_first_not_of(' ') == string::npos)
        return true;
    if (t.at(0) != '\t')
        return false;

    tasks.push_back(t.substr(1));
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x20, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x2200
cmpq $-0x1, %rax
jne 0x2bce
movb $0x1, -0x1(%rbp)
jmp 0x2c43
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x22a0
movsbl (%rax), %eax
cmpl $0x9, %eax
je 0x2be9
movb $0x0, -0x1(%rbp)
jmp 0x2c43
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl $0x1, %edx
movq $-0x1, %rcx
callq 0x2240
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x3880
jmp 0x2c1d
leaq -0x38(%rbp), %rdi
callq 0x2140
movb $0x1, -0x1(%rbp)
jmp 0x2c43
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2140
jmp 0x2c4e
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2390
nopw (%rax,%rax)
// File: j84guo[P]cake/cake.cpp
// Function: topologicalSort(std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Target, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Target>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::unordered_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void topologicalSort
(
    TargetMap& nodes,
    const string& id,
    StringSet& visited,
    vector<string>& order
)
{
    if (visited.find(id) != visited.end())
        return;

    visited.emplace(id);
    for (const string& adj : nodes.at(id).adjacent)
        topologicalSort(nodes, adj, visited, order);
    order.push_back(id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3ad0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3b00
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3aa0
testb $0x1, %al
jne 0x2fd9
jmp 0x2fde
jmp 0x306e
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3b30
movq %rax, -0x40(%rbp)
movb %dl, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3a50
addq $0x20, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x3920
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x3990
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3950
testb $0x1, %al
jne 0x3034
jmp 0x3061
leaq -0x50(%rbp), %rdi
callq 0x3a80
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x2f90
leaq -0x50(%rbp), %rdi
callq 0x39e0
jmp 0x3021
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x38b0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: j84guo[P]cake/cake.cpp
// Function: doTask(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool doTask(string task)
{
    cout << "@" << task << endl;
    char * const argv[] = {
        (char *) "/bin/bash",
        (char *) "-c",
        (char *) task.c_str(),
        NULL
    };

    int status;
    pid_t child = fork();

    if (child == -1) {
        perror("fork");
        return false;
    } else if (!child) {
        execvp("bash", argv);
        perror("execvp");
        exit(1);
    }

    if (wait(&status) == -1) {
        perror("wait");
        return false;
    }
    return WIFEXITED(status) && WEXITSTATUS(status) == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x10(%rbp)
movq 0x9e79(%rip), %rdi      # 0xcfd0
leaq 0x4eff(%rip), %rsi      # 0x805d
callq 0x2210
movq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0x21f0
movq %rax, %rdi
movq 0x9e47(%rip), %rsi      # 0xcfc0
callq 0x2250
movq -0x40(%rbp), %rdi
leaq 0x4ed6(%rip), %rax      # 0x805f
movq %rax, -0x30(%rbp)
leaq 0x4ed5(%rip), %rax      # 0x8069
movq %rax, -0x28(%rbp)
callq 0x20c0
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
callq 0x2080
movl %eax, -0x38(%rbp)
cmpl $-0x1, -0x38(%rbp)
jne 0x31c9
leaq 0x4eae(%rip), %rdi      # 0x806c
callq 0x21b0
movb $0x0, -0x1(%rbp)
jmp 0x3243
cmpl $0x0, -0x38(%rbp)
jne 0x31f5
leaq -0x30(%rbp), %rsi
leaq 0x4e8a(%rip), %rdi      # 0x8064
callq 0x2180
leaq 0x4e8b(%rip), %rdi      # 0x8071
callq 0x21b0
movl $0x1, %edi
callq 0x22b0
jmp 0x31f7
leaq -0x34(%rbp), %rdi
callq 0x22d0
cmpl $-0x1, %eax
jne 0x3217
leaq 0x4e6c(%rip), %rdi      # 0x8078
callq 0x21b0
movb $0x0, -0x1(%rbp)
jmp 0x3243
movl -0x34(%rbp), %ecx
andl $0x7f, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x41(%rbp)
jne 0x323b
movl -0x34(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nop