#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*/ usekey(unsigned long *);
void cookey(register unsigned long *raw1) {
  register unsigned long *cook, *raw0;
  unsigned long dough[32];
  register int i;
  cook = dough;
  for (i = 0; i < 16; i++, raw1++) {
    raw0 = raw1++;
    *cook = (*raw0 & 0x00fc0000L) << 6;
    *cook |= (*raw0 & 0x00000fc0L) << 10;
    *cook |= (*raw1 & 0x00fc0000L) >> 10;
    *cook++ |= (*raw1 & 0x00000fc0L) >> 6;
    *cook = (*raw0 & 0x0003f000L) << 12;
    *cook |= (*raw0 & 0x0000003fL) << 16;
    *cook |= (*raw1 & 0x0003f000L) >> 4;
    *cook++ |= (*raw1 & 0x0000003fL);
  }
  usekey(dough);
  return;
}


x86 assembly (clang, -O0):
<cookey>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
mov    %rdi,-0x8(%rbp)
lea    -0x120(%rbp),%rax
mov    %rax,-0x10(%rbp)
movl   $0x0,-0x124(%rbp)
cmpl   $0x10,-0x124(%rbp)
jge    125a <cookey+0x14a>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x8(%rbp)
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rcx
and    $0xfc0000,%rcx
shl    $0x6,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%rcx
and    $0xfc0,%rcx
shl    $0xa,%rcx
mov    -0x10(%rbp),%rax
or     (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%rcx
and    $0xfc0000,%rcx
shr    $0xa,%rcx
mov    -0x10(%rbp),%rax
or     (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%rcx
and    $0xfc0,%rcx
shr    $0x6,%rcx
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x10(%rbp)
or     (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%rcx
and    $0x3f000,%rcx
shl    $0xc,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%rcx
and    $0x3f,%rcx
shl    $0x10,%rcx
mov    -0x10(%rbp),%rax
or     (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%rcx
and    $0x3f000,%rcx
shr    $0x4,%rcx
mov    -0x10(%rbp),%rax
or     (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%rcx
and    $0x3f,%rcx
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x10(%rbp)
or     (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x124(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x124(%rbp)
mov    -0x8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x8(%rbp)
jmp    1134 <cookey+0x24>
lea    -0x120(%rbp),%rdi
call   1030 <usekey@plt>
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cookey>:
sub    $0x108,%rsp
lea    0x100(%rdi),%rax
mov    %rsp,%rcx
cmp    %rax,%rcx
jae    11c3 <cookey+0xb3>
lea    0x100(%rsp),%rax
cmp    %rdi,%rax
jbe    11c3 <cookey+0xb3>
xor    %r8d,%r8d
xchg   %ax,%ax
mov    (%rdi,%r8,1),%ecx
mov    %ecx,%edx
shl    $0x6,%edx
and    $0x3f000000,%edx
mov    %ecx,%esi
shl    $0xa,%esi
and    $0x3f0000,%esi
or     %rdx,%rsi
mov    0x8(%rdi,%r8,1),%rax
mov    %rax,%rdx
shr    $0xa,%rdx
and    $0x3f00,%edx
or     %rsi,%rdx
mov    %eax,%esi
shr    $0x6,%esi
and    $0x3f,%esi
or     %rdx,%rsi
mov    %rsi,(%rsp,%r8,1)
mov    %ecx,%edx
shl    $0xc,%edx
and    $0x3f000000,%edx
and    $0x3f,%ecx
shl    $0x10,%rcx
or     %rdx,%rcx
mov    %rax,%rdx
shr    $0x4,%rdx
and    $0x3f00,%edx
and    $0x3f,%eax
or     %rcx,%rax
or     %rdx,%rax
mov    %rax,0x8(%rsp,%r8,1)
add    $0x10,%r8
cmp    $0x100,%r8d
jne    1140 <cookey+0x30>
jmp    12a3 <cookey+0x193>
xor    %eax,%eax
movdqa 0xe32(%rip),%xmm8
movdqa 0xe3a(%rip),%xmm1
movdqa 0xe42(%rip),%xmm2
movdqa 0xe4a(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
movdqu (%rdi,%rax,1),%xmm6
movdqu 0x10(%rdi,%rax,1),%xmm0
movdqa %xmm6,%xmm5
punpcklqdq %xmm0,%xmm5
punpckhqdq %xmm0,%xmm6
movdqa %xmm5,%xmm4
psllq  $0x6,%xmm4
pand   %xmm8,%xmm4
movdqa %xmm5,%xmm7
psllq  $0xa,%xmm7
pand   %xmm1,%xmm7
por    %xmm4,%xmm7
movdqa %xmm6,%xmm0
psrlq  $0xa,%xmm0
pand   %xmm2,%xmm0
movdqa %xmm6,%xmm4
psrlq  $0x6,%xmm4
pand   %xmm3,%xmm4
por    %xmm0,%xmm4
por    %xmm7,%xmm4
movdqa %xmm5,%xmm0
psllq  $0xc,%xmm0
pand   %xmm8,%xmm0
psllq  $0x10,%xmm5
pand   %xmm1,%xmm5
por    %xmm0,%xmm5
movdqa %xmm6,%xmm0
psrlq  $0x4,%xmm0
pand   %xmm2,%xmm0
pand   %xmm3,%xmm6
por    %xmm0,%xmm6
por    %xmm5,%xmm6
movdqa %xmm4,%xmm0
punpcklqdq %xmm6,%xmm0
punpckhqdq %xmm6,%xmm4
movdqa %xmm4,0x10(%rsp,%rax,1)
movdqa %xmm0,(%rsp,%rax,1)
add    $0x20,%rax
cmp    $0x100,%rax
jne    11f0 <cookey+0xe0>
mov    %rsp,%rdi
call   1030 <usekey@plt>
add    $0x108,%rsp
ret

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

LLVM IR (-O2):
define void @cookey(i64* nocapture %0) {
%2 = alloca [32 x i64]
%3 = bitcast [32 x i64]* %2 to i8*
%4 = getelementptr inbounds [32 x i64], [32 x i64]* %2, i64 0, i64 0
%5 = getelementptr inbounds [32 x i64], [32 x i64]* %2, i64 1, i64 0
%6 = getelementptr i64, i64* %0, i64 32
%7 = bitcast i64* %6 to [32 x i64]*
%8 = icmp ult [32 x i64]* %2, %7
%9 = icmp ugt i64* %5, %0
%10 = and i1 %8, %9
br i1 %10, label %46, label %11
11: ; preds = %1, %11
%12 = phi i64 [ %44, %11 ], [ 0, %1 ]
%13 = shl i64 %12, 1
%14 = getelementptr i64, i64* %0, i64 %13
%15 = shl i64 %12, 1
%16 = getelementptr [32 x i64], [32 x i64]* %2, i64 0, i64 %15
%17 = bitcast i64* %14 to <4 x i64>*
%18 = load <4 x i64>, <4 x i64>* %17
%19 = shufflevector <4 x i64> %18, <4 x i64> poison, <2 x i32> <i32 0, i32 2>
%20 = shufflevector <4 x i64> %18, <4 x i64> poison, <2 x i32> <i32 1, i32 3>
%21 = shl <2 x i64> %19, <i64 6, i64 6>
%22 = and <2 x i64> %21, <i64 1056964608, i64 1056964608>
%23 = shl <2 x i64> %19, <i64 10, i64 10>
%24 = and <2 x i64> %23, <i64 4128768, i64 4128768>
%25 = or <2 x i64> %22, %24
%26 = lshr <2 x i64> %20, <i64 10, i64 10>
%27 = and <2 x i64> %26, <i64 16128, i64 16128>
%28 = or <2 x i64> %27, %25
%29 = lshr <2 x i64> %20, <i64 6, i64 6>
%30 = and <2 x i64> %29, <i64 63, i64 63>
%31 = or <2 x i64> %28, %30
%32 = shl <2 x i64> %19, <i64 12, i64 12>
%33 = and <2 x i64> %32, <i64 1056964608, i64 1056964608>
%34 = shl <2 x i64> %19, <i64 16, i64 16>
%35 = and <2 x i64> %34, <i64 4128768, i64 4128768>
%36 = or <2 x i64> %33, %35
%37 = lshr <2 x i64> %20, <i64 4, i64 4>
%38 = and <2 x i64> %37, <i64 16128, i64 16128>
%39 = and <2 x i64> %20, <i64 63, i64 63>
%40 = or <2 x i64> %36, %39
%41 = or <2 x i64> %40, %38
%42 = bitcast i64* %16 to <4 x i64>*
%43 = shufflevector <2 x i64> %31, <2 x i64> %41, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x i64> %43, <4 x i64>* %42
%44 = add nuw i64 %12, 2
%45 = icmp eq i64 %44, 16
br i1 %45, label %79, label %11
46: ; preds = %1, %46
%47 = phi i32 [ %76, %46 ], [ 0, %1 ]
%48 = phi i64* [ %77, %46 ], [ %0, %1 ]
%49 = phi i64* [ %73, %46 ], [ %4, %1 ]
%50 = getelementptr inbounds i64, i64* %48, i64 1
%51 = load i64, i64* %48
%52 = shl i64 %51, 6
%53 = and i64 %52, 1056964608
%54 = shl i64 %51, 10
%55 = and i64 %54, 4128768
%56 = or i64 %53, %55
%57 = load i64, i64* %50
%58 = lshr i64 %57, 10
%59 = and i64 %58, 16128
%60 = or i64 %59, %56
%61 = lshr i64 %57, 6
%62 = and i64 %61, 63
%63 = getelementptr inbounds i64, i64* %49, i64 1
%64 = or i64 %60, %62
store i64 %64, i64* %49
%65 = shl i64 %51, 12
%66 = and i64 %65, 1056964608
%67 = shl i64 %51, 16
%68 = and i64 %67, 4128768
%69 = or i64 %66, %68
%70 = lshr i64 %57, 4
%71 = and i64 %70, 16128
%72 = and i64 %57, 63
%73 = getelementptr inbounds i64, i64* %49, i64 2
%74 = or i64 %69, %72
%75 = or i64 %74, %71
store i64 %75, i64* %63
%76 = add nuw nsw i32 %47, 1
%77 = getelementptr inbounds i64, i64* %48, i64 2
%78 = icmp eq i32 %76, 16
br i1 %78, label %79, label %46
79: ; preds = %11, %46
%80 = call i32 @usekey(i64* %4)
ret void
}