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

/* Variables and functions */
int /*<<< orphan*/ hmac_sha1(unsigned char *, size_t, unsigned char *, int,
                             unsigned char *);
int /*<<< orphan*/ hmac_sha1_vector(unsigned char *, size_t, int,
                                    unsigned char const **, size_t *,
                                    unsigned char *);
int /*<<< orphan*/ memcpy(unsigned char *, unsigned char *, int);
size_t strlen(char const *);
void pbkdf2_sha1_f(const char *passphrase, const char *ssid, size_t ssid_len,
                   int iterations, int count, uint8_t *digest) {
  unsigned char tmp[20], tmp2[20];
  int i, j;
  unsigned char count_buf[4];
  const uint8_t *addr[2];
  size_t len[2];
  size_t passphrase_len = strlen(passphrase);
  addr[0] = (uint8_t *)ssid;
  len[0] = ssid_len;
  addr[1] = count_buf;
  len[1] = 4;
  count_buf[0] = (count >> 24) & 0xff;
  count_buf[1] = (count >> 16) & 0xff;
  count_buf[2] = (count >> 8) & 0xff;
  count_buf[3] = count & 0xff;
  hmac_sha1_vector((uint8_t *)passphrase, passphrase_len, 2, addr, len, tmp);
  memcpy(digest, tmp, 20);
  for (i = 1; i < iterations; i++) {
    uint8_t *pTemp;
    hmac_sha1((uint8_t *)passphrase, passphrase_len, ((i & 0x01) ? tmp : tmp2),
              20, ((i & 0x01) ? tmp2 : tmp));
    pTemp = (i & 0x01) ? tmp2 : tmp;
    for (j = 0; j < 20; j++)
      digest[j] ^= pTemp[j];
  }
}


