void rotate_90(char before[][10], char trans[][10], int n) {
  int i, j;
  for (i = 0; i < n; ++i)
    for (j = 0; j < n; ++j)
      trans[i][j] = before[j][n - 1 - i];
}


x86 assembly (clang, -O0):
<rotate_90>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    118a <rotate_90+0x8a>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1177 <rotate_90+0x77>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0xa,%rcx,%rcx
add    %rcx,%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x18(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0xa,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1129 <rotate_90+0x29>
jmp    117c <rotate_90+0x7c>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1116 <rotate_90+0x16>
pop    %rbp
ret

x86 assembly (clang, -O2):
<rotate_90>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
test   %edx,%edx
jle    1404 <rotate_90+0x304>
mov    %edx,%r12d
lea    (%r12,%r12,4),%rax
lea    (%rdi,%rax,2),%r10
add    $0xfffffffffffffff7,%r10
mov    %r12d,%r8d
and    $0xfffffff0,%r8d
mov    %r12d,%eax
and    $0xfffffff8,%eax
mov    %rax,-0x20(%rsp)
mov    %r12d,%eax
and    $0x3,%eax
lea    -0x1(%rdx),%r15d
mov    %rax,-0x8(%rsp)
add    %rax,%rax
lea    (%rax,%rax,4),%r13
xor    %r14d,%r14d
mov    %rsi,%r11
mov    %r8,-0x28(%rsp)
mov    %rsi,-0x10(%rsp)
mov    %r10,-0x18(%rsp)
jmp    1175 <rotate_90+0x75>
add    $0x1,%r14
add    $0xffffffff,%r15d
add    $0xa,%r11
cmp    %r12,%r14
je     1404 <rotate_90+0x304>
movslq %r15d,%r15
cmp    $0x8,%edx
jb     11aa <rotate_90+0xaa>
mov    %r14d,%eax
not    %eax
add    %edx,%eax
cltq
lea    (%r10,%rax,1),%rbx
lea    (%r14,%r14,4),%rbp
lea    (%rsi,%rbp,2),%rbp
cmp    %rbx,%rbp
jae    1250 <rotate_90+0x150>
add    %rdi,%rax
add    %r12,%rbp
cmp    %rbp,%rax
jae    1250 <rotate_90+0x150>
xor    %eax,%eax
mov    %rax,%r9
not    %r9
add    %r12,%r9
cmpq   $0x0,-0x8(%rsp)
je     11e7 <rotate_90+0xe7>
lea    (%rax,%rax,4),%rcx
lea    (%rdi,%rcx,2),%rbp
add    %r15,%rbp
xor    %r8d,%r8d
nopl   0x0(%rax,%rax,1)
movzbl 0x0(%rbp,%r8,1),%ebx
mov    %bl,(%r11,%rax,1)
add    $0x1,%rax
add    $0xa,%r8
cmp    %r8,%r13
jne    11d0 <rotate_90+0xd0>
cmp    $0x3,%r9
mov    -0x28(%rsp),%r8
jb     1160 <rotate_90+0x60>
lea    (%rax,%rax,4),%rcx
lea    (%rdi,%rcx,2),%rbx
add    %r15,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rbx),%ecx
mov    %cl,(%r11,%rax,1)
movzbl 0xa(%rbx),%ecx
mov    %cl,0x1(%r11,%rax,1)
movzbl 0x14(%rbx),%ecx
mov    %cl,0x2(%r11,%rax,1)
movzbl 0x1e(%rbx),%ecx
mov    %cl,0x3(%r11,%rax,1)
add    $0x4,%rax
add    $0x28,%rbx
cmp    %rax,%r12
jne    1210 <rotate_90+0x110>
jmp    1160 <rotate_90+0x60>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    $0x10,%edx
jae    125c <rotate_90+0x15c>
xor    %ebx,%ebx
jmp    1366 <rotate_90+0x266>
lea    (%rdi,%r15,1),%rax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl 0x96(%rax),%ebp
movd   %ebp,%xmm0
movzbl 0x8c(%rax),%ebp
movd   %ebp,%xmm1
punpcklbw %xmm0,%xmm1
movzbl 0x82(%rax),%ebp
movd   %ebp,%xmm0
movzbl 0x78(%rax),%ebp
movd   %ebp,%xmm2
punpcklbw %xmm0,%xmm2
punpcklwd %xmm1,%xmm2
movzbl 0x6e(%rax),%ebp
movd   %ebp,%xmm0
movzbl 0x64(%rax),%ebp
movd   %ebp,%xmm1
punpcklbw %xmm0,%xmm1
movzbl 0x5a(%rax),%ebp
movd   %ebp,%xmm3
movzbl 0x50(%rax),%ebp
movd   %ebp,%xmm0
punpcklbw %xmm3,%xmm0
punpcklwd %xmm1,%xmm0
punpckldq %xmm2,%xmm0
movzbl 0x46(%rax),%ebp
movd   %ebp,%xmm1
movzbl 0x3c(%rax),%ebp
movd   %ebp,%xmm2
punpcklbw %xmm1,%xmm2
movzbl 0x32(%rax),%ebp
movd   %ebp,%xmm1
movzbl 0x28(%rax),%ebp
movd   %ebp,%xmm3
punpcklbw %xmm1,%xmm3
punpcklwd %xmm2,%xmm3
movzbl 0x1e(%rax),%ebp
movd   %ebp,%xmm1
movzbl 0x14(%rax),%ebp
movd   %ebp,%xmm2
punpcklbw %xmm1,%xmm2
movzbl 0xa(%rax),%ebp
movd   %ebp,%xmm1
movzbl (%rax),%ebp
movd   %ebp,%xmm4
punpcklbw %xmm1,%xmm4
punpcklwd %xmm2,%xmm4
punpckldq %xmm3,%xmm4
punpcklqdq %xmm0,%xmm4
movdqu %xmm4,(%r11,%rbx,1)
add    $0x10,%rbx
add    $0xa0,%rax
cmp    %rbx,%r8
jne    1270 <rotate_90+0x170>
cmp    %r12,%r8
je     1160 <rotate_90+0x60>
mov    %r8,%rbx
mov    %r8,%rax
test   $0x8,%r12b
je     11ac <rotate_90+0xac>
lea    (%rbx,%rbx,4),%rax
mov    %rdi,%rcx
lea    (%rdi,%rax,2),%rax
add    %r15,%rax
mov    -0x20(%rsp),%rdi
nopl   0x0(%rax)
movzbl (%rax),%r8d
movzbl 0x14(%rax),%ebp
movzbl 0x28(%rax),%r10d
movzbl 0x3c(%rax),%esi
movzbl 0x1e(%rax),%r9d
shl    $0x8,%r9d
or     %ebp,%r9d
movzbl 0xa(%rax),%ebp
shl    $0x8,%ebp
or     %r8d,%ebp
movd   %ebp,%xmm0
pinsrw $0x1,%r9d,%xmm0
movzbl 0x32(%rax),%ebp
shl    $0x8,%ebp
or     %r10d,%ebp
pinsrw $0x2,%ebp,%xmm0
movzbl 0x46(%rax),%ebp
shl    $0x8,%ebp
or     %esi,%ebp
pinsrw $0x3,%ebp,%xmm0
movq   %xmm0,(%r11,%rbx,1)
add    $0x8,%rbx
add    $0x50,%rax
cmp    %rbx,%rdi
jne    1380 <rotate_90+0x280>
mov    %rdi,%rax
cmp    %r12,%rdi
mov    -0x10(%rsp),%rsi
mov    %rcx,%rdi
mov    -0x18(%rsp),%r10
mov    -0x28(%rsp),%r8
je     1160 <rotate_90+0x60>
jmp    11ac <rotate_90+0xac>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @rotate_90([10 x i8]* %0, [10 x i8]* %1, i32 %2) {
%4 = alloca [10 x i8]*
%5 = alloca [10 x i8]*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
store [10 x i8]* %0, [10 x i8]** %4
store [10 x i8]* %1, [10 x i8]** %5
store i32 %2, i32* %6
store i32 0, i32* %7
br label %9
9: ; preds = %41, %3
%10 = load i32, i32* %7
%11 = load i32, i32* %6
%12 = icmp slt i32 %10, %11
br i1 %12, label %13, label %44
13: ; preds = %9
store i32 0, i32* %8
br label %14
14: ; preds = %37, %13
%15 = load i32, i32* %8
%16 = load i32, i32* %6
%17 = icmp slt i32 %15, %16
br i1 %17, label %18, label %40
18: ; preds = %14
%19 = load [10 x i8]*, [10 x i8]** %4
%20 = load i32, i32* %8
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds [10 x i8], [10 x i8]* %19, i64 %21
%23 = load i32, i32* %6
%24 = sub nsw i32 %23, 1
%25 = load i32, i32* %7
%26 = sub nsw i32 %24, %25
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds [10 x i8], [10 x i8]* %22, i64 0, i64 %27
%29 = load i8, i8* %28
%30 = load [10 x i8]*, [10 x i8]** %5
%31 = load i32, i32* %7
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds [10 x i8], [10 x i8]* %30, i64 %32
%34 = load i32, i32* %8
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds [10 x i8], [10 x i8]* %33, i64 0, i64 %35
store i8 %29, i8* %36
br label %37
37: ; preds = %18
%38 = load i32, i32* %8
%39 = add nsw i32 %38, 1
store i32 %39, i32* %8
br label %14
40: ; preds = %14
br label %41
41: ; preds = %40
%42 = load i32, i32* %7
%43 = add nsw i32 %42, 1
store i32 %43, i32* %7
br label %9
44: ; preds = %9
ret void
}

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