LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, (%rdi)
leaq 0x611c(%rip), %rdx      # 0xa3da
movq %rdi, 0x8(%rsp)
movq %rdx, %rsi
callq 0x5182
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x43ba
xorl %r15d, %r15d
movl $0xd1b71759, %ebx       # imm = 0xD1B71759
movl (%rax,%r15,4), %r12d
movl %r12d, %ebp
negl %ebp
cmovsl %r12d, %ebp
movl $0x1, %r13d
cmpl $0xa, %ebp
jb 0x4339
movl $0x4, %r13d
movl %ebp, %eax
cmpl $0x63, %eax
jbe 0x4330
cmpl $0x3e7, %eax            # imm = 0x3E7
jbe 0x4336
cmpl $0x2710, %eax           # imm = 0x2710
jb 0x4339
movl %eax, %ecx
imulq %rbx, %rcx
shrq $0x2d, %rcx
addl $0x4, %r13d
cmpl $0x1869f, %eax          # imm = 0x1869F
movl %ecx, %eax
ja 0x4300
addl $-0x3, %r13d
jmp 0x4339
addl $-0x2, %r13d
jmp 0x4339
decl %r13d
shrl $0x1f, %r12d
leal (%r12,%r13), %esi
leaq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
movl $0x2d, %edx
callq 0x2140
addq 0x18(%rsp), %r12
movq %r12, %rdi
movl %r13d, %esi
movl %ebp, %edx
callq 0x4d69
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2120
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x43a0
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2110
incq %r15
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r15, %rcx
ja 0x42e0
movq 0x8(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x43f2
movq %rax, %r14
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x43f2
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2110
movq 0x8(%rsp), %rax
movq (%rax), %rdi
cmpq 0x10(%rsp), %rdi
je 0x4411
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2110
movq %r14, %rdi
callq 0x21b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x429a
movq 0xa59e(%rip), %rax      # 0xf120
subq 0xa58f(%rip), %rax      # 0xf118
movq 0x8(%r14), %rcx
subq (%r14), %rcx
shrq $0x2, %rax
shrq $0x2, %rcx
subl %eax, %ecx
cmpl $-0x2, %ecx
jg 0x4be7
xorl %r12d, %r12d
leaq 0x54b3(%rip), %r15      # 0xa05c
movl $0x1, %r8d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x2120
incl %r12d
movq 0xa558(%rip), %rax      # 0xf120
subq 0xa549(%rip), %rax      # 0xf118
shrq $0x2, %rax
movq 0x8(%r14), %rcx
subq (%r14), %rcx
shrq $0x2, %rcx
notl %ecx
addl %eax, %ecx
cmpl %ecx, %r12d
jl 0x4ba9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x4c10
movq (%rbx), %rsi
incq %rsi
callq 0x2110
movq %r14, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl 0xa4f6(%rip), %ecx      # 0xf138
movl (%rdi), %edx
testl %edx, %edx
je 0x4c70
xorl %edi, %edi
movl $0x1, %r9d
movl %ecx, %eax
movl %edx, %r8d
cltd
idivl %r8d
movl %r9d, %esi
imull %r9d, %eax
subl %eax, %edi
movl %r8d, %eax
movl %edi, %r9d
movl %esi, %edi
testl %edx, %edx
jne 0x4c52
jmp 0x4c75
xorl %esi, %esi
movl %ecx, %r8d
cmpl $0x2, %r8d
jge 0x4c85
movl %esi, %eax
sarl $0x1f, %eax
andl %ecx, %eax
addl %esi, %eax
retq
pushq %rax
callq 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x457c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e52
movl 0x18(%rsp), %eax
movl %eax, 0x18(%rbx)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5747
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
xorl %r13d, %r13d
movq %rsp, %r15
xorl %ebp, %ebp
movl $0x0, (%rsp)
xorl %r12d, %r12d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x4b32
movq 0x99e9(%rip), %rcx      # 0xf168
addq %r13, %rcx
imull (%rcx,%r12,4), %eax
movl 0x99ab(%rip), %ecx      # 0xf138
cltd
idivl %ecx
movl %edx, %eax
addl (%rsp), %eax
cltd
idivl %ecx
movl %edx, (%rsp)
incq %r12
cmpq $0x8, %r12
jne 0x576d
movq 0x28(%rsp), %rsi
cmpq 0x30(%rsp), %rsi
je 0x57bd
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x28(%rsp)
jmp 0x57c8
movq %r14, %rdi
movq %r15, %rdx
callq 0x50a0
incq %rbp
addq $0x20, %r13
cmpq $0x8, %rbp
jne 0x5763
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
movl $0x2, %edx
callq 0x445c
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4e52
movl 0x18(%rsp), %eax
movl %eax, 0x18(%rbx)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x580f
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
leaq 0x9982(%rip), %rsi      # 0xf198
movq %rbx, %rdi
callq 0x44e0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x5835
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x587b
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x587e
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
jmp 0x587e
jmp 0x587b
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5895
movq 0x10(%rsp), %rsi
jmp 0x588d
jmp 0x587b
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x5895
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
movq %rbx, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
xorl %r13d, %r13d
movq %rsp, %r15
xorl %ebp, %ebp
movl $0x0, (%rsp)
xorl %r12d, %r12d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x4b32
movq 0x989a(%rip), %rcx      # 0xf180
addq %r13, %rcx
imull (%rcx,%r12,4), %eax
movl 0x9844(%rip), %ecx      # 0xf138
cltd
idivl %ecx
movl %edx, %eax
addl (%rsp), %eax
cltd
idivl %ecx
movl %edx, (%rsp)
incq %r12
cmpq $0x8, %r12
jne 0x58d4
movq 0x28(%rsp), %rsi
cmpq 0x30(%rsp), %rsi
je 0x5924
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x28(%rsp)
jmp 0x592f
movq %r14, %rdi
movq %r15, %rdx
callq 0x50a0
incq %rbp
addq $0x20, %r13
cmpq $0x8, %rbp
jne 0x58ca
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
movl $0x2, %edx
callq 0x445c
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4e52
movl 0x18(%rsp), %eax
movl %eax, 0x18(%rbx)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5976
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
leaq 0x983b(%rip), %rsi      # 0xf1b8
movq %rbx, %rdi
callq 0x44e0
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x457c
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4e52
movl 0x18(%rsp), %eax
movl %eax, 0x18(%rbx)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x59b8
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x59cf
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x59e7
jmp 0x5a06
jmp 0x5a06
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5a09
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
jmp 0x5a09
jmp 0x5a06
jmp 0x5a06
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x5a20
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
movq %rbx, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x2, 0x96fa(%rip)      # 0xf138
movl 0x20(%rdi), %ecx
testl %ecx, %ecx
jle 0x5a87
movl 0x24(%rbx), %eax
xorl %r14d, %r14d
testl %eax, %eax
jle 0x5a7c
leaq (%r14,%r14,2), %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
addq %r12, %rdi
callq 0x5700
incq %r13
movslq 0x24(%rbx), %rax
addq $0x20, %r12
cmpq %rax, %r13
jl 0x5a59
movl 0x20(%rbx), %ecx
incq %r14
movslq %ecx, %rdx
cmpq %rdx, %r14
jl 0x5a4b
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x2, 0x968e(%rip)      # 0xf138
movl 0x20(%rdi), %ecx
testl %ecx, %ecx
jle 0x5af3
movl 0x24(%rbx), %eax
xorl %r14d, %r14d
testl %eax, %eax
jle 0x5ae8
leaq (%r14,%r14,2), %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
addq %r12, %rdi
callq 0x589d
incq %r13
movslq 0x24(%rbx), %rax
addq $0x20, %r12
cmpq %rax, %r13
jl 0x5ac5
movl 0x20(%rbx), %ecx
incq %r14
movslq %ecx, %rdx
cmpq %rdx, %r14
jl 0x5ab7
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x20(%rdi)
jle 0x5bd0
xorl %ecx, %ecx
movq %rcx, 0x8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movl 0x24(%rbx), %ecx
testl %ecx, %ecx
jle 0x5bb1
xorl %r13d, %r13d
movq 0x8(%rsp), %r14
leaq (%r14,%r14,2), %r12
leaq 0x10(%rsp), %r15
leal (%r14,%r13), %eax
cltd
idivl %ecx
movq 0x8(%rbx), %rax
shlq $0x5, %rdx
addq (%rax,%r12,8), %rdx
movq %r15, %rdi
movq %rdx, %rsi
callq 0x6da4
incl %r13d
movl 0x24(%rbx), %ecx
cmpl %ecx, %r13d
jl 0x5b4b
testl %ecx, %ecx
jle 0x5bb1
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x10(%rsp), %r14
leaq (%r14,%r13), %rsi
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %r15
leaq (%r15,%r13), %rdi
callq 0x4e52
movl 0x18(%r14,%r13), %eax
movl %eax, 0x18(%r15,%r13)
incq %rbp
movslq 0x24(%rbx), %rax
addq $0x20, %r13
cmpq %rax, %rbp
jl 0x5b7d
leaq 0x10(%rsp), %rdi
callq 0x6d3c
movq 0x8(%rsp), %rcx
incq %rcx
movslq 0x20(%rbx), %rax
cmpq %rax, %rcx
jl 0x5b1d
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5be4
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6d3c
movq %rbx, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x20(%rdi)
jle 0x5ce3
movq $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movl 0x24(%rbx), %eax
testl %eax, %eax
jle 0x5cbc
xorl %ebp, %ebp
movq (%rsp), %rcx
leaq (%rcx,%rcx,2), %r13
movq 0x8(%rsp), %r15
leaq 0x10(%rsp), %r14
movl %r15d, %ecx
sarl $0x1f, %ecx
andl %eax, %ecx
movq 0x8(%rbx), %rax
movslq %ecx, %rsi
addq %r15, %rsi
shlq $0x5, %rsi
addq (%rax,%r13,8), %rsi
movq %r14, %rdi
callq 0x6da4
incl %ebp
movl 0x24(%rbx), %eax
incq %r15
cmpl %eax, %ebp
jl 0x5c51
testl %eax, %eax
jle 0x5cbc
xorl %r15d, %r15d
xorl %ebp, %ebp
movq 0x10(%rsp), %r12
leaq (%r12,%r15), %rsi
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %r14
leaq (%r14,%r15), %rdi
callq 0x4e52
movl 0x18(%r12,%r15), %eax
movl %eax, 0x18(%r14,%r15)
incq %rbp
movslq 0x24(%rbx), %rax
addq $0x20, %r15
cmpq %rax, %rbp
jl 0x5c88
leaq 0x10(%rsp), %rdi
callq 0x6d3c
movq (%rsp), %rdx
incq %rdx
movslq 0x20(%rbx), %rax
decq 0x8(%rsp)
movq %rdx, (%rsp)
cmpq %rax, %rdx
jl 0x5c25
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5cf7
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6d3c
movq %rbx, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rdi
movq 0x8(%rsi), %rdx
cmpq %rdi, %rdx
je 0x5e2d
movq %rsi, %r14
movzbl (%rdi), %ebp
leaq 0x1(%rdi), %rsi
cmpq %rdx, %rsi
je 0x5e24
subq %rsi, %rdx
callq 0x2170
movq 0x8(%r14), %rdx
decq %rdx
movq %rdx, 0x8(%r14)
jmp 0x5e2f
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
movl $0x2, %edx
movl $0x8, %ecx
callq 0x441a
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/permutationlock[P]aes_math/lib/aes.cpp
// Function: keyExpandCore(std::vector<GaloisPolynomial, std::allocator<GaloisPolynomial>>&, int)
vector<GaloisPolynomial>& keyExpandCore(vector<GaloisPolynomial> & word, int iteration){
    // Do a simple left rotate of bytes
    GaloisPolynomial temp(word[0]);
    word[0] = word[1];
    word[1] = word[2];
    word[2] = word[3];
    word[3] = temp;
    
    // Apply S-Box to each byte
    for(int i=0; i<4; i++){
        sBox(word[i]);
    }
    
    // Apply Rcon operation (add 2^(iteration-1) to word[0])
    vector<Modular<int>> v;
    for(int i=0; i<iteration-2; i++){
        v.push_back(0);
    }
    v.push_back(1);
    word[0] += GaloisPolynomial(v);
    
    return word;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rsi
leaq 0x38(%rsp), %rdi
callq 0x2ffc
movq (%rbx), %r14
leaq 0x20(%r14), %rsi
movq %r14, %rdi
callq 0x4e52
movl 0x38(%r14), %eax
movl %eax, 0x18(%r14)
movq (%rbx), %r14
leaq 0x40(%r14), %rsi
leaq 0x20(%r14), %rdi
callq 0x4e52
movl 0x58(%r14), %eax
movl %eax, 0x38(%r14)
movq (%rbx), %r14
leaq 0x60(%r14), %rsi
leaq 0x40(%r14), %rdi
callq 0x4e52
movl 0x78(%r14), %eax
movl %eax, 0x58(%r14)
movq (%rbx), %r14
leaq 0x60(%r14), %rdi
leaq 0x38(%rsp), %rsi
callq 0x4e52
movl 0x50(%rsp), %eax
movl %eax, 0x78(%r14)
xorl %r14d, %r14d
movq (%rbx), %rdi
addq %r14, %rdi
callq 0x5700
addq $0x20, %r14
cmpq $0x80, %r14
jne 0x5eca
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
cmpl $0x2, %ebp
jle 0x5f5b
addl $-0x2, %ebp
movq %rsp, %r14
leaq 0x18(%rsp), %r15
movl $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x5f27
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x5f32
movq %r14, %rdi
movq %r15, %rdx
callq 0x4f7a
decl %ebp
jne 0x5f02
movq 0x8(%rsp), %rsi
movl $0x1, 0x18(%rsp)
cmpq 0x10(%rsp), %rsi
je 0x5f65
movl $0x1, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x5f72
movl $0x1, 0x18(%rsp)
xorl %esi, %esi
movq %rsp, %rdi
leaq 0x18(%rsp), %rdx
callq 0x4f7a
leaq 0x18(%rsp), %rdi
movq %rsp, %rsi
movl $0x2, %edx
callq 0x445c
movq (%rbx), %rdi
leaq 0x18(%rsp), %rsi
callq 0x44e0
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x5fa8
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5fbe
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x5fd5
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6005
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x6008
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
jmp 0x6008
jmp 0x6005
jmp 0x6020
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6023
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
jmp 0x6023
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x603a
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
movq %rbx, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, 0x40(%rsp)
movl %edx, 0x4(%rsp)
movq %rdi, %rbx
leaq 0x8195(%rip), %rax      # 0xed88
movq %rax, (%rdi)
addq $0x8, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
movl %esi, 0x1c(%rsp)
movslq %esi, %rsi
movq %rdi, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
callq 0x73c0
movq 0x8(%rbx), %rax
cmpq %rax, 0x10(%rbx)
je 0x6d06
movslq 0x4(%rsp), %rcx
movq %rcx, 0x30(%rsp)
shlq $0x5, 0x20(%rsp)
movq $0x0, 0x8(%rsp)
xorl %esi, %esi
movq %rbx, 0x28(%rsp)
movq %rsi, 0x38(%rsp)
leaq (%rsi,%rsi,2), %r13
leaq (%rax,%r13,8), %rdi
movq 0x30(%rsp), %rsi
callq 0x743c
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax,%r13,8), %r15
cmpq %r15, 0x8(%rax,%r13,8)
je 0x6cc8
xorl %r12d, %r12d
movq 0x8(%rsp), %rbp
xorl %ebx, %ebx
movq 0x40(%rsp), %rax
movq (%rax), %r14
leaq (%r14,%rbp), %rsi
leaq (%r15,%r12), %rdi
callq 0x4e52
movl 0x18(%r14,%rbp), %eax
movl %eax, 0x18(%r15,%r12)
incq %rbx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax,%r13,8), %r15
movq 0x8(%rax,%r13,8), %rcx
subq %r15, %rcx
sarq $0x5, %rcx
addq $0x20, %rbp
addq $0x20, %r12
cmpq %rbx, %rcx
ja 0x6c81
movq 0x38(%rsp), %rsi
incq %rsi
movq 0x28(%rsp), %rbx
movq 0x10(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
movq 0x8(%rsp), %rdx
addq 0x20(%rsp), %rdx
movq %rdx, 0x8(%rsp)
cmpq %rsi, %rcx
ja 0x6c4d
movl 0x1c(%rsp), %eax
movl %eax, 0x20(%rbx)
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6d27
jmp 0x6d27
movq %rax, %r14
movq 0x10(%rsp), %rdi
callq 0x746c
movq %r14, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, 0x50(%rsp)
movq %rdi, %r14
movl 0x20(%rdx), %r15d
movq %rdx, 0x48(%rsp)
movl 0x24(%rdx), %r13d
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
movl $0x8, %ecx
callq 0x441a
movq %r14, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %r12
movl %r15d, %esi
movq %r13, 0x18(%rsp)
movl %r13d, %edx
movq %rbx, %rcx
callq 0x7ab6
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x6e41
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
testl %r12d, %r12d
jle 0x6f0b
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rbp
movq $0x0, 0x10(%rsp)
leaq 0x20(%rsp), %rbx
cmpl $0x0, 0x18(%rsp)
jle 0x6ef5
movq 0x10(%rsp), %rax
leaq (%rax,%rax,2), %r13
xorl %r14d, %r14d
movq %r14, 0x40(%rsp)
shlq $0x5, %r14
xorl %r15d, %r15d
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rax
movq %r15, %rsi
shlq $0x5, %rsi
addq (%rax,%r13,8), %rsi
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
leaq (%r15,%r15,2), %rcx
movq (%rax,%rcx,8), %rdx
addq %r14, %rdx
movq %rbx, %rdi
callq 0x498a
movq (%rbp), %rax
movq (%rax,%r13,8), %rdi
addq %r14, %rdi
movq %rbx, %rsi
callq 0x44e0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x6ede
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
incq %r15
cmpq %r12, %r15
jne 0x6e84
movq 0x40(%rsp), %r14
incq %r14
cmpq 0x18(%rsp), %r14
jne 0x6e78
movq 0x10(%rsp), %rcx
incq %rcx
movq %rcx, 0x10(%rsp)
cmpq %r12, %rcx
jne 0x6e61
movq 0x8(%rsp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x6f71
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
jmp 0x6f71
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x6f5a
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
jmp 0x6f5a
movq %rax, %rbx
leaq 0x7e27(%rip), %rax      # 0xed88
movq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq %rbp, %rdi
callq 0x746c
movq %rbx, %rdi
callq 0x21b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpq %rdi, %rsi
je 0x70a2
movq %rsi, %r14
movl 0x20(%rsi), %eax
movl 0x24(%rsi), %ecx
movq %rcx, (%rsp)
leaq 0x8(%rbx), %r15
movq %rax, 0x8(%rsp)
movslq %eax, %rsi
movq %r15, %rdi
callq 0x73c0
movq 0x8(%rbx), %rdi
cmpq %rdi, 0x10(%rbx)
je 0x6ffc
movslq (%rsp), %r12
xorl %ebp, %ebp
xorl %r13d, %r13d
addq %rbp, %rdi
movq %r12, %rsi
callq 0x743c
incq %r13
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rax
subq %rdi, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
addq $0x18, %rbp
cmpq %r13, %rax
ja 0x6fc8
movq %rbx, 0x18(%rsp)
cmpl $0x0, 0x8(%rsp)
jle 0x708e
movq (%rsp), %r13
shlq $0x5, %r13
movq $0x0, 0x10(%rsp)
cmpl $0x0, (%rsp)
jle 0x707a
movq 0x10(%rsp), %rax
leaq (,%rax,8), %rax
leaq (%rax,%rax,2), %rax
movq %rax, 0x20(%rsp)
xorl %ebx, %ebx
movq 0x8(%r14), %rax
movq 0x20(%rsp), %rdx
movq (%rax,%rdx), %rbp
leaq (%rbx,%rbp), %rsi
movq (%r15), %rax
movq %r15, %r12
movq %r14, %r15
movq (%rax,%rdx), %r14
leaq (%r14,%rbx), %rdi
callq 0x4e52
movl 0x18(%rbp,%rbx), %eax
movl %eax, 0x18(%r14,%rbx)
movq %r15, %r14
movq %r12, %r15
addq $0x20, %rbx
cmpq %rbx, %r13
jne 0x703b
movq 0x10(%rsp), %rdx
incq %rdx
movq %rdx, 0x10(%rsp)
cmpq 0x8(%rsp), %rdx
jne 0x701d
movq 0x18(%rsp), %rbx
movq 0x8(%rsp), %rax
movl %eax, 0x20(%rbx)
movq (%rsp), %rax
movl %eax, 0x24(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movslq 0x20(%rsi), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
jle 0x7129
movq %rsi, %r14
movl 0x24(%rsi), %r13d
movq %r13, 0x8(%rsp)
shlq $0x5, %r13
xorl %ebp, %ebp
cmpl $0x0, 0x8(%rsp)
jle 0x711f
leaq (,%rbp,8), %rax
leaq (%rax,%rax,2), %r15
xorl %r12d, %r12d
movq 0x8(%r14), %rax
movq (%rax,%r15), %rsi
addq %r12, %rsi
movq 0x8(%rbx), %rax
movq (%rax,%r15), %rdi
addq %r12, %rdi
callq 0x44e0
addq $0x20, %r12
cmpq %r12, %r13
jne 0x70fb
incq %rbp
cmpq 0x10(%rsp), %rbp
jne 0x70e5
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movl %edx, 0x8(%rsp)
movq %rdi, %r15
leaq 0x72b3(%rip), %rax      # 0xed88
movq %rax, (%rdi)
addq $0x8, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
movq $0x0, 0x18(%r15)
movl %esi, 0xc(%rsp)
movslq %esi, %rsi
movq %rdi, 0x10(%rsp)
callq 0x73c0
movq 0x8(%r15), %rdi
cmpq %rdi, 0x10(%r15)
je 0x7b48
movslq 0x8(%rsp), %r13
xorl %ebx, %ebx
movabsq $-0x5555555555555555, %rbp # imm = 0xAAAAAAAAAAAAAAAB
xorl %r12d, %r12d
addq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x7b7e
incq %r12
movq 0x8(%r15), %rdi
movq 0x10(%r15), %rax
subq %rdi, %rax
sarq $0x3, %rax
imulq %rbp, %rax
addq $0x18, %rbx
cmpq %r12, %rax
ja 0x7b1b
movl 0xc(%rsp), %eax
movl %eax, 0x20(%r15)
movl 0x8(%rsp), %eax
movl %eax, 0x24(%r15)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7b69
movq %rax, %r14
movq 0x10(%rsp), %rdi
callq 0x746c
movq %r14, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1b0(%rbp), %r15
movq %r15, %rdi
callq 0x2160
leaq 0x1f35(%rip), %rsi      # 0x50be
movl $0x9, %edx
movq %r15, %rdi
callq 0x2150
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq -0x38(%rbp), %rdi
callq 0x3b36
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x1b0(%rbp), %rdi
callq 0x2150
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x31d3
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2140
leaq 0x1eee(%rip), %rsi      # 0x50c8
leaq -0x1b0(%rbp), %rdi
movl $0x1, %edx
callq 0x2150
leaq -0x1a8(%rbp), %rsi
movq %rbx, %rdi
callq 0x21b0
movq 0x3dcf(%rip), %rsi      # 0x6fd0
leaq -0x1b0(%rbp), %rdi
callq 0x20b0
leaq -0x140(%rbp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x324d
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x324d
jmp 0x324a
movq %rax, %rbx
movq 0x3d7c(%rip), %rsi      # 0x6fd0
leaq -0x1b0(%rbp), %rdi
callq 0x20b0
leaq -0x140(%rbp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
movq 0x3d47(%rip), %r15      # 0x6fd8
leaq 0x1e3d(%rip), %rsi      # 0x50d5
movl $0x2, %edx
movq %r15, %rdi
callq 0x2150
leaq 0x1d67(%rip), %rsi      # 0x5013
movl $0x1, %edx
movq %r15, %rdi
callq 0x2150
leaq -0x1b0(%rbp), %r15
movq %r15, %rdi
callq 0x2160
leaq 0x1e09(%rip), %rsi      # 0x50d8
movl $0x9, %edx
movq %r15, %rdi
callq 0x2150
leaq -0x1b0(%rbp), %rdi
movq %r14, %rsi
callq 0x20e0
testq %r14, %r14
je 0x3343
leaq 0x1de9(%rip), %rsi      # 0x50e0
leaq -0x1b0(%rbp), %rdi
movl $0x1, %edx
callq 0x2150
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x3c64
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x1b0(%rbp), %rdi
callq 0x2150
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x335b
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x335b
leaq 0x1d98(%rip), %rsi      # 0x50e2
leaq -0x1b0(%rbp), %rdi
movl $0xd, %edx
callq 0x2150
leaq -0x1a8(%rbp), %rsi
movq %rbx, %rdi
callq 0x21b0
movq 0x3c5f(%rip), %rsi      # 0x6fd0
leaq -0x1b0(%rbp), %rdi
callq 0x20b0
leaq -0x140(%rbp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x33bd
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x33bd
jmp 0x33ba
movq %rax, %rbx
movq 0x3c0c(%rip), %rsi      # 0x6fd0
leaq -0x1b0(%rbp), %rdi
callq 0x20b0
leaq -0x140(%rbp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, -0x50(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x2160
cmpq %r14, %r15
je 0x3bd1
xorl %ebx, %ebx
leaq -0x48(%rbp), %r12
leaq -0x1c8(%rbp), %r13
testq %rbx, %rbx
je 0x3b8b
movl $0x1, %edx
movq %r13, %rdi
leaq 0x1544(%rip), %rsi      # 0x50ca
callq 0x2150
leaq (%r15,%rbx), %rsi
movq %r12, %rdi
callq 0x3c64
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r13, %rdi
callq 0x2150
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3bc0
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2140
leaq (%r15,%rbx), %rax
addq $0x4, %rax
addq $0x4, %rbx
cmpq %r14, %rax
jne 0x3b72
leaq -0x1c0(%rbp), %rsi
movq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x21b0
movq 0x33e5(%rip), %rsi      # 0x6fd0
leaq -0x1c8(%rbp), %rdi
callq 0x20b0
leaq -0x158(%rbp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3c1c
jmp 0x3c1c
movq %rax, %r14
jmp 0x3c3d
movq %rax, %r14
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3c3d
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2140
movq 0x338c(%rip), %rsi      # 0x6fd0
leaq -0x1c8(%rbp), %rdi
callq 0x20b0
leaq -0x158(%rbp), %rdi
callq 0x2060
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rsi, %r14
movq %rdi, %rbx
movq 0x3357(%rip), %r15      # 0x6fd8
leaq 0x1444(%rip), %rsi      # 0x50cc
movl $0x8, %edx
movq %r15, %rdi
callq 0x2150
leaq 0x1377(%rip), %rsi      # 0x5013
movl $0x1, %edx
movq %r15, %rdi
callq 0x2150
leaq -0x190(%rbp), %r15
movq %r15, %rdi
callq 0x2160
movl (%r14), %esi
movq %r15, %rdi
callq 0x21e0
leaq -0x188(%rbp), %rsi
movq %rbx, %rdi
callq 0x21b0
movq 0x32f7(%rip), %rsi      # 0x6fd0
leaq -0x190(%rbp), %rdi
callq 0x20b0
leaq -0x120(%rbp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x32c4(%rip), %rsi      # 0x6fd0
leaq -0x190(%rbp), %rdi
callq 0x20b0
leaq -0x120(%rbp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/vssense[P]Compiler/src/shlang/flag_manager.cpp
// Function: GetFlagInfo(int, char const**, FlagInfo*)
void GetFlagInfo(const int argc, const char** argv, FlagInfo* info)
{
    assert(argv);
    assert(info);

    for (int i = 1; i < argc; ++i)
    {
        if (argv[i][0] == '-')
        {
            GetFlag(argv, info, &i);
        }
        else
        {
            if (info->input_file != nullptr)
            {
                printf("error : more than one input files\n");
                return;
            }

            info->input_file = argv[i];
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rsi, %rsi
je 0x160e
movq %rdx, %rbx
testq %rdx, %rdx
je 0x162d
movl %edi, %r15d
movl $0x1, -0x24(%rbp)
cmpl $0x2, %edi
jl 0x15e9
movq %rsi, %r14
movl $0x1, %eax
leaq -0x24(%rbp), %r12
movslq %eax, %rcx
movq (%r14,%rcx,8), %rcx
cmpb $0x2d, (%rcx)
jne 0x15d6
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x13a4
movl -0x24(%rbp), %eax
jmp 0x15df
cmpq $0x0, (%rbx)
jne 0x15f6
movq %rcx, (%rbx)
incl %eax
movl %eax, -0x24(%rbp)
cmpl %r15d, %eax
jl 0x15b7
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xfb0(%rip), %rdi       # 0x25ad
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1080
leaq 0xeec(%rip), %rdi       # 0x2501
leaq 0xeea(%rip), %rsi       # 0x2506
leaq 0xf53(%rip), %rcx       # 0x2576
movl $0x4c, %edx
callq 0x1050
leaq 0x9d0(%rip), %rdi       # 0x2004
leaq 0xecb(%rip), %rsi       # 0x2506
leaq 0xf34(%rip), %rcx       # 0x2576
movl $0x4d, %edx
callq 0x1050
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lib/node.json.hxx
// Function: bool cxon::imp::read_string_value_extract_nans_<cxon::JSON<test::kind::unquoted_keys_traits>, cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const*, cxon::context<cxon::JSON<test::kind::unquoted_keys_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>, cxon::napa::imp::cst<cxon::node::json::extract_nans, bool, true>>>(cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const*&, char const*, cxon::context<cxon::JSON<test::kind::unquoted_keys_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>, cxon::napa::imp::cst<cxon::node::json::extract_nans, bool, true>>&)
static bool read_string_value_extract_nans_(N& n, S& s, II& i, II e, Cx& cx) {
                if (read_value<X>(s, i, e, cx)) {
                    using real = typename N::real;
                    using symbol = typename S::value_type;
                         if (s == nmst_<symbol>::pinf) n.template imbue<real>() =  std::numeric_limits<real>::infinity();
                    else if (s == nmst_<symbol>::ninf) n.template imbue<real>() = -std::numeric_limits<real>::infinity();
                    else if (s == nmst_<symbol>::nan ) n.template imbue<real>() =  std::numeric_limits<real>::quiet_NaN();
                    return true;
                }
                return false;
            }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
callq 0x15ecc
movl %eax, %ebp
testb %al, %al
je 0x79d5
leaq 0x3d12f(%rip), %rsi     # 0x44a91
movq %r14, %rdi
callq 0x40b0
testl %eax, %eax
je 0x799e
leaq 0x3d11b(%rip), %rsi     # 0x44a90
movq %r14, %rdi
callq 0x40b0
testl %eax, %eax
je 0x79a8
leaq 0x3d2c0(%rip), %rsi     # 0x44c48
movq %r14, %rdi
callq 0x40b0
testl %eax, %eax
jne 0x79d5
movsd 0x3c76c(%rip), %xmm0    # 0x44108
jmp 0x79b0
movsd 0x3c772(%rip), %xmm0    # 0x44118
jmp 0x79b0
movsd 0x3c760(%rip), %xmm0    # 0x44110
cmpl $0x3, 0x20(%rbx)
je 0x79d1
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x13dae
movsd 0x8(%rsp), %xmm0
movl $0x3, 0x20(%rbx)
movsd %xmm0, (%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lang/json/node/node.hxx
// Function: cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>::operator=(cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const&)
basic_node& operator =(const basic_node& o)
                noexcept(value::is_nothrow_copy_assignable<basic_node>::value)
            {
                switch (o.kind_) {
#                   define CXON_JSON_TYPE_DEF(T)    case node_kind::T: return value::copy_assign<T>(*this, o)
                        CXON_JSON_TYPE_DEF(object);
                        CXON_JSON_TYPE_DEF(array);
                        CXON_JSON_TYPE_DEF(string);
                        CXON_JSON_TYPE_DEF(real);
                        CXON_JSON_TYPE_DEF(sint);
                        CXON_JSON_TYPE_DEF(uint);
                        CXON_JSON_TYPE_DEF(boolean);
                        CXON_JSON_TYPE_DEF(null);
#                   undef CXON_JSON_TYPE_DEF
                }
                return *this; // LCOV_EXCL_LINE
            }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x20(%rsi), %eax
cmpq $0x7, %rax
ja 0x7eed
movq %rsi, %r14
leaq 0x3c2f6(%rip), %rcx     # 0x44120
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x16a54
cmpl $0x4, 0x20(%rbx)
je 0x7e5a
movq %rbx, %rdi
callq 0x13dae
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movq (%r14), %rax
movq %rax, (%rbx)
jmp 0x7eed
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x16b16
cmpl $0x3, 0x20(%rbx)
je 0x7e8c
movq %rbx, %rdi
callq 0x13dae
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movsd (%r14), %xmm0
movsd %xmm0, (%rbx)
jmp 0x7eed
cmpl $0x7, 0x20(%rbx)
je 0x7eac
movq %rbx, %rdi
callq 0x13dae
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movq $0x0, (%rbx)
jmp 0x7eed
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x16ab6
cmpl $0x5, 0x20(%rbx)
jne 0x7e4b
jmp 0x7e5a
cmpl $0x6, 0x20(%rbx)
je 0x7ee8
movq %rbx, %rdi
callq 0x13dae
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movb (%r14), %al
movb %al, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lang/cbor/node/node.hxx
// Function: cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>>::basic_node(cxon::cbor::basic_node<cxon::cbor::ordered_node_traits<std::allocator<char>>> const&)
basic_node(const basic_node& o)
                noexcept(value::is_nothrow_copy_constructible<basic_node>::value)
            :   kind_(o.kind_), alloc_(std::allocator_traits<allocator_type>::select_on_container_copy_construction(o.alloc_))
            {
                switch (o.kind_) {
#                   define CXON_CBOR_TYPE_DEF(T)    case node_kind::T: value::copy_construct<T>(*this, o); break
                        CXON_CBOR_TYPE_DEF(map);
                        CXON_CBOR_TYPE_DEF(array);
                        CXON_CBOR_TYPE_DEF(tag);
                        CXON_CBOR_TYPE_DEF(bytes);
                        CXON_CBOR_TYPE_DEF(text);
                        CXON_CBOR_TYPE_DEF(real);
                        CXON_CBOR_TYPE_DEF(sint);
                        CXON_CBOR_TYPE_DEF(uint);
                        CXON_CBOR_TYPE_DEF(simple);
                        CXON_CBOR_TYPE_DEF(boolean);
                        CXON_CBOR_TYPE_DEF(null);
                        CXON_CBOR_TYPE_DEF(undefined);
#                   undef CXON_CBOR_TYPE_DEF
                }
            }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
cmpl $0x2, %eax
jne 0x8215
movq (%r14), %r14
movl $0x30, %edi
callq 0x4230
movq %rax, (%rbx)
movq (%r14), %rcx
movq %rcx, (%rax)
addq $0x8, %rax
addq $0x8, %r14
movq %rax, %rbx
jmp 0x81e6
cmpl $0xa, %eax
ja 0x82a7
movl %eax, %eax
leaq 0x3bf19(%rip), %rcx     # 0x44140
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%r14), %rax
movq %rax, (%rbx)
jmp 0x82a7
movb (%r14), %al
movb %al, (%rbx)
jmp 0x82a7
movq (%r14), %r14
movl $0x18, %edi
callq 0x4230
movq %rax, (%rbx)
leaq 0x7(%rsp), %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x22704
jmp 0x82a7
movq (%r14), %r14
movl $0x18, %edi
callq 0x4230
movq %rax, (%rbx)
leaq 0x6(%rsp), %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x225d8
jmp 0x82a7
movq $0x0, (%rbx)
jmp 0x82a7
leaq 0x5(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2281c
jmp 0x82a7
movsd (%r14), %xmm0
movsd %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13922
nop
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/src/cbor/cbor.node-main.cxx
// Function: test::kind::test::hex2bin(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::string hex2bin(const std::string& hex) {
            static constexpr unsigned char hex_[256] = {
                /*  0*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                /* 16*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                /* 32*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                /* 48*/ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0,
                /* 64*/ 0,10,11,12,13,14,15, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                /* 80*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                /* 96*/ 0,10,11,12,13,14,15, 0, 0, 0, 0, 0, 0, 0, 0, 0
            };
            CXON_ASSERT(hex.length() % 2 == 0, "invalid input");
            std::string bin;
                for (std::size_t i = 0, is = hex.length(); i != is; i += 2) {
                    char const b = char((hex_[(unsigned)hex[i]] << 4) + hex_[(unsigned)hex[i + 1]]);
                    bin += b;
                }
            return bin;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r12
testq %r12, %r12
je 0x9882
movq %rsi, %r14
xorl %r13d, %r13d
leaq 0x3b72d(%rip), %rbp     # 0x44f80
movq (%r14), %rax
movsbq (%rax,%r13), %rcx
movl %ecx, %ecx
movb (%rcx,%rbp), %cl
shlb $0x4, %cl
movsbq 0x1(%rax,%r13), %rax
movl %eax, %eax
addb (%rax,%rbp), %cl
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x4200
addq $0x2, %r13
cmpq %r13, %r12
jne 0x9853
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x98a4
callq 0x4220
movq %r14, %rdi
callq 0x43b0