#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 uint8_t;

/* Variables and functions */
int /*<<< orphan*/ ConstantGeneration(int *);
void SubkeyGeneration(const uint8_t *mk, uint8_t *sk) {
  uint8_t delta[128];
  uint8_t i, j, index;
  ConstantGeneration(delta);
  for (i = 0; i < 8; i++) {
    for (j = 0; j < 8; j++) {
      index = (j - i + 8) & 0x07;
      sk[16 * i + j] = (mk[index] + delta[16 * i + j]) & 0xFF;
      sk[16 * i + j + 8] = (mk[index + 8] + delta[16 * i + j + 8]) & 0xFF;
    }
  }
}


x86 assembly (clang, -O0):
<SubkeyGeneration>:
push   %rbp
mov    %rsp,%rbp
sub    $0x220,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
lea    -0x210(%rbp),%rdi
call   1030 <ConstantGeneration@plt>
movl   $0x0,-0x214(%rbp)
cmpl   $0x8,-0x214(%rbp)
jge    1237 <SubkeyGeneration+0x127>
movl   $0x0,-0x218(%rbp)
cmpl   $0x8,-0x218(%rbp)
jge    121e <SubkeyGeneration+0x10e>
mov    -0x218(%rbp),%eax
sub    -0x214(%rbp),%eax
add    $0x8,%eax
and    $0x7,%eax
mov    %eax,-0x21c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x21c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x214(%rbp),%eax
shl    $0x4,%eax
add    -0x218(%rbp),%eax
cltq
add    -0x210(%rbp,%rax,4),%edx
and    $0xff,%edx
mov    -0x10(%rbp),%rax
mov    -0x214(%rbp),%ecx
shl    $0x4,%ecx
add    -0x218(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x21c(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x214(%rbp),%eax
shl    $0x4,%eax
add    -0x218(%rbp),%eax
add    $0x8,%eax
cltq
add    -0x210(%rbp,%rax,4),%edx
and    $0xff,%edx
mov    -0x10(%rbp),%rax
mov    -0x214(%rbp),%ecx
shl    $0x4,%ecx
add    -0x218(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x218(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x218(%rbp)
jmp    1150 <SubkeyGeneration+0x40>
jmp    1223 <SubkeyGeneration+0x113>
mov    -0x214(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x214(%rbp)
jmp    1139 <SubkeyGeneration+0x29>
add    $0x220,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<SubkeyGeneration>:
push   %r14
push   %rbx
sub    $0x208,%rsp
mov    %rsi,%r14
mov    %rdi,%rbx
mov    %rsp,%rdi
call   1030 <ConstantGeneration@plt>
mov    $0x8,%eax
mov    $0xf,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    -0x8(%rax),%edx
and    $0x7,%edx
mov    -0x3c(%rsp,%rcx,4),%esi
add    (%rbx,%rdx,4),%esi
movzbl %sil,%esi
mov    %esi,-0x3c(%r14,%rcx,4)
or     $0x8,%edx
mov    -0x1c(%rsp,%rcx,4),%esi
add    (%rbx,%rdx,4),%esi
movzbl %sil,%edx
mov    %edx,-0x1c(%r14,%rcx,4)
lea    -0x7(%rax),%edx
and    $0x7,%edx
mov    -0x38(%rsp,%rcx,4),%esi
add    (%rbx,%rdx,4),%esi
movzbl %sil,%esi
mov    %esi,-0x38(%r14,%rcx,4)
or     $0x8,%edx
mov    -0x18(%rsp,%rcx,4),%esi
add    (%rbx,%rdx,4),%esi
movzbl %sil,%edx
mov    %edx,-0x18(%r14,%rcx,4)
lea    -0x6(%rax),%edx
and    $0x7,%edx
mov    -0x34(%rsp,%rcx,4),%esi
add    (%rbx,%rdx,4),%esi
movzbl %sil,%esi
mov    %esi,-0x34(%r14,%rcx,4)
or     $0x8,%edx
mov    -0x14(%rsp,%rcx,4),%esi
add    (%rbx,%rdx,4),%esi
movzbl %sil,%edx
mov    %edx,-0x14(%r14,%rcx,4)
lea    -0x5(%rax),%edx
and    $0x7,%edx
mov    -0x30(%rsp,%rcx,4),%esi
add    (%rbx,%rdx,4),%esi
movzbl %sil,%esi
mov    %esi,-0x30(%r14,%rcx,4)
or     $0x8,%edx
mov    -0x10(%rsp,%rcx,4),%esi
add    (%rbx,%rdx,4),%esi
movzbl %sil,%edx
mov    %edx,-0x10(%r14,%rcx,4)
lea    -0x4(%rax),%edx
and    $0x7,%edx
mov    -0x2c(%rsp,%rcx,4),%esi
add    (%rbx,%rdx,4),%esi
movzbl %sil,%esi
mov    %esi,-0x2c(%r14,%rcx,4)
or     $0x8,%edx
mov    -0xc(%rsp,%rcx,4),%esi
add    (%rbx,%rdx,4),%esi
movzbl %sil,%edx
mov    %edx,-0xc(%r14,%rcx,4)
lea    -0x3(%rax),%edx
and    $0x7,%edx
mov    -0x28(%rsp,%rcx,4),%esi
add    (%rbx,%rdx,4),%esi
movzbl %sil,%esi
mov    %esi,-0x28(%r14,%rcx,4)
or     $0x8,%edx
mov    -0x8(%rsp,%rcx,4),%esi
add    (%rbx,%rdx,4),%esi
movzbl %sil,%edx
mov    %edx,-0x8(%r14,%rcx,4)
lea    -0x2(%rax),%edx
and    $0x7,%edx
mov    -0x24(%rsp,%rcx,4),%esi
add    (%rbx,%rdx,4),%esi
movzbl %sil,%esi
mov    %esi,-0x24(%r14,%rcx,4)
or     $0x8,%edx
mov    -0x4(%rsp,%rcx,4),%esi
add    (%rbx,%rdx,4),%esi
movzbl %sil,%edx
mov    %edx,-0x4(%r14,%rcx,4)
mov    -0x20(%rsp,%rcx,4),%edx
add    -0x4(%rbx,%rax,4),%edx
add    $0xffffffffffffffff,%rax
movzbl %dl,%edx
mov    %edx,-0x20(%r14,%rcx,4)
mov    %eax,%edx
or     $0x8,%edx
mov    (%rsp,%rcx,4),%esi
add    (%rbx,%rdx,4),%esi
movzbl %sil,%edx
mov    %edx,(%r14,%rcx,4)
add    $0x10,%rcx
test   %rax,%rax
jne    1140 <SubkeyGeneration+0x30>
add    $0x208,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define void @SubkeyGeneration(i32* %0, i32* %1) {
%3 = alloca i32*
%4 = alloca i32*
%5 = alloca [128 x i32]
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
store i32* %0, i32** %3
store i32* %1, i32** %4
%9 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 0
%10 = call i32 @ConstantGeneration(i32* %9)
store i32 0, i32* %6
br label %11
11: ; preds = %73, %2
%12 = load i32, i32* %6
%13 = icmp slt i32 %12, 8
br i1 %13, label %14, label %76
14: ; preds = %11
store i32 0, i32* %7
br label %15
15: ; preds = %69, %14
%16 = load i32, i32* %7
%17 = icmp slt i32 %16, 8
br i1 %17, label %18, label %72
18: ; preds = %15
%19 = load i32, i32* %7
%20 = load i32, i32* %6
%21 = sub nsw i32 %19, %20
%22 = add nsw i32 %21, 8
%23 = and i32 %22, 7
store i32 %23, i32* %8
%24 = load i32*, i32** %3
%25 = load i32, i32* %8
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds i32, i32* %24, i64 %26
%28 = load i32, i32* %27
%29 = load i32, i32* %6
%30 = mul nsw i32 16, %29
%31 = load i32, i32* %7
%32 = add nsw i32 %30, %31
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 %33
%35 = load i32, i32* %34
%36 = add nsw i32 %28, %35
%37 = and i32 %36, 255
%38 = load i32*, i32** %4
%39 = load i32, i32* %6
%40 = mul nsw i32 16, %39
%41 = load i32, i32* %7
%42 = add nsw i32 %40, %41
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds i32, i32* %38, i64 %43
store i32 %37, i32* %44
%45 = load i32*, i32** %3
%46 = load i32, i32* %8
%47 = add nsw i32 %46, 8
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds i32, i32* %45, i64 %48
%50 = load i32, i32* %49
%51 = load i32, i32* %6
%52 = mul nsw i32 16, %51
%53 = load i32, i32* %7
%54 = add nsw i32 %52, %53
%55 = add nsw i32 %54, 8
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 %56
%58 = load i32, i32* %57
%59 = add nsw i32 %50, %58
%60 = and i32 %59, 255
%61 = load i32*, i32** %4
%62 = load i32, i32* %6
%63 = mul nsw i32 16, %62
%64 = load i32, i32* %7
%65 = add nsw i32 %63, %64
%66 = add nsw i32 %65, 8
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds i32, i32* %61, i64 %67
store i32 %60, i32* %68
br label %69
69: ; preds = %18
%70 = load i32, i32* %7
%71 = add nsw i32 %70, 1
store i32 %71, i32* %7
br label %15
72: ; preds = %15
br label %73
73: ; preds = %72
%74 = load i32, i32* %6
%75 = add nsw i32 %74, 1
store i32 %75, i32* %6
br label %11
76: ; preds = %11
ret void
}

LLVM IR (-O2):
define void @SubkeyGeneration(i32* nocapture %0, i32* nocapture writeonly %1) {
%3 = alloca [128 x i32]
%4 = bitcast [128 x i32]* %3 to i8*
%5 = getelementptr inbounds [128 x i32], [128 x i32]* %3, i64 0, i64 0
%6 = call i32 @ConstantGeneration(i32* %5)
br label %7
7: ; preds = %2, %7
%8 = phi i64 [ 0, %2 ], [ %185, %7 ]
%9 = shl nsw i64 %8, 4
%10 = trunc i64 %8 to i32
%11 = sub i32 0, %10
%12 = and i32 %11, 7
%13 = zext i32 %12 to i64
%14 = getelementptr inbounds i32, i32* %0, i64 %13
%15 = load i32, i32* %14
%16 = getelementptr inbounds [128 x i32], [128 x i32]* %3, i64 0, i64 %9
%17 = load i32, i32* %16
%18 = add nsw i32 %17, %15
%19 = and i32 %18, 255
%20 = getelementptr inbounds i32, i32* %1, i64 %9
store i32 %19, i32* %20
%21 = or i32 %12, 8
%22 = zext i32 %21 to i64
%23 = getelementptr inbounds i32, i32* %0, i64 %22
%24 = load i32, i32* %23
%25 = or i64 %9, 8
%26 = getelementptr inbounds [128 x i32], [128 x i32]* %3, i64 0, i64 %25
%27 = load i32, i32* %26
%28 = add nsw i32 %27, %24
%29 = and i32 %28, 255
%30 = getelementptr inbounds i32, i32* %1, i64 %25
store i32 %29, i32* %30
%31 = trunc i64 %8 to i32
%32 = sub i32 1, %31
%33 = and i32 %32, 7
%34 = zext i32 %33 to i64
%35 = getelementptr inbounds i32, i32* %0, i64 %34
%36 = load i32, i32* %35
%37 = or i64 %9, 1
%38 = getelementptr inbounds [128 x i32], [128 x i32]* %3, i64 0, i64 %37
%39 = load i32, i32* %38
%40 = add nsw i32 %39, %36
%41 = and i32 %40, 255
%42 = getelementptr inbounds i32, i32* %1, i64 %37
store i32 %41, i32* %42
%43 = or i32 %33, 8
%44 = zext i32 %43 to i64
%45 = getelementptr inbounds i32, i32* %0, i64 %44
%46 = load i32, i32* %45
%47 = or i64 %9, 9
%48 = getelementptr inbounds [128 x i32], [128 x i32]* %3, i64 0, i64 %47
%49 = load i32, i32* %48
%50 = add nsw i32 %49, %46
%51 = and i32 %50, 255
%52 = getelementptr inbounds i32, i32* %1, i64 %47
store i32 %51, i32* %52
%53 = trunc i64 %8 to i32
%54 = sub i32 2, %53
%55 = and i32 %54, 7
%56 = zext i32 %55 to i64
%57 = getelementptr inbounds i32, i32* %0, i64 %56
%58 = load i32, i32* %57
%59 = or i64 %9, 2
%60 = getelementptr inbounds [128 x i32], [128 x i32]* %3, i64 0, i64 %59
%61 = load i32, i32* %60
%62 = add nsw i32 %61, %58
%63 = and i32 %62, 255
%64 = getelementptr inbounds i32, i32* %1, i64 %59
store i32 %63, i32* %64
%65 = or i32 %55, 8
%66 = zext i32 %65 to i64
%67 = getelementptr inbounds i32, i32* %0, i64 %66
%68 = load i32, i32* %67
%69 = or i64 %9, 10
%70 = getelementptr inbounds [128 x i32], [128 x i32]* %3, i64 0, i64 %69
%71 = load i32, i32* %70
%72 = add nsw i32 %71, %68
%73 = and i32 %72, 255
%74 = getelementptr inbounds i32, i32* %1, i64 %69
store i32 %73, i32* %74
%75 = trunc i64 %8 to i32
%76 = sub i32 3, %75
%77 = and i32 %76, 7
%78 = zext i32 %77 to i64
%79 = getelementptr inbounds i32, i32* %0, i64 %78
%80 = load i32, i32* %79
%81 = or i64 %9, 3
%82 = getelementptr inbounds [128 x i32], [128 x i32]* %3, i64 0, i64 %81
%83 = load i32, i32* %82
%84 = add nsw i32 %83, %80
%85 = and i32 %84, 255
%86 = getelementptr inbounds i32, i32* %1, i64 %81
store i32 %85, i32* %86
%87 = or i32 %77, 8
%88 = zext i32 %87 to i64
%89 = getelementptr inbounds i32, i32* %0, i64 %88
%90 = load i32, i32* %89
%91 = or i64 %9, 11
%92 = getelementptr inbounds [128 x i32], [128 x i32]* %3, i64 0, i64 %91
%93 = load i32, i32* %92
%94 = add nsw i32 %93, %90
%95 = and i32 %94, 255
%96 = getelementptr inbounds i32, i32* %1, i64 %91
store i32 %95, i32* %96
%97 = trunc i64 %8 to i32
%98 = sub i32 4, %97
%99 = and i32 %98, 7
%100 = zext i32 %99 to i64
%101 = getelementptr inbounds i32, i32* %0, i64 %100
%102 = load i32, i32* %101
%103 = or i64 %9, 4
%104 = getelementptr inbounds [128 x i32], [128 x i32]* %3, i64 0, i64 %103
%105 = load i32, i32* %104
%106 = add nsw i32 %105, %102
%107 = and i32 %106, 255
%108 = getelementptr inbounds i32, i32* %1, i64 %103
store i32 %107, i32* %108
%109 = or i32 %99, 8
%110 = zext i32 %109 to i64
%111 = getelementptr inbounds i32, i32* %0, i64 %110
%112 = load i32, i32* %111
%113 = or i64 %9, 12
%114 = getelementptr inbounds [128 x i32], [128 x i32]* %3, i64 0, i64 %113
%115 = load i32, i32* %114
%116 = add nsw i32 %115, %112
%117 = and i32 %116, 255
%118 = getelementptr inbounds i32, i32* %1, i64 %113
store i32 %117, i32* %118
%119 = trunc i64 %8 to i32
%120 = sub i32 5, %119
%121 = and i32 %120, 7
%122 = zext i32 %121 to i64
%123 = getelementptr inbounds i32, i32* %0, i64 %122
%124 = load i32, i32* %123
%125 = or i64 %9, 5
%126 = getelementptr inbounds [128 x i32], [128 x i32]* %3, i64 0, i64 %125
%127 = load i32, i32* %126
%128 = add nsw i32 %127, %124
%129 = and i32 %128, 255
%130 = getelementptr inbounds i32, i32* %1, i64 %125
store i32 %129, i32* %130
%131 = or i32 %121, 8
%132 = zext i32 %131 to i64
%133 = getelementptr inbounds i32, i32* %0, i64 %132
%134 = load i32, i32* %133
%135 = or i64 %9, 13
%136 = getelementptr inbounds [128 x i32], [128 x i32]* %3, i64 0, i64 %135
%137 = load i32, i32* %136
%138 = add nsw i32 %137, %134
%139 = and i32 %138, 255
%140 = getelementptr inbounds i32, i32* %1, i64 %135
store i32 %139, i32* %140
%141 = trunc i64 %8 to i32
%142 = sub i32 6, %141
%143 = and i32 %142, 7
%144 = zext i32 %143 to i64
%145 = getelementptr inbounds i32, i32* %0, i64 %144
%146 = load i32, i32* %145
%147 = or i64 %9, 6
%148 = getelementptr inbounds [128 x i32], [128 x i32]* %3, i64 0, i64 %147
%149 = load i32, i32* %148
%150 = add nsw i32 %149, %146
%151 = and i32 %150, 255
%152 = getelementptr inbounds i32, i32* %1, i64 %147
store i32 %151, i32* %152
%153 = or i32 %143, 8
%154 = zext i32 %153 to i64
%155 = getelementptr inbounds i32, i32* %0, i64 %154
%156 = load i32, i32* %155
%157 = or i64 %9, 14
%158 = getelementptr inbounds [128 x i32], [128 x i32]* %3, i64 0, i64 %157
%159 = load i32, i32* %158
%160 = add nsw i32 %159, %156
%161 = and i32 %160, 255
%162 = getelementptr inbounds i32, i32* %1, i64 %157
store i32 %161, i32* %162
%163 = trunc i64 %8 to i32
%164 = sub i32 7, %163
%165 = and i32 %164, 7
%166 = zext i32 %165 to i64
%167 = getelementptr inbounds i32, i32* %0, i64 %166
%168 = load i32, i32* %167
%169 = or i64 %9, 7
%170 = getelementptr inbounds [128 x i32], [128 x i32]* %3, i64 0, i64 %169
%171 = load i32, i32* %170
%172 = add nsw i32 %171, %168
%173 = and i32 %172, 255
%174 = getelementptr inbounds i32, i32* %1, i64 %169
store i32 %173, i32* %174
%175 = or i32 %165, 8
%176 = zext i32 %175 to i64
%177 = getelementptr inbounds i32, i32* %0, i64 %176
%178 = load i32, i32* %177
%179 = or i64 %9, 15
%180 = getelementptr inbounds [128 x i32], [128 x i32]* %3, i64 0, i64 %179
%181 = load i32, i32* %180
%182 = add nsw i32 %181, %178
%183 = and i32 %182, 255
%184 = getelementptr inbounds i32, i32* %1, i64 %179
store i32 %183, i32* %184
%185 = add nuw nsw i64 %8, 1
%186 = icmp eq i64 %185, 8
br i1 %186, label %187, label %7
187: ; preds = %7
ret void
}