int var_y(unsigned char *a, unsigned char *b, int s) {
  int i, j, var = 0;
  for (i = 3; i; i--) {
    for (j = 0; j < 8; j++) {
      var += (((a[j] - a[j + s]) ^ ((a[j] - a[j + s]) >> 31)) -
              ((a[j] - a[j + s]) >> 31));
    }
    a += s;
    b += s;
  }
  return 4 * var;
}


x86 assembly (clang, -O0):
<var_y>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x3,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
je     11e3 <var_y+0xe3>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x8,-0x1c(%rbp)
jge    11b3 <var_y+0xb3>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
mov    -0x1c(%rbp),%edx
add    -0x14(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
mov    -0x8(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    -0x8(%rbp),%rdx
mov    -0x1c(%rbp),%esi
add    -0x14(%rbp),%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
sub    %edx,%ecx
sar    $0x1f,%ecx
xor    %ecx,%eax
mov    -0x8(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    -0x8(%rbp),%rdx
mov    -0x1c(%rbp),%esi
add    -0x14(%rbp),%esi
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
sub    %edx,%ecx
sar    $0x1f,%ecx
sub    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    112e <var_y+0x2e>
mov    -0x14(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    111d <var_y+0x1d>
mov    -0x20(%rbp),%eax
shl    $0x2,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<var_y>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
movslq %edx,%rax
lea    (%rdi,%rax,1),%rdx
lea    (%rdx,%rax,1),%rcx
movq   (%rdi,%rax,1),%xmm2
movq   (%rax,%rdx,1),%xmm1
movd   0x1(%rdi,%rax,1),%xmm14
movzbl 0x5(%rdi,%rax,1),%esi
movq   (%rdi),%xmm7
movzwl 0x6(%rdi,%rax,1),%edi
movd   %edi,%xmm8
movd   %esi,%xmm13
movzbl 0x1(%rax,%rdx,1),%esi
mov    %esi,-0x4(%rsp)
movzbl 0x2(%rax,%rdx,1),%r10d
movzbl 0x3(%rax,%rdx,1),%r9d
movzbl 0x4(%rax,%rdx,1),%r8d
movzbl 0x5(%rax,%rdx,1),%ebp
movzbl 0x6(%rax,%rdx,1),%r12d
movzbl 0x7(%rax,%rdx,1),%r15d
movzbl (%rax,%rcx,1),%edx
movzbl 0x1(%rax,%rcx,1),%esi
movzbl 0x2(%rax,%rcx,1),%ebx
movzbl 0x3(%rax,%rcx,1),%edi
movzbl 0x4(%rax,%rcx,1),%r13d
movzbl 0x5(%rax,%rcx,1),%r14d
movzbl 0x6(%rax,%rcx,1),%r11d
movzbl 0x7(%rax,%rcx,1),%eax
movd   %edx,%xmm10
movd   %esi,%xmm9
movd   %ebx,%xmm11
movd   %edi,%xmm15
movd   %r8d,%xmm12
pxor   %xmm5,%xmm5
punpcklbw %xmm5,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpcklbw %xmm5,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm6
packuswb %xmm2,%xmm6
movdqa %xmm6,%xmm2
punpckhbw %xmm5,%xmm2
movdqa %xmm2,%xmm3
punpckhwd %xmm5,%xmm3
punpcklwd %xmm5,%xmm2
movdqa %xmm6,%xmm1
punpcklbw %xmm5,%xmm1
movdqa %xmm1,%xmm4
punpcklwd %xmm5,%xmm4
punpckhwd %xmm5,%xmm1
punpcklbw %xmm5,%xmm14
punpcklwd %xmm5,%xmm14
punpcklbw %xmm5,%xmm7
movdqa %xmm7,%xmm0
punpckhwd %xmm5,%xmm0
punpcklwd %xmm5,%xmm7
punpcklbw %xmm5,%xmm8
punpcklwd %xmm5,%xmm8
movd   %ebp,%xmm5
psrldq $0xf,%xmm6
punpcklqdq %xmm14,%xmm6
shufps $0x98,%xmm14,%xmm6
psubd  %xmm6,%xmm7
movd   %r12d,%xmm6
shufps $0xf4,%xmm14,%xmm13
movd   %r15d,%xmm14
shufps $0x42,%xmm8,%xmm13
movd   %r13d,%xmm8
psubd  %xmm13,%xmm0
movdqa %xmm0,%xmm13
psrad  $0x1f,%xmm13
paddd  %xmm13,%xmm0
pxor   %xmm13,%xmm0
movdqa %xmm7,%xmm13
psrad  $0x1f,%xmm13
paddd  %xmm13,%xmm7
pxor   %xmm13,%xmm7
movd   %r14d,%xmm13
paddd  %xmm0,%xmm7
movd   %r11d,%xmm0
punpckldq %xmm10,%xmm9
movd   %eax,%xmm10
punpckldq %xmm11,%xmm15
movd   %r10d,%xmm11
punpcklqdq %xmm9,%xmm15
punpckldq %xmm12,%xmm5
punpckldq %xmm6,%xmm14
punpcklqdq %xmm5,%xmm14
psubd  %xmm14,%xmm2
punpckldq %xmm8,%xmm13
punpckldq %xmm0,%xmm10
punpcklqdq %xmm13,%xmm10
psubd  %xmm10,%xmm4
movd   %r9d,%xmm0
punpckldq %xmm11,%xmm0
movss  -0x4(%rsp),%xmm5
movdqa %xmm1,%xmm6
shufps $0xc7,%xmm5,%xmm6
shufps $0x24,%xmm6,%xmm0
psubd  %xmm0,%xmm3
psubd  %xmm15,%xmm1
movdqa %xmm1,%xmm0
psrad  $0x1f,%xmm0
paddd  %xmm0,%xmm1
pxor   %xmm0,%xmm1
movdqa %xmm3,%xmm0
psrad  $0x1f,%xmm0
paddd  %xmm0,%xmm3
pxor   %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqa %xmm2,%xmm0
psrad  $0x1f,%xmm0
paddd  %xmm0,%xmm2
pxor   %xmm0,%xmm2
movdqa %xmm4,%xmm0
psrad  $0x1f,%xmm0
paddd  %xmm0,%xmm4
pxor   %xmm0,%xmm4
paddd  %xmm2,%xmm4
paddd  %xmm3,%xmm4
pshufd $0xee,%xmm4,%xmm0
paddd  %xmm4,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%ecx
pshufd $0xee,%xmm7,%xmm0
paddd  %xmm7,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%eax
add    %ecx,%eax
shl    $0x2,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @var_y(i8* nocapture %0, i8* nocapture readnone %1, i32 %2) {
%4 = sext i32 %2 to i64
%5 = getelementptr inbounds i8, i8* %0, i64 %4
%6 = getelementptr inbounds i8, i8* %5, i64 %4
%7 = bitcast i8* %5 to <8 x i8>*
%8 = load <8 x i8>, <8 x i8>* %7
%9 = bitcast i8* %6 to <8 x i8>*
%10 = load <8 x i8>, <8 x i8>* %9
%11 = shufflevector <8 x i8> %10, <8 x i8> poison, <16 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%12 = shufflevector <8 x i8> %8, <8 x i8> poison, <16 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%13 = shufflevector <16 x i8> %11, <16 x i8> %12, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23>
%14 = zext <16 x i8> %13 to <16 x i32>
%15 = add nsw i64 %4, 1
%16 = getelementptr inbounds i8, i8* %0, i64 %15
%17 = add nsw i64 %4, 2
%18 = add nsw i64 %4, 3
%19 = add nsw i64 %4, 4
%20 = bitcast i8* %16 to <4 x i8>*
%21 = load <4 x i8>, <4 x i8>* %20
%22 = zext <4 x i8> %21 to <4 x i32>
%23 = add nsw i64 %4, 5
%24 = getelementptr inbounds i8, i8* %0, i64 %23
%25 = load i8, i8* %24
%26 = zext i8 %25 to i32
%27 = add nsw i64 %4, 6
%28 = getelementptr inbounds i8, i8* %0, i64 %27
%29 = bitcast i8* %0 to <8 x i8>*
%30 = load <8 x i8>, <8 x i8>* %29
%31 = zext <8 x i8> %30 to <8 x i32>
%32 = add nsw i64 %4, 7
%33 = bitcast i8* %28 to <2 x i8>*
%34 = load <2 x i8>, <2 x i8>* %33
%35 = zext <2 x i8> %34 to <2 x i32>
%36 = shufflevector <16 x i32> %14, <16 x i32> undef, <8 x i32> <i32 15, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%37 = shufflevector <4 x i32> %22, <4 x i32> poison, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef>
%38 = shufflevector <8 x i32> %36, <8 x i32> %37, <8 x i32> <i32 0, i32 8, i32 9, i32 10, i32 11, i32 undef, i32 undef, i32 undef>
%39 = insertelement <8 x i32> %38, i32 %26, i64 5
%40 = shufflevector <2 x i32> %35, <2 x i32> poison, <8 x i32> <i32 0, i32 1, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%41 = shufflevector <8 x i32> %39, <8 x i32> %40, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 8, i32 9>
%42 = sub nsw <8 x i32> %31, %41
%43 = call <8 x i32> @llvm.abs.v8i32(<8 x i32> %42, i1 true)
%44 = getelementptr inbounds i8, i8* %5, i64 %15
%45 = load i8, i8* %44
%46 = zext i8 %45 to i32
%47 = getelementptr inbounds i8, i8* %5, i64 %17
%48 = load i8, i8* %47
%49 = zext i8 %48 to i32
%50 = getelementptr inbounds i8, i8* %5, i64 %18
%51 = load i8, i8* %50
%52 = zext i8 %51 to i32
%53 = getelementptr inbounds i8, i8* %5, i64 %19
%54 = load i8, i8* %53
%55 = zext i8 %54 to i32
%56 = getelementptr inbounds i8, i8* %5, i64 %23
%57 = load i8, i8* %56
%58 = zext i8 %57 to i32
%59 = getelementptr inbounds i8, i8* %5, i64 %27
%60 = load i8, i8* %59
%61 = zext i8 %60 to i32
%62 = getelementptr inbounds i8, i8* %5, i64 %32
%63 = load i8, i8* %62
%64 = zext i8 %63 to i32
%65 = getelementptr inbounds i8, i8* %6, i64 %4
%66 = load i8, i8* %65
%67 = zext i8 %66 to i32
%68 = getelementptr inbounds i8, i8* %6, i64 %15
%69 = load i8, i8* %68
%70 = zext i8 %69 to i32
%71 = getelementptr inbounds i8, i8* %6, i64 %17
%72 = load i8, i8* %71
%73 = zext i8 %72 to i32
%74 = getelementptr inbounds i8, i8* %6, i64 %18
%75 = load i8, i8* %74
%76 = zext i8 %75 to i32
%77 = getelementptr inbounds i8, i8* %6, i64 %19
%78 = load i8, i8* %77
%79 = zext i8 %78 to i32
%80 = getelementptr inbounds i8, i8* %6, i64 %23
%81 = load i8, i8* %80
%82 = zext i8 %81 to i32
%83 = getelementptr inbounds i8, i8* %6, i64 %27
%84 = load i8, i8* %83
%85 = zext i8 %84 to i32
%86 = getelementptr inbounds i8, i8* %6, i64 %32
%87 = load i8, i8* %86
%88 = zext i8 %87 to i32
%89 = insertelement <16 x i32> poison, i32 %88, i64 0
%90 = insertelement <16 x i32> %89, i32 %85, i64 1
%91 = insertelement <16 x i32> %90, i32 %82, i64 2
%92 = insertelement <16 x i32> %91, i32 %79, i64 3
%93 = insertelement <16 x i32> %92, i32 %76, i64 4
%94 = insertelement <16 x i32> %93, i32 %73, i64 5
%95 = insertelement <16 x i32> %94, i32 %70, i64 6
%96 = insertelement <16 x i32> %95, i32 %67, i64 7
%97 = insertelement <16 x i32> %96, i32 %64, i64 8
%98 = insertelement <16 x i32> %97, i32 %61, i64 9
%99 = insertelement <16 x i32> %98, i32 %58, i64 10
%100 = insertelement <16 x i32> %99, i32 %55, i64 11
%101 = insertelement <16 x i32> %100, i32 %52, i64 12
%102 = insertelement <16 x i32> %101, i32 %49, i64 13
%103 = insertelement <16 x i32> %102, i32 %46, i64 14
%104 = shufflevector <16 x i32> %103, <16 x i32> %14, <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 23>
%105 = sub nsw <16 x i32> %14, %104
%106 = call <16 x i32> @llvm.abs.v16i32(<16 x i32> %105, i1 true)
%107 = call i32 @llvm.vector.reduce.add.v16i32(<16 x i32> %106)
%108 = call i32 @llvm.vector.reduce.add.v8i32(<8 x i32> %43)
%109 = add nuw nsw i32 %107, %108
%110 = shl nuw nsw i32 %109, 2
ret i32 %110
}