void RandomFunc(unsigned short input[1], unsigned short output[1]) {
  unsigned short state[1];
  char copy13;
  {
    state[0UL] = (input[0UL] + 914778474UL) ^ (unsigned short)11;
    if (state[0UL] & (unsigned short)1) {
      if ((state[0UL] >> (unsigned short)1) & (unsigned short)1) {
        if (!((state[0UL] >> (unsigned short)3) & (unsigned short)1)) {
          state[0UL] |= (state[0UL] & (unsigned short)15) << 3UL;
          state[0UL] |= (state[0UL] & (unsigned short)31) << 3UL;
        }
      } else {
        state[0UL] |= (state[0UL] & (unsigned short)31) << 3UL;
        state[0UL] |= ((state[0UL] + state[0UL]) & (unsigned short)15) << 3UL;
      }
    } else {
      state[0UL] += state[0UL];
      copy13 = *((char *)(&state[0UL]) + 0);
      *((char *)(&state[0UL]) + 0) = *((char *)(&state[0UL]) + 1);
      *((char *)(&state[0UL]) + 1) = copy13;
      copy13 = *((char *)(&state[0UL]) + 1);
      *((char *)(&state[0UL]) + 1) = *((char *)(&state[0UL]) + 0);
      *((char *)(&state[0UL]) + 0) = copy13;
    }
    output[0UL] = state[0UL] * 586248263UL ^ (unsigned short)63477;
  }
}


