#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 uint32_t;
typedef void *__m128i;

/* Variables and functions */
void *_mm_add_epi32(void *, int /*<<< orphan*/);
void *_mm_or_si128(int /*<<< orphan*/, int /*<<< orphan*/);
void *_mm_set_epi32(int, int, int, int);
int /*<<< orphan*/ _mm_sll_epi32(void *, void *);
int /*<<< orphan*/ _mm_srl_epi32(void *, void *);
void *_mm_xor_si128(void *, int /*<<< orphan*/);
int /*<<< orphan*/ pthread_exit(int /*<<< orphan*/ *);
void *hashMem(void *memPtr) {
  __m128i *mem = (__m128i *)memPtr;
  uint32_t i;
  for (i = 0; i < (16384 / sizeof(__m128i)) * 2; i++) {
    __m128i v = _mm_set_epi32(i, i, i, i);
    mem[i] = v;
  }
  __m128i *prev1 = mem + (16384 / sizeof(__m128i));
  __m128i *prev2 = mem;
  __m128i *to = mem + 2 * (16384 / sizeof(__m128i));
  __m128i shiftRightVal = _mm_set_epi32(25, 25, 25, 25);
  __m128i shiftLeftVal = _mm_set_epi32(7, 7, 7, 7);
  __m128i value1 = shiftRightVal;
  __m128i value2 = shiftRightVal;
  for (i = 2;
       i < (((1LL << 31) / sizeof(__m128i)) / (2 * (16384 / sizeof(__m128i))));
       i++) {
    uint32_t randAddr = *(((uint32_t *)to) - 1);
    __m128i *from = mem + (16384 / sizeof(__m128i)) * (randAddr % i);
    uint32_t j;
    for (j = 0; j < (16384 / sizeof(__m128i)) / 2; j++) {
      value1 = _mm_add_epi32(value1, *prev1++);
      value1 = _mm_add_epi32(value1, *prev2++);
      value1 = _mm_xor_si128(value1, *from++);
      value1 = _mm_or_si128(_mm_srl_epi32(value1, shiftRightVal),
                            _mm_sll_epi32(value1, shiftLeftVal));
      *to++ = value1;
      value2 = _mm_add_epi32(value2, *prev1++);
      value2 = _mm_add_epi32(value2, *prev2++);
      value2 = _mm_xor_si128(value2, *from++);
      value2 = _mm_or_si128(_mm_srl_epi32(value2, shiftRightVal),
                            _mm_sll_epi32(value2, shiftLeftVal));
      *to++ = value2;
    }
  }
  pthread_exit(NULL);
}


x86 assembly (clang, -O0):
<hashMem>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movslq -0x1c(%rbp),%rax
cmp    $0x1000,%rax
jae    11d1 <hashMem+0x61>
mov    -0x1c(%rbp),%edi
mov    -0x1c(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x1c(%rbp),%ecx
call   1030 <_mm_set_epi32@plt>
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    118e <hashMem+0x1e>
mov    -0x18(%rbp),%rax
add    $0x4000,%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
add    $0x8000,%rax
mov    %rax,-0x40(%rbp)
mov    $0x19,%ecx
mov    %ecx,%edi
mov    %ecx,%esi
mov    %ecx,%edx
call   1030 <_mm_set_epi32@plt>
mov    %rax,-0x48(%rbp)
mov    $0x7,%ecx
mov    %ecx,%edi
mov    %ecx,%esi
mov    %ecx,%edx
call   1030 <_mm_set_epi32@plt>
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x60(%rbp)
movl   $0x2,-0x1c(%rbp)
movslq -0x1c(%rbp),%rax
cmp    $0x10000,%rax
jae    13ff <hashMem+0x28f>
mov    -0x40(%rbp),%rax
mov    -0x4(%rax),%eax
mov    %eax,-0x64(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x64(%rbp),%eax
cltd
idivl  -0x1c(%rbp)
mov    -0x80(%rbp),%rax
movslq %edx,%rcx
shl    $0xb,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x74(%rbp)
movslq -0x74(%rbp),%rax
cmp    $0x400,%rax
jae    13ec <hashMem+0x27c>
mov    -0x58(%rbp),%rdi
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%rax
mov    %eax,%esi
call   1040 <_mm_add_epi32@plt>
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rdi
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%rax
mov    %eax,%esi
call   1040 <_mm_add_epi32@plt>
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rdi
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x70(%rbp)
mov    (%rax),%rax
mov    %eax,%esi
call   1070 <_mm_xor_si128@plt>
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rdi
mov    -0x48(%rbp),%rsi
call   1080 <_mm_srl_epi32@plt>
mov    %eax,-0x88(%rbp)
mov    -0x58(%rbp),%rdi
mov    -0x50(%rbp),%rsi
call   1090 <_mm_sll_epi32@plt>
mov    -0x88(%rbp),%edi
mov    %eax,%esi
call   1060 <_mm_or_si128@plt>
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x40(%rbp)
mov    %rcx,(%rax)
mov    -0x60(%rbp),%rdi
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%rax
mov    %eax,%esi
call   1040 <_mm_add_epi32@plt>
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rdi
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%rax
mov    %eax,%esi
call   1040 <_mm_add_epi32@plt>
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rdi
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x70(%rbp)
mov    (%rax),%rax
mov    %eax,%esi
call   1070 <_mm_xor_si128@plt>
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rdi
mov    -0x48(%rbp),%rsi
call   1080 <_mm_srl_epi32@plt>
mov    %eax,-0x84(%rbp)
mov    -0x60(%rbp),%rdi
mov    -0x50(%rbp),%rsi
call   1090 <_mm_sll_epi32@plt>
mov    -0x84(%rbp),%edi
mov    %eax,%esi
call   1060 <_mm_or_si128@plt>
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x40(%rbp)
mov    %rcx,(%rax)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    127a <hashMem+0x10a>
jmp    13f1 <hashMem+0x281>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1234 <hashMem+0xc4>
xor    %eax,%eax
mov    %eax,%edi
call   1050 <pthread_exit@plt>
mov    -0x8(%rbp),%rax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<hashMem>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rdi,%r12
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ebx,%edi
mov    %ebx,%esi
mov    %ebx,%edx
mov    %ebx,%ecx
call   1030 <_mm_set_epi32@plt>
mov    %rax,(%r12,%rbx,8)
add    $0x1,%rbx
cmp    $0x1000,%rbx
jne    1190 <hashMem+0x20>
lea    0x4000(%r12),%rbx
lea    0x8000(%r12),%rax
mov    %rax,(%rsp)
mov    $0x19,%edi
mov    $0x19,%esi
mov    $0x19,%edx
mov    $0x19,%ecx
call   1030 <_mm_set_epi32@plt>
mov    %rax,%r15
mov    $0x7,%edi
mov    $0x7,%esi
mov    $0x7,%edx
mov    $0x7,%ecx
call   1030 <_mm_set_epi32@plt>
mov    %rax,%r14
mov    $0x2,%ecx
mov    %r15,%rsi
mov    %r15,%rbp
mov    %r12,%rax
mov    %r12,0x38(%rsp)
mov    %r14,0x28(%rsp)
mov    %r15,0x20(%rsp)
nopw   0x0(%rax,%rax,1)
mov    %rbx,0x18(%rsp)
mov    %rax,0x8(%rsp)
mov    (%rsp),%rax
mov    -0x4(%rax),%eax
cltd
mov    %ecx,0x14(%rsp)
idiv   %ecx
movslq %edx,%rax
shl    $0xe,%rax
add    %r12,%rax
mov    %rax,0x30(%rsp)
xor    %r12d,%r12d
nopw   0x0(%rax,%rax,1)
mov    %rsi,0x40(%rsp)
mov    0x18(%rsp),%r13
mov    0x0(%r13,%r12,1),%esi
mov    %r15,%rdi
call   1040 <_mm_add_epi32@plt>
mov    0x8(%rsp),%rcx
mov    (%rcx,%r12,1),%esi
mov    %rax,%rdi
call   1040 <_mm_add_epi32@plt>
mov    0x30(%rsp),%rcx
mov    (%rcx,%r12,1),%esi
mov    %rax,%rdi
call   1070 <_mm_xor_si128@plt>
mov    %rax,%rbx
mov    %rax,%rdi
mov    %rbp,%rsi
call   1080 <_mm_srl_epi32@plt>
mov    %eax,%ebp
mov    %rbx,%rdi
mov    %r14,%rsi
call   1090 <_mm_sll_epi32@plt>
mov    %ebp,%edi
mov    %eax,%esi
call   1060 <_mm_or_si128@plt>
mov    %rax,%r15
mov    (%rsp),%r14
mov    %rax,(%r14,%r12,1)
mov    0x8(%r13,%r12,1),%esi
mov    0x40(%rsp),%rdi
call   1040 <_mm_add_epi32@plt>
mov    0x8(%rsp),%rcx
mov    0x8(%rcx,%r12,1),%esi
mov    %rax,%rdi
call   1040 <_mm_add_epi32@plt>
mov    0x30(%rsp),%rcx
mov    0x8(%rcx,%r12,1),%esi
mov    %rax,%rdi
call   1070 <_mm_xor_si128@plt>
mov    %rax,%rbp
mov    %rax,%rdi
mov    0x20(%rsp),%rsi
call   1080 <_mm_srl_epi32@plt>
mov    %eax,%ebx
mov    %rbp,%rdi
mov    0x28(%rsp),%rsi
call   1090 <_mm_sll_epi32@plt>
mov    %ebx,%edi
mov    %eax,%esi
call   1060 <_mm_or_si128@plt>
mov    %rax,%rsi
mov    %rax,0x8(%r14,%r12,1)
mov    0x20(%rsp),%rbp
mov    0x28(%rsp),%r14
add    $0x10,%r12
cmp    $0x4000,%r12d
jne    1250 <hashMem+0xe0>
mov    0x14(%rsp),%ecx
add    $0x1,%ecx
mov    0x18(%rsp),%rbx
add    %r12,%rbx
mov    0x8(%rsp),%rax
add    %r12,%rax
add    %r12,(%rsp)
cmp    $0x10000,%ecx
mov    0x38(%rsp),%r12
jne    1220 <hashMem+0xb0>
xor    %edi,%edi
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <pthread_exit@plt>

LLVM IR (-O0):
define i8* @hashMem(i8* %0) {
%2 = alloca i8*
%3 = alloca i8*
%4 = alloca i8**
%5 = alloca i32
%6 = alloca i8*
%7 = alloca i8**
%8 = alloca i8**
%9 = alloca i8**
%10 = alloca i8*
%11 = alloca i8*
%12 = alloca i8*
%13 = alloca i8*
%14 = alloca i32
%15 = alloca i8**
%16 = alloca i32
store i8* %0, i8** %3
%17 = load i8*, i8** %3
%18 = bitcast i8* %17 to i8**
store i8** %18, i8*** %4
store i32 0, i32* %5
br label %19
19: ; preds = %34, %1
%20 = load i32, i32* %5
%21 = sext i32 %20 to i64
%22 = icmp ult i64 %21, 4096
br i1 %22, label %23, label %37
23: ; preds = %19
%24 = load i32, i32* %5
%25 = load i32, i32* %5
%26 = load i32, i32* %5
%27 = load i32, i32* %5
%28 = call i8* @_mm_set_epi32(i32 %24, i32 %25, i32 %26, i32 %27)
store i8* %28, i8** %6
%29 = load i8*, i8** %6
%30 = load i8**, i8*** %4
%31 = load i32, i32* %5
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds i8*, i8** %30, i64 %32
store i8* %29, i8** %33
br label %34
34: ; preds = %23
%35 = load i32, i32* %5
%36 = add nsw i32 %35, 1
store i32 %36, i32* %5
br label %19
37: ; preds = %19
%38 = load i8**, i8*** %4
%39 = getelementptr inbounds i8*, i8** %38, i64 2048
store i8** %39, i8*** %7
%40 = load i8**, i8*** %4
store i8** %40, i8*** %8
%41 = load i8**, i8*** %4
%42 = getelementptr inbounds i8*, i8** %41, i64 4096
store i8** %42, i8*** %9
%43 = call i8* @_mm_set_epi32(i32 25, i32 25, i32 25, i32 25)
store i8* %43, i8** %10
%44 = call i8* @_mm_set_epi32(i32 7, i32 7, i32 7, i32 7)
store i8* %44, i8** %11
%45 = load i8*, i8** %10
store i8* %45, i8** %12
%46 = load i8*, i8** %10
store i8* %46, i8** %13
store i32 2, i32* %5
br label %47
47: ; preds = %128, %37
%48 = load i32, i32* %5
%49 = sext i32 %48 to i64
%50 = icmp ult i64 %49, 65536
br i1 %50, label %51, label %131
51: ; preds = %47
%52 = load i8**, i8*** %9
%53 = bitcast i8** %52 to i32*
%54 = getelementptr inbounds i32, i32* %53, i64 -1
%55 = load i32, i32* %54
store i32 %55, i32* %14
%56 = load i8**, i8*** %4
%57 = load i32, i32* %14
%58 = load i32, i32* %5
%59 = srem i32 %57, %58
%60 = sext i32 %59 to i64
%61 = mul i64 2048, %60
%62 = getelementptr inbounds i8*, i8** %56, i64 %61
store i8** %62, i8*** %15
store i32 0, i32* %16
br label %63
63: ; preds = %124, %51
%64 = load i32, i32* %16
%65 = sext i32 %64 to i64
%66 = icmp ult i64 %65, 1024
br i1 %66, label %67, label %127
67: ; preds = %63
%68 = load i8*, i8** %12
%69 = load i8**, i8*** %7
%70 = getelementptr inbounds i8*, i8** %69, i32 1
store i8** %70, i8*** %7
%71 = load i8*, i8** %69
%72 = ptrtoint i8* %71 to i32
%73 = call i8* @_mm_add_epi32(i8* %68, i32 %72)
store i8* %73, i8** %12
%74 = load i8*, i8** %12
%75 = load i8**, i8*** %8
%76 = getelementptr inbounds i8*, i8** %75, i32 1
store i8** %76, i8*** %8
%77 = load i8*, i8** %75
%78 = ptrtoint i8* %77 to i32
%79 = call i8* @_mm_add_epi32(i8* %74, i32 %78)
store i8* %79, i8** %12
%80 = load i8*, i8** %12
%81 = load i8**, i8*** %15
%82 = getelementptr inbounds i8*, i8** %81, i32 1
store i8** %82, i8*** %15
%83 = load i8*, i8** %81
%84 = ptrtoint i8* %83 to i32
%85 = call i8* @_mm_xor_si128(i8* %80, i32 %84)
store i8* %85, i8** %12
%86 = load i8*, i8** %12
%87 = load i8*, i8** %10
%88 = call i32 @_mm_srl_epi32(i8* %86, i8* %87)
%89 = load i8*, i8** %12
%90 = load i8*, i8** %11
%91 = call i32 @_mm_sll_epi32(i8* %89, i8* %90)
%92 = call i8* @_mm_or_si128(i32 %88, i32 %91)
store i8* %92, i8** %12
%93 = load i8*, i8** %12
%94 = load i8**, i8*** %9
%95 = getelementptr inbounds i8*, i8** %94, i32 1
store i8** %95, i8*** %9
store i8* %93, i8** %94
%96 = load i8*, i8** %13
%97 = load i8**, i8*** %7
%98 = getelementptr inbounds i8*, i8** %97, i32 1
store i8** %98, i8*** %7
%99 = load i8*, i8** %97
%100 = ptrtoint i8* %99 to i32
%101 = call i8* @_mm_add_epi32(i8* %96, i32 %100)
store i8* %101, i8** %13
%102 = load i8*, i8** %13
%103 = load i8**, i8*** %8
%104 = getelementptr inbounds i8*, i8** %103, i32 1
store i8** %104, i8*** %8
%105 = load i8*, i8** %103
%106 = ptrtoint i8* %105 to i32
%107 = call i8* @_mm_add_epi32(i8* %102, i32 %106)
store i8* %107, i8** %13
%108 = load i8*, i8** %13
%109 = load i8**, i8*** %15
%110 = getelementptr inbounds i8*, i8** %109, i32 1
store i8** %110, i8*** %15
%111 = load i8*, i8** %109
%112 = ptrtoint i8* %111 to i32
%113 = call i8* @_mm_xor_si128(i8* %108, i32 %112)
store i8* %113, i8** %13
%114 = load i8*, i8** %13
%115 = load i8*, i8** %10
%116 = call i32 @_mm_srl_epi32(i8* %114, i8* %115)
%117 = load i8*, i8** %13
%118 = load i8*, i8** %11
%119 = call i32 @_mm_sll_epi32(i8* %117, i8* %118)
%120 = call i8* @_mm_or_si128(i32 %116, i32 %119)
store i8* %120, i8** %13
%121 = load i8*, i8** %13
%122 = load i8**, i8*** %9
%123 = getelementptr inbounds i8*, i8** %122, i32 1
store i8** %123, i8*** %9
store i8* %121, i8** %122
br label %124
124: ; preds = %67
%125 = load i32, i32* %16
%126 = add nsw i32 %125, 1
store i32 %126, i32* %16
br label %63
127: ; preds = %63
br label %128
128: ; preds = %127
%129 = load i32, i32* %5
%130 = add nsw i32 %129, 1
store i32 %130, i32* %5
br label %47
131: ; preds = %47
%132 = call i32 @pthread_exit(i32* null)
%133 = load i8*, i8** %2
ret i8* %133
}

LLVM IR (-O2):
define noalias i8* @hashMem(i8* nocapture %0) {
%2 = bitcast i8* %0 to i8**
br label %3
3: ; preds = %1, %3
%4 = phi i64 [ 0, %1 ], [ %8, %3 ]
%5 = trunc i64 %4 to i32
%6 = tail call i8* @_mm_set_epi32(i32 %5, i32 %5, i32 %5, i32 %5)
%7 = getelementptr inbounds i8*, i8** %2, i64 %4
store i8* %6, i8** %7
%8 = add nuw nsw i64 %4, 1
%9 = icmp eq i64 %8, 4096
br i1 %9, label %10, label %3
10: ; preds = %3
%11 = getelementptr inbounds i8, i8* %0, i64 16384
%12 = bitcast i8* %11 to i8**
%13 = getelementptr inbounds i8, i8* %0, i64 32768
%14 = bitcast i8* %13 to i8**
%15 = tail call i8* @_mm_set_epi32(i32 25, i32 25, i32 25, i32 25)
%16 = tail call i8* @_mm_set_epi32(i32 7, i32 7, i32 7, i32 7)
br label %17
17: ; preds = %10, %79
%18 = phi i32 [ 2, %10 ], [ %80, %79 ]
%19 = phi i8* [ %15, %10 ], [ %75, %79 ]
%20 = phi i8* [ %15, %10 ], [ %56, %79 ]
%21 = phi i8** [ %12, %10 ], [ %58, %79 ]
%22 = phi i8** [ %2, %10 ], [ %63, %79 ]
%23 = phi i8** [ %14, %10 ], [ %76, %79 ]
%24 = bitcast i8** %23 to i32*
%25 = getelementptr inbounds i32, i32* %24, i64 -1
%26 = load i32, i32* %25
%27 = srem i32 %26, %18
%28 = sext i32 %27 to i64
%29 = shl nsw i64 %28, 11
%30 = getelementptr inbounds i8*, i8** %2, i64 %29
br label %31
31: ; preds = %17, %31
%32 = phi i32 [ 0, %17 ], [ %77, %31 ]
%33 = phi i8** [ %30, %17 ], [ %68, %31 ]
%34 = phi i8* [ %19, %17 ], [ %75, %31 ]
%35 = phi i8* [ %20, %17 ], [ %56, %31 ]
%36 = phi i8** [ %21, %17 ], [ %58, %31 ]
%37 = phi i8** [ %22, %17 ], [ %63, %31 ]
%38 = phi i8** [ %23, %17 ], [ %76, %31 ]
%39 = getelementptr inbounds i8*, i8** %36, i64 1
%40 = load i8*, i8** %36
%41 = ptrtoint i8* %40 to i64
%42 = trunc i64 %41 to i32
%43 = tail call i8* @_mm_add_epi32(i8* %35, i32 %42)
%44 = getelementptr inbounds i8*, i8** %37, i64 1
%45 = load i8*, i8** %37
%46 = ptrtoint i8* %45 to i64
%47 = trunc i64 %46 to i32
%48 = tail call i8* @_mm_add_epi32(i8* %43, i32 %47)
%49 = getelementptr inbounds i8*, i8** %33, i64 1
%50 = load i8*, i8** %33
%51 = ptrtoint i8* %50 to i64
%52 = trunc i64 %51 to i32
%53 = tail call i8* @_mm_xor_si128(i8* %48, i32 %52)
%54 = tail call i32 @_mm_srl_epi32(i8* %53, i8* %15)
%55 = tail call i32 @_mm_sll_epi32(i8* %53, i8* %16)
%56 = tail call i8* @_mm_or_si128(i32 %54, i32 %55)
%57 = getelementptr inbounds i8*, i8** %38, i64 1
store i8* %56, i8** %38
%58 = getelementptr inbounds i8*, i8** %36, i64 2
%59 = load i8*, i8** %39
%60 = ptrtoint i8* %59 to i64
%61 = trunc i64 %60 to i32
%62 = tail call i8* @_mm_add_epi32(i8* %34, i32 %61)
%63 = getelementptr inbounds i8*, i8** %37, i64 2
%64 = load i8*, i8** %44
%65 = ptrtoint i8* %64 to i64
%66 = trunc i64 %65 to i32
%67 = tail call i8* @_mm_add_epi32(i8* %62, i32 %66)
%68 = getelementptr inbounds i8*, i8** %33, i64 2
%69 = load i8*, i8** %49
%70 = ptrtoint i8* %69 to i64
%71 = trunc i64 %70 to i32
%72 = tail call i8* @_mm_xor_si128(i8* %67, i32 %71)
%73 = tail call i32 @_mm_srl_epi32(i8* %72, i8* %15)
%74 = tail call i32 @_mm_sll_epi32(i8* %72, i8* %16)
%75 = tail call i8* @_mm_or_si128(i32 %73, i32 %74)
%76 = getelementptr inbounds i8*, i8** %38, i64 2
store i8* %75, i8** %57
%77 = add nuw nsw i32 %32, 1
%78 = icmp eq i32 %77, 1024
br i1 %78, label %79, label %31
79: ; preds = %31
%80 = add nuw nsw i32 %18, 1
%81 = icmp eq i32 %80, 65536
br i1 %81, label %82, label %17
82: ; preds = %79
%83 = tail call i32 @pthread_exit(i32* null)
ret i8* undef
}