int get_ctx(int x, int y, unsigned char *p) {
  int v;
  v = 0;
  v = v * 3;
  if (y >= 4) {
    v += p[-3 * (128 + 2 * 4)] << 0;
  } else {
    v += 2;
  }
  v = v * 3;
  if (x >= 4) {
    v += (p[-3]) << 0;
  } else {
    v += 2;
  }
  v = v << 2;
  v += p[-2 * (128 + 2 * 4) + 2] << 0;
  v += p[-2 * (128 + 2 * 4) - 2] << 1;
  v = v << 1;
  v += p[-2] << 0;
  v = v << 3;
  v += p[-2 * (128 + 2 * 4) - 1] << 0;
  v += p[-2 * (128 + 2 * 4)] << 1;
  v += p[-2 * (128 + 2 * 4) + 1] << 2;
  v = v << 4;
  v += p[-(128 + 2 * 4) - 1] << 0;
  v += p[-(128 + 2 * 4) + 1] << 1;
  v += p[-(128 + 2 * 4) + 2] << 2;
  v += p[-(128 + 2 * 4) - 2] << 3;
  v = v << 2;
  v += p[-1] << 0;
  v += p[-(128 + 2 * 4)] << 1;
  return v;
}


x86 assembly (clang, -O0):
<get_ctx>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
imul   $0x3,-0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x4,-0x8(%rbp)
jl     113f <get_ctx+0x3f>
mov    -0x10(%rbp),%rax
movzbl -0x198(%rax),%eax
shl    $0x0,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    1148 <get_ctx+0x48>
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
imul   $0x3,-0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x4,-0x4(%rbp)
jl     116f <get_ctx+0x6f>
mov    -0x10(%rbp),%rax
movzbl -0x3(%rax),%eax
shl    $0x0,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    1178 <get_ctx+0x78>
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movzbl -0x10e(%rax),%eax
shl    $0x0,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movzbl -0x112(%rax),%eax
shl    $0x1,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movzbl -0x2(%rax),%eax
shl    $0x0,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x3,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movzbl -0x111(%rax),%eax
shl    $0x0,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movzbl -0x110(%rax),%eax
shl    $0x1,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movzbl -0x10f(%rax),%eax
shl    $0x2,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x4,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movzbl -0x89(%rax),%eax
shl    $0x0,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movzbl -0x87(%rax),%eax
shl    $0x1,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movzbl -0x86(%rax),%eax
shl    $0x2,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movzbl -0x8a(%rax),%eax
shl    $0x3,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movzbl -0x1(%rax),%eax
shl    $0x0,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movzbl -0x88(%rax),%eax
shl    $0x1,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_ctx>:
mov    $0x6,%eax
cmp    $0x4,%esi
jl     1114 <get_ctx+0x14>
movzbl -0x198(%rdx),%eax
lea    (%rax,%rax,2),%eax
mov    $0x2,%ecx
cmp    $0x4,%edi
jl     1122 <get_ctx+0x22>
movzbl -0x3(%rdx),%ecx
add    %eax,%ecx
movzbl -0x10e(%rdx),%eax
lea    (%rax,%rcx,4),%eax
movzbl -0x112(%rdx),%ecx
lea    (%rax,%rcx,2),%eax
movzbl -0x2(%rdx),%ecx
lea    (%rcx,%rax,2),%eax
movzbl -0x111(%rdx),%ecx
movzbl -0x110(%rdx),%esi
movzbl -0x10f(%rdx),%edi
lea    (%rcx,%rsi,2),%ecx
lea    (%rcx,%rax,8),%eax
lea    (%rax,%rdi,4),%eax
shl    $0x4,%eax
movzbl -0x89(%rdx),%ecx
movzbl -0x87(%rdx),%esi
movzbl -0x86(%rdx),%edi
movzbl -0x8a(%rdx),%r8d
ff
lea    (%rcx,%rsi,2),%ecx
lea    (%rcx,%rdi,4),%ecx
add    %eax,%ecx
lea    (%rcx,%r8,8),%eax
movzbl -0x1(%rdx),%ecx
movzbl -0x88(%rdx),%edx
lea    (%rcx,%rdx,2),%ecx
lea    (%rcx,%rax,4),%eax
ret

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

