int MMask_evaluateSymbol(int width, unsigned char *frame) {
  int x, y;
  unsigned char *p;
  int sum1 = 0, sum2 = 0;
  p = frame + width * (width - 1);
  for (x = 1; x < width; x++) {
    sum1 += (p[x] & 1);
  }
  p = frame + width * 2 - 1;
  for (y = 1; y < width; y++) {
    sum2 += (*p & 1);
    p += width;
  }
  return (sum1 <= sum2) ? (sum1 * 16 + sum2) : (sum2 * 16 + sum1);
}


x86 assembly (clang, -O0):
<MMask_evaluateSymbol>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
mov    -0x4(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1169 <MMask_evaluateSymbol+0x69>
mov    -0x20(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
and    $0x1,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    113a <MMask_evaluateSymbol+0x3a>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11c3 <MMask_evaluateSymbol+0xc3>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
and    $0x1,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x4(%rbp),%ecx
mov    -0x20(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1188 <MMask_evaluateSymbol+0x88>
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     11e0 <MMask_evaluateSymbol+0xe0>
mov    -0x24(%rbp),%eax
shl    $0x4,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    11ec <MMask_evaluateSymbol+0xec>
mov    -0x28(%rbp),%eax
shl    $0x4,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<MMask_evaluateSymbol>:
push   %rbx
xor    %ecx,%ecx
mov    $0x0,%edx
cmp    $0x2,%edi
jl     12e0 <MMask_evaluateSymbol+0x1e0>
lea    -0x1(%rdi),%r8d
mov    %r8d,%eax
imul   %edi,%eax
movslq %eax,%rdx
add    %rsi,%rdx
mov    %edi,%r9d
lea    -0x1(%r9),%r10
cmp    $0x8,%r10
jae    113a <MMask_evaluateSymbol+0x3a>
xor    %ecx,%ecx
mov    $0x1,%eax
jmp    1250 <MMask_evaluateSymbol+0x150>
mov    %r10,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rcx
mov    %rcx,%r11
shr    $0x3,%r11
add    $0x1,%r11
test   %rcx,%rcx
je     12f5 <MMask_evaluateSymbol+0x1f5>
mov    %r11,%rbx
and    $0xfffffffffffffffe,%rbx
pxor   %xmm2,%xmm2
mov    $0x1,%ecx
movdqa 0xe8f(%rip),%xmm3
pxor   %xmm0,%xmm0
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
movd   (%rdx,%rcx,1),%xmm5
movd   0x4(%rdx,%rcx,1),%xmm4
pand   %xmm3,%xmm5
pand   %xmm3,%xmm4
punpcklbw %xmm2,%xmm5
punpcklwd %xmm2,%xmm5
paddd  %xmm0,%xmm5
punpcklbw %xmm2,%xmm4
punpcklwd %xmm2,%xmm4
paddd  %xmm1,%xmm4
movd   0x8(%rdx,%rcx,1),%xmm0
movd   0xc(%rdx,%rcx,1),%xmm1
pand   %xmm3,%xmm0
pand   %xmm3,%xmm1
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
paddd  %xmm5,%xmm0
punpcklbw %xmm2,%xmm1
punpcklwd %xmm2,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rbx
jne    1180 <MMask_evaluateSymbol+0x80>
test   $0x1,%r11b
je     121e <MMask_evaluateSymbol+0x11e>
movd   (%rdx,%rcx,1),%xmm2
movd   0x4(%rdx,%rcx,1),%xmm3
movdqa 0xe06(%rip),%xmm4
pand   %xmm4,%xmm2
pand   %xmm4,%xmm3
pxor   %xmm4,%xmm4
punpcklbw %xmm4,%xmm2
punpcklwd %xmm4,%xmm2
paddd  %xmm2,%xmm0
punpcklbw %xmm4,%xmm3
punpcklwd %xmm4,%xmm3
paddd  %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ecx
cmp    %rax,%r10
je     1262 <MMask_evaluateSymbol+0x162>
or     $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rdx,%rax,1),%ebx
and    $0x1,%ebx
add    %ebx,%ecx
add    $0x1,%rax
cmp    %rax,%r9
jne    1250 <MMask_evaluateSymbol+0x150>
xor    %edx,%edx
cmp    $0x2,%edi
jl     12e0 <MMask_evaluateSymbol+0x1e0>
lea    (%rdi,%rdi,1),%eax
cltq
add    %rsi,%rax
add    $0xffffffffffffffff,%rax
add    $0xfffffffe,%edi
mov    %r8d,%esi
and    $0x3,%esi
cmp    $0x3,%edi
jae    1287 <MMask_evaluateSymbol+0x187>
xor    %edx,%edx
jmp    12c8 <MMask_evaluateSymbol+0x1c8>
and    $0xfffffffc,%r8d
xor    %edx,%edx
nopl   (%rax)
movzbl (%rax),%edi
and    $0x1,%edi
add    %edx,%edi
movzbl (%rax,%r9,1),%edx
add    %r9,%rax
and    $0x1,%edx
add    %edi,%edx
movzbl (%r9,%rax,1),%edi
add    %r9,%rax
and    $0x1,%edi
add    %edx,%edi
movzbl (%r9,%rax,1),%edx
add    %r9,%rax
and    $0x1,%edx
add    %edi,%edx
add    %r9,%rax
add    $0xfffffffc,%r8d
jne    1290 <MMask_evaluateSymbol+0x190>
test   %esi,%esi
je     12e0 <MMask_evaluateSymbol+0x1e0>
nopl   0x0(%rax)
movzbl (%rax),%edi
and    $0x1,%edi
add    %edi,%edx
add    %r9,%rax
add    $0xffffffff,%esi
jne    12d0 <MMask_evaluateSymbol+0x1d0>
mov    %ecx,%esi
shl    $0x4,%esi
add    %edx,%esi
mov    %edx,%eax
shl    $0x4,%eax
add    %ecx,%eax
cmp    %edx,%ecx
cmovbe %esi,%eax
pop    %rbx
ret
pxor   %xmm0,%xmm0
mov    $0x1,%ecx
pxor   %xmm1,%xmm1
test   $0x1,%r11b
jne    11e7 <MMask_evaluateSymbol+0xe7>
jmp    121e <MMask_evaluateSymbol+0x11e>

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

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