void RandomFunc(unsigned long input[1], unsigned long output[1]) {
  unsigned long state[1];
  char copy11;
  unsigned int copy13;
  char copy14;
  unsigned int copy15;
  char copy16;
  unsigned short copy17;
  {
    state[0UL] = (input[0UL] + 914778474UL) * 67330564296145686UL;
    if (state[0UL] & 1UL) {
      if (state[0UL] & 1UL) {
        if (state[0UL] & 1UL) {
          copy11 = *((char *)(&state[0UL]) + 1);
          *((char *)(&state[0UL]) + 1) = *((char *)(&state[0UL]) + 7);
          *((char *)(&state[0UL]) + 7) = copy11;
        } else {
          copy13 = *((unsigned int *)(&state[0UL]) + 1);
          *((unsigned int *)(&state[0UL]) + 1) =
              *((unsigned int *)(&state[0UL]) + 0);
          *((unsigned int *)(&state[0UL]) + 0) = copy13;
          copy13 = *((unsigned int *)(&state[0UL]) + 0);
          *((unsigned int *)(&state[0UL]) + 0) =
              *((unsigned int *)(&state[0UL]) + 1);
          *((unsigned int *)(&state[0UL]) + 1) = copy13;
          state[0UL] += state[0UL];
        }
      } else {
        copy14 = *((char *)(&state[0UL]) + 1);
        *((char *)(&state[0UL]) + 1) = *((char *)(&state[0UL]) + 7);
        *((char *)(&state[0UL]) + 7) = copy14;
        copy15 = *((unsigned int *)(&state[0UL]) + 1);
        *((unsigned int *)(&state[0UL]) + 1) =
            *((unsigned int *)(&state[0UL]) + 0);
        *((unsigned int *)(&state[0UL]) + 0) = copy15;
        copy15 = *((unsigned int *)(&state[0UL]) + 0);
        *((unsigned int *)(&state[0UL]) + 0) =
            *((unsigned int *)(&state[0UL]) + 1);
        *((unsigned int *)(&state[0UL]) + 1) = copy15;
      }
    } else {
      copy16 = *((char *)(&state[0UL]) + 6);
      *((char *)(&state[0UL]) + 6) = *((char *)(&state[0UL]) + 5);
      *((char *)(&state[0UL]) + 5) = copy16;
      copy16 = *((char *)(&state[0UL]) + 3);
      *((char *)(&state[0UL]) + 3) = *((char *)(&state[0UL]) + 2);
      *((char *)(&state[0UL]) + 2) = copy16;
      copy17 = *((unsigned short *)(&state[0UL]) + 0);
      *((unsigned short *)(&state[0UL]) + 0) =
          *((unsigned short *)(&state[0UL]) + 2);
      *((unsigned short *)(&state[0UL]) + 2) = copy17;
    }
    output[0UL] = (state[0UL] + 622214515UL) - 0xffffffffe852b961UL;
  }
}


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
movabs $0xef34ca9f65fb16,%rcx
imul   %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     11e8 <RandomFunc+0xe8>
mov    -0x18(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     11ad <RandomFunc+0xad>
mov    -0x18(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     1178 <RandomFunc+0x78>
mov    -0x17(%rbp),%al
mov    %al,-0x19(%rbp)
mov    -0x11(%rbp),%al
mov    %al,-0x17(%rbp)
mov    -0x19(%rbp),%al
mov    %al,-0x11(%rbp)
jmp    11a8 <RandomFunc+0xa8>
mov    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    11e3 <RandomFunc+0xe3>
mov    -0x17(%rbp),%al
mov    %al,-0x21(%rbp)
mov    -0x11(%rbp),%al
mov    %al,-0x17(%rbp)
mov    -0x21(%rbp),%al
mov    %al,-0x11(%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)
mov    -0x18(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    1224 <RandomFunc+0x124>
mov    -0x12(%rbp),%al
mov    %al,-0x29(%rbp)
mov    -0x13(%rbp),%al
mov    %al,-0x12(%rbp)
mov    -0x29(%rbp),%al
mov    %al,-0x13(%rbp)
mov    -0x15(%rbp),%al
mov    %al,-0x29(%rbp)
mov    -0x16(%rbp),%al
mov    %al,-0x15(%rbp)
mov    -0x29(%rbp),%al
mov    %al,-0x16(%rbp)
mov    -0x18(%rbp),%ax
mov    %ax,-0x2c(%rbp)
mov    -0x14(%rbp),%ax
mov    %ax,-0x18(%rbp)
mov    -0x2c(%rbp),%ax
mov    %ax,-0x14(%rbp)
mov    -0x18(%rbp),%rcx
add    $0x25163d73,%rcx
sub    $0xffffffffe852b961,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<RandomFunc>:
movabs $0xef34ca9f65fb16,%rcx
imul   (%rdi),%rcx
movabs $0xdf61e99ee5b9fd1c,%rax
e9 61 df
add    %rcx,%rax
mov    %rax,%rdx
shr    $0x20,%rdx
mov    %rax,%r9
shr    $0x28,%r9
and    $0xff00,%r9d
movzbl %dl,%r8d
mov    %eax,%edi
and    $0xff0000,%edi
shl    $0x8,%rdi
mov    %rax,%rcx
shr    $0x8,%rcx
and    $0xff0000,%ecx
or     %rdi,%rcx
or     %r8,%rcx
movzwl %ax,%edi
and    $0xff000000,%edx
shr    $0x18,%rax
and    $0xff0000,%eax
or     %edx,%eax
or     %edi,%eax
shl    $0x20,%rax
or     %r9,%rcx
add    %rcx,%rax
add    $0x3cc38412,%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 i8
%7 = alloca i32
%8 = alloca i8
%9 = alloca i32
%10 = alloca i8
%11 = alloca i16
store i64* %0, i64** %3
store i64* %1, i64** %4
%12 = load i64*, i64** %3
%13 = getelementptr inbounds i64, i64* %12, i64 0
%14 = load i64, i64* %13
%15 = add i64 %14, 914778474
%16 = mul i64 %15, 67330564296145686
%17 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
store i64 %16, i64* %17
%18 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%19 = load i64, i64* %18
%20 = and i64 %19, 1
%21 = icmp ne i64 %20, 0
br i1 %21, label %22, label %132
22: ; preds = %2
%23 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%24 = load i64, i64* %23
%25 = and i64 %24, 1
%26 = icmp ne i64 %25, 0
br i1 %26, label %27, label %85
27: ; preds = %22
%28 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%29 = load i64, i64* %28
%30 = and i64 %29, 1
%31 = icmp ne i64 %30, 0
br i1 %31, label %32, label %48
32: ; preds = %27
%33 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%34 = bitcast i64* %33 to i8*
%35 = getelementptr inbounds i8, i8* %34, i64 1
%36 = load i8, i8* %35
store i8 %36, i8* %6
%37 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%38 = bitcast i64* %37 to i8*
%39 = getelementptr inbounds i8, i8* %38, i64 7
%40 = load i8, i8* %39
%41 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%42 = bitcast i64* %41 to i8*
%43 = getelementptr inbounds i8, i8* %42, i64 1
store i8 %40, i8* %43
%44 = load i8, i8* %6
%45 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%46 = bitcast i64* %45 to i8*
%47 = getelementptr inbounds i8, i8* %46, i64 7
store i8 %44, i8* %47
br label %84
48: ; preds = %27
%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 1
%52 = load i32, i32* %51
store i32 %52, i32* %7
%53 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%54 = bitcast i64* %53 to i32*
%55 = getelementptr inbounds i32, i32* %54, i64 0
%56 = load i32, i32* %55
%57 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%58 = bitcast i64* %57 to i32*
%59 = getelementptr inbounds i32, i32* %58, i64 1
store i32 %56, i32* %59
%60 = load i32, i32* %7
%61 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%62 = bitcast i64* %61 to i32*
%63 = getelementptr inbounds i32, i32* %62, i64 0
store i32 %60, i32* %63
%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 0
%67 = load i32, i32* %66
store i32 %67, i32* %7
%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 1
%71 = load i32, i32* %70
%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 0
store i32 %71, i32* %74
%75 = load i32, i32* %7
%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 1
store i32 %75, i32* %78
%79 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%80 = load i64, i64* %79
%81 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%82 = load i64, i64* %81
%83 = add i64 %82, %80
store i64 %83, i64* %81
br label %84
84: ; preds = %48, %32
br label %131
85: ; preds = %22
%86 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%87 = bitcast i64* %86 to i8*
%88 = getelementptr inbounds i8, i8* %87, i64 1
%89 = load i8, i8* %88
store i8 %89, i8* %8
%90 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%91 = bitcast i64* %90 to i8*
%92 = getelementptr inbounds i8, i8* %91, i64 7
%93 = load i8, i8* %92
%94 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%95 = bitcast i64* %94 to i8*
%96 = getelementptr inbounds i8, i8* %95, i64 1
store i8 %93, i8* %96
%97 = load i8, i8* %8
%98 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%99 = bitcast i64* %98 to i8*
%100 = getelementptr inbounds i8, i8* %99, i64 7
store i8 %97, i8* %100
%101 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%102 = bitcast i64* %101 to i32*
%103 = getelementptr inbounds i32, i32* %102, i64 1
%104 = load i32, i32* %103
store i32 %104, i32* %9
%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
%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
store i32 %108, i32* %111
%112 = load i32, i32* %9
%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 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%117 = bitcast i64* %116 to i32*
%118 = getelementptr inbounds i32, i32* %117, i64 0
%119 = load i32, i32* %118
store i32 %119, i32* %9
%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
%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
store i32 %123, i32* %126
%127 = load i32, i32* %9
%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
br label %131
131: ; preds = %85, %84
br label %178
132: ; preds = %2
%133 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%134 = bitcast i64* %133 to i8*
%135 = getelementptr inbounds i8, i8* %134, i64 6
%136 = load i8, i8* %135
store i8 %136, i8* %10
%137 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%138 = bitcast i64* %137 to i8*
%139 = getelementptr inbounds i8, i8* %138, i64 5
%140 = load i8, i8* %139
%141 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%142 = bitcast i64* %141 to i8*
%143 = getelementptr inbounds i8, i8* %142, i64 6
store i8 %140, i8* %143
%144 = load i8, i8* %10
%145 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%146 = bitcast i64* %145 to i8*
%147 = getelementptr inbounds i8, i8* %146, i64 5
store i8 %144, i8* %147
%148 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%149 = bitcast i64* %148 to i8*
%150 = getelementptr inbounds i8, i8* %149, i64 3
%151 = load i8, i8* %150
store i8 %151, i8* %10
%152 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%153 = bitcast i64* %152 to i8*
%154 = getelementptr inbounds i8, i8* %153, i64 2
%155 = load i8, i8* %154
%156 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%157 = bitcast i64* %156 to i8*
%158 = getelementptr inbounds i8, i8* %157, i64 3
store i8 %155, i8* %158
%159 = load i8, i8* %10
%160 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%161 = bitcast i64* %160 to i8*
%162 = getelementptr inbounds i8, i8* %161, i64 2
store i8 %159, i8* %162
%163 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%164 = bitcast i64* %163 to i16*
%165 = getelementptr inbounds i16, i16* %164, i64 0
%166 = load i16, i16* %165
store i16 %166, i16* %11
%167 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%168 = bitcast i64* %167 to i16*
%169 = getelementptr inbounds i16, i16* %168, i64 2
%170 = load i16, i16* %169
%171 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%172 = bitcast i64* %171 to i16*
%173 = getelementptr inbounds i16, i16* %172, i64 0
store i16 %170, i16* %173
%174 = load i16, i16* %11
%175 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%176 = bitcast i64* %175 to i16*
%177 = getelementptr inbounds i16, i16* %176, i64 2
store i16 %174, i16* %177
br label %178
178: ; preds = %132, %131
%179 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%180 = load i64, i64* %179
%181 = add i64 %180, 622214515
%182 = sub i64 %181, -397231775
%183 = load i64*, i64** %4
%184 = getelementptr inbounds i64, i64* %183, i64 0
store i64 %182, i64* %184
ret void
}

LLVM IR (-O2):
define void @RandomFunc(i64* nocapture %0, i64* nocapture writeonly %1) {
%3 = load i64, i64* %0
%4 = mul i64 %3, 67330564296145686
%5 = add i64 %4, -2350340661842412260
%6 = lshr i64 %5, 32
%7 = lshr i64 %5, 40
%8 = and i64 %7, 65280
%9 = and i64 %6, 255
%10 = shl i64 %5, 8
%11 = and i64 %10, 4278190080
%12 = lshr i64 %5, 8
%13 = and i64 %12, 16711680
%14 = and i64 %5, 65534
%15 = and i64 %6, 4278190080
%16 = lshr i64 %5, 24
%17 = and i64 %16, 16711680
%18 = or i64 %15, %17
%19 = or i64 %18, %14
%20 = shl nuw i64 %19, 32
%21 = add nuw nsw i64 %13, 1019446290
%22 = add nuw nsw i64 %21, %11
%23 = add nuw nsw i64 %22, %9
%24 = add nuw nsw i64 %23, %8
%25 = add i64 %24, %20
store i64 %25, i64* %1
ret void
}