void memset_RGB24(void *adr, int r, int v, int b, long count) {
  long i, n;
  register long v1, v2, v3, *pt = (long *)(adr);
  unsigned char *p, R = (unsigned char)r, V = (unsigned char)v,
                    B = (unsigned char)b;
  p = (unsigned char *)adr;
  *p++ = R;
  *p++ = V;
  *p++ = B;
  *p++ = R;
  *p++ = V;
  *p++ = B;
  *p++ = R;
  *p++ = V;
  *p++ = B;
  *p++ = R;
  *p++ = V;
  *p++ = B;
  v1 = *pt++;
  v2 = *pt++;
  v3 = *pt++;
  n = count >> 2;
  for (i = 1; i < n; i++) {
    *pt++ = v1;
    *pt++ = v2;
    *pt++ = v3;
  }
}


x86 assembly (clang, -O0):
<memset_RGB24>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0xc(%rbp),%eax
mov    %al,-0x59(%rbp)
mov    -0x10(%rbp),%eax
mov    %al,-0x5a(%rbp)
mov    -0x14(%rbp),%eax
mov    %al,-0x5b(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x59(%rbp),%cl
mov    -0x58(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x58(%rbp)
mov    %cl,(%rax)
mov    -0x5a(%rbp),%cl
mov    -0x58(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x58(%rbp)
mov    %cl,(%rax)
mov    -0x5b(%rbp),%cl
mov    -0x58(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x58(%rbp)
mov    %cl,(%rax)
mov    -0x59(%rbp),%cl
mov    -0x58(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x58(%rbp)
mov    %cl,(%rax)
mov    -0x5a(%rbp),%cl
mov    -0x58(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x58(%rbp)
mov    %cl,(%rax)
mov    -0x5b(%rbp),%cl
mov    -0x58(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x58(%rbp)
mov    %cl,(%rax)
mov    -0x59(%rbp),%cl
mov    -0x58(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x58(%rbp)
mov    %cl,(%rax)
mov    -0x5a(%rbp),%cl
mov    -0x58(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x58(%rbp)
mov    %cl,(%rax)
mov    -0x5b(%rbp),%cl
mov    -0x58(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x58(%rbp)
mov    %cl,(%rax)
mov    -0x59(%rbp),%cl
mov    -0x58(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x58(%rbp)
mov    %cl,(%rax)
mov    -0x5a(%rbp),%cl
mov    -0x58(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x58(%rbp)
mov    %cl,(%rax)
mov    -0x5b(%rbp),%cl
mov    -0x58(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x58(%rbp)
mov    %cl,(%rax)
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x50(%rbp)
mov    (%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x50(%rbp)
mov    (%rax),%rax
mov    %rax,-0x40(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x50(%rbp)
mov    (%rax),%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
sar    $0x2,%rax
mov    %rax,-0x30(%rbp)
movq   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x30(%rbp),%rax
jge    12de <memset_RGB24+0x1de>
mov    -0x38(%rbp),%rcx
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x50(%rbp)
mov    %rcx,(%rax)
mov    -0x40(%rbp),%rcx
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x50(%rbp)
mov    %rcx,(%rax)
mov    -0x48(%rbp),%rcx
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x50(%rbp)
mov    %rcx,(%rax)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    127d <memset_RGB24+0x17d>
pop    %rbp
ret

x86 assembly (clang, -O2):
<memset_RGB24>:
mov    %sil,(%rdi)
mov    %dl,0x1(%rdi)
mov    %cl,0x2(%rdi)
mov    %sil,0x3(%rdi)
mov    %dl,0x4(%rdi)
mov    %cl,0x5(%rdi)
mov    %sil,0x6(%rdi)
mov    %dl,0x7(%rdi)
mov    %cl,0x8(%rdi)
mov    %sil,0x9(%rdi)
mov    %dl,0xa(%rdi)
mov    %cl,0xb(%rdi)
cmp    $0x8,%r8
jl     11e2 <memset_RGB24+0xe2>
movups (%rdi),%xmm0
mov    0x10(%rdi),%rax
shr    $0x2,%r8
add    $0x18,%rdi
lea    -0x1(%r8),%rdx
add    $0xfffffffffffffffe,%r8
mov    %edx,%ecx
and    $0x7,%ecx
cmp    $0x7,%r8
jb     11bb <memset_RGB24+0xbb>
and    $0xfffffffffffffff8,%rdx
nopw   0x0(%rax,%rax,1)
movups %xmm0,(%rdi)
mov    %rax,0x10(%rdi)
movups %xmm0,0x18(%rdi)
mov    %rax,0x28(%rdi)
movups %xmm0,0x30(%rdi)
mov    %rax,0x40(%rdi)
movups %xmm0,0x48(%rdi)
mov    %rax,0x58(%rdi)
movups %xmm0,0x60(%rdi)
mov    %rax,0x70(%rdi)
movups %xmm0,0x78(%rdi)
mov    %rax,0x88(%rdi)
movups %xmm0,0x90(%rdi)
mov    %rax,0xa0(%rdi)
movups %xmm0,0xa8(%rdi)
mov    %rax,0xb8(%rdi)
add    $0xc0,%rdi
add    $0xfffffffffffffff8,%rdx
jne    1160 <memset_RGB24+0x60>
test   %rcx,%rcx
je     11e2 <memset_RGB24+0xe2>
shl    $0x3,%rcx
lea    (%rcx,%rcx,2),%rcx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups %xmm0,(%rdi,%rdx,1)
mov    %rax,0x10(%rdi,%rdx,1)
add    $0x18,%rdx
cmp    %rdx,%rcx
jne    11d0 <memset_RGB24+0xd0>
ret

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

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