LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stanfordnlp[P]GloVe/src/common.c
// Function: log_file_loading_error
int log_file_loading_error(char *file_description, char *file_name) {
    fprintf(stderr, "Unable to open %s %s.\n", file_description, file_name);
    fprintf(stderr, "Errno: %d\n", errno);
    char error[MAX_STRING_LENGTH];
    STRERROR(errno, error, MAX_STRING_LENGTH);
    fprintf(stderr, "Error description: %s\n", error);
    return errno;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x3ebe(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x1e9c(%rip), %rsi      # 0x5fe8
movb $0x0, %al
callq 0x1140
movq 0x3e9e(%rip), %rax      # 0x7ff8
movq (%rax), %rax
movq %rax, -0x408(%rbp)
callq 0x1050
movq -0x408(%rbp), %rdi
movl (%rax), %edx
leaq 0x1e86(%rip), %rsi      # 0x5fff
movb $0x0, %al
callq 0x1140
callq 0x1050
movl (%rax), %edi
leaq -0x400(%rbp), %rsi
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x10b0
movq 0x3e59(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq -0x400(%rbp), %rdx
leaq 0x1e5a(%rip), %rsi      # 0x600a
movb $0x0, %al
callq 0x1140
callq 0x1050
movl (%rax), %eax
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/src/test_gauss_elimination.c
// Function: main
int
main(int argc VL_UNUSED, char**argv VL_UNUSED)
{
  double A [] = { 1, 12, 3, 4 };
  double b [] = { 1, -2 } ;
  double x [2] ;
  double c [2] ;
  int i ;

  vl_solve_linear_system_2 (x, A, b) ;

  c[0] = A[0] * x[0] + A[2] * x[1] ;
  c[1] = A[1] * x[0] + A[3] * x[1] ;

  for (i = 0 ; i < 2 ; ++i) {
    VL_PRINTF("[A x]_%-4d = %4g, b_%-4d = %4g\n", i+1, c[i], i+1, b[i]) ;
  }

  return 0 ;
}

// Assembly:
subq $0x78, %rsp
movl $0x0, 0x74(%rsp)
movl %edi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0xea4(%rip), %rax       # 0x2010
movq %rax, 0x40(%rsp)
movq 0xea0(%rip), %rax       # 0x2018
movq %rax, 0x48(%rsp)
movq 0xe9c(%rip), %rax       # 0x2020
movq %rax, 0x50(%rsp)
movq 0xe98(%rip), %rax       # 0x2028
movq %rax, 0x58(%rsp)
movq 0xe94(%rip), %rax       # 0x2030
movq %rax, 0x30(%rsp)
movq 0xe90(%rip), %rax       # 0x2038
movq %rax, 0x38(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x1040
movsd 0x40(%rsp), %xmm0
movsd 0x20(%rsp), %xmm2
movsd 0x50(%rsp), %xmm1
mulsd 0x28(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x48(%rsp), %xmm0
movsd 0x20(%rsp), %xmm2
movsd 0x58(%rsp), %xmm1
mulsd 0x28(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x2, 0xc(%rsp)
jge 0x1260
callq 0x1030
movq %rax, %rcx
movl 0xc(%rsp), %esi
addl $0x1, %esi
movslq 0xc(%rsp), %rax
movsd 0x10(%rsp,%rax,8), %xmm0
movl 0xc(%rsp), %edx
addl $0x1, %edx
movslq 0xc(%rsp), %rax
movsd 0x30(%rsp,%rax,8), %xmm1
leaq 0xdf1(%rip), %rdi       # 0x2040
movb $0x2, %al
callq *%rcx
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1215
xorl %eax, %eax
addq $0x78, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.cpp
// Function: KeccakF::KeccakF(unsigned int, int, unsigned int)
KeccakF::KeccakF(unsigned int aWidth, int aStartRoundIndex, unsigned int aNrRounds)
{
    width = aWidth;
    initializeNominalNumberOfRounds();
    laneSize = width/25;
    nrRounds = aNrRounds;
    startRoundIndex = aStartRoundIndex;
    mask = (LaneValue(~0)) >> (64-laneSize);
    initializeRhoOffsets();
    initializeRoundConstants();
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
movl %ecx, 0x34(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xeac0
movq 0x18(%rsp), %rdi
movq 0x11228(%rip), %rax     # 0x1ff98
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x20, %rdi
movq %rdi, 0x8(%rsp)
callq 0xe410
movq 0x18(%rsp), %rdi
addq $0x38, %rdi
movq %rdi, 0x10(%rsp)
callq 0xe7a0
movq 0x18(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl %eax, 0x8(%rdi)
callq 0xe5b0
jmp 0xedab
movq 0x18(%rsp), %rdi
movl 0x8(%rdi), %eax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
shrq $0x23, %rax
movl %eax, 0xc(%rdi)
movl 0x34(%rsp), %eax
movl %eax, 0x18(%rdi)
movl 0x38(%rsp), %eax
movl %eax, 0x14(%rdi)
movb 0xc(%rdi), %cl
movb %cl, %al
movl %eax, %ecx
movq $-0x1, %rax
bzhiq %rcx, %rax, %rax
movq %rax, 0x50(%rdi)
callq 0xd120
jmp 0xeded
movq 0x18(%rsp), %rdi
callq 0xe8d0
jmp 0xedf9
addq $0x48, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0xdfc0
movq 0x8(%rsp), %rdi
callq 0xdb00
movq 0x18(%rsp), %rdi
callq 0xe020
movq 0x28(%rsp), %rdi
callq 0xe7c0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.cpp
// Function: KeccakF::initializeNominalNumberOfRounds()
void KeccakF::initializeNominalNumberOfRounds()
{
    switch(width) {
    case 25:
        nominalNrRounds = 12;
        break;
    case 50:
        nominalNrRounds = 14;
        break;
    case 100:
        nominalNrRounds = 16;
        break;
    case 200:
        nominalNrRounds = 18;
        break;
    case 400:
        nominalNrRounds = 20;
        break;
    case 800:
        nominalNrRounds = 22;
        break;
    case 1600:
        nominalNrRounds = 24;
        break;
    default:
        throw(KeccakException("The width must be 25 times a power of two between 1 and 64."));
    }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x24(%rsp)
subl $0x19, %eax
je 0xeeab
jmp 0xee61
movl 0x24(%rsp), %eax
subl $0x32, %eax
je 0xeebc
jmp 0xee6c
movl 0x24(%rsp), %eax
subl $0x64, %eax
je 0xeecd
jmp 0xee77
movl 0x24(%rsp), %eax
subl $0xc8, %eax
je 0xeede
jmp 0xee84
movl 0x24(%rsp), %eax
subl $0x190, %eax            # imm = 0x190
je 0xeeef
jmp 0xee91
movl 0x24(%rsp), %eax
subl $0x320, %eax            # imm = 0x320
je 0xef00
jmp 0xee9e
movl 0x24(%rsp), %eax
subl $0x640, %eax            # imm = 0x640
je 0xef11
jmp 0xef22
movq 0x18(%rsp), %rax
movl $0xc, 0x10(%rax)
jmp 0xefd4
movq 0x18(%rsp), %rax
movl $0xe, 0x10(%rax)
jmp 0xefd4
movq 0x18(%rsp), %rax
movl $0x10, 0x10(%rax)
jmp 0xefd4
movq 0x18(%rsp), %rax
movl $0x12, 0x10(%rax)
jmp 0xefd4
movq 0x18(%rsp), %rax
movl $0x14, 0x10(%rax)
jmp 0xefd4
movq 0x18(%rsp), %rax
movl $0x16, 0x10(%rax)
jmp 0xefd4
movq 0x18(%rsp), %rax
movl $0x18, 0x10(%rax)
jmp 0xefd4
movb $0x1, 0x2b(%rsp)
movl $0x20, %edi
callq 0xe570
movq %rax, 0x8(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xdce0
movq 0x10(%rsp), %rdx
leaq 0xc0af(%rip), %rsi      # 0x1b000
leaq 0x40(%rsp), %rdi
callq 0xe740
jmp 0xef5d
movq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xde70
jmp 0xef6e
movq 0x8(%rsp), %rdi
movb $0x0, 0x2b(%rsp)
movq 0x11041(%rip), %rsi     # 0x1ffc0
movq 0x11032(%rip), %rdx     # 0x1ffb8
callq 0xd8c0
jmp 0xefe3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0xefb5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xe450
leaq 0x3f(%rsp), %rdi
callq 0xe050
testb $0x1, 0x2b(%rsp)
jne 0xefc8
jmp 0xefd2
movq 0x8(%rsp), %rdi
callq 0xdd30
jmp 0xefd9
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xe7c0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.cpp
// Function: KeccakF::initializeRhoOffsets()
void KeccakF::initializeRhoOffsets()
{
    rhoOffsets.resize(25);
    rhoOffsets[index(0, 0)] = 0;
    unsigned int x = 1;
    unsigned int y = 0;
    for(unsigned int t=0; t<24; t++) {
        rhoOffsets[index(x, y)] = ((t+1)*(t+2)/2) % laneSize;
        unsigned int newX = (0*x + 1*y)%5;
        unsigned int newY = (2*x + 3*y)%5;
        x = newX;
        y = newY;
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x20, %rdi
movl $0x19, %esi
callq 0xd9b0
movq 0x18(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x20(%rsp)
xorl %esi, %esi
movl %esi, %edi
callq 0xeb10
movq 0x20(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0xd620
movl $0x0, (%rax)
movl $0x1, 0x3c(%rsp)
movl $0x0, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
cmpl $0x18, 0x34(%rsp)
jae 0xf104
movq 0x18(%rsp), %rcx
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl 0x34(%rsp), %edx
addl $0x2, %edx
imull %edx, %eax
shrl %eax
xorl %edx, %edx
divl 0xc(%rcx)
movq 0x18(%rsp), %rax
movl %edx, 0x14(%rsp)
addq $0x20, %rax
movq %rax, 0x8(%rsp)
movl 0x3c(%rsp), %edi
movl 0x38(%rsp), %esi
callq 0xeb10
movq 0x8(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0xd620
movl 0x14(%rsp), %edx
movl %edx, (%rax)
imull $0x0, 0x3c(%rsp), %eax
movl 0x38(%rsp), %ecx
shll $0x0, %ecx
addl %ecx, %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, 0x30(%rsp)
movl 0x3c(%rsp), %eax
shll %eax
imull $0x3, 0x38(%rsp), %ecx
addl %ecx, %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, 0x2c(%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0x3c(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x38(%rsp)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0xf054
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.cpp
// Function: KeccakF::initializeRoundConstants()
void KeccakF::initializeRoundConstants()
{
    roundConstants.clear();
    UINT8 LFSRstate = 0x01;
    for(unsigned int i=0; i<255; i++) {
        LaneValue c = 0;
        for(unsigned int j=0; j<7; j++) {
            unsigned int bitPosition = (1<<j)-1; //2^j-1
            if (LFSR86540(LFSRstate))
                c ^= (LaneValue)1<<bitPosition;
        }
        roundConstants.push_back(c & mask);
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x38, %rdi
callq 0xd070
movb $0x1, 0x2f(%rsp)
movl $0x0, 0x28(%rsp)
cmpl $0xff, 0x28(%rsp)
jae 0xf1dc
movq $0x0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
cmpl $0x7, 0x1c(%rsp)
jae 0xf1a8
movl 0x1c(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
movl %eax, 0x18(%rsp)
leaq 0x2f(%rsp), %rdi
callq 0xdfe0
testb $0x1, %al
jne 0xf181
jmp 0xf199
movl 0x18(%rsp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
xorq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xf19b
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xf158
movq 0x8(%rsp), %rcx
movq %rcx, %rdi
addq $0x38, %rdi
movq 0x20(%rsp), %rax
andq 0x50(%rcx), %rax
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0xd910
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0xf139
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.cpp
// Function: KeccakF::KeccakF(unsigned int)
KeccakF::KeccakF(unsigned int aWidth)
{
    width = aWidth;
    initializeNominalNumberOfRounds();
    laneSize = width/25;
    nrRounds = nominalNrRounds;
    startRoundIndex = 0;
    mask = (LaneValue(~0)) >> (64-laneSize);
    initializeRhoOffsets();
    initializeRoundConstants();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xeac0
movq 0x10(%rsp), %rdi
movq 0x10d80(%rip), %rax     # 0x1ff98
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x20, %rdi
movq %rdi, (%rsp)
callq 0xe410
movq 0x10(%rsp), %rdi
addq $0x38, %rdi
movq %rdi, 0x8(%rsp)
callq 0xe7a0
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0x8(%rdi)
callq 0xe5b0
jmp 0xf252
movq 0x10(%rsp), %rdi
movl 0x8(%rdi), %eax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
shrq $0x23, %rax
movl %eax, 0xc(%rdi)
movl 0x10(%rdi), %eax
movl %eax, 0x18(%rdi)
movl $0x0, 0x14(%rdi)
movb 0xc(%rdi), %cl
movb %cl, %al
movl %eax, %ecx
movq $-0x1, %rax
bzhiq %rcx, %rax, %rax
movq %rax, 0x50(%rdi)
callq 0xd120
jmp 0xf293
movq 0x10(%rsp), %rdi
callq 0xe8d0
jmp 0xf29f
addq $0x38, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0xdfc0
movq (%rsp), %rdi
callq 0xdb00
movq 0x10(%rsp), %rdi
callq 0xe020
movq 0x20(%rsp), %rdi
callq 0xe7c0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.cpp
// Function: KeccakF::index(int, int)
unsigned int KeccakF::index(int x, int y)
{
    x %= 5;
    if (x<0) x += 5;
    y %= 5;
    if (y<0) y += 5;

    return(x + (5*y));
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movl -0x4(%rsp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
movl %edx, -0x4(%rsp)
cmpl $0x0, -0x4(%rsp)
jge 0xf35a
movl -0x4(%rsp), %eax
addl $0x5, %eax
movl %eax, -0x4(%rsp)
movl -0x8(%rsp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
movl %edx, -0x8(%rsp)
cmpl $0x0, -0x8(%rsp)
jge 0xf37c
movl -0x8(%rsp), %eax
addl $0x5, %eax
movl %eax, -0x8(%rsp)
movl -0x4(%rsp), %eax
imull $0x5, -0x8(%rsp), %ecx
addl %ecx, %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movl 0xc(%rax), %ecx
movl -0x14(%rsp), %eax
cltd
idivl %ecx
movl %edx, -0x14(%rsp)
cmpl $0x0, -0x14(%rsp)
jge 0xf49d
movq -0x20(%rsp), %rax
movl 0xc(%rax), %eax
addl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
cmpl $0x0, -0x14(%rsp)
je 0xf4f5
movq -0x20(%rsp), %rax
movq 0x50(%rax), %rcx
movq -0x10(%rsp), %rax
andq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movl -0x14(%rsp), %ecx
shlq %cl, %rax
movq -0x20(%rsp), %rcx
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movl 0xc(%rcx), %ecx
subl -0x14(%rsp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
movq -0x28(%rsp), %rcx
xorq %rax, %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
movq -0x20(%rsp), %rax
movq 0x50(%rax), %rcx
movq -0x10(%rsp), %rax
andq (%rax), %rcx
movq %rcx, (%rax)
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movl $0x19, %esi
callq 0xd950
movq 0x18(%rsp), %rax
cmpl $0x1, 0xc(%rax)
je 0xf568
movq 0x18(%rsp), %rax
cmpl $0x2, 0xc(%rax)
je 0xf568
movq 0x18(%rsp), %rax
cmpl $0x4, 0xc(%rax)
je 0xf568
movq 0x18(%rsp), %rax
cmpl $0x8, 0xc(%rax)
jne 0xf5d9
movl $0x0, 0x2c(%rsp)
cmpl $0x19, 0x2c(%rsp)
jae 0xf5d4
movq 0x18(%rsp), %rdx
movq 0x38(%rsp), %rax
movl 0x2c(%rsp), %ecx
imull 0xc(%rdx), %ecx
shrl $0x3, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movl 0x2c(%rsp), %ecx
imull 0xc(%rdx), %ecx
andl $0x7, %ecx
sarl %cl, %eax
movq 0x18(%rsp), %rcx
cltq
andq 0x50(%rcx), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0xdde0
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xf570
jmp 0xf6b1
movq 0x18(%rsp), %rax
cmpl $0x10, 0xc(%rax)
je 0xf5fe
movq 0x18(%rsp), %rax
cmpl $0x20, 0xc(%rax)
je 0xf5fe
movq 0x18(%rsp), %rax
cmpl $0x40, 0xc(%rax)
jne 0xf6af
movl $0x0, 0x28(%rsp)
cmpl $0x19, 0x28(%rsp)
jae 0xf6ad
movq 0x30(%rsp), %rdi
movl 0x28(%rsp), %eax
movl %eax, %esi
callq 0xdde0
movq $0x0, (%rax)
movl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rcx
movl 0x24(%rsp), %eax
movl 0xc(%rcx), %ecx
shrl $0x3, %ecx
cmpl %ecx, %eax
jae 0xf69b
movq 0x18(%rsp), %rdx
movq 0x38(%rsp), %rax
movl 0x28(%rsp), %ecx
imull 0xc(%rdx), %ecx
shrl $0x3, %ecx
addl 0x24(%rsp), %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movl 0x24(%rsp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movl 0x28(%rsp), %eax
movl %eax, %esi
callq 0xdde0
movq 0x8(%rsp), %rcx
orq (%rax), %rcx
movq %rcx, (%rax)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xf630
jmp 0xf69d
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0xf606
jmp 0xf6af
jmp 0xf6b1
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x1, 0xc(%rax)
je 0xf708
movq 0x8(%rsp), %rax
cmpl $0x2, 0xc(%rax)
je 0xf708
movq 0x8(%rsp), %rax
cmpl $0x4, 0xc(%rax)
je 0xf708
movq 0x8(%rsp), %rax
cmpl $0x8, 0xc(%rax)
jne 0xf7a8
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rcx
movl 0x1c(%rsp), %eax
imull $0x19, 0xc(%rcx), %ecx
addl $0x7, %ecx
shrl $0x3, %ecx
cmpl %ecx, %eax
jae 0xf741
movq 0x20(%rsp), %rax
movl 0x1c(%rsp), %ecx
movb $0x0, (%rax,%rcx)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xf710
movl $0x0, 0x18(%rsp)
cmpl $0x19, 0x18(%rsp)
jae 0xf7a3
movq 0x28(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0xd9e0
movq 0x8(%rsp), %rdx
movq (%rax), %rsi
movl 0x18(%rsp), %eax
imull 0xc(%rdx), %eax
andl $0x7, %eax
movl %eax, %eax
movl %eax, %ecx
shlq %cl, %rsi
movq 0x20(%rsp), %rax
movl 0x18(%rsp), %ecx
imull 0xc(%rdx), %ecx
shrl $0x3, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %edx
orq %rsi, %rdx
movb %dl, (%rax,%rcx)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xf749
jmp 0xf865
movq 0x8(%rsp), %rax
cmpl $0x10, 0xc(%rax)
je 0xf7cd
movq 0x8(%rsp), %rax
cmpl $0x20, 0xc(%rax)
je 0xf7cd
movq 0x8(%rsp), %rax
cmpl $0x40, 0xc(%rax)
jne 0xf863
movl $0x0, 0x14(%rsp)
cmpl $0x19, 0x14(%rsp)
jae 0xf861
movl $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movl 0x10(%rsp), %eax
movl 0xc(%rcx), %ecx
shrl $0x3, %ecx
cmpl %ecx, %eax
jae 0xf84f
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0xd9e0
movq 0x8(%rsp), %rsi
movq (%rax), %rax
movl 0x10(%rsp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rax
andq $0xff, %rax
movb %al, %dl
movq 0x20(%rsp), %rax
movl 0x14(%rsp), %ecx
movl 0xc(%rsi), %esi
shrl $0x3, %esi
imull %esi, %ecx
addl 0x10(%rsp), %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0xf7e8
jmp 0xf851
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xf7d5
jmp 0xf863
jmp 0xf865
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xd050
movq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rdi
movl $0x19, %esi
callq 0xd1c0
jmp 0xf8ad
leaq 0x2f(%rsp), %rdi
callq 0xde10
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0xe180
jmp 0xf8cd
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xd450
jmp 0xf8de
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rdx
leaq 0x30(%rsp), %rsi
callq 0xe350
leaq 0x30(%rsp), %rdi
callq 0xdfc0
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x2f(%rsp), %rdi
callq 0xde10
jmp 0xf933
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xdfc0
movq 0x20(%rsp), %rdi
callq 0xe7c0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.cpp
// Function: KeccakF::inverse(unsigned char*) const
void KeccakF::inverse(UINT8 * state) const
{
    vector<LaneValue> A(25);
    fromBytesToLanes(state, A);
    inverse(A);
    fromLanesToBytes(A, state);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xd050
movq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rdi
movl $0x19, %esi
callq 0xd1c0
jmp 0xf97d
leaq 0x2f(%rsp), %rdi
callq 0xde10
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0xe180
jmp 0xf99d
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xdd20
jmp 0xf9ae
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rdx
leaq 0x30(%rsp), %rsi
callq 0xe350
leaq 0x30(%rsp), %rdi
callq 0xdfc0
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x2f(%rsp), %rdi
callq 0xde10
jmp 0xfa03
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xdfc0
movq 0x20(%rsp), %rdi
callq 0xe7c0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq 0x1d8(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xea00
leaq 0x60(%rsp), %rdi
leaq 0xb327(%rip), %rsi      # 0x1b05e
callq 0xd420
movq %rax, 0x38(%rsp)
jmp 0xfd43
movq 0x38(%rsp), %rdi
movq 0x10279(%rip), %rsi     # 0x1ffc8
callq 0xdf50
movq %rax, 0x18(%rsp)
jmp 0xfd5b
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rax
movl 0x8(%rax), %esi
callq 0xe2b0
movq %rax, 0x10(%rsp)
jmp 0xfd74
movq 0x10(%rsp), %rdi
leaq 0xb2e5(%rip), %rsi      # 0x1b065
callq 0xd420
movq %rax, 0x8(%rsp)
jmp 0xfd8c
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rax
movl 0x18(%rax), %esi
callq 0xe2b0
jmp 0xfda0
movq 0x30(%rsp), %rax
cmpl $0x0, 0x14(%rax)
je 0xfdf1
leaq 0x60(%rsp), %rdi
leaq 0xb2ae(%rip), %rsi      # 0x1b065
callq 0xd420
movq %rax, (%rsp)
jmp 0xfdc2
movq (%rsp), %rdi
movq 0x30(%rsp), %rax
movl 0x14(%rax), %esi
callq 0xe680
jmp 0xfdd5
jmp 0xfdf1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xea90
jmp 0xfe19
movq 0x20(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xe1f0
jmp 0xfe02
leaq 0x50(%rsp), %rdi
callq 0xea90
movq 0x28(%rsp), %rax
addq $0x1e8, %rsp            # imm = 0x1E8
retq
movq 0x48(%rsp), %rdi
callq 0xe7c0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movzbl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x9(%rsp)
movq -0x8(%rsp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xff96
movq -0x8(%rsp), %rax
movzbl (%rax), %eax
shll %eax
xorl $0x71, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, (%rax)
jmp 0xffa2
movq -0x8(%rsp), %rax
movzbl (%rax), %ecx
shll %ecx
movb %cl, (%rax)
movb -0x9(%rsp), %al
andb $0x1, %al
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x1c0(%rsp)
movq %rsi, 0x1b8(%rsp)
movl %edx, 0x1b4(%rsp)
movl %ecx, 0x1b0(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xea00
leaq 0x38(%rsp), %rdi
movq 0x1b8(%rsp), %rsi
callq 0xe790
jmp 0x10000
cmpl $0x1, 0x1b4(%rsp)
jbe 0x100a5
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x28(%rsp,%rax), %rdi
movl $0x30, %esi
callq 0xd830
jmp 0x10028
cmpl $0xa, 0x1b4(%rsp)
ja 0x10068
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x28(%rsp,%rax), %rdi
movl $0x1, %esi
callq 0xdda0
jmp 0x1004c
jmp 0x10090
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xea90
jmp 0x100cd
cmpl $0x64, 0x1b4(%rsp)
ja 0x1008e
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x28(%rsp,%rax), %rdi
movl $0x2, %esi
callq 0xdda0
jmp 0x1008c
jmp 0x1008e
jmp 0x10090
leaq 0x38(%rsp), %rdi
movl 0x1b0(%rsp), %esi
callq 0xe2b0
jmp 0x100a3
jmp 0x100a5
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xe1f0
jmp 0x100b6
leaq 0x28(%rsp), %rdi
callq 0xea90
movq 0x10(%rsp), %rax
addq $0x1c8, %rsp            # imm = 0x1C8
retq
movq 0x20(%rsp), %rdi
callq 0xe7c0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0xd270
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xd6b0
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xe8a0
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xdb10
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
callq 0xe5a0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0xdfd0
movl $0x0, 0x1c(%rsp)
cmpl $0x5, 0x1c(%rsp)
jae 0x12683
movl $0x0, 0x18(%rsp)
cmpl $0x5, 0x18(%rsp)
jae 0x12671
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
leaq 0x14(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq 0xe5e0
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
callq 0xeb10
movl %eax, %eax
movl %eax, %esi
leaq 0x20(%rsp), %rdi
callq 0xdde0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
callq 0xeb10
movq (%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0xdde0
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x125f8
jmp 0x12673
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x125e5
leaq 0x20(%rsp), %rdi
callq 0xdfc0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0xd050
movq 0x48(%rsp), %rdx
leaq 0x70(%rsp), %rdi
movl $0x5, %esi
callq 0xd1c0
jmp 0x126dc
leaq 0x6f(%rsp), %rdi
callq 0xde10
movl $0x0, 0x58(%rsp)
cmpl $0x5, 0x58(%rsp)
jae 0x12878
movl $0x0, 0x54(%rsp)
cmpl $0x5, 0x54(%rsp)
jae 0x127fb
movq 0x88(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x54(%rsp), %edi
movl 0x58(%rsp), %esi
callq 0xeb10
movq 0x18(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0xdde0
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x54(%rsp), %edi
addl $0x1, %edi
movl 0x58(%rsp), %esi
callq 0xeb10
movq 0x20(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0xdde0
movq (%rax), %rax
xorq $-0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x54(%rsp), %edi
addl $0x2, %edi
movl 0x58(%rsp), %esi
callq 0xeb10
movq 0x28(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0xdde0
movq 0x30(%rsp), %rcx
movq %rax, %rdx
movq 0x38(%rsp), %rax
andq (%rdx), %rcx
xorq %rcx, %rax
movq %rax, 0x40(%rsp)
movl 0x54(%rsp), %eax
movl %eax, %esi
leaq 0x70(%rsp), %rdi
callq 0xdde0
movq 0x40(%rsp), %rcx
movq %rcx, (%rax)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x12701
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x6f(%rsp), %rdi
callq 0xde10
jmp 0x1288a
movl $0x0, 0x50(%rsp)
cmpl $0x5, 0x50(%rsp)
jae 0x12866
movl 0x50(%rsp), %edi
callq 0xe140
movl %eax, %eax
movl %eax, %esi
leaq 0x70(%rsp), %rdi
callq 0xdde0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x50(%rsp), %edi
movl 0x58(%rsp), %esi
callq 0xeb10
movq 0x8(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0xdde0
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x12803
jmp 0x12868
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x126ee
leaq 0x70(%rsp), %rdi
callq 0xdfc0
addq $0x98, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0xe7c0
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
callq 0xe5a0
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xd1e0
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xe520
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xdaf0
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xd570
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movl $0x0, 0x84(%rsp)
cmpl $0x5, 0x84(%rsp)
jae 0x1309c
movl $0x5, 0x80(%rsp)
movl 0x80(%rsp), %eax
movq %rax, 0x38(%rsp)
leaq 0x67(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0xd050
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
leaq 0x68(%rsp), %rdi
callq 0xd1c0
jmp 0x12edc
leaq 0x67(%rsp), %rdi
callq 0xde10
movl $0x0, 0x50(%rsp)
movl 0x50(%rsp), %eax
cmpl 0x80(%rsp), %eax
jae 0x12f77
movq 0x88(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x50(%rsp), %edi
movl 0x84(%rsp), %esi
callq 0xeb10
movq 0x28(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0xdde0
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movl 0x50(%rsp), %edi
callq 0xe140
movl %eax, %eax
movl %eax, %esi
leaq 0x68(%rsp), %rdi
callq 0xdde0
movq 0x30(%rsp), %rcx
movq %rcx, (%rax)
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x12eee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x67(%rsp), %rdi
callq 0xde10
jmp 0x130a4
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl 0x80(%rsp), %ecx
subl $0x1, %ecx
imull $0x3, %ecx, %ecx
shrl %ecx
cmpl %ecx, %eax
jae 0x1307c
movl 0x80(%rsp), %eax
subl $0x2, %eax
imull 0x4c(%rsp), %eax
movl %eax, 0x48(%rsp)
movl 0x48(%rsp), %edi
callq 0xe140
movl %eax, %eax
movl %eax, %esi
leaq 0x68(%rsp), %rdi
callq 0xdde0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x88(%rsp), %rax
movq %rax, (%rsp)
movl 0x48(%rsp), %edi
addl $0x2, %edi
movl 0x84(%rsp), %esi
callq 0xeb10
movq (%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0xdde0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x48(%rsp), %edi
addl $0x1, %edi
callq 0xe140
movl %eax, %eax
movl %eax, %esi
leaq 0x68(%rsp), %rdi
callq 0xdde0
movq 0x8(%rsp), %rcx
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq (%rdx), %rdx
xorq $-0x1, %rdx
andq %rdx, %rcx
xorq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x48(%rsp), %edi
movl 0x84(%rsp), %esi
callq 0xeb10
movq 0x18(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0xdde0
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x12f7f
leaq 0x68(%rsp), %rdi
callq 0xdfc0
movl 0x84(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x84(%rsp)
jmp 0x12e92
addq $0x98, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0xe7c0
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0xdfd0
movl $0x0, 0x1c(%rsp)
cmpl $0x5, 0x1c(%rsp)
jae 0x13173
movl $0x0, 0x18(%rsp)
cmpl $0x5, 0x18(%rsp)
jae 0x13161
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
leaq 0x14(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq 0xeaa0
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
callq 0xeb10
movl %eax, %eax
movl %eax, %esi
leaq 0x20(%rsp), %rdi
callq 0xdde0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
callq 0xeb10
movq (%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0xdde0
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x130e8
jmp 0x13163
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x130d5
leaq 0x20(%rsp), %rdi
callq 0xdfc0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keyakv2.cpp
// Function: keypack(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int)
string keypack(const string& K, unsigned int l)
{
    if (K.size() + 2 > l)
        throw Exception("The key is too big and does not fit in the key pack.");
    string result = char(enc8(l)) + K + char(1);
    while(result.size() < l)
        result += char(0);
    return result;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movl %edx, 0x84(%rsp)
movq 0x88(%rsp), %rdi
callq 0xdbb0
addq $0x2, %rax
movl 0x84(%rsp), %ecx
cmpq %rcx, %rax
jbe 0x147b4
movb $0x1, 0x4b(%rsp)
movl $0x20, %edi
callq 0xe570
movq %rax, 0x8(%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xdce0
movq 0x10(%rsp), %rdx
leaq 0x6a4f(%rip), %rsi      # 0x1b17a
leaq 0x60(%rsp), %rdi
callq 0xe740
jmp 0x14737
movq 0x8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xde70
jmp 0x14748
movq 0x8(%rsp), %rdi
movb $0x0, 0x4b(%rsp)
movq 0xb867(%rip), %rsi      # 0x1ffc0
movq 0xb858(%rip), %rdx      # 0x1ffb8
callq 0xd8c0
jmp 0x14884
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x14792
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xe450
leaq 0x5f(%rsp), %rdi
callq 0xe050
testb $0x1, 0x4b(%rsp)
jne 0x147a5
jmp 0x147af
movq 0x8(%rsp), %rdi
callq 0xdd30
jmp 0x1487a
movb $0x0, 0x4a(%rsp)
movl 0x84(%rsp), %edi
callq 0xe9c0
movq 0x88(%rsp), %rdx
movsbl %al, %esi
leaq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xe0f0
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
movl $0x1, %edx
callq 0xd880
jmp 0x147f3
leaq 0x28(%rsp), %rdi
callq 0xe450
movq 0x18(%rsp), %rdi
callq 0xdbb0
movl 0x84(%rsp), %ecx
cmpq %rcx, %rax
jae 0x14857
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0xd370
jmp 0x14821
jmp 0x147fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xe450
jmp 0x1487a
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0xe450
jmp 0x1487a
movb $0x1, 0x4a(%rsp)
testb $0x1, 0x4a(%rsp)
jne 0x1486d
movq 0x18(%rsp), %rdi
callq 0xe450
movq 0x20(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0xe7c0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x1e8, %rsp            # imm = 0x1E8
movl %edi, 0x1e4(%rsp)
cmpl $0xff, 0x1e4(%rsp)
jbe 0x14e7a
leaq 0x58(%rsp), %rdi
callq 0xea00
leaq 0x68(%rsp), %rdi
leaq 0x641a(%rip), %rsi      # 0x1b1af
callq 0xd420
movq %rax, 0x18(%rsp)
jmp 0x14da1
movq 0x18(%rsp), %rdi
movl 0x1e4(%rsp), %esi
callq 0xe2b0
movq %rax, 0x10(%rsp)
jmp 0x14db9
movq 0x10(%rsp), %rdi
leaq 0x63f7(%rip), %rsi      # 0x1b1bc
callq 0xd420
jmp 0x14dcc
movb $0x1, 0x27(%rsp)
movl $0x20, %edi
callq 0xe570
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xe1f0
jmp 0x14df1
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xde70
jmp 0x14e02
movq 0x8(%rsp), %rdi
movb $0x0, 0x27(%rsp)
movq 0xb1ad(%rip), %rsi      # 0x1ffc0
movq 0xb19e(%rip), %rdx      # 0x1ffb8
callq 0xd8c0
jmp 0x14e93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x14e6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x14e59
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xe450
testb $0x1, 0x27(%rsp)
jne 0x14e62
jmp 0x14e6c
movq 0x8(%rsp), %rdi
callq 0xdd30
jmp 0x14e6e
leaq 0x58(%rsp), %rdi
callq 0xea90
jmp 0x14e89
movl 0x1e4(%rsp), %eax
addq $0x1e8, %rsp            # imm = 0x1E8
retq
movq 0x50(%rsp), %rdi
callq 0xe7c0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movb %r8b, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
andb $0x1, %al
movb %al, 0x2b(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
callq 0xd250
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x1f(%rsp)
jne 0x15313
jmp 0x15326
movq 0x20(%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0x10(%rcx), %eax
setb %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x15333
jmp 0x153d7
movq 0x38(%rsp), %rdi
callq 0xdca0
movq 0x20(%rsp), %rdi
movb %al, 0x2a(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x8, %rdi
callq 0xd1d0
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movzbl 0x2a(%rsp), %ecx
xorl %ecx, %eax
movsbl %al, %esi
callq 0xe310
testb $0x1, 0x2b(%rsp)
je 0x1539f
movq 0x20(%rsp), %rdi
movb 0x2a(%rsp), %al
movb %al, 0xf(%rsp)
addq $0x8, %rdi
callq 0xd1d0
movb 0xf(%rsp), %dl
movl 0x2c(%rsp), %ecx
movb %dl, (%rax,%rcx)
jmp 0x153c7
movq 0x20(%rsp), %rdi
movzbl 0x2a(%rsp), %eax
movl %eax, 0x8(%rsp)
addq $0x8, %rdi
callq 0xd1d0
movl 0x8(%rsp), %esi
movl 0x2c(%rsp), %ecx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x152fa
movl 0x2c(%rsp), %edi
callq 0xe9c0
movq 0x20(%rsp), %rdi
movzbl %al, %eax
movl %eax, 0x4(%rsp)
addq $0x8, %rdi
callq 0xd1d0
movq 0x20(%rsp), %rcx
movl 0x4(%rsp), %esi
movl 0x1c(%rcx), %ecx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0x27(%rsp)
je 0x15445
movq 0x18(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x20(%rsp)
jmp 0x1544d
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %edi
callq 0xe9c0
movq 0x18(%rsp), %rdi
movzbl %al, %eax
movl %eax, 0x14(%rsp)
addq $0x8, %rdi
callq 0xd1d0
movq 0x18(%rsp), %rcx
movl 0x14(%rsp), %esi
movl 0x20(%rcx), %ecx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movq 0x28(%rsp), %rdi
callq 0xd250
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x13(%rsp)
jne 0x15499
jmp 0x154ac
movq 0x18(%rsp), %rcx
movl 0x20(%rsp), %eax
cmpl 0x14(%rcx), %eax
setb %al
movb %al, 0x13(%rsp)
movb 0x13(%rsp), %al
testb $0x1, %al
jne 0x154b6
jmp 0x154f0
movq 0x28(%rsp), %rdi
callq 0xdca0
movq 0x18(%rsp), %rdi
movl %eax, 0xc(%rsp)
addq $0x8, %rdi
callq 0xd1d0
movl 0xc(%rsp), %esi
movl 0x20(%rsp), %ecx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x15480
movl 0x20(%rsp), %edi
callq 0xe9c0
movq 0x18(%rsp), %rdi
movzbl %al, %eax
movl %eax, 0x8(%rsp)
addq $0x8, %rdi
callq 0xd1d0
movq 0x18(%rsp), %rcx
movl 0x8(%rsp), %esi
movl 0x24(%rcx), %ecx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movl %edx, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
testb $0x1, 0x2f(%rsp)
je 0x155c9
cmpl $0x0, 0x28(%rsp)
jne 0x15594
movl $0xff, %edi
callq 0xe9c0
movq 0x20(%rsp), %rdi
movzbl %al, %eax
movl %eax, 0x1c(%rsp)
addq $0x8, %rdi
callq 0xd1d0
movq 0x20(%rsp), %rcx
movl 0x1c(%rsp), %esi
movl 0x18(%rcx), %ecx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
jmp 0x155c7
movl 0x28(%rsp), %edi
callq 0xe9c0
movq 0x20(%rsp), %rdi
movzbl %al, %eax
movl %eax, 0x18(%rsp)
addq $0x8, %rdi
callq 0xd1d0
movq 0x20(%rsp), %rcx
movl 0x18(%rsp), %esi
movl 0x18(%rcx), %ecx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
jmp 0x155fa
xorl %edi, %edi
callq 0xe9c0
movq 0x20(%rsp), %rdi
movzbl %al, %eax
movl %eax, 0x14(%rsp)
addq $0x8, %rdi
callq 0xd1d0
movq 0x20(%rsp), %rcx
movl 0x14(%rsp), %esi
movl 0x18(%rcx), %ecx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
callq 0xd1d0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
movq 0x70(%rsp), %rcx
movq %rcx, 0x18(%rsp)
movl 0x64(%rsp), %eax
cmpl 0x10(%rcx), %eax
jbe 0x1570e
movb $0x1, 0x2b(%rsp)
movl $0x20, %edi
callq 0xe570
movq %rax, 0x8(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xdce0
movq 0x10(%rsp), %rdx
leaq 0x5b84(%rip), %rsi      # 0x1b20c
leaq 0x40(%rsp), %rdi
callq 0xe740
jmp 0x15694
movq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xde70
jmp 0x156a5
movq 0x8(%rsp), %rdi
movb $0x0, 0x2b(%rsp)
movq 0xa90a(%rip), %rsi      # 0x1ffc0
movq 0xa8fb(%rip), %rdx      # 0x1ffb8
callq 0xd8c0
jmp 0x15764
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x156ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xe450
leaq 0x3f(%rsp), %rdi
callq 0xe050
testb $0x1, 0x2b(%rsp)
jne 0x15702
jmp 0x1570c
movq 0x8(%rsp), %rdi
callq 0xdd30
jmp 0x1575a
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x64(%rsp), %eax
jae 0x15755
movq 0x18(%rsp), %rdi
movq 0x68(%rsp), %rax
movq %rax, (%rsp)
addq $0x8, %rdi
callq 0xd1d0
movq (%rsp), %rdi
movl 0x24(%rsp), %ecx
movsbl (%rax,%rcx), %esi
callq 0xe310
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x15716
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xe7c0
nopw %cs:(%rax,%rax)