void RandomFunc(unsigned long input[1], unsigned long output[1]) {
  unsigned long state[1];
  unsigned int copy11;
  unsigned int copy13;
  unsigned int copy17;
  unsigned int copy18;
  unsigned short copy19;
  {
    state[0UL] = (input[0UL] + 914778474UL) - 981234615UL;
    if (state[0UL] & 1UL) {
      if (state[0UL] & 1UL) {
        if (state[0UL] & 1UL) {
          state[0UL] += state[0UL];
          copy11 = *((unsigned int *)(&state[0UL]) + 1);
          *((unsigned int *)(&state[0UL]) + 1) =
              *((unsigned int *)(&state[0UL]) + 0);
          *((unsigned int *)(&state[0UL]) + 0) = copy11;
          copy11 = *((unsigned int *)(&state[0UL]) + 0);
          *((unsigned int *)(&state[0UL]) + 0) =
              *((unsigned int *)(&state[0UL]) + 1);
          *((unsigned int *)(&state[0UL]) + 1) = copy11;
        } else {
          copy13 = *((unsigned int *)(&state[0UL]) + 0);
          *((unsigned int *)(&state[0UL]) + 0) =
              *((unsigned int *)(&state[0UL]) + 1);
          *((unsigned int *)(&state[0UL]) + 1) = copy13;
        }
      } else if ((state[0UL] >> 4UL) & 1UL) {
        state[0UL] += state[0UL];
      }
    } else if ((state[0UL] >> 2UL) & 1UL) {
      copy17 = *((unsigned int *)(&state[0UL]) + 0);
      *((unsigned int *)(&state[0UL]) + 0) =
          *((unsigned int *)(&state[0UL]) + 1);
      *((unsigned int *)(&state[0UL]) + 1) = copy17;
      copy18 = *((unsigned int *)(&state[0UL]) + 1);
      *((unsigned int *)(&state[0UL]) + 1) =
          *((unsigned int *)(&state[0UL]) + 0);
      *((unsigned int *)(&state[0UL]) + 0) = copy18;
    } else {
      copy19 = *((unsigned short *)(&state[0UL]) + 0);
      *((unsigned short *)(&state[0UL]) + 0) =
          *((unsigned short *)(&state[0UL]) + 2);
      *((unsigned short *)(&state[0UL]) + 2) = copy19;
      state[0UL] += state[0UL];
    }
    output[0UL] = (state[0UL] + 380867558UL) - 653123240UL;
  }
}


