#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);
int /*<<< orphan*/ memset(unsigned char *, int /*<<< orphan*/, unsigned int);
void matrix_get_rotated_layer(unsigned char *matrix, unsigned int size,
                              unsigned int layer, unsigned char *buffer) {
  unsigned int i, offset;
  unsigned int k = 0;
  unsigned int first = layer;
  unsigned int last = size - 1 - layer;
  assert(matrix != NULL);
  assert(buffer != NULL);
  assert(layer < size / 2);
  memset(buffer, 0, size * 4 * sizeof(unsigned char));
  for (i = first; i < last; i++) {
    offset = i - first;
    buffer[k++] = matrix[i * size + last];
    buffer[k++] = matrix[last * size + last - offset];
    buffer[k++] = matrix[(last - offset) * size + first];
    buffer[k++] = matrix[first * size + i];
  }
}


x86 assembly (clang, -O0):
<matrix_get_rotated_layer>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
sub    -0x10(%rbp),%eax
mov    %eax,-0x2c(%rbp)
cmpq   $0x0,-0x8(%rbp)
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
cmpq   $0x0,-0x18(%rbp)
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%ecx
shr    $0x1,%ecx
cmp    %ecx,%eax
setb   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
mov    -0x18(%rbp),%rdi
mov    -0xc(%rbp),%eax
shl    $0x2,%eax
mov    %eax,%eax
shl    $0x0,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    -0x28(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    126f <matrix_get_rotated_layer+0x14f>
mov    -0x1c(%rbp),%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x24(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
sub    -0x20(%rbp),%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x24(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x20(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x28(%rbp),%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x24(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x1c(%rbp),%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x24(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11aa <matrix_get_rotated_layer+0x8a>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<matrix_get_rotated_layer>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rcx,%r15
mov    %edx,%r12d
mov    %esi,%ebx
mov    %rdi,%r13
mov    %edx,%r14d
not    %r14d
lea    (%r14,%rbx,1),%eax
mov    %eax,0x18(%rsp)
xor    %edi,%edi
test   %r13,%r13
setne  %dil
call   1040 <assert@plt>
xor    %edi,%edi
test   %r15,%r15
setne  %dil
call   1040 <assert@plt>
mov    %ebx,%eax
shr    %eax
xor    %edi,%edi
cmp    %r12d,%eax
seta   %dil
call   1040 <assert@plt>
lea    0x0(,%rbx,4),%edx
xor    %ebp,%ebp
mov    %r15,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
mov    %rbx,%r10
mov    %r12,%rax
mov    %r12,0x10(%rsp)
mov    0x18(%rsp),%ebx
cmp    %r12d,%ebx
jbe    1401 <matrix_get_rotated_layer+0x2e1>
mov    %ebx,%eax
mov    0x10(%rsp),%r12d
mov    %ebx,%r11d
mov    %r11,%rsi
sub    %r12,%rsi
cmp    $0x8,%rsi
jb     136b <matrix_get_rotated_layer+0x24b>
mov    %r12,%rcx
not    %rcx
add    %r11,%rcx
mov    0x10(%rsp),%rax
lea    (%rax,%rax,1),%edi
mov    %edi,%eax
add    %ecx,%eax
setb   %r9b
mov    $0x4,%edx
mov    %rcx,%rax
mul    %rdx
seto   %r8b
cmp    $0x1,%r10d
jne    136b <matrix_get_rotated_layer+0x24b>
mov    %rcx,%rdx
shr    $0x20,%rdx
jne    136b <matrix_get_rotated_layer+0x24b>
mov    %r12,(%rsp)
mov    %edi,%r12d
neg    %r12d
cmp    %ecx,%r12d
jb     1367 <matrix_get_rotated_layer+0x247>
test   %rdx,%rdx
jne    1367 <matrix_get_rotated_layer+0x247>
test   %ecx,%ecx
jne    1367 <matrix_get_rotated_layer+0x247>
test   %rdx,%rdx
jne    1367 <matrix_get_rotated_layer+0x247>
test   %r9b,%r9b
jne    1367 <matrix_get_rotated_layer+0x247>
test   %rdx,%rdx
jne    1367 <matrix_get_rotated_layer+0x247>
lea    0x2(%r15),%rcx
lea    (%r15,%rax,1),%rdx
add    $0x2,%rdx
cmp    %rcx,%rdx
jb     1367 <matrix_get_rotated_layer+0x247>
test   %r8b,%r8b
jne    1367 <matrix_get_rotated_layer+0x247>
lea    0x3(%r15),%rcx
lea    (%r15,%rax,1),%rdx
add    $0x3,%rdx
cmp    %rcx,%rdx
jb     1367 <matrix_get_rotated_layer+0x247>
test   %r8b,%r8b
jne    1367 <matrix_get_rotated_layer+0x247>
lea    0x1(%r15),%rcx
lea    (%r15,%rax,1),%rdx
add    $0x1,%rdx
cmp    %rcx,%rdx
jb     1367 <matrix_get_rotated_layer+0x247>
test   %r8b,%r8b
jne    1367 <matrix_get_rotated_layer+0x247>
add    %r15,%rax
cmp    %r15,%rax
jb     1367 <matrix_get_rotated_layer+0x247>
test   %r8b,%r8b
jne    1367 <matrix_get_rotated_layer+0x247>
mov    (%rsp),%rbx
mov    %r10,0x8(%rsp)
lea    (%r15,%rsi,4),%rax
lea    (%rdi,%r13,1),%r8
add    %r11,%rdi
sub    %rbx,%rdi
add    %r13,%rdi
mov    %rbx,%rdx
sub    %r11,%rdx
lea    (%rdx,%r13,1),%r9
add    $0x1,%r9
lea    0x1(%r13),%rcx
lea    (%rbx,%r12,1),%rdx
sub    %r11,%rdx
lea    (%rdx,%r13,1),%r10
add    $0x1,%r10
lea    (%r12,%r13,1),%rdx
add    $0x1,%rdx
cmp    %r15,%rdi
seta   %bl
mov    %rsi,0x20(%rsp)
lea    (%rsi,%r13,1),%rdi
cmp    %rax,%r8
setb   %r8b
cmp    %r15,%rcx
seta   %cl
cmp    %rax,%r9
setb   %r9b
cmp    %r15,%rdx
seta   %dl
cmp    %rax,%r10
setb   %r10b
cmp    %r15,%rdi
seta   %dil
cmp    %r13,%rax
seta   %al
test   %r8b,%bl
jne    1713 <matrix_get_rotated_layer+0x5f3>
and    %r9b,%cl
jne    1713 <matrix_get_rotated_layer+0x5f3>
and    %r10b,%dl
mov    (%rsp),%r12
jne    1721 <matrix_get_rotated_layer+0x601>
and    %al,%dil
mov    0x8(%rsp),%r10
jne    136b <matrix_get_rotated_layer+0x24b>
mov    0x20(%rsp),%rax
cmp    $0x10,%rax
jae    1410 <matrix_get_rotated_layer+0x2f0>
xor    %r8d,%r8d
jmp    1570 <matrix_get_rotated_layer+0x450>
mov    (%rsp),%r12
mov    0x10(%rsp),%rsi
mov    %esi,%eax
imul   %r10d,%eax
mov    %r10d,%ecx
sub    %esi,%ecx
imul   %r10d,%ecx
mov    %r12d,%edx
not    %edx
add    %edx,%ecx
add    %r10d,%edx
imul   %r10d,%edx
add    %esi,%edx
add    %r12d,%eax
lea    0x1(%r12),%edi
imul   %r10d,%edi
add    %edi,%r14d
sub    %r12,%r11
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r14d,%edi
movzbl 0x0(%r13,%rdi,1),%ebx
lea    0x1(%rbp),%edi
mov    %ebp,%esi
mov    %bl,(%r15,%rsi,1)
mov    %ecx,%esi
movzbl 0x0(%r13,%rsi,1),%ebx
lea    0x2(%rbp),%esi
mov    %bl,(%r15,%rdi,1)
mov    %edx,%edi
movzbl 0x0(%r13,%rdi,1),%ebx
lea    0x3(%rbp),%edi
mov    %bl,(%r15,%rsi,1)
mov    %eax,%esi
movzbl 0x0(%r13,%rsi,1),%ebx
add    $0x4,%ebp
mov    %bl,(%r15,%rdi,1)
add    $0xffffffff,%ecx
sub    %r10d,%edx
add    $0x1,%eax
add    %r10d,%r14d
add    $0xffffffffffffffff,%r11
jne    13b0 <matrix_get_rotated_layer+0x290>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x18(%rsp),%r12d
mov    %r12d,%r9d
imul   %r10d,%r9d
add    %r9d,%r12d
mov    %rax,%rbx
mov    %rax,%r8
and    $0xfffffffffffffff0,%r8
mov    0x10(%rsp),%rax
add    %eax,%r9d
mov    %r10d,%esi
shl    $0x4,%esi
lea    -0x1(%r10),%ecx
imul   %eax,%ecx
lea    (%r10,%rcx,1),%edx
add    $0xffffffff,%edx
lea    0x1(%r10),%edi
imul   %eax,%edi
xor    %ebp,%ebp
pxor   %xmm0,%xmm0
mov    %r8,%rcx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %edx,%eax
movdqu 0x0(%r13,%rax,1),%xmm1
mov    %r12d,%eax
movdqu -0xf(%r13,%rax,1),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
mov    %r9d,%eax
movdqu -0xf(%r13,%rax,1),%xmm3
movdqa %xmm3,%xmm4
punpcklbw %xmm0,%xmm4
pshufd $0x4e,%xmm4,%xmm4
pshuflw $0x1b,%xmm4,%xmm4
pshufhw $0x1b,%xmm4,%xmm4
punpckhbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
packuswb %xmm4,%xmm3
mov    %edi,%eax
movdqu 0x0(%r13,%rax,1),%xmm4
mov    %ebp,%eax
and    $0xffffffc0,%eax
movdqa %xmm3,%xmm5
punpcklbw %xmm4,%xmm5
movdqa %xmm1,%xmm6
punpcklbw %xmm2,%xmm6
movdqa %xmm6,%xmm7
punpcklwd %xmm5,%xmm7
punpckhwd %xmm5,%xmm6
punpckhbw %xmm4,%xmm3
punpckhbw %xmm2,%xmm1
movdqa %xmm1,%xmm2
punpcklwd %xmm3,%xmm2
punpckhwd %xmm3,%xmm1
movdqu %xmm1,0x30(%r15,%rax,1)
movdqu %xmm2,0x20(%r15,%rax,1)
movdqu %xmm6,0x10(%r15,%rax,1)
movdqu %xmm7,(%r15,%rax,1)
add    $0x40,%rbp
add    $0xfffffff0,%r12d
sub    %esi,%r9d
add    %esi,%edx
add    $0x10,%edi
add    $0xfffffffffffffff0,%rcx
jne    1460 <matrix_get_rotated_layer+0x340>
cmp    %r8,%rbx
mov    (%rsp),%r12
je     1401 <matrix_get_rotated_layer+0x2e1>
mov    %rbx,%rax
test   $0x8,%al
jne    1570 <matrix_get_rotated_layer+0x450>
lea    0x0(,%r8,4),%ebp
add    %r8,%r12
jmp    136b <matrix_get_rotated_layer+0x24b>
mov    %rax,%rbx
and    $0xfffffffffffffff8,%rbx
add    %rbx,%r12
mov    %r12,(%rsp)
lea    0x0(,%rbx,4),%ebp
lea    0x0(,%r8,4),%r9
mov    %r10d,%eax
mov    0x10(%rsp),%rdx
sub    %edx,%eax
mov    %r10,%rcx
imul   %eax,%r10d
sub    %edx,%r10d
mov    %r8d,%edi
not    %edi
add    %edi,%r10d
add    %eax,%edi
imul   %ecx,%edi
add    %edx,%edi
lea    0x0(,%rcx,8),%esi
lea    (%rdx,%r8,1),%eax
add    $0x1,%eax
imul   %ecx,%eax
add    %r14d,%eax
lea    0x1(%rcx),%r12d
imul   %edx,%r12d
add    %r8d,%r12d
mov    %rbx,0x18(%rsp)
sub    %rbx,%r8
pxor   %xmm0,%xmm0
movdqa 0xa1c(%rip),%xmm8
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %eax,%ecx
mov    %r10d,%edx
movq   -0x7(%r13,%rdx,1),%xmm3
mov    %edi,%edx
movq   -0x7(%r13,%rdx,1),%xmm5
mov    %r12d,%edx
movq   0x0(%r13,%rdx,1),%xmm2
mov    %r9d,%edx
and    $0xffffffe0,%edx
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
packuswb %xmm3,%xmm4
movq   0x0(%r13,%rcx,1),%xmm3
punpcklbw %xmm0,%xmm5
pshufd $0x4e,%xmm5,%xmm5
pshuflw $0x1b,%xmm5,%xmm5
pshufhw $0x1b,%xmm5,%xmm5
packuswb %xmm5,%xmm5
punpcklbw %xmm0,%xmm2
punpcklbw %xmm0,%xmm5
movdqa %xmm5,%xmm6
punpcklwd %xmm2,%xmm6
pshufd $0xfa,%xmm6,%xmm7
pshufd $0x50,%xmm6,%xmm6
packuswb %xmm7,%xmm6
movdqa %xmm8,%xmm7
pandn  %xmm6,%xmm7
punpcklbw %xmm0,%xmm3
punpckhbw %xmm0,%xmm4
movdqa %xmm3,%xmm6
punpcklwd %xmm4,%xmm6
pshufd $0xf6,%xmm6,%xmm1
pshufd $0xd4,%xmm6,%xmm6
packuswb %xmm1,%xmm6
pand   %xmm8,%xmm6
por    %xmm7,%xmm6
punpckhwd %xmm2,%xmm5
pshufd $0xfa,%xmm5,%xmm1
pshufd $0x50,%xmm5,%xmm2
packuswb %xmm1,%xmm2
movdqa %xmm8,%xmm1
pandn  %xmm2,%xmm1
punpckhwd %xmm4,%xmm3
pshufd $0xf6,%xmm3,%xmm2
pshufd $0xd4,%xmm3,%xmm3
packuswb %xmm2,%xmm3
pand   %xmm8,%xmm3
por    %xmm1,%xmm3
movdqu %xmm3,0x10(%r15,%rdx,1)
movdqu %xmm6,(%r15,%rdx,1)
add    $0x20,%r9
add    $0xfffffff8,%r10d
sub    %esi,%edi
add    %esi,%eax
add    $0x8,%r12d
add    $0x8,%r8
jne    15f0 <matrix_get_rotated_layer+0x4d0>
mov    0x18(%rsp),%rax
cmp    %rax,0x20(%rsp)
mov    0x8(%rsp),%r10
mov    (%rsp),%r12
jne    136b <matrix_get_rotated_layer+0x24b>
jmp    1401 <matrix_get_rotated_layer+0x2e1>
mov    0x8(%rsp),%r10
mov    (%rsp),%r12
jmp    136b <matrix_get_rotated_layer+0x24b>
mov    0x8(%rsp),%r10
jmp    136b <matrix_get_rotated_layer+0x24b>

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

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