LLVM IR (-O2):
define i32 @get_ctx(i32 %0, i32 %1, i8* nocapture %2) {
%4 = icmp sgt i32 %1, 3
br i1 %4, label %5, label %10
5: ; preds = %3
%6 = getelementptr inbounds i8, i8* %2, i64 -408
%7 = load i8, i8* %6
%8 = zext i8 %7 to i32
%9 = mul nuw nsw i32 %8, 3
br label %10
10: ; preds = %3, %5
%11 = phi i32 [ %9, %5 ], [ 6, %3 ]
%12 = icmp sgt i32 %0, 3
br i1 %12, label %13, label %17
13: ; preds = %10
%14 = getelementptr inbounds i8, i8* %2, i64 -3
%15 = load i8, i8* %14
%16 = zext i8 %15 to i32
br label %17
17: ; preds = %10, %13
%18 = phi i32 [ %16, %13 ], [ 2, %10 ]
%19 = add nuw nsw i32 %18, %11
%20 = shl nuw nsw i32 %19, 2
%21 = getelementptr inbounds i8, i8* %2, i64 -270
%22 = load i8, i8* %21
%23 = zext i8 %22 to i32
%24 = add nuw nsw i32 %20, %23
%25 = getelementptr inbounds i8, i8* %2, i64 -274
%26 = load i8, i8* %25
%27 = zext i8 %26 to i32
%28 = shl nuw nsw i32 %27, 1
%29 = add nuw nsw i32 %24, %28
%30 = shl nuw nsw i32 %29, 1
%31 = getelementptr inbounds i8, i8* %2, i64 -2
%32 = load i8, i8* %31
%33 = zext i8 %32 to i32
%34 = add nuw nsw i32 %30, %33
%35 = shl nuw nsw i32 %34, 3
%36 = getelementptr inbounds i8, i8* %2, i64 -273
%37 = load i8, i8* %36
%38 = zext i8 %37 to i32
%39 = getelementptr inbounds i8, i8* %2, i64 -272
%40 = load i8, i8* %39
%41 = zext i8 %40 to i32
%42 = shl nuw nsw i32 %41, 1
%43 = getelementptr inbounds i8, i8* %2, i64 -271
%44 = load i8, i8* %43
%45 = zext i8 %44 to i32
%46 = shl nuw nsw i32 %45, 2
%47 = add nuw nsw i32 %42, %38
%48 = add nuw nsw i32 %47, %35
%49 = add nuw nsw i32 %48, %46
%50 = shl nuw nsw i32 %49, 4
%51 = getelementptr inbounds i8, i8* %2, i64 -137
%52 = load i8, i8* %51
%53 = zext i8 %52 to i32
%54 = getelementptr inbounds i8, i8* %2, i64 -135
%55 = load i8, i8* %54
%56 = zext i8 %55 to i32
%57 = shl nuw nsw i32 %56, 1
%58 = getelementptr inbounds i8, i8* %2, i64 -134
%59 = load i8, i8* %58
%60 = zext i8 %59 to i32
%61 = shl nuw nsw i32 %60, 2
%62 = getelementptr inbounds i8, i8* %2, i64 -138
%63 = load i8, i8* %62
%64 = zext i8 %63 to i32
%65 = shl nuw nsw i32 %64, 3
%66 = add nuw nsw i32 %57, %53
%67 = add nuw nsw i32 %66, %61
%68 = add nuw nsw i32 %67, %50
%69 = add nuw nsw i32 %68, %65
%70 = shl nuw nsw i32 %69, 2
%71 = getelementptr inbounds i8, i8* %2, i64 -1
%72 = load i8, i8* %71
%73 = zext i8 %72 to i32
%74 = getelementptr inbounds i8, i8* %2, i64 -136
%75 = load i8, i8* %74
%76 = zext i8 %75 to i32
%77 = shl nuw nsw i32 %76, 1
%78 = add nuw nsw i32 %77, %73
%79 = add nuw nsw i32 %78, %70
ret i32 %79
}