void RandomFunc(unsigned long input[1], unsigned long output[1]) {
  unsigned long state[1];
  char copy11;
  unsigned int copy13;
  unsigned int copy14;
  unsigned short copy16;
  unsigned int copy17;
  unsigned short copy18;
  {
    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 if ((state[0UL] >> 1UL) & 1UL) {
        copy14 = *((unsigned int *)(&state[0UL]) + 1);
        *((unsigned int *)(&state[0UL]) + 1) =
            *((unsigned int *)(&state[0UL]) + 0);
        *((unsigned int *)(&state[0UL]) + 0) = copy14;
        copy14 = *((unsigned int *)(&state[0UL]) + 0);
        *((unsigned int *)(&state[0UL]) + 0) =
            *((unsigned int *)(&state[0UL]) + 1);
        *((unsigned int *)(&state[0UL]) + 1) = copy14;
      } else {
        state[0UL] *= state[0UL];
        copy16 = *((unsigned short *)(&state[0UL]) + 3);
        *((unsigned short *)(&state[0UL]) + 3) =
            *((unsigned short *)(&state[0UL]) + 0);
        *((unsigned short *)(&state[0UL]) + 0) = copy16;
      }
    } else if (state[0UL] & 1UL) {
      state[0UL] *= state[0UL];
      copy17 = *((unsigned int *)(&state[0UL]) + 1);
      *((unsigned int *)(&state[0UL]) + 1) =
          *((unsigned int *)(&state[0UL]) + 0);
      *((unsigned int *)(&state[0UL]) + 0) = copy17;
    } else {
      copy18 = *((unsigned short *)(&state[0UL]) + 2);
      *((unsigned short *)(&state[0UL]) + 2) =
          *((unsigned short *)(&state[0UL]) + 3);
      *((unsigned short *)(&state[0UL]) + 3) = copy18;
      copy18 = *((unsigned short *)(&state[0UL]) + 1);
      *((unsigned short *)(&state[0UL]) + 1) =
          *((unsigned short *)(&state[0UL]) + 0);
      *((unsigned short *)(&state[0UL]) + 0) = copy18;
    }
    output[0UL] = state[0UL] + 1506028036UL;
  }
}


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     121b <RandomFunc+0x11b>
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    1216 <RandomFunc+0x116>
mov    -0x18(%rbp),%rax
shr    $0x1,%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     11ec <RandomFunc+0xec>
mov    -0x14(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    1211 <RandomFunc+0x111>
mov    -0x18(%rbp),%rax
imul   -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x12(%rbp),%ax
mov    %ax,-0x26(%rbp)
mov    -0x18(%rbp),%ax
mov    %ax,-0x12(%rbp)
mov    -0x26(%rbp),%ax
mov    %ax,-0x18(%rbp)
jmp    1216 <RandomFunc+0x116>
jmp    1286 <RandomFunc+0x186>
mov    -0x18(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     1251 <RandomFunc+0x151>
mov    -0x18(%rbp),%rax
imul   -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    1281 <RandomFunc+0x181>
mov    -0x14(%rbp),%ax
mov    %ax,-0x2e(%rbp)
mov    -0x12(%rbp),%ax
mov    %ax,-0x14(%rbp)
mov    -0x2e(%rbp),%ax
mov    %ax,-0x12(%rbp)
mov    -0x16(%rbp),%ax
mov    %ax,-0x2e(%rbp)
mov    -0x18(%rbp),%ax
mov    %ax,-0x16(%rbp)
mov    -0x2e(%rbp),%ax
mov    %ax,-0x18(%rbp)
jmp    1286 <RandomFunc+0x186>
mov    -0x18(%rbp),%rcx
add    $0x59c42a04,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<RandomFunc>:
movabs $0xef34ca9f65fb16,%rax
imul   (%rdi),%rax
movabs $0xdf61e99ee5b9fd1c,%rcx
e9 61 df
add    %rax,%rcx
mov    %rcx,%rax
shr    $0x10,%rax
mov    %rcx,%rdx
shr    $0x30,%rdx
shl    $0x10,%ecx
movzwl %ax,%edi
and    $0xffff0000,%eax
or     %eax,%edx
shl    $0x20,%rdx
or     %rcx,%rdi
lea    (%rdx,%rdi,1),%rax
add    $0x59c42a04,%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 i32
%9 = alloca i16
%10 = alloca i32
%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 %145
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 %144
85: ; preds = %22
%86 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%87 = load i64, i64* %86
%88 = lshr i64 %87, 1
%89 = and i64 %88, 1
%90 = icmp ne i64 %89, 0
br i1 %90, label %91, label %122
91: ; preds = %85
%92 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%93 = bitcast i64* %92 to i32*
%94 = getelementptr inbounds i32, i32* %93, i64 1
%95 = load i32, i32* %94
store i32 %95, i32* %8
%96 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%97 = bitcast i64* %96 to i32*
%98 = getelementptr inbounds i32, i32* %97, i64 0
%99 = load i32, i32* %98
%100 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%101 = bitcast i64* %100 to i32*
%102 = getelementptr inbounds i32, i32* %101, i64 1
store i32 %99, i32* %102
%103 = load i32, i32* %8
%104 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%105 = bitcast i64* %104 to i32*
%106 = getelementptr inbounds i32, i32* %105, i64 0
store i32 %103, i32* %106
%107 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%108 = bitcast i64* %107 to i32*
%109 = getelementptr inbounds i32, i32* %108, i64 0
%110 = load i32, i32* %109
store i32 %110, i32* %8
%111 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%112 = bitcast i64* %111 to i32*
%113 = getelementptr inbounds i32, i32* %112, i64 1
%114 = load i32, i32* %113
%115 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%116 = bitcast i64* %115 to i32*
%117 = getelementptr inbounds i32, i32* %116, i64 0
store i32 %114, i32* %117
%118 = load i32, i32* %8
%119 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%120 = bitcast i64* %119 to i32*
%121 = getelementptr inbounds i32, i32* %120, i64 1
store i32 %118, i32* %121
br label %143
122: ; preds = %85
%123 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%124 = load i64, i64* %123
%125 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%126 = load i64, i64* %125
%127 = mul i64 %126, %124
store i64 %127, i64* %125
%128 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%129 = bitcast i64* %128 to i16*
%130 = getelementptr inbounds i16, i16* %129, i64 3
%131 = load i16, i16* %130
store i16 %131, i16* %9
%132 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%133 = bitcast i64* %132 to i16*
%134 = getelementptr inbounds i16, i16* %133, i64 0
%135 = load i16, i16* %134
%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 3
store i16 %135, i16* %138
%139 = load i16, i16* %9
%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 0
store i16 %139, i16* %142
br label %143
143: ; preds = %122, %91
br label %144
144: ; preds = %143, %84
br label %203
145: ; preds = %2
%146 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%147 = load i64, i64* %146
%148 = and i64 %147, 1
%149 = icmp ne i64 %148, 0
br i1 %149, label %150, label %171
150: ; preds = %145
%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 = mul i64 %154, %152
store i64 %155, i64* %153
%156 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%157 = bitcast i64* %156 to i32*
%158 = getelementptr inbounds i32, i32* %157, i64 1
%159 = load i32, i32* %158
store i32 %159, i32* %10
%160 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%161 = bitcast i64* %160 to i32*
%162 = getelementptr inbounds i32, i32* %161, i64 0
%163 = load i32, i32* %162
%164 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%165 = bitcast i64* %164 to i32*
%166 = getelementptr inbounds i32, i32* %165, i64 1
store i32 %163, i32* %166
%167 = load i32, i32* %10
%168 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%169 = bitcast i64* %168 to i32*
%170 = getelementptr inbounds i32, i32* %169, i64 0
store i32 %167, i32* %170
br label %202
171: ; preds = %145
%172 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%173 = bitcast i64* %172 to i16*
%174 = getelementptr inbounds i16, i16* %173, i64 2
%175 = load i16, i16* %174
store i16 %175, i16* %11
%176 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%177 = bitcast i64* %176 to i16*
%178 = getelementptr inbounds i16, i16* %177, i64 3
%179 = load i16, i16* %178
%180 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%181 = bitcast i64* %180 to i16*
%182 = getelementptr inbounds i16, i16* %181, i64 2
store i16 %179, i16* %182
%183 = load i16, i16* %11
%184 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%185 = bitcast i64* %184 to i16*
%186 = getelementptr inbounds i16, i16* %185, i64 3
store i16 %183, i16* %186
%187 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%188 = bitcast i64* %187 to i16*
%189 = getelementptr inbounds i16, i16* %188, i64 1
%190 = load i16, i16* %189
store i16 %190, i16* %11
%191 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%192 = bitcast i64* %191 to i16*
%193 = getelementptr inbounds i16, i16* %192, i64 0
%194 = load i16, i16* %193
%195 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%196 = bitcast i64* %195 to i16*
%197 = getelementptr inbounds i16, i16* %196, i64 1
store i16 %194, i16* %197
%198 = load i16, i16* %11
%199 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%200 = bitcast i64* %199 to i16*
%201 = getelementptr inbounds i16, i16* %200, i64 0
store i16 %198, i16* %201
br label %202
202: ; preds = %171, %150
br label %203
203: ; preds = %202, %144
%204 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%205 = load i64, i64* %204
%206 = add i64 %205, 1506028036
%207 = load i64*, i64** %4
%208 = getelementptr inbounds i64, i64* %207, i64 0
store i64 %206, i64* %208
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, 16
%7 = lshr i64 %5, 48
%8 = and i64 %6, 255
%9 = shl i64 %5, 16
%10 = and i64 %6, 65280
%11 = and i64 %6, 4294901760
%12 = or i64 %11, %7
%13 = shl nuw i64 %12, 32
%14 = and i64 %9, 4294836224
%15 = add nuw nsw i64 %8, 1506028036
%16 = add nuw nsw i64 %15, %10
%17 = add nuw nsw i64 %16, %14
%18 = add i64 %17, %13
store i64 %18, i64* %1
ret void
}