#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 */

/* Variables and functions */
int /*<<< orphan*/ AESROUND(unsigned char *, unsigned char *, unsigned char *);
int /*<<< orphan*/ memcpy(unsigned char *, unsigned char *, int);
void aegis128L_initialization(const unsigned char *key, const unsigned char *iv,
                              unsigned char *state) {
  int i;
  unsigned char tmp[16];
  unsigned char constant[32] = {0x0,  0x1,  0x01, 0x02, 0x03, 0x05, 0x08, 0x0d,
                                0x15, 0x22, 0x37, 0x59, 0x90, 0xe9, 0x79, 0x62,
                                0xdb, 0x3d, 0x18, 0x55, 0x6d, 0xc2, 0x2f, 0xf1,
                                0x20, 0x11, 0x31, 0x42, 0x73, 0xb5, 0x28, 0xdd};
  {
    ((unsigned long long *)(state))[0] =
        ((unsigned long long *)(key))[0] ^ ((unsigned long long *)(iv))[0];
    ((unsigned long long *)(state))[1] =
        ((unsigned long long *)(key))[1] ^ ((unsigned long long *)(iv))[1];
  };
  memcpy(state + 16, constant + 16, 16);
  memcpy(state + 32, constant, 16);
  memcpy(state + 48, constant + 16, 16);
  {
    ((unsigned long long *)(state + 64))[0] =
        ((unsigned long long *)(key))[0] ^ ((unsigned long long *)(iv))[0];
    ((unsigned long long *)(state + 64))[1] =
        ((unsigned long long *)(key))[1] ^ ((unsigned long long *)(iv))[1];
  };
  {
    ((unsigned long long *)(state + 80))[0] =
        ((unsigned long long *)(key))[0] ^
        ((unsigned long long *)(constant))[0];
    ((unsigned long long *)(state + 80))[1] =
        ((unsigned long long *)(key))[1] ^
        ((unsigned long long *)(constant))[1];
  };
  {
    ((unsigned long long *)(state + 96))[0] =
        ((unsigned long long *)(key))[0] ^
        ((unsigned long long *)(constant + 16))[0];
    ((unsigned long long *)(state + 96))[1] =
        ((unsigned long long *)(key))[1] ^
        ((unsigned long long *)(constant + 16))[1];
  };
  {
    ((unsigned long long *)(state + 112))[0] =
        ((unsigned long long *)(key))[0] ^
        ((unsigned long long *)(constant))[0];
    ((unsigned long long *)(state + 112))[1] =
        ((unsigned long long *)(key))[1] ^
        ((unsigned long long *)(constant))[1];
  };
  for (i = 0; i < 10; i++) {
    memcpy(tmp, state + 112, 16);
    AESROUND(state + 112, state + 96, state + 112);
    AESROUND(state + 96, state + 80, state + 96);
    AESROUND(state + 80, state + 64, state + 80);
    AESROUND(state + 64, state + 48, state + 64);
    AESROUND(state + 48, state + 32, state + 48);
    AESROUND(state + 32, state + 16, state + 32);
    AESROUND(state + 16, state + 0, state + 16);
    AESROUND(state + 0, tmp, state + 0);
    {
      ((unsigned long long *)(state))[0] =
          ((unsigned long long *)(state))[0] ^ ((unsigned long long *)(iv))[0];
      ((unsigned long long *)(state))[1] =
          ((unsigned long long *)(state))[1] ^ ((unsigned long long *)(iv))[1];
    };
    {
      ((unsigned long long *)(state + 64))[0] =
          ((unsigned long long *)(state + 64))[0] ^
          ((unsigned long long *)(key))[0];
      ((unsigned long long *)(state + 64))[1] =
          ((unsigned long long *)(state + 64))[1] ^
          ((unsigned long long *)(key))[1];
    };
  }
}


