LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.h
// Function: void KeccakF::theta<unsigned long long>(std::vector<unsigned long long, std::allocator<unsigned long long>>&) const
void KeccakF::theta(vector<Lane>& A) const
{
    vector<Lane> C(5);
    for(unsigned int x=0; x<5; x++) {
        C[x] = A[index(x,0)]; 
        for(unsigned int y=1; y<5; y++) 
            C[x] ^= A[index(x,y)];
    }
    vector<Lane> D(5);
    for(unsigned int x=0; x<5; x++) {
        Lane temp = C[index(x+1)];
        ROL(temp, 1);
        D[x] = temp ^ C[index(x-1)];
    }
    for(int x=0; x<5; x++)
        for(unsigned int y=0; y<5; y++)
            A[index(x,y)] ^= D[x];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x28, %edi
callq 0x5210
movq %rax, %rbx
vpxor %xmm0, %xmm0, %xmm0
vmovdqu %ymm0, (%rax)
movq $0x0, 0x20(%rax)
movq (%r14), %rax
xorl %ecx, %ecx
movq %rax, %rdx
movq (%rax,%rcx,8), %rsi
movq %rsi, (%rbx,%rcx,8)
movl $0x28, %edi
xorq (%rdx,%rdi), %rsi
movq %rsi, (%rbx,%rcx,8)
addq $0x28, %rdi
cmpq $0xc8, %rdi
jne 0x7035
incq %rcx
addq $0x8, %rdx
cmpq $0x5, %rcx
jne 0x7028
movl $0x28, %edi
vzeroupper
callq 0x5210
movq %rax, %rdi
vpxor %xmm0, %xmm0, %xmm0
vmovdqu %ymm0, (%rax)
movq $0x0, 0x20(%rax)
movl 0xc(%r15), %esi
xorl %ecx, %ecx
movl $0x1, %eax
xorl %edx, %edx
idivl %esi
subl %edx, %esi
vpbroadcastq 0x50(%r15), %ymm1
vpbroadcastq %rdx, %ymm2
vpmovsxbq 0x3fd3(%rip), %ymm3 # 0xb070
vpbroadcastq %rsi, %ymm4
vpbroadcastq 0x3fb4(%rip), %ymm5 # 0xb060
vpcmpeqd %ymm6, %ymm6, %ymm6
vpbroadcastq 0x3faf(%rip), %ymm7 # 0xb068
vpcmpltuq %ymm5, %ymm3, %k1
vpsubq %ymm6, %ymm3, %ymm8
vpcmpneqq %ymm7, %ymm3, %k2
vpblendd $0xaa, %ymm0, %ymm8, %ymm8 # ymm8 = ymm8[0],ymm0[1],ymm8[2],ymm0[3],ymm8[4],ymm0[5],ymm8[6],ymm0[7]
vmovdqa64 %ymm8, %ymm9 {%k2} {z}
vpxor %xmm8, %xmm8, %xmm8
kmovq %k1, %k2
vpgatherqq (%rbx,%ymm9,8), %ymm8 {%k2}
testl %edx, %edx
je 0x70ff
vpand %ymm1, %ymm8, %ymm8
vpsllvq %ymm2, %ymm8, %ymm9
vpsrlvq %ymm4, %ymm8, %ymm8
vpxor %ymm8, %ymm9, %ymm8
vptestmq %ymm3, %ymm3, %k2
vpaddq %ymm6, %ymm3, %ymm9
vpblendd $0xaa, %ymm0, %ymm9, %ymm9 # ymm9 = ymm9[0],ymm0[1],ymm9[2],ymm0[3],ymm9[4],ymm0[5],ymm9[6],ymm0[7]
vpblendmq %ymm9, %ymm7, %ymm9 {%k2}
vpxor %xmm10, %xmm10, %xmm10
kmovq %k1, %k2
vpgatherqq (%rbx,%ymm9,8), %ymm10 {%k2}
vpternlogq $0x78, %ymm8, %ymm1, %ymm10
vmovdqu64 %ymm10, (%rdi,%rcx,8) {%k1}
addq $0x4, %rcx
vpaddq %ymm7, %ymm3, %ymm3
cmpq $0x8, %rcx
jne 0x70b9
movq (%r14), %rax
xorl %ecx, %ecx
movq (%rdi,%rcx,8), %rdx
xorl %esi, %esi
xorq %rdx, (%rax,%rsi)
addq $0x28, %rsi
cmpq $0xc8, %rsi
jne 0x7151
incq %rcx
addq $0x8, %rax
cmpq $0x5, %rcx
jne 0x714b
movl $0x28, %esi
vzeroupper
callq 0x5060
movl $0x28, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x5060
movq %rax, %r14
movl $0x28, %esi
movq %rbx, %rdi
callq 0x5060
movq %r14, %rdi
callq 0x5670
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.h
// Function: void KeccakF::pi<unsigned long long>(std::vector<unsigned long long, std::allocator<unsigned long long>>&) const
void KeccakF::pi(vector<Lane>& A) const
{
    vector<Lane> a(A);
    for(unsigned int x=0; x<5; x++) 
    for(unsigned int y=0; y<5; y++) {
        unsigned int X, Y;
        pi(x, y, X, Y);
        A[index(X,Y)] = a[index(x,y)];
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5450
movq (%r14), %rdi
movq (%rbx), %rax
xorl %ecx, %ecx
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
movq %rdi, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %r10d, %r10d
movl %ecx, %r11d
movl %r8d, %ebx
movq %rax, %r14
movl %r11d, %r15d
imulq %rdx, %r15
shrq $0x22, %r15
leal (%r15,%r15,4), %r15d
leal (%r15,%r15,4), %ebp
movl %ebx, %r15d
subl %ebp, %r15d
movq (%rsi,%r10,8), %r12
movq %r12, (%r14,%r15,8)
addq $0x8, %r14
addl $0xf, %ebx
addl $0x3, %r11d
addq $0x5, %r10
cmpq $0x19, %r10
jne 0x7252
incq %r9
addl $0xa, %r8d
addl $0x2, %ecx
addq $0x8, %rsi
cmpq $0x5, %r9
jne 0x7246
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x5060
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.h
// Function: void KeccakF::chi<unsigned long long>(std::vector<unsigned long long, std::allocator<unsigned long long>>&) const
void KeccakF::chi(vector<Lane>& A) const
{
    vector<Lane> C(5);
    for(unsigned int y=0; y<5; y++) { 
        for(unsigned int x=0; x<5; x++)
            C[x] = A[index(x,y)] ^ ((~A[index(x+1,y)]) & A[index(x+2,y)]);
        for(unsigned int x=0; x<5; x++)
            A[index(x,y)] = C[index(x)];
    }
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movl $0x28, %edi
callq 0x5210
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, (%rax)
movq $0x0, 0x20(%rax)
movq (%rbx), %rcx
xorl %edx, %edx
movq %rcx, %rsi
xorl %edi, %edi
leaq (%rdi,%rdi,4), %r8
leaq (%rcx,%r8,8), %r8
xorl %r9d, %r9d
leaq 0x1(%r9), %r10
cmpq $0x4, %r9
movl $0x0, %r11d
cmovneq %r10, %r11
movq (%r8,%r11,8), %r11
xorl %ebx, %ebx
cmpq $0x3, %r9
setb %bl
leal (%rbx,%rbx,4), %ebx
addl %edx, %ebx
addl %r9d, %ebx
addl $-0x3, %ebx
andnq (%rcx,%rbx,8), %r11, %r11
xorq (%rsi,%r9,8), %r11
movq %r11, (%rax,%r9,8)
movq %r10, %r9
cmpq $0x5, %r10
jne 0x72e9
xorl %r8d, %r8d
movq (%rax,%r8,8), %r9
movq %r9, (%rsi,%r8,8)
incq %r8
cmpq $0x5, %r8
jne 0x732d
incq %rdi
addq $0x5, %rdx
addq $0x28, %rsi
cmpq $0x5, %rdi
jne 0x72de
movl $0x28, %esi
movq %rax, %rdi
popq %rbx
vzeroupper
jmp 0x5060
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.h
// Function: void KeccakF::inverseRound<unsigned long long>(std::vector<unsigned long long, std::allocator<unsigned long long>>&, int) const
void KeccakF::inverseRound(vector<Lane>& state, int roundIndex) const
{
    iota(state, roundIndex);
    inverseChi(state);
    inversePi(state);
    inverseRho(state);
    inverseTheta(state);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq %edx, %rax
imulq $-0x7f7f7f7f, %rax, %rcx # imm = 0x80808081
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0x7, %ecx
addl %edx, %ecx
movl %ecx, %edx
shll $0x8, %edx
subl %edx, %ecx
leal (%rax,%rcx), %edx
addl %ecx, %eax
addl $0xff, %eax
cmpl $0xffffff01, %edx       # imm = 0xFFFFFF01
cmovbl %edx, %eax
movq 0x38(%rdi), %rcx
movq (%rcx,%rax,8), %rax
movq (%rsi), %rcx
xorq %rax, (%rcx)
callq 0x5090
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5570
movq %r14, %rdi
movq %rbx, %rsi
callq 0x52c0
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5180
nop
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.h
// Function: void KeccakF::inverseChi<unsigned long long>(std::vector<unsigned long long, std::allocator<unsigned long long>>&) const
void KeccakF::inverseChi(vector<Lane>& A) const
{
    for(unsigned int y=0; y<5; y++) { 
        unsigned int length = 5;
        vector<Lane> C(length);
        for(unsigned int x=0; x<length; x++) C[index(x)] = A[index(x,y)];
        for(unsigned int x=0; x<(3*(length-1)/2); x++) {
            unsigned int X = (length-2)*x;
            A[index(X,y)] = C[index(X)] ^ (A[index(X+2,y)] & (~C[index(X+1)]));
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, (%rsp)
movl $0x10, %ebx
xorl %r14d, %r14d
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
xorl %r13d, %r13d
movl $0x28, %edi
callq 0x5210
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, (%rax)
movq $0x0, 0x20(%rax)
movq (%rsp), %rcx
movq (%rcx), %r8
movq %r14, 0x8(%rsp)
addq %r8, %r14
xorl %ecx, %ecx
movq (%r14,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
incq %rcx
cmpq $0x5, %rcx
jne 0x74ae
movq %rbx, 0x10(%rsp)
addq %rbx, %r8
movq %rax, %r10
addq $0x8, %r10
movl $0x2, %ecx
movl $0x1, %esi
movl $0x6, %r11d
movq %rax, %rbp
xorl %edi, %edi
movq %rdi, %rdx
mulxq %r12, %rdx, %rdx
addq %rdx, %rdx
andq $-0x8, %rdx
leaq (%rdx,%rdx,4), %rbx
movq %r14, %r9
subq %rbx, %r9
movq %rcx, %rdx
mulxq %r12, %rdx, %rdx
addq %rdx, %rdx
andq $-0x8, %rdx
leaq (%rdx,%rdx,4), %r15
negq %r15
movq %rsi, %rdx
mulxq %r12, %rdx, %rdx
addq %rdx, %rdx
andq $-0x8, %rdx
leaq (%rdx,%rdx,4), %rdx
negq %rdx
movq (%r10,%rdx), %rdx
andnq (%r8,%r15), %rdx, %rdx
movq %rbp, %r15
subq %rbx, %r15
xorq (%r15), %rdx
movq %rdx, (%r9)
addq $0x18, %r14
addq $0x3, %rdi
addq $0x18, %rbp
addq $0x18, %r8
addq $0x3, %rcx
addq $0x18, %r10
addq $0x3, %rsi
decl %r11d
jne 0x74e3
movl $0x28, %esi
movq %rax, %rdi
vzeroupper
callq 0x5060
incq %r13
movq 0x8(%rsp), %r14
addq $0x28, %r14
movq 0x10(%rsp), %rbx
addq $0x28, %rbx
cmpq $0x5, %r13
jne 0x7483
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.h
// Function: void KeccakF::inversePi<unsigned long long>(std::vector<unsigned long long, std::allocator<unsigned long long>>&) const
void KeccakF::inversePi(vector<Lane>& A) const
{
    vector<Lane> a(A);
    for(unsigned int X=0; X<5; X++) 
    for(unsigned int Y=0; Y<5; Y++) {
        unsigned int x, y;
        inversePi(X, Y, x, y);
        A[index(x,y)] = a[index(X,Y)];
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x5450
movq (%r14), %rdi
movq (%rbx), %rax
xorl %ecx, %ecx
movabsq $-0x3333333333333333, %rsi # imm = 0xCCCCCCCCCCCCCCCD
movq %rdi, %r8
movq $-0xc8, %r9
movq %rcx, %rdx
movq %rax, %r10
mulxq %rsi, %r11, %r11
addq %r11, %r11
andq $-0x8, %r11
leaq (%r11,%r11,4), %r11
negq %r11
movq 0xc8(%r8,%r9), %rbx
movq %rbx, (%r10,%r11)
addq $0x18, %r10
addq $0x3, %rdx
addq $0x28, %r9
jne 0x75d5
incq %rcx
addq $0x8, %r8
addq $0x30, %rax
cmpq $0x5, %rcx
jne 0x75c8
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x5060
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Motorist.cpp
// Function: enc8(unsigned int)
UINT8 enc8(unsigned int x)
{
    if (x > 255) {
        stringstream s;
        s << "The integer " << x << " cannot be encoded on 8 bits.";
        throw Exception(s.str());
    }
    else
        return UINT8(x);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movl %edi, %ebx
cmpl $0x100, %edi            # imm = 0x100
jae 0x7fc8
movl %ebx, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28(%rsp), %rdi
callq 0x5720
leaq 0x38(%rsp), %r14
leaq 0x3266(%rip), %rsi      # 0xb244
movl $0xc, %edx
movq %r14, %rdi
callq 0x5250
movl %ebx, %esi
movq %r14, %rdi
callq 0x56d0
leaq 0x3255(%rip), %rsi      # 0xb251
movl $0x1d, %edx
movq %rax, %rdi
callq 0x5250
movl $0x20, %edi
callq 0x55a0
movq %rax, %rbx
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x54b0
movq %rbx, %rax
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x5170
xorl %ebp, %ebp
movq 0x6f70(%rip), %rsi      # 0xefc0
movq 0x6f61(%rip), %rdx      # 0xefb8
movq %rbx, %rdi
callq 0x5270
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x807d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5060
testb %bpl, %bpl
jne 0x8087
jmp 0x8094
movq %rax, %r14
movq %rbx, %rdi
callq 0x5380
jmp 0x8094
movq %rax, %r14
movq 0x6f35(%rip), %rsi      # 0xefd0
leaq 0x28(%rsp), %rdi
callq 0x53b0
leaq 0xa8(%rsp), %rdi
callq 0x55b0
movq %r14, %rdi
callq 0x5670
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Motorist.cpp
// Function: Piston::Piston(Permutation const*, unsigned int, unsigned int)
Piston::Piston(const Permutation *aF, unsigned int aRs, unsigned int aRa)
    : f(aF), Rs(aRs), Ra(aRa)
{
    unsigned int b = f->getWidth();
    if (Rs > Ra)
        throw Exception("Rs is larger than Ra.");
    if (Ra > ((b-32)/8))
        throw Exception("Ra is larger than (b-32)/8.");
    state.reset(new UINT8[(b+7)/8]);
    memset(state.get(), 0, (b+7)/8);
    EOM = Ra;
    CryptEnd = Ra+1;
    InjectStart = Ra+2;
    InjectEnd = Ra+3;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsi, (%rdi)
movq $0x0, 0x8(%rdi)
movl %edx, 0x10(%rdi)
movl %ecx, 0x14(%rdi)
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
movl %eax, %r14d
movl 0x14(%rbx), %eax
cmpl %eax, 0x10(%rbx)
ja 0x8160
leal -0x20(%r14), %ecx
shrl $0x3, %ecx
cmpl %ecx, %eax
ja 0x81c8
addl $0x7, %r14d
shrl $0x3, %r14d
movq %r14, %rdi
callq 0x5600
movq %rax, %r15
movq 0x8(%rbx), %rdi
cmpq %rax, %rdi
je 0x812a
movl $0x1, %esi
callq 0x5060
movq %r15, 0x8(%rbx)
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x5220
movl 0x14(%rbx), %eax
movl %eax, 0x18(%rbx)
vpbroadcastd %eax, %xmm0
vpaddd 0x30b8(%rip), %xmm0, %xmm0 # 0xb200
vmovq %xmm0, 0x1c(%rbx)
addl $0x3, %eax
movl %eax, 0x24(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x55a0
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x30f1(%rip), %rsi      # 0xb26f
leaq 0x30ff(%rip), %rdx      # 0xb284
movq %rsp, %rdi
callq 0x5160
movq %r15, %rax
addq $0x10, %rax
movq %rax, (%r15)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
movb $0x1, %bpl
movq %r15, %rdi
callq 0x5170
xorl %ebp, %ebp
movq 0x6e09(%rip), %rsi      # 0xefc0
movq 0x6dfa(%rip), %rdx      # 0xefb8
movq %r15, %rdi
callq 0x5270
jmp 0x822e
movl $0x20, %edi
callq 0x55a0
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x309f(%rip), %rsi      # 0xb285
leaq 0x30b3(%rip), %rdx      # 0xb2a0
movq %rsp, %rdi
callq 0x5160
movq %r15, %rax
addq $0x10, %rax
movq %rax, (%r15)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
movb $0x1, %bpl
movq %r15, %rdi
callq 0x5170
xorl %ebp, %ebp
movq 0x6da1(%rip), %rsi      # 0xefc0
movq 0x6d92(%rip), %rdx      # 0xefb8
movq %r15, %rdi
callq 0x5270
jmp 0x8232
jmp 0x8252
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x824b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5060
testb %bpl, %bpl
jne 0x8255
jmp 0x8262
movq %rax, %r14
movq %r15, %rdi
callq 0x5380
jmp 0x8262
movq %rax, %r14
movq 0x8(%rbx), %rdi
movl $0x1, %esi
callq 0x5060
movq %r14, %rdi
callq 0x5670
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Motorist.cpp
// Function: Piston::Crypt(std::istream&, std::ostream&, unsigned int, bool)
void Piston::Crypt(istream& I, ostream& O, unsigned int omega, bool unwrapFlag)
{
    while(hasMore(I) && (omega < Rs)) {
        UINT8 x = I.get();
        O.put(state.get()[omega] ^ x);
        if (unwrapFlag)
            state.get()[omega] = x;
        else
            state.get()[omega] ^= x;
        omega++;
    }
    state.get()[CryptEnd] ^= enc8(omega);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, 0x4(%rsp)
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x52e0
testl %eax, %eax
js 0x8394
cmpl %ebp, 0x10(%rbx)
jbe 0x8394
movl %ebp, %r14d
incq %r14
movq %r12, %rdi
callq 0x5330
movl %eax, %r13d
movq 0x8(%rbx), %rax
movb -0x1(%rax,%r14), %al
xorb %r13b, %al
movsbl %al, %esi
movq %r15, %rdi
callq 0x5510
movq 0x8(%rbx), %rax
cmpb $0x0, 0x4(%rsp)
jne 0x8372
xorb -0x1(%rax,%r14), %r13b
movb %r13b, -0x1(%rax,%r14)
movq %r12, %rdi
callq 0x52e0
incl %ebp
testl %eax, %eax
js 0x8394
leaq 0x1(%r14), %rax
movl 0x10(%rbx), %ecx
cmpq %rcx, %r14
movq %rax, %r14
jb 0x8340
movl %ebp, %edi
callq 0x56f0
movq 0x8(%rbx), %rcx
movl 0x1c(%rbx), %edx
xorb %al, (%rcx,%rdx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Motorist.cpp
// Function: Piston::Inject(std::istream&, bool)
void Piston::Inject(istream& X, bool cryptingFlag)
{
    unsigned int omega;
    if (cryptingFlag)
        omega = Rs;
    else
        omega = 0;
    state.get()[InjectStart] ^= enc8(omega);
    while(hasMore(X) && (omega < Ra)) {
        state.get()[omega] ^= X.get();
        omega++;
    }
    state.get()[InjectEnd] ^= enc8(omega);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0x83ca
movl 0x10(%rbx), %ebp
movl %ebp, %edi
callq 0x56f0
movq 0x8(%rbx), %rcx
movl 0x20(%rbx), %edx
xorb %al, (%rcx,%rdx)
movq %r14, %rdi
callq 0x52e0
testl %eax, %eax
js 0x8420
cmpl 0x14(%rbx), %ebp
jae 0x8420
movl %ebp, %r15d
incq %r15
movq %r14, %rdi
callq 0x5330
movq 0x8(%rbx), %rcx
xorb %al, -0x1(%rcx,%r15)
movq %r14, %rdi
callq 0x52e0
incl %ebp
testl %eax, %eax
js 0x8420
leaq 0x1(%r15), %rax
movl 0x14(%rbx), %ecx
cmpq %rcx, %r15
movq %rax, %r15
jb 0x83f2
movl %ebp, %edi
callq 0x56f0
movq 0x8(%rbx), %rcx
movl 0x24(%rbx), %edx
xorb %al, (%rcx,%rdx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Motorist.cpp
// Function: Piston::Spark(bool, unsigned int)
void Piston::Spark(bool eomFlag, unsigned int l)
{
    if (eomFlag) {
        if (l == 0)
            state.get()[EOM] ^= enc8(255);
        else
            state.get()[EOM] ^= enc8(l);
    }
    else
        state.get()[EOM] ^= enc8(0);
    (*f)(state.get());
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x845d
testl %edx, %edx
je 0x8451
movl %edx, %edi
callq 0x56f0
jmp 0x8453
movb $-0x1, %al
movq 0x8(%rbx), %rcx
movl 0x18(%rbx), %edx
xorb %al, (%rcx,%rdx)
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq (%rdi), %rax
movq 0x18(%rax), %rax
popq %rbx
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Motorist.cpp
// Function: Piston::GetTag(std::ostream&, unsigned int) const
void Piston::GetTag(ostream& T, unsigned int l) const
{
    if (l > Rs)
        throw Exception("The requested tag is too long.");
    for(unsigned int i=0; i<l; i++)
        T.put(state.get()[i]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpl %edx, 0x10(%rdi)
jb 0x84b5
testl %edx, %edx
je 0x84a8
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r15d
xorl %r12d, %r12d
movq 0x8(%r14), %rax
movsbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0x5510
incq %r12
cmpq %r12, %r15
jne 0x848f
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x55a0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2dcf(%rip), %rsi      # 0xb2a1
leaq 0x2de6(%rip), %rdx      # 0xb2bf
movq %rsp, %rdi
callq 0x5160
movq %rbx, %rax
addq $0x10, %rax
movq %rax, (%rbx)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x5170
xorl %ebp, %ebp
movq 0x6ab5(%rip), %rsi      # 0xefc0
movq 0x6aa6(%rip), %rdx      # 0xefb8
movq %rbx, %rdi
callq 0x5270
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x8533
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5060
testb %bpl, %bpl
jne 0x853d
jmp 0x8545
movq %rax, %r14
movq %rbx, %rdi
callq 0x5380
movq %r14, %rdi
callq 0x5670
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Motorist.cpp
// Function: Engine::Crypt(std::istream&, std::ostream&, bool)
void Engine::Crypt(istream& I, ostream& O, bool unwrapFlag)
{
    if (phase != fresh)
        throw Exception("The phase must be fresh to call Engine::Crypt().");
    for(unsigned int i=0; i<Pi; i++)
        Pistons[i].Crypt(I, O, Et[i], unwrapFlag);
    if (hasMore(I))
        phase = crypted;
    else
        phase = endOfCrypt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x0, 0x10(%rdi)
jne 0x8702
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x86e3
movq %rdx, %r15
xorl %r12d, %r12d
movzbl %cl, %ebp
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rax), %rdi
addq %r12, %rdi
movl (%rcx,%r13,4), %ecx
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %r8d
callq 0x53f0
incq %r13
movl (%rbx), %eax
addq $0x28, %r12
cmpq %rax, %r13
jb 0x86b5
movq %r14, %rdi
callq 0x52e0
shrl $0x1f, %eax
incl %eax
movl %eax, 0x10(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x55a0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2bb7(%rip), %rsi      # 0xb2d6
leaq 0x2be0(%rip), %rdx      # 0xb306
leaq 0x8(%rsp), %rdi
callq 0x5160
movq %rbx, %rax
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x5170
xorl %ebp, %ebp
movq 0x6865(%rip), %rsi      # 0xefc0
movq 0x6856(%rip), %rdx      # 0xefb8
movq %rbx, %rdi
callq 0x5270
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x8784
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5060
testb %bpl, %bpl
jne 0x878e
jmp 0x8796
movq %rax, %r14
movq %rbx, %rdi
callq 0x5380
movq %r14, %rdi
callq 0x5670
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Motorist.cpp
// Function: Engine::Inject(std::istream&)
void Engine::Inject(istream& A)
{
    if ((phase != fresh) && (phase != crypted) && (phase != endOfCrypt))
        throw Exception("The phase must be fresh, crypted or endOfCrypt to call Engine::Inject().");
    bool cryptingFlag = (phase == crypted) || (phase == endOfCrypt);
    for(unsigned int i=0; i<Pi; i++)
        Pistons[i].Inject(A, cryptingFlag);
    if ((phase == crypted) || hasMore(A)) {
        Spark(false, vector<unsigned int>(Pi, 0));
        phase = fresh;
    }
    else
        phase = endOfMessage;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl 0x10(%rdi), %ebp
cmpl $0x3, %ebp
jae 0x8866
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x87f6
decl %ebp
xorl %r15d, %r15d
xorl %r12d, %r12d
xorl %edx, %edx
cmpl $0x2, %ebp
setb %dl
movq 0x8(%rbx), %rax
movq (%rax), %rdi
addq %r15, %rdi
movq %r14, %rsi
callq 0x54f0
incq %r12
movl (%rbx), %eax
addq $0x28, %r15
cmpq %rax, %r12
jb 0x87c9
movl 0x10(%rbx), %ebp
jmp 0x87f8
xorl %eax, %eax
cmpl $0x1, %ebp
je 0x880b
movq %r14, %rdi
callq 0x52e0
testl %eax, %eax
js 0x885f
movl (%rbx), %eax
movl %eax, %esi
leaq 0x2c(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rcx
callq 0x53d0
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5390
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x884d
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x5060
xorl %eax, %eax
movl %eax, 0x10(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x3, %eax
jmp 0x884f
movl $0x20, %edi
callq 0x55a0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2a84(%rip), %rsi      # 0xb307
leaq 0x2ac5(%rip), %rdx      # 0xb34f
leaq 0x8(%rsp), %rdi
callq 0x5160
movq %rbx, %rax
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x5170
xorl %ebp, %ebp
movq 0x6701(%rip), %rsi      # 0xefc0
movq 0x66f2(%rip), %rdx      # 0xefb8
movq %rbx, %rdi
callq 0x5270
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x88e8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5060
testb %bpl, %bpl
jne 0x88f2
jmp 0x891b
movq %rax, %r14
movq %rbx, %rdi
callq 0x5380
jmp 0x891b
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x891b
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x5060
jmp 0x891b
movq %rax, %r14
movq %r14, %rdi
callq 0x5670
nop
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Motorist.cpp
// Function: Engine::GetTags(std::ostream&, std::vector<unsigned int, std::allocator<unsigned int>> const&)
void Engine::GetTags(ostream& T, const vector<unsigned int>& l)
{
    if (phase != endOfMessage)
        throw Exception("The phase must be endOfMessage to call Engine::GetTags().");
    Spark(true, l);
    for(unsigned int i=0; i<Pi; i++)
        Pistons[i].GetTag(T, l[i]);
    phase = fresh;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x3, 0x10(%rdi)
jne 0x8996
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x1, %esi
callq 0x5390
cmpl $0x0, (%r14)
je 0x897f
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x8(%r14), %rax
movq (%rax), %rdi
addq %r12, %rdi
movq (%rbx), %rax
movl (%rax,%r13,4), %edx
movq %r15, %rsi
callq 0x5660
incq %r13
movl (%r14), %eax
addq $0x28, %r12
cmpq %rax, %r13
jb 0x8957
movl $0x0, 0x10(%r14)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x55a0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x299d(%rip), %rsi      # 0xb350
leaq 0x29cf(%rip), %rdx      # 0xb389
leaq 0x8(%rsp), %rdi
callq 0x5160
movq %rbx, %rax
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x5170
xorl %ebp, %ebp
movq 0x65d1(%rip), %rsi      # 0xefc0
movq 0x65c2(%rip), %rdx      # 0xefb8
movq %rbx, %rdi
callq 0x5270
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x8a18
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5060
testb %bpl, %bpl
jne 0x8a22
jmp 0x8a2a
movq %rax, %r14
movq %rbx, %rdi
callq 0x5380
movq %r14, %rdi
callq 0x5670
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Motorist.cpp
// Function: Motorist::StartEngine(std::istream&, bool, std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&, bool, bool)
bool Motorist::StartEngine(istream& SUV, bool tagFlag, stringstream& T, bool unwrapFlag, bool forgetFlag)
{
    if (phase != ready)
        throw Exception("The phase must be ready to call Motorist::StartEngine().");
    engine.InjectCollective(SUV, true);
    if (forgetFlag)
        MakeKnot();
    bool res = HandleTag(tagFlag, T, unwrapFlag);
    if (res)
        phase = riding;
    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpl $0x0, 0x60(%rdi)
jne 0x8f6f
movl %r9d, %r12d
movl %r8d, %ebp
movq %rcx, %r14
movl %edx, %r15d
movq %rdi, %rbx
addq $0x20, %rdi
movl $0x1, %edx
callq 0x5590
testb %r12b, %r12b
je 0x8f44
movq %rbx, %rdi
callq 0x5560
movzbl %r15b, %esi
movzbl %bpl, %ecx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5350
testb %al, %al
je 0x8f62
movl $0x1, 0x60(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x55a0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2445(%rip), %rsi      # 0xb3d1
leaq 0x2476(%rip), %rdx      # 0xb409
movq %rsp, %rdi
callq 0x5160
movq %rbx, %rax
addq $0x10, %rax
movq %rax, (%rbx)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x5170
xorl %ebp, %ebp
movq 0x5ffb(%rip), %rsi      # 0xefc0
movq 0x5fec(%rip), %rdx      # 0xefb8
movq %rbx, %rdi
callq 0x5270
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x8fed
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5060
testb %bpl, %bpl
jne 0x8ff7
jmp 0x8fff
movq %rax, %r14
movq %rbx, %rdi
callq 0x5380
movq %r14, %rdi
callq 0x5670
nop
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Motorist.cpp
// Function: Motorist::MakeKnot()
void Motorist::MakeKnot()
{
    stringstream Tprime;
    engine.GetTags(Tprime, vector<unsigned int>(Pi, cprime/8));
    Tprime.seekg(0, ios_base::beg);
    engine.InjectCollective(Tprime, false);
}

// Assembly:
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5720
movl (%rbx), %esi
movl 0x58(%rbx), %eax
shrl $0x3, %eax
leaq 0x24(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rcx
callq 0x53d0
addq $0x20, %rbx
leaq 0x38(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x5400
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x9068
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x5060
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5150
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5590
movq 0x5f44(%rip), %rsi      # 0xefd0
leaq 0x28(%rsp), %rdi
callq 0x53b0
leaq 0xa8(%rsp), %rdi
callq 0x55b0
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x90cd
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x5060
jmp 0x90cd
jmp 0x90ca
movq %rax, %rbx
movq 0x5efc(%rip), %rsi      # 0xefd0
leaq 0x28(%rsp), %rdi
callq 0x53b0
leaq 0xa8(%rsp), %rdi
callq 0x55b0
movq %rbx, %rdi
callq 0x5670
nop
// File: /workspace/github_c_makefile_star2_O3/intel[P]pf-bb-config/config_app.c
// Function: uio_get_bar0_mapping
static void *
uio_get_bar0_mapping(const char *pci_addr,
		unsigned int bar_size, void *dev)
{
	char bar0path[PATH_MAX];
	int bar0addrfd;
	void *map;

	snprintf(bar0path, sizeof(bar0path),
			"%s/%s/%s", SYS_DIR, pci_addr, BAR0_FILE);
	bar0addrfd = open(bar0path, O_RDWR | O_SYNC);
	if (bar0addrfd < 0) {
		LOG(ERR, "Failed to open BAR %s", bar0path);
		exit(1);
	}
	map = mmap(0, bar_size, PROT_READ | PROT_WRITE, MAP_SHARED,
			bar0addrfd, 0);
	close(bar0addrfd);
	if (map == MAP_FAILED) {
		printf("ERR:SYSFS: mmap failed\n");
		map = NULL; /* MAP_FAILED is not equal to NULL */
	}
	return map;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movl %esi, %ebx
movq %rdi, %r8
leaq 0xd82d(%rip), %rdx      # 0x1b20b
leaq 0xd82f(%rip), %rcx      # 0x1b214
leaq 0xd83d(%rip), %r9       # 0x1b229
movq %rsp, %r14
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdi
xorl %eax, %eax
callq 0xd170
movq %r14, %rdi
movl $0x101002, %esi         # imm = 0x101002
xorl %eax, %eax
callq 0xd2f0
testl %eax, %eax
js 0xda59
movl %eax, %ebp
movl %ebx, %esi
xorl %edi, %edi
movl $0x3, %edx
movl $0x1, %ecx
movl %eax, %r8d
xorl %r9d, %r9d
callq 0xd120
movq %rax, %rbx
movl %ebp, %edi
callq 0xd1a0
cmpq $-0x1, %rbx
jne 0xda4a
leaq 0xdb42(%rip), %rdi      # 0x1b585
callq 0xd0c0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %rbp
retq
callq 0xe36f
leaq 0x2646b(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
leaq 0xd7c4(%rip), %rdx      # 0x1b233
movq %rsp, %r9
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
movl $0x1, %edi
callq 0xd3e0
// File: /workspace/github_c_makefile_star2_O3/intel[P]pf-bb-config/config_app.c
// Function: configure_device
static int
configure_device(hw_device *device)
{

	if ((device->ops.open) && (device->ops.open(device))) {
		LOG(ERR, "device(%s) open failed", device->device_name);
		return -1;
	}

	/* Get BAR0 Mapping for device */
	if (device->ops.get_bar0_addr) {
		device->bar0Addr = device->ops.get_bar0_addr(device->pci_address,
				device->bar_size, device);
		if (device->bar0Addr == NULL)
			return -1;
	} else
		return -1;

	/* Call device specific configuration function */
	if (device->ops.conf(device, device->bar0Addr, device->config_file,
			BB_ACC_FIRST_CFG) == 0) {
		LOG(INFO, "%s PF [%s] configuration complete!",
				device->device_name, device->pci_address);
	} else {
		LOG(ERR, "%s PF [%s] configuration failed!",
				device->device_name, device->pci_address);
		return -1;
	}

	/* enable intr if supported, applicable only in case of vfio */
	if ((device->ops.enable_intr) && (device->ops.enable_intr(device))) {
		LOG(ERR, "Enable interrupts failed");
		return -1;
	}

	bb_acc_set_all_device_status(device, RTE_BBDEV_DEV_CONFIGURED);

	LOG(DEBUG, "Done");
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0xdfab
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
je 0xdfab
callq 0xe36f
leaq 0x25f34(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
movq (%rbx), %r9
leaq 0xd4eb(%rip), %rdx      # 0x1b494
jmp 0xe00c
movq 0x78(%rbx), %rax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0xe01f
leaq 0x20(%rbx), %r14
movl 0xb8(%rbx), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq *%rax
movq %rax, 0xb0(%rbx)
testq %rax, %rax
je 0xe01f
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %ecx
callq *0x38(%rbx)
movl %eax, %ebp
callq 0xe36f
movq (%rbx), %r9
testl %ebp, %ebp
je 0xe02c
leaq 0x25ed2(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
movq %r14, (%rsp)
leaq 0xd4d0(%rip), %rdx      # 0x1b4dc
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x25e9d(%rip), %r15     # 0x33ed0
movq 0x10(%r15), %r8
movq %r14, (%rsp)
leaq 0xd470(%rip), %rdx      # 0x1b4b2
xorl %ebp, %ebp
movl $0x2, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0xe086
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
je 0xe086
callq 0xe36f
movq (%r15), %r8
leaq 0xd48e(%rip), %rdx      # 0x1b504
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
jmp 0xe01a
movq %rbx, %rdi
movl $0x3, %esi
callq 0x1a06b
callq 0xe36f
movq 0x18(%r15), %r8
leaq 0xd481(%rip), %rdx      # 0x1b524
leaq 0xd48c(%rip), %r9       # 0x1b536
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
jmp 0xe01f
// File: /workspace/github_c_makefile_star2_O3/intel[P]pf-bb-config/config_app.c
// Function: get_file_val
static unsigned long
get_file_val(const char *file_path)
{
	char content[BUFSIZ];
	FILE *f;

	f = fopen(file_path, "r");
	if (NULL == f) {
		LOG(ERR, "Failed to open %s", file_path);
		exit(1);
	}
	if (fgets(content, sizeof(content), f) == NULL) {
		fclose(f);
		return false;
	}
	fclose(f);
	const unsigned long content_val = strtoul(content, NULL, 16);

	return content_val;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x2008, %rsp           # imm = 0x2008
movq %rdi, %rbx
leaq 0xdea1(%rip), %rsi      # 0x1c194
callq 0xd320
testq %rax, %rax
je 0xe33e
movq %rax, %r14
movq %rsp, %rdi
movl $0x2000, %esi           # imm = 0x2000
movq %rax, %rdx
callq 0xd1e0
movq %rax, %rbx
movq %r14, %rdi
callq 0xd0f0
testq %rbx, %rbx
je 0xe331
movq %rsp, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0xd390
jmp 0xe333
xorl %eax, %eax
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r14
retq
callq 0xe36f
leaq 0x25b86(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
leaq 0xd11a(%rip), %rdx      # 0x1b46e
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
movq %rbx, %r9
xorl %eax, %eax
callq 0x199b4
movl $0x1, %edi
callq 0xd3e0
// File: /workspace/github_c_makefile_star2_O3/intel[P]pf-bb-config/./bb_acc_log.h
// Function: timestamp
static char *timestamp()
{
	char *time_s;
	time_t now = time(NULL);
	const struct tm *gtm = gmtime(&now);
	if (gtm == NULL)
		return NULL;

	time_s = asctime(gtm);
	if (time_s == NULL)
		return NULL;

	time_s[strlen(time_s)-1] = '\0';
	return time_s;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
xorl %ebx, %ebx
xorl %edi, %edi
callq 0xd250
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0xd350
testq %rax, %rax
je 0xe3b0
movq %rax, %rdi
callq 0xd130
testq %rax, %rax
je 0xe3ae
movq %rax, %rbx
movq %rax, %rdi
callq 0xd110
movb $0x0, -0x1(%rbx,%rax)
jmp 0xe3b0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/intel[P]pf-bb-config/acc100/acc100_cfg_app.c
// Function: accFromQgid
int
accFromQgid(int qg_idx, struct acc100_conf *acc100_conf)
{
	int accQg[ACC100_NUM_QGRPS];
	int NumQGroupsPerFn[NUM_ACC];
	int acc, qgIdx, qgIndex = 0;
	for (qgIdx = 0; qgIdx < ACC100_NUM_QGRPS; qgIdx++)
		accQg[qgIdx] = 0;
	NumQGroupsPerFn[UL_4G] = acc100_conf->q_ul_4g.num_qgroups;
	NumQGroupsPerFn[UL_5G] = acc100_conf->q_ul_5g.num_qgroups;
	NumQGroupsPerFn[DL_4G] = acc100_conf->q_dl_4g.num_qgroups;
	NumQGroupsPerFn[DL_5G] = acc100_conf->q_dl_5g.num_qgroups;
	for (acc = UL_4G;  acc < NUM_ACC; acc++)
		for (qgIdx = 0; qgIdx < NumQGroupsPerFn[acc]; qgIdx++)
			accQg[qgIndex++] = acc;
	acc = accQg[qg_idx];
	return acc;
}

// Assembly:
xorps %xmm0, %xmm0
movaps %xmm0, -0x28(%rsp)
movaps %xmm0, -0x18(%rsp)
movzwl 0x6(%rsi), %eax
movl %eax, -0x38(%rsp)
movzwl 0x12(%rsi), %eax
movl %eax, -0x34(%rsp)
movzwl 0xc(%rsi), %eax
movl %eax, -0x30(%rsp)
movzwl 0x18(%rsi), %eax
movl %eax, -0x2c(%rsp)
xorl %eax, %eax
xorl %ecx, %ecx
movl -0x38(%rsp,%rax,4), %edx
testl %edx, %edx
jle 0xe40f
movslq %ecx, %rsi
leaq (%rsp,%rsi,4), %r8
addq $-0x28, %r8
xorl %esi, %esi
movl %eax, (%r8,%rsi,4)
incq %rsi
cmpl %esi, %edx
jne 0xe402
addl %esi, %ecx
incq %rax
cmpq $0x4, %rax
jne 0xe3ed
movslq %edi, %rax
movl -0x28(%rsp,%rax,4), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/intel[P]pf-bb-config/acc100/acc100_cfg_app.c
// Function: qtopFromAcc
void
qtopFromAcc(struct q_topology_t **qtop, int acc_enum,
		struct acc100_conf *acc100_conf)
{
	struct q_topology_t *p_qtop;
	p_qtop = NULL;
	switch (acc_enum) {
	case UL_4G:
		p_qtop = &(acc100_conf->q_ul_4g);
		break;
	case UL_5G:
		p_qtop = &(acc100_conf->q_ul_5g);
		break;
	case DL_4G:
		p_qtop = &(acc100_conf->q_dl_4g);
		break;
	case DL_5G:
		p_qtop = &(acc100_conf->q_dl_5g);
		break;
	default:
		/* NOTREACHED */
		LOG(ERR, "Unexpected error evaluating qtopFromAcc");
		break;
	}
	*qtop = p_qtop;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x3, %esi
ja 0xe459
movq %rdx, %r14
movl %esi, %eax
leaq 0xd254(%rip), %rcx      # 0x1b68c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x6, %r14
jmp 0xe480
addq $0xc, %r14
jmp 0xe480
addq $0x18, %r14
jmp 0xe480
addq $0x12, %r14
jmp 0xe480
callq 0xf853
leaq 0x25a6b(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
leaq 0xd22d(%rip), %rdx      # 0x1b69c
xorl %r14d, %r14d
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x199b4
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/intel[P]pf-bb-config/acc100/acc100_cfg_app.c
// Function: aqDepth
int
aqDepth(int qg_idx, struct acc100_conf *acc100_conf)
{
	struct q_topology_t *q_top = NULL;
	int acc_enum = accFromQgid(qg_idx, acc100_conf);
	qtopFromAcc(&q_top, acc_enum, acc100_conf);
	if (q_top == NULL)
		return 1;
	return MAX(1, q_top->aq_depth_log2);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsp, %r14
movq $0x0, (%r14)
callq 0xe3bc
movq %r14, %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0xe420
movq (%r14), %rax
testq %rax, %rax
je 0xe4c6
movzwl 0x4(%rax), %eax
cmpw $0x1, %ax
adcl $0x0, %eax
movzwl %ax, %eax
jmp 0xe4cb
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/intel[P]pf-bb-config/acc100/acc100_cfg_app.c
// Function: aqNum
int
aqNum(int qg_idx, struct acc100_conf *acc100_conf)
{
	struct q_topology_t *q_top = NULL;
	int acc_enum = accFromQgid(qg_idx, acc100_conf);
	qtopFromAcc(&q_top, acc_enum, acc100_conf);
	if (q_top == NULL)
		return 0;
	return q_top->num_aqs_per_groups;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsp, %r14
movq $0x0, (%r14)
callq 0xe3bc
movq %r14, %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0xe420
movq (%r14), %rax
testq %rax, %rax
je 0xe504
movzwl 0x2(%rax), %eax
jmp 0xe506
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/intel[P]pf-bb-config/acc100/acc100_cfg_parser.c
// Function: acc100_queue_range_check
int
acc100_queue_range_check(struct q_topology_t q_conf)
{
	if ((q_conf.num_aqs_per_groups < 1) ||
			(q_conf.num_aqs_per_groups > ACC100_NUM_AQS)) {
		printf("ERROR: Number of AQs out of range %d\n",
				q_conf.num_aqs_per_groups);
		return -1;
	}
	if ((q_conf.aq_depth_log2 < 1) ||
			(q_conf.aq_depth_log2 > ACC100_MAX_QDEPTH)) {
		printf("ERROR: AQ Depth out of range %d\n",
				q_conf.aq_depth_log2);
		return -1;
	}
	if (q_conf.num_qgroups > ACC100_NUM_QGRPS) {
		printf("ERROR: Number of QG out of range %d\n",
				q_conf.num_qgroups);
		return -1;
	}
	return 0;
}

// Assembly:
pushq %rax
movq %rdi, %rax
leal -0x110000(%rdi), %ecx
cmpl $0xffefffff, %ecx       # imm = 0xFFEFFFFF
ja 0xf8c0
shrl $0x10, %eax
leaq 0xc274(%rip), %rdi      # 0x1bb30
movl %eax, %esi
jmp 0xf8ec
movq %rax, %rcx
shrq $0x20, %rcx
movzwl %cx, %esi
leal -0xd(%rsi), %ecx
cmpl $-0xd, %ecx
ja 0xf8db
leaq 0xc27d(%rip), %rdi      # 0x1bb56
jmp 0xf8ec
movzwl %ax, %esi
xorl %eax, %eax
cmpl $0x9, %esi
jb 0xf8f8
leaq 0xc28b(%rip), %rdi      # 0x1bb77
xorl %eax, %eax
callq 0xd150
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/intel[P]pf-bb-config/acc100/acc100_cfg_parser.c
// Function: acc100_range_check
int
acc100_range_check(struct acc100_conf *acc100_conf)
{
	uint16_t totalQgs = acc100_conf->q_ul_4g.num_qgroups +
			acc100_conf->q_ul_5g.num_qgroups +
			acc100_conf->q_dl_4g.num_qgroups +
			acc100_conf->q_dl_5g.num_qgroups;
	if (totalQgs > ACC100_NUM_QGRPS) {
		printf("ERROR: Number of Qgroups %d > %d\n",
				totalQgs, ACC100_NUM_QGRPS);
		return -1;
	}
	if (acc100_conf->num_vf_bundles > ACC100_NUM_VFS) {
		printf("ERROR: Number of VFs bundle %d > %d\n",
				acc100_conf->num_vf_bundles, ACC100_NUM_VFS);
		return -1;
	}

	if (acc100_queue_range_check(acc100_conf->q_ul_4g) != 0)
		return -1;
	if (acc100_queue_range_check(acc100_conf->q_dl_4g) != 0)
		return -1;
	if (acc100_queue_range_check(acc100_conf->q_ul_5g) != 0)
		return -1;
	if (acc100_queue_range_check(acc100_conf->q_dl_5g) != 0)
		return -1;
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movzwl 0x12(%rdi), %eax
addw 0x6(%rdi), %ax
addw 0xc(%rdi), %ax
addw 0x18(%rdi), %ax
cmpw $0x9, %ax
jb 0xf924
movzwl %ax, %esi
leaq 0xc27f(%rip), %rdi      # 0x1bb9c
movl $0x8, %edx
jmp 0xf93c
movq %rdi, %rbx
movzwl 0x4(%rdi), %esi
cmpl $0x11, %esi
jb 0xf951
leaq 0xc287(%rip), %rdi      # 0x1bbbe
movl $0x10, %edx
xorl %eax, %eax
callq 0xd150
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl 0x6(%rbx), %eax
movzwl 0xa(%rbx), %edi
shlq $0x20, %rdi
orq %rax, %rdi
callq 0xf8a0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0xf948
movl 0xc(%rbx), %eax
movl 0x10(%rbx), %edi
shlq $0x20, %rdi
orq %rax, %rdi
callq 0xf8a0
testl %eax, %eax
jne 0xf948
movl 0x12(%rbx), %eax
movzwl 0x16(%rbx), %edi
shlq $0x20, %rdi
orq %rax, %rdi
callq 0xf8a0
testl %eax, %eax
jne 0xf948
movl 0x18(%rbx), %eax
movl 0x1c(%rbx), %edi
shlq $0x20, %rdi
orq %rax, %rdi
callq 0xf8a0
xorl %ebp, %ebp
negl %eax
sbbl %ebp, %ebp
jmp 0xf948
// File: /workspace/github_c_makefile_star2_O3/intel[P]pf-bb-config/acc100/acc100_cfg_parser.c
// Function: acc100_parse_conf_file
int
acc100_parse_conf_file(const char *file_name, struct acc100_conf *acc100_conf)
{
	int ret;

	set_default_config(acc100_conf);

	ret = cfg_parse(file_name, acc100_handler, acc100_conf);

	if (ret != 0) {
		printf("ERROR: Config file parser error\n");
		set_default_config(acc100_conf);
		return -1;
	}

	ret = acc100_range_check(acc100_conf);
	if (ret != 0) {
		printf("ERROR: Parameter out of range\n");
		set_default_config(acc100_conf);
		return -1;
	}

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xfa16
leaq 0xf9(%rip), %rsi        # 0xfac6
movq %r14, %rdi
movq %rbx, %rdx
callq 0x139e6
testl %eax, %eax
je 0xf9e5
leaq 0xc3be(%rip), %rdi      # 0x1bda1
jmp 0xf9f8
movq %rbx, %rdi
callq 0xf8fa
testl %eax, %eax
je 0xfa12
leaq 0xc38b(%rip), %rdi      # 0x1bd83
callq 0xd0c0
movq %rbx, %rdi
callq 0xfa16
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
jmp 0xfa0a
// File: /workspace/github_c_makefile_star2_O3/intel[P]pf-bb-config/acc100/acc100_cfg_parser.c
// Function: parse_number16
static int
parse_number16(const char *str, uint16_t *value)
{
	uint64_t val = 0;
	char *end;

	if (str == NULL)
		return -EINVAL;

	val = strtoul(str, &end, 0);
	if (val > UINT16_MAX || str == end) {
		printf("ERROR: Invalid value %" PRIu64 "\n", val);
		return -ERANGE;
	}

	*value = (uint16_t) val;
	return 1;
}

// Assembly:
testq %rdi, %rdi
je 0x101c2
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %rsi
xorl %edx, %edx
callq 0xd390
cmpq $0xffff, %rax           # imm = 0xFFFF
ja 0x101c8
cmpq %r14, (%rsp)
je 0x101c8
movw %ax, (%rbx)
movl $0x1, %eax
jmp 0x101de
movl $0xffffffea, %eax       # imm = 0xFFFFFFEA
retq
leaq 0xbb74(%rip), %rdi      # 0x1bd43
movq %rax, %rsi
xorl %eax, %eax
callq 0xd150
movl $0xffffffde, %eax       # imm = 0xFFFFFFDE
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/intel[P]pf-bb-config/acc100/acc100_cfg_parser.c
// Function: parse_item_no
static int
parse_item_no(const char *full_name, const char *base_name)
{
	int postfix_len, number_start, ret;
	uint16_t item_no = 0;

	postfix_len = strlen(full_name) - strlen(base_name);
	if (postfix_len > 0) {
		number_start = strlen((const char *) base_name);
		ret = parse_number16(&full_name[number_start], &item_no);
		if (ret != 1)
			printf("ERROR: Parsing item (%d) failed (%d)\n", item_no, ret);
	}

	return item_no;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movw $0x0, 0xe(%rsp)
callq 0xd110
movq %rax, %r15
movq %r14, %rdi
callq 0xd110
subl %eax, %r15d
testl %r15d, %r15d
jle 0x10247
cltq
addq %rax, %rbx
leaq 0xe(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10191
movzwl (%r14), %ebx
cmpl $0x1, %eax
je 0x10249
movzwl %bx, %esi
leaq 0xbb21(%rip), %rdi      # 0x1bd5d
movl %eax, %edx
xorl %eax, %eax
callq 0xd150
jmp 0x10249
xorl %ebx, %ebx
movzwl %bx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/intel[P]pf-bb-config/acc100/acc100_cfg_parser.c
// Function: parse_number32
static int
parse_number32(const char *str, uint32_t *value)
{
	uint64_t val = 0;
	char *end;

	if (str == NULL)
		return -EINVAL;

	val = strtoul(str, &end, 0);
	if (val > UINT32_MAX || str == end) {
		printf("ERROR: Invalid value %" PRIu64 "\n", val);
		return -ERANGE;
	}
	*value = (uint32_t) val;
	return 1;
}

// Assembly:
testq %rdi, %rdi
je 0x10287
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %rsi
xorl %edx, %edx
callq 0xd390
movq %rax, %rcx
shrq $0x20, %rcx
jne 0x1028d
cmpq %r14, (%rsp)
je 0x1028d
movl %eax, (%rbx)
movl $0x1, %eax
jmp 0x102a3
movl $0xffffffea, %eax       # imm = 0xFFFFFFEA
retq
leaq 0xbaaf(%rip), %rdi      # 0x1bd43
movq %rax, %rsi
xorl %eax, %eax
callq 0xd150
movl $0xffffffde, %eax       # imm = 0xFFFFFFDE
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/intel[P]pf-bb-config/fpga_lte/fpga_lte_cfg_parser.c
// Function: fpga_lte_parse_conf_file
int
fpga_lte_parse_conf_file(const char *file_name,
		struct fpga_lte_fec_conf *fpga_conf)
{
	int ret;

	set_default_config(fpga_conf);

	ret = cfg_parse(file_name, fpga_handler, fpga_conf);

	if (ret == -1) {
		printf("ERROR: Error loading configuration file %s\n",
			file_name);
		set_default_config(fpga_conf);
		return -ENOENT;
	} else if (ret == -2) {
		printf("ERROR: Memory allocation error\n");
		set_default_config(fpga_conf);
		return -ENOMEM;
	}

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb $0x1, (%rsi)
movl $0x40400303, 0x11(%rsi) # imm = 0x40400303
movaps 0xba25(%rip), %xmm0     # 0x1c040
movups %xmm0, 0x1(%rsi)
leaq 0x5f(%rip), %rsi        # 0x10685
movq %rbx, %rdx
callq 0x139e6
cmpl $-0x2, %eax
je 0x10654
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
jne 0x1067d
leaq 0xba0d(%rip), %rdi      # 0x1c050
movq %r14, %rsi
xorl %eax, %eax
callq 0xd150
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0x10665
leaq 0xbaab(%rip), %rdi      # 0x1c106
callq 0xd0c0
movl $0xfffffff4, %eax       # imm = 0xFFFFFFF4
leaq 0x1(%rbx), %rcx
movb $0x1, (%rbx)
movl $0x40400303, 0x11(%rbx) # imm = 0x40400303
movaps 0xb9c6(%rip), %xmm0     # 0x1c040
movups %xmm0, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq