#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 uint_fast8_t;
typedef int uint_fast32_t;
typedef int uint64_t;

/* Variables and functions */
int /*<<< orphan*/ softfloat_shortShiftRightJamM(int, int const *, int, int *);
void softfloat_shiftRightJam256M(const uint64_t *aPtr, uint_fast32_t dist,
                                 uint64_t *zPtr) {
  uint64_t wordJam;
  uint_fast32_t wordDist;
  uint64_t *ptr;
  uint_fast8_t i, innerDist;
  wordJam = 0;
  wordDist = dist >> 6;
  if (wordDist) {
    if (4 < wordDist)
      wordDist = 4;
    ptr = (uint64_t *)(aPtr + 0);
    i = wordDist;
    do {
      wordJam = *ptr++;
      if (wordJam)
        break;
      --i;
    } while (i);
    ptr = zPtr;
  }
  if (wordDist < 4) {
    aPtr += (wordDist);
    innerDist = dist & 63;
    if (innerDist) {
      softfloat_shortShiftRightJamM(4 - wordDist, aPtr, innerDist, zPtr + 0);
      if (!wordDist)
        goto wordJam;
    } else {
      aPtr += 0;
      ptr = zPtr + 0;
      for (i = 4 - wordDist; i; --i) {
        *ptr = *aPtr;
        aPtr += 1;
        ptr += 1;
      }
    }
    ptr = zPtr + ((4) - (wordDist));
  }
  do {
    *ptr++ = 0;
    --wordDist;
  } while (wordDist);
wordJam:
  if (wordJam)
    zPtr[0] |= 1;
}