x86 assembly (clang, -O0):
<aegis128L_initialization>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    0xec5(%rip),%rax
mov    %rax,-0x50(%rbp)
mov    0xec2(%rip),%rax
mov    %rax,-0x48(%rbp)
mov    0xebf(%rip),%rax
mov    %rax,-0x40(%rbp)
mov    0xebc(%rip),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%rcx
mov    -0x10(%rbp),%rax
xor    (%rax),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rcx
mov    -0x10(%rbp),%rax
xor    0x8(%rax),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x8(%rax)
mov    -0x18(%rbp),%rdi
add    $0x10,%rdi
lea    -0x50(%rbp),%rsi
add    $0x10,%rsi
mov    $0x10,%edx
call   1030 <memcpy@plt>
mov    -0x18(%rbp),%rdi
add    $0x20,%rdi
lea    -0x50(%rbp),%rsi
mov    $0x10,%edx
call   1030 <memcpy@plt>
mov    -0x18(%rbp),%rdi
add    $0x30,%rdi
lea    -0x50(%rbp),%rsi
add    $0x10,%rsi
mov    $0x10,%edx
call   1030 <memcpy@plt>
mov    -0x8(%rbp),%rax
mov    (%rax),%rcx
mov    -0x10(%rbp),%rax
xor    (%rax),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x40(%rax)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rcx
mov    -0x10(%rbp),%rax
xor    0x8(%rax),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x48(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%rcx
xor    -0x50(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x50(%rax)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rcx
xor    -0x48(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x58(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%rcx
xor    -0x40(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x60(%rax)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rcx
xor    -0x38(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x68(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%rcx
xor    -0x50(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x70(%rax)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rcx
xor    -0x48(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x78(%rax)
movl   $0x0,-0x1c(%rbp)
cmpl   $0xa,-0x1c(%rbp)
jge    13e3 <aegis128L_initialization+0x2c3>
lea    -0x30(%rbp),%rdi
mov    -0x18(%rbp),%rsi
add    $0x70,%rsi
mov    $0x10,%edx
call   1030 <memcpy@plt>
mov    -0x18(%rbp),%rdi
add    $0x70,%rdi
mov    -0x18(%rbp),%rsi
add    $0x60,%rsi
mov    -0x18(%rbp),%rdx
add    $0x70,%rdx
call   1040 <AESROUND@plt>
mov    -0x18(%rbp),%rdi
add    $0x60,%rdi
mov    -0x18(%rbp),%rsi
add    $0x50,%rsi
mov    -0x18(%rbp),%rdx
add    $0x60,%rdx
call   1040 <AESROUND@plt>
mov    -0x18(%rbp),%rdi
add    $0x50,%rdi
mov    -0x18(%rbp),%rsi
add    $0x40,%rsi
mov    -0x18(%rbp),%rdx
add    $0x50,%rdx
call   1040 <AESROUND@plt>
mov    -0x18(%rbp),%rdi
add    $0x40,%rdi
mov    -0x18(%rbp),%rsi
add    $0x30,%rsi
mov    -0x18(%rbp),%rdx
add    $0x40,%rdx
call   1040 <AESROUND@plt>
mov    -0x18(%rbp),%rdi
add    $0x30,%rdi
mov    -0x18(%rbp),%rsi
add    $0x20,%rsi
mov    -0x18(%rbp),%rdx
add    $0x30,%rdx
call   1040 <AESROUND@plt>
mov    -0x18(%rbp),%rdi
add    $0x20,%rdi
mov    -0x18(%rbp),%rsi
add    $0x10,%rsi
mov    -0x18(%rbp),%rdx
add    $0x20,%rdx
call   1040 <AESROUND@plt>
mov    -0x18(%rbp),%rdi
add    $0x10,%rdi
mov    -0x18(%rbp),%rsi
mov    -0x18(%rbp),%rdx
add    $0x10,%rdx
call   1040 <AESROUND@plt>
mov    -0x18(%rbp),%rdi
lea    -0x30(%rbp),%rsi
mov    -0x18(%rbp),%rdx
call   1040 <AESROUND@plt>
mov    -0x18(%rbp),%rax
mov    (%rax),%rcx
mov    -0x10(%rbp),%rax
xor    (%rax),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rcx
mov    -0x10(%rbp),%rax
xor    0x8(%rax),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x8(%rax)
mov    -0x18(%rbp),%rax
mov    0x40(%rax),%rcx
mov    -0x8(%rbp),%rax
xor    (%rax),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x40(%rax)
mov    -0x18(%rbp),%rax
mov    0x48(%rax),%rcx
mov    -0x8(%rbp),%rax
xor    0x8(%rax),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x48(%rax)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1281 <aegis128L_initialization+0x161>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<aegis128L_initialization>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %rdx,%r12
mov    %rsi,%r15
mov    %rdi,%rbp
movaps 0xecf(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
movaps 0xeb3(%rip),%xmm0
movaps %xmm0,(%rsp)
lea    0x10(%rsp),%r14
mov    (%rsi),%rax
xor    (%rdi),%rax
mov    %rax,(%rdx)
mov    0x8(%rsi),%rax
xor    0x8(%rdi),%rax
mov    %rax,0x8(%rdx)
lea    0x10(%rdx),%rdi
mov    %rdi,0x58(%rsp)
mov    %r14,%rsi
mov    $0x10,%edx
call   1030 <memcpy@plt>
lea    0x20(%r12),%rdi
mov    %rsp,%rsi
mov    %rdi,0x50(%rsp)
mov    $0x10,%edx
call   1030 <memcpy@plt>
lea    0x30(%r12),%rdi
mov    %rdi,0x48(%rsp)
mov    %r14,%rsi
mov    $0x10,%edx
call   1030 <memcpy@plt>
mov    (%r15),%rax
xor    0x0(%rbp),%rax
lea    0x40(%r12),%rcx
mov    %rcx,0x40(%rsp)
mov    %rax,0x40(%r12)
mov    %r15,0x68(%rsp)
mov    0x8(%r15),%rax
xor    0x8(%rbp),%rax
mov    %rax,0x48(%r12)
mov    (%rsp),%rax
mov    0x0(%rbp),%rcx
xor    %rax,%rcx
mov    %rcx,0x50(%r12)
mov    0x8(%rsp),%rcx
mov    0x8(%rbp),%rdx
xor    %rcx,%rdx
mov    %rdx,0x58(%r12)
mov    0x10(%rsp),%rdx
xor    0x0(%rbp),%rdx
mov    %rdx,0x60(%r12)
mov    0x18(%rsp),%rdx
xor    0x8(%rbp),%rdx
lea    0x50(%r12),%rsi
mov    %rsi,0x38(%rsp)
mov    %rdx,0x68(%r12)
xor    0x0(%rbp),%rax
lea    0x60(%r12),%rdx
mov    %rdx,0x30(%rsp)
mov    %rax,0x70(%r12)
mov    %rbp,0x60(%rsp)
xor    0x8(%rbp),%rcx
lea    0x70(%r12),%rax
mov    %rax,0x28(%rsp)
mov    %rcx,0x78(%r12)
mov    $0xa,%r13d
mov    0x50(%rsp),%r15
mov    0x58(%rsp),%r14
nopl   0x0(%rax)
lea    0x70(%rsp),%rdi
mov    0x28(%rsp),%rbx
mov    %rbx,%rsi
mov    $0x10,%edx
call   1030 <memcpy@plt>
mov    %rbx,%rdi
mov    0x30(%rsp),%rbp
mov    %rbp,%rsi
mov    %rbx,%rdx
call   1040 <AESROUND@plt>
mov    %rbp,%rdi
mov    0x38(%rsp),%rbx
mov    %rbx,%rsi
mov    %rbp,%rdx
call   1040 <AESROUND@plt>
mov    %rbx,%rdi
mov    0x40(%rsp),%rbp
mov    %rbp,%rsi
mov    %rbx,%rdx
call   1040 <AESROUND@plt>
mov    %rbp,%rdi
mov    0x48(%rsp),%rbx
mov    %rbx,%rsi
mov    %rbp,%rdx
call   1040 <AESROUND@plt>
mov    %rbx,%rdi
mov    %r15,%rsi
mov    %rbx,%rdx
call   1040 <AESROUND@plt>
mov    %r15,%rdi
mov    %r14,%rsi
mov    %r15,%rdx
call   1040 <AESROUND@plt>
mov    %r14,%rdi
mov    %r12,%rsi
mov    %r14,%rdx
call   1040 <AESROUND@plt>
mov    %r12,%rdi
lea    0x70(%rsp),%rsi
mov    %r12,%rdx
call   1040 <AESROUND@plt>
mov    0x68(%rsp),%rcx
mov    (%rcx),%rax
xor    %rax,(%r12)
mov    0x8(%rcx),%rax
xor    %rax,0x8(%r12)
mov    0x60(%rsp),%rcx
mov    (%rcx),%rax
xor    %rax,0x40(%r12)
mov    0x8(%rcx),%rax
xor    %rax,0x48(%r12)
add    $0xffffffff,%r13d
jne    1260 <aegis128L_initialization+0x140>
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@__const.aegis128L_initialization.constant = [32 x i8] c"\00\01\01\02\03\05\08\0D\15\227Y\90\E9yb\DB=\18Um\C2/\F1 \111Bs\B5(\DD"
define void @aegis128L_initialization(i8* nocapture %0, i8* nocapture %1, i8* %2) {
%4 = alloca [16 x i8]
%5 = alloca [32 x i8]
%6 = getelementptr inbounds [16 x i8], [16 x i8]* %4, i64 0, i64 0
%7 = getelementptr inbounds [32 x i8], [32 x i8]* %5, i64 0, i64 0
%8 = bitcast i8* %0 to i64*
%9 = load i64, i64* %8
%10 = bitcast i8* %1 to i64*
%11 = load i64, i64* %10
%12 = xor i64 %11, %9
%13 = bitcast i8* %2 to i64*
store i64 %12, i64* %13
%14 = getelementptr inbounds i8, i8* %0, i64 8
%15 = bitcast i8* %14 to i64*
%16 = load i64, i64* %15
%17 = getelementptr inbounds i8, i8* %1, i64 8
%18 = bitcast i8* %17 to i64*
%19 = load i64, i64* %18
%20 = xor i64 %19, %16
%21 = getelementptr inbounds i8, i8* %2, i64 8
%22 = bitcast i8* %21 to i64*
store i64 %20, i64* %22
%23 = getelementptr inbounds i8, i8* %2, i64 16
%24 = getelementptr inbounds [32 x i8], [32 x i8]* %5, i64 0, i64 16
%25 = call i32 @memcpy(i8* %23, i8* %24, i32 16)
%26 = getelementptr inbounds i8, i8* %2, i64 32
%27 = call i32 @memcpy(i8* %26, i8* %7, i32 16)
%28 = getelementptr inbounds i8, i8* %2, i64 48
%29 = call i32 @memcpy(i8* %28, i8* %24, i32 16)
%30 = load i64, i64* %8
%31 = load i64, i64* %10
%32 = xor i64 %31, %30
%33 = getelementptr inbounds i8, i8* %2, i64 64
%34 = bitcast i8* %33 to i64*
store i64 %32, i64* %34
%35 = load i64, i64* %15
%36 = load i64, i64* %18
%37 = xor i64 %36, %35
%38 = getelementptr inbounds i8, i8* %2, i64 72
%39 = bitcast i8* %38 to i64*
store i64 %37, i64* %39
%40 = load i64, i64* %8
%41 = bitcast [32 x i8]* %5 to i64*
%42 = load i64, i64* %41
%43 = xor i64 %42, %40
%44 = getelementptr inbounds i8, i8* %2, i64 80
%45 = bitcast i8* %44 to i64*
store i64 %43, i64* %45
%46 = load i64, i64* %15
%47 = getelementptr inbounds [32 x i8], [32 x i8]* %5, i64 0, i64 8
%48 = bitcast i8* %47 to i64*
%49 = load i64, i64* %48
%50 = xor i64 %49, %46
%51 = getelementptr inbounds i8, i8* %2, i64 88
%52 = bitcast i8* %51 to i64*
store i64 %50, i64* %52
%53 = load i64, i64* %8
%54 = bitcast i8* %24 to i64*
%55 = load i64, i64* %54
%56 = xor i64 %55, %53
%57 = getelementptr inbounds i8, i8* %2, i64 96
%58 = bitcast i8* %57 to i64*
store i64 %56, i64* %58
%59 = load i64, i64* %15
%60 = getelementptr inbounds [32 x i8], [32 x i8]* %5, i64 0, i64 24
%61 = bitcast i8* %60 to i64*
%62 = load i64, i64* %61
%63 = xor i64 %62, %59
%64 = getelementptr inbounds i8, i8* %2, i64 104
%65 = bitcast i8* %64 to i64*
store i64 %63, i64* %65
%66 = load i64, i64* %8
%67 = xor i64 %66, %42
%68 = getelementptr inbounds i8, i8* %2, i64 112
%69 = bitcast i8* %68 to i64*
store i64 %67, i64* %69
%70 = load i64, i64* %15
%71 = xor i64 %70, %49
%72 = getelementptr inbounds i8, i8* %2, i64 120
%73 = bitcast i8* %72 to i64*
store i64 %71, i64* %73
br label %74
74: ; preds = %3, %74
%75 = phi i32 [ 0, %3 ], [ %97, %74 ]
%76 = call i32 @memcpy(i8* %6, i8* %68, i32 16)
%77 = call i32 @AESROUND(i8* %68, i8* %57, i8* %68)
%78 = call i32 @AESROUND(i8* %57, i8* %44, i8* %57)
%79 = call i32 @AESROUND(i8* %44, i8* %33, i8* %44)
%80 = call i32 @AESROUND(i8* %33, i8* %28, i8* %33)
%81 = call i32 @AESROUND(i8* %28, i8* %26, i8* %28)
%82 = call i32 @AESROUND(i8* %26, i8* %23, i8* %26)
%83 = call i32 @AESROUND(i8* %23, i8* %2, i8* %23)
%84 = call i32 @AESROUND(i8* %2, i8* %6, i8* %2)
%85 = load i64, i64* %13
%86 = load i64, i64* %10
%87 = xor i64 %86, %85
store i64 %87, i64* %13
%88 = load i64, i64* %22
%89 = load i64, i64* %18
%90 = xor i64 %89, %88
store i64 %90, i64* %22
%91 = load i64, i64* %34
%92 = load i64, i64* %8
%93 = xor i64 %92, %91
store i64 %93, i64* %34
%94 = load i64, i64* %39
%95 = load i64, i64* %15
%96 = xor i64 %95, %94
store i64 %96, i64* %39
%97 = add nuw nsw i32 %75, 1
%98 = icmp eq i32 %97, 10
br i1 %98, label %99, label %74
99: ; preds = %74
ret void
}