void put_ccode_box(unsigned int *pixels, int x1, int x2, int y1, int y2,
                   int width, unsigned int color, unsigned int linecolor) {
  int x, y, i;
  i = x1 + y1 * width;
  for (x = x1; x < x2; x++) {
    pixels[i++] |= linecolor;
  }
  for (y = y1 + 1; y < y2 - 1; y++) {
    i = x1 + y * width;
    pixels[i++] |= linecolor;
    for (x = x1 + 1; x < x2 - 1; x++) {
      pixels[i++] += color;
    }
    pixels[i++] |= linecolor;
  }
  i = x1 + (y2 - 1) * width;
  for (x = x1; x < x2; x++) {
    pixels[i++] |= linecolor;
  }
}


x86 assembly (clang, -O0):
<put_ccode_box>:
push   %rbp
mov    %rsp,%rbp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9d,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1169 <put_ccode_box+0x69>
mov    0x18(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1134 <put_ccode_box+0x34>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1219 <put_ccode_box+0x119>
mov    -0xc(%rbp),%eax
mov    -0x24(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    0x18(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    11f0 <put_ccode_box+0xf0>
mov    0x10(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
movslq %ecx,%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11b6 <put_ccode_box+0xb6>
mov    0x18(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1172 <put_ccode_box+0x72>
mov    -0xc(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x1c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1266 <put_ccode_box+0x166>
mov    0x18(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1231 <put_ccode_box+0x131>
pop    %rbp
ret

x86 assembly (clang, -O2):
<put_ccode_box>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    0x40(%rsp),%ebx
mov    %esi,%r15d
not    %r15d
cmp    %edx,%esi
mov    %rdx,-0x58(%rsp)
mov    %r9d,-0x5c(%rsp)
jge    123b <put_ccode_box+0x13b>
mov    %r9d,%eax
imul   %ecx,%eax
add    %esi,%eax
movslq %eax,%r10
lea    (%r15,%rdx,1),%r9d
cmp    $0x7,%r9d
jae    1147 <put_ccode_box+0x47>
mov    %esi,%ebp
mov    -0x5c(%rsp),%r9d
jmp    121b <put_ccode_box+0x11b>
add    $0x1,%r9
mov    %r9,%r11
movabs $0x1fffffff8,%rax
and    %rax,%r11
movd   0x40(%rsp),%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%r11),%rdx
mov    %rdx,%rax
shr    $0x3,%rax
add    $0x1,%rax
test   %rdx,%rdx
je     11da <put_ccode_box+0xda>
mov    %rax,%rbx
and    $0xfffffffffffffffe,%rbx
lea    (%rdi,%r10,4),%rdx
add    $0x30,%rdx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movdqu -0x30(%rdx,%rbp,4),%xmm1
movdqu -0x20(%rdx,%rbp,4),%xmm2
movdqu -0x10(%rdx,%rbp,4),%xmm3
movdqu (%rdx,%rbp,4),%xmm4
por    %xmm0,%xmm1
por    %xmm0,%xmm2
movdqu %xmm1,-0x30(%rdx,%rbp,4)
movdqu %xmm2,-0x20(%rdx,%rbp,4)
por    %xmm0,%xmm3
por    %xmm0,%xmm4
movdqu %xmm3,-0x10(%rdx,%rbp,4)
movdqu %xmm4,(%rdx,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rbx
jne    1190 <put_ccode_box+0x90>
jmp    11dc <put_ccode_box+0xdc>
xor    %ebp,%ebp
test   $0x1,%al
mov    -0x58(%rsp),%rdx
je     1206 <put_ccode_box+0x106>
add    %r10,%rbp
movdqu (%rdi,%rbp,4),%xmm1
movdqu 0x10(%rdi,%rbp,4),%xmm2
por    %xmm0,%xmm1
por    %xmm0,%xmm2
movdqu %xmm1,(%rdi,%rbp,4)
movdqu %xmm2,0x10(%rdi,%rbp,4)
cmp    %r11,%r9
mov    -0x5c(%rsp),%r9d
mov    0x40(%rsp),%ebx
je     123b <put_ccode_box+0x13b>
add    %r11,%r10
lea    (%r11,%rsi,1),%ebp
lea    (%rdi,%r10,4),%rax
sub    %ebp,%edx
xor    %ebp,%ebp
mov    0x40(%rsp),%ebx
nopw   0x0(%rax,%rax,1)
or     %ebx,(%rax,%rbp,4)
add    $0x1,%rbp
cmp    %ebp,%edx
jne    1230 <put_ccode_box+0x130>
mov    %r15,-0x40(%rsp)
mov    %rsi,-0x48(%rsp)
add    $0xffffffff,%r8d
add    $0x1,%ecx
cmp    %r8d,%ecx
mov    %ebx,%r11d
jge    143d <put_ccode_box+0x33d>
mov    0x38(%rsp),%ebx
mov    -0x58(%rsp),%rdx
lea    -0x1(%rdx),%r13d
mov    -0x48(%rsp),%r10
lea    0x1(%r10),%r15d
movslq %ecx,%rax
imul   %r9d,%ecx
add    %r10d,%ecx
add    $0x1,%ecx
movslq %r9d,%r12
movslq %r10d,%r14
mov    %edx,%ebp
sub    %r10d,%ebp
add    $0xfffffffd,%ebp
lea    0x1(%rbp),%rdx
mov    %rdx,-0x10(%rsp)
mov    %r8d,-0x50(%rsp)
mov    %rdx,%r8
movabs $0x1fffffff8,%rdx
and    %rdx,%r8
lea    -0x8(%r8),%rsi
mov    %rsi,-0x20(%rsp)
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %r8,-0x18(%rsp)
lea    (%r10,%r8,1),%edx
add    $0x1,%edx
mov    %edx,-0x4c(%rsp)
mov    -0x50(%rsp),%r8d
movd   %ebx,%xmm0
pshufd $0x0,%xmm0,%xmm0
mov    %rsi,%rdx
mov    %rsi,-0x28(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,-0x30(%rsp)
lea    0x30(%rdi),%rdx
mov    %rdx,-0x38(%rsp)
mov    %rbp,-0x8(%rsp)
jmp    131f <put_ccode_box+0x21f>
nopw   0x0(%rax,%rax,1)
lea    (%rdx,%r14,1),%r10
add    $0x1,%r10
movslq %r10d,%rdx
or     %r11d,(%rdi,%rdx,4)
add    $0x1,%rax
add    %r9d,%ecx
cmp    %eax,%r8d
je     143d <put_ccode_box+0x33d>
mov    %rax,%rdx
imul   %r12,%rdx
lea    (%rdx,%r14,1),%rsi
or     %r11d,(%rdi,%rsi,4)
cmp    %r13d,%r15d
jge    1300 <put_ccode_box+0x200>
movslq %ecx,%r10
cmp    $0x7,%ebp
jae    1350 <put_ccode_box+0x250>
mov    %r15d,%edx
jmp    140e <put_ccode_box+0x30e>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmpq   $0x0,-0x20(%rsp)
je     1432 <put_ccode_box+0x332>
mov    -0x38(%rsp),%rdx
lea    (%rdx,%r10,4),%r11
mov    -0x30(%rsp),%r9
xor    %esi,%esi
nopl   0x0(%rax)
movdqu -0x30(%r11,%rsi,4),%xmm1
movdqu -0x20(%r11,%rsi,4),%xmm2
movdqu -0x10(%r11,%rsi,4),%xmm3
movdqu (%r11,%rsi,4),%xmm4
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm2
movdqu %xmm1,-0x30(%r11,%rsi,4)
movdqu %xmm2,-0x20(%r11,%rsi,4)
paddd  %xmm0,%xmm3
paddd  %xmm0,%xmm4
movdqu %xmm3,-0x10(%r11,%rsi,4)
movdqu %xmm4,(%r11,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%r9
jne    1370 <put_ccode_box+0x270>
testb  $0x1,-0x28(%rsp)
je     13e8 <put_ccode_box+0x2e8>
add    %r10,%rsi
movdqu (%rdi,%rsi,4),%xmm1
movdqu 0x10(%rdi,%rsi,4),%xmm2
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm2
movdqu %xmm1,(%rdi,%rsi,4)
movdqu %xmm2,0x10(%rdi,%rsi,4)
mov    -0x18(%rsp),%rsi
add    %rsi,%r10
mov    -0x4c(%rsp),%edx
cmp    %rsi,-0x10(%rsp)
mov    -0x5c(%rsp),%r9d
mov    -0x8(%rsp),%rbp
mov    0x40(%rsp),%r11d
je     1308 <put_ccode_box+0x208>
mov    %r13d,%esi
sub    %edx,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    %ebx,(%rdi,%r10,4)
add    $0x1,%r10
add    $0xffffffff,%esi
jne    1420 <put_ccode_box+0x320>
jmp    1308 <put_ccode_box+0x208>
xor    %esi,%esi
testb  $0x1,-0x28(%rsp)
jne    13c7 <put_ccode_box+0x2c7>
jmp    13e8 <put_ccode_box+0x2e8>
mov    -0x58(%rsp),%rbx
mov    -0x48(%rsp),%r10
cmp    %ebx,%r10d
jge    155c <put_ccode_box+0x45c>
imul   %r9d,%r8d
add    %r10d,%r8d
movslq %r8d,%r8
mov    -0x40(%rsp),%rdx
add    %ebx,%edx
cmp    $0x7,%edx
jb     153a <put_ccode_box+0x43a>
add    $0x1,%rdx
movabs $0x1fffffff8,%rax
and    %rdx,%rax
movd   %r11d,%xmm0
pshufd $0x0,%xmm0,%xmm0
mov    %rax,%r9
lea    -0x8(%rax),%rcx
mov    %rcx,%rax
shr    $0x3,%rax
add    $0x1,%rax
test   %rcx,%rcx
je     1567 <put_ccode_box+0x467>
mov    %rax,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%rdi,%r8,4),%rbp
add    $0x30,%rbp
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu -0x30(%rbp,%rcx,4),%xmm1
movdqu -0x20(%rbp,%rcx,4),%xmm2
movdqu -0x10(%rbp,%rcx,4),%xmm3
movdqu 0x0(%rbp,%rcx,4),%xmm4
por    %xmm0,%xmm1
por    %xmm0,%xmm2
movdqu %xmm1,-0x30(%rbp,%rcx,4)
movdqu %xmm2,-0x20(%rbp,%rcx,4)
por    %xmm0,%xmm3
por    %xmm0,%xmm4
movdqu %xmm3,-0x10(%rbp,%rcx,4)
movdqu %xmm4,0x0(%rbp,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    14c0 <put_ccode_box+0x3c0>
test   $0x1,%al
je     152f <put_ccode_box+0x42f>
add    %r8,%rcx
movdqu (%rdi,%rcx,4),%xmm1
movdqu 0x10(%rdi,%rcx,4),%xmm2
por    %xmm0,%xmm1
por    %xmm0,%xmm2
movdqu %xmm1,(%rdi,%rcx,4)
movdqu %xmm2,0x10(%rdi,%rcx,4)
cmp    %r9,%rdx
je     155c <put_ccode_box+0x45c>
add    %r9,%r8
add    %r9d,%r10d
lea    (%rdi,%r8,4),%rax
sub    %r10d,%ebx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
or     %r11d,(%rax,%rcx,4)
add    $0x1,%rcx
cmp    %ecx,%ebx
jne    1550 <put_ccode_box+0x450>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ecx,%ecx
test   $0x1,%al
jne    150e <put_ccode_box+0x40e>
jmp    152f <put_ccode_box+0x42f>

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

LLVM IR (-O2):
define void @put_ccode_box(i32* nocapture %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6, i32 %7) {
%9 = icmp slt i32 %1, %2
br i1 %9, label %10, label %84
10: ; preds = %8
%11 = mul nsw i32 %5, %3
%12 = add i32 %11, %1
%13 = sext i32 %12 to i64
%14 = xor i32 %1, -1
%15 = add i32 %14, %2
%16 = zext i32 %15 to i64
%17 = add nuw nsw i64 %16, 1
%18 = icmp ult i32 %15, 7
br i1 %18, label %81, label %19
19: ; preds = %10
%20 = and i64 %17, 8589934584
%21 = add nsw i64 %20, %13
%22 = trunc i64 %20 to i32
%23 = add i32 %22, %1
%24 = insertelement <4 x i32> poison, i32 %7, i64 0
%25 = shufflevector <4 x i32> %24, <4 x i32> poison, <4 x i32> zeroinitializer
%26 = insertelement <4 x i32> poison, i32 %7, i64 0
%27 = shufflevector <4 x i32> %26, <4 x i32> poison, <4 x i32> zeroinitializer
%28 = add nsw i64 %20, -8
%29 = lshr exact i64 %28, 3
%30 = add nuw nsw i64 %29, 1
%31 = and i64 %30, 1
%32 = icmp eq i64 %28, 0
br i1 %32, label %64, label %33
33: ; preds = %19
%34 = and i64 %30, 4611686018427387902
br label %35
35: ; preds = %35, %33
%36 = phi i64 [ 0, %33 ], [ %61, %35 ]
%37 = phi i64 [ 0, %33 ], [ %62, %35 ]
%38 = add i64 %36, %13
%39 = getelementptr inbounds i32, i32* %0, i64 %38
%40 = bitcast i32* %39 to <4 x i32>*
%41 = load <4 x i32>, <4 x i32>* %40
%42 = getelementptr inbounds i32, i32* %39, i64 4
%43 = bitcast i32* %42 to <4 x i32>*
%44 = load <4 x i32>, <4 x i32>* %43
%45 = or <4 x i32> %41, %25
%46 = or <4 x i32> %44, %27
%47 = bitcast i32* %39 to <4 x i32>*
store <4 x i32> %45, <4 x i32>* %47
%48 = bitcast i32* %42 to <4 x i32>*
store <4 x i32> %46, <4 x i32>* %48
%49 = or i64 %36, 8
%50 = add i64 %49, %13
%51 = getelementptr inbounds i32, i32* %0, i64 %50
%52 = bitcast i32* %51 to <4 x i32>*
%53 = load <4 x i32>, <4 x i32>* %52
%54 = getelementptr inbounds i32, i32* %51, i64 4
%55 = bitcast i32* %54 to <4 x i32>*
%56 = load <4 x i32>, <4 x i32>* %55
%57 = or <4 x i32> %53, %25
%58 = or <4 x i32> %56, %27
%59 = bitcast i32* %51 to <4 x i32>*
store <4 x i32> %57, <4 x i32>* %59
%60 = bitcast i32* %54 to <4 x i32>*
store <4 x i32> %58, <4 x i32>* %60
%61 = add nuw i64 %36, 16
%62 = add i64 %37, 2
%63 = icmp eq i64 %62, %34
br i1 %63, label %64, label %35
64: ; preds = %35, %19
%65 = phi i64 [ 0, %19 ], [ %61, %35 ]
%66 = icmp eq i64 %31, 0
br i1 %66, label %79, label %67
67: ; preds = %64
%68 = add i64 %65, %13
%69 = getelementptr inbounds i32, i32* %0, i64 %68
%70 = bitcast i32* %69 to <4 x i32>*
%71 = load <4 x i32>, <4 x i32>* %70
%72 = getelementptr inbounds i32, i32* %69, i64 4
%73 = bitcast i32* %72 to <4 x i32>*
%74 = load <4 x i32>, <4 x i32>* %73
%75 = or <4 x i32> %71, %25
%76 = or <4 x i32> %74, %27
%77 = bitcast i32* %69 to <4 x i32>*
store <4 x i32> %75, <4 x i32>* %77
%78 = bitcast i32* %72 to <4 x i32>*
store <4 x i32> %76, <4 x i32>* %78
br label %79
79: ; preds = %64, %67
%80 = icmp eq i64 %17, %20
br i1 %80, label %84, label %81
81: ; preds = %10, %79
%82 = phi i64 [ %13, %10 ], [ %21, %79 ]
%83 = phi i32 [ %1, %10 ], [ %23, %79 ]
br label %119
84: ; preds = %119, %79, %8
%85 = add i32 %4, -1
%86 = add i32 %3, 1
%87 = icmp slt i32 %86, %85
br i1 %87, label %88, label %208
88: ; preds = %84
%89 = add i32 %2, -1
%90 = add nsw i32 %1, 1
%91 = icmp slt i32 %90, %89
%92 = mul i32 %86, %5
%93 = add i32 %92, %1
%94 = add i32 %93, 1
%95 = sext i32 %86 to i64
%96 = sext i32 %5 to i64
%97 = sext i32 %1 to i64
%98 = add i32 %2, -3
%99 = sub i32 %98, %1
%100 = zext i32 %99 to i64
%101 = add nuw nsw i64 %100, 1
%102 = and i64 %101, 8589934584
%103 = add nsw i64 %102, -8
%104 = lshr exact i64 %103, 3
%105 = add nuw nsw i64 %104, 1
%106 = icmp ult i32 %99, 7
%107 = and i64 %101, 8589934584
%108 = trunc i64 %107 to i32
%109 = add i32 %90, %108
%110 = insertelement <4 x i32> poison, i32 %6, i64 0
%111 = shufflevector <4 x i32> %110, <4 x i32> poison, <4 x i32> zeroinitializer
%112 = insertelement <4 x i32> poison, i32 %6, i64 0
%113 = shufflevector <4 x i32> %112, <4 x i32> poison, <4 x i32> zeroinitializer
%114 = and i64 %105, 1
%115 = icmp eq i64 %103, 0
%116 = and i64 %105, 4611686018427387902
%117 = icmp eq i64 %114, 0
%118 = icmp eq i64 %101, %107
br label %128
119: ; preds = %81, %119
%120 = phi i64 [ %122, %119 ], [ %82, %81 ]
%121 = phi i32 [ %126, %119 ], [ %83, %81 ]
%122 = add nsw i64 %120, 1
%123 = getelementptr inbounds i32, i32* %0, i64 %120
%124 = load i32, i32* %123
%125 = or i32 %124, %7
store i32 %125, i32* %123
%126 = add nsw i32 %121, 1
%127 = icmp eq i32 %126, %2
br i1 %127, label %84, label %119
128: ; preds = %88, %197
%129 = phi i64 [ %95, %88 ], [ %204, %197 ]
%130 = phi i32 [ %94, %88 ], [ %205, %197 ]
%131 = mul nsw i64 %129, %96
%132 = add nsw i64 %131, %97
%133 = getelementptr inbounds i32, i32* %0, i64 %132
%134 = load i32, i32* %133
%135 = or i32 %134, %7
store i32 %135, i32* %133
%136 = add i64 %132, 1
br i1 %91, label %137, label %197
137: ; preds = %128
%138 = sext i32 %130 to i64
br i1 %106, label %185, label %139
139: ; preds = %137
%140 = add nsw i64 %107, %138
br i1 %115, label %170, label %141
141: ; preds = %139, %141
%142 = phi i64 [ %167, %141 ], [ 0, %139 ]
%143 = phi i64 [ %168, %141 ], [ 0, %139 ]
%144 = add i64 %142, %138
%145 = getelementptr inbounds i32, i32* %0, i64 %144
%146 = bitcast i32* %145 to <4 x i32>*
%147 = load <4 x i32>, <4 x i32>* %146
%148 = getelementptr inbounds i32, i32* %145, i64 4
%149 = bitcast i32* %148 to <4 x i32>*
%150 = load <4 x i32>, <4 x i32>* %149
%151 = add <4 x i32> %147, %111
%152 = add <4 x i32> %150, %113
%153 = bitcast i32* %145 to <4 x i32>*
store <4 x i32> %151, <4 x i32>* %153
%154 = bitcast i32* %148 to <4 x i32>*
store <4 x i32> %152, <4 x i32>* %154
%155 = or i64 %142, 8
%156 = add i64 %155, %138
%157 = getelementptr inbounds i32, i32* %0, i64 %156
%158 = bitcast i32* %157 to <4 x i32>*
%159 = load <4 x i32>, <4 x i32>* %158
%160 = getelementptr inbounds i32, i32* %157, i64 4
%161 = bitcast i32* %160 to <4 x i32>*
%162 = load <4 x i32>, <4 x i32>* %161
%163 = add <4 x i32> %159, %111
%164 = add <4 x i32> %162, %113
%165 = bitcast i32* %157 to <4 x i32>*
store <4 x i32> %163, <4 x i32>* %165
%166 = bitcast i32* %160 to <4 x i32>*
store <4 x i32> %164, <4 x i32>* %166
%167 = add nuw i64 %142, 16
%168 = add i64 %143, 2
%169 = icmp eq i64 %168, %116
br i1 %169, label %170, label %141
170: ; preds = %141, %139
%171 = phi i64 [ 0, %139 ], [ %167, %141 ]
br i1 %117, label %184, label %172
172: ; preds = %170
%173 = add i64 %171, %138
%174 = getelementptr inbounds i32, i32* %0, i64 %173
%175 = bitcast i32* %174 to <4 x i32>*
%176 = load <4 x i32>, <4 x i32>* %175
%177 = getelementptr inbounds i32, i32* %174, i64 4
%178 = bitcast i32* %177 to <4 x i32>*
%179 = load <4 x i32>, <4 x i32>* %178
%180 = add <4 x i32> %176, %111
%181 = add <4 x i32> %179, %113
%182 = bitcast i32* %174 to <4 x i32>*
store <4 x i32> %180, <4 x i32>* %182
%183 = bitcast i32* %177 to <4 x i32>*
store <4 x i32> %181, <4 x i32>* %183
br label %184
184: ; preds = %170, %172
br i1 %118, label %197, label %185
185: ; preds = %137, %184
%186 = phi i64 [ %138, %137 ], [ %140, %184 ]
%187 = phi i32 [ %90, %137 ], [ %109, %184 ]
br label %188
188: ; preds = %185, %188
%189 = phi i64 [ %194, %188 ], [ %186, %185 ]
%190 = phi i32 [ %195, %188 ], [ %187, %185 ]
%191 = getelementptr inbounds i32, i32* %0, i64 %189
%192 = load i32, i32* %191
%193 = add i32 %192, %6
store i32 %193, i32* %191
%194 = add nsw i64 %189, 1
%195 = add nsw i32 %190, 1
%196 = icmp eq i32 %195, %89
br i1 %196, label %197, label %188
197: ; preds = %188, %184, %128
%198 = phi i64 [ %136, %128 ], [ %140, %184 ], [ %194, %188 ]
%199 = shl i64 %198, 32
%200 = ashr exact i64 %199, 32
%201 = getelementptr inbounds i32, i32* %0, i64 %200
%202 = load i32, i32* %201
%203 = or i32 %202, %7
store i32 %203, i32* %201
%204 = add nsw i64 %129, 1
%205 = add i32 %130, %5
%206 = trunc i64 %204 to i32
%207 = icmp eq i32 %85, %206
br i1 %207, label %208, label %128
208: ; preds = %197, %84
br i1 %9, label %209, label %292
209: ; preds = %208
%210 = mul nsw i32 %85, %5
%211 = add i32 %210, %1
%212 = sext i32 %211 to i64
%213 = xor i32 %1, -1
%214 = add i32 %213, %2
%215 = zext i32 %214 to i64
%216 = add nuw nsw i64 %215, 1
%217 = icmp ult i32 %214, 7
br i1 %217, label %280, label %218
218: ; preds = %209
%219 = and i64 %216, 8589934584
%220 = add nsw i64 %219, %212
%221 = trunc i64 %219 to i32
%222 = add i32 %221, %1
%223 = insertelement <4 x i32> poison, i32 %7, i64 0
%224 = shufflevector <4 x i32> %223, <4 x i32> poison, <4 x i32> zeroinitializer
%225 = insertelement <4 x i32> poison, i32 %7, i64 0
%226 = shufflevector <4 x i32> %225, <4 x i32> poison, <4 x i32> zeroinitializer
%227 = add nsw i64 %219, -8
%228 = lshr exact i64 %227, 3
%229 = add nuw nsw i64 %228, 1
%230 = and i64 %229, 1
%231 = icmp eq i64 %227, 0
br i1 %231, label %263, label %232
232: ; preds = %218
%233 = and i64 %229, 4611686018427387902
br label %234
234: ; preds = %234, %232
%235 = phi i64 [ 0, %232 ], [ %260, %234 ]
%236 = phi i64 [ 0, %232 ], [ %261, %234 ]
%237 = add i64 %235, %212
%238 = getelementptr inbounds i32, i32* %0, i64 %237
%239 = bitcast i32* %238 to <4 x i32>*
%240 = load <4 x i32>, <4 x i32>* %239
%241 = getelementptr inbounds i32, i32* %238, i64 4
%242 = bitcast i32* %241 to <4 x i32>*
%243 = load <4 x i32>, <4 x i32>* %242
%244 = or <4 x i32> %240, %224
%245 = or <4 x i32> %243, %226
%246 = bitcast i32* %238 to <4 x i32>*
store <4 x i32> %244, <4 x i32>* %246
%247 = bitcast i32* %241 to <4 x i32>*
store <4 x i32> %245, <4 x i32>* %247
%248 = or i64 %235, 8
%249 = add i64 %248, %212
%250 = getelementptr inbounds i32, i32* %0, i64 %249
%251 = bitcast i32* %250 to <4 x i32>*
%252 = load <4 x i32>, <4 x i32>* %251
%253 = getelementptr inbounds i32, i32* %250, i64 4
%254 = bitcast i32* %253 to <4 x i32>*
%255 = load <4 x i32>, <4 x i32>* %254
%256 = or <4 x i32> %252, %224
%257 = or <4 x i32> %255, %226
%258 = bitcast i32* %250 to <4 x i32>*
store <4 x i32> %256, <4 x i32>* %258
%259 = bitcast i32* %253 to <4 x i32>*
store <4 x i32> %257, <4 x i32>* %259
%260 = add nuw i64 %235, 16
%261 = add i64 %236, 2
%262 = icmp eq i64 %261, %233
br i1 %262, label %263, label %234
263: ; preds = %234, %218
%264 = phi i64 [ 0, %218 ], [ %260, %234 ]
%265 = icmp eq i64 %230, 0
br i1 %265, label %278, label %266
266: ; preds = %263
%267 = add i64 %264, %212
%268 = getelementptr inbounds i32, i32* %0, i64 %267
%269 = bitcast i32* %268 to <4 x i32>*
%270 = load <4 x i32>, <4 x i32>* %269
%271 = getelementptr inbounds i32, i32* %268, i64 4
%272 = bitcast i32* %271 to <4 x i32>*
%273 = load <4 x i32>, <4 x i32>* %272
%274 = or <4 x i32> %270, %224
%275 = or <4 x i32> %273, %226
%276 = bitcast i32* %268 to <4 x i32>*
store <4 x i32> %274, <4 x i32>* %276
%277 = bitcast i32* %271 to <4 x i32>*
store <4 x i32> %275, <4 x i32>* %277
br label %278
278: ; preds = %263, %266
%279 = icmp eq i64 %216, %219
br i1 %279, label %292, label %280
280: ; preds = %209, %278
%281 = phi i64 [ %212, %209 ], [ %220, %278 ]
%282 = phi i32 [ %1, %209 ], [ %222, %278 ]
br label %283
283: ; preds = %280, %283
%284 = phi i64 [ %286, %283 ], [ %281, %280 ]
%285 = phi i32 [ %290, %283 ], [ %282, %280 ]
%286 = add nsw i64 %284, 1
%287 = getelementptr inbounds i32, i32* %0, i64 %284
%288 = load i32, i32* %287
%289 = or i32 %288, %7
store i32 %289, i32* %287
%290 = add nsw i32 %285, 1
%291 = icmp eq i32 %290, %2
br i1 %291, label %292, label %283
292: ; preds = %283, %278, %208
ret void
}