LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/lmclaramunt[P]AES-Crypto/Cipher.cpp
// Function: Cipher::keyExpansion(unsigned char*, unsigned char**)
void Cipher::keyExpansion(unsigned char* key, unsigned char** keyExpanded) {
    unsigned char temp[4];
    int i = 0;
    
    while(i < Nk) {
        for(int j=0; j<4; j++) keyExpanded[i][j] = key[4*i+j];
        i++;
    }
    i = Nk;
    while (i < 4*(Nr+1)) {
        for(int j=0; j<4; j++) temp[j] = keyExpanded[i-1][j];
        if (i % Nk == 0) {
            unsigned char rcon[4];
            Rcon(i/Nk, rcon);
            RotWord(temp);
            subWord(temp);
            for(int j=0; j<4; j++) temp[j] ^= rcon[j];
        } else if (Nk > 6 && i % Nk == 4) {
            subWord(temp);
        }
        for(int j=0; j<4; j++) 
            keyExpanded[i][j] = keyExpanded[i-Nk][j] ^ temp[j];
        i++;
    }
}

// Assembly:
movq %rdx, %rcx
movl 0x18(%rdi), %edx
testl %edx, %edx
jle 0x4de9
xorl %eax, %eax
xorl %edx, %edx
movb (%rsi,%rdx), %r8b
movq (%rcx,%rax,8), %r9
movb %r8b, (%r9,%rdx)
incq %rdx
cmpq $0x4, %rdx
jne 0x4dc4
incq %rax
movslq 0x18(%rdi), %rdx
addq $0x4, %rsi
cmpq %rdx, %rax
jl 0x4dc2
movl 0x1c(%rdi), %eax
leal 0x4(,%rax,4), %eax
cmpl %eax, %edx
jge 0x4f10
movslq %edx, %rsi
leaq 0x280b(%rip), %r8       # 0x7610
leaq 0x2604(%rip), %r9       # 0x7410
movq -0x8(%rcx,%rsi,8), %rax
movl (%rax), %eax
movl %eax, -0x8(%rsp)
movl 0x18(%rdi), %r10d
movl %esi, %eax
cltd
idivl %r10d
testl %edx, %edx
je 0x4e5f
cmpl $0x7, %r10d
jl 0x4ece
cmpl $0x4, %edx
jne 0x4ece
xorl %eax, %eax
movzbl -0x8(%rsp,%rax), %edx
movl %edx, %r10d
andl $0xf, %r10d
andl $-0x10, %edx
addq %r9, %rdx
movb (%r10,%rdx), %dl
movb %dl, -0x8(%rsp,%rax)
incq %rax
cmpq $0x4, %rax
jne 0x4e3a
jmp 0x4ece
movl %esi, %eax
cltd
idivl %r10d
cltq
movb -0x1(%rax,%r8), %al
movb %al, -0x4(%rsp)
movb $0x0, -0x1(%rsp)
movw $0x0, -0x3(%rsp)
movb -0x8(%rsp), %al
movb -0x7(%rsp), %dl
movb %dl, -0x8(%rsp)
movzwl -0x6(%rsp), %edx
movw %dx, -0x7(%rsp)
movb %al, -0x5(%rsp)
xorl %eax, %eax
movzbl -0x8(%rsp,%rax), %edx
movl %edx, %r10d
andl $0xf, %r10d
andl $-0x10, %edx
addq %r9, %rdx
movb (%r10,%rdx), %dl
movb %dl, -0x8(%rsp,%rax)
incq %rax
cmpq $0x4, %rax
jne 0x4e98
xorl %eax, %eax
movb -0x4(%rsp,%rax), %dl
xorb %dl, -0x8(%rsp,%rax)
incq %rax
cmpq $0x4, %rax
jne 0x4ebd
xorl %eax, %eax
movslq 0x18(%rdi), %rdx
movq %rsi, %r10
subq %rdx, %r10
movq (%rcx,%r10,8), %rdx
movb -0x8(%rsp,%rax), %r10b
xorb (%rdx,%rax), %r10b
movq (%rcx,%rsi,8), %rdx
movb %r10b, (%rdx,%rax)
incq %rax
cmpq $0x4, %rax
jne 0x4ed0
incq %rsi
movl 0x1c(%rdi), %eax
leal 0x4(,%rax,4), %eax
cltq
cmpq %rax, %rsi
jl 0x4e0c
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/lmclaramunt[P]AES-Crypto/Cipher.cpp
// Function: Cipher::shiftColumnsByOne(unsigned char**, int*, bool)
void Cipher::shiftColumnsByOne(unsigned char** st, int* row, bool leftDir) {
    if(leftDir) {
        for(int column = 0; column < 3; column++) {
            unsigned char temp = st[*row][column];
            int next = (column + 1) % 4;
            st[*row][column] = st[*row][next];
            st[*row][next] = temp;
        }
    } else {
        for(int column = 3; column > 0; column--) {
            unsigned char temp = st[*row][column];
            int next = (column + 1) % 4;
            st[*row][column] = st[*row][next];
            st[*row][next] = temp;
        }
    }
}

// Assembly:
testl %ecx, %ecx
je 0x4fac
movl $0x1, %eax
movslq (%rdx), %rcx
movq (%rsi,%rcx,8), %rcx
movb -0x1(%rcx,%rax), %dil
movb (%rcx,%rax), %r8b
movb %r8b, -0x1(%rcx,%rax)
movslq (%rdx), %rcx
movq (%rsi,%rcx,8), %rcx
movb %dil, (%rcx,%rax)
incq %rax
cmpq $0x4, %rax
jne 0x4f81
jmp 0x4fe1
movl $0x4, %eax
movslq (%rdx), %rcx
movq (%rsi,%rcx,8), %rcx
movb -0x1(%rcx,%rax), %dil
movl %eax, %r8d
andl $0x3, %r8d
movb (%rcx,%r8), %r9b
movb %r9b, -0x1(%rcx,%rax)
movslq (%rdx), %rcx
movq (%rsi,%rcx,8), %rcx
movb %dil, (%rcx,%r8)
decq %rax
cmpq $0x1, %rax
ja 0x4fb1
retq
// File: /workspace/github_cpp_makefile_star2_O1/lmclaramunt[P]AES-Crypto/Cipher.cpp
// Function: Cipher::shiftColumnsByTwo(unsigned char**, int*)
void Cipher::shiftColumnsByTwo(unsigned char** st, int* row) {
    for(int column = 0; column < 2; column++) {
        unsigned char temp = st[*row][column];
        st[*row][column] = st[*row][column+2];
        st[*row][column+2] = temp;
    }
}