x86 assembly (clang, -O0):
<RandomFunc>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movzwl (%rax),%eax
add    $0x3686696a,%rax
xor    $0xb,%rax
mov    %ax,-0x12(%rbp)
movzwl -0x12(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     11b7 <RandomFunc+0xb7>
movzwl -0x12(%rbp),%eax
sar    $0x1,%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1184 <RandomFunc+0x84>
movzwl -0x12(%rbp),%eax
sar    $0x3,%eax
and    $0x1,%eax
cmp    $0x0,%eax
jne    117f <RandomFunc+0x7f>
movzwl -0x12(%rbp),%ecx
and    $0xf,%ecx
shl    $0x3,%ecx
movzwl -0x12(%rbp),%eax
or     %ecx,%eax
mov    %ax,-0x12(%rbp)
movzwl -0x12(%rbp),%ecx
and    $0x1f,%ecx
shl    $0x3,%ecx
movzwl -0x12(%rbp),%eax
or     %ecx,%eax
mov    %ax,-0x12(%rbp)
jmp    11b2 <RandomFunc+0xb2>
movzwl -0x12(%rbp),%ecx
and    $0x1f,%ecx
shl    $0x3,%ecx
movzwl -0x12(%rbp),%eax
or     %ecx,%eax
mov    %ax,-0x12(%rbp)
movzwl -0x12(%rbp),%ecx
movzwl -0x12(%rbp),%eax
add    %eax,%ecx
and    $0xf,%ecx
shl    $0x3,%ecx
movzwl -0x12(%rbp),%eax
or     %ecx,%eax
mov    %ax,-0x12(%rbp)
jmp    11e9 <RandomFunc+0xe9>
movzwl -0x12(%rbp),%ecx
movzwl -0x12(%rbp),%eax
add    %ecx,%eax
mov    %ax,-0x12(%rbp)
mov    -0x12(%rbp),%al
mov    %al,-0x13(%rbp)
mov    -0x11(%rbp),%al
mov    %al,-0x12(%rbp)
mov    -0x13(%rbp),%al
mov    %al,-0x11(%rbp)
mov    -0x11(%rbp),%al
mov    %al,-0x13(%rbp)
mov    -0x12(%rbp),%al
mov    %al,-0x11(%rbp)
mov    -0x13(%rbp),%al
mov    %al,-0x12(%rbp)
movzwl -0x12(%rbp),%eax
imul   $0x22f17047,%rax,%rax
xor    $0xf7f5,%rax
mov    %ax,%cx
mov    -0x10(%rbp),%rax
mov    %cx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<RandomFunc>:
movzwl (%rdi),%eax
add    $0x696a,%eax
mov    %eax,%ecx
xor    $0xb,%ecx
test   $0x1,%cl
jne    1116 <RandomFunc+0x16>
add    %ecx,%ecx
jmp    115c <RandomFunc+0x5c>
movzwl %cx,%edx
test   $0x2,%dl
jne    1139 <RandomFunc+0x39>
lea    0x0(,%rcx,8),%edx
or     %ecx,%edx
and    $0xffffff00,%eax
movzbl %dl,%ecx
or     %ecx,%eax
shl    $0x4,%ecx
and    $0x70,%ecx
jmp    115a <RandomFunc+0x5a>
test   $0x8,%dl
jne    115e <RandomFunc+0x5e>
lea    0x0(,%rcx,8),%edx
and    $0x78,%edx
and    $0xffffff00,%eax
movzbl %cl,%ecx
or     %edx,%ecx
or     %ecx,%eax
shl    $0x3,%ecx
movzbl %cl,%ecx
or     %eax,%ecx
mov    %ecx,%eax
and    $0xffffff00,%eax
movzbl %cl,%ecx
or     %eax,%ecx
imul   $0x7047,%ecx,%eax
xor    $0xf7f5,%eax
mov    %ax,(%rsi)
ret

LLVM IR (-O0):
define void @RandomFunc(i16* %0, i16* %1) {
%3 = alloca i16*
%4 = alloca i16*
%5 = alloca [1 x i16]
%6 = alloca i8
store i16* %0, i16** %3
store i16* %1, i16** %4
%7 = load i16*, i16** %3
%8 = getelementptr inbounds i16, i16* %7, i64 0
%9 = load i16, i16* %8
%10 = zext i16 %9 to i64
%11 = add i64 %10, 914778474
%12 = xor i64 %11, 11
%13 = trunc i64 %12 to i16
%14 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
store i16 %13, i16* %14
%15 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%16 = load i16, i16* %15
%17 = zext i16 %16 to i32
%18 = and i32 %17, 1
%19 = icmp ne i32 %18, 0
br i1 %19, label %20, label %82
20: ; preds = %2
%21 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%22 = load i16, i16* %21
%23 = zext i16 %22 to i32
%24 = ashr i32 %23, 1
%25 = and i32 %24, 1
%26 = icmp ne i32 %25, 0
br i1 %26, label %27, label %56
27: ; preds = %20
%28 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%29 = load i16, i16* %28
%30 = zext i16 %29 to i32
%31 = ashr i32 %30, 3
%32 = and i32 %31, 1
%33 = icmp ne i32 %32, 0
br i1 %33, label %55, label %34
34: ; preds = %27
%35 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%36 = load i16, i16* %35
%37 = zext i16 %36 to i32
%38 = and i32 %37, 15
%39 = shl i32 %38, 3
%40 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%41 = load i16, i16* %40
%42 = zext i16 %41 to i32
%43 = or i32 %42, %39
%44 = trunc i32 %43 to i16
store i16 %44, i16* %40
%45 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%46 = load i16, i16* %45
%47 = zext i16 %46 to i32
%48 = and i32 %47, 31
%49 = shl i32 %48, 3
%50 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%51 = load i16, i16* %50
%52 = zext i16 %51 to i32
%53 = or i32 %52, %49
%54 = trunc i32 %53 to i16
store i16 %54, i16* %50
br label %55
55: ; preds = %34, %27
br label %81
56: ; preds = %20
%57 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%58 = load i16, i16* %57
%59 = zext i16 %58 to i32
%60 = and i32 %59, 31
%61 = shl i32 %60, 3
%62 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%63 = load i16, i16* %62
%64 = zext i16 %63 to i32
%65 = or i32 %64, %61
%66 = trunc i32 %65 to i16
store i16 %66, i16* %62
%67 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%68 = load i16, i16* %67
%69 = zext i16 %68 to i32
%70 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%71 = load i16, i16* %70
%72 = zext i16 %71 to i32
%73 = add nsw i32 %69, %72
%74 = and i32 %73, 15
%75 = shl i32 %74, 3
%76 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%77 = load i16, i16* %76
%78 = zext i16 %77 to i32
%79 = or i32 %78, %75
%80 = trunc i32 %79 to i16
store i16 %80, i16* %76
br label %81
81: ; preds = %56, %55
br label %121
82: ; preds = %2
%83 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%84 = load i16, i16* %83
%85 = zext i16 %84 to i32
%86 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%87 = load i16, i16* %86
%88 = zext i16 %87 to i32
%89 = add nsw i32 %88, %85
%90 = trunc i32 %89 to i16
store i16 %90, i16* %86
%91 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%92 = bitcast i16* %91 to i8*
%93 = getelementptr inbounds i8, i8* %92, i64 0
%94 = load i8, i8* %93
store i8 %94, i8* %6
%95 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%96 = bitcast i16* %95 to i8*
%97 = getelementptr inbounds i8, i8* %96, i64 1
%98 = load i8, i8* %97
%99 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%100 = bitcast i16* %99 to i8*
%101 = getelementptr inbounds i8, i8* %100, i64 0
store i8 %98, i8* %101
%102 = load i8, i8* %6
%103 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%104 = bitcast i16* %103 to i8*
%105 = getelementptr inbounds i8, i8* %104, i64 1
store i8 %102, i8* %105
%106 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%107 = bitcast i16* %106 to i8*
%108 = getelementptr inbounds i8, i8* %107, i64 1
%109 = load i8, i8* %108
store i8 %109, i8* %6
%110 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%111 = bitcast i16* %110 to i8*
%112 = getelementptr inbounds i8, i8* %111, i64 0
%113 = load i8, i8* %112
%114 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%115 = bitcast i16* %114 to i8*
%116 = getelementptr inbounds i8, i8* %115, i64 1
store i8 %113, i8* %116
%117 = load i8, i8* %6
%118 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%119 = bitcast i16* %118 to i8*
%120 = getelementptr inbounds i8, i8* %119, i64 0
store i8 %117, i8* %120
br label %121
121: ; preds = %82, %81
%122 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%123 = load i16, i16* %122
%124 = zext i16 %123 to i64
%125 = mul i64 %124, 586248263
%126 = xor i64 %125, 63477
%127 = trunc i64 %126 to i16
%128 = load i16*, i16** %4
%129 = getelementptr inbounds i16, i16* %128, i64 0
store i16 %127, i16* %129
ret void
}

LLVM IR (-O2):
define void @RandomFunc(i16* nocapture %0, i16* nocapture writeonly %1) {
%3 = load i16, i16* %0
%4 = add i16 %3, 26986
%5 = xor i16 %4, 11
%6 = zext i16 %5 to i32
%7 = and i32 %6, 1
%8 = icmp eq i32 %7, 0
br i1 %8, label %34, label %9
9: ; preds = %2
%10 = and i32 %6, 2
%11 = icmp eq i32 %10, 0
br i1 %11, label %25, label %12
12: ; preds = %9
%13 = and i32 %6, 8
%14 = icmp eq i32 %13, 0
br i1 %14, label %15, label %36
15: ; preds = %12
%16 = shl i16 %5, 3
%17 = and i16 %16, 120
%18 = and i16 %4, -256
%19 = and i16 %5, 255
%20 = or i16 %17, %19
%21 = or i16 %20, %18
%22 = shl nuw nsw i16 %20, 3
%23 = and i16 %22, 248
%24 = or i16 %21, %23
br label %36
25: ; preds = %9
%26 = shl i16 %5, 3
%27 = or i16 %26, %5
%28 = and i16 %4, -256
%29 = and i16 %27, 255
%30 = or i16 %29, %28
%31 = shl nuw nsw i16 %29, 4
%32 = and i16 %31, 112
%33 = or i16 %30, %32
br label %36
34: ; preds = %2
%35 = shl i16 %5, 1
br label %36
36: ; preds = %25, %15, %12, %34
%37 = phi i16 [ %5, %12 ], [ %24, %15 ], [ %33, %25 ], [ %35, %34 ]
%38 = phi i16 [ %4, %12 ], [ %24, %15 ], [ %33, %25 ], [ %35, %34 ]
%39 = and i16 %38, -256
%40 = and i16 %37, 255
%41 = or i16 %39, %40
%42 = mul i16 %41, 28743
%43 = xor i16 %42, -2059
store i16 %43, i16* %1
ret void
}