#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int uint32_t;

/* Variables and functions */
void f2m_reduce(uint32_t *C) {
  uint32_t j, t;
  for (j = 10; j > 5; j--) {
    t = C[j];
    C[j - 6] = C[j - 6] ^ (t << 29);
    C[j - 5] = C[j - 5] ^ (t << 4) ^ (t << 3) ^ (t) ^ (t >> 3);
    C[j - 4] = C[j - 4] ^ (t >> 28) ^ (t >> 29);
  }
  t = (C[5] >> 3) << 3;
  C[0] = C[0] ^ (t << 4) ^ (t << 3) ^ (t) ^ (t >> 3);
  C[1] = C[1] ^ (t >> 28) ^ (t >> 29);
  C[5] = C[5] & 0x7;
}


x86 assembly (clang, -O0):
<f2m_reduce>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movl   $0xa,-0xc(%rbp)
cmpl   $0x5,-0xc(%rbp)
jle    11c8 <f2m_reduce+0xc8>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x6,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%eax
shl    $0x1d,%eax
xor    %eax,%edx
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x6,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x5,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%eax
shl    $0x4,%eax
xor    %eax,%edx
mov    -0x10(%rbp),%eax
shl    $0x3,%eax
xor    %eax,%edx
xor    -0x10(%rbp),%edx
mov    -0x10(%rbp),%eax
sar    $0x3,%eax
xor    %eax,%edx
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x5,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%eax
sar    $0x1c,%eax
xor    %eax,%edx
mov    -0x10(%rbp),%eax
sar    $0x1d,%eax
xor    %eax,%edx
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
jmp    110f <f2m_reduce+0xf>
mov    -0x8(%rbp),%rax
mov    0x14(%rax),%eax
sar    $0x3,%eax
shl    $0x3,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
mov    -0x10(%rbp),%eax
shl    $0x4,%eax
xor    %eax,%ecx
mov    -0x10(%rbp),%eax
shl    $0x3,%eax
xor    %eax,%ecx
xor    -0x10(%rbp),%ecx
mov    -0x10(%rbp),%eax
sar    $0x3,%eax
xor    %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%ecx
mov    -0x10(%rbp),%eax
sar    $0x1c,%eax
xor    %eax,%ecx
mov    -0x10(%rbp),%eax
sar    $0x1d,%eax
xor    %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    0x14(%rax),%ecx
and    $0x7,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x14(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<f2m_reduce>:
movdqu 0x1c(%rdi),%xmm0
pshufd $0xff,%xmm0,%xmm1
movd   %xmm1,%eax
mov    %eax,%edx
shl    $0x4,%edx
lea    0x0(,%rax,8),%ecx
mov    %eax,%esi
sar    $0x3,%esi
xor    %ecx,%esi
xor    %eax,%edx
xor    %esi,%edx
xor    0x14(%rdi),%edx
mov    %eax,%ecx
sar    $0x1c,%ecx
sar    $0x1d,%eax
xor    %ecx,%eax
xor    0x18(%rdi),%eax
movdqu 0x4(%rdi),%xmm2
movd   %eax,%xmm1
mov    %eax,0x18(%rdi)
pshufd $0xee,%xmm0,%xmm3
movd   %xmm3,%r8d
mov    %r8d,%esi
sar    $0x1c,%esi
sar    $0x1d,%r8d
xor    %esi,%r8d
xor    %edx,%r8d
movd   %eax,%xmm4
shufps $0xe4,%xmm0,%xmm4
movdqa %xmm0,%xmm3
movd   %r8d,%xmm5
shufps $0xd4,%xmm0,%xmm5
punpckldq %xmm0,%xmm1
pslld  $0x1d,%xmm0
pxor   %xmm2,%xmm0
pshufd $0x39,%xmm0,%xmm0
shl    $0x1d,%eax
xor    (%rdi),%eax
shufps $0x24,%xmm4,%xmm3
movaps %xmm3,%xmm2
pslld  $0x4,%xmm2
movaps %xmm3,%xmm4
pslld  $0x3,%xmm4
pxor   %xmm3,%xmm2
psrad  $0x3,%xmm3
pxor   %xmm4,%xmm3
pxor   %xmm2,%xmm3
pxor   %xmm0,%xmm3
mov    %r8d,%edx
and    $0xfffffff8,%edx
lea    0x0(,%rdx,8),%esi
mov    %r8d,%ecx
sar    $0x3,%ecx
xor    %edx,%ecx
shl    $0x4,%edx
xor    %edx,%ecx
xor    %esi,%ecx
xor    %eax,%ecx
mov    %ecx,(%rdi)
shufps $0x24,%xmm5,%xmm1
movaps %xmm1,%xmm0
psrad  $0x1c,%xmm0
pshufd $0xed,%xmm0,%xmm2
psrad  $0x1d,%xmm1
pshufd $0xe8,%xmm1,%xmm4
punpckldq %xmm2,%xmm4
pshufd $0xed,%xmm1,%xmm1
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm1,%xmm0
pxor   %xmm4,%xmm0
pxor   %xmm3,%xmm0
pshufd $0x93,%xmm0,%xmm0
movdqu %xmm0,0x4(%rdi)
and    $0x7,%r8d
mov    %r8d,0x14(%rdi)
ret

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

LLVM IR (-O2):
define void @f2m_reduce(i32* nocapture %0) {
%2 = getelementptr inbounds i32, i32* %0, i64 5
%3 = load i32, i32* %2
%4 = getelementptr inbounds i32, i32* %0, i64 7
%5 = bitcast i32* %4 to <4 x i32>*
%6 = load <4 x i32>, <4 x i32>* %5
%7 = extractelement <4 x i32> %6, i64 3
%8 = shl i32 %7, 4
%9 = shl i32 %7, 3
%10 = ashr i32 %7, 3
%11 = xor i32 %8, %7
%12 = xor i32 %11, %9
%13 = xor i32 %12, %10
%14 = xor i32 %13, %3
%15 = getelementptr inbounds i32, i32* %0, i64 6
%16 = load i32, i32* %15
%17 = ashr i32 %7, 28
%18 = ashr i32 %7, 29
%19 = xor i32 %18, %17
%20 = xor i32 %19, %16
store i32 %20, i32* %15
%21 = extractelement <4 x i32> %6, i64 2
%22 = ashr i32 %21, 28
%23 = ashr i32 %21, 29
%24 = xor i32 %23, %22
%25 = xor i32 %24, %14
%26 = getelementptr inbounds i32, i32* %0, i64 1
%27 = bitcast i32* %26 to <4 x i32>*
%28 = load <4 x i32>, <4 x i32>* %27
%29 = shl <4 x i32> %6, <i32 29, i32 29, i32 29, i32 29>
%30 = xor <4 x i32> %28, %29
%31 = shufflevector <4 x i32> %30, <4 x i32> poison, <4 x i32> <i32 1, i32 2, i32 3, i32 0>
%32 = load i32, i32* %0
%33 = shl i32 %20, 29
%34 = xor i32 %32, %33
%35 = extractelement <4 x i32> %6, i64 0
%36 = extractelement <4 x i32> %6, i64 1
%37 = insertelement <4 x i32> %6, i32 %20, i64 3
%38 = shl <4 x i32> %37, <i32 4, i32 4, i32 4, i32 4>
%39 = shl <4 x i32> %37, <i32 3, i32 3, i32 3, i32 3>
%40 = ashr <4 x i32> %37, <i32 3, i32 3, i32 3, i32 3>
%41 = xor <4 x i32> %38, %37
%42 = xor <4 x i32> %41, %39
%43 = xor <4 x i32> %42, %40
%44 = xor <4 x i32> %43, %31
%45 = and i32 %25, -8
%46 = shl i32 %45, 4
%47 = shl i32 %45, 3
%48 = ashr i32 %25, 3
%49 = xor i32 %45, %34
%50 = xor i32 %49, %48
%51 = xor i32 %50, %46
%52 = xor i32 %51, %47
store i32 %52, i32* %0
%53 = insertelement <4 x i32> poison, i32 %20, i64 0
%54 = insertelement <4 x i32> %53, i32 %35, i64 1
%55 = insertelement <4 x i32> %54, i32 %36, i64 2
%56 = insertelement <4 x i32> %55, i32 %25, i64 3
%57 = ashr <4 x i32> %56, <i32 29, i32 28, i32 29, i32 28>
%58 = ashr <4 x i32> %56, <i32 28, i32 29, i32 28, i32 29>
%59 = xor <4 x i32> %57, %58
%60 = xor <4 x i32> %59, %44
%61 = shufflevector <4 x i32> %60, <4 x i32> poison, <4 x i32> <i32 3, i32 0, i32 1, i32 2>
%62 = bitcast i32* %26 to <4 x i32>*
store <4 x i32> %61, <4 x i32>* %62
%63 = and i32 %25, 7
store i32 %63, i32* %2
ret void
}