#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*/ genBoard(char **);
void rotateC(char arr[4][9], int sector) {
  char nboard[4][9];
  genBoard(nboard);
  int i, j, k;
  for (i = 0; i < 4; i++) {
    if (i != sector) {
      for (j = 0; j < 9; j++) {
        nboard[i][j] = arr[i][j];
      }
    }
  }
  nboard[sector][2] = arr[sector][0];
  nboard[sector][5] = arr[sector][1];
  nboard[sector][8] = arr[sector][2];
  nboard[sector][1] = arr[sector][3];
  nboard[sector][4] = arr[sector][4];
  nboard[sector][7] = arr[sector][5];
  nboard[sector][0] = arr[sector][6];
  nboard[sector][3] = arr[sector][7];
  nboard[sector][6] = arr[sector][8];
  for (k = 0; k < 9; k++) {
    arr[sector][k] = nboard[sector][k];
  }
}


x86 assembly (clang, -O0):
<rotateC>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
lea    -0x30(%rbp),%rdi
call   1030 <genBoard@plt>
movl   $0x0,-0x34(%rbp)
cmpl   $0x4,-0x34(%rbp)
jge    11a8 <rotateC+0x98>
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
je     1195 <rotateC+0x85>
movl   $0x0,-0x38(%rbp)
cmpl   $0x9,-0x38(%rbp)
jge    1190 <rotateC+0x80>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x9,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
movslq -0x34(%rbp),%rcx
lea    -0x30(%rbp),%rax
imul   $0x9,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    114c <rotateC+0x3c>
jmp    1195 <rotateC+0x85>
jmp    119a <rotateC+0x8a>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    112f <rotateC+0x1f>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x9,%rcx,%rcx
add    %rcx,%rax
mov    (%rax),%cl
movslq -0xc(%rbp),%rdx
lea    -0x30(%rbp),%rax
imul   $0x9,%rdx,%rdx
add    %rdx,%rax
mov    %cl,0x2(%rax)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x9,%rcx,%rcx
add    %rcx,%rax
mov    0x1(%rax),%cl
movslq -0xc(%rbp),%rdx
lea    -0x30(%rbp),%rax
imul   $0x9,%rdx,%rdx
add    %rdx,%rax
mov    %cl,0x5(%rax)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x9,%rcx,%rcx
add    %rcx,%rax
mov    0x2(%rax),%cl
movslq -0xc(%rbp),%rdx
lea    -0x30(%rbp),%rax
imul   $0x9,%rdx,%rdx
add    %rdx,%rax
mov    %cl,0x8(%rax)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x9,%rcx,%rcx
add    %rcx,%rax
mov    0x3(%rax),%cl
movslq -0xc(%rbp),%rdx
lea    -0x30(%rbp),%rax
imul   $0x9,%rdx,%rdx
add    %rdx,%rax
mov    %cl,0x1(%rax)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x9,%rcx,%rcx
add    %rcx,%rax
mov    0x4(%rax),%cl
movslq -0xc(%rbp),%rdx
lea    -0x30(%rbp),%rax
imul   $0x9,%rdx,%rdx
add    %rdx,%rax
mov    %cl,0x4(%rax)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x9,%rcx,%rcx
add    %rcx,%rax
mov    0x5(%rax),%cl
movslq -0xc(%rbp),%rdx
lea    -0x30(%rbp),%rax
imul   $0x9,%rdx,%rdx
add    %rdx,%rax
mov    %cl,0x7(%rax)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x9,%rcx,%rcx
add    %rcx,%rax
mov    0x6(%rax),%cl
movslq -0xc(%rbp),%rdx
lea    -0x30(%rbp),%rax
imul   $0x9,%rdx,%rdx
add    %rdx,%rax
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x9,%rcx,%rcx
add    %rcx,%rax
mov    0x7(%rax),%cl
movslq -0xc(%rbp),%rdx
lea    -0x30(%rbp),%rax
imul   $0x9,%rdx,%rdx
add    %rdx,%rax
mov    %cl,0x3(%rax)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x9,%rcx,%rcx
add    %rcx,%rax
mov    0x8(%rax),%cl
movslq -0xc(%rbp),%rdx
lea    -0x30(%rbp),%rax
imul   $0x9,%rdx,%rdx
add    %rdx,%rax
mov    %cl,0x6(%rax)
movl   $0x0,-0x3c(%rbp)
cmpl   $0x9,-0x3c(%rbp)
jge    1335 <rotateC+0x225>
movslq -0xc(%rbp),%rcx
lea    -0x30(%rbp),%rax
imul   $0x9,%rcx,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x9,%rcx,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12f1 <rotateC+0x1e1>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rotateC>:
push   %rbp
push   %rbx
sub    $0x28,%rsp
mov    %esi,%ebp
mov    %rdi,%rbx
mov    %rsp,%rdi
call   1030 <genBoard@plt>
test   %ebp,%ebp
je     1166 <rotateC+0x56>
mov    0x8(%rbx),%al
mov    %al,0x8(%rsp)
mov    (%rbx),%rax
mov    %rax,(%rsp)
cmp    $0x1,%ebp
je     1176 <rotateC+0x66>
mov    0x11(%rbx),%al
mov    %al,0x11(%rsp)
mov    0x9(%rbx),%rax
mov    %rax,0x9(%rsp)
cmp    $0x2,%ebp
je     1186 <rotateC+0x76>
mov    0x1a(%rbx),%al
mov    %al,0x1a(%rsp)
mov    0x12(%rbx),%rax
mov    %rax,0x12(%rsp)
cmp    $0x3,%ebp
jne    1186 <rotateC+0x76>
jmp    1196 <rotateC+0x86>
mov    0x11(%rbx),%al
mov    %al,0x11(%rsp)
mov    0x9(%rbx),%rax
mov    %rax,0x9(%rsp)
mov    0x1a(%rbx),%al
mov    %al,0x1a(%rsp)
mov    0x12(%rbx),%rax
mov    %rax,0x12(%rsp)
mov    0x23(%rbx),%al
mov    %al,0x23(%rsp)
mov    0x1b(%rbx),%rax
mov    %rax,0x1b(%rsp)
movslq %ebp,%rax
lea    (%rax,%rax,8),%rax
mov    (%rbx,%rax,1),%cl
mov    %cl,0x2(%rsp,%rax,1)
mov    0x1(%rbx,%rax,1),%cl
mov    %cl,0x5(%rsp,%rax,1)
mov    0x2(%rbx,%rax,1),%cl
mov    %cl,0x8(%rsp,%rax,1)
mov    0x3(%rbx,%rax,1),%dl
mov    %dl,0x1(%rsp,%rax,1)
mov    0x4(%rbx,%rax,1),%dl
mov    %dl,0x4(%rsp,%rax,1)
mov    0x5(%rbx,%rax,1),%dl
mov    %dl,0x7(%rsp,%rax,1)
mov    0x6(%rbx,%rax,1),%dl
mov    %dl,(%rsp,%rax,1)
mov    0x7(%rbx,%rax,1),%dl
mov    %dl,0x3(%rsp,%rax,1)
mov    0x8(%rbx,%rax,1),%dl
mov    %dl,0x6(%rsp,%rax,1)
mov    %cl,0x8(%rbx,%rax,1)
mov    (%rsp,%rax,1),%rcx
mov    %rcx,(%rbx,%rax,1)
add    $0x28,%rsp
pop    %rbx
pop    %rbp
ret

