void update_sc_state(int **sign_state, int x, int y, int sign) {
  if (sign) {
    sign_state[y - 1][x - 1] |= (1 << 5);
    sign_state[y - 1][x] |= (1 << 1);
    sign_state[y - 1][x + 1] |= (1 << 7);
    sign_state[y][x - 1] |= (1 << 3);
    sign_state[y][x + 1] |= (1 << 3);
    sign_state[y + 1][x - 1] |= (1 << 7);
    sign_state[y + 1][x] |= (1 << 1);
    sign_state[y + 1][x + 1] |= (1 << 5);
  } else {
    sign_state[y - 1][x - 1] |= (1 << 4);
    sign_state[y - 1][x] |= (1 << 0);
    sign_state[y - 1][x + 1] |= (1 << 6);
    sign_state[y][x - 1] |= (1 << 2);
    sign_state[y][x + 1] |= (1 << 2);
    sign_state[y + 1][x - 1] |= (1 << 6);
    sign_state[y + 1][x] |= (1 << 0);
    sign_state[y + 1][x + 1] |= (1 << 4);
  }
}


x86 assembly (clang, -O0):
<update_sc_state>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
je     122a <update_sc_state+0x12a>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
or     $0x20,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
or     $0x2,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
or     $0x80,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
or     $0x8,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
or     $0x8,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
or     $0x80,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
or     $0x2,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
or     $0x20,%edx
mov    %edx,(%rax,%rcx,4)
jmp    132e <update_sc_state+0x22e>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
or     $0x10,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
or     $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
or     $0x40,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
or     $0x4,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
or     $0x4,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
or     $0x40,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
or     $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
or     $0x10,%edx
mov    %edx,(%rax,%rcx,4)
pop    %rbp
ret

x86 assembly (clang, -O2):
<update_sc_state>:
movslq %esi,%rax
lea    -0x1(%rax),%r8
movslq %edx,%r9
mov    -0x8(%rdi,%r9,8),%rsi
mov    -0x4(%rsi,%rax,4),%edx
test   %ecx,%ecx
je     1156 <update_sc_state+0x56>
or     $0x20,%edx
mov    %edx,(%rsi,%r8,4)
orb    $0x2,(%rsi,%rax,4)
orb    $0x80,0x4(%rsi,%rax,4)
mov    (%rdi,%r9,8),%rcx
orl    $0x8,(%rcx,%r8,4)
orb    $0x8,0x4(%rcx,%rax,4)
mov    0x8(%rdi,%r9,8),%rcx
orl    $0x80,(%rcx,%r8,4)
orb    $0x2,(%rcx,%rax,4)
lea    (%rcx,%rax,4),%rax
add    $0x4,%rax
mov    $0x20,%ecx
or     %ecx,(%rax)
ret
or     $0x10,%edx
mov    %edx,(%rsi,%r8,4)
orb    $0x1,(%rsi,%rax,4)
orb    $0x40,0x4(%rsi,%rax,4)
mov    (%rdi,%r9,8),%rcx
orl    $0x4,(%rcx,%r8,4)
orb    $0x4,0x4(%rcx,%rax,4)
mov    0x8(%rdi,%r9,8),%rcx
orl    $0x40,(%rcx,%r8,4)
orb    $0x1,(%rcx,%rax,4)
lea    (%rcx,%rax,4),%rax
add    $0x4,%rax
mov    $0x10,%ecx
or     %ecx,(%rax)
ret

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

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