#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*/ assert(int);
void do_rotate(int *grid, int w, int h, int n, int orientable, int x, int y,
               int dir) {
  int i, j;
  assert(x >= 0 && x + n <= w);
  assert(y >= 0 && y + n <= h);
  dir &= 3;
  if (dir == 0)
    return;
  grid += y * w + x;
  for (i = 0; i < (n + 1) / 2; i++) {
    for (j = 0; j < n / 2; j++) {
      int k;
      int g[4];
      int p[4];
      p[0] = j * w + i;
      p[1] = i * w + (n - j - 1);
      p[2] = (n - j - 1) * w + (n - i - 1);
      p[3] = (n - i - 1) * w + j;
      for (k = 0; k < 4; k++)
        g[k] = grid[p[k]];
      for (k = 0; k < 4; k++) {
        int v = g[(k + dir) & 3];
        if (orientable)
          v ^= ((v + dir) ^ v) & 3;
        grid[p[k]] = v;
      }
    }
  }
  if (orientable && (n & 1)) {
    int v = grid[n / 2 * (w + 1)];
    v ^= ((v + dir) ^ v) & 3;
    grid[n / 2 * (w + 1)] = v;
  }
}


x86 assembly (clang, -O0):
<do_rotate>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
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)
xor    %eax,%eax
cmpl   $0x0,-0x1c(%rbp)
mov    %al,-0x59(%rbp)
jl     1154 <do_rotate+0x44>
mov    -0x1c(%rbp),%eax
add    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
setle  %al
mov    %al,-0x59(%rbp)
mov    -0x59(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
xor    %eax,%eax
cmpl   $0x0,0x10(%rbp)
mov    %al,-0x5a(%rbp)
jl     117f <do_rotate+0x6f>
mov    0x10(%rbp),%eax
add    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
setle  %al
mov    %al,-0x5a(%rbp)
mov    -0x5a(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    0x18(%rbp),%eax
and    $0x3,%eax
mov    %eax,0x18(%rbp)
cmpl   $0x0,0x18(%rbp)
jne    11a4 <do_rotate+0x94>
jmp    13a1 <do_rotate+0x291>
mov    0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x1c(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x60(%rbp),%eax
cmp    %ecx,%eax
jge    131a <do_rotate+0x20a>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x64(%rbp),%eax
cmp    %ecx,%eax
jge    1307 <do_rotate+0x1f7>
mov    -0x24(%rbp),%eax
imul   -0xc(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x20(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    -0x24(%rbp),%ecx
sub    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x14(%rbp),%eax
sub    -0x24(%rbp),%eax
sub    $0x1,%eax
imul   -0xc(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    -0x20(%rbp),%ecx
sub    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x14(%rbp),%eax
sub    -0x20(%rbp),%eax
sub    $0x1,%eax
imul   -0xc(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x4,-0x28(%rbp)
jge    1294 <do_rotate+0x184>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movslq -0x50(%rbp,%rcx,4),%rcx
mov    (%rax,%rcx,4),%ecx
movslq -0x28(%rbp),%rax
mov    %ecx,-0x40(%rbp,%rax,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1264 <do_rotate+0x154>
movl   $0x0,-0x28(%rbp)
cmpl   $0x4,-0x28(%rbp)
jge    12f4 <do_rotate+0x1e4>
mov    -0x28(%rbp),%eax
add    0x18(%rbp),%eax
and    $0x3,%eax
cltq
mov    -0x40(%rbp,%rax,4),%eax
mov    %eax,-0x54(%rbp)
cmpl   $0x0,-0x18(%rbp)
je     12d3 <do_rotate+0x1c3>
mov    -0x54(%rbp),%eax
add    0x18(%rbp),%eax
xor    -0x54(%rbp),%eax
and    $0x3,%eax
xor    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movslq -0x50(%rbp,%rcx,4),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    129b <do_rotate+0x18b>
jmp    12f9 <do_rotate+0x1e9>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11ef <do_rotate+0xdf>
jmp    130c <do_rotate+0x1fc>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11c7 <do_rotate+0xb7>
cmpl   $0x0,-0x18(%rbp)
je     13a1 <do_rotate+0x291>
mov    -0x14(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     13a1 <do_rotate+0x291>
mov    -0x8(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x80(%rbp),%rax
mov    -0xc(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
add    0x18(%rbp),%eax
xor    -0x58(%rbp),%eax
and    $0x3,%eax
xor    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x74(%rbp),%edx
mov    %eax,%ecx
mov    -0x70(%rbp),%rax
mov    -0xc(%rbp),%esi
add    $0x1,%esi
imul   %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<do_rotate>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r9d,%r12d
mov    %r8d,%r15d
mov    %ecx,%r14d
mov    %edx,0x30(%rsp)
mov    %rdi,%rbx
mov    0xb8(%rsp),%ebp
mov    0xb0(%rsp),%r13d
lea    (%r12,%r14,1),%eax
mov    %esi,(%rsp)
cmp    %esi,%eax
setle  %al
test   %r9d,%r9d
setns  %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
lea    (%r14,%r13,1),%eax
cmp    0x30(%rsp),%eax
setle  %al
test   %r13d,%r13d
setns  %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
mov    %ebp,%ecx
and    $0x3,%ecx
je     13cb <do_rotate+0x2bb>
mov    %r15d,0xc(%rsp)
imul   (%rsp),%r13d
add    %r12d,%r13d
movslq %r13d,%rdx
lea    (%rbx,%rdx,4),%r15
test   %r14d,%r14d
mov    0xb8(%rsp),%eax
jle    138c <do_rotate+0x27c>
lea    0x1(%r14),%esi
shr    %esi
mov    %esi,0x3c(%rsp)
mov    %r14d,%esi
shr    %esi
cmp    $0x2,%esi
mov    $0x1,%edi
cmovge %esi,%edi
mov    %ecx,%ecx
lea    0x1(%rax),%esi
and    $0x3,%esi
mov    %rsi,0x60(%rsp)
lea    0x2(%rax),%r13d
and    $0x3,%r13d
add    $0xffffffff,%eax
and    $0x3,%eax
mov    %rax,0x70(%rsp)
lea    (%rbx,%rdx,4),%rax
mov    %rax,0x48(%rsp)
lea    -0x1(%r14),%eax
mov    (%rsp),%esi
mov    %esi,%edx
mov    %eax,0x8(%rsp)
imul   %eax,%edx
movslq %esi,%rbp
shl    $0x2,%rbp
mov    %rdx,0x28(%rsp)
lea    (%r14,%rdx,1),%eax
add    $0xffffffff,%eax
mov    %eax,0x4(%rsp)
xor    %edx,%edx
mov    %r15,0x40(%rsp)
mov    %r14,0x50(%rsp)
mov    %rbp,0x68(%rsp)
mov    (%rsp),%ebx
jmp    1265 <do_rotate+0x155>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x58(%rsp),%rdx
add    $0x1,%edx
mov    0x28(%rsp),%rax
mov    (%rsp),%esi
sub    %esi,%eax
mov    %rax,0x28(%rsp)
addq   $0x4,0x40(%rsp)
addl   $0xffffffff,0x4(%rsp)
add    %esi,0x8(%rsp)
cmp    0x3c(%rsp),%edx
mov    0x50(%rsp),%r14
je     138c <do_rotate+0x27c>
mov    %rdx,0x58(%rsp)
cmp    $0x1,%r14d
je     1230 <do_rotate+0x120>
movslq 0x28(%rsp),%rsi
mov    0x48(%rsp),%rax
lea    (%rax,%rsi,4),%rax
mov    %rax,0x30(%rsp)
mov    0x8(%rsp),%eax
mov    %eax,%r11d
mov    0x4(%rsp),%eax
mov    %eax,%r9d
mov    0x40(%rsp),%r14
xor    %r8d,%r8d
nopl   0x0(%rax)
mov    (%r14),%esi
mov    %esi,0x10(%rsp)
movslq %r11d,%r11
mov    (%r15,%r11,4),%esi
mov    %esi,0x14(%rsp)
movslq %r9d,%r9
mov    (%r15,%r9,4),%esi
mov    %esi,0x18(%rsp)
mov    0x30(%rsp),%r10
mov    (%r10,%r8,4),%esi
mov    %esi,0x1c(%rsp)
mov    0x10(%rsp,%rcx,4),%esi
mov    0xb8(%rsp),%eax
lea    (%rsi,%rax,1),%r12d
and    $0x3,%r12d
mov    %r13,%rbp
mov    %esi,%r13d
and    $0xfffffffc,%r13d
or     %r12d,%r13d
mov    0x60(%rsp),%rdx
mov    0xb8(%rsp),%eax
mov    0xc(%rsp),%r12d
test   %r12d,%r12d
cmove  %esi,%r13d
mov    %r13d,(%r14)
mov    %rbp,%r13
mov    0x10(%rsp,%rdx,4),%esi
mov    %rdi,%rdx
lea    (%rsi,%rax,1),%edi
and    $0x3,%edi
mov    %rcx,%rbp
mov    %esi,%ecx
and    $0xfffffffc,%ecx
or     %edi,%ecx
test   %r12d,%r12d
cmove  %esi,%ecx
mov    %ecx,(%r15,%r11,4)
mov    0x10(%rsp,%r13,4),%ecx
lea    (%rcx,%rax,1),%esi
and    $0x3,%esi
mov    %ecx,%edi
and    $0xfffffffc,%edi
or     %esi,%edi
test   %r12d,%r12d
cmove  %ecx,%edi
mov    %edi,(%r15,%r9,4)
mov    0x70(%rsp),%rcx
mov    0x10(%rsp,%rcx,4),%ecx
lea    (%rcx,%rax,1),%esi
and    $0x3,%esi
mov    %ecx,%edi
and    $0xfffffffc,%edi
or     %esi,%edi
test   %r12d,%r12d
cmove  %ecx,%edi
mov    %rbp,%rcx
mov    0x68(%rsp),%rbp
mov    %edi,(%r10,%r8,4)
mov    %rdx,%rdi
add    $0x1,%r8
add    %rbp,%r14
sub    %ebx,%r9d
add    $0xffffffff,%r11d
cmp    %r8d,%edi
jne    12a0 <do_rotate+0x190>
jmp    1230 <do_rotate+0x120>
cmpl   $0x0,0xc(%rsp)
je     13cb <do_rotate+0x2bb>
mov    %r14d,%ecx
and    $0x1,%ecx
je     13cb <do_rotate+0x2bb>
mov    %r14d,%ecx
shr    $0x1f,%ecx
add    %r14d,%ecx
sar    %ecx
mov    (%rsp),%eax
add    $0x1,%eax
imul   %ecx,%eax
movslq %eax,%rcx
mov    (%r15,%rcx,4),%edx
mov    0xb8(%rsp),%eax
add    %edx,%eax
and    $0x3,%eax
and    $0xfffffffc,%edx
or     %eax,%edx
mov    %edx,(%r15,%rcx,4)
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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