LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: onai[P]npio/./npio.h
// Function: npio_swap_bytes(unsigned long, unsigned long, void*)
static inline int npio_swap_bytes(size_t n, size_t bit_width, void* data)
{
  size_t i;
  char *p = (char*) data;

  if (bit_width == 8)
    return 0;

  switch (bit_width)
  {
    case 16:
      for (i = 0; i < n; ++i)
      {
        npio_swap_bytes_(p, p + 1);
        p += 2;
      }
      return 0;

    case 32:
      for (i = 0; i < n; ++i)
      {
        npio_swap_bytes_(p, p + 3);
        npio_swap_bytes_(p + 1, p + 2);
        p += 4;
      }
      return 0;

    case 64:
      for (i = 0; i < n; ++i)
      {
        npio_swap_bytes_(p, p + 7);
        npio_swap_bytes_(p + 1, p + 6);
        npio_swap_bytes_(p + 2, p + 5);
        npio_swap_bytes_(p + 3, p + 4);
        p += 8;
      }
      return 0;

    default:
      return ENOTSUP;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x8, -0x18(%rbp)
jne 0x24ef
movl $0x0, -0x4(%rbp)
jmp 0x2651
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
subq $0x10, %rax
je 0x251e
jmp 0x24ff
movq -0x38(%rbp), %rax
subq $0x20, %rax
je 0x2567
jmp 0x250b
movq -0x38(%rbp), %rax
subq $0x40, %rax
je 0x25c5
jmp 0x264a
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x255b
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x1, %rsi
callq 0x2660
movq -0x30(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2526
movl $0x0, -0x4(%rbp)
jmp 0x2651
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x25b9
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x3, %rsi
callq 0x2660
movq -0x30(%rbp), %rdi
addq $0x1, %rdi
movq -0x30(%rbp), %rsi
addq $0x2, %rsi
callq 0x2660
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x256f
movl $0x0, -0x4(%rbp)
jmp 0x2651
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x2641
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x7, %rsi
callq 0x2660
movq -0x30(%rbp), %rdi
addq $0x1, %rdi
movq -0x30(%rbp), %rsi
addq $0x6, %rsi
callq 0x2660
movq -0x30(%rbp), %rdi
addq $0x2, %rdi
movq -0x30(%rbp), %rsi
addq $0x5, %rsi
callq 0x2660
movq -0x30(%rbp), %rdi
addq $0x3, %rdi
movq -0x30(%rbp), %rsi
addq $0x4, %rsi
callq 0x2660
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x25cd
movl $0x0, -0x4(%rbp)
jmp 0x2651
movl $0x5f, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: onai[P]npio/./npio.h
// Function: npio_free_array(npio_Array*)
static inline void npio_free_array(npio_Array* array)
{
  if (array->dtype)
  {
    free(array->dtype);
    array->dtype = 0;
  }

  if (array->shape)
  {
    free(array->shape);
    array->shape = 0;
  }

  if (array->data && !array->_buf)
  {
    free(array->data);
    array->data = 0;
  }

  if (array->_mmapped)
  {
    munmap(array->_buf, array->_buf_size);
    array->_buf = 0;
  }

  if (array->_fd >= 0)
  {
    close(array->_fd);
    array->_fd = -1;
  }

  if (array->_hdr_buf)
  {
    free(array->_hdr_buf);
    array->_hdr_buf = 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x26c0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10d0
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x26e4
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x10d0
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x2713
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x2713
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x10d0
movq -0x8(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x78(%rax)
je 0x273e
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rsi
callq 0x1090
movq -0x8(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x50(%rax)
jl 0x275f
movq -0x8(%rbp), %rax
movl 0x50(%rax), %edi
callq 0x1140
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x50(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x2783
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x10d0
movq -0x8(%rbp), %rax
movq $0x0, 0x68(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: permutationlock[P]aes_math/lib/galois_field.cpp
// Function: Polynomial::Polynomial(int, int, int)
Polynomial::Polynomial(int value, int p, int n): _p(p) {
    for(int i=0; i<n; i++){
        _a.push_back(0);
    }
    
    for(int i=n-1; i>=0; i--){
        int num = pow(_p, i);
        if(value >= num){
            int m = (value/num)%_p;
            _a[i] = Modular<int>(m);
            value -= m * num;
        }
        if(value==0) break;
    }
    
    reduce();
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl %edx, 0x48(%rsp)
movl %ecx, 0x44(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x6720
movq 0x10(%rsp), %rax
movl 0x48(%rsp), %ecx
movl %ecx, 0x18(%rax)
movl $0x0, 0x40(%rsp)
movl 0x40(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x4412
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x38(%rsp)
leaq 0x3c(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x6760
jmp 0x43d5
movq 0x8(%rsp), %rdi
leaq 0x3c(%rsp), %rsi
callq 0x6730
jmp 0x43e6
jmp 0x43e8
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x43a8
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x67e0
jmp 0x44df
movl 0x44(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x28(%rsp)
cmpl $0x0, 0x28(%rsp)
jl 0x44ce
movq 0x10(%rsp), %rax
movl 0x18(%rax), %edi
movl 0x28(%rsp), %esi
callq 0x6780
movsd %xmm0, (%rsp)
jmp 0x4440
movsd (%rsp), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x24(%rsp)
movl 0x4c(%rsp), %eax
cmpl 0x24(%rsp), %eax
jl 0x44b3
movq 0x10(%rsp), %rcx
movl 0x4c(%rsp), %eax
movl 0x24(%rsp), %esi
cltd
idivl %esi
movl 0x18(%rcx), %ecx
cltd
idivl %ecx
movl %edx, 0x20(%rsp)
leaq 0x1c(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x6760
jmp 0x4482
movq 0x10(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0x67a0
movq %rax, %rdi
leaq 0x1c(%rsp), %rsi
callq 0x67c0
jmp 0x44a0
movl 0x20(%rsp), %ecx
imull 0x24(%rsp), %ecx
movl 0x4c(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
jne 0x44bc
jmp 0x44ce
jmp 0x44be
movl 0x28(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x441d
movq 0x10(%rsp), %rdi
callq 0x44f0
jmp 0x44da
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x22b0
nopl (%rax)
// File: permutationlock[P]aes_math/lib/galois_field.cpp
// Function: Polynomial::Polynomial(Polynomial const&)
Polynomial::Polynomial(const Polynomial & other){
    _p = other._p;
    
    for(int i=0; i<other.size(); i++){
        _a.push_back(other[i]);
    }
    
    reduce();
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x6720
movq 0x18(%rsp), %rax
movq 0x38(%rsp), %rcx
movl 0x18(%rcx), %ecx
movl %ecx, 0x18(%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x4700
movl %eax, 0x14(%rsp)
jmp 0x467d
movl 0x10(%rsp), %eax
movl 0x14(%rsp), %ecx
cmpl %ecx, %eax
jge 0x46e0
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x4710
movq %rax, 0x8(%rsp)
jmp 0x46a7
movq 0x8(%rsp), %rsi
movq (%rsp), %rdi
callq 0x6860
jmp 0x46b7
jmp 0x46b9
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x4665
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x67e0
jmp 0x46f1
movq 0x18(%rsp), %rdi
callq 0x44f0
jmp 0x46ec
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x22b0
nopl (%rax,%rax)
// File: permutationlock[P]aes_math/lib/galois_field.cpp
// Function: Polynomial::operator+=(Polynomial const&)
Polynomial & Polynomial::operator+=(const Polynomial & other){
    if(_p != other._p) throw runtime_error("Mismatched prime.");
    
    while(_a.size()<other.size())
        _a.push_back(0);
    
    Modular<int>::globalSetModulus(_p);
    
    for(int i=0; i<other.size(); i++){
        _a[i] += other[i];
    }
    
    reduce();
    
    return *this;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x18(%rax), %eax
movq 0x48(%rsp), %rcx
cmpl 0x18(%rcx), %eax
je 0x47bd
movl $0x10, %edi
callq 0x20a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
leaq 0x11883(%rip), %rsi     # 0x16004
callq 0x2070
jmp 0x4788
movq 0x20(%rsp), %rdi
movq 0x1985c(%rip), %rsi     # 0x1dff0
movq 0x1982d(%rip), %rdx     # 0x1dfc8
callq 0x2290
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x2130
jmp 0x4891
jmp 0x47bf
movq 0x28(%rsp), %rdi
callq 0x6840
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
callq 0x4700
movl %eax, %ecx
movq 0x18(%rsp), %rax
movslq %ecx, %rcx
cmpq %rcx, %rax
jae 0x480f
movl $0x0, 0x34(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x34(%rsp), %rsi
callq 0x6760
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x6730
jmp 0x47bf
movq 0x28(%rsp), %rdi
addq $0x18, %rdi
callq 0x68f0
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x48(%rsp), %rdi
callq 0x4700
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0x487d
movq 0x48(%rsp), %rdi
movl 0x30(%rsp), %esi
callq 0x4710
movq 0x28(%rsp), %rdi
movq %rax, 0x8(%rsp)
movslq 0x30(%rsp), %rsi
callq 0x67a0
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x6910
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x4825
movq 0x28(%rsp), %rdi
callq 0x44f0
movq 0x28(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x22b0
nopl (%rax,%rax)
// File: permutationlock[P]aes_math/lib/galois_field.cpp
// Function: Polynomial::operator%=(Polynomial const&)
Polynomial & Polynomial::operator%=(const Polynomial & other){
    if(_p != other._p) throw runtime_error("Mismatched prime.");
    
    Modular<int>::globalSetModulus(_p);
    while(this->size() >= other.size()){
        Modular<int> c =  _a.back().mulInverse() * other._a.back();
        int diff = this->size()-other.size();
        vector<Modular<int>> v;
        for(int i=0; i< diff; i++)
            v.push_back(0);
        v.push_back(c);
        Polynomial p(v,_p);
        (*this) -= (other * p);
    }
    
    return *this;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x18(%rax), %eax
movq 0x98(%rsp), %rcx
cmpl 0x18(%rcx), %eax
je 0x4d12
movl $0x10, %edi
callq 0x20a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x11334(%rip), %rsi     # 0x16004
callq 0x2070
jmp 0x4cd7
movq 0x8(%rsp), %rdi
movq 0x1930d(%rip), %rsi     # 0x1dff0
movq 0x192de(%rip), %rdx     # 0x1dfc8
callq 0x2290
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
callq 0x2130
jmp 0x4ef0
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
callq 0x68f0
movq 0x10(%rsp), %rdi
callq 0x4700
movl %eax, 0x4(%rsp)
movq 0x98(%rsp), %rdi
callq 0x4700
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jl 0x4ee3
movq 0x10(%rsp), %rdi
callq 0x6a00
movq %rax, %rdi
callq 0x6a40
movl %eax, 0x84(%rsp)
movq 0x98(%rsp), %rdi
callq 0x6b10
movq %rax, %rsi
leaq 0x84(%rsp), %rdi
callq 0x6990
movq 0x10(%rsp), %rdi
movl %eax, 0x88(%rsp)
callq 0x4700
movl %eax, (%rsp)
movq 0x98(%rsp), %rdi
callq 0x4700
movl %eax, %ecx
movl (%rsp), %eax
subl %ecx, %eax
movl %eax, 0x80(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x6720
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
cmpl 0x80(%rsp), %eax
jge 0x4e1f
movl $0x0, 0x5c(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x5c(%rsp), %rsi
callq 0x6760
jmp 0x4de6
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x6730
jmp 0x4df7
jmp 0x4df9
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x4dc0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x4ed7
leaq 0x68(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x6860
jmp 0x4e33
movq 0x10(%rsp), %rax
movl 0x18(%rax), %edx
leaq 0x38(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x4570
jmp 0x4e4c
movq 0x98(%rsp), %rsi
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x4f00
jmp 0x4e65
movq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x48a0
jmp 0x4e76
leaq 0x18(%rsp), %rdi
callq 0x6b50
leaq 0x38(%rsp), %rdi
callq 0x6b50
leaq 0x68(%rsp), %rdi
callq 0x67e0
jmp 0x4d20
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x4ecd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x6b50
leaq 0x38(%rsp), %rdi
callq 0x6b50
leaq 0x68(%rsp), %rdi
callq 0x67e0
jmp 0x4ef0
movq 0x10(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x90(%rsp), %rdi
callq 0x22b0
nopl (%rax)
// File: permutationlock[P]aes_math/lib/galois_field.cpp
// Function: Polynomial::toInt() const
int Polynomial::toInt() const{
    int sum = 0;
    for(int i=0; i<_a.size(); i++){
        sum += _a[i].value()*pow(_p,i);
    }
    return sum;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x6840
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x5602
movq 0x10(%rsp), %rdi
movslq 0x18(%rsp), %rsi
callq 0x68d0
movq %rax, %rdi
callq 0x6bc0
movl %eax, %ecx
movq 0x10(%rsp), %rax
cvtsi2sd %ecx, %xmm0
movsd %xmm0, (%rsp)
movl 0x18(%rax), %edi
movl 0x18(%rsp), %esi
callq 0x6780
movaps %xmm0, %xmm2
movsd (%rsp), %xmm0
cvtsi2sdl 0x1c(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x5583
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: permutationlock[P]aes_math/lib/galois_field.cpp
// Function: Polynomial::toString[abi:cxx11]() const
string Polynomial::toString() const{
    string s = "";
    for(int i=0; i<_a.size(); i++){
        s.insert(0,to_string(_a[i].value()));
    }
    return s;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x0, 0x67(%rsp)
leaq 0x66(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x22c0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rdx
leaq 0x107e3(%rip), %rsi     # 0x162cd
callq 0x2230
jmp 0x5af1
leaq 0x66(%rsp), %rdi
callq 0x21f0
movl $0x0, 0x50(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x6840
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x5bc5
movq 0x18(%rsp), %rdi
movslq 0x50(%rsp), %rsi
callq 0x68d0
movq %rax, %rdi
callq 0x6bc0
movl %eax, 0x4(%rsp)
jmp 0x5b45
movl 0x4(%rsp), %esi
leaq 0x30(%rsp), %rdi
callq 0x6bd0
jmp 0x5b55
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x30(%rsp), %rdx
callq 0x2260
jmp 0x5b6a
leaq 0x30(%rsp), %rdi
callq 0x20e0
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x5b03
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x66(%rsp), %rdi
callq 0x21f0
jmp 0x5bef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x5be5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x20e0
jmp 0x5be5
movb $0x1, 0x67(%rsp)
testb $0x1, 0x67(%rsp)
jne 0x5bdb
movq 0x20(%rsp), %rdi
callq 0x20e0
movq 0x10(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x20e0
movq 0x58(%rsp), %rdi
callq 0x22b0
nopl (%rax)
// File: permutationlock[P]aes_math/lib/galois_field.cpp
// Function: GaloisPolynomial::toString[abi:cxx11]() const
string GaloisPolynomial::toString() const{
    string s = _polynomial.toString();
    for(int i=0; i<_modulus.size()-_polynomial.size()-1; i++)
        s.insert(0, "0");
    return s;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rsi
movq %rsi, 0x18(%rsp)
movb $0x0, 0x37(%rsp)
callq 0x5aa0
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0x4(%rsp)
leaq 0x17b52(%rip), %rdi     # 0x1e1a8
callq 0x4700
movq 0x18(%rsp), %rdi
movl %eax, (%rsp)
callq 0x4700
movl (%rsp), %ecx
movl %eax, %edx
movl 0x4(%rsp), %eax
subl %edx, %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x66ba
movq 0x8(%rsp), %rdi
leaq 0xf996(%rip), %rdx      # 0x1601c
xorl %eax, %eax
movl %eax, %esi
callq 0x2040
jmp 0x6691
jmp 0x6693
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x6647
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x20e0
jmp 0x66da
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x66d0
movq 0x8(%rsp), %rdi
callq 0x20e0
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: permutationlock[P]aes_math/lib/modular_arithmetic.cpp
// Function: Modular<int>::mulInverse() const
Modular<T> Modular<T>::mulInverse() const{
    T t = 0;
    T r = _modulus;
    T new_t = 1;
    T new_r = _val;
    while(new_r != 0){
        T quotient = r / new_r;
        T temp_t = t;
        t = new_t;
        new_t = temp_t - quotient * new_t;
        T temp_r = r;
        r = new_r;
        new_r = temp_r - quotient * new_r;
    }
    if(r>1) throw;    // Should never happen for prime field
    if(t<0) t = t+_modulus;
    return Modular<T>(t);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movl $0x0, 0x24(%rsp)
movl 0x1776c(%rip), %ecx     # 0x1e1c8
movl %ecx, 0x20(%rsp)
movl $0x1, 0x1c(%rsp)
movl (%rax), %eax
movl %eax, 0x18(%rsp)
cmpl $0x0, 0x18(%rsp)
je 0x6aca
movl 0x20(%rsp), %eax
cltd
idivl 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x10(%rsp), %eax
movl 0x14(%rsp), %ecx
imull 0x1c(%rsp), %ecx
subl %ecx, %eax
movl %eax, 0x1c(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0xc(%rsp), %eax
movl 0x14(%rsp), %ecx
imull 0x18(%rsp), %ecx
subl %ecx, %eax
movl %eax, 0x18(%rsp)
jmp 0x6a6e
cmpl $0x1, 0x20(%rsp)
jle 0x6ad6
callq 0x2240
cmpl $0x0, 0x24(%rsp)
jge 0x6aeb
movl 0x24(%rsp), %eax
addl 0x176e1(%rip), %eax     # 0x1e1c8
movl %eax, 0x24(%rsp)
leaq 0x34(%rsp), %rdi
leaq 0x24(%rsp), %rsi
callq 0x6760
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: permutationlock[P]aes_math/lib/aes.cpp
// Function: sBox(GaloisPolynomial&)
GaloisPolynomial & sBox(GaloisPolynomial & p){
    // Invert each element
    p = p.inverse();
    
    // Calculate affine transformation
    vector<Modular<int>> coef;
    for(int r=0; r<8; r++){
        Modular<int> sum(0);
        for(int c=0; c<8; c++){
            sum += p[c] * rijndael_A[r*8+c];
        }
        coef.push_back(sum);
    }
    p = GaloisPolynomial(coef);
    
    // Add polynomial b
    p += rijndael_b;
    
    return p;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq 0xa0(%rsp), %rsi
leaq 0x80(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x5e70
movq 0x18(%rsp), %rsi
movq 0xa0(%rsp), %rdi
callq 0xc390
jmp 0xa32d
leaq 0x80(%rsp), %rdi
callq 0x6f00
leaq 0x58(%rsp), %rdi
callq 0x6720
movl $0x0, 0x54(%rsp)
cmpl $0x8, 0x54(%rsp)
jge 0xa454
movl $0x0, 0x4c(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x4c(%rsp), %rsi
callq 0x6760
jmp 0xa370
movl $0x0, 0x48(%rsp)
cmpl $0x8, 0x48(%rsp)
jge 0xa431
movq 0xa0(%rsp), %rdi
movl 0x48(%rsp), %esi
callq 0x6560
movl %eax, 0x14(%rsp)
jmp 0xa39a
movl 0x14(%rsp), %eax
movl %eax, 0x40(%rsp)
movl 0x54(%rsp), %eax
movl 0x48(%rsp), %edx
movl %eax, %ecx
movl %edx, %eax
leal (%rax,%rcx,8), %eax
movslq %eax, %rsi
leaq 0x13e3d(%rip), %rdi     # 0x1e1f8
callq 0x68d0
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
callq 0x6990
movl %eax, 0x10(%rsp)
jmp 0xa3d3
movl 0x10(%rsp), %eax
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x44(%rsp), %rsi
callq 0x6910
jmp 0xa3ec
jmp 0xa3ee
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0xa378
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x6f00
jmp 0xa4e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0xa4da
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x6860
jmp 0xa442
jmp 0xa444
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0xa34c
leaq 0x20(%rsp), %rdi
leaq 0x58(%rsp), %rsi
movl $0x2, %edx
callq 0x5c70
jmp 0xa46a
movq 0xa0(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xc390
jmp 0xa47e
leaq 0x20(%rsp), %rdi
callq 0x6f00
movq 0xa0(%rsp), %rdi
leaq 0x13d91(%rip), %rsi     # 0x1e228
callq 0x5d40
jmp 0xa49e
movq 0xa0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x67e0
movq 0x8(%rsp), %rax
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x6f00
leaq 0x58(%rsp), %rdi
callq 0x67e0
movq 0x78(%rsp), %rdi
callq 0x22b0
nop
// File: permutationlock[P]aes_math/lib/aes.cpp
// Function: sBox_inverse(GaloisPolynomial&)
GaloisPolynomial & sBox_inverse(GaloisPolynomial & p){
    // Calculate affine transformation
    vector<Modular<int>> coef;
    for(int r=0; r<8; r++){
        Modular<int> sum(0);
        for(int c=0; c<8; c++){
            sum += p[c] * rijndael_A_inverse[r*8+c];
        }
        coef.push_back(sum);
    }
    p = GaloisPolynomial(coef);
    
    // Add polynomial b inverse
    p += rijndael_b_inverse;
    
    // Invert each element
    p = p.inverse();
    
    return p;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x6720
movl $0x0, 0x74(%rsp)
cmpl $0x8, 0x74(%rsp)
jge 0xa5f9
movl $0x0, 0x6c(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x6c(%rsp), %rsi
callq 0x6760
jmp 0xa535
movl $0x0, 0x58(%rsp)
cmpl $0x8, 0x58(%rsp)
jge 0xa5d6
movq 0x90(%rsp), %rdi
movl 0x58(%rsp), %esi
callq 0x6560
movl %eax, 0xc(%rsp)
jmp 0xa55f
movl 0xc(%rsp), %eax
movl %eax, 0x50(%rsp)
movl 0x74(%rsp), %eax
movl 0x58(%rsp), %edx
movl %eax, %ecx
movl %edx, %eax
leal (%rax,%rcx,8), %eax
movslq %eax, %rsi
leaq 0x13c90(%rip), %rdi     # 0x1e210
callq 0x68d0
movq %rax, %rsi
leaq 0x50(%rsp), %rdi
callq 0x6990
movl %eax, 0x8(%rsp)
jmp 0xa598
movl 0x8(%rsp), %eax
movl %eax, 0x54(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x54(%rsp), %rsi
callq 0x6910
jmp 0xa5b1
jmp 0xa5b3
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0xa53d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xa6c9
leaq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x6860
jmp 0xa5e7
jmp 0xa5e9
movl 0x74(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x74(%rsp)
jmp 0xa511
leaq 0x30(%rsp), %rdi
leaq 0x78(%rsp), %rsi
movl $0x2, %edx
callq 0x5c70
jmp 0xa60f
movq 0x90(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xc390
jmp 0xa623
leaq 0x30(%rsp), %rdi
callq 0x6f00
movq 0x90(%rsp), %rdi
leaq 0x13c0c(%rip), %rsi     # 0x1e248
callq 0x5d40
jmp 0xa643
movq 0x90(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x5e70
jmp 0xa657
movq 0x90(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xc390
jmp 0xa66b
leaq 0x10(%rsp), %rdi
callq 0x6f00
movq 0x90(%rsp), %rax
movq %rax, (%rsp)
leaq 0x78(%rsp), %rdi
callq 0x67e0
movq (%rsp), %rax
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x6f00
jmp 0xa6c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x6f00
leaq 0x78(%rsp), %rdi
callq 0x67e0
movq 0x60(%rsp), %rdi
callq 0x22b0
nopl (%rax)
// File: permutationlock[P]aes_math/lib/aes.cpp
// Function: subBytes(QSMatrix<GaloisPolynomial>&)
QSMatrix<GaloisPolynomial> & subBytes(QSMatrix<GaloisPolynomial> & state){
    Modular<int>::globalSetModulus(2);
    for(int i=0; i<state.getRows(); i++){
        for(int j=0; j<state.getCols(); j++){
            sBox(state(i,j));
        }
    }
    
    return state;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x2, 0x1c(%rsp)
leaq 0x1c(%rsp), %rdi
callq 0x68f0
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0xc3c0
movl %eax, %ecx
movl 0x10(%rsp), %eax
cmpl %ecx, %eax
jge 0xa77b
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
callq 0xc3d0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0xa76c
movq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0x14(%rsp), %rdx
callq 0xc3e0
movq %rax, %rdi
callq 0xa2f0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xa727
jmp 0xa76e
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xa703
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: permutationlock[P]aes_math/lib/aes.cpp
// Function: subBytes_inverse(QSMatrix<GaloisPolynomial>&)
QSMatrix<GaloisPolynomial> & subBytes_inverse(QSMatrix<GaloisPolynomial> & state){
    Modular<int>::globalSetModulus(2);
    for(int i=0; i<state.getRows(); i++){
        for(int j=0; j<state.getCols(); j++){
            sBox_inverse(state(i,j));
        }
    }
    
    return state;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x2, 0x1c(%rsp)
leaq 0x1c(%rsp), %rdi
callq 0x68f0
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0xc3c0
movl %eax, %ecx
movl 0x10(%rsp), %eax
cmpl %ecx, %eax
jge 0xa82b
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
callq 0xc3d0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0xa81c
movq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0x14(%rsp), %rdx
callq 0xc3e0
movq %rax, %rdi
callq 0xa4f0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xa7d7
jmp 0xa81e
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xa7b3
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: permutationlock[P]aes_math/lib/aes.cpp
// Function: shiftRows(QSMatrix<GaloisPolynomial>&)
QSMatrix<GaloisPolynomial> & shiftRows(QSMatrix<GaloisPolynomial> & state){
    for(int i=0; i<state.getRows(); i++){
        vector<GaloisPolynomial> temp;  // Save first as temp since it is overwritten
        for(int j=0; j<state.getCols(); j++){
            int c = (j+i)%state.getCols();
            temp.push_back(state(i,c));
        }
        for(int j=0; j<state.getCols(); j++){
            state(i,j) = temp[j];
        }
    }
    
    return state;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movl $0x0, 0x6c(%rsp)
movl 0x6c(%rsp), %eax
movl %eax, 0x30(%rsp)
movq 0x70(%rsp), %rdi
callq 0xc3c0
movl %eax, %ecx
movl 0x30(%rsp), %eax
cmpl %ecx, %eax
jge 0xa9c6
leaq 0x50(%rsp), %rdi
callq 0xc420
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x28(%rsp)
movq 0x70(%rsp), %rdi
callq 0xc3d0
movl %eax, 0x2c(%rsp)
jmp 0xa89b
movl 0x28(%rsp), %eax
movl 0x2c(%rsp), %ecx
cmpl %ecx, %eax
jge 0xa933
movl 0x4c(%rsp), %eax
movl 0x6c(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0x20(%rsp)
movq 0x70(%rsp), %rdi
callq 0xc3d0
movl %eax, 0x24(%rsp)
jmp 0xa8c9
movl 0x24(%rsp), %ecx
movl 0x20(%rsp), %eax
cltd
idivl %ecx
movl %edx, 0x38(%rsp)
movq 0x70(%rsp), %rdi
leaq 0x6c(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0xc3e0
movq %rax, 0x18(%rsp)
jmp 0xa8f3
movq 0x18(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0xc430
jmp 0xa904
jmp 0xa906
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0xa883
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xc2f0
jmp 0xa9d0
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x70(%rsp), %rdi
callq 0xc3d0
movl %eax, 0x14(%rsp)
jmp 0xa953
movl 0x10(%rsp), %eax
movl 0x14(%rsp), %ecx
cmpl %ecx, %eax
jge 0xa9ac
movslq 0x34(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0xc4a0
movq %rax, (%rsp)
movq 0x70(%rsp), %rdi
leaq 0x6c(%rsp), %rsi
leaq 0x34(%rsp), %rdx
callq 0xc3e0
movq %rax, 0x8(%rsp)
jmp 0xa98d
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0xc4c0
jmp 0xa99d
jmp 0xa99f
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0xa93b
leaq 0x50(%rsp), %rdi
callq 0xc2f0
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0xa851
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x22b0
nopw (%rax,%rax)
// File: permutationlock[P]aes_math/lib/aes.cpp
// Function: shiftRows_inverse(QSMatrix<GaloisPolynomial>&)
QSMatrix<GaloisPolynomial> & shiftRows_inverse(QSMatrix<GaloisPolynomial> & state){
    for(int i=0; i<state.getRows(); i++){
        vector<GaloisPolynomial> temp;  // Save first as temp since it is overwritten
        for(int j=0; j<state.getCols(); j++){
            int c = (j-i);
            if(c<0) c = state.getCols() + c;
            temp.push_back(state(i,c));
        }
        for(int j=0; j<state.getCols(); j++){
            state(i,j) = temp[j];
        }
    }
    
    return state;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movl $0x0, 0x6c(%rsp)
movl 0x6c(%rsp), %eax
movl %eax, 0x30(%rsp)
movq 0x70(%rsp), %rdi
callq 0xc3c0
movl %eax, %ecx
movl 0x30(%rsp), %eax
cmpl %ecx, %eax
jge 0xab6a
leaq 0x50(%rsp), %rdi
callq 0xc420
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x28(%rsp)
movq 0x70(%rsp), %rdi
callq 0xc3d0
movl %eax, 0x2c(%rsp)
jmp 0xaa3b
movl 0x28(%rsp), %eax
movl 0x2c(%rsp), %ecx
cmpl %ecx, %eax
jge 0xaad7
movl 0x4c(%rsp), %eax
subl 0x6c(%rsp), %eax
movl %eax, 0x38(%rsp)
cmpl $0x0, 0x38(%rsp)
jge 0xaa99
movq 0x70(%rsp), %rdi
callq 0xc3d0
movl %eax, 0x24(%rsp)
jmp 0xaa6e
movl 0x24(%rsp), %eax
addl 0x38(%rsp), %eax
movl %eax, 0x38(%rsp)
jmp 0xaa99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xc2f0
jmp 0xab74
movq 0x70(%rsp), %rdi
leaq 0x6c(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0xc3e0
movq %rax, 0x18(%rsp)
jmp 0xaab4
movq 0x18(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0xc430
jmp 0xaac5
jmp 0xaac7
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0xaa23
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x70(%rsp), %rdi
callq 0xc3d0
movl %eax, 0x14(%rsp)
jmp 0xaaf7
movl 0x10(%rsp), %eax
movl 0x14(%rsp), %ecx
cmpl %ecx, %eax
jge 0xab50
movslq 0x34(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0xc4a0
movq %rax, (%rsp)
movq 0x70(%rsp), %rdi
leaq 0x6c(%rsp), %rsi
leaq 0x34(%rsp), %rdx
callq 0xc3e0
movq %rax, 0x8(%rsp)
jmp 0xab31
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0xc4c0
jmp 0xab41
jmp 0xab43
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0xaadf
leaq 0x50(%rsp), %rdi
callq 0xc2f0
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0xa9f1
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x22b0
nop
// File: permutationlock[P]aes_math/lib/aes.cpp
// Function: extractPoly(std::vector<unsigned char, std::allocator<unsigned char>>&)
GaloisPolynomial extractPoly(vector<unsigned char> & text){
    if(text.size() == 0) return GaloisPolynomial(0);
    int n = (int) text[0];
    text.erase(text.begin());
    return GaloisPolynomial(n);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0xc970
cmpq $0x0, %rax
jne 0xace3
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x2, %edx
movl $0x8, %ecx
callq 0x5c00
jmp 0xad4a
movq 0x38(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc990
movzbl (%rax), %eax
movl %eax, 0x34(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
callq 0xca20
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xca50
movq (%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xc9b0
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
movl 0x34(%rsp), %esi
movl $0x2, %edx
movl $0x8, %ecx
callq 0x5c00
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: permutationlock[P]aes_math/lib/matrix.cpp
// Function: QSMatrix<GaloisPolynomial>::QSMatrix(int, int, std::vector<GaloisPolynomial, std::allocator<GaloisPolynomial>> const&)
QSMatrix<T>::QSMatrix(int rows, int cols, const vector<T> & _initial) {
    _mat.resize(rows);
    for (int i=0; i<_mat.size(); i++) {
        _mat[i].resize(cols);
        for (int j=0; j<_mat[i].size(); j++){
            _mat[i][j] = _initial[i*rows+j];
        }
    }
    _rows = rows;
    _cols = cols;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl %edx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0x11c01(%rip), %rax     # 0x1dd88
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, 0x20(%rsp)
callq 0xda50
movq 0x20(%rsp), %rdi
movslq 0x4c(%rsp), %rsi
callq 0xda60
jmp 0xc1a9
movl $0x0, 0x30(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x8, %rdi
callq 0xdb00
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0xc2c4
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
movslq 0x30(%rsp), %rsi
callq 0xdb20
movq %rax, %rdi
movslq 0x48(%rsp), %rsi
callq 0xdb40
jmp 0xc1fc
movl $0x0, 0x2c(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x2c(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
movslq 0x30(%rsp), %rsi
callq 0xdb20
movq %rax, %rdi
callq 0xcc30
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xc2b2
movq 0x40(%rsp), %rdi
movl 0x30(%rsp), %eax
movl 0x4c(%rsp), %ecx
imull %ecx, %eax
movl 0x2c(%rsp), %ecx
addl %ecx, %eax
movslq %eax, %rsi
callq 0xdbe0
movq 0x18(%rsp), %rdi
movq %rax, (%rsp)
addq $0x8, %rdi
movslq 0x30(%rsp), %rsi
callq 0xdb20
movq %rax, %rdi
movslq 0x2c(%rsp), %rsi
callq 0xc4a0
movq (%rsp), %rsi
movq %rax, %rdi
callq 0xc4c0
jmp 0xc286
jmp 0xc288
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xc204
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0xdc00
jmp 0xc2dc
jmp 0xc2b4
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0xc1b1
movq 0x18(%rsp), %rax
movl 0x4c(%rsp), %ecx
movl %ecx, 0x20(%rax)
movl 0x48(%rsp), %ecx
movl %ecx, 0x24(%rax)
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: permutationlock[P]aes_math/lib/matrix.cpp
// Function: QSMatrix<GaloisPolynomial>::operator*(QSMatrix<GaloisPolynomial> const&) const
QSMatrix<T> QSMatrix<T>::operator*(const QSMatrix<T>& rhs) const {
    int _rows = rhs.getRows();
    int _cols = rhs.getCols();
    QSMatrix result(_rows, _cols, 0.0);

    for (int i=0; i<_rows; i++) {
        for (int j=0; j<_cols; j++) {
            for (int k=0; k<_rows; k++) {
                result(i,j) += this->_mat[i][k] * rhs(k,j);
            }
        }
    }

    return result;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xa0(%rsp), %rdi
callq 0xc3c0
movl %eax, 0x9c(%rsp)
movq 0xa0(%rsp), %rdi
callq 0xc3d0
movl %eax, 0x98(%rsp)
movb $0x0, 0x97(%rsp)
movl 0x9c(%rsp), %eax
movl %eax, 0x28(%rsp)
movl 0x98(%rsp), %eax
movl %eax, 0x2c(%rsp)
leaq 0x70(%rsp), %rdi
movq %rdi, 0x30(%rsp)
xorl %esi, %esi
movl $0x2, %edx
movl $0x8, %ecx
callq 0x5c00
movq 0x20(%rsp), %rdi
movl 0x28(%rsp), %esi
movl 0x2c(%rsp), %edx
movq 0x30(%rsp), %rcx
callq 0xf3d0
jmp 0xc5a3
leaq 0x70(%rsp), %rdi
callq 0x6f00
movl $0x0, 0x60(%rsp)
movl 0x60(%rsp), %eax
cmpl 0x9c(%rsp), %eax
jge 0xc6f7
movl $0x0, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
cmpl 0x98(%rsp), %eax
jge 0xc6e5
movl $0x0, 0x58(%rsp)
movl 0x58(%rsp), %eax
cmpl 0x9c(%rsp), %eax
jge 0xc6d3
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
movslq 0x60(%rsp), %rsi
callq 0xf4c0
movq %rax, %rdi
movslq 0x58(%rsp), %rsi
callq 0xdbe0
movq %rax, (%rsp)
movq 0xa0(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x5c(%rsp), %rdx
callq 0xf4e0
movq %rax, 0x8(%rsp)
jmp 0xc63a
movq 0x8(%rsp), %rdx
movq (%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x6380
jmp 0xc64f
movq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x5c(%rsp), %rdx
callq 0xc3e0
movq %rax, %rdi
leaq 0x38(%rsp), %rsi
callq 0x5d40
jmp 0xc672
leaq 0x38(%rsp), %rdi
callq 0x6f00
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0xc5e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x6f00
jmp 0xc72a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0xc720
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x6f00
jmp 0xc720
jmp 0xc6d5
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0xc5ce
jmp 0xc6e7
movl 0x60(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x60(%rsp)
jmp 0xc5b5
movb $0x1, 0x97(%rsp)
testb $0x1, 0x97(%rsp)
jne 0xc713
movq 0x20(%rsp), %rdi
callq 0xc360
movq 0x10(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xc360
movq 0x68(%rsp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
nop
// File: permutationlock[P]aes_math/lib/matrix.cpp
// Function: QSMatrix<GaloisPolynomial>::operator=(QSMatrix<GaloisPolynomial> const&)
QSMatrix<T>& QSMatrix<T>::operator=(const QSMatrix<T>& rhs) {
    if (&rhs == this)
        return *this;

    int newrows = rhs.getRows();
    int newcols = rhs.getCols();

    _mat.resize(newrows);
    for (int i=0; i<_mat.size(); i++) {
        _mat[i].resize(newcols);
    }

    for (int i=0; i<newrows; i++) {
        for (int j=0; j<newcols; j++) {
            _mat[i][j] = rhs(i, j);
        }
    }
    _rows = newrows;
    _cols = newcols;

    return *this;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq %rax, 0x30(%rsp)
jne 0xc76e
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0xc893
movq 0x30(%rsp), %rdi
callq 0xc3c0
movl %eax, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
callq 0xc3d0
movq 0x10(%rsp), %rdi
movl %eax, 0x28(%rsp)
addq $0x8, %rdi
movslq 0x2c(%rsp), %rsi
callq 0xda60
movl $0x0, 0x24(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x24(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
callq 0xdb00
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xc7f7
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movslq 0x24(%rsp), %rsi
callq 0xdb20
movq %rax, %rdi
movslq 0x28(%rsp), %rsi
callq 0xdb40
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xc7a5
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0xc87b
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x28(%rsp), %eax
jge 0xc86c
movq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x1c(%rsp), %rdx
callq 0xf4e0
movq 0x10(%rsp), %rdi
movq %rax, (%rsp)
addq $0x8, %rdi
movslq 0x20(%rsp), %rsi
callq 0xdb20
movq %rax, %rdi
movslq 0x1c(%rsp), %rsi
callq 0xc4a0
movq (%rsp), %rsi
movq %rax, %rdi
callq 0xc4c0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xc811
jmp 0xc86e
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0xc7ff
movq 0x10(%rsp), %rax
movl 0x2c(%rsp), %ecx
movl %ecx, 0x20(%rax)
movl 0x28(%rsp), %ecx
movl %ecx, 0x24(%rax)
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: permutationlock[P]aes_math/lib/matrix.cpp
// Function: QSMatrix<GaloisPolynomial>::operator+=(QSMatrix<GaloisPolynomial> const&)
QSMatrix<T>& QSMatrix<T>::operator+=(const QSMatrix<T>& rhs) {
    int _rows = rhs.getRows();
    int _cols = rhs.getCols();

    for (int i=0; i<_rows; i++) {
        for (int j=0; j<_cols; j++) {
            this->_mat[i][j] += rhs(i,j);
        }
    }

    return *this;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0xc3c0
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
callq 0xc3d0
movl %eax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0xc95a
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0xc94b
movq 0x28(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xf4e0
movq 0x10(%rsp), %rdi
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
movslq 0x1c(%rsp), %rsi
callq 0xdb20
movq %rax, %rdi
movslq 0x18(%rsp), %rsi
callq 0xc4a0
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x5d40
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xc8ee
jmp 0xc94d
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xc8dc
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: permutationlock[P]aes_math/lib/matrix.cpp
// Function: QSMatrix<GaloisPolynomial>::QSMatrix(int, int, GaloisPolynomial const&)
QSMatrix<T>::QSMatrix(int rows, int cols, const T& _initial) {
    _mat.resize(rows);
    for (int i=0; i<_mat.size(); i++) {
        _mat[i].resize(cols, _initial);
    }
    _rows = rows;
    _cols = cols;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0xe991(%rip), %rax      # 0x1dd88
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, 0x18(%rsp)
callq 0xda50
movq 0x18(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xda60
jmp 0xf419
movl $0x0, 0x20(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
callq 0xdb00
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xf496
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movslq 0x20(%rsp), %rsi
callq 0xdb20
movq %rax, %rdi
movslq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0xf520
jmp 0xf46d
jmp 0xf46f
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0xf421
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0xdc00
jmp 0xf4ae
movq 0x10(%rsp), %rax
movl 0x3c(%rsp), %ecx
movl %ecx, 0x20(%rax)
movl 0x38(%rsp), %ecx
movl %ecx, 0x24(%rax)
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x22b0
nopl (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/examples/./debug_rep.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> debug_rep<int>(std::vector<int, std::allocator<int>> const&)
std::string debug_rep(const std::vector<T>& v)
{
	std::ostringstream ret;
	ret << "vector: [";
	ret << debug_rep(v.begin(), v.end());
	ret << "]";
	return ret.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1e0(%rbp)
movq %rdi, %rax
movq %rax, -0x1d8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0x21a0
movq -0x1d0(%rbp), %rdi
leaq 0x3bef(%rip), %rsi      # 0x7094
callq 0x2130
jmp 0x34ac
movq -0x10(%rbp), %rdi
callq 0x49b0
movq %rax, -0x1c0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x49e0
movq %rax, -0x1c8(%rbp)
movq -0x1c0(%rbp), %rsi
movq -0x1c8(%rbp), %rdx
leaq -0x1b8(%rbp), %rdi
callq 0x4850
jmp 0x34e8
leaq -0x188(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x2110
jmp 0x34fd
leaq -0x1b8(%rbp), %rdi
callq 0x20c0
leaq 0x3b8e(%rip), %rsi      # 0x709e
leaq -0x188(%rbp), %rdi
callq 0x2130
jmp 0x351e
movq -0x1e0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x2160
jmp 0x3533
leaq -0x188(%rbp), %rdi
callq 0x2030
movq -0x1d8(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x3581
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x20c0
leaq -0x188(%rbp), %rdi
callq 0x2030
movq -0x190(%rbp), %rdi
callq 0x2240
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/examples/./debug_rep.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> debug_rep<int>(int*)
std::string debug_rep(T* p)
{
#ifdef DEBUG
	std::cout << "T*" << "\t";
#endif
	std::ostringstream ret;
	ret << "pointer: " << p;         // print the pointer's own value
	if (p)
		ret << " " << debug_rep(*p); // print the value to which p points
	else
		ret << " null pointer";      // or indicate that the p is null
	return ret.str(); // return a copy of the string to which ret is bound
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x7a0d(%rip), %rdi      # 0xafd8
leaq 0x3ad9(%rip), %rsi      # 0x70ab
callq 0x2130
movq %rax, %rdi
leaq 0x3a32(%rip), %rsi      # 0x7013
callq 0x2130
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0x21a0
movq -0x1c8(%rbp), %rdi
leaq 0x3aa7(%rip), %rsi      # 0x70ae
callq 0x2130
movq %rax, -0x1c0(%rbp)
jmp 0x3615
movq -0x1c0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x20f0
jmp 0x3627
cmpq $0x0, -0x10(%rbp)
je 0x36b7
leaq 0x3a7d(%rip), %rsi      # 0x70b6
leaq -0x188(%rbp), %rdi
callq 0x2130
movq %rax, -0x1e0(%rbp)
jmp 0x364e
movq -0x10(%rbp), %rsi
leaq -0x1b8(%rbp), %rdi
callq 0x4a50
jmp 0x3660
movq -0x1e0(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x2110
jmp 0x3675
leaq -0x1b8(%rbp), %rdi
callq 0x20c0
jmp 0x36ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x36ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x20c0
jmp 0x36ff
leaq 0x39fa(%rip), %rsi      # 0x70b8
leaq -0x188(%rbp), %rdi
callq 0x2130
jmp 0x36cc
jmp 0x36ce
movq -0x1d8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x2160
jmp 0x36e3
leaq -0x188(%rbp), %rdi
callq 0x2030
movq -0x1d0(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
leaq -0x188(%rbp), %rdi
callq 0x2030
movq -0x190(%rbp), %rdi
callq 0x2240
nopw (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/examples/./debug_rep.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> debug_rep<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>(__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>)
std::string debug_rep(T b, T e)
{
	std::ostringstream ret;
	for (T it = b; it != e; ++it) {
		if (it != b)
			ret << ",";            // put comma before all but the first element
		ret << debug_rep(*it);     // print the element
	}
	return ret.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x21a0
movq -0x10(%rbp), %rax
movq %rax, -0x198(%rbp)
leaq -0x198(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x4a10
testb $0x1, %al
jne 0x48a8
jmp 0x495b
leaq -0x198(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x4a10
testb $0x1, %al
jne 0x48be
jmp 0x48ec
leaq 0x27db(%rip), %rsi      # 0x70a0
leaq -0x190(%rbp), %rdi
callq 0x2130
jmp 0x48d3
jmp 0x48ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x498c
leaq -0x198(%rbp), %rdi
callq 0x4b20
movq %rax, %rsi
leaq -0x1c8(%rbp), %rdi
callq 0x4a50
jmp 0x4909
leaq -0x190(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x2110
jmp 0x491e
leaq -0x1c8(%rbp), %rdi
callq 0x20c0
leaq -0x198(%rbp), %rdi
callq 0x4b40
jmp 0x488f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x20c0
jmp 0x498c
movq -0x1d8(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x2160
jmp 0x4970
leaq -0x190(%rbp), %rdi
callq 0x2030
movq -0x1d0(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
leaq -0x190(%rbp), %rdi
callq 0x2030
movq -0x1a0(%rbp), %rdi
callq 0x2240
nopw %cs:(%rax,%rax)
nop
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/examples/./debug_rep.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> debug_rep<int>(int const&)
std::string debug_rep(const T& t)
{
#ifdef DEBUG
	std::cout << "const T&" << "\t";
#endif
	std::ostringstream ret;
	ret << t; // uses T's output operator to print a representation of t
	return ret.str();  // return a copy of the string to which ret is bound
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, -0x1b0(%rbp)
movq %rdi, %rax
movq %rax, -0x1a8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x655d(%rip), %rdi      # 0xafd8
leaq 0x2620(%rip), %rsi      # 0x70a2
callq 0x2130
movq %rax, %rdi
leaq 0x2582(%rip), %rsi      # 0x7013
callq 0x2130
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1a0(%rbp)
callq 0x21a0
movq -0x1a0(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x2230
jmp 0x4abd
movq -0x1b0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x2160
jmp 0x4ad2
leaq -0x188(%rbp), %rdi
callq 0x2030
movq -0x1a8(%rbp), %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x2030
movq -0x190(%rbp), %rdi
callq 0x2240
nopl (%rax,%rax)