LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.cpp
// Function: KeccakF::ROL(unsigned long long&, int) const
void KeccakF::ROL(LaneValue& L, int offset) const
{
    offset %= (int)laneSize;
    if (offset < 0) offset += laneSize;

    if (offset != 0) {
        L &= mask;
        L = (((LaneValue)L) << offset) ^ (((LaneValue)L) >> (laneSize-offset));
    }
    L &= mask;
}

// Assembly:
movl %edx, %eax
movl 0xc(%rdi), %ecx
cltd
idivl %ecx
movl %edx, %eax
sarl $0x1f, %eax
andl %ecx, %eax
addl %edx, %eax
je 0x5e6a
movq (%rsi), %rdx
andq 0x50(%rdi), %rdx
shlxq %rax, %rdx, %r8
subl %eax, %ecx
shrxq %rcx, %rdx, %rax
xorq %r8, %rax
movq %rax, (%rsi)
movq 0x50(%rdi), %rax
andq %rax, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.cpp
// Function: KeccakF::fromBytesToLanes(unsigned char const*, std::vector<unsigned long long, std::allocator<unsigned long long>>&) const
void KeccakF::fromBytesToLanes(const UINT8 *in, vector<LaneValue>& out) const
{
    out.resize(25);
    if ((laneSize == 1) || (laneSize == 2) || (laneSize == 4) || (laneSize == 8)) {
        for(unsigned int i=0; i<25; i++)
            out[i] = (in[i*laneSize/8] >> ((i*laneSize) % 8)) & mask;
    }
    else if ((laneSize == 16) || (laneSize == 32) || (laneSize == 64)) {
        for(unsigned int i=0; i<25; i++) {
            out[i] = 0;
            for(unsigned int j=0; j<(laneSize/8); j++)
                out[i] |= LaneValue((UINT8)(in[i*laneSize/8+j])) << (8*j);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl $0x19, %esi
movq %rdx, %rdi
callq 0x5280
movl 0xc(%r14), %eax
leal -0x1(%rax), %ecx
cmpl $0x3f, %ecx
ja 0x5f3a
movl $0x8b, %edx
btq %rcx, %rdx
jae 0x5ed9
movq (%r15), %rcx
xorl %edx, %edx
xorl %esi, %esi
movl %edx, %edi
shrl $0x3, %edi
movzbl (%rbx,%rdi), %edi
movl %edx, %r8d
andb $0x7, %r8b
shrxl %r8d, %edi, %edi
andl 0x50(%r14), %edi
movq %rdi, (%rcx,%rsi,8)
incq %rsi
addl %eax, %edx
cmpq $0x19, %rsi
jne 0x5eaf
jmp 0x5f3a
movabsq $-0x7fffffff7fff8000, %rdx # imm = 0x8000000080008000
btq %rcx, %rdx
jae 0x5f3a
movq (%r15), %rcx
movl %eax, %edx
andl $-0x8, %edx
xorl %esi, %esi
xorl %edi, %edi
movq $0x0, (%rcx,%rdi,8)
cmpl $0x8, %eax
jb 0x5f2f
movl %esi, %r8d
shrl $0x3, %r8d
addq %rbx, %r8
movq (%rcx,%rdi,8), %r9
xorl %r10d, %r10d
movzbl (%r8), %r11d
shlxq %r10, %r11, %r11
orq %r11, %r9
movq %r9, (%rcx,%rdi,8)
incq %r8
addq $0x8, %r10
cmpq %r10, %rdx
jne 0x5f13
incq %rdi
addl %eax, %esi
cmpq $0x19, %rdi
jne 0x5ef5
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.cpp
// Function: KeccakF::fromLanesToBytes(std::vector<unsigned long long, std::allocator<unsigned long long>> const&, unsigned char*) const
void KeccakF::fromLanesToBytes(const vector<LaneValue>& in, UINT8 *out) const
{
    if ((laneSize == 1) || (laneSize == 2) || (laneSize == 4) || (laneSize == 8)) {
        for(unsigned int i=0; i<(25*laneSize+7)/8; i++)
            out[i] = 0;
        for(unsigned int i=0; i<25; i++)
            out[i*laneSize/8] |= in[i] << ((i*laneSize) % 8);
    }
    else if ((laneSize == 16) || (laneSize == 32) || (laneSize == 64)) {
        for(unsigned int i=0; i<25; i++)
            for(unsigned int j=0; j<(laneSize/8); j++)
                out[i*(laneSize/8)+j] = (UINT8)((in[i] >> (8*j)) & 0xFF);
    }
}

// Assembly:
movl 0xc(%rdi), %eax
decl %eax
cmpl $0x3f, %eax
ja 0x6005
movl $0x8b, %ecx
btq %rax, %rcx
jae 0x5fb4
movl 0xc(%rdi), %eax
leal (%rax,%rax,4), %eax
leal (%rax,%rax,4), %eax
addl $0x7, %eax
cmpl $0x8, %eax
jb 0x5f87
xorl %eax, %eax
movb $0x0, (%rdx,%rax)
incq %rax
movl 0xc(%rdi), %ecx
leal (%rcx,%rcx,4), %ecx
leal (%rcx,%rcx,4), %ecx
addl $0x7, %ecx
shrl $0x3, %ecx
cmpq %rcx, %rax
jb 0x5f6c
xorl %eax, %eax
movq (%rsi), %rcx
movl 0xc(%rdi), %r8d
imull %eax, %r8d
movl %r8d, %r9d
andb $0x7, %r9b
shlxq %r9, (%rcx,%rax,8), %rcx
shrl $0x3, %r8d
orb %cl, (%rdx,%r8)
incq %rax
cmpq $0x19, %rax
jne 0x5f89
jmp 0x6005
movabsq $-0x7fffffff7fff8000, %rcx # imm = 0x8000000080008000
btq %rax, %rcx
jae 0x6005
xorl %eax, %eax
movl 0xc(%rdi), %ecx
cmpl $0x8, %ecx
jb 0x5ffc
shrl $0x3, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
movq (%rsi), %r10
shrxq %r8, (%r10,%rax,8), %r10
imull %eax, %ecx
addl %r9d, %ecx
movb %r10b, (%rdx,%rcx)
incq %r9
movl 0xc(%rdi), %ecx
shrl $0x3, %ecx
addq $0x8, %r8
cmpq %rcx, %r9
jb 0x5fd7
incq %rax
cmpq $0x19, %rax
jne 0x5fc6
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.cpp
// Function: KeccakF::operator()(unsigned char*) const
void KeccakF::operator()(UINT8 * state) const
{
    vector<LaneValue> A(25);
    fromBytesToLanes(state, A);
    forward(A);
    fromLanesToBytes(A, state);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
vxorps %xmm0, %xmm0, %xmm0
movq %rsp, %r15
vmovaps %xmm0, (%r15)
xorl %r12d, %r12d
movq %r12, 0x10(%r15)
movl $0xc8, %edi
callq 0x5210
movq %rax, (%r15)
movq %rax, 0x8(%r15)
leaq 0xc8(%rax), %rcx
movq %rcx, 0x10(%r15)
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, (%rax)
vmovups %ymm0, 0x20(%rax)
vmovups %ymm0, 0x40(%rax)
vmovups %ymm0, 0x60(%rax)
vmovups %ymm0, 0x80(%rax)
vmovups %ymm0, 0xa0(%rax)
movq %r12, 0xc0(%rax)
movq %rcx, 0x8(%r15)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
vzeroupper
callq 0x54c0
movq %rsp, %rsi
movq %r14, %rdi
callq 0x5130
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x5530
movq (%r15), %rdi
testq %rdi, %rdi
je 0x60ba
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x5060
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x60df
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x5060
movq %rbx, %rdi
callq 0x5680
nop
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.cpp
// Function: KeccakF::getDescription[abi:cxx11]() const
string KeccakF::getDescription() const
{
    stringstream a;
    if ((nrRounds == nominalNrRounds) && (startRoundIndex == 0))
        a << "Keccak-f[" << dec << width;
    else if ((startRoundIndex + nrRounds) == nominalNrRounds)
        a << "Keccak-p[" << dec << width << ", " << nrRounds;
    else {
        a << "Keccak-f[" << dec << width;
        a << ", " << dec << nrRounds << " rounds " << startRoundIndex << "-" << (startRoundIndex+nrRounds-1);
    }
    a << "]";
    return a.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5730
movl 0x18(%r14), %edx
movl 0x10(%r14), %eax
movl 0x14(%r14), %ecx
movl %edx, %esi
xorl %eax, %esi
orl %ecx, %esi
jne 0x6233
leaq 0x18(%rsp), %r15
leaq 0x4eda(%rip), %rsi      # 0xb0e0
movl $0x9, %edx
movq %r15, %rdi
callq 0x5250
movq 0x18(%rsp), %rax
movq -0x18(%rax), %rax
movl 0x30(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x30(%rsp,%rax)
movl 0x8(%r14), %eax
jmp 0x6349
addl %edx, %ecx
leaq 0x18(%rsp), %r15
cmpl %eax, %ecx
jne 0x6295
leaq 0x4ea5(%rip), %rsi      # 0xb0ea
movl $0x9, %edx
movq %r15, %rdi
callq 0x5250
movq 0x18(%rsp), %rax
movq -0x18(%rax), %rax
movl 0x30(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x30(%rsp,%rax)
movl 0x8(%r14), %esi
movq %r15, %rdi
callq 0x56e0
movq %rax, %r15
leaq 0x4e75(%rip), %rsi      # 0xb0f4
movl $0x2, %edx
movq %rax, %rdi
callq 0x5250
movl 0x18(%r14), %eax
jmp 0x6349
leaq 0x4e44(%rip), %rsi      # 0xb0e0
movl $0x9, %edx
movq %r15, %rdi
callq 0x5250
movq 0x18(%rsp), %rax
movq -0x18(%rax), %rax
movl 0x30(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x30(%rsp,%rax)
movl 0x8(%r14), %esi
movq %r15, %rdi
callq 0x56e0
leaq 0x4e21(%rip), %rsi      # 0xb0f4
movl $0x2, %edx
movq %r15, %rdi
callq 0x5250
movq 0x18(%rsp), %rax
movq -0x18(%rax), %rax
movl 0x30(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x30(%rsp,%rax)
movl 0x18(%r14), %esi
movq %r15, %rdi
callq 0x56e0
movq %rax, %r15
leaq 0x4dea(%rip), %rsi      # 0xb0f7
movl $0x8, %edx
movq %rax, %rdi
callq 0x5250
movl 0x14(%r14), %esi
movq %r15, %rdi
callq 0x5600
movq %rax, %r15
leaq 0x4dd9(%rip), %rsi      # 0xb109
movl $0x1, %edx
movq %rax, %rdi
callq 0x5250
movl 0x14(%r14), %eax
movl 0x18(%r14), %ecx
addl %ecx, %eax
decl %eax
movl %eax, %esi
movq %r15, %rdi
callq 0x56e0
leaq 0x18(%rsp), %rdi
leaq 0x4da1(%rip), %rsi      # 0xb100
movl $0x1, %edx
callq 0x5250
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x54b0
movq 0x8c53(%rip), %rsi      # 0xefd0
leaq 0x8(%rsp), %rdi
callq 0x53b0
leaq 0x88(%rsp), %rdi
callq 0x55c0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8c22(%rip), %rsi      # 0xefd0
leaq 0x8(%rsp), %rdi
callq 0x53b0
leaq 0x88(%rsp), %rdi
callq 0x55c0
movq %rbx, %rdi
callq 0x5680
nop
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.cpp
// Function: KeccakF::getName[abi:cxx11]() const
string KeccakF::getName() const
{
    stringstream a;
    a << "KeccakF-" << dec << width << "-" << nrRounds;
    if (startRoundIndex != 0)
        a << "-" << startRoundIndex;
    return a.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x5730
leaq 0x10(%rsp), %r15
leaq 0x4d0c(%rip), %rsi      # 0xb102
movl $0x8, %edx
movq %r15, %rdi
callq 0x5250
movq 0x10(%rsp), %rax
movq -0x18(%rax), %rax
movl 0x28(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x28(%rsp,%rax)
movl 0x8(%r14), %esi
movq %r15, %rdi
callq 0x56e0
movq %rax, %r12
leaq 0x4cd9(%rip), %rsi      # 0xb109
movl $0x1, %edx
movq %rax, %rdi
callq 0x5250
movl 0x18(%r14), %esi
movq %r12, %rdi
callq 0x56e0
cmpl $0x0, 0x14(%r14)
je 0x6470
leaq 0x4cb2(%rip), %rsi      # 0xb109
movl $0x1, %edx
movq %r15, %rdi
callq 0x5250
movl 0x14(%r14), %esi
movq %r15, %rdi
callq 0x5600
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x54b0
movq 0x8b4c(%rip), %rsi      # 0xefd0
movq %rsp, %rdi
callq 0x53b0
leaq 0x80(%rsp), %rdi
callq 0x55c0
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8b1b(%rip), %rsi      # 0xefd0
movq %rsp, %rdi
callq 0x53b0
leaq 0x80(%rsp), %rdi
callq 0x55c0
movq %rbx, %rdi
callq 0x5680
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.cpp
// Function: LFSR86540(unsigned char&)
bool LFSR86540(UINT8& state)
{
    bool result = (state & 0x01) != 0;
    if ((state & 0x80) != 0)
        state = (state << 1) ^ 0x71;
    else
        state <<= 1;
    return result;
}

// Assembly:
movb (%rdi), %al
leal (%rax,%rax), %ecx
movzbl %cl, %edx
xorb $0x71, %cl
testb %al, %al
movzbl %cl, %ecx
cmovnsl %edx, %ecx
movb %cl, (%rdi)
andb $0x1, %al
retq
nop
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.cpp
// Function: KeccakF::buildBitName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int, unsigned int)
string KeccakF::buildBitName(const string& prefixSymbol, unsigned int laneSize, unsigned int z)
{
    stringstream s;
    s << prefixSymbol;
    if (laneSize > 1) {
        s.fill('0');
        if (laneSize <= 10)
            s.width(1);
        else if (laneSize <= 100)
            s.width(2);
        s << z;
    }
    return s.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5730
leaq 0x18(%rsp), %r14
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r14, %rdi
callq 0x5250
cmpl $0x2, %r15d
jb 0x66a5
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %r12
addq $0x8, %r12
cmpb $0x0, 0xe1(%r12)
jne 0x666e
movq %r12, %rdi
movl $0x20, %esi
callq 0x5030
movb %al, 0xe0(%r12)
movb $0x1, 0xe1(%r12)
movb $0x30, 0xe0(%r12)
movl $0x1, %eax
cmpl $0xb, %r15d
jb 0x668d
movl $0x2, %eax
cmpl $0x64, %r15d
ja 0x669b
movq 0x8(%rsp), %rcx
movq -0x18(%rcx), %rcx
movq %rax, 0x18(%rsp,%rcx)
movl %ebp, %esi
movq %r14, %rdi
callq 0x56e0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x54b0
movq 0x8917(%rip), %rsi      # 0xefd0
leaq 0x8(%rsp), %rdi
callq 0x53b0
leaq 0x88(%rsp), %rdi
callq 0x55c0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x88e3(%rip), %rsi      # 0xefd0
leaq 0x8(%rsp), %rdi
callq 0x53b0
leaq 0x88(%rsp), %rdi
callq 0x55c0
movq %rbx, %rdi
callq 0x5680
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.h
// Function: void KeccakF::round<unsigned long long>(std::vector<unsigned long long, std::allocator<unsigned long long>>&, int) const
void KeccakF::round(vector<Lane>& state, int roundIndex) const
{
    theta(state);
    rho(state);
    pi(state);
    chi(state);
    iota(state, roundIndex);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x50c0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x51d0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x56a0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x52d0
movslq %ebp, %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
addl %ecx, %eax
addl $0xff, %eax
movl $0x80808081, %ecx       # imm = 0x80808081
imulq %rax, %rcx
shrq $0x27, %rcx
movl %ecx, %edx
shll $0x8, %edx
subl %edx, %ecx
addl %eax, %ecx
movq 0x38(%r14), %rax
movq (%rax,%rcx,8), %rax
movq (%rbx), %rcx
xorq %rax, (%rcx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x5450
movq (%r14), %rax
movq (%rbx), %rcx
xorl %edx, %edx
movl $0xcccccccd, %esi       # imm = 0xCCCCCCCD
xorl %edi, %edi
xorl %r8d, %r8d
xorl %r9d, %r9d
movl %edx, %r10d
movl %edi, %r11d
movq %rcx, %rbx
movl %r10d, %r14d
imulq %rsi, %r14
shrq $0x22, %r14
leal (%r14,%r14,4), %r14d
leal (%r14,%r14,4), %ebp
movl %r11d, %r14d
subl %ebp, %r14d
movq (%rax,%r9,8), %r15
movq %r15, (%rbx,%r14,8)
addq $0x8, %rbx
addl $0xf, %r11d
addl $0x3, %r10d
addq $0x5, %r9
cmpq $0x19, %r9
jne 0x7300
incq %r8
addl $0xa, %edi
addl $0x2, %edx
addq $0x8, %rax
cmpq $0x5, %r8
jne 0x72f4
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x7360
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x5060
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl $0x28, %edi
callq 0x5210
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, (%rax)
movq $0x0, 0x20(%rax)
movq (%rbx), %rcx
leaq 0x10(%rcx), %rsi
xorl %edi, %edi
movabsq $-0x3333333333333333, %r8 # imm = 0xCCCCCCCCCCCCCCCD
movq %rcx, %r9
leaq (%rdi,%rdi,4), %rdx
leaq (%rcx,%rdx,8), %r10
movl $0x2, %edx
xorl %r11d, %r11d
mulxq %r8, %rbx, %rbx
addq %rbx, %rbx
andq $-0x8, %rbx
leaq (%rbx,%rbx,4), %rbx
movq %rsi, %r14
subq %rbx, %r14
leaq 0x1(%r11), %rbx
cmpq $0x4, %r11
movl $0x0, %r15d
cmovneq %rbx, %r15
movq (%r10,%r15,8), %r15
andnq (%r14,%r11,8), %r15, %r14
xorq (%r9,%r11,8), %r14
movq %r14, (%rax,%r11,8)
incq %rdx
movq %rbx, %r11
cmpq $0x5, %rbx
jne 0x73b4
xorl %edx, %edx
movq (%rax,%rdx,8), %r10
movq %r10, (%r9,%rdx,8)
incq %rdx
cmpq $0x5, %rdx
jne 0x73fc
incq %rdi
addq $0x28, %r9
addq $0x28, %rsi
cmpq $0x5, %rdi
jne 0x73a4
movl $0x28, %esi
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
vzeroupper
jmp 0x5060
nop
// File: /workspace/github_c_makefile_star2_O1/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
addl %ecx, %eax
addl $0xff, %eax
movl $0x80808081, %ecx       # imm = 0x80808081
imulq %rax, %rcx
shrq $0x27, %rcx
movl %ecx, %edx
shll $0x8, %edx
subl %edx, %ecx
addl %eax, %ecx
movq 0x38(%rdi), %rax
movq (%rax,%rcx,8), %rax
movq (%rsi), %rcx
xorq %rax, (%rcx)
callq 0x5090
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5580
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_O1/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, %rbx
movl $0x10, %r13d
xorl %r15d, %r15d
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
xorl %eax, %eax
movq %rsi, (%rsp)
movq %rax, 0x8(%rsp)
movl $0x28, %edi
callq 0x5210
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, (%rax)
movq $0x0, 0x20(%rax)
movq (%rbx), %rcx
addq %r15, %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movq %rsi, (%rax,%rdx,8)
incq %rdx
cmpq $0x5, %rdx
jne 0x758b
movq (%rbx), %r8
leaq (%r8,%r15), %r14
movq %r13, 0x10(%rsp)
addq %r13, %r8
movq %rax, %r10
addq $0x8, %r10
movl $0x6, %r11d
movl $0x2, %ecx
movl $0x1, %esi
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), %r13
negq %r13
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,%r13), %rdx, %rdx
movq %rbp, %r13
subq %rbx, %r13
xorq (%r13), %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 0x75c7
movl $0x28, %esi
movq %rax, %rdi
vzeroupper
callq 0x5060
movq 0x8(%rsp), %rax
incq %rax
addq $0x28, %r15
movq 0x10(%rsp), %r13
addq $0x28, %r13
cmpq $0x5, %rax
movq (%rsp), %rbx
jne 0x7564
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rax
movq (%rbx), %rcx
xorl %esi, %esi
movabsq $-0x3333333333333333, %rdi # imm = 0xCCCCCCCCCCCCCCCD
movq $-0xc8, %r8
movq %rsi, %rdx
movq %rcx, %r9
mulxq %rdi, %r10, %r10
addq %r10, %r10
andq $-0x8, %r10
leaq (%r10,%r10,4), %r10
negq %r10
movq 0xc8(%rax,%r8), %r11
movq %r11, (%r9,%r10)
addq $0x18, %r9
addq $0x3, %rdx
addq $0x28, %r8
jne 0x76ba
incq %rsi
addq $0x8, %rax
addq $0x30, %rcx
cmpq $0x5, %rsi
jne 0x76ad
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x770e
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x5060
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8044
movl %ebx, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28(%rsp), %rdi
callq 0x5730
leaq 0x38(%rsp), %r14
leaq 0x320e(%rip), %rsi      # 0xb268
movl $0xc, %edx
movq %r14, %rdi
callq 0x5250
movl %ebx, %esi
movq %r14, %rdi
callq 0x56e0
leaq 0x31fd(%rip), %rsi      # 0xb275
movl $0x1d, %edx
movq %rax, %rdi
callq 0x5250
movl $0x20, %edi
callq 0x55b0
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 0x6ef4(%rip), %rsi      # 0xefc0
movq 0x6ee5(%rip), %rdx      # 0xefb8
movq %rbx, %rdi
callq 0x5270
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8101
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5060
jmp 0x8101
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x8113
movq %rbx, %rdi
callq 0x5380
jmp 0x8113
movq %rax, %r14
movq 0x6eb6(%rip), %rsi      # 0xefd0
leaq 0x28(%rsp), %rdi
callq 0x53b0
leaq 0xa8(%rsp), %rdi
callq 0x55c0
movq %r14, %rdi
callq 0x5680
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x81e6
leal -0x20(%r14), %ecx
shrl $0x3, %ecx
cmpl %ecx, %eax
ja 0x824e
addl $0x7, %r14d
shrl $0x3, %r14d
movq %r14, %rdi
callq 0x5610
movq %rax, %r15
movq 0x8(%rbx), %rdi
cmpq %rax, %rdi
je 0x81ac
testq %rdi, %rdi
je 0x81a8
movl $0x1, %esi
callq 0x5060
movq %r15, 0x8(%rbx)
movq 0x8(%rbx), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x5220
movl 0x14(%rbx), %eax
movl %eax, 0x18(%rbx)
vpbroadcastd %eax, %xmm0
vpaddd 0x3062(%rip), %xmm0, %xmm0 # 0xb230
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 0x55b0
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x308f(%rip), %rsi      # 0xb293
leaq 0x309d(%rip), %rdx      # 0xb2a8
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 0x6d83(%rip), %rsi      # 0xefc0
movq 0x6d74(%rip), %rdx      # 0xefb8
movq %r15, %rdi
callq 0x5270
jmp 0x82b4
movl $0x20, %edi
callq 0x55b0
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x303d(%rip), %rsi      # 0xb2a9
leaq 0x3051(%rip), %rdx      # 0xb2c4
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 0x6d1b(%rip), %rsi      # 0xefc0
movq 0x6d0c(%rip), %rdx      # 0xefb8
movq %r15, %rdi
callq 0x5270
jmp 0x82b8
jmp 0x82d3
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x82d9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5060
jmp 0x82d9
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x82eb
movq %r15, %rdi
callq 0x5380
jmp 0x82eb
movq %rax, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x82fe
movl $0x1, %esi
callq 0x5060
movq %r14, %rdi
callq 0x5680
// File: /workspace/github_c_makefile_star2_O1/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 0x842c
cmpl %ebp, 0x10(%rbx)
jbe 0x842c
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 0x5520
movq 0x8(%rbx), %rax
cmpb $0x0, 0x4(%rsp)
jne 0x840a
xorb -0x1(%rax,%r14), %r13b
movb %r13b, -0x1(%rax,%r14)
movq %r12, %rdi
callq 0x52e0
incl %ebp
testl %eax, %eax
js 0x842c
leaq 0x1(%r14), %rax
movl 0x10(%rbx), %ecx
cmpq %rcx, %r14
movq %rax, %r14
jb 0x83d8
movl %ebp, %edi
callq 0x5700
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_O1/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 0x8462
movl 0x10(%rbx), %ebp
movl %ebp, %edi
callq 0x5700
movq 0x8(%rbx), %rcx
movl 0x20(%rbx), %edx
xorb %al, (%rcx,%rdx)
movq %r14, %rdi
callq 0x52e0
testl %eax, %eax
js 0x84b8
cmpl 0x14(%rbx), %ebp
jae 0x84b8
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 0x84b8
leaq 0x1(%r15), %rax
movl 0x14(%rbx), %ecx
cmpq %rcx, %r15
movq %rax, %r15
jb 0x848a
movl %ebp, %edi
callq 0x5700
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_O1/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 0x84f5
testl %edx, %edx
je 0x84e9
movl %edx, %edi
callq 0x5700
jmp 0x84eb
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_O1/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 0x854d
testl %edx, %edx
je 0x8540
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r15d
xorl %r12d, %r12d
movq 0x8(%r14), %rax
movsbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0x5520
incq %r12
cmpq %r12, %r15
jne 0x8527
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x55b0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2d5b(%rip), %rsi      # 0xb2c5
leaq 0x2d72(%rip), %rdx      # 0xb2e3
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 0x6a1d(%rip), %rsi      # 0xefc0
movq 0x6a0e(%rip), %rdx      # 0xefb8
movq %rbx, %rdi
callq 0x5270
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x85d3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5060
jmp 0x85d3
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x85e0
movq %rbx, %rdi
callq 0x5380
movq %r14, %rdi
callq 0x5680
// File: /workspace/github_c_makefile_star2_O1/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 0x879e
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x877f
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 0x8751
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 0x55b0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2b3f(%rip), %rsi      # 0xb2fa
leaq 0x2b68(%rip), %rdx      # 0xb32a
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 0x67c9(%rip), %rsi      # 0xefc0
movq 0x67ba(%rip), %rdx      # 0xefb8
movq %rbx, %rdi
callq 0x5270
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x8828
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5060
jmp 0x8828
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x8835
movq %rbx, %rdi
callq 0x5380
movq %r14, %rdi
callq 0x5680
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x88fe
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x8891
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 0x5500
incq %r12
movl (%rbx), %eax
addq $0x28, %r15
cmpq %rax, %r12
jb 0x8869
cmpl $0x1, 0x10(%rbx)
je 0x88a3
movq %r14, %rdi
callq 0x52e0
testl %eax, %eax
js 0x88f7
movl (%rbx), %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 0x88e5
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 0x88e7
movl $0x20, %edi
callq 0x55b0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2a10(%rip), %rsi      # 0xb32b
leaq 0x2a51(%rip), %rdx      # 0xb373
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 0x6669(%rip), %rsi      # 0xefc0
movq 0x665a(%rip), %rdx      # 0xefb8
movq %rbx, %rdi
callq 0x5270
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x8988
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5060
jmp 0x8988
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x89b6
movq %rbx, %rdi
callq 0x5380
jmp 0x89b6
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x89b6
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x5060
jmp 0x89b6
movq %rax, %r14
movq %r14, %rdi
callq 0x5680
// File: /workspace/github_c_makefile_star2_O1/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 0x8a30
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x1, %esi
callq 0x5390
cmpl $0x0, (%r14)
je 0x8a19
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 0x5670
incq %r13
movl (%r14), %eax
addq $0x28, %r12
cmpq %rax, %r13
jb 0x89f1
movl $0x0, 0x10(%r14)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x55b0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2927(%rip), %rsi      # 0xb374
leaq 0x2959(%rip), %rdx      # 0xb3ad
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 0x6537(%rip), %rsi      # 0xefc0
movq 0x6528(%rip), %rdx      # 0xefb8
movq %rbx, %rdi
callq 0x5270
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x8aba
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5060
jmp 0x8aba
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x8ac7
movq %rbx, %rdi
callq 0x5380
movq %r14, %rdi
callq 0x5680
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x901d
movl %r9d, %r12d
movl %r8d, %ebp
movq %rcx, %r14
movl %edx, %r15d
movq %rdi, %rbx
addq $0x20, %rdi
movl $0x1, %edx
callq 0x55a0
testb %r12b, %r12b
je 0x8ff2
movq %rbx, %rdi
callq 0x5570
movzbl %r15b, %esi
movzbl %bpl, %ecx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5350
testb %al, %al
je 0x9010
movl $0x1, 0x60(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x55b0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x23bb(%rip), %rsi      # 0xb3f5
leaq 0x23ec(%rip), %rdx      # 0xb42d
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 0x5f4d(%rip), %rsi      # 0xefc0
movq 0x5f3e(%rip), %rdx      # 0xefb8
movq %rbx, %rdi
callq 0x5270
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x90a3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5060
jmp 0x90a3
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x90b0
movq %rbx, %rdi
callq 0x5380
movq %r14, %rdi
callq 0x5680
// File: /workspace/github_c_makefile_star2_O1/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 0x5730
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 0x9118
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 0x55a0
movq 0x5e94(%rip), %rsi      # 0xefd0
leaq 0x28(%rsp), %rdi
callq 0x53b0
leaq 0xa8(%rsp), %rdi
callq 0x55c0
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x917d
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x5060
jmp 0x917d
jmp 0x917a
movq %rax, %rbx
movq 0x5e4c(%rip), %rsi      # 0xefd0
leaq 0x28(%rsp), %rdi
callq 0x53b0
leaq 0xa8(%rsp), %rdi
callq 0x55c0
movq %rbx, %rdi
callq 0x5680
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xd812(%rip), %rdx      # 0x1b20b
leaq 0xd814(%rip), %rcx      # 0x1b214
leaq 0xd822(%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 0xd300
testl %eax, %eax
js 0xda74
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 0xda65
leaq 0xdb27(%rip), %rdi      # 0x1b585
callq 0xd0c0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %rbp
retq
callq 0xe395
leaq 0x26450(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
leaq 0xd7a9(%rip), %rdx      # 0x1b233
movq %rsp, %r9
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movl $0x1, %edi
callq 0xd3f0
// File: /workspace/github_c_makefile_star2_O1/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 0xdfd1
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
je 0xdfd1
callq 0xe395
leaq 0x25f0e(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
movq (%rbx), %r9
leaq 0xd4c5(%rip), %rdx      # 0x1b494
jmp 0xe032
movq 0x78(%rbx), %rax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0xe045
leaq 0x20(%rbx), %r14
movl 0xb8(%rbx), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq *%rax
movq %rax, 0xb0(%rbx)
testq %rax, %rax
je 0xe045
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %ecx
callq *0x38(%rbx)
movl %eax, %ebp
callq 0xe395
movq (%rbx), %r9
testl %ebp, %ebp
je 0xe052
leaq 0x25eac(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
movq %r14, (%rsp)
leaq 0xd4aa(%rip), %rdx      # 0x1b4dc
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x25e77(%rip), %r15     # 0x33ed0
movq 0x10(%r15), %r8
movq %r14, (%rsp)
leaq 0xd44a(%rip), %rdx      # 0x1b4b2
xorl %ebp, %ebp
movl $0x2, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0xe0ac
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
je 0xe0ac
callq 0xe395
movq (%r15), %r8
leaq 0xd468(%rip), %rdx      # 0x1b504
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
jmp 0xe040
movq %rbx, %rdi
movl $0x3, %esi
callq 0x1a35f
callq 0xe395
movq 0x18(%r15), %r8
leaq 0xd45b(%rip), %rdx      # 0x1b524
leaq 0xd466(%rip), %r9       # 0x1b536
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
jmp 0xe045
// File: /workspace/github_c_makefile_star2_O1/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 0xde67(%rip), %rsi      # 0x1c180
callq 0xd330
testq %rax, %rax
je 0xe364
movq %rax, %r14
movq %rsp, %rdi
movl $0x2000, %esi           # imm = 0x2000
movq %rax, %rdx
callq 0xd1f0
movq %rax, %rbx
movq %r14, %rdi
callq 0xd0f0
testq %rbx, %rbx
je 0xe357
movq %rsp, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0xd3a0
jmp 0xe359
xorl %eax, %eax
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r14
retq
callq 0xe395
leaq 0x25b60(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
leaq 0xd0f4(%rip), %rdx      # 0x1b46e
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
movq %rbx, %r9
xorl %eax, %eax
callq 0x19ca8
movl $0x1, %edi
callq 0xd3f0
// File: /workspace/github_c_makefile_star2_O1/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 0xd260
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0xd360
testq %rax, %rax
je 0xe3d6
movq %rax, %rdi
callq 0xd130
testq %rax, %rax
je 0xe3d4
movq %rax, %rbx
movq %rax, %rdi
callq 0xd110
movb $0x0, -0x1(%rbx,%rax)
jmp 0xe3d6
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xe433
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 0xe426
addl %esi, %ecx
incq %rax
cmpq $0x4, %rax
jne 0xe411
movslq %edi, %rax
movl -0x28(%rsp,%rax,4), %eax
retq