LLVM IR (-O0):
define void @rotateC([9 x i8]* %0, i32 %1) {
%3 = alloca [9 x i8]*
%4 = alloca i32
%5 = alloca [4 x [9 x i8]]
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
store [9 x i8]* %0, [9 x i8]** %3
store i32 %1, i32* %4
%9 = getelementptr inbounds [4 x [9 x i8]], [4 x [9 x i8]]* %5, i64 0, i64 0
%10 = bitcast [9 x i8]* %9 to i8**
%11 = call i32 @genBoard(i8** %10)
store i32 0, i32* %6
br label %12
12: ; preds = %43, %2
%13 = load i32, i32* %6
%14 = icmp slt i32 %13, 4
br i1 %14, label %15, label %46
15: ; preds = %12
%16 = load i32, i32* %6
%17 = load i32, i32* %4
%18 = icmp ne i32 %16, %17
br i1 %18, label %19, label %42
19: ; preds = %15
store i32 0, i32* %7
br label %20
20: ; preds = %38, %19
%21 = load i32, i32* %7
%22 = icmp slt i32 %21, 9
br i1 %22, label %23, label %41
23: ; preds = %20
%24 = load [9 x i8]*, [9 x i8]** %3
%25 = load i32, i32* %6
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds [9 x i8], [9 x i8]* %24, i64 %26
%28 = load i32, i32* %7
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds [9 x i8], [9 x i8]* %27, i64 0, i64 %29
%31 = load i8, i8* %30
%32 = load i32, i32* %6
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds [4 x [9 x i8]], [4 x [9 x i8]]* %5, i64 0, i64 %33
%35 = load i32, i32* %7
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [9 x i8], [9 x i8]* %34, i64 0, i64 %36
store i8 %31, i8* %37
br label %38
38: ; preds = %23
%39 = load i32, i32* %7
%40 = add nsw i32 %39, 1
store i32 %40, i32* %7
br label %20
41: ; preds = %20
br label %42
42: ; preds = %41, %15
br label %43
43: ; preds = %42
%44 = load i32, i32* %6
%45 = add nsw i32 %44, 1
store i32 %45, i32* %6
br label %12
46: ; preds = %12
%47 = load [9 x i8]*, [9 x i8]** %3
%48 = load i32, i32* %4
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds [9 x i8], [9 x i8]* %47, i64 %49
%51 = getelementptr inbounds [9 x i8], [9 x i8]* %50, i64 0, i64 0
%52 = load i8, i8* %51
%53 = load i32, i32* %4
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds [4 x [9 x i8]], [4 x [9 x i8]]* %5, i64 0, i64 %54
%56 = getelementptr inbounds [9 x i8], [9 x i8]* %55, i64 0, i64 2
store i8 %52, i8* %56
%57 = load [9 x i8]*, [9 x i8]** %3
%58 = load i32, i32* %4
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds [9 x i8], [9 x i8]* %57, i64 %59
%61 = getelementptr inbounds [9 x i8], [9 x i8]* %60, i64 0, i64 1
%62 = load i8, i8* %61
%63 = load i32, i32* %4
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds [4 x [9 x i8]], [4 x [9 x i8]]* %5, i64 0, i64 %64
%66 = getelementptr inbounds [9 x i8], [9 x i8]* %65, i64 0, i64 5
store i8 %62, i8* %66
%67 = load [9 x i8]*, [9 x i8]** %3
%68 = load i32, i32* %4
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds [9 x i8], [9 x i8]* %67, i64 %69
%71 = getelementptr inbounds [9 x i8], [9 x i8]* %70, i64 0, i64 2
%72 = load i8, i8* %71
%73 = load i32, i32* %4
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds [4 x [9 x i8]], [4 x [9 x i8]]* %5, i64 0, i64 %74
%76 = getelementptr inbounds [9 x i8], [9 x i8]* %75, i64 0, i64 8
store i8 %72, i8* %76
%77 = load [9 x i8]*, [9 x i8]** %3
%78 = load i32, i32* %4
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds [9 x i8], [9 x i8]* %77, i64 %79
%81 = getelementptr inbounds [9 x i8], [9 x i8]* %80, i64 0, i64 3
%82 = load i8, i8* %81
%83 = load i32, i32* %4
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds [4 x [9 x i8]], [4 x [9 x i8]]* %5, i64 0, i64 %84
%86 = getelementptr inbounds [9 x i8], [9 x i8]* %85, i64 0, i64 1
store i8 %82, i8* %86
%87 = load [9 x i8]*, [9 x i8]** %3
%88 = load i32, i32* %4
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds [9 x i8], [9 x i8]* %87, i64 %89
%91 = getelementptr inbounds [9 x i8], [9 x i8]* %90, i64 0, i64 4
%92 = load i8, i8* %91
%93 = load i32, i32* %4
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds [4 x [9 x i8]], [4 x [9 x i8]]* %5, i64 0, i64 %94
%96 = getelementptr inbounds [9 x i8], [9 x i8]* %95, i64 0, i64 4
store i8 %92, i8* %96
%97 = load [9 x i8]*, [9 x i8]** %3
%98 = load i32, i32* %4
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds [9 x i8], [9 x i8]* %97, i64 %99
%101 = getelementptr inbounds [9 x i8], [9 x i8]* %100, i64 0, i64 5
%102 = load i8, i8* %101
%103 = load i32, i32* %4
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds [4 x [9 x i8]], [4 x [9 x i8]]* %5, i64 0, i64 %104
%106 = getelementptr inbounds [9 x i8], [9 x i8]* %105, i64 0, i64 7
store i8 %102, i8* %106
%107 = load [9 x i8]*, [9 x i8]** %3
%108 = load i32, i32* %4
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds [9 x i8], [9 x i8]* %107, i64 %109
%111 = getelementptr inbounds [9 x i8], [9 x i8]* %110, i64 0, i64 6
%112 = load i8, i8* %111
%113 = load i32, i32* %4
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds [4 x [9 x i8]], [4 x [9 x i8]]* %5, i64 0, i64 %114
%116 = getelementptr inbounds [9 x i8], [9 x i8]* %115, i64 0, i64 0
store i8 %112, i8* %116
%117 = load [9 x i8]*, [9 x i8]** %3
%118 = load i32, i32* %4
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds [9 x i8], [9 x i8]* %117, i64 %119
%121 = getelementptr inbounds [9 x i8], [9 x i8]* %120, i64 0, i64 7
%122 = load i8, i8* %121
%123 = load i32, i32* %4
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds [4 x [9 x i8]], [4 x [9 x i8]]* %5, i64 0, i64 %124
%126 = getelementptr inbounds [9 x i8], [9 x i8]* %125, i64 0, i64 3
store i8 %122, i8* %126
%127 = load [9 x i8]*, [9 x i8]** %3
%128 = load i32, i32* %4
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds [9 x i8], [9 x i8]* %127, i64 %129
%131 = getelementptr inbounds [9 x i8], [9 x i8]* %130, i64 0, i64 8
%132 = load i8, i8* %131
%133 = load i32, i32* %4
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds [4 x [9 x i8]], [4 x [9 x i8]]* %5, i64 0, i64 %134
%136 = getelementptr inbounds [9 x i8], [9 x i8]* %135, i64 0, i64 6
store i8 %132, i8* %136
store i32 0, i32* %8
br label %137
137: ; preds = %155, %46
%138 = load i32, i32* %8
%139 = icmp slt i32 %138, 9
br i1 %139, label %140, label %158
140: ; preds = %137
%141 = load i32, i32* %4
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds [4 x [9 x i8]], [4 x [9 x i8]]* %5, i64 0, i64 %142
%144 = load i32, i32* %8
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds [9 x i8], [9 x i8]* %143, i64 0, i64 %145
%147 = load i8, i8* %146
%148 = load [9 x i8]*, [9 x i8]** %3
%149 = load i32, i32* %4
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds [9 x i8], [9 x i8]* %148, i64 %150
%152 = load i32, i32* %8
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds [9 x i8], [9 x i8]* %151, i64 0, i64 %153
store i8 %147, i8* %154
br label %155
155: ; preds = %140
%156 = load i32, i32* %8
%157 = add nsw i32 %156, 1
store i32 %157, i32* %8
br label %137
158: ; preds = %137
ret void
}