// Assembly:
xorl %eax, %eax
movslq (%rdx), %rcx
movq (%rsi,%rcx,8), %rcx
movb (%rcx,%rax), %dil
movb 0x2(%rcx,%rax), %r8b
movb %r8b, (%rcx,%rax)
movslq (%rdx), %rcx
movq (%rsi,%rcx,8), %rcx
movb %dil, 0x2(%rcx,%rax)
incq %rax
cmpq $0x1, %rax
je 0x4fe4
retq
// File: /workspace/github_cpp_makefile_star2_O1/lmclaramunt[P]AES-Crypto/Cipher.cpp
// Function: Cipher::shiftRows(unsigned char**)
void Cipher::shiftRows(unsigned char** st) {
    int row = 1;
    shiftColumnsByOne(st, &row, true);
    shiftColumnsByTwo(st, &(++row));
    shiftColumnsByOne(st, &(++row), false);   //Shift to the right by 1 is equivalent to shift to the left by 3
}

// Assembly:
movl $0x1, %eax
movq 0x8(%rsi), %rcx
movb -0x1(%rcx,%rax), %dl
movb (%rcx,%rax), %dil
movb %dil, -0x1(%rcx,%rax)
movq 0x8(%rsi), %rcx
movb %dl, (%rcx,%rax)
incq %rax
cmpq $0x4, %rax
jne 0x5013
xorl %eax, %eax
movq 0x10(%rsi), %rcx
movb (%rcx,%rax), %dl
movb 0x2(%rcx,%rax), %dil
movb %dil, (%rcx,%rax)
movq 0x10(%rsi), %rcx
movb %dl, 0x2(%rcx,%rax)
incq %rax
cmpq $0x1, %rax
je 0x5036
movl $0x4, %eax
movq 0x18(%rsi), %rcx
movb -0x1(%rcx,%rax), %dl
movl %eax, %edi
andl $0x3, %edi
movb (%rcx,%rdi), %r8b
movb %r8b, -0x1(%rcx,%rax)
movq 0x18(%rsi), %rcx
movb %dl, (%rcx,%rdi)
decq %rax
cmpq $0x1, %rax
ja 0x505c
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/lmclaramunt[P]AES-Crypto/Cipher.cpp
// Function: Cipher::gFMultiply(unsigned char, unsigned char)
unsigned char Cipher::gFMultiply(unsigned char matrixValue, unsigned char st) {
    unsigned char mul = 0x00;
    if (matrixValue%0x02) {
        mul = st;
        matrixValue -= 0x01;
    }
    while (matrixValue) {
        unsigned char xt = st;
        for (int i=0; i < (int)log2(matrixValue); i++){
            xt = xTime(xt);
        }
        mul ^= xt;
        matrixValue %= (unsigned)(int)pow(2, (int)log2(matrixValue));
    }
    return mul;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movl %esi, %edx
xorl %ebx, %ebx
testb $0x1, %dl
cmovnel %ebp, %ebx
andb $-0x2, %dl
je 0x513c
movzbl %dl, %r14d
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x2410
cvttsd2si %xmm0, %eax
movl %ebp, %r15d
testl %eax, %eax
jle 0x510a
xorl %r12d, %r12d
movl %ebp, %r15d
leal (%r15,%r15), %eax
movzbl %al, %ecx
xorb $0x1b, %al
testb %r15b, %r15b
movzbl %al, %r15d
cmovnsl %ecx, %r15d
incl %r12d
movsd 0x8(%rsp), %xmm0
callq 0x2410
cvttsd2si %xmm0, %eax
cmpl %eax, %r12d
jl 0x50df
xorb %r15b, %bl
movsd 0x8(%rsp), %xmm0
callq 0x2410
cvttsd2si %xmm0, %edi
movsd 0x22dc(%rip), %xmm0     # 0x7400
callq 0x2340
cvttsd2si %xmm0, %ecx
movl %r14d, %eax
xorl %edx, %edx
divl %ecx
testl %edx, %edx
jne 0x50b7
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/lmclaramunt[P]AES-Crypto/Cipher.cpp
// Function: Cipher::mixColumns(unsigned char**, unsigned char**)
void Cipher::mixColumns(unsigned char** st, unsigned char** s2){
    unsigned char matrixValues[4] = {0x02, 0x03, 0x01, 0x01};
    for (int i=0; i < 4; i++) {
        for (unsigned int j=0; j < 4; j++) {
            if (i==0) {
                s2[j] = new unsigned char[4];
            }
            unsigned int temp = 0;
            for (unsigned int k=0; k < 4; k++) {
                temp ^= gFMultiply(matrixValues[(k-j)%4], st[k][i]);
            }
            s2[j][i] = temp;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %r14
xorl %r15d, %r15d
leaq 0x2672(%rip), %r12      # 0x77de
xorl %r13d, %r13d
xorl %ebx, %ebx
testq %r15, %r15
jne 0x5189
movl $0x4, %edi
callq 0x2030
movq 0x8(%rsp), %rcx
movq %rax, (%rcx,%rbx,8)
movq %rbx, 0x10(%rsp)
xorl %ebx, %ebx
xorl %ebp, %ebp
leal (%rbx,%r13), %eax
andl $0x3, %eax
movzbl (%rax,%r12), %esi
movq (%r14,%rbx,8), %rax
movzbl (%rax,%r15), %edx
callq 0x5096
movzbl %al, %eax
xorl %eax, %ebp
incq %rbx
cmpq $0x4, %rbx
jne 0x5192
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rbx
movq (%rax,%rbx,8), %rax
movb %bpl, (%rax,%r15)
incq %rbx
decq %r13
cmpq $0x4, %rbx
jne 0x5171
incq %r15
cmpq $0x4, %r15
jne 0x516c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/lmclaramunt[P]AES-Crypto/Cipher.cpp
// Function: Cipher::invShiftRows(unsigned char**)
void Cipher::invShiftRows(unsigned char** st) {
    int row = 1;
    shiftColumnsByOne(st, &row, false);
    shiftColumnsByTwo(st, &(++row));
    shiftColumnsByOne(st, &(++row), true);   //Shift to the left by 1 is equivalent to shift to the right by 3
}

// Assembly:
movl $0x4, %eax
movq 0x8(%rsi), %rcx
movb -0x1(%rcx,%rax), %dl
movl %eax, %edi
andl $0x3, %edi
movb (%rcx,%rdi), %r8b
movb %r8b, -0x1(%rcx,%rax)
movq 0x8(%rsi), %rcx
movb %dl, (%rcx,%rdi)
decq %rax
cmpq $0x1, %rax
ja 0x5495
xorl %eax, %eax
movq 0x10(%rsi), %rcx
movb (%rcx,%rax), %dl
movb 0x2(%rcx,%rax), %dil
movb %dil, (%rcx,%rax)
movq 0x10(%rsi), %rcx
movb %dl, 0x2(%rcx,%rax)
incq %rax
cmpq $0x1, %rax
je 0x54bd
movl $0x1, %eax
movq 0x18(%rsi), %rcx
movb -0x1(%rcx,%rax), %dl
movb (%rcx,%rax), %dil
movb %dil, -0x1(%rcx,%rax)
movq 0x18(%rsi), %rcx
movb %dl, (%rcx,%rax)
incq %rax
cmpq $0x4, %rax
jne 0x54e3
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/lmclaramunt[P]AES-Crypto/Cipher.cpp
// Function: Cipher::invSubBytes(unsigned char**)
void Cipher::invSubBytes(unsigned char** st) {
    for(int i = 0; i < 4; i++) {
        for(int j=0; j < 4; j++) {
            int k = (int)st[i][j];
            st[i][j] = sboxInv[k/16][k%16];
        }
    }
}

// Assembly:
xorl %eax, %eax
leaq 0x2001(%rip), %rcx      # 0x7510
xorl %edx, %edx
movq (%rsi,%rax,8), %rdi
movzbl (%rdi,%rdx), %r8d
movl %r8d, %r9d
andl $0xf, %r9d
andl $-0x10, %r8d
addq %rcx, %r8
movb (%r9,%r8), %r8b
movb %r8b, (%rdi,%rdx)
incq %rdx
cmpq $0x4, %rdx
jne 0x5511
incq %rax
cmpq $0x4, %rax
jne 0x550f
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/lmclaramunt[P]AES-Crypto/Cipher.cpp
// Function: Cipher::invMixColumns(unsigned char**, unsigned char**)
void Cipher::invMixColumns(unsigned char** st, unsigned char** s2) {
    unsigned char matrixValues[4] = {0x0e, 0x0b, 0x0d, 0x09};
    for (int i=0; i < 4; i++) {
        for (unsigned int j=0; j < 4; j++) {
            if (i==0) {
                s2[j] = new unsigned char[4];
            }
            unsigned int temp = 0;
            for (unsigned int k=0; k < 4; k++) {
                temp ^= gFMultiply(matrixValues[(k-j)%4], st[k][i]);
            }
            s2[j][i] = temp;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %r14
xorl %r15d, %r15d
leaq 0x227e(%rip), %r12      # 0x77e2
xorl %r13d, %r13d
xorl %ebx, %ebx
testq %r15, %r15
jne 0x5581
movl $0x4, %edi
callq 0x2030
movq 0x8(%rsp), %rcx
movq %rax, (%rcx,%rbx,8)
movq %rbx, 0x10(%rsp)
xorl %ebx, %ebx
xorl %ebp, %ebp
leal (%rbx,%r13), %eax
andl $0x3, %eax
movzbl (%rax,%r12), %esi
movq (%r14,%rbx,8), %rax
movzbl (%rax,%r15), %edx
callq 0x5096
movzbl %al, %eax
xorl %eax, %ebp
incq %rbx
cmpq $0x4, %rbx
jne 0x558a
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rbx
movq (%rax,%rbx,8), %rax
movb %bpl, (%rax,%r15)
incq %rbx
decq %r13
cmpq $0x4, %rbx
jne 0x5569
incq %r15
cmpq $0x4, %r15
jne 0x5564
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/lmclaramunt[P]AES-Crypto/Cipher.cpp
// Function: Cipher::CBC_MAC(Block, bool, bool)
Sequence Cipher::CBC_MAC(Block block, bool encrypting, bool padding){
    Sequence tag(16);
    unsigned char* mssgLength;
    getMessageLength(&mssgLength, encrypting, padding);
    tag.setSequence(mssgLength);
    encrypt(&tag, macKeyExp);
    int i = -1;
    for(Sequence sq: block.getSequenceVector()){
        i++;
        if(!encrypting && (i < 1)) continue;    //First block of ciphertext contains MAC Tag, so ommit it
        tag = tag ^ sq;
        encrypt(&tag, macKeyExp);               //Using a different key than authorization!!
    }
    return tag;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %r12
movq %r12, %rdi
movl $0x10, %esi
callq 0x31dc
leaq 0x20(%rsp), %r13
movq %r14, %rdi
movq %r13, %rsi
movl %ebx, %edx
movl %ebp, %ecx
callq 0x58c8
movq (%r13), %rsi
movq %r12, %rdi
callq 0x31f8
movq 0x8(%r14), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x525e
movq %r15, %rdi
callq 0x3568
movq (%rax), %r13
movq 0x8(%rax), %rbp
cmpq %rbp, %r13
je 0x58b0
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movq %rsp, %r15
movups (%r13), %xmm0
movaps %xmm0, 0x10(%rsp)
testl %r12d, %r12d
setns %al
orb %bl, %al
cmpb $0x1, %al
jne 0x58a4
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
callq 0x335d
movq (%rax), %rcx
movq %rcx, (%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x8(%rsp)
movq 0x8(%r14), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x525e
addq $0x10, %r13
incl %r12d
cmpq %rbp, %r13
jne 0x5864
movq (%rsp), %rax
movl 0x8(%rsp), %edx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/lmclaramunt[P]AES-Crypto/Cipher.cpp
// Function: Cipher::getMessageLength(unsigned char**, bool, bool)
void Cipher::getMessageLength(unsigned char** s, bool encrypting, bool padding){
    *s = new  unsigned char[16];
    ifstream text(*textPath, ios::binary);
    text.seekg(0, ios::end);
    int length = text.tellg();                     //Get the file's length
    if(encrypting){                                //Length will be the ciphertext length
        length += 32;                              //Add IV and MAC's Tag length
        if(padding) 
            length += (length%16 == 0) ? 16 : (length%16);
    }
    unsigned char bytes[sizeof length];
    std::copy(static_cast<const unsigned char*>(static_cast<const void*>(&length)),
          static_cast<const unsigned char*>(static_cast<const void*>(&length)) + sizeof length,
          bytes);
    for(int i = 0; i < sizeof length; i++)      //First 4 bytes will have length values
        (*s)[i] = bytes[i];
    for(int i = sizeof length; i < 16; i++)     //The remained will be initialzed to zero
        (*s)[i] = 0x00;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movl $0x10, %edi
callq 0x2030
movq %rax, (%rbx)
movq 0x28(%r15), %rsi
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movl $0x4, %edx
callq 0x2380
movq %r15, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x22d0
leaq 0x10(%rsp), %rdi
callq 0x23f0
testb %r14b, %r14b
je 0x5944
addl $0x20, %eax
testb %bpl, %bpl
je 0x5944
leal 0xf(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
andl $-0x10, %ecx
movl %eax, %edx
subl %ecx, %edx
movl $0x10, %ecx
cmovnel %edx, %ecx
addl %eax, %ecx
movl %ecx, %eax
movl %eax, 0xc(%rsp)
xorl %eax, %eax
movb 0xc(%rsp,%rax), %cl
movq (%rbx), %rdx
movb %cl, (%rdx,%rax)
incq %rax
cmpq $0x4, %rax
jne 0x594a
movl $0x4, %eax
movq (%rbx), %rcx
movb $0x0, (%rcx,%rax)
incq %rax
cmpq $0x10, %rax
jne 0x5962
leaq 0x10(%rsp), %rdi
callq 0x2070
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x598c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2400
nop
// File: /workspace/github_cpp_makefile_star2_O1/lmclaramunt[P]AES-Crypto/Cipher.cpp
// Function: Cipher::authenticateSequences(Sequence*, Sequence*)
bool Cipher::authenticateSequences(Sequence* first, Sequence* second){
    bool same = true;
    for(int i=0; i < 16; i++){
        if(first->getSequence()[i] != second->getSequence()[i]){
            same = false;
            break;
        }
    }
    return same;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rsi, %rdi
callq 0x31f0
movq (%rax), %rax
movb (%rax), %bpl
movq %rbx, %rdi
callq 0x31f0
movq (%rax), %rax
cmpb (%rax), %bpl
jne 0x5a07
xorl %eax, %eax
movq %rax, %r15
cmpq $0xf, %rax
je 0x59fe
movq %r14, %rdi
callq 0x31f0
movq (%rax), %rax
movb 0x1(%rax,%r15), %bpl
movq %rbx, %rdi
callq 0x31f0
movq (%rax), %rcx
leaq 0x1(%r15), %rax
cmpb 0x1(%rcx,%r15), %bpl
je 0x59cf
cmpq $0xf, %r15
setae %al
jmp 0x5a09
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/lmclaramunt[P]AES-Crypto/Cipher.cpp
// Function: Cipher::removePadding(Sequence*)
void Cipher::removePadding(Sequence* lastPlainText) { 
    int paddingValue = lastPlainText->getSequence()[15];    //Last byte tells how many bytes to remove      
    bool error = false;
    for(int i = 15; i > 16-paddingValue; i--){
        if(lastPlainText->getSequence()[i] != paddingValue){
            error = true;
            break;
        }
    }
    if(!error){
        lastPlainText->setSize(16-paddingValue);
    }else
        throw "Padding error!\n";   //Error if the last block doesn't containt `10` in its last bytes
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x31f0
movq (%rax), %rax
movzbl 0xf(%rax), %r15d
movl $0x10, %r14d
subq %r15, %r14
cmpq $0x2, %r15
jb 0x5a5d
movl $0xf, %r12d
movq %rbx, %rdi
callq 0x31f0
movq (%rax), %rax
cmpb %r15b, (%rax,%r12)
jne 0x5a73
decq %r12
cmpq %r14, %r12
jg 0x5a44
movq %rbx, %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x31fc
movl $0x8, %edi
callq 0x2120
leaq 0x1c9f(%rip), %rcx      # 0x7723
movq %rcx, (%rax)
movq 0x5532(%rip), %rsi      # 0xafc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O1/lmclaramunt[P]AES-Crypto/Cipher.cpp
// Function: Cipher::writePlainText()
void Cipher::writePlainText(){
    ofstream plaintext;
    plaintext.open(*textPath, ios::binary);
    int i = -1;
    for(Sequence sq: inputBlock->getSequenceVector()){
        i++;
        if(i <= 1) continue;           //Don't write neither IV nor MAC Tag in Plaintext
        plaintext.write((const char*)sq.getSequence(), sq.getSize());
    }
    plaintext.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x23c0
movq 0x28(%rbx), %rsi
movq %r14, %rdi
movl $0x4, %edx
callq 0x2100
movq 0x10(%rbx), %rdi
callq 0x3568
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x5b25
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rsp, %rbx
leaq 0x18(%rsp), %r14
movups (%r12), %xmm0
movaps %xmm0, (%rsp)
testl %ebp, %ebp
jle 0x5b1a
movq %rbx, %rdi
callq 0x31f0
movq (%rax), %r15
movq %rbx, %rdi
callq 0x31f4
movslq %eax, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x22c0
addq $0x10, %r12
incl %ebp
cmpq %r13, %r12
jne 0x5aec
leaq 0x18(%rsp), %rdi
callq 0x2300
movq 0x549a(%rip), %rax      # 0xafd0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x20(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x18(%rsp,%rcx)
callq 0x21d0
leaq 0x110(%rsp), %rdi
callq 0x20b0
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5b79
jmp 0x5b79
jmp 0x5b79
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2320
movq %rbx, %rdi
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O1/lmclaramunt[P]AES-Crypto/Cipher.cpp
// Function: Cipher::writeCipherText(Sequence*)
void Cipher::writeCipherText(Sequence* tag){
    ofstream ciphertext;
    ciphertext.open(*textPath, ios::binary);
    ciphertext.write((const char*)tag->getSequence(), tag->getSize());
    for(Sequence sq: inputBlock->getSequenceVector()){
    ciphertext.write((const char*)sq.getSequence(), sq.getSize());
    }
    ciphertext.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x23c0
movq 0x28(%rbx), %rsi
movq %r15, %rdi
movl $0x4, %edx
callq 0x2100
movq %r14, %rdi
callq 0x31f0
movq (%rax), %r15
movq %r14, %rdi
callq 0x31f4
movslq %eax, %rdx
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x22c0
movq 0x10(%rbx), %rdi
callq 0x3568
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x5c35
movq %rsp, %rbx
leaq 0x10(%rsp), %r14
movups (%r12), %xmm0
movaps %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x31f0
movq (%rax), %r15
movq %rbx, %rdi
callq 0x31f4
movslq %eax, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x22c0
addq $0x10, %r12
cmpq %r13, %r12
jne 0x5c02
leaq 0x10(%rsp), %rdi
callq 0x2300
movq 0x538a(%rip), %rax      # 0xafd0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x18(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x10(%rsp,%rcx)
callq 0x21d0
leaq 0x108(%rsp), %rdi
callq 0x20b0
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x5c86
jmp 0x5c86
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2320
movq %rbx, %rdi
callq 0x2400
nop
// File: /workspace/github_cpp_makefile_star2_O1/lmclaramunt[P]AES-Crypto/Cipher.cpp
// Function: Cipher::CBC_encrypt()
void Cipher::CBC_encrypt(){
    Sequence ivSq(16), ivOriginal(16);      //ivOriginal keeps track of IV, to write it in ciphertext
    generateKey(ivSq.getSequence(), 4);
    ivOriginal.updateSequence(ivSq);
    
    //Encrypt
    for(Sequence sq: inputBlock->getSequenceVector()){  
        ivSq = sq ^ ivSq;
        encrypt(&ivSq, aesKeyExp);
    }

    //Authenticate
    inputBlock->getSequenceVector().
        insert(inputBlock->getSequenceVector().begin(), ivOriginal);    //Append IV to Ciphertext
    Sequence tag = CBC_MAC(*inputBlock, true, true);    // both bool true since we are encrypting with padding
    
    //Write ciphertext after encryption and authentication
    writeCipherText(&tag);
    /* Sequence cleanup as it can leave traces in memory */
    ivSq.~Sequence();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
movl $0x10, %esi
callq 0x31dc
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movl $0x10, %esi
callq 0x31dc
movq %r14, %rdi
callq 0x31f0
movq (%rax), %rsi
movl $0x4, %edx
callq 0x4bc2
movq (%r14), %rsi
movl 0x8(%r14), %edx
movq %r15, %rdi
callq 0x327e
movq 0x10(%rbx), %rdi
callq 0x3568
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x5d49
leaq 0x10(%rsp), %r14
movq %rsp, %r15
movups (%r12), %xmm0
movaps %xmm0, 0x10(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x335d
movq (%rax), %rcx
movq %rcx, (%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x8(%rsp)
movq (%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x525e
addq $0x10, %r12
cmpq %r13, %r12
jne 0x5d0f
movq 0x10(%rbx), %rdi
callq 0x3568
movq %rax, %r14
movq 0x10(%rbx), %rdi
callq 0x3568
movq (%rax), %rsi
leaq 0x40(%rsp), %rdx
movq %r14, %rdi
callq 0x634a
movq 0x10(%rbx), %rsi
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x6448
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x57f0
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
movl %edx, 0x8(%r14)
leaq 0x28(%rsp), %rdi
callq 0x352e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5b8e
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x352e
movq %rbx, %rdi
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O1/lmclaramunt[P]AES-Crypto/Cipher.cpp
// Function: Cipher::OFB_encrypt()
void Cipher::OFB_encrypt(){   
    Sequence ivSq(16), ivOriginal(16);
    time_t rawtime;
    struct tm * timeinfo;
    unsigned char iv[16];
    time(&rawtime);
    timeinfo = localtime(&rawtime);
    strftime ((char *)iv, 16, "%r", timeinfo);
    ivSq.setSequence(iv);
    ivOriginal.updateSequence(ivSq);        //Keep track of IV to write it in Ciphertext
    
    //Encrypt
    for(Sequence sq: inputBlock->getSequenceVector()){
        encrypt(&ivSq, aesKeyExp);
        sq = sq ^ ivSq;
    }

    //Authenticate
    inputBlock->getSequenceVector().
        insert(inputBlock->getSequenceVector().begin(), ivOriginal);    //Append IV to Ciphertext
    Sequence tag = CBC_MAC(*inputBlock, true, false);       //Get MAC Tag, we are encrypting without padding
    
    //Write ciphertext after encryption and authentication
    writeCipherText(&tag);
    /* Sequence cleanup as it can leave traces in memory */
    ivSq.~Sequence();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movl $0x10, %esi
callq 0x31dc
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movl $0x10, %esi
callq 0x31dc
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x2200
movq %r12, %rdi
callq 0x2190
leaq 0x1713(%rip), %rdx      # 0x7769
leaq 0x50(%rsp), %r12
movl $0x10, %esi
movq %r12, %rdi
movq %rax, %rcx
callq 0x21b0
movq %r14, %rdi
movq %r12, %rsi
callq 0x31f8
movq (%r14), %rsi
movl 0x8(%r14), %edx
movq %r15, %rdi
callq 0x327e
movq 0x10(%rbx), %rdi
callq 0x3568
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x60cd
leaq 0x40(%rsp), %r14
movq %rsp, %r15
movups (%r12), %xmm0
movaps %xmm0, (%rsp)
movq (%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x525e
movq %r15, %rdi
movq %r14, %rsi
callq 0x335d
addq $0x10, %r12
cmpq %r13, %r12
jne 0x60a2
movq 0x10(%rbx), %rdi
callq 0x3568
movq %rax, %r14
movq 0x10(%rbx), %rdi
callq 0x3568
movq (%rax), %rsi
leaq 0x30(%rsp), %rdx
movq %r14, %rdi
callq 0x634a
movq 0x10(%rbx), %rsi
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x6448
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x57f0
movq %rsp, %r14
movq %rax, (%r14)
movl %edx, 0x8(%r14)
leaq 0x10(%rsp), %rdi
callq 0x352e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5b8e
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x352e
movq %rbx, %rdi
callq 0x2400
nop
// File: /workspace/github_cpp_makefile_star2_O1/lmclaramunt[P]AES-Crypto/Cipher.cpp
// Function: Cipher::OFB_decrypt()
void Cipher::OFB_decrypt(){     
    Sequence tag = CBC_MAC(*inputBlock, false, true);             //Generate MAC Tag from Ciphertext
    Sequence readTag = inputBlock->getSequenceVector().at(0);     //Get the MAC Tag in the Ciphertext
    if(authenticateSequences(&readTag, &tag)){          //Authenticate Ciphertext
        Sequence ivSq(16);
        int i = -1;

        //Decrypt Ciphertext
        for(Sequence sq: inputBlock->getSequenceVector()) {
            i++;
            if(i <= 1) {
                ivSq.updateSequence(sq);    //Ignore first 2 block when decrypting, since these
                continue;                   //Contain MAC Tag and IV respectively
            }
            encrypt(&ivSq, aesKeyExp);
            sq = sq ^ ivSq; 
        }

        //Ciphertext has been authenticated and decrypted. Ready to write plaintext
        writePlainText();
    } else
        throw "Ciphertext has been modified, it won't be decrypted!\n";     //Authenticate-then-decrypt
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x6448
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x57f0
movq %rax, 0x18(%rsp)
movl %edx, 0x20(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x352e
movq 0x10(%rbx), %rdi
callq 0x3568
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x626b
movups (%rcx), %xmm0
leaq 0x50(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x18(%rsp), %rdx
callq 0x59a2
testb %al, %al
je 0x627d
leaq 0x28(%rsp), %rdi
movl $0x10, %esi
callq 0x31dc
movq 0x10(%rbx), %rdi
callq 0x3568
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x6254
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x28(%rsp), %r14
movq %rsp, %r15
movups (%r12), %xmm0
movaps %xmm0, (%rsp)
testl %ebp, %ebp
jle 0x6239
movq (%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x525e
movq %r15, %rdi
movq %r14, %rsi
callq 0x335d
movq (%rax), %rcx
movq %rcx, (%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x8(%rsp)
jmp 0x6249
movq (%rsp), %rsi
movl 0x8(%rsp), %edx
movq %r14, %rdi
callq 0x327e
addq $0x10, %r12
incl %ebp
cmpq %r13, %r12
jne 0x6203
movq %rbx, %rdi
callq 0x5a98
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1522(%rip), %rdi      # 0x7794
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2330
movl $0x8, %edi
callq 0x2120
leaq 0x14a5(%rip), %rcx      # 0x7733
movq %rcx, (%rax)
movq 0x4d28(%rip), %rsi      # 0xafc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x23d0
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x352e
movq %rbx, %rdi
callq 0x2400
nop
// File: /workspace/github_cpp_makefile_star2_O1/Chaircrusher[P]primeratiogen/Bjorklund.cpp
// Function: Bjorklund::init()
void Bjorklund::init(){
    try{
        iter();
        
    }catch(out_of_range){
        cerr<<"pulse::out_of_range"<<'\n';
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
callq 0x35ce
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x35bd
movq %rbx, %rdi
callq 0x2140
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x21c0
movq 0x3a61(%rip), %rax      # 0x6fb8
addq $0x10, %rax
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x2070
movq 0x3a83(%rip), %rdi      # 0x6ff0
leaq 0x1b17(%rip), %rsi      # 0x508b
movl $0x13, %edx
callq 0x2130
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movq 0x3a63(%rip), %rdi      # 0x6ff0
movl $0x1, %edx
callq 0x2130
leaq 0x8(%rsp), %rdi
callq 0x2208
callq 0x21a0
jmp 0x3524
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2208
callq 0x21a0
movq %rbx, %rdi
callq 0x21f0
movq %rax, %rdi
callq 0x2be1
nop
// File: /workspace/github_cpp_makefile_star2_O1/Chaircrusher[P]primeratiogen/Bjorklund.cpp
// Function: Bjorklund::init(int, int)
void Bjorklund::init(int step, int pulse){
    lengthOfSeq = step;
    pulseAmt = pulse;
    
    try{
        iter();
        
    }catch(out_of_range){
        cerr<<"pulse::out_of_range"<<'\n';
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, 0x58(%rdi)
movl %edx, 0x5c(%rdi)
callq 0x35ce
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x3855
movq %rbx, %rdi
callq 0x2140
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x21c0
movq 0x37c9(%rip), %rax      # 0x6fb8
addq $0x10, %rax
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x2070
movq 0x37eb(%rip), %rdi      # 0x6ff0
leaq 0x187f(%rip), %rsi      # 0x508b
movl $0x13, %edx
callq 0x2130
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movq 0x37cb(%rip), %rdi      # 0x6ff0
movl $0x1, %edx
callq 0x2130
leaq 0x8(%rsp), %rdi
callq 0x2208
callq 0x21a0
jmp 0x37bc
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2208
callq 0x21a0
movq %rbx, %rdi
callq 0x21f0
movq %rax, %rdi
callq 0x2be1
nop
// File: /workspace/github_cpp_makefile_star2_O1/Chaircrusher[P]primeratiogen/Bjorklund.cpp
// Function: Bjorklund::buildSeq(int)
void Bjorklund::buildSeq(int slot){
    //construct a binary sequence of n bits with k one‚Äôs, such that the k one‚Äôs are distributed as evenly as possible among the zero‚Äôs
    
    if (slot == -1) {
        sequence.push_back(0);
    }
    else if (slot == -2)  {
        sequence.push_back(1);
    }else{
        for (int i = 0; i < count[slot]; i++)
            buildSeq(slot-1);
        if (remainder[slot] !=0)
            buildSeq(slot-2);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
cmpl $-0x2, %r14d
je 0x38c7
cmpl $-0x1, %r14d
je 0x38bc
movslq %r14d, %r15
movq 0x18(%rbx), %rax
cmpl $0x0, (%rax,%r15,4)
jle 0x38ac
leal -0x1(%r14), %ebp
xorl %r12d, %r12d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3866
incl %r12d
movq 0x18(%rbx), %rax
cmpl (%rax,%r15,4), %r12d
jl 0x3895
movq (%rbx), %rax
cmpl $0x0, (%rax,%r15,4)
je 0x38e0
addl $-0x2, %r14d
jmp 0x3874
addq $0x30, %rbx
movq %rbx, %rdi
xorl %esi, %esi
jmp 0x38d3
addq $0x30, %rbx
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3a98
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Chaircrusher[P]primeratiogen/Bjorklund.cpp
// Function: Bjorklund::print()
void Bjorklund::print(){
    for(int i=0; i != sequence.size();i++){
        cout<<sequence.at(i);
    }
    cout<<'\n';
    cout<<"Size : "<<sequence.size()<<'\n';
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movl 0x48(%rdi), %ecx
subq 0x30(%rdi), %rax
shlq $0x3, %rax
addq %rcx, %rax
je 0x394e
leaq 0x30(%rbx), %r14
xorl %r15d, %r15d
movq 0x36a5(%rip), %r12      # 0x6fc0
movq %r14, %rdi
movq %r15, %rsi
callq 0x3a32
xorl %esi, %esi
testq %rdx, (%rax)
setne %sil
movq %r12, %rdi
callq 0x21b0
incq %r15
movq 0x40(%rbx), %rax
movl 0x48(%rbx), %ecx
subq 0x30(%rbx), %rax
leaq (%rcx,%rax,8), %rax
cmpq %rax, %r15
jne 0x391b
movb $0xa, %bpl
leaq 0xe(%rsp), %rsi
movb %bpl, (%rsi)
movq 0x3660(%rip), %r14      # 0x6fc0
movl $0x1, %edx
movq %r14, %rdi
callq 0x2130
leaq 0x174c(%rip), %rsi      # 0x50c0
movl $0x7, %edx
movq %r14, %rdi
callq 0x2130
movq 0x40(%rbx), %rax
movl 0x48(%rbx), %ecx
subq 0x30(%rbx), %rax
leaq (%rcx,%rax,8), %rsi
movq %r14, %rdi
callq 0x20b0
leaq 0xf(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2130
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Chaircrusher[P]primeratiogen/Bjorklund.cpp
// Function: Bjorklund::LoadSequence()
vector<bool> Bjorklund::LoadSequence(){
    vector<bool> seq;
    for(int i=0;i < lengthOfSeq;i++){
        seq.push_back(sequence[i]);
    }
    return seq;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, (%rdi)
movl %eax, 0x8(%rdi)
movq %rax, 0x10(%rdi)
movl %eax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
cmpl %eax, 0x58(%rsi)
jle 0x3a0d
movq %rsi, %r14
xorl %r15d, %r15d
movq 0x30(%r14), %rax
movq %r15, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
xorl %esi, %esi
btq %r15, %rax
setb %sil
movq %rbx, %rdi
callq 0x3a98
incq %r15
movslq 0x58(%r14), %rax
cmpq %rax, %r15
jl 0x39e0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2bec
movq %r14, %rdi
callq 0x21f0
movq %rax, %rdi
callq 0x2be1
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH01_GettingStarted/examples/occurs.cc
// Function: main
int main()
{
	// currVal is the number we're counting; we'll read new values into val
	int currVal = 0, val = 0;

	// read first number and ensure that we have data to process
	if (std::cin >> currVal) {        
		int cnt = 1;  // store the count for the current value we're processing
		while (std::cin >> val) { // read the remaining numbers 
			if (val == currVal)   // if the values are the same
				++cnt;            // add 1 to cnt 
			else { // otherwise, print the count for the previous value
				std::cout << currVal << " occurs " 
				          << cnt << " times" << std::endl;
				currVal = val;    // remember the new value
				cnt = 1;          // reset the counter
			}
		}  // while loop ends here
		// remember to print the count for the last value in the file
		std::cout << currVal << " occurs " 
		          << cnt << " times" << std::endl;
	} // outermost if statement ends here
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %eax, %eax
leaq -0x30(%rbp), %rsi
movl %eax, (%rsi)
movl %eax, -0x2c(%rbp)
movq 0x2dd4(%rip), %rdi      # 0x3fe0
callq 0x1040
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x136a
movq 0x2db6(%rip), %rdi      # 0x3fe0
leaq -0x2c(%rbp), %rsi
callq 0x1040
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl $0x1, %r15d
testb $0x5, 0x20(%rax,%rcx)
jne 0x12fb
movq 0x2d8e(%rip), %rbx      # 0x3fe0
leaq -0x2c(%rbp), %r14
leaq 0xdb0(%rip), %r13       # 0x200d
movl -0x30(%rbp), %esi
cmpl %esi, -0x2c(%rbp)
jne 0x126a
incl %r15d
jmp 0x12de
movq 0x2d5f(%rip), %rdi      # 0x3fd0
callq 0x10a0
movq %rax, %r12
movl $0x8, %edx
movq %rax, %rdi
leaq 0xd7c(%rip), %rsi       # 0x2004
callq 0x1080
movq %r12, %rdi
movl %r15d, %esi
callq 0x10a0
movq %rax, %r15
movl $0x6, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x1080
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x1070
movsbl %al, %esi
movq %r15, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
movl $0x1, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1040
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x125d
movl -0x30(%rbp), %esi
movq 0x2ccb(%rip), %rdi      # 0x3fd0
callq 0x10a0
movq %rax, %rbx
leaq 0xcf0(%rip), %rsi       # 0x2004
movl $0x8, %edx
movq %rax, %rdi
callq 0x1080
movq %rbx, %rdi
movl %r15d, %esi
callq 0x10a0
movq %rax, %rbx
leaq 0xcd7(%rip), %rsi       # 0x200d
movl $0x6, %edx
movq %rax, %rdi
callq 0x1080
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1070
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/JayWalker512[P]JayParser/VM.cpp
// Function: VM::VM(std::basic_ifstream<char, std::char_traits<char>>*)
VM::VM(std::ifstream *file) : m_ic(0), m_opc(0), m_op1(0), m_op2(0), m_program(file)
{
	m_log = Log::init();
	
	for (uint i = 0; i < 0xFFFF; ++i)
		m_memory[i] = 0;
	
	m_eax = m_memory + EAX;
	m_ebx = m_memory + EBX;
	m_ecx = m_memory + ECX;
	m_edx = m_memory + EDX;
	
	m_lgf = m_memory + LGF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x40020(%rdi)
movq %rax, 0x4002c(%rdi)
movq %rsi, 0x40040(%rdi)
callq 0x263e
movq %rax, 0x40048(%rbx)
movl $0x3fffc, %edx          # imm = 0x3FFFC
movq %rbx, %rdi
xorl %esi, %esi
callq 0x20a0
leaq 0x3fffc(%rbx), %rax
movq %rax, 0x40000(%rbx)
leaq 0x3fff8(%rbx), %rax
movq %rax, 0x40008(%rbx)
leaq 0x3fff4(%rbx), %rax
movq %rax, 0x40010(%rbx)
leaq 0x3fff0(%rbx), %rax
movq %rax, 0x40018(%rbx)
leaq 0x3ffc0(%rbx), %rax
movq %rax, 0x40038(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/JayWalker512[P]JayParser/VM.cpp
// Function: VM::parse()
void VM::parse()
{
	parseDataSection();
	
	if (m_log->getErrorCount())
		return;

	parseCodeSection();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2dde
movq 0x40048(%rbx), %rax
movq 0x48(%rax), %rcx
movl 0x28(%rax), %edx
movl %ecx, %esi
subl %edx, %esi
shrl $0x3, %esi
cmpq $0x1, %rcx
adcl $-0x1, %esi
shll $0x6, %esi
movq 0x20(%rax), %rcx
movq 0x30(%rax), %rdx
subq 0x38(%rax), %rdx
shrq $0x3, %rdx
addl %esi, %edx
subq 0x10(%rax), %rcx
shrq $0x3, %rcx
addl %edx, %ecx
je 0x2dd0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2f78
// File: /workspace/github_cpp_makefile_star2_O1/JayWalker512[P]JayParser/VM.cpp
// Function: VM::parseDataSection()
void VM::parseDataSection()
{	
	jumpToSection(DATASEC);
	
	// Parse
	while (!m_program->eof()) {
		readNextOperators();
		
		if ((uint)((m_op1 << 16) + m_op2) == CODESEC)
			return;
		
		for (uint i = 0; i < m_op1; ++i) {
			m_memory[m_op2 + i] = m_program->get();
		}
	}
	
	m_log->add(new Error(FATAL + PARSERR + 5, "Infinite data section."));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl $0xddffddff, %esi       # imm = 0xDDFFDDFF
callq 0x33ee
movq 0x40040(%rbx), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x2, 0x20(%rax,%rcx)
jne 0x2e93
leaq 0x4002c(%rbx), %r14
leaq 0x40030(%rbx), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x338e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x338e
movl 0x4002c(%rbx), %eax
shll $0x10, %eax
addl 0x40030(%rbx), %eax
cmpl $0xccffccff, %eax       # imm = 0xCCFFCCFF
je 0x2f31
cmpl $0x0, (%r14)
je 0x2e7e
xorl %r12d, %r12d
movq 0x40040(%rbx), %rdi
callq 0x2150
movl 0x40030(%rbx), %ecx
addl %r12d, %ecx
movl %eax, (%rbx,%rcx,4)
incl %r12d
cmpl 0x4002c(%rbx), %r12d
jb 0x2e5a
movq 0x40040(%rbx), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x2, 0x20(%rax,%rcx)
je 0x2e21
movq 0x40048(%rbx), %r14
movl $0x28, %edi
callq 0x2120
movq %rax, %rbx
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x12c1(%rip), %rsi      # 0x4177
leaq 0x12d0(%rip), %rdx      # 0x418d
leaq -0x40(%rbp), %rdi
callq 0x2c54
movl $0x80ffee05, (%rbx)     # imm = 0x80FFEE05
leaq 0x8(%rbx), %rdi
movq %rbx, %rax
addq $0x18, %rax
movq %rax, 0x8(%rbx)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq %rsi, %rdx
movb $0x1, %r12b
callq 0x2bba
movq %rbx, -0x48(%rbp)
movq 0x30(%r14), %rax
movq 0x40(%r14), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x2f0d
movq %rbx, (%rax)
addq $0x8, 0x30(%r14)
jmp 0x2f1c
xorl %r12d, %r12d
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x29a8
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x2f31
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2130
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movb $0x1, %r12b
jmp 0x2f5e
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x2f5e
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2130
testb %r12b, %r12b
je 0x2f70
movl $0x28, %esi
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/JayWalker512[P]JayParser/VM.cpp
// Function: VM::readNextInstruction()
void VM::readNextInstruction()
{
	char buffer;
	m_program->get(buffer);
	
	m_instruction = (unsigned char)buffer;	
	++m_ic;
	
	switch (m_instruction) {
		case NOP:
		case DSP:
		case RSTLG:
		case JMP:
		case JMF:
		case JMPMK:
		case NOT:
			return;
		case DEC:
		case INC:
		case NEG:
			readNextOp1();
			return;
		case MOV:
		case SET:
		case ADD:
		case SUB:
		case MUL:
		case DIV:
		case EQQ:
		case NEQ:
		case AND:
		case ORR:
			readNextOperators();
			return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x40040(%rdi), %rdi
leaq -0x11(%rbp), %r14
movq %r14, %rsi
callq 0x2170
movzbl (%r14), %eax
incl 0x40020(%rbx)
movl %eax, 0x40028(%rbx)
cmpq $0x23, %rax
ja 0x3368
movabsq $0xf000f000c, %rcx      # imm = 0xF000F000C
btq %rax, %rcx
jae 0x334d
leaq 0x4002c(%rbx), %rsi
movq %rbx, %rdi
callq 0x338e
movl $0x40030, %esi          # imm = 0x40030
jmp 0x335d
movl $0x4002c, %esi          # imm = 0x4002C
movl $0x2300000, %ecx        # imm = 0x2300000
btq %rax, %rcx
jae 0x3368
addq %rbx, %rsi
movq %rbx, %rdi
callq 0x338e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/JayWalker512[P]JayParser/VM.cpp
// Function: VM::readNextOperator(unsigned int&)
void VM::readNextOperator(uint& op)
{
	char high, low;
	m_program->get(high);
	m_program->get(low);
	
	op = ((unsigned char)high << 8) + (unsigned char)low;
	
	++m_opc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x40040(%rdi), %rdi
leaq -0x22(%rbp), %r15
movq %r15, %rsi
callq 0x2170
movq 0x40040(%r14), %rdi
leaq -0x21(%rbp), %r12
movq %r12, %rsi
callq 0x2170
movzbl (%r15), %eax
shll $0x8, %eax
movzbl (%r12), %ecx
orl %eax, %ecx
movl %ecx, (%rbx)
incl 0x40024(%r14)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/JayWalker512[P]JayParser/VM.cpp
// Function: VM::jumpToSection(unsigned int)
void VM::jumpToSection(uint section)
{
	uint buffer = 0;
	
	m_program->seekg(0, std::ios_base::beg);
	
	// Fill the buffer
	readNextSection(&buffer);
	readNextSection(&buffer);
	readNextSection(&buffer);
	
	do {
		readNextSection(&buffer);
		if (buffer == section)
			return;
	} while (!m_program->eof());
	
	m_log->add(new Error(FATAL + PARSERR + 4, "Cannot find requested section."));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x40040(%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2160
movq 0x40040(%rbx), %rdi
leaq -0x30(%rbp), %r15
movq %r15, %rsi
callq 0x2170
movzbl (%r15), %r12d
movq 0x40040(%rbx), %rdi
leaq -0x30(%rbp), %r13
movq %r13, %rsi
callq 0x2170
movzbl (%r13), %r13d
movq 0x40040(%rbx), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2170
shll $0x10, %r12d
shll $0x8, %r13d
orl %r12d, %r13d
leaq -0x30(%rbp), %rax
movzbl (%rax), %r12d
orl %r13d, %r12d
movq 0x40040(%rbx), %rdi
movq %r15, %rsi
callq 0x2170
movl %r12d, %eax
shll $0x8, %eax
movzbl -0x30(%rbp), %r12d
orl %eax, %r12d
cmpl %r14d, %r12d
je 0x3543
movq 0x40040(%rbx), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x2, 0x20(%rax,%rcx)
je 0x346a
movq 0x40048(%rbx), %r14
movl $0x28, %edi
callq 0x2120
movq %rax, %rbx
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xc90(%rip), %rsi       # 0x4158
leaq 0xca7(%rip), %rdx       # 0x4176
leaq -0x50(%rbp), %rdi
callq 0x2c54
movl $0x80ffee04, (%rbx)     # imm = 0x80FFEE04
leaq 0x8(%rbx), %rdi
movq %rbx, %rax
addq $0x18, %rax
movq %rax, 0x8(%rbx)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
addq %rsi, %rdx
movb $0x1, %r12b
callq 0x2bba
movq %rbx, -0x30(%rbp)
movq 0x30(%r14), %rax
movq 0x40(%r14), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x351f
movq %rbx, (%rax)
addq $0x8, 0x30(%r14)
jmp 0x352e
xorl %r12d, %r12d
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x29a8
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x3543
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2130
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movb $0x1, %r12b
jmp 0x3572
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x3572
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2130
testb %r12b, %r12b
je 0x3584
movl $0x28, %esi
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x21d0