void moveSnakeArray(int snakeXY[][310], int snakeLength, int direction) {
  int i;
  for (i = snakeLength - 1; i >= 1; i--) {
    snakeXY[0][i] = snakeXY[0][i - 1];
    snakeXY[1][i] = snakeXY[1][i - 1];
  }
  switch (direction) {
  case (char)'B':
    snakeXY[1][0]++;
    break;
  case (char)'C':
    snakeXY[0][0]++;
    break;
  case (char)'A':
    snakeXY[1][0]--;
    break;
  case (char)'D':
    snakeXY[0][0]--;
    break;
  }
  return;
}


x86 assembly (clang, -O0):
<moveSnakeArray>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x1,-0x14(%rbp)
jl     116d <moveSnakeArray+0x6d>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    0x4d8(%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,0x4d8(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    1117 <moveSnakeArray+0x17>
mov    -0x10(%rbp),%eax
add    $0xffffffbf,%eax
mov    %eax,%ecx
mov    %rcx,-0x20(%rbp)
sub    $0x3,%eax
ja     11e1 <moveSnakeArray+0xe1>
mov    -0x20(%rbp),%rax
lea    0xe73(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x8(%rbp),%rax
mov    0x4d8(%rax),%ecx
add    $0x1,%ecx
mov    %ecx,0x4d8(%rax)
jmp    11e1 <moveSnakeArray+0xe1>
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    11e1 <moveSnakeArray+0xe1>
mov    -0x8(%rbp),%rax
mov    0x4d8(%rax),%ecx
add    $0xffffffff,%ecx
mov    %ecx,0x4d8(%rax)
jmp    11e1 <moveSnakeArray+0xe1>
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
add    $0xffffffff,%ecx
mov    %ecx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<moveSnakeArray>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
cmp    $0x2,%esi
jl     1175 <moveSnakeArray+0x75>
mov    $0xfffffffe,%eax
mov    %esi,%ebp
xor    %r9d,%r9d
mov    %rbp,%rcx
sub    $0x2,%rcx
mov    $0x0,%r8d
cmovae %rcx,%r8
add    $0x1,%r8
cmp    $0x4,%r8
jae    11a7 <moveSnakeArray+0xa7>
add    %rbp,%rax
add    $0xffffffffffffffff,%rbp
nopl   0x0(%rax,%rax,1)
mov    %eax,%ecx
shl    $0x2,%rcx
mov    (%rdi,%rcx,1),%esi
mov    %ebp,%ebx
shl    $0x2,%rbx
mov    %esi,(%rdi,%rbx,1)
mov    0x4d8(%rdi,%rcx,1),%ecx
mov    %ecx,0x4d8(%rdi,%rbx,1)
add    $0xffffffffffffffff,%rax
lea    -0x1(%rbp),%rcx
add    $0x1,%rbp
cmp    $0x2,%rbp
mov    %rcx,%rbp
ja     1140 <moveSnakeArray+0x40>
add    $0xffffffbf,%edx
cmp    $0x3,%edx
ja     119c <moveSnakeArray+0x9c>
movslq %edx,%rax
lea    0xe79(%rip),%rcx
lea    0xe92(%rip),%rdx
imul   $0x4d8,(%rcx,%rax,8),%rcx
mov    (%rdx,%rax,4),%eax
add    %eax,(%rdi,%rcx,1)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %ebp,%ebx
sub    $0x2,%ebx
cmovb  %r9d,%ebx
mov    %rbp,%rcx
sub    $0x2,%rcx
cmovae %rcx,%r9
lea    -0x1(%rsi),%r10d
cmp    %ebx,%r10d
jb     1134 <moveSnakeArray+0x34>
mov    %r9,%rcx
shr    $0x20,%rcx
jne    1134 <moveSnakeArray+0x34>
add    $0xfffffffe,%esi
cmp    %ebx,%esi
jb     1134 <moveSnakeArray+0x34>
test   %rcx,%rcx
jne    1134 <moveSnakeArray+0x34>
lea    (%rdi,%r10,4),%rbx
shl    $0x2,%r9
mov    %rbx,%rcx
sub    %r9,%rcx
cmp    %rbx,%rcx
ja     1134 <moveSnakeArray+0x34>
xor    %ecx,%ecx
test   %cl,%cl
jne    1134 <moveSnakeArray+0x34>
lea    (%rdi,%r10,4),%rbx
add    $0x4d8,%rbx
mov    %rbx,%rcx
sub    %r9,%rcx
cmp    %rbx,%rcx
ja     1134 <moveSnakeArray+0x34>
xor    %ecx,%ecx
test   %cl,%cl
jne    1134 <moveSnakeArray+0x34>
lea    (%rdi,%rsi,4),%rbx
mov    %rbx,%rcx
sub    %r9,%rcx
cmp    %rbx,%rcx
ja     1134 <moveSnakeArray+0x34>
xor    %ecx,%ecx
test   %cl,%cl
jne    1134 <moveSnakeArray+0x34>
lea    (%rdi,%rsi,4),%rbx
add    $0x4d8,%rbx
mov    %rbx,%rcx
sub    %r9,%rcx
cmp    %rbx,%rcx
ja     1134 <moveSnakeArray+0x34>
xor    %ecx,%ecx
test   %cl,%cl
jne    1134 <moveSnakeArray+0x34>
cmp    $0x2,%rbp
mov    $0x2,%ecx
cmovb  %rbp,%rcx
lea    (%rcx,%r10,1),%rbx
sub    %rbp,%rbx
lea    (%rdi,%rbx,4),%r9
lea    (%rdi,%r10,4),%r14
add    $0x4,%r14
lea    (%rdi,%rbx,4),%rbx
add    $0x4d8,%rbx
lea    (%rdi,%r10,4),%r15
add    $0x4dc,%r15
add    %rsi,%rcx
sub    %rbp,%rcx
lea    (%rdi,%rcx,4),%r10
lea    (%rdi,%rsi,4),%r13
add    $0x4,%r13
lea    (%rdi,%rcx,4),%r12
add    $0x4d8,%r12
lea    (%rdi,%rsi,4),%r11
add    $0x4dc,%r11
cmp    %r15,%r9
setb   -0x1(%rsp)
cmp    %r14,%rbx
setb   -0x2(%rsp)
cmp    %r13,%r9
setb   %cl
cmp    %r14,%r10
setb   -0x3(%rsp)
cmp    %r11,%r9
setb   %sil
cmp    %r14,%r12
setb   %r14b
cmp    %r13,%rbx
setb   %r9b
cmp    %r15,%r10
setb   %r13b
cmp    %r11,%rbx
setb   %r10b
cmp    %r15,%r12
setb   %r15b
mov    -0x2(%rsp),%bl
test   %bl,-0x1(%rsp)
jne    1134 <moveSnakeArray+0x34>
and    -0x3(%rsp),%cl
jne    1134 <moveSnakeArray+0x34>
and    %r14b,%sil
jne    1134 <moveSnakeArray+0x34>
and    %r13b,%r9b
jne    1134 <moveSnakeArray+0x34>
and    %r15b,%r10b
jne    1134 <moveSnakeArray+0x34>
mov    %r8,%r9
and    $0xfffffffffffffffc,%r9
lea    -0x4(%r9),%rcx
mov    %rcx,%r10
shr    $0x2,%r10
add    $0x1,%r10
test   %rcx,%rcx
je     140f <moveSnakeArray+0x30f>
mov    %r10,%r14
and    $0xfffffffffffffffe,%r14
lea    (%rax,%rbp,1),%rbx
add    $0xfffffffffffffffc,%rbx
xor    %r11d,%r11d
nopl   0x0(%rax)
lea    0x5(%rbx),%ecx
lea    0x4(%rbx),%esi
movups -0xc(%rdi,%rsi,4),%xmm0
movups %xmm0,-0xc(%rdi,%rcx,4)
movups 0x4cc(%rdi,%rsi,4),%xmm0
movups %xmm0,0x4cc(%rdi,%rcx,4)
mov    %ebx,%ecx
lea    0x1(%rbx),%esi
shl    $0x2,%rcx
movups -0xc(%rdi,%rcx,1),%xmm0
movups %xmm0,-0xc(%rdi,%rsi,4)
movups 0x4cc(%rdi,%rcx,1),%xmm0
movups %xmm0,0x4cc(%rdi,%rsi,4)
add    $0x8,%r11
add    $0xfffffffffffffff8,%rbx
add    $0xfffffffffffffffe,%r14
jne    1380 <moveSnakeArray+0x280>
test   $0x1,%r10b
je     13fe <moveSnakeArray+0x2fe>
mov    %ebp,%ecx
sub    %r11d,%ecx
lea    (%rax,%rcx,1),%esi
add    %eax,%ecx
add    $0x1,%ecx
movups -0xc(%rdi,%rsi,4),%xmm0
movups %xmm0,-0xc(%rdi,%rcx,4)
movups 0x4cc(%rdi,%rsi,4),%xmm0
movups %xmm0,0x4cc(%rdi,%rcx,4)
cmp    %r9,%r8
je     1175 <moveSnakeArray+0x75>
sub    %r9,%rbp
jmp    1134 <moveSnakeArray+0x34>
xor    %r11d,%r11d
test   $0x1,%r10b
jne    13d7 <moveSnakeArray+0x2d7>
jmp    13fe <moveSnakeArray+0x2fe>

LLVM IR (-O0):
define void @moveSnakeArray([310 x i32]* %0, i32 %1, i32 %2) {
%4 = alloca [310 x i32]*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
store [310 x i32]* %0, [310 x i32]** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
%8 = load i32, i32* %5
%9 = sub nsw i32 %8, 1
store i32 %9, i32* %7
br label %10
10: ; preds = %38, %3
%11 = load i32, i32* %7
%12 = icmp sge i32 %11, 1
br i1 %12, label %13, label %41
13: ; preds = %10
%14 = load [310 x i32]*, [310 x i32]** %4
%15 = getelementptr inbounds [310 x i32], [310 x i32]* %14, i64 0
%16 = load i32, i32* %7
%17 = sub nsw i32 %16, 1
%18 = sext i32 %17 to i64
%19 = getelementptr inbounds [310 x i32], [310 x i32]* %15, i64 0, i64 %18
%20 = load i32, i32* %19
%21 = load [310 x i32]*, [310 x i32]** %4
%22 = getelementptr inbounds [310 x i32], [310 x i32]* %21, i64 0
%23 = load i32, i32* %7
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds [310 x i32], [310 x i32]* %22, i64 0, i64 %24
store i32 %20, i32* %25
%26 = load [310 x i32]*, [310 x i32]** %4
%27 = getelementptr inbounds [310 x i32], [310 x i32]* %26, i64 1
%28 = load i32, i32* %7
%29 = sub nsw i32 %28, 1
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds [310 x i32], [310 x i32]* %27, i64 0, i64 %30
%32 = load i32, i32* %31
%33 = load [310 x i32]*, [310 x i32]** %4
%34 = getelementptr inbounds [310 x i32], [310 x i32]* %33, i64 1
%35 = load i32, i32* %7
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [310 x i32], [310 x i32]* %34, i64 0, i64 %36
store i32 %32, i32* %37
br label %38
38: ; preds = %13
%39 = load i32, i32* %7
%40 = add nsw i32 %39, -1
store i32 %40, i32* %7
br label %10
41: ; preds = %10
%42 = load i32, i32* %6
switch i32 %42, label %67 [
i32 66, label %43
i32 67, label %49
i32 65, label %55
i32 68, label %61
]
43: ; preds = %41
%44 = load [310 x i32]*, [310 x i32]** %4
%45 = getelementptr inbounds [310 x i32], [310 x i32]* %44, i64 1
%46 = getelementptr inbounds [310 x i32], [310 x i32]* %45, i64 0, i64 0
%47 = load i32, i32* %46
%48 = add nsw i32 %47, 1
store i32 %48, i32* %46
br label %67
49: ; preds = %41
%50 = load [310 x i32]*, [310 x i32]** %4
%51 = getelementptr inbounds [310 x i32], [310 x i32]* %50, i64 0
%52 = getelementptr inbounds [310 x i32], [310 x i32]* %51, i64 0, i64 0
%53 = load i32, i32* %52
%54 = add nsw i32 %53, 1
store i32 %54, i32* %52
br label %67
55: ; preds = %41
%56 = load [310 x i32]*, [310 x i32]** %4
%57 = getelementptr inbounds [310 x i32], [310 x i32]* %56, i64 1
%58 = getelementptr inbounds [310 x i32], [310 x i32]* %57, i64 0, i64 0
%59 = load i32, i32* %58
%60 = add nsw i32 %59, -1
store i32 %60, i32* %58
br label %67
61: ; preds = %41
%62 = load [310 x i32]*, [310 x i32]** %4
%63 = getelementptr inbounds [310 x i32], [310 x i32]* %62, i64 0
%64 = getelementptr inbounds [310 x i32], [310 x i32]* %63, i64 0, i64 0
%65 = load i32, i32* %64
%66 = add nsw i32 %65, -1
store i32 %66, i32* %64
br label %67
67: ; preds = %41, %61, %55, %49, %43
ret void
}

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