x86 assembly (clang, -O0):
<softfloat_shiftRightJam256M>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
sar    $0x6,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x20(%rbp)
je     119e <softfloat_shiftRightJam256M+0x8e>
mov    $0x4,%eax
cmp    -0x20(%rbp),%eax
jge    1152 <softfloat_shiftRightJam256M+0x42>
movl   $0x4,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
je     1183 <softfloat_shiftRightJam256M+0x73>
jmp    1196 <softfloat_shiftRightJam256M+0x86>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jne    1160 <softfloat_shiftRightJam256M+0x50>
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpl   $0x4,-0x20(%rbp)
jge    1272 <softfloat_shiftRightJam256M+0x162>
mov    -0x20(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    -0xc(%rbp),%eax
and    $0x3f,%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
je     11fc <softfloat_shiftRightJam256M+0xec>
mov    $0x4,%edi
sub    -0x20(%rbp),%edi
mov    -0x8(%rbp),%rsi
mov    -0x30(%rbp),%edx
mov    -0x18(%rbp),%rcx
call   1030 <softfloat_shortShiftRightJamM@plt>
cmpl   $0x0,-0x20(%rbp)
jne    11f7 <softfloat_shiftRightJam256M+0xe7>
jmp    12a4 <softfloat_shiftRightJam256M+0x194>
jmp    1258 <softfloat_shiftRightJam256M+0x148>
mov    -0x8(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    $0x4,%eax
sub    -0x20(%rbp),%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     1253 <softfloat_shiftRightJam256M+0x143>
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x8(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1217 <softfloat_shiftRightJam256M+0x107>
jmp    1258 <softfloat_shiftRightJam256M+0x148>
mov    -0x18(%rbp),%rax
mov    $0x4,%ecx
sub    -0x20(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
jmp    1277 <softfloat_shiftRightJam256M+0x167>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
movl   $0x0,(%rax)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x20(%rbp)
jne    1277 <softfloat_shiftRightJam256M+0x167>
jmp    12a4 <softfloat_shiftRightJam256M+0x194>
cmpl   $0x0,-0x1c(%rbp)
je     12b9 <softfloat_shiftRightJam256M+0x1a9>
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
or     $0x1,%ecx
mov    %ecx,(%rax)
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<softfloat_shiftRightJam256M>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %rdx,%r15
mov    %esi,%ebp
mov    %rdi,%rsi
cmp    $0x40,%ebp
jae    1154 <softfloat_shiftRightJam256M+0x34>
test   %ebp,%ebp
je     11e4 <softfloat_shiftRightJam256M+0xc4>
mov    $0x4,%edi
mov    %ebp,%edx
mov    %r15,%rcx
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <softfloat_shortShiftRightJamM@plt>
mov    %ebp,%r12d
sar    $0x6,%r12d
cmp    $0x100,%ebp
mov    $0x4,%eax
cmovl  %r12d,%eax
cltq
lea    -0x1(%rax),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rsi,%rdx,4),%ebx
test   %ebx,%ebx
jne    1192 <softfloat_shiftRightJam256M+0x72>
lea    0x1(%rdx),%rdi
cmp    %edx,%ecx
mov    %rdi,%rdx
jne    1180 <softfloat_shiftRightJam256M+0x60>
mov    $0x4,%ecx
cmp    $0xff,%ebp
jg     11dc <softfloat_shiftRightJam256M+0xbc>
lea    (%rsi,%rax,4),%rsi
mov    $0x4,%r14d
sub    %r12d,%r14d
mov    %ebp,%edx
and    $0x3f,%edx
je     12bb <softfloat_shiftRightJam256M+0x19b>
mov    %r14d,%edi
mov    %r15,%rcx
call   1040 <softfloat_shortShiftRightJamM@plt>
cmp    $0x40,%ebp
jae    13b6 <softfloat_shiftRightJam256M+0x296>
test   %ebx,%ebx
je     11d3 <softfloat_shiftRightJam256M+0xb3>
orb    $0x1,(%r15)
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r15,%rdi
jmp    13c0 <softfloat_shiftRightJam256M+0x2a0>
xor    %r8d,%r8d
mov    $0x4,%r10d
xor    %ebx,%ebx
lea    -0x1(%r10),%edx
cmp    $0x7,%edx
jb     121a <softfloat_shiftRightJam256M+0xfa>
lea    (%rsi,%rdx,4),%rax
add    $0x4,%rax
cmp    %r15,%rax
jbe    12dc <softfloat_shiftRightJam256M+0x1bc>
lea    (%r15,%rdx,4),%rax
add    $0x4,%rax
cmp    %rax,%rsi
jae    12dc <softfloat_shiftRightJam256M+0x1bc>
mov    %r10d,%ebp
mov    %r15,%rdx
lea    -0x1(%rbp),%r9d
test   $0x7,%bpl
je     1256 <softfloat_shiftRightJam256M+0x136>
mov    %ebp,%eax
and    $0x7,%eax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rsi),%edi
mov    %edi,(%rdx)
add    $0x4,%rsi
add    $0x4,%rdx
add    $0x1,%rcx
cmp    %ecx,%eax
jne    1240 <softfloat_shiftRightJam256M+0x120>
sub    %ecx,%ebp
cmp    $0x7,%r9d
jb     13b0 <softfloat_shiftRightJam256M+0x290>
mov    %ebp,%eax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rsi,%rcx,4),%edi
mov    %edi,(%rdx,%rcx,4)
mov    0x4(%rsi,%rcx,4),%edi
mov    %edi,0x4(%rdx,%rcx,4)
mov    0x8(%rsi,%rcx,4),%edi
mov    %edi,0x8(%rdx,%rcx,4)
mov    0xc(%rsi,%rcx,4),%edi
mov    %edi,0xc(%rdx,%rcx,4)
mov    0x10(%rsi,%rcx,4),%edi
mov    %edi,0x10(%rdx,%rcx,4)
mov    0x14(%rsi,%rcx,4),%edi
mov    %edi,0x14(%rdx,%rcx,4)
mov    0x18(%rsi,%rcx,4),%edi
mov    %edi,0x18(%rdx,%rcx,4)
mov    0x1c(%rsi,%rcx,4),%edi
mov    %edi,0x1c(%rdx,%rcx,4)
add    $0x8,%rcx
cmp    %ecx,%eax
jne    1270 <softfloat_shiftRightJam256M+0x150>
jmp    13b0 <softfloat_shiftRightJam256M+0x290>
mov    %r14d,%r10d
mov    %r12d,%r8d
mov    $0x0,%r14d
cmp    $0x4,%r12d
mov    $0x4,%r12d
jne    11ef <softfloat_shiftRightJam256M+0xcf>
jmp    13b6 <softfloat_shiftRightJam256M+0x296>
add    $0x1,%rdx
mov    %rdx,%r9
and    $0xfffffffffffffff8,%r9
lea    -0x8(%r9),%rdi
mov    %rdi,%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %eax,%ecx
and    $0x3,%ecx
cmp    $0x18,%rdi
jae    1305 <softfloat_shiftRightJam256M+0x1e5>
xor    %edi,%edi
jmp    1370 <softfloat_shiftRightJam256M+0x250>
and    $0xfffffffffffffffc,%rax
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups (%rsi,%rdi,4),%xmm0
movups 0x10(%rsi,%rdi,4),%xmm1
movups %xmm0,(%r15,%rdi,4)
movups %xmm1,0x10(%r15,%rdi,4)
movups 0x20(%rsi,%rdi,4),%xmm0
movups 0x30(%rsi,%rdi,4),%xmm1
movups %xmm0,0x20(%r15,%rdi,4)
movups %xmm1,0x30(%r15,%rdi,4)
movups 0x40(%rsi,%rdi,4),%xmm0
movups 0x50(%rsi,%rdi,4),%xmm1
movups %xmm0,0x40(%r15,%rdi,4)
movups %xmm1,0x50(%r15,%rdi,4)
movups 0x60(%rsi,%rdi,4),%xmm0
movups 0x70(%rsi,%rdi,4),%xmm1
movups %xmm0,0x60(%r15,%rdi,4)
movups %xmm1,0x70(%r15,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rax
jne    1310 <softfloat_shiftRightJam256M+0x1f0>
test   %rcx,%rcx
je     13ab <softfloat_shiftRightJam256M+0x28b>
lea    (%r15,%rdi,4),%rax
add    $0x10,%rax
lea    (%rsi,%rdi,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rcx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rax,%rbp,1)
movups %xmm1,(%rax,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rcx
jne    1390 <softfloat_shiftRightJam256M+0x270>
cmp    %r9,%rdx
jne    13df <softfloat_shiftRightJam256M+0x2bf>
mov    %r8d,%r12d
mov    %r10d,%r14d
mov    %r14d,%eax
lea    (%r15,%rax,4),%rdi
mov    %r12d,%ecx
add    $0xffffffff,%ecx
lea    0x4(,%rcx,4),%rdx
xor    %esi,%esi
call   1030 <memset@plt>
test   %ebx,%ebx
jne    11cf <softfloat_shiftRightJam256M+0xaf>
jmp    11d3 <softfloat_shiftRightJam256M+0xb3>
lea    (%rsi,%r9,4),%rsi
mov    %r10d,%ebp
sub    %r9d,%ebp
lea    (%r15,%r9,4),%rdx
jmp    1220 <softfloat_shiftRightJam256M+0x100>

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

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