LLVM IR (-O2):
define void @rotateC([9 x i8]* nocapture %0, i32 %1) {
%3 = alloca [4 x [9 x i8]]
%4 = getelementptr inbounds [4 x [9 x i8]], [4 x [9 x i8]]* %3, i64 0, i64 0, i64 0
%5 = bitcast [4 x [9 x i8]]* %3 to i8**
%6 = call i32 @genBoard(i8** %5)
%7 = icmp eq i32 %1, 0
br i1 %7, label %8, label %11
8: ; preds = %2
%9 = getelementptr [9 x i8], [9 x i8]* %0, i64 1, i64 0
%10 = getelementptr inbounds [4 x [9 x i8]], [4 x [9 x i8]]* %3, i64 0, i64 1, i64 0
br label %18
11: ; preds = %2
%12 = getelementptr [9 x i8], [9 x i8]* %0, i64 0, i64 0
%13 = icmp eq i32 %1, 1
br i1 %13, label %18, label %14
14: ; preds = %11
%15 = getelementptr [9 x i8], [9 x i8]* %0, i64 1, i64 0
%16 = getelementptr inbounds [4 x [9 x i8]], [4 x [9 x i8]]* %3, i64 0, i64 1, i64 0
%17 = icmp eq i32 %1, 2
br i1 %17, label %25, label %21
18: ; preds = %8, %11
%19 = getelementptr [9 x i8], [9 x i8]* %0, i64 2, i64 0
%20 = getelementptr inbounds [4 x [9 x i8]], [4 x [9 x i8]]* %3, i64 0, i64 2, i64 0
br label %25
21: ; preds = %14
%22 = getelementptr [9 x i8], [9 x i8]* %0, i64 2, i64 0
%23 = getelementptr inbounds [4 x [9 x i8]], [4 x [9 x i8]]* %3, i64 0, i64 2, i64 0
%24 = icmp eq i32 %1, 3
br i1 %24, label %28, label %25
25: ; preds = %14, %18, %21
%26 = getelementptr [9 x i8], [9 x i8]* %0, i64 3, i64 0
%27 = getelementptr inbounds [4 x [9 x i8]], [4 x [9 x i8]]* %3, i64 0, i64 3, i64 0
br label %28
28: ; preds = %25, %21
%29 = sext i32 %1 to i64
%30 = getelementptr [9 x i8], [9 x i8]* %0, i64 %29, i64 0
%31 = load i8, i8* %30
%32 = getelementptr inbounds [4 x [9 x i8]], [4 x [9 x i8]]* %3, i64 0, i64 %29, i64 2
store i8 %31, i8* %32
%33 = getelementptr inbounds [9 x i8], [9 x i8]* %0, i64 %29, i64 1
%34 = load i8, i8* %33
%35 = getelementptr inbounds [4 x [9 x i8]], [4 x [9 x i8]]* %3, i64 0, i64 %29, i64 5
store i8 %34, i8* %35
%36 = getelementptr inbounds [9 x i8], [9 x i8]* %0, i64 %29, i64 2
%37 = load i8, i8* %36
%38 = getelementptr inbounds [4 x [9 x i8]], [4 x [9 x i8]]* %3, i64 0, i64 %29, i64 8
store i8 %37, i8* %38
%39 = getelementptr inbounds [9 x i8], [9 x i8]* %0, i64 %29, i64 3
%40 = load i8, i8* %39
%41 = getelementptr inbounds [4 x [9 x i8]], [4 x [9 x i8]]* %3, i64 0, i64 %29, i64 1
store i8 %40, i8* %41
%42 = getelementptr inbounds [9 x i8], [9 x i8]* %0, i64 %29, i64 4
%43 = load i8, i8* %42
%44 = getelementptr inbounds [4 x [9 x i8]], [4 x [9 x i8]]* %3, i64 0, i64 %29, i64 4
store i8 %43, i8* %44
%45 = getelementptr inbounds [9 x i8], [9 x i8]* %0, i64 %29, i64 5
%46 = load i8, i8* %45
%47 = getelementptr inbounds [4 x [9 x i8]], [4 x [9 x i8]]* %3, i64 0, i64 %29, i64 7
store i8 %46, i8* %47
%48 = getelementptr inbounds [9 x i8], [9 x i8]* %0, i64 %29, i64 6
%49 = load i8, i8* %48
%50 = getelementptr [4 x [9 x i8]], [4 x [9 x i8]]* %3, i64 0, i64 %29, i64 0
store i8 %49, i8* %50
%51 = getelementptr inbounds [9 x i8], [9 x i8]* %0, i64 %29, i64 7
%52 = load i8, i8* %51
%53 = getelementptr inbounds [4 x [9 x i8]], [4 x [9 x i8]]* %3, i64 0, i64 %29, i64 3
store i8 %52, i8* %53
%54 = getelementptr inbounds [9 x i8], [9 x i8]* %0, i64 %29, i64 8
%55 = load i8, i8* %54
%56 = getelementptr inbounds [4 x [9 x i8]], [4 x [9 x i8]]* %3, i64 0, i64 %29, i64 6
store i8 %55, i8* %56
ret void
}