void predict_16x16_h(unsigned char *src, unsigned int src_stride,
                     unsigned char *dst, unsigned int dst_stride,
                     int neighbour) {
  int i;
  for (i = 0; i < 16; i++) {
    const unsigned int v = 0x01010101 * src[-1];
    unsigned int *p = (unsigned int *)dst;
    *p++ = v;
    *p++ = v;
    *p++ = v;
    *p++ = v;
    src += src_stride;
    dst += dst_stride;
  }
}


x86 assembly (clang, -O0):
<predict_16x16_h>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x10,-0x24(%rbp)
jge    11be <predict_16x16_h+0xbe>
mov    -0x8(%rbp),%rax
movzbl -0x1(%rax),%eax
imul   $0x1010101,%eax,%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
mov    -0x28(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
mov    -0x28(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
mov    -0x28(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
mov    -0xc(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,%ecx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,%ecx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    111d <predict_16x16_h+0x1d>
pop    %rbp
ret

x86 assembly (clang, -O2):
<predict_16x16_h>:
mov    %esi,%esi
mov    %ecx,%eax
movzbl -0x1(%rdi),%ecx
imul   $0x1010101,%ecx,%ecx
movd   %ecx,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqu %xmm0,(%rdx)
movzbl -0x1(%rdi,%rsi,1),%ecx
add    %rsi,%rdi
imul   $0x1010101,%ecx,%ecx
movd   %ecx,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqu %xmm0,(%rdx,%rax,1)
add    %rax,%rdx
movzbl -0x1(%rsi,%rdi,1),%ecx
add    %rsi,%rdi
imul   $0x1010101,%ecx,%ecx
movd   %ecx,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqu %xmm0,(%rax,%rdx,1)
add    %rax,%rdx
movzbl -0x1(%rsi,%rdi,1),%ecx
add    %rsi,%rdi
imul   $0x1010101,%ecx,%ecx
movd   %ecx,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqu %xmm0,(%rax,%rdx,1)
add    %rax,%rdx
movzbl -0x1(%rsi,%rdi,1),%ecx
add    %rsi,%rdi
imul   $0x1010101,%ecx,%ecx
movd   %ecx,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqu %xmm0,(%rax,%rdx,1)
add    %rax,%rdx
lea    (%rdx,%rax,1),%r9
movzbl -0x1(%rsi,%rdi,1),%r8d
add    %rsi,%rdi
imul   $0x1010101,%r8d,%ecx
mov    %ecx,(%rax,%rdx,1)
mov    %ecx,0x4(%rax,%rdx,1)
mov    %ecx,0x8(%rax,%rdx,1)
mov    %ecx,0xc(%rax,%rdx,1)
lea    (%r9,%rax,1),%r10
movzbl -0x1(%rsi,%rdi,1),%edx
add    %rsi,%rdi
imul   $0x1010101,%edx,%edx
mov    %edx,(%rax,%r9,1)
mov    %edx,0x4(%rax,%r9,1)
mov    %edx,0x8(%rax,%r9,1)
mov    %edx,0xc(%rax,%r9,1)
lea    (%r10,%rax,1),%rdx
movzbl -0x1(%rsi,%rdi,1),%r8d
add    %rsi,%rdi
imul   $0x1010101,%r8d,%ecx
mov    %ecx,(%rax,%r10,1)
mov    %ecx,0x4(%rax,%r10,1)
mov    %ecx,0x8(%rax,%r10,1)
mov    %ecx,0xc(%rax,%r10,1)
lea    (%rdx,%rax,1),%r9
movzbl -0x1(%rsi,%rdi,1),%r8d
add    %rsi,%rdi
imul   $0x1010101,%r8d,%ecx
mov    %ecx,(%rax,%rdx,1)
mov    %ecx,0x4(%rax,%rdx,1)
mov    %ecx,0x8(%rax,%rdx,1)
mov    %ecx,0xc(%rax,%rdx,1)
lea    (%r9,%rax,1),%r10
movzbl -0x1(%rsi,%rdi,1),%edx
add    %rsi,%rdi
imul   $0x1010101,%edx,%edx
mov    %edx,(%rax,%r9,1)
mov    %edx,0x4(%rax,%r9,1)
mov    %edx,0x8(%rax,%r9,1)
mov    %edx,0xc(%rax,%r9,1)
lea    (%r10,%rax,1),%rdx
movzbl -0x1(%rsi,%rdi,1),%r8d
add    %rsi,%rdi
imul   $0x1010101,%r8d,%ecx
mov    %ecx,(%rax,%r10,1)
mov    %ecx,0x4(%rax,%r10,1)
mov    %ecx,0x8(%rax,%r10,1)
mov    %ecx,0xc(%rax,%r10,1)
lea    (%rdx,%rax,1),%r9
movzbl -0x1(%rsi,%rdi,1),%r8d
add    %rsi,%rdi
imul   $0x1010101,%r8d,%ecx
mov    %ecx,(%rax,%rdx,1)
mov    %ecx,0x4(%rax,%rdx,1)
mov    %ecx,0x8(%rax,%rdx,1)
mov    %ecx,0xc(%rax,%rdx,1)
lea    (%r9,%rax,1),%r10
movzbl -0x1(%rsi,%rdi,1),%edx
add    %rsi,%rdi
imul   $0x1010101,%edx,%edx
mov    %edx,(%rax,%r9,1)
mov    %edx,0x4(%rax,%r9,1)
mov    %edx,0x8(%rax,%r9,1)
mov    %edx,0xc(%rax,%r9,1)
lea    (%r10,%rax,1),%rdx
movzbl -0x1(%rsi,%rdi,1),%r8d
add    %rsi,%rdi
imul   $0x1010101,%r8d,%ecx
mov    %ecx,(%rax,%r10,1)
mov    %ecx,0x4(%rax,%r10,1)
mov    %ecx,0x8(%rax,%r10,1)
mov    %ecx,0xc(%rax,%r10,1)
lea    (%rdx,%rax,1),%r9
movzbl -0x1(%rsi,%rdi,1),%r8d
add    %rsi,%rdi
imul   $0x1010101,%r8d,%ecx
mov    %ecx,(%rax,%rdx,1)
mov    %ecx,0x4(%rax,%rdx,1)
mov    %ecx,0x8(%rax,%rdx,1)
mov    %ecx,0xc(%rax,%rdx,1)
movzbl -0x1(%rsi,%rdi,1),%ecx
imul   $0x1010101,%ecx,%ecx
mov    %ecx,(%rax,%r9,1)
mov    %ecx,0x4(%rax,%r9,1)
mov    %ecx,0x8(%rax,%r9,1)
mov    %ecx,0xc(%rax,%r9,1)
ret

LLVM IR (-O0):
define void @predict_16x16_h(i8* %0, i32 %1, i8* %2, i32 %3, i32 %4) {
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32*
store i8* %0, i8** %6
store i32 %1, i32* %7
store i8* %2, i8** %8
store i32 %3, i32* %9
store i32 %4, i32* %10
store i32 0, i32* %11
br label %14
14: ; preds = %45, %5
%15 = load i32, i32* %11
%16 = icmp slt i32 %15, 16
br i1 %16, label %17, label %48
17: ; preds = %14
%18 = load i8*, i8** %6
%19 = getelementptr inbounds i8, i8* %18, i64 -1
%20 = load i8, i8* %19
%21 = zext i8 %20 to i32
%22 = mul nsw i32 16843009, %21
store i32 %22, i32* %12
%23 = load i8*, i8** %8
%24 = bitcast i8* %23 to i32*
store i32* %24, i32** %13
%25 = load i32, i32* %12
%26 = load i32*, i32** %13
%27 = getelementptr inbounds i32, i32* %26, i32 1
store i32* %27, i32** %13
store i32 %25, i32* %26
%28 = load i32, i32* %12
%29 = load i32*, i32** %13
%30 = getelementptr inbounds i32, i32* %29, i32 1
store i32* %30, i32** %13
store i32 %28, i32* %29
%31 = load i32, i32* %12
%32 = load i32*, i32** %13
%33 = getelementptr inbounds i32, i32* %32, i32 1
store i32* %33, i32** %13
store i32 %31, i32* %32
%34 = load i32, i32* %12
%35 = load i32*, i32** %13
%36 = getelementptr inbounds i32, i32* %35, i32 1
store i32* %36, i32** %13
store i32 %34, i32* %35
%37 = load i32, i32* %7
%38 = load i8*, i8** %6
%39 = zext i32 %37 to i64
%40 = getelementptr inbounds i8, i8* %38, i64 %39
store i8* %40, i8** %6
%41 = load i32, i32* %9
%42 = load i8*, i8** %8
%43 = zext i32 %41 to i64
%44 = getelementptr inbounds i8, i8* %42, i64 %43
store i8* %44, i8** %8
br label %45
45: ; preds = %17
%46 = load i32, i32* %11
%47 = add nsw i32 %46, 1
store i32 %47, i32* %11
br label %14
48: ; preds = %14
ret void
}

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