x86 assembly (clang, -O0):
<RandomFunc>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
add    $0x3686696a,%rax
sub    $0x3a7c73b7,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     11d1 <RandomFunc+0xd1>
mov    -0x18(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     11a5 <RandomFunc+0xa5>
mov    -0x18(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     118e <RandomFunc+0x8e>
mov    -0x18(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    11a0 <RandomFunc+0xa0>
mov    -0x18(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    11cc <RandomFunc+0xcc>
mov    -0x18(%rbp),%rax
shr    $0x4,%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     11c7 <RandomFunc+0xc7>
mov    -0x18(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    11cc <RandomFunc+0xcc>
jmp    1239 <RandomFunc+0x139>
mov    -0x18(%rbp),%rax
shr    $0x2,%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     1210 <RandomFunc+0x110>
mov    -0x18(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    1234 <RandomFunc+0x134>
mov    -0x18(%rbp),%ax
mov    %ax,-0x2a(%rbp)
mov    -0x14(%rbp),%ax
mov    %ax,-0x18(%rbp)
mov    -0x2a(%rbp),%ax
mov    %ax,-0x14(%rbp)
mov    -0x18(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    1239 <RandomFunc+0x139>
mov    -0x18(%rbp),%rcx
add    $0x16b393e6,%rcx
sub    $0x26eddea8,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<RandomFunc>:
mov    $0xfffffffffc09f5b3,%rcx
add    (%rdi),%rcx
mov    %rcx,%rax
shr    $0x20,%rax
test   $0x1,%cl
jne    1150 <RandomFunc+0x50>
test   $0x4,%cl
jne    118a <RandomFunc+0x8a>
movzwl %cx,%edi
and    $0xffff0000,%ecx
mov    %eax,%edx
and    $0x7fff0000,%edx
or     %rdi,%rdx
movzwl %ax,%edi
or     %ecx,%edi
mov    %rdx,%rax
shl    $0x21,%rax
lea    (%rax,%rdi,2),%rax
lea    (%rdi,%rdi,1),%rcx
shr    $0xf,%edi
shr    $0x20,%rax
shr    $0xf,%rdx
jmp    1194 <RandomFunc+0x94>
shl    $0x21,%rax
mov    %rcx,%rdx
add    %rcx,%rdx
movabs $0x100000000,%rdi
and    %rdx,%rdi
or     %rax,%rdi
shr    $0x20,%rdi
movzwl %di,%r8d
movzwl %dx,%r9d
shr    $0xf,%ecx
movzwl %cx,%edi
shr    $0x30,%rax
mov    %eax,%edx
mov    %r8d,%eax
mov    %r9d,%ecx
jmp    1194 <RandomFunc+0x94>
mov    %eax,%edx
shr    $0x10,%edx
mov    %ecx,%edi
shr    $0x10,%edi
shl    $0x10,%edi
movzwl %cx,%ecx
or     %edi,%ecx
shl    $0x10,%edx
movzwl %ax,%eax
or     %edx,%eax
shl    $0x20,%rax
add    %rcx,%rax
add    $0xffffffffefc5b53e,%rax
mov    %rax,(%rsi)
ret

LLVM IR (-O0):
define void @RandomFunc(i64* %0, i64* %1) {
%3 = alloca i64*
%4 = alloca i64*
%5 = alloca [1 x i64]
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i16
store i64* %0, i64** %3
store i64* %1, i64** %4
%11 = load i64*, i64** %3
%12 = getelementptr inbounds i64, i64* %11, i64 0
%13 = load i64, i64* %12
%14 = add i64 %13, 914778474
%15 = sub i64 %14, 981234615
%16 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
store i64 %15, i64* %16
%17 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%18 = load i64, i64* %17
%19 = and i64 %18, 1
%20 = icmp ne i64 %19, 0
br i1 %20, label %21, label %98
21: ; preds = %2
%22 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%23 = load i64, i64* %22
%24 = and i64 %23, 1
%25 = icmp ne i64 %24, 0
br i1 %25, label %26, label %84
26: ; preds = %21
%27 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%28 = load i64, i64* %27
%29 = and i64 %28, 1
%30 = icmp ne i64 %29, 0
br i1 %30, label %31, label %67
31: ; preds = %26
%32 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%33 = load i64, i64* %32
%34 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%35 = load i64, i64* %34
%36 = add i64 %35, %33
store i64 %36, i64* %34
%37 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%38 = bitcast i64* %37 to i32*
%39 = getelementptr inbounds i32, i32* %38, i64 1
%40 = load i32, i32* %39
store i32 %40, i32* %6
%41 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%42 = bitcast i64* %41 to i32*
%43 = getelementptr inbounds i32, i32* %42, i64 0
%44 = load i32, i32* %43
%45 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%46 = bitcast i64* %45 to i32*
%47 = getelementptr inbounds i32, i32* %46, i64 1
store i32 %44, i32* %47
%48 = load i32, i32* %6
%49 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%50 = bitcast i64* %49 to i32*
%51 = getelementptr inbounds i32, i32* %50, i64 0
store i32 %48, i32* %51
%52 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%53 = bitcast i64* %52 to i32*
%54 = getelementptr inbounds i32, i32* %53, i64 0
%55 = load i32, i32* %54
store i32 %55, i32* %6
%56 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%57 = bitcast i64* %56 to i32*
%58 = getelementptr inbounds i32, i32* %57, i64 1
%59 = load i32, i32* %58
%60 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%61 = bitcast i64* %60 to i32*
%62 = getelementptr inbounds i32, i32* %61, i64 0
store i32 %59, i32* %62
%63 = load i32, i32* %6
%64 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%65 = bitcast i64* %64 to i32*
%66 = getelementptr inbounds i32, i32* %65, i64 1
store i32 %63, i32* %66
br label %83
67: ; preds = %26
%68 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%69 = bitcast i64* %68 to i32*
%70 = getelementptr inbounds i32, i32* %69, i64 0
%71 = load i32, i32* %70
store i32 %71, i32* %7
%72 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%73 = bitcast i64* %72 to i32*
%74 = getelementptr inbounds i32, i32* %73, i64 1
%75 = load i32, i32* %74
%76 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%77 = bitcast i64* %76 to i32*
%78 = getelementptr inbounds i32, i32* %77, i64 0
store i32 %75, i32* %78
%79 = load i32, i32* %7
%80 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%81 = bitcast i64* %80 to i32*
%82 = getelementptr inbounds i32, i32* %81, i64 1
store i32 %79, i32* %82
br label %83
83: ; preds = %67, %31
br label %97
84: ; preds = %21
%85 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%86 = load i64, i64* %85
%87 = lshr i64 %86, 4
%88 = and i64 %87, 1
%89 = icmp ne i64 %88, 0
br i1 %89, label %90, label %96
90: ; preds = %84
%91 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%92 = load i64, i64* %91
%93 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%94 = load i64, i64* %93
%95 = add i64 %94, %92
store i64 %95, i64* %93
br label %96
96: ; preds = %90, %84
br label %97
97: ; preds = %96, %83
br label %157
98: ; preds = %2
%99 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%100 = load i64, i64* %99
%101 = lshr i64 %100, 2
%102 = and i64 %101, 1
%103 = icmp ne i64 %102, 0
br i1 %103, label %104, label %135
104: ; preds = %98
%105 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%106 = bitcast i64* %105 to i32*
%107 = getelementptr inbounds i32, i32* %106, i64 0
%108 = load i32, i32* %107
store i32 %108, i32* %8
%109 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%110 = bitcast i64* %109 to i32*
%111 = getelementptr inbounds i32, i32* %110, i64 1
%112 = load i32, i32* %111
%113 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%114 = bitcast i64* %113 to i32*
%115 = getelementptr inbounds i32, i32* %114, i64 0
store i32 %112, i32* %115
%116 = load i32, i32* %8
%117 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%118 = bitcast i64* %117 to i32*
%119 = getelementptr inbounds i32, i32* %118, i64 1
store i32 %116, i32* %119
%120 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%121 = bitcast i64* %120 to i32*
%122 = getelementptr inbounds i32, i32* %121, i64 1
%123 = load i32, i32* %122
store i32 %123, i32* %9
%124 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%125 = bitcast i64* %124 to i32*
%126 = getelementptr inbounds i32, i32* %125, i64 0
%127 = load i32, i32* %126
%128 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%129 = bitcast i64* %128 to i32*
%130 = getelementptr inbounds i32, i32* %129, i64 1
store i32 %127, i32* %130
%131 = load i32, i32* %9
%132 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%133 = bitcast i64* %132 to i32*
%134 = getelementptr inbounds i32, i32* %133, i64 0
store i32 %131, i32* %134
br label %156
135: ; preds = %98
%136 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%137 = bitcast i64* %136 to i16*
%138 = getelementptr inbounds i16, i16* %137, i64 0
%139 = load i16, i16* %138
store i16 %139, i16* %10
%140 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%141 = bitcast i64* %140 to i16*
%142 = getelementptr inbounds i16, i16* %141, i64 2
%143 = load i16, i16* %142
%144 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%145 = bitcast i64* %144 to i16*
%146 = getelementptr inbounds i16, i16* %145, i64 0
store i16 %143, i16* %146
%147 = load i16, i16* %10
%148 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%149 = bitcast i64* %148 to i16*
%150 = getelementptr inbounds i16, i16* %149, i64 2
store i16 %147, i16* %150
%151 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%152 = load i64, i64* %151
%153 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%154 = load i64, i64* %153
%155 = add i64 %154, %152
store i64 %155, i64* %153
br label %156
156: ; preds = %135, %104
br label %157
157: ; preds = %156, %97
%158 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%159 = load i64, i64* %158
%160 = add i64 %159, 380867558
%161 = sub i64 %160, 653123240
%162 = load i64*, i64** %4
%163 = getelementptr inbounds i64, i64* %162, i64 0
store i64 %161, i64* %163
ret void
}

LLVM IR (-O2):
define void @RandomFunc(i64* nocapture %0, i64* nocapture writeonly %1) {
%3 = load i64, i64* %0
%4 = add i64 %3, -66456141
%5 = trunc i64 %4 to i32
%6 = and i32 %5, -65536
%7 = lshr i64 %4, 32
%8 = trunc i64 %7 to i32
%9 = and i64 %4, 65535
%10 = and i64 %7, 2147418112
%11 = and i32 %8, 65535
%12 = and i64 %4, 1
%13 = icmp eq i64 %12, 0
br i1 %13, label %28, label %14
14: ; preds = %2
%15 = shl i64 %7, 33
%16 = shl i64 %4, 1
%17 = and i64 %16, 4294967296
%18 = or i64 %15, %17
%19 = lshr exact i64 %18, 32
%20 = trunc i64 %16 to i32
%21 = trunc i64 %19 to i32
%22 = and i32 %21, 65535
%23 = and i32 %20, 65534
%24 = lshr i32 %5, 15
%25 = and i32 %24, 65535
%26 = lshr i64 %15, 48
%27 = trunc i64 %26 to i32
br label %47
28: ; preds = %2
%29 = and i64 %4, 4
%30 = icmp eq i64 %29, 0
br i1 %30, label %34, label %31
31: ; preds = %28
%32 = lshr i32 %8, 16
%33 = lshr i32 %5, 16
br label %47
34: ; preds = %28
%35 = or i32 %11, %6
%36 = or i64 %10, %9
%37 = zext i32 %35 to i64
%38 = shl nuw i64 %36, 33
%39 = shl nuw nsw i64 %37, 1
%40 = or i64 %39, %38
%41 = trunc i64 %39 to i32
%42 = lshr i32 %35, 15
%43 = lshr i64 %40, 32
%44 = trunc i64 %43 to i32
%45 = lshr i64 %36, 15
%46 = trunc i64 %45 to i32
br label %47
47: ; preds = %31, %34, %14
%48 = phi i32 [ %22, %14 ], [ %8, %31 ], [ %44, %34 ]
%49 = phi i32 [ %27, %14 ], [ %32, %31 ], [ %46, %34 ]
%50 = phi i32 [ %23, %14 ], [ %5, %31 ], [ %41, %34 ]
%51 = phi i32 [ %25, %14 ], [ %33, %31 ], [ %42, %34 ]
%52 = shl i32 %51, 16
%53 = and i32 %50, 65535
%54 = or i32 %52, %53
%55 = shl nuw i32 %49, 16
%56 = and i32 %48, 65535
%57 = or i32 %55, %56
%58 = zext i32 %57 to i64
%59 = shl nuw i64 %58, 32
%60 = zext i32 %54 to i64
%61 = add i64 %59, -272255682
%62 = add i64 %61, %60
store i64 %62, i64* %1
ret void
}