void RandomFunc(unsigned int input[1], unsigned int output[1]) {
  unsigned int state[1];
  char copy12;
  {
    state[0UL] = (input[0UL] | 51238316UL) >> 3U;
    if ((state[0UL] >> 3U) & 1U) {
      if (!((state[0UL] >> 4U) & 1U)) {
        state[0UL] >>= ((state[0UL] >> 1U) & 7U) | 1UL;
      }
    } else {
      copy12 = *((char *)(&state[0UL]) + 0);
      *((char *)(&state[0UL]) + 0) = *((char *)(&state[0UL]) + 3);
      *((char *)(&state[0UL]) + 3) = copy12;
    }
    output[0UL] = (state[0UL] | 629089775UL) >> 1U;
  }
}


x86 assembly (clang, -O0):
<RandomFunc>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
or     $0x30dd5ac,%rax
shr    $0x3,%rax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shr    $0x3,%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1161 <RandomFunc+0x61>
mov    -0x14(%rbp),%eax
shr    $0x4,%eax
and    $0x1,%eax
cmp    $0x0,%eax
jne    115c <RandomFunc+0x5c>
mov    -0x14(%rbp),%eax
shr    $0x1,%eax
and    $0x7,%eax
mov    %eax,%eax
mov    %eax,%ecx
or     $0x1,%rcx
mov    -0x14(%rbp),%eax
shr    %cl,%eax
mov    %eax,-0x14(%rbp)
jmp    1173 <RandomFunc+0x73>
mov    -0x14(%rbp),%al
mov    %al,-0x15(%rbp)
mov    -0x11(%rbp),%al
mov    %al,-0x14(%rbp)
mov    -0x15(%rbp),%al
mov    %al,-0x11(%rbp)
mov    -0x14(%rbp),%eax
or     $0x257f25ef,%rax
shr    $0x1,%rax
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<RandomFunc>:
mov    (%rdi),%eax
mov    %eax,%ecx
shr    $0x3,%ecx
or     $0x61bab5,%ecx
mov    %eax,%edx
shr    $0x1b,%edx
mov    %edx,%edi
and    $0xfffffff0,%edi
test   $0x40,%al
cmove  %ecx,%edx
mov    $0x10,%eax
cmove  %edi,%eax
shl    $0x18,%edx
and    $0x80da00,%ecx
or     %edx,%ecx
or     %eax,%ecx
shr    %ecx
or     $0x12bf92f7,%ecx
mov    %ecx,(%rsi)
ret

LLVM IR (-O0):
define void @RandomFunc(i32* %0, i32* %1) {
%3 = alloca i32*
%4 = alloca i32*
%5 = alloca [1 x i32]
%6 = alloca i8
store i32* %0, i32** %3
store i32* %1, i32** %4
%7 = load i32*, i32** %3
%8 = getelementptr inbounds i32, i32* %7, i64 0
%9 = load i32, i32* %8
%10 = zext i32 %9 to i64
%11 = or i64 %10, 51238316
%12 = lshr i64 %11, 3
%13 = trunc i64 %12 to i32
%14 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 0
store i32 %13, i32* %14
%15 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 0
%16 = load i32, i32* %15
%17 = lshr i32 %16, 3
%18 = and i32 %17, 1
%19 = icmp ne i32 %18, 0
br i1 %19, label %20, label %38
20: ; preds = %2
%21 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 0
%22 = load i32, i32* %21
%23 = lshr i32 %22, 4
%24 = and i32 %23, 1
%25 = icmp ne i32 %24, 0
br i1 %25, label %37, label %26
26: ; preds = %20
%27 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 0
%28 = load i32, i32* %27
%29 = lshr i32 %28, 1
%30 = and i32 %29, 7
%31 = zext i32 %30 to i64
%32 = or i64 %31, 1
%33 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 0
%34 = load i32, i32* %33
%35 = trunc i64 %32 to i32
%36 = lshr i32 %34, %35
store i32 %36, i32* %33
br label %37
37: ; preds = %26, %20
br label %54
38: ; preds = %2
%39 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 0
%40 = bitcast i32* %39 to i8*
%41 = getelementptr inbounds i8, i8* %40, i64 0
%42 = load i8, i8* %41
store i8 %42, i8* %6
%43 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 0
%44 = bitcast i32* %43 to i8*
%45 = getelementptr inbounds i8, i8* %44, i64 3
%46 = load i8, i8* %45
%47 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 0
%48 = bitcast i32* %47 to i8*
%49 = getelementptr inbounds i8, i8* %48, i64 0
store i8 %46, i8* %49
%50 = load i8, i8* %6
%51 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 0
%52 = bitcast i32* %51 to i8*
%53 = getelementptr inbounds i8, i8* %52, i64 3
store i8 %50, i8* %53
br label %54
54: ; preds = %38, %37
%55 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 0
%56 = load i32, i32* %55
%57 = zext i32 %56 to i64
%58 = or i64 %57, 629089775
%59 = lshr i64 %58, 1
%60 = trunc i64 %59 to i32
%61 = load i32*, i32** %4
%62 = getelementptr inbounds i32, i32* %61, i64 0
store i32 %60, i32* %62
ret void
}

LLVM IR (-O2):
define void @RandomFunc(i32* nocapture %0, i32* nocapture writeonly %1) {
%3 = load i32, i32* %0
%4 = lshr i32 %3, 3
%5 = or i32 %4, 6404789
%6 = lshr i32 %3, 27
%7 = and i32 %3, 64
%8 = icmp eq i32 %7, 0
%9 = select i1 %8, i32 %5, i32 %6
%10 = shl i32 %9, 24
%11 = and i32 %5, 8444416
%12 = or i32 %10, %11
%13 = and i32 %6, 16
%14 = select i1 %8, i32 %13, i32 16
%15 = or i32 %12, %14
%16 = lshr exact i32 %15, 1
%17 = or i32 %16, 314544887
store i32 %17, i32* %1
ret void
}