x86 assembly (clang, -O0):
<pbkdf2_sha1_f>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x98(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x90(%rbp)
lea    -0x6c(%rbp),%rax
mov    %rax,-0x78(%rbp)
movq   $0x4,-0x88(%rbp)
mov    -0x20(%rbp),%eax
sar    $0x18,%eax
and    $0xff,%eax
mov    %al,-0x6c(%rbp)
mov    -0x20(%rbp),%eax
sar    $0x10,%eax
and    $0xff,%eax
mov    %al,-0x6b(%rbp)
mov    -0x20(%rbp),%eax
sar    $0x8,%eax
and    $0xff,%eax
mov    %al,-0x6a(%rbp)
mov    -0x20(%rbp),%eax
and    $0xff,%eax
mov    %al,-0x69(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x98(%rbp),%rsi
lea    -0x80(%rbp),%rcx
lea    -0x90(%rbp),%r8
lea    -0x40(%rbp),%r9
mov    $0x2,%edx
call   1040 <hmac_sha1_vector@plt>
mov    -0x28(%rbp),%rdi
lea    -0x40(%rbp),%rsi
mov    $0x14,%edx
call   1050 <memcpy@plt>
movl   $0x1,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1341 <pbkdf2_sha1_f+0x201>
mov    -0x8(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x64(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     124e <pbkdf2_sha1_f+0x10e>
lea    -0x40(%rbp),%rax
mov    %rax,-0xb8(%rbp)
jmp    1259 <pbkdf2_sha1_f+0x119>
lea    -0x60(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0xb8(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0x64(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1286 <pbkdf2_sha1_f+0x146>
lea    -0x60(%rbp),%rax
mov    %rax,-0xc8(%rbp)
jmp    1291 <pbkdf2_sha1_f+0x151>
lea    -0x40(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0xc0(%rbp),%rdx
mov    -0xa8(%rbp),%rsi
mov    -0xb0(%rbp),%rdi
mov    -0xc8(%rbp),%r8
mov    $0x14,%ecx
call   1060 <hmac_sha1@plt>
mov    -0x64(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     12d6 <pbkdf2_sha1_f+0x196>
lea    -0x60(%rbp),%rax
mov    %rax,-0xd0(%rbp)
jmp    12e1 <pbkdf2_sha1_f+0x1a1>
lea    -0x40(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0xd0(%rbp),%rax
mov    %rax,-0xa0(%rbp)
movl   $0x0,-0x68(%rbp)
cmpl   $0x14,-0x68(%rbp)
jge    132e <pbkdf2_sha1_f+0x1ee>
mov    -0xa0(%rbp),%rax
movslq -0x68(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x28(%rbp),%rax
movslq -0x68(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    12f6 <pbkdf2_sha1_f+0x1b6>
jmp    1333 <pbkdf2_sha1_f+0x1f3>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    120a <pbkdf2_sha1_f+0xca>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<pbkdf2_sha1_f>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %r9,%rbx
mov    %r8d,%ebp
mov    %ecx,%r15d
mov    %rdx,%r13
mov    %rsi,%r14
mov    %rdi,%r12
call   1030 <strlen@plt>
mov    %rax,%rsi
mov    %r14,0x90(%rsp)
mov    %r13,0x80(%rsp)
lea    0x8(%rsp),%rax
mov    %rax,0x98(%rsp)
movq   $0x4,0x88(%rsp)
mov    %ebp,%ecx
mov    %ebp,%eax
shr    $0x18,%eax
mov    %al,0x8(%rsp)
mov    %ebp,%eax
shr    $0x10,%eax
mov    %al,0x9(%rsp)
mov    %ch,0xa(%rsp)
mov    %cl,0xb(%rsp)
lea    0x90(%rsp),%rcx
lea    0x80(%rsp),%r8
lea    0x30(%rsp),%rbp
mov    %r12,0x58(%rsp)
mov    %r12,%rdi
mov    %rsi,0x50(%rsp)
mov    $0x2,%edx
mov    %rbp,%r9
call   1040 <hmac_sha1_vector@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    $0x14,%edx
call   1050 <memcpy@plt>
cmp    $0x2,%r15d
jl     13aa <pbkdf2_sha1_f+0x26a>
mov    $0x1,%r14d
mov    %r15d,0xc(%rsp)
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xor    %r15d,%r15d
test   $0x1,%r14b
mov    %rbp,%rdx
lea    0x10(%rsp),%r13
cmove  %r13,%rdx
cmove  %rbp,%r13
lea    0x11(%rsp),%r12
lea    0x31(%rsp),%rax
cmove  %rax,%r12
lea    0x20(%rsp),%rcx
lea    0x40(%rsp),%rax
cmove  %rax,%rcx
mov    %rcx,0x78(%rsp)
lea    0x21(%rsp),%rcx
lea    0x41(%rsp),%rax
cmove  %rax,%rcx
mov    %rcx,0x70(%rsp)
lea    0x22(%rsp),%rcx
lea    0x42(%rsp),%rax
cmove  %rax,%rcx
mov    %rcx,0x68(%rsp)
sete   %r15b
lea    0x23(%rsp),%rcx
lea    0x43(%rsp),%rax
cmove  %rax,%rcx
mov    %rcx,0x60(%rsp)
mov    0x58(%rsp),%rdi
mov    0x50(%rsp),%rsi
mov    $0x14,%ecx
mov    %r13,%r8
call   1060 <hmac_sha1@plt>
movzwl 0x32(%rsp),%eax
movd   %r15d,%xmm1
mov    0xc(%rsp),%r15d
movzwl 0x12(%rsp),%ecx
punpcklbw %xmm1,%xmm1
movd   %eax,%xmm3
pshuflw $0x0,%xmm1,%xmm4
psllw  $0x7,%xmm1
movdqa 0xd36(%rip),%xmm6
pand   %xmm6,%xmm1
movd   %ecx,%xmm2
pxor   %xmm0,%xmm0
pcmpgtb %xmm1,%xmm0
movd   0x34(%rsp),%xmm1
pand   %xmm0,%xmm3
movd   0x14(%rsp),%xmm5
psllw  $0x7,%xmm4
pand   %xmm6,%xmm4
pandn  %xmm2,%xmm0
pxor   %xmm2,%xmm2
pcmpgtb %xmm4,%xmm2
movdqa %xmm2,%xmm4
pandn  %xmm5,%xmm4
pand   %xmm2,%xmm1
movq   0x38(%rsp),%xmm5
movq   0x18(%rsp),%xmm6
pand   %xmm2,%xmm5
por    %xmm3,%xmm0
pandn  %xmm6,%xmm2
movdqu (%rbx),%xmm8
movdqa 0x0(%r13),%xmm6
por    %xmm4,%xmm1
movzbl (%r12),%eax
movd   %eax,%xmm4
psllw  $0x8,%xmm4
movdqa 0xcc8(%rip),%xmm3
movdqa %xmm3,%xmm7
pandn  %xmm4,%xmm7
pand   %xmm3,%xmm6
por    %xmm6,%xmm7
punpcklwd %xmm0,%xmm7
por    %xmm5,%xmm2
punpckldq %xmm1,%xmm7
punpcklqdq %xmm2,%xmm7
pxor   %xmm8,%xmm7
movdqu %xmm7,(%rbx)
mov    0x78(%rsp),%rax
movzbl (%rax),%eax
xor    %al,0x10(%rbx)
mov    0x70(%rsp),%rax
movzbl (%rax),%eax
xor    %al,0x11(%rbx)
mov    0x68(%rsp),%rax
movzbl (%rax),%eax
xor    %al,0x12(%rbx)
mov    0x60(%rsp),%rax
movzbl (%rax),%eax
xor    %al,0x13(%rbx)
add    $0x1,%r14d
cmp    %r14d,%r15d
jne    1210 <pbkdf2_sha1_f+0xd0>
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @pbkdf2_sha1_f(i8* %0, i8* %1, i64 %2, i32 %3, i32 %4, i8* %5) {
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i64
%10 = alloca i32
%11 = alloca i32
%12 = alloca i8*
%13 = alloca [20 x i8]
%14 = alloca [20 x i8]
%15 = alloca i32
%16 = alloca i32
%17 = alloca [4 x i8]
%18 = alloca [2 x i8*]
%19 = alloca [2 x i64]
%20 = alloca i64
%21 = alloca i8*
store i8* %0, i8** %7
store i8* %1, i8** %8
store i64 %2, i64* %9
store i32 %3, i32* %10
store i32 %4, i32* %11
store i8* %5, i8** %12
%22 = load i8*, i8** %7
%23 = call i64 @strlen(i8* %22)
store i64 %23, i64* %20
%24 = load i8*, i8** %8
%25 = getelementptr inbounds [2 x i8*], [2 x i8*]* %18, i64 0, i64 0
store i8* %24, i8** %25
%26 = load i64, i64* %9
%27 = getelementptr inbounds [2 x i64], [2 x i64]* %19, i64 0, i64 0
store i64 %26, i64* %27
%28 = getelementptr inbounds [4 x i8], [4 x i8]* %17, i64 0, i64 0
%29 = getelementptr inbounds [2 x i8*], [2 x i8*]* %18, i64 0, i64 1
store i8* %28, i8** %29
%30 = getelementptr inbounds [2 x i64], [2 x i64]* %19, i64 0, i64 1
store i64 4, i64* %30
%31 = load i32, i32* %11
%32 = ashr i32 %31, 24
%33 = and i32 %32, 255
%34 = trunc i32 %33 to i8
%35 = getelementptr inbounds [4 x i8], [4 x i8]* %17, i64 0, i64 0
store i8 %34, i8* %35
%36 = load i32, i32* %11
%37 = ashr i32 %36, 16
%38 = and i32 %37, 255
%39 = trunc i32 %38 to i8
%40 = getelementptr inbounds [4 x i8], [4 x i8]* %17, i64 0, i64 1
store i8 %39, i8* %40
%41 = load i32, i32* %11
%42 = ashr i32 %41, 8
%43 = and i32 %42, 255
%44 = trunc i32 %43 to i8
%45 = getelementptr inbounds [4 x i8], [4 x i8]* %17, i64 0, i64 2
store i8 %44, i8* %45
%46 = load i32, i32* %11
%47 = and i32 %46, 255
%48 = trunc i32 %47 to i8
%49 = getelementptr inbounds [4 x i8], [4 x i8]* %17, i64 0, i64 3
store i8 %48, i8* %49
%50 = load i8*, i8** %7
%51 = load i64, i64* %20
%52 = getelementptr inbounds [2 x i8*], [2 x i8*]* %18, i64 0, i64 0
%53 = getelementptr inbounds [2 x i64], [2 x i64]* %19, i64 0, i64 0
%54 = getelementptr inbounds [20 x i8], [20 x i8]* %13, i64 0, i64 0
%55 = call i32 @hmac_sha1_vector(i8* %50, i64 %51, i32 2, i8** %52, i64* %53, i8* %54)
%56 = load i8*, i8** %12
%57 = getelementptr inbounds [20 x i8], [20 x i8]* %13, i64 0, i64 0
%58 = call i32 @memcpy(i8* %56, i8* %57, i32 20)
store i32 1, i32* %15
br label %59
59: ; preds = %116, %6
%60 = load i32, i32* %15
%61 = load i32, i32* %10
%62 = icmp slt i32 %60, %61
br i1 %62, label %63, label %119
63: ; preds = %59
%64 = load i8*, i8** %7
%65 = load i64, i64* %20
%66 = load i32, i32* %15
%67 = and i32 %66, 1
%68 = icmp ne i32 %67, 0
br i1 %68, label %69, label %71
69: ; preds = %63
%70 = getelementptr inbounds [20 x i8], [20 x i8]* %13, i64 0, i64 0
br label %73
71: ; preds = %63
%72 = getelementptr inbounds [20 x i8], [20 x i8]* %14, i64 0, i64 0
br label %73
73: ; preds = %71, %69
%74 = phi i8* [ %70, %69 ], [ %72, %71 ]
%75 = load i32, i32* %15
%76 = and i32 %75, 1
%77 = icmp ne i32 %76, 0
br i1 %77, label %78, label %80
78: ; preds = %73
%79 = getelementptr inbounds [20 x i8], [20 x i8]* %14, i64 0, i64 0
br label %82
80: ; preds = %73
%81 = getelementptr inbounds [20 x i8], [20 x i8]* %13, i64 0, i64 0
br label %82
82: ; preds = %80, %78
%83 = phi i8* [ %79, %78 ], [ %81, %80 ]
%84 = call i32 @hmac_sha1(i8* %64, i64 %65, i8* %74, i32 20, i8* %83)
%85 = load i32, i32* %15
%86 = and i32 %85, 1
%87 = icmp ne i32 %86, 0
br i1 %87, label %88, label %90
88: ; preds = %82
%89 = getelementptr inbounds [20 x i8], [20 x i8]* %14, i64 0, i64 0
br label %92
90: ; preds = %82
%91 = getelementptr inbounds [20 x i8], [20 x i8]* %13, i64 0, i64 0
br label %92
92: ; preds = %90, %88
%93 = phi i8* [ %89, %88 ], [ %91, %90 ]
store i8* %93, i8** %21
store i32 0, i32* %16
br label %94
94: ; preds = %112, %92
%95 = load i32, i32* %16
%96 = icmp slt i32 %95, 20
br i1 %96, label %97, label %115
97: ; preds = %94
%98 = load i8*, i8** %21
%99 = load i32, i32* %16
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds i8, i8* %98, i64 %100
%102 = load i8, i8* %101
%103 = zext i8 %102 to i32
%104 = load i8*, i8** %12
%105 = load i32, i32* %16
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds i8, i8* %104, i64 %106
%108 = load i8, i8* %107
%109 = zext i8 %108 to i32
%110 = xor i32 %109, %103
%111 = trunc i32 %110 to i8
store i8 %111, i8* %107
br label %112
112: ; preds = %97
%113 = load i32, i32* %16
%114 = add nsw i32 %113, 1
store i32 %114, i32* %16
br label %94
115: ; preds = %94
br label %116
116: ; preds = %115
%117 = load i32, i32* %15
%118 = add nsw i32 %117, 1
store i32 %118, i32* %15
br label %59
119: ; preds = %59
ret void
}

LLVM IR (-O2):
define void @pbkdf2_sha1_f(i8* %0, i8* %1, i64 %2, i32 %3, i32 %4, i8* %5) {
%7 = alloca [20 x i8]
%8 = alloca [20 x i8]
%9 = alloca [4 x i8]
%10 = alloca [2 x i8*]
%11 = alloca [2 x i64]
%12 = getelementptr inbounds [20 x i8], [20 x i8]* %7, i64 0, i64 0
%13 = getelementptr inbounds [20 x i8], [20 x i8]* %8, i64 0, i64 0
%14 = getelementptr inbounds [4 x i8], [4 x i8]* %9, i64 0, i64 0
%15 = bitcast [2 x i8*]* %10 to i8*
%16 = bitcast [2 x i64]* %11 to i8*
%17 = tail call i64 @strlen(i8* dereferenceable(1) %0)
%18 = getelementptr inbounds [2 x i8*], [2 x i8*]* %10, i64 0, i64 0
store i8* %1, i8** %18
%19 = getelementptr inbounds [2 x i64], [2 x i64]* %11, i64 0, i64 0
store i64 %2, i64* %19
%20 = getelementptr inbounds [2 x i8*], [2 x i8*]* %10, i64 0, i64 1
store i8* %14, i8** %20
%21 = getelementptr inbounds [2 x i64], [2 x i64]* %11, i64 0, i64 1
store i64 4, i64* %21
%22 = lshr i32 %4, 24
%23 = trunc i32 %22 to i8
store i8 %23, i8* %14
%24 = lshr i32 %4, 16
%25 = trunc i32 %24 to i8
%26 = getelementptr inbounds [4 x i8], [4 x i8]* %9, i64 0, i64 1
store i8 %25, i8* %26
%27 = lshr i32 %4, 8
%28 = trunc i32 %27 to i8
%29 = getelementptr inbounds [4 x i8], [4 x i8]* %9, i64 0, i64 2
store i8 %28, i8* %29
%30 = trunc i32 %4 to i8
%31 = getelementptr inbounds [4 x i8], [4 x i8]* %9, i64 0, i64 3
store i8 %30, i8* %31
%32 = call i32 @hmac_sha1_vector(i8* %0, i64 %17, i32 2, i8** %18, i64* %19, i8* %12)
%33 = call i32 @memcpy(i8* %5, i8* %12, i32 20)
%34 = icmp sgt i32 %3, 1
br i1 %34, label %35, label %122
35: ; preds = %6
%36 = getelementptr inbounds [20 x i8], [20 x i8]* %7, i64 0, i64 1
%37 = getelementptr inbounds [20 x i8], [20 x i8]* %8, i64 0, i64 1
%38 = getelementptr inbounds [20 x i8], [20 x i8]* %7, i64 0, i64 2
%39 = getelementptr inbounds [20 x i8], [20 x i8]* %8, i64 0, i64 2
%40 = getelementptr inbounds [20 x i8], [20 x i8]* %7, i64 0, i64 4
%41 = getelementptr inbounds [20 x i8], [20 x i8]* %8, i64 0, i64 4
%42 = getelementptr inbounds [20 x i8], [20 x i8]* %7, i64 0, i64 8
%43 = getelementptr inbounds [20 x i8], [20 x i8]* %8, i64 0, i64 8
%44 = getelementptr inbounds [20 x i8], [20 x i8]* %7, i64 0, i64 16
%45 = getelementptr inbounds [20 x i8], [20 x i8]* %8, i64 0, i64 16
%46 = getelementptr inbounds i8, i8* %5, i64 16
%47 = getelementptr inbounds [20 x i8], [20 x i8]* %7, i64 0, i64 17
%48 = getelementptr inbounds [20 x i8], [20 x i8]* %8, i64 0, i64 17
%49 = getelementptr inbounds i8, i8* %5, i64 17
%50 = getelementptr inbounds [20 x i8], [20 x i8]* %7, i64 0, i64 18
%51 = getelementptr inbounds [20 x i8], [20 x i8]* %8, i64 0, i64 18
%52 = getelementptr inbounds i8, i8* %5, i64 18
%53 = getelementptr inbounds [20 x i8], [20 x i8]* %7, i64 0, i64 19
%54 = getelementptr inbounds [20 x i8], [20 x i8]* %8, i64 0, i64 19
%55 = getelementptr inbounds i8, i8* %5, i64 19
%56 = bitcast i8* %38 to <2 x i8>*
%57 = bitcast i8* %39 to <2 x i8>*
%58 = bitcast i8* %40 to <4 x i8>*
%59 = bitcast i8* %41 to <4 x i8>*
%60 = bitcast i8* %42 to <8 x i8>*
%61 = bitcast i8* %43 to <8 x i8>*
%62 = bitcast i8* %5 to <16 x i8>*
%63 = bitcast i8* %5 to <16 x i8>*
br label %64
64: ; preds = %35, %64
%65 = phi i32 [ %120, %64 ], [ 1, %35 ]
%66 = and i32 %65, 1
%67 = icmp eq i32 %66, 0
%68 = select i1 %67, i8* %13, i8* %12
%69 = select i1 %67, i8* %12, i8* %13
%70 = call i32 @hmac_sha1(i8* %0, i64 %17, i8* %68, i32 20, i8* %69)
%71 = bitcast i8* %69 to <16 x i8>*
%72 = load <16 x i8>, <16 x i8>* %71
%73 = load i8, i8* %36
%74 = load i8, i8* %37
%75 = select i1 %67, i8 %73, i8 %74
%76 = load <2 x i8>, <2 x i8>* %56
%77 = load <2 x i8>, <2 x i8>* %57
%78 = insertelement <2 x i1> poison, i1 %67, i64 0
%79 = shufflevector <2 x i1> %78, <2 x i1> poison, <2 x i32> zeroinitializer
%80 = select <2 x i1> %79, <2 x i8> %76, <2 x i8> %77
%81 = load <4 x i8>, <4 x i8>* %58
%82 = load <4 x i8>, <4 x i8>* %59
%83 = insertelement <4 x i1> poison, i1 %67, i64 0
%84 = shufflevector <4 x i1> %83, <4 x i1> poison, <4 x i32> zeroinitializer
%85 = select <4 x i1> %84, <4 x i8> %81, <4 x i8> %82
%86 = load <8 x i8>, <8 x i8>* %60
%87 = load <8 x i8>, <8 x i8>* %61
%88 = insertelement <8 x i1> poison, i1 %67, i64 0
%89 = shufflevector <8 x i1> %88, <8 x i1> poison, <8 x i32> zeroinitializer
%90 = select <8 x i1> %89, <8 x i8> %86, <8 x i8> %87
%91 = load <16 x i8>, <16 x i8>* %62
%92 = insertelement <16 x i8> %72, i8 %75, i64 1
%93 = shufflevector <2 x i8> %80, <2 x i8> poison, <16 x i32> <i32 0, i32 1, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%94 = shufflevector <16 x i8> %92, <16 x i8> %93, <16 x i32> <i32 0, i32 1, i32 16, i32 17, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%95 = shufflevector <4 x i8> %85, <4 x i8> poison, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%96 = shufflevector <16 x i8> %94, <16 x i8> %95, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 16, i32 17, i32 18, i32 19, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%97 = shufflevector <8 x i8> %90, <8 x i8> poison, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%98 = shufflevector <16 x i8> %96, <16 x i8> %97, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23>
%99 = xor <16 x i8> %91, %98
store <16 x i8> %99, <16 x i8>* %63
%100 = load i8, i8* %44
%101 = load i8, i8* %45
%102 = select i1 %67, i8 %100, i8 %101
%103 = load i8, i8* %46
%104 = xor i8 %103, %102
store i8 %104, i8* %46
%105 = load i8, i8* %47
%106 = load i8, i8* %48
%107 = select i1 %67, i8 %105, i8 %106
%108 = load i8, i8* %49
%109 = xor i8 %108, %107
store i8 %109, i8* %49
%110 = load i8, i8* %50
%111 = load i8, i8* %51
%112 = select i1 %67, i8 %110, i8 %111
%113 = load i8, i8* %52
%114 = xor i8 %113, %112
store i8 %114, i8* %52
%115 = load i8, i8* %53
%116 = load i8, i8* %54
%117 = select i1 %67, i8 %115, i8 %116
%118 = load i8, i8* %55
%119 = xor i8 %118, %117
store i8 %119, i8* %55
%120 = add nuw nsw i32 %65, 1
%121 = icmp eq i32 %120, %3
br i1 %121, label %122, label %64
122: ; preds = %64, %6
ret void
}