#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ __m256i;

/* Variables and functions */
int /*<<< orphan*/ _MM_SHUFFLE(int, int, int, int);
int /*<<< orphan*/ _mm256_and_si256(int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ _mm256_loadu_si256(int /*<<< orphan*/ *);
int /*<<< orphan*/ _mm256_or_si256(int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ _mm256_permute4x64_epi64(int /*<<< orphan*/,
                                            int /*<<< orphan*/);
int /*<<< orphan*/ _mm256_slli_epi64(int /*<<< orphan*/, int);
int /*<<< orphan*/ _mm256_srli_epi64(int /*<<< orphan*/, int);
int /*<<< orphan*/ _mm256_storeu_si256(int /*<<< orphan*/ *,
                                       int /*<<< orphan*/);
int /*<<< orphan*/ _mm256_xor_si256(int /*<<< orphan*/, int /*<<< orphan*/);
void morus_dec_aut_step(unsigned char *plaintext,
                        const unsigned char *ciphertext, __m256i *state) {
  __m256i keystream;
  __m256i msgblk = _mm256_loadu_si256((__m256i *)ciphertext);
  keystream = _mm256_xor_si256(
      (state[0]),
      (_mm256_permute4x64_epi64((state[1]), _MM_SHUFFLE(0, 3, 2, 1))));
  keystream =
      _mm256_xor_si256((keystream), (_mm256_and_si256((state[2]), (state[3]))));
  msgblk = _mm256_xor_si256((keystream), (msgblk));
  _mm256_storeu_si256((__m256i *)plaintext, msgblk);
  state[0] = _mm256_xor_si256((state[0]), (state[3]));
  state[0] =
      _mm256_xor_si256((state[0]), (_mm256_and_si256((state[1]), (state[2]))));
  state[0] = _mm256_or_si256((_mm256_slli_epi64((state[0]), (13))),
                             (_mm256_srli_epi64((state[0]), (64 - 13))));
  state[3] = _mm256_permute4x64_epi64((state[3]), _MM_SHUFFLE(2, 1, 0, 3));
  state[1] = _mm256_xor_si256((state[1]), (msgblk));
  state[1] = _mm256_xor_si256((state[1]), (state[4]));
  state[1] =
      _mm256_xor_si256((state[1]), (_mm256_and_si256((state[2]), (state[3]))));
  state[1] = _mm256_or_si256((_mm256_slli_epi64((state[1]), (46))),
                             (_mm256_srli_epi64((state[1]), (64 - 46))));
  state[4] = _mm256_permute4x64_epi64((state[4]), _MM_SHUFFLE(1, 0, 3, 2));
  state[2] = _mm256_xor_si256((state[2]), (msgblk));
  state[2] = _mm256_xor_si256((state[2]), (state[0]));
  state[2] =
      _mm256_xor_si256((state[2]), (_mm256_and_si256((state[3]), (state[4]))));
  state[2] = _mm256_or_si256((_mm256_slli_epi64((state[2]), (38))),
                             (_mm256_srli_epi64((state[2]), (64 - 38))));
  state[0] = _mm256_permute4x64_epi64((state[0]), _MM_SHUFFLE(0, 3, 2, 1));
  state[3] = _mm256_xor_si256((state[3]), (msgblk));
  state[3] = _mm256_xor_si256((state[3]), (state[1]));
  state[3] =
      _mm256_xor_si256((state[3]), (_mm256_and_si256((state[4]), (state[0]))));
  state[3] = _mm256_or_si256((_mm256_slli_epi64((state[3]), (7))),
                             (_mm256_srli_epi64((state[3]), (64 - 7))));
  state[1] = _mm256_permute4x64_epi64((state[1]), _MM_SHUFFLE(1, 0, 3, 2));
  state[4] = _mm256_xor_si256((state[4]), (msgblk));
  state[4] = _mm256_xor_si256((state[4]), (state[2]));
  state[4] =
      _mm256_xor_si256((state[4]), (_mm256_and_si256((state[0]), (state[1]))));
  state[4] = _mm256_or_si256((_mm256_slli_epi64((state[4]), (4))),
                             (_mm256_srli_epi64((state[4]), (64 - 4))));
  state[2] = _mm256_permute4x64_epi64((state[2]), _MM_SHUFFLE(2, 1, 0, 3));
}


x86 assembly (clang, -O0):
<morus_dec_aut_step>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x10(%rbp),%rdi
call   10b0 <_mm256_loadu_si256@plt>
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x64(%rbp)
mov    -0x18(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x68(%rbp)
xor    %edi,%edi
mov    $0x3,%esi
mov    $0x2,%edx
mov    $0x1,%ecx
call   1030 <_MM_SHUFFLE@plt>
mov    -0x68(%rbp),%edi
mov    %eax,%esi
call   1090 <_mm256_permute4x64_epi64@plt>
mov    -0x64(%rbp),%edi
mov    %eax,%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%edi
mov    -0x18(%rbp),%rax
mov    0xc(%rax),%esi
call   1060 <_mm256_and_si256@plt>
mov    -0x60(%rbp),%edi
mov    %eax,%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%edi
mov    -0x20(%rbp),%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x20(%rbp),%esi
call   1050 <_mm256_storeu_si256@plt>
mov    -0x18(%rbp),%rax
mov    (%rax),%edi
mov    -0x18(%rbp),%rax
mov    0xc(%rax),%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
mov    0x4(%rax),%edi
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%esi
call   1060 <_mm256_and_si256@plt>
mov    -0x5c(%rbp),%edi
mov    %eax,%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%edi
mov    $0xd,%esi
call   1040 <_mm256_slli_epi64@plt>
mov    %eax,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%edi
mov    $0x33,%esi
call   1080 <_mm256_srli_epi64@plt>
mov    -0x58(%rbp),%edi
mov    %eax,%esi
call   10a0 <_mm256_or_si256@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x18(%rbp),%rax
mov    0xc(%rax),%eax
mov    %eax,-0x54(%rbp)
mov    $0x2,%edi
mov    $0x1,%esi
xor    %edx,%edx
mov    $0x3,%ecx
call   1030 <_MM_SHUFFLE@plt>
mov    -0x54(%rbp),%edi
mov    %eax,%esi
call   1090 <_mm256_permute4x64_epi64@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0x18(%rbp),%rax
mov    0x4(%rax),%edi
mov    -0x20(%rbp),%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x18(%rbp),%rax
mov    0x4(%rax),%edi
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x18(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x50(%rbp)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%edi
mov    -0x18(%rbp),%rax
mov    0xc(%rax),%esi
call   1060 <_mm256_and_si256@plt>
mov    -0x50(%rbp),%edi
mov    %eax,%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x18(%rbp),%rax
mov    0x4(%rax),%edi
mov    $0x2e,%esi
call   1040 <_mm256_slli_epi64@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x18(%rbp),%rax
mov    0x4(%rax),%edi
mov    $0x12,%esi
call   1080 <_mm256_srli_epi64@plt>
mov    -0x4c(%rbp),%edi
mov    %eax,%esi
call   10a0 <_mm256_or_si256@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%eax
mov    %eax,-0x48(%rbp)
mov    $0x1,%edi
xor    %esi,%esi
mov    $0x3,%edx
mov    $0x2,%ecx
call   1030 <_MM_SHUFFLE@plt>
mov    -0x48(%rbp),%edi
mov    %eax,%esi
call   1090 <_mm256_permute4x64_epi64@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%edi
mov    -0x20(%rbp),%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%edi
mov    -0x18(%rbp),%rax
mov    (%rax),%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    0xc(%rax),%edi
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%esi
call   1060 <_mm256_and_si256@plt>
mov    -0x44(%rbp),%edi
mov    %eax,%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%edi
mov    $0x26,%esi
call   1040 <_mm256_slli_epi64@plt>
mov    %eax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%edi
mov    $0x1a,%esi
call   1080 <_mm256_srli_epi64@plt>
mov    -0x40(%rbp),%edi
mov    %eax,%esi
call   10a0 <_mm256_or_si256@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
xor    %edi,%edi
mov    $0x3,%esi
mov    $0x2,%edx
mov    $0x1,%ecx
call   1030 <_MM_SHUFFLE@plt>
mov    -0x3c(%rbp),%edi
mov    %eax,%esi
call   1090 <_mm256_permute4x64_epi64@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x18(%rbp),%rax
mov    0xc(%rax),%edi
mov    -0x20(%rbp),%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0x18(%rbp),%rax
mov    0xc(%rax),%edi
mov    -0x18(%rbp),%rax
mov    0x4(%rax),%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0x18(%rbp),%rax
mov    0xc(%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%edi
mov    -0x18(%rbp),%rax
mov    (%rax),%esi
call   1060 <_mm256_and_si256@plt>
mov    -0x38(%rbp),%edi
mov    %eax,%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0x18(%rbp),%rax
mov    0xc(%rax),%edi
mov    $0x7,%esi
call   1040 <_mm256_slli_epi64@plt>
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%rax
mov    0xc(%rax),%edi
mov    $0x39,%esi
call   1080 <_mm256_srli_epi64@plt>
mov    -0x34(%rbp),%edi
mov    %eax,%esi
call   10a0 <_mm256_or_si256@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0x18(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x30(%rbp)
mov    $0x1,%edi
xor    %esi,%esi
mov    $0x3,%edx
mov    $0x2,%ecx
call   1030 <_MM_SHUFFLE@plt>
mov    -0x30(%rbp),%edi
mov    %eax,%esi
call   1090 <_mm256_permute4x64_epi64@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%edi
mov    -0x20(%rbp),%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%edi
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%edi
mov    -0x18(%rbp),%rax
mov    0x4(%rax),%esi
call   1060 <_mm256_and_si256@plt>
mov    -0x2c(%rbp),%edi
mov    %eax,%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%edi
mov    $0x4,%esi
call   1040 <_mm256_slli_epi64@plt>
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%edi
mov    $0x3c,%esi
call   1080 <_mm256_srli_epi64@plt>
mov    -0x28(%rbp),%edi
mov    %eax,%esi
call   10a0 <_mm256_or_si256@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x24(%rbp)
mov    $0x2,%edi
mov    $0x1,%esi
xor    %edx,%edx
mov    $0x3,%ecx
call   1030 <_MM_SHUFFLE@plt>
mov    -0x24(%rbp),%edi
mov    %eax,%esi
call   1090 <_mm256_permute4x64_epi64@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0x8(%rax)
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<morus_dec_aut_step>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %rdx,%rbx
mov    %rdi,%r15
mov    %rsi,%rdi
call   10b0 <_mm256_loadu_si256@plt>
mov    %eax,%r14d
mov    (%rbx),%r12d
mov    0x4(%rbx),%ebp
xor    %edi,%edi
mov    $0x3,%esi
mov    $0x2,%edx
mov    $0x1,%ecx
call   1030 <_MM_SHUFFLE@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   1090 <_mm256_permute4x64_epi64@plt>
mov    %r12d,%edi
mov    %eax,%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,%ebp
mov    0x8(%rbx),%edi
mov    0xc(%rbx),%esi
call   1060 <_mm256_and_si256@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,%edi
mov    %r14d,%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,%r14d
mov    %r15,%rdi
mov    %eax,%esi
call   1050 <_mm256_storeu_si256@plt>
mov    (%rbx),%edi
mov    0xc(%rbx),%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,%ebp
mov    %eax,(%rbx)
mov    0x4(%rbx),%edi
mov    0x8(%rbx),%esi
call   1060 <_mm256_and_si256@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,(%rbx)
mov    %eax,%edi
mov    $0xd,%esi
call   1040 <_mm256_slli_epi64@plt>
mov    %eax,%ebp
mov    (%rbx),%edi
mov    $0x33,%esi
call   1080 <_mm256_srli_epi64@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   10a0 <_mm256_or_si256@plt>
mov    %eax,(%rbx)
mov    0xc(%rbx),%ebp
mov    $0x2,%edi
mov    $0x1,%esi
xor    %edx,%edx
mov    $0x3,%ecx
call   1030 <_MM_SHUFFLE@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   1090 <_mm256_permute4x64_epi64@plt>
mov    %eax,0xc(%rbx)
mov    0x4(%rbx),%edi
mov    %r14d,%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,0x4(%rbx)
mov    0x10(%rbx),%esi
mov    %eax,%edi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,%ebp
mov    %eax,0x4(%rbx)
mov    0x8(%rbx),%edi
mov    0xc(%rbx),%esi
call   1060 <_mm256_and_si256@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,0x4(%rbx)
mov    %eax,%edi
mov    $0x2e,%esi
call   1040 <_mm256_slli_epi64@plt>
mov    %eax,%ebp
mov    0x4(%rbx),%edi
mov    $0x12,%esi
call   1080 <_mm256_srli_epi64@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   10a0 <_mm256_or_si256@plt>
mov    %eax,0x4(%rbx)
mov    0x10(%rbx),%ebp
mov    $0x1,%edi
xor    %esi,%esi
mov    $0x3,%edx
mov    $0x2,%ecx
call   1030 <_MM_SHUFFLE@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   1090 <_mm256_permute4x64_epi64@plt>
mov    %eax,0x10(%rbx)
mov    0x8(%rbx),%edi
mov    %r14d,%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,0x8(%rbx)
mov    (%rbx),%esi
mov    %eax,%edi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,%ebp
mov    %eax,0x8(%rbx)
mov    0xc(%rbx),%edi
mov    0x10(%rbx),%esi
call   1060 <_mm256_and_si256@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,0x8(%rbx)
mov    %eax,%edi
mov    $0x26,%esi
call   1040 <_mm256_slli_epi64@plt>
mov    %eax,%ebp
mov    0x8(%rbx),%edi
mov    $0x1a,%esi
call   1080 <_mm256_srli_epi64@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   10a0 <_mm256_or_si256@plt>
mov    %eax,0x8(%rbx)
mov    (%rbx),%ebp
xor    %edi,%edi
mov    $0x3,%esi
mov    $0x2,%edx
mov    $0x1,%ecx
call   1030 <_MM_SHUFFLE@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   1090 <_mm256_permute4x64_epi64@plt>
mov    %eax,(%rbx)
mov    0xc(%rbx),%edi
mov    %r14d,%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,0xc(%rbx)
mov    0x4(%rbx),%esi
mov    %eax,%edi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,%ebp
mov    %eax,0xc(%rbx)
mov    (%rbx),%esi
mov    0x10(%rbx),%edi
call   1060 <_mm256_and_si256@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,0xc(%rbx)
mov    %eax,%edi
mov    $0x7,%esi
call   1040 <_mm256_slli_epi64@plt>
mov    %eax,%ebp
mov    0xc(%rbx),%edi
mov    $0x39,%esi
call   1080 <_mm256_srli_epi64@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   10a0 <_mm256_or_si256@plt>
mov    %eax,0xc(%rbx)
mov    0x4(%rbx),%ebp
mov    $0x1,%edi
xor    %esi,%esi
mov    $0x3,%edx
mov    $0x2,%ecx
call   1030 <_MM_SHUFFLE@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   1090 <_mm256_permute4x64_epi64@plt>
mov    %eax,0x4(%rbx)
mov    0x10(%rbx),%edi
mov    %r14d,%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,0x10(%rbx)
mov    0x8(%rbx),%esi
mov    %eax,%edi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,%ebp
mov    %eax,0x10(%rbx)
mov    (%rbx),%edi
mov    0x4(%rbx),%esi
call   1060 <_mm256_and_si256@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   1070 <_mm256_xor_si256@plt>
mov    %eax,0x10(%rbx)
mov    %eax,%edi
mov    $0x4,%esi
call   1040 <_mm256_slli_epi64@plt>
mov    %eax,%ebp
mov    0x10(%rbx),%edi
mov    $0x3c,%esi
call   1080 <_mm256_srli_epi64@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   10a0 <_mm256_or_si256@plt>
mov    %eax,0x10(%rbx)
mov    0x8(%rbx),%ebp
mov    $0x2,%edi
mov    $0x1,%esi
xor    %edx,%edx
mov    $0x3,%ecx
call   1030 <_MM_SHUFFLE@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   1090 <_mm256_permute4x64_epi64@plt>
mov    %eax,0x8(%rbx)
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @morus_dec_aut_step(i8* %0, i8* %1, i32* %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i32*
%7 = alloca i32
%8 = alloca i32
store i8* %0, i8** %4
store i8* %1, i8** %5
store i32* %2, i32** %6
%9 = load i8*, i8** %5
%10 = bitcast i8* %9 to i32*
%11 = call i32 @_mm256_loadu_si256(i32* %10)
store i32 %11, i32* %8
%12 = load i32*, i32** %6
%13 = getelementptr inbounds i32, i32* %12, i64 0
%14 = load i32, i32* %13
%15 = load i32*, i32** %6
%16 = getelementptr inbounds i32, i32* %15, i64 1
%17 = load i32, i32* %16
%18 = call i32 @_MM_SHUFFLE(i32 0, i32 3, i32 2, i32 1)
%19 = call i32 @_mm256_permute4x64_epi64(i32 %17, i32 %18)
%20 = call i32 @_mm256_xor_si256(i32 %14, i32 %19)
store i32 %20, i32* %7
%21 = load i32, i32* %7
%22 = load i32*, i32** %6
%23 = getelementptr inbounds i32, i32* %22, i64 2
%24 = load i32, i32* %23
%25 = load i32*, i32** %6
%26 = getelementptr inbounds i32, i32* %25, i64 3
%27 = load i32, i32* %26
%28 = call i32 @_mm256_and_si256(i32 %24, i32 %27)
%29 = call i32 @_mm256_xor_si256(i32 %21, i32 %28)
store i32 %29, i32* %7
%30 = load i32, i32* %7
%31 = load i32, i32* %8
%32 = call i32 @_mm256_xor_si256(i32 %30, i32 %31)
store i32 %32, i32* %8
%33 = load i8*, i8** %4
%34 = bitcast i8* %33 to i32*
%35 = load i32, i32* %8
%36 = call i32 @_mm256_storeu_si256(i32* %34, i32 %35)
%37 = load i32*, i32** %6
%38 = getelementptr inbounds i32, i32* %37, i64 0
%39 = load i32, i32* %38
%40 = load i32*, i32** %6
%41 = getelementptr inbounds i32, i32* %40, i64 3
%42 = load i32, i32* %41
%43 = call i32 @_mm256_xor_si256(i32 %39, i32 %42)
%44 = load i32*, i32** %6
%45 = getelementptr inbounds i32, i32* %44, i64 0
store i32 %43, i32* %45
%46 = load i32*, i32** %6
%47 = getelementptr inbounds i32, i32* %46, i64 0
%48 = load i32, i32* %47
%49 = load i32*, i32** %6
%50 = getelementptr inbounds i32, i32* %49, i64 1
%51 = load i32, i32* %50
%52 = load i32*, i32** %6
%53 = getelementptr inbounds i32, i32* %52, i64 2
%54 = load i32, i32* %53
%55 = call i32 @_mm256_and_si256(i32 %51, i32 %54)
%56 = call i32 @_mm256_xor_si256(i32 %48, i32 %55)
%57 = load i32*, i32** %6
%58 = getelementptr inbounds i32, i32* %57, i64 0
store i32 %56, i32* %58
%59 = load i32*, i32** %6
%60 = getelementptr inbounds i32, i32* %59, i64 0
%61 = load i32, i32* %60
%62 = call i32 @_mm256_slli_epi64(i32 %61, i32 13)
%63 = load i32*, i32** %6
%64 = getelementptr inbounds i32, i32* %63, i64 0
%65 = load i32, i32* %64
%66 = call i32 @_mm256_srli_epi64(i32 %65, i32 51)
%67 = call i32 @_mm256_or_si256(i32 %62, i32 %66)
%68 = load i32*, i32** %6
%69 = getelementptr inbounds i32, i32* %68, i64 0
store i32 %67, i32* %69
%70 = load i32*, i32** %6
%71 = getelementptr inbounds i32, i32* %70, i64 3
%72 = load i32, i32* %71
%73 = call i32 @_MM_SHUFFLE(i32 2, i32 1, i32 0, i32 3)
%74 = call i32 @_mm256_permute4x64_epi64(i32 %72, i32 %73)
%75 = load i32*, i32** %6
%76 = getelementptr inbounds i32, i32* %75, i64 3
store i32 %74, i32* %76
%77 = load i32*, i32** %6
%78 = getelementptr inbounds i32, i32* %77, i64 1
%79 = load i32, i32* %78
%80 = load i32, i32* %8
%81 = call i32 @_mm256_xor_si256(i32 %79, i32 %80)
%82 = load i32*, i32** %6
%83 = getelementptr inbounds i32, i32* %82, i64 1
store i32 %81, i32* %83
%84 = load i32*, i32** %6
%85 = getelementptr inbounds i32, i32* %84, i64 1
%86 = load i32, i32* %85
%87 = load i32*, i32** %6
%88 = getelementptr inbounds i32, i32* %87, i64 4
%89 = load i32, i32* %88
%90 = call i32 @_mm256_xor_si256(i32 %86, i32 %89)
%91 = load i32*, i32** %6
%92 = getelementptr inbounds i32, i32* %91, i64 1
store i32 %90, i32* %92
%93 = load i32*, i32** %6
%94 = getelementptr inbounds i32, i32* %93, i64 1
%95 = load i32, i32* %94
%96 = load i32*, i32** %6
%97 = getelementptr inbounds i32, i32* %96, i64 2
%98 = load i32, i32* %97
%99 = load i32*, i32** %6
%100 = getelementptr inbounds i32, i32* %99, i64 3
%101 = load i32, i32* %100
%102 = call i32 @_mm256_and_si256(i32 %98, i32 %101)
%103 = call i32 @_mm256_xor_si256(i32 %95, i32 %102)
%104 = load i32*, i32** %6
%105 = getelementptr inbounds i32, i32* %104, i64 1
store i32 %103, i32* %105
%106 = load i32*, i32** %6
%107 = getelementptr inbounds i32, i32* %106, i64 1
%108 = load i32, i32* %107
%109 = call i32 @_mm256_slli_epi64(i32 %108, i32 46)
%110 = load i32*, i32** %6
%111 = getelementptr inbounds i32, i32* %110, i64 1
%112 = load i32, i32* %111
%113 = call i32 @_mm256_srli_epi64(i32 %112, i32 18)
%114 = call i32 @_mm256_or_si256(i32 %109, i32 %113)
%115 = load i32*, i32** %6
%116 = getelementptr inbounds i32, i32* %115, i64 1
store i32 %114, i32* %116
%117 = load i32*, i32** %6
%118 = getelementptr inbounds i32, i32* %117, i64 4
%119 = load i32, i32* %118
%120 = call i32 @_MM_SHUFFLE(i32 1, i32 0, i32 3, i32 2)
%121 = call i32 @_mm256_permute4x64_epi64(i32 %119, i32 %120)
%122 = load i32*, i32** %6
%123 = getelementptr inbounds i32, i32* %122, i64 4
store i32 %121, i32* %123
%124 = load i32*, i32** %6
%125 = getelementptr inbounds i32, i32* %124, i64 2
%126 = load i32, i32* %125
%127 = load i32, i32* %8
%128 = call i32 @_mm256_xor_si256(i32 %126, i32 %127)
%129 = load i32*, i32** %6
%130 = getelementptr inbounds i32, i32* %129, i64 2
store i32 %128, i32* %130
%131 = load i32*, i32** %6
%132 = getelementptr inbounds i32, i32* %131, i64 2
%133 = load i32, i32* %132
%134 = load i32*, i32** %6
%135 = getelementptr inbounds i32, i32* %134, i64 0
%136 = load i32, i32* %135
%137 = call i32 @_mm256_xor_si256(i32 %133, i32 %136)
%138 = load i32*, i32** %6
%139 = getelementptr inbounds i32, i32* %138, i64 2
store i32 %137, i32* %139
%140 = load i32*, i32** %6
%141 = getelementptr inbounds i32, i32* %140, i64 2
%142 = load i32, i32* %141
%143 = load i32*, i32** %6
%144 = getelementptr inbounds i32, i32* %143, i64 3
%145 = load i32, i32* %144
%146 = load i32*, i32** %6
%147 = getelementptr inbounds i32, i32* %146, i64 4
%148 = load i32, i32* %147
%149 = call i32 @_mm256_and_si256(i32 %145, i32 %148)
%150 = call i32 @_mm256_xor_si256(i32 %142, i32 %149)
%151 = load i32*, i32** %6
%152 = getelementptr inbounds i32, i32* %151, i64 2
store i32 %150, i32* %152
%153 = load i32*, i32** %6
%154 = getelementptr inbounds i32, i32* %153, i64 2
%155 = load i32, i32* %154
%156 = call i32 @_mm256_slli_epi64(i32 %155, i32 38)
%157 = load i32*, i32** %6
%158 = getelementptr inbounds i32, i32* %157, i64 2
%159 = load i32, i32* %158
%160 = call i32 @_mm256_srli_epi64(i32 %159, i32 26)
%161 = call i32 @_mm256_or_si256(i32 %156, i32 %160)
%162 = load i32*, i32** %6
%163 = getelementptr inbounds i32, i32* %162, i64 2
store i32 %161, i32* %163
%164 = load i32*, i32** %6
%165 = getelementptr inbounds i32, i32* %164, i64 0
%166 = load i32, i32* %165
%167 = call i32 @_MM_SHUFFLE(i32 0, i32 3, i32 2, i32 1)
%168 = call i32 @_mm256_permute4x64_epi64(i32 %166, i32 %167)
%169 = load i32*, i32** %6
%170 = getelementptr inbounds i32, i32* %169, i64 0
store i32 %168, i32* %170
%171 = load i32*, i32** %6
%172 = getelementptr inbounds i32, i32* %171, i64 3
%173 = load i32, i32* %172
%174 = load i32, i32* %8
%175 = call i32 @_mm256_xor_si256(i32 %173, i32 %174)
%176 = load i32*, i32** %6
%177 = getelementptr inbounds i32, i32* %176, i64 3
store i32 %175, i32* %177
%178 = load i32*, i32** %6
%179 = getelementptr inbounds i32, i32* %178, i64 3
%180 = load i32, i32* %179
%181 = load i32*, i32** %6
%182 = getelementptr inbounds i32, i32* %181, i64 1
%183 = load i32, i32* %182
%184 = call i32 @_mm256_xor_si256(i32 %180, i32 %183)
%185 = load i32*, i32** %6
%186 = getelementptr inbounds i32, i32* %185, i64 3
store i32 %184, i32* %186
%187 = load i32*, i32** %6
%188 = getelementptr inbounds i32, i32* %187, i64 3
%189 = load i32, i32* %188
%190 = load i32*, i32** %6
%191 = getelementptr inbounds i32, i32* %190, i64 4
%192 = load i32, i32* %191
%193 = load i32*, i32** %6
%194 = getelementptr inbounds i32, i32* %193, i64 0
%195 = load i32, i32* %194
%196 = call i32 @_mm256_and_si256(i32 %192, i32 %195)
%197 = call i32 @_mm256_xor_si256(i32 %189, i32 %196)
%198 = load i32*, i32** %6
%199 = getelementptr inbounds i32, i32* %198, i64 3
store i32 %197, i32* %199
%200 = load i32*, i32** %6
%201 = getelementptr inbounds i32, i32* %200, i64 3
%202 = load i32, i32* %201
%203 = call i32 @_mm256_slli_epi64(i32 %202, i32 7)
%204 = load i32*, i32** %6
%205 = getelementptr inbounds i32, i32* %204, i64 3
%206 = load i32, i32* %205
%207 = call i32 @_mm256_srli_epi64(i32 %206, i32 57)
%208 = call i32 @_mm256_or_si256(i32 %203, i32 %207)
%209 = load i32*, i32** %6
%210 = getelementptr inbounds i32, i32* %209, i64 3
store i32 %208, i32* %210
%211 = load i32*, i32** %6
%212 = getelementptr inbounds i32, i32* %211, i64 1
%213 = load i32, i32* %212
%214 = call i32 @_MM_SHUFFLE(i32 1, i32 0, i32 3, i32 2)
%215 = call i32 @_mm256_permute4x64_epi64(i32 %213, i32 %214)
%216 = load i32*, i32** %6
%217 = getelementptr inbounds i32, i32* %216, i64 1
store i32 %215, i32* %217
%218 = load i32*, i32** %6
%219 = getelementptr inbounds i32, i32* %218, i64 4
%220 = load i32, i32* %219
%221 = load i32, i32* %8
%222 = call i32 @_mm256_xor_si256(i32 %220, i32 %221)
%223 = load i32*, i32** %6
%224 = getelementptr inbounds i32, i32* %223, i64 4
store i32 %222, i32* %224
%225 = load i32*, i32** %6
%226 = getelementptr inbounds i32, i32* %225, i64 4
%227 = load i32, i32* %226
%228 = load i32*, i32** %6
%229 = getelementptr inbounds i32, i32* %228, i64 2
%230 = load i32, i32* %229
%231 = call i32 @_mm256_xor_si256(i32 %227, i32 %230)
%232 = load i32*, i32** %6
%233 = getelementptr inbounds i32, i32* %232, i64 4
store i32 %231, i32* %233
%234 = load i32*, i32** %6
%235 = getelementptr inbounds i32, i32* %234, i64 4
%236 = load i32, i32* %235
%237 = load i32*, i32** %6
%238 = getelementptr inbounds i32, i32* %237, i64 0
%239 = load i32, i32* %238
%240 = load i32*, i32** %6
%241 = getelementptr inbounds i32, i32* %240, i64 1
%242 = load i32, i32* %241
%243 = call i32 @_mm256_and_si256(i32 %239, i32 %242)
%244 = call i32 @_mm256_xor_si256(i32 %236, i32 %243)
%245 = load i32*, i32** %6
%246 = getelementptr inbounds i32, i32* %245, i64 4
store i32 %244, i32* %246
%247 = load i32*, i32** %6
%248 = getelementptr inbounds i32, i32* %247, i64 4
%249 = load i32, i32* %248
%250 = call i32 @_mm256_slli_epi64(i32 %249, i32 4)
%251 = load i32*, i32** %6
%252 = getelementptr inbounds i32, i32* %251, i64 4
%253 = load i32, i32* %252
%254 = call i32 @_mm256_srli_epi64(i32 %253, i32 60)
%255 = call i32 @_mm256_or_si256(i32 %250, i32 %254)
%256 = load i32*, i32** %6
%257 = getelementptr inbounds i32, i32* %256, i64 4
store i32 %255, i32* %257
%258 = load i32*, i32** %6
%259 = getelementptr inbounds i32, i32* %258, i64 2
%260 = load i32, i32* %259
%261 = call i32 @_MM_SHUFFLE(i32 2, i32 1, i32 0, i32 3)
%262 = call i32 @_mm256_permute4x64_epi64(i32 %260, i32 %261)
%263 = load i32*, i32** %6
%264 = getelementptr inbounds i32, i32* %263, i64 2
store i32 %262, i32* %264
ret void
}

LLVM IR (-O2):
define void @morus_dec_aut_step(i8* %0, i8* %1, i32* nocapture %2) {
%4 = bitcast i8* %1 to i32*
%5 = tail call i32 @_mm256_loadu_si256(i32* %4)
%6 = load i32, i32* %2
%7 = getelementptr inbounds i32, i32* %2, i64 1
%8 = load i32, i32* %7
%9 = tail call i32 @_MM_SHUFFLE(i32 0, i32 3, i32 2, i32 1)
%10 = tail call i32 @_mm256_permute4x64_epi64(i32 %8, i32 %9)
%11 = tail call i32 @_mm256_xor_si256(i32 %6, i32 %10)
%12 = getelementptr inbounds i32, i32* %2, i64 2
%13 = load i32, i32* %12
%14 = getelementptr inbounds i32, i32* %2, i64 3
%15 = load i32, i32* %14
%16 = tail call i32 @_mm256_and_si256(i32 %13, i32 %15)
%17 = tail call i32 @_mm256_xor_si256(i32 %11, i32 %16)
%18 = tail call i32 @_mm256_xor_si256(i32 %17, i32 %5)
%19 = bitcast i8* %0 to i32*
%20 = tail call i32 @_mm256_storeu_si256(i32* %19, i32 %18)
%21 = load i32, i32* %2
%22 = load i32, i32* %14
%23 = tail call i32 @_mm256_xor_si256(i32 %21, i32 %22)
store i32 %23, i32* %2
%24 = load i32, i32* %7
%25 = load i32, i32* %12
%26 = tail call i32 @_mm256_and_si256(i32 %24, i32 %25)
%27 = tail call i32 @_mm256_xor_si256(i32 %23, i32 %26)
store i32 %27, i32* %2
%28 = tail call i32 @_mm256_slli_epi64(i32 %27, i32 13)
%29 = load i32, i32* %2
%30 = tail call i32 @_mm256_srli_epi64(i32 %29, i32 51)
%31 = tail call i32 @_mm256_or_si256(i32 %28, i32 %30)
store i32 %31, i32* %2
%32 = load i32, i32* %14
%33 = tail call i32 @_MM_SHUFFLE(i32 2, i32 1, i32 0, i32 3)
%34 = tail call i32 @_mm256_permute4x64_epi64(i32 %32, i32 %33)
store i32 %34, i32* %14
%35 = load i32, i32* %7
%36 = tail call i32 @_mm256_xor_si256(i32 %35, i32 %18)
store i32 %36, i32* %7
%37 = getelementptr inbounds i32, i32* %2, i64 4
%38 = load i32, i32* %37
%39 = tail call i32 @_mm256_xor_si256(i32 %36, i32 %38)
store i32 %39, i32* %7
%40 = load i32, i32* %12
%41 = load i32, i32* %14
%42 = tail call i32 @_mm256_and_si256(i32 %40, i32 %41)
%43 = tail call i32 @_mm256_xor_si256(i32 %39, i32 %42)
store i32 %43, i32* %7
%44 = tail call i32 @_mm256_slli_epi64(i32 %43, i32 46)
%45 = load i32, i32* %7
%46 = tail call i32 @_mm256_srli_epi64(i32 %45, i32 18)
%47 = tail call i32 @_mm256_or_si256(i32 %44, i32 %46)
store i32 %47, i32* %7
%48 = load i32, i32* %37
%49 = tail call i32 @_MM_SHUFFLE(i32 1, i32 0, i32 3, i32 2)
%50 = tail call i32 @_mm256_permute4x64_epi64(i32 %48, i32 %49)
store i32 %50, i32* %37
%51 = load i32, i32* %12
%52 = tail call i32 @_mm256_xor_si256(i32 %51, i32 %18)
store i32 %52, i32* %12
%53 = load i32, i32* %2
%54 = tail call i32 @_mm256_xor_si256(i32 %52, i32 %53)
store i32 %54, i32* %12
%55 = load i32, i32* %14
%56 = load i32, i32* %37
%57 = tail call i32 @_mm256_and_si256(i32 %55, i32 %56)
%58 = tail call i32 @_mm256_xor_si256(i32 %54, i32 %57)
store i32 %58, i32* %12
%59 = tail call i32 @_mm256_slli_epi64(i32 %58, i32 38)
%60 = load i32, i32* %12
%61 = tail call i32 @_mm256_srli_epi64(i32 %60, i32 26)
%62 = tail call i32 @_mm256_or_si256(i32 %59, i32 %61)
store i32 %62, i32* %12
%63 = load i32, i32* %2
%64 = tail call i32 @_MM_SHUFFLE(i32 0, i32 3, i32 2, i32 1)
%65 = tail call i32 @_mm256_permute4x64_epi64(i32 %63, i32 %64)
store i32 %65, i32* %2
%66 = load i32, i32* %14
%67 = tail call i32 @_mm256_xor_si256(i32 %66, i32 %18)
store i32 %67, i32* %14
%68 = load i32, i32* %7
%69 = tail call i32 @_mm256_xor_si256(i32 %67, i32 %68)
store i32 %69, i32* %14
%70 = load i32, i32* %37
%71 = load i32, i32* %2
%72 = tail call i32 @_mm256_and_si256(i32 %70, i32 %71)
%73 = tail call i32 @_mm256_xor_si256(i32 %69, i32 %72)
store i32 %73, i32* %14
%74 = tail call i32 @_mm256_slli_epi64(i32 %73, i32 7)
%75 = load i32, i32* %14
%76 = tail call i32 @_mm256_srli_epi64(i32 %75, i32 57)
%77 = tail call i32 @_mm256_or_si256(i32 %74, i32 %76)
store i32 %77, i32* %14
%78 = load i32, i32* %7
%79 = tail call i32 @_MM_SHUFFLE(i32 1, i32 0, i32 3, i32 2)
%80 = tail call i32 @_mm256_permute4x64_epi64(i32 %78, i32 %79)
store i32 %80, i32* %7
%81 = load i32, i32* %37
%82 = tail call i32 @_mm256_xor_si256(i32 %81, i32 %18)
store i32 %82, i32* %37
%83 = load i32, i32* %12
%84 = tail call i32 @_mm256_xor_si256(i32 %82, i32 %83)
store i32 %84, i32* %37
%85 = load i32, i32* %2
%86 = load i32, i32* %7
%87 = tail call i32 @_mm256_and_si256(i32 %85, i32 %86)
%88 = tail call i32 @_mm256_xor_si256(i32 %84, i32 %87)
store i32 %88, i32* %37
%89 = tail call i32 @_mm256_slli_epi64(i32 %88, i32 4)
%90 = load i32, i32* %37
%91 = tail call i32 @_mm256_srli_epi64(i32 %90, i32 60)
%92 = tail call i32 @_mm256_or_si256(i32 %89, i32 %91)
store i32 %92, i32* %37
%93 = load i32, i32* %12
%94 = tail call i32 @_MM_SHUFFLE(i32 2, i32 1, i32 0, i32 3)
%95 = tail call i32 @_mm256_permute4x64_epi64(i32 %93, i32 %94)
store i32 %95, i32* %12
ret void
}