void RandomFunc(unsigned long input[1], unsigned long output[1]) {
  unsigned long state[1];
  char copy11;
  unsigned short copy12;
  {
    state[0UL] = (input[0UL] - 51238316UL) - 339126204UL;
    if ((state[0UL] >> 3UL) & 1UL) {
      if (state[0UL] & 1UL) {
        if (state[0UL] & 1UL) {
          copy11 = *((char *)(&state[0UL]) + 6);
          *((char *)(&state[0UL]) + 6) = *((char *)(&state[0UL]) + 5);
          *((char *)(&state[0UL]) + 5) = copy11;
          copy11 = *((char *)(&state[0UL]) + 5);
          *((char *)(&state[0UL]) + 5) = *((char *)(&state[0UL]) + 2);
          *((char *)(&state[0UL]) + 2) = copy11;
        } else {
          state[0UL] |= (state[0UL] & 31UL) << 4UL;
        }
      } else if ((state[0UL] >> 3UL) & 1UL) {
        state[0UL] |= (state[0UL] * state[0UL] & 31UL) << 3UL;
      } else {
        copy12 = *((unsigned short *)(&state[0UL]) + 1);
        *((unsigned short *)(&state[0UL]) + 1) =
            *((unsigned short *)(&state[0UL]) + 2);
        *((unsigned short *)(&state[0UL]) + 2) = copy12;
      }
    } else if ((state[0UL] >> 3UL) & 1UL) {
      state[0UL] *= state[0UL];
    } else {
      state[0UL] >>= ((state[0UL] >> 1UL) & 7UL) | 1UL;
    }
    output[0UL] =
        ((state[0UL] >> 15UL) | (state[0UL] << 49UL)) | 648590319959290308UL;
  }
}


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
sub    $0x30dd5ac,%rax
sub    $0x1436a7bc,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x3,%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     11f5 <RandomFunc+0xf5>
mov    -0x18(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     119f <RandomFunc+0x9f>
mov    -0x18(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     1186 <RandomFunc+0x86>
mov    -0x12(%rbp),%al
mov    %al,-0x19(%rbp)
mov    -0x13(%rbp),%al
mov    %al,-0x12(%rbp)
mov    -0x19(%rbp),%al
mov    %al,-0x13(%rbp)
mov    -0x13(%rbp),%al
mov    %al,-0x19(%rbp)
mov    -0x16(%rbp),%al
mov    %al,-0x13(%rbp)
mov    -0x19(%rbp),%al
mov    %al,-0x16(%rbp)
jmp    119a <RandomFunc+0x9a>
mov    -0x18(%rbp),%rax
and    $0x1f,%rax
shl    $0x4,%rax
or     -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    11f0 <RandomFunc+0xf0>
mov    -0x18(%rbp),%rax
shr    $0x3,%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     11d3 <RandomFunc+0xd3>
mov    -0x18(%rbp),%rax
imul   -0x18(%rbp),%rax
and    $0x1f,%rax
shl    $0x3,%rax
or     -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    11eb <RandomFunc+0xeb>
mov    -0x16(%rbp),%ax
mov    %ax,-0x1c(%rbp)
mov    -0x14(%rbp),%ax
mov    %ax,-0x16(%rbp)
mov    -0x1c(%rbp),%ax
mov    %ax,-0x14(%rbp)
jmp    11f0 <RandomFunc+0xf0>
jmp    123d <RandomFunc+0x13d>
mov    -0x18(%rbp),%rax
shr    $0x3,%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     121d <RandomFunc+0x11d>
mov    -0x18(%rbp),%rax
imul   -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    1238 <RandomFunc+0x138>
mov    -0x18(%rbp),%rcx
shr    $0x1,%rcx
and    $0x7,%rcx
or     $0x1,%rcx
mov    -0x18(%rbp),%rax
shr    %cl,%rax
mov    %rax,-0x18(%rbp)
jmp    123d <RandomFunc+0x13d>
mov    -0x18(%rbp),%rcx
shr    $0xf,%rcx
mov    -0x18(%rbp),%rax
shl    $0x31,%rax
or     %rax,%rcx
movabs $0x9004175a9ee31c4,%rax
or     %rax,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<RandomFunc>:
push   %r15
push   %r14
push   %r12
push   %rbx
mov    (%rdi),%r10
lea    -0x17447d68(%r10),%rcx
mov    %rcx,%rdx
shr    $0x10,%rdx
mov    %rcx,%r12
shr    $0x18,%r12
mov    %rcx,%r8
shr    $0x20,%r8
mov    %rcx,%r11
shr    $0x28,%r11
mov    %r12d,%edi
shl    $0x8,%edi
movzbl %dl,%r9d
mov    %r11d,%ebx
shl    $0x8,%ebx
movzbl %r8b,%r15d
movabs $0xffff000000000000,%rax
and    %rcx,%rax
movzwl %bx,%r14d
or     %r15,%r14
mov    %r14,%rbx
shl    $0x20,%rbx
or     %rax,%rbx
movzwl %di,%edi
or     %r9,%rdi
mov    %rdi,%rax
shl    $0x10,%rax
or     %rbx,%rax
movzwl %cx,%ebx
or     %rax,%rbx
test   $0x8,%cl
jne    11ad <RandomFunc+0xad>
shr    %cl
and    $0x6,%cl
or     $0x1,%cl
shr    %cl,%rbx
mov    %rbx,%r9
shr    $0x10,%r9
mov    %rbx,%r12
shr    $0x18,%r12
mov    %rbx,%r8
shr    $0x20,%r8
mov    %rbx,%rdx
shr    $0x28,%rdx
mov    %rbx,%r11
shr    $0x30,%r11
mov    %rbx,%rcx
jmp    11de <RandomFunc+0xde>
mov    %rcx,%r9
shr    $0x30,%r9
test   $0x1,%r10b
jne    11de <RandomFunc+0xde>
mov    %ebx,%eax
imul   %eax,%eax
shl    $0x3,%eax
movzbl %al,%ecx
or     %rbx,%rcx
mov    %edi,%r12d
shr    $0x8,%r12d
mov    %r14d,%edx
shr    $0x8,%edx
mov    %r14d,%r8d
mov    %r9,%r11
mov    %edi,%r9d
movabs $0xff00000000000000,%rax
and    %rcx,%rax
shl    $0x8,%r12d
movzbl %r9b,%edi
or     %r12d,%edi
shl    $0x8,%edx
movzbl %r8b,%ebx
or     %edx,%ebx
movzbl %r11b,%edx
shl    $0x30,%rdx
or     %rax,%rdx
movzwl %bx,%eax
shl    $0x20,%rax
or     %rdx,%rax
movzwl %di,%edx
shl    $0x10,%rdx
or     %rax,%rdx
movzwl %cx,%eax
or     %rdx,%rax
shrd   $0xf,%rcx,%rax
movabs $0x9004175a9ee31c4,%rcx
or     %rax,%rcx
mov    %rcx,(%rsi)
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
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 i16
store i64* %0, i64** %3
store i64* %1, i64** %4
%8 = load i64*, i64** %3
%9 = getelementptr inbounds i64, i64* %8, i64 0
%10 = load i64, i64* %9
%11 = sub i64 %10, 51238316
%12 = sub i64 %11, 339126204
%13 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
store i64 %12, i64* %13
%14 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%15 = load i64, i64* %14
%16 = lshr i64 %15, 3
%17 = and i64 %16, 1
%18 = icmp ne i64 %17, 0
br i1 %18, label %19, label %104
19: ; preds = %2
%20 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%21 = load i64, i64* %20
%22 = and i64 %21, 1
%23 = icmp ne i64 %22, 0
br i1 %23, label %24, label %69
24: ; preds = %19
%25 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%26 = load i64, i64* %25
%27 = and i64 %26, 1
%28 = icmp ne i64 %27, 0
br i1 %28, label %29, label %60
29: ; preds = %24
%30 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%31 = bitcast i64* %30 to i8*
%32 = getelementptr inbounds i8, i8* %31, i64 6
%33 = load i8, i8* %32
store i8 %33, i8* %6
%34 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%35 = bitcast i64* %34 to i8*
%36 = getelementptr inbounds i8, i8* %35, i64 5
%37 = load i8, i8* %36
%38 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%39 = bitcast i64* %38 to i8*
%40 = getelementptr inbounds i8, i8* %39, i64 6
store i8 %37, i8* %40
%41 = load i8, i8* %6
%42 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%43 = bitcast i64* %42 to i8*
%44 = getelementptr inbounds i8, i8* %43, i64 5
store i8 %41, i8* %44
%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 5
%48 = load i8, i8* %47
store i8 %48, i8* %6
%49 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%50 = bitcast i64* %49 to i8*
%51 = getelementptr inbounds i8, i8* %50, i64 2
%52 = load i8, i8* %51
%53 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%54 = bitcast i64* %53 to i8*
%55 = getelementptr inbounds i8, i8* %54, i64 5
store i8 %52, i8* %55
%56 = load i8, i8* %6
%57 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%58 = bitcast i64* %57 to i8*
%59 = getelementptr inbounds i8, i8* %58, i64 2
store i8 %56, i8* %59
br label %68
60: ; preds = %24
%61 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%62 = load i64, i64* %61
%63 = and i64 %62, 31
%64 = shl i64 %63, 4
%65 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%66 = load i64, i64* %65
%67 = or i64 %66, %64
store i64 %67, i64* %65
br label %68
68: ; preds = %60, %29
br label %103
69: ; preds = %19
%70 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%71 = load i64, i64* %70
%72 = lshr i64 %71, 3
%73 = and i64 %72, 1
%74 = icmp ne i64 %73, 0
br i1 %74, label %75, label %86
75: ; preds = %69
%76 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%77 = load i64, i64* %76
%78 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%79 = load i64, i64* %78
%80 = mul i64 %77, %79
%81 = and i64 %80, 31
%82 = shl i64 %81, 3
%83 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%84 = load i64, i64* %83
%85 = or i64 %84, %82
store i64 %85, i64* %83
br label %102
86: ; preds = %69
%87 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%88 = bitcast i64* %87 to i16*
%89 = getelementptr inbounds i16, i16* %88, i64 1
%90 = load i16, i16* %89
store i16 %90, i16* %7
%91 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%92 = bitcast i64* %91 to i16*
%93 = getelementptr inbounds i16, i16* %92, i64 2
%94 = load i16, i16* %93
%95 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%96 = bitcast i64* %95 to i16*
%97 = getelementptr inbounds i16, i16* %96, i64 1
store i16 %94, i16* %97
%98 = load i16, i16* %7
%99 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%100 = bitcast i64* %99 to i16*
%101 = getelementptr inbounds i16, i16* %100, i64 2
store i16 %98, i16* %101
br label %102
102: ; preds = %86, %75
br label %103
103: ; preds = %102, %68
br label %126
104: ; preds = %2
%105 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%106 = load i64, i64* %105
%107 = lshr i64 %106, 3
%108 = and i64 %107, 1
%109 = icmp ne i64 %108, 0
br i1 %109, label %110, label %116
110: ; preds = %104
%111 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%112 = load i64, i64* %111
%113 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%114 = load i64, i64* %113
%115 = mul i64 %114, %112
store i64 %115, i64* %113
br label %125
116: ; preds = %104
%117 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%118 = load i64, i64* %117
%119 = lshr i64 %118, 1
%120 = and i64 %119, 7
%121 = or i64 %120, 1
%122 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%123 = load i64, i64* %122
%124 = lshr i64 %123, %121
store i64 %124, i64* %122
br label %125
125: ; preds = %116, %110
br label %126
126: ; preds = %125, %103
%127 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%128 = load i64, i64* %127
%129 = lshr i64 %128, 15
%130 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%131 = load i64, i64* %130
%132 = shl i64 %131, 49
%133 = or i64 %129, %132
%134 = or i64 %133, 648590319959290308
%135 = load i64*, i64** %4
%136 = getelementptr inbounds i64, i64* %135, i64 0
store i64 %134, i64* %136
ret void
}

LLVM IR (-O2):
define void @RandomFunc(i64* nocapture %0, i64* nocapture writeonly %1) {
%3 = load i64, i64* %0
%4 = add i64 %3, -390364520
%5 = lshr i64 %4, 16
%6 = lshr i64 %4, 24
%7 = lshr i64 %4, 32
%8 = lshr i64 %4, 40
%9 = lshr i64 %4, 48
%10 = shl nuw nsw i64 %6, 8
%11 = and i64 %5, 255
%12 = shl nuw nsw i64 %8, 8
%13 = and i64 %7, 255
%14 = and i64 %4, -281474976710656
%15 = and i64 %12, 65280
%16 = or i64 %15, %13
%17 = shl nuw nsw i64 %16, 32
%18 = or i64 %17, %14
%19 = and i64 %10, 65280
%20 = or i64 %19, %11
%21 = shl nuw nsw i64 %20, 16
%22 = or i64 %18, %21
%23 = and i64 %4, 65535
%24 = or i64 %22, %23
%25 = and i64 %4, 8
%26 = icmp eq i64 %25, 0
br i1 %26, label %43, label %27
27: ; preds = %2
%28 = trunc i64 %9 to i16
%29 = trunc i64 %7 to i16
%30 = trunc i64 %6 to i16
%31 = trunc i64 %5 to i16
%32 = and i64 %3, 1
%33 = icmp eq i64 %32, 0
br i1 %33, label %34, label %57
34: ; preds = %27
%35 = shl i64 %24, 3
%36 = mul i64 %35, %24
%37 = and i64 %36, 248
%38 = or i64 %37, %24
%39 = trunc i64 %20 to i16
%40 = lshr i16 %39, 8
%41 = trunc i64 %16 to i16
%42 = lshr i16 %41, 8
br label %57
43: ; preds = %2
%44 = lshr i64 %4, 1
%45 = and i64 %44, 6
%46 = or i64 %45, 1
%47 = lshr i64 %24, %46
%48 = lshr i64 %47, 16
%49 = trunc i64 %48 to i16
%50 = lshr i64 %47, 24
%51 = trunc i64 %50 to i16
%52 = lshr i64 %47, 32
%53 = trunc i64 %52 to i16
%54 = lshr i64 %47, 40
%55 = trunc i64 %54 to i16
%56 = lshr i64 %47, 48
br label %57
57: ; preds = %27, %43, %34
%58 = phi i16 [ %42, %34 ], [ %55, %43 ], [ %31, %27 ]
%59 = phi i16 [ %41, %34 ], [ %53, %43 ], [ %29, %27 ]
%60 = phi i64 [ %38, %34 ], [ %47, %43 ], [ %4, %27 ]
%61 = phi i64 [ %9, %34 ], [ %56, %43 ], [ %8, %27 ]
%62 = phi i16 [ %39, %34 ], [ %49, %43 ], [ %28, %27 ]
%63 = phi i16 [ %40, %34 ], [ %51, %43 ], [ %30, %27 ]
%64 = and i64 %60, -72057594037927936
%65 = shl i16 %63, 8
%66 = and i16 %62, 255
%67 = or i16 %65, %66
%68 = shl i16 %58, 8
%69 = and i16 %59, 255
%70 = or i16 %69, %68
%71 = shl i64 %61, 48
%72 = and i64 %71, 71776119061217280
%73 = or i64 %64, %72
%74 = zext i16 %70 to i64
%75 = shl nuw nsw i64 %74, 32
%76 = or i64 %73, %75
%77 = zext i16 %67 to i64
%78 = shl nuw nsw i64 %77, 16
%79 = or i64 %78, %76
%80 = and i64 %60, 32768
%81 = or i64 %79, %80
%82 = tail call i64 @llvm.fshl.i64(i64 %60, i64 %81, i64 49)
%83 = or i64 %82, 648590319959290308
store i64 %83, i64* %1
ret void
}