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 {
      state[0UL] |= ((state[0UL] << (((state[0UL] >> 1UL) & 7UL) | 1UL)) & 15UL)
                    << 3UL;
    }
    output[0UL] = state[0UL] * 623241920UL + 137413431168UL;
  }
}


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    121c <RandomFunc+0x11c>
mov    -0x18(%rbp),%rax
mov    -0x18(%rbp),%rcx
shr    $0x1,%rcx
and    $0x7,%rcx
or     $0x1,%rcx
shl    %cl,%rax
and    $0xf,%rax
shl    $0x3,%rax
or     -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
imul   $0x2525eac0,-0x18(%rbp),%rcx
25
movabs $0x1ffe7a8f80,%rax
add    %rax,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<RandomFunc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    (%rdi),%r11
lea    -0x17447d68(%r11),%rax
mov    %rax,%r15
shr    $0x10,%r15
mov    %rax,%r12
shr    $0x18,%r12
mov    %rax,%r8
shr    $0x20,%r8
mov    %rax,%r9
shr    $0x28,%r9
mov    %rax,%r10
shr    $0x30,%r10
mov    %r12d,%edi
shl    $0x8,%edi
movzbl %r15b,%r14d
mov    %r9d,%ecx
shl    $0x8,%ecx
movzbl %r8b,%ebp
movabs $0xffff000000000000,%rbx
and    %rax,%rbx
movzwl %cx,%r13d
or     %rbp,%r13
mov    %r13,%rcx
shl    $0x20,%rcx
or     %rbx,%rcx
movzwl %di,%edx
or     %r14,%rdx
mov    %rdx,%rdi
shl    $0x10,%rdi
or     %rcx,%rdi
movzwl %ax,%ebx
or     %rdi,%rbx
test   $0x8,%al
jne    11a5 <RandomFunc+0xa5>
mov    %eax,%ecx
shr    %cl
and    $0x6,%cl
or     $0x1,%cl
mov    %eax,%edx
shl    %cl,%edx
shl    $0x3,%edx
and    $0x70,%edx
or     %rdx,%rbx
mov    %r9d,%ebp
mov    %r10,%r9
mov    %rbx,%r14
jmp    11db <RandomFunc+0xdb>
mov    %r15d,%ebp
mov    %rax,%r14
mov    %r10d,%r15d
test   $0x1,%r11b
jne    11db <RandomFunc+0xdb>
mov    %ebx,%eax
imul   %eax,%eax
shl    $0x3,%eax
movzbl %al,%eax
or     %rbx,%rax
mov    %edx,%r12d
shr    $0x8,%r12d
mov    %r13d,%ebp
shr    $0x8,%ebp
mov    %r13d,%r8d
mov    %r10,%r9
mov    %rax,%r14
mov    %edx,%r15d
movabs $0xff00000000000000,%rcx
and    %rax,%rcx
shl    $0x8,%r12d
movzbl %r15b,%eax
or     %r12d,%eax
shl    $0x8,%ebp
movzbl %r8b,%edx
or     %ebp,%edx
movzbl %r9b,%edi
shl    $0x30,%rdi
or     %rcx,%rdi
movzwl %dx,%ecx
shl    $0x20,%rcx
or     %rdi,%rcx
movzwl %ax,%eax
shl    $0x10,%rax
or     %rcx,%rax
movzwl %r14w,%ecx
or     %rax,%rcx
imul   $0x2525eac0,%rcx,%rax
movabs $0x1ffe7a8f80,%rcx
add    %rax,%rcx
mov    %rcx,(%rsi)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
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 %118
104: ; preds = %2
%105 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%106 = load i64, i64* %105
%107 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%108 = load i64, i64* %107
%109 = lshr i64 %108, 1
%110 = and i64 %109, 7
%111 = or i64 %110, 1
%112 = shl i64 %106, %111
%113 = and i64 %112, 15
%114 = shl i64 %113, 3
%115 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%116 = load i64, i64* %115
%117 = or i64 %116, %114
store i64 %117, i64* %115
br label %118
118: ; preds = %104, %103
%119 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%120 = load i64, i64* %119
%121 = mul i64 %120, 623241920
%122 = add i64 %121, 137413431168
%123 = load i64*, i64** %4
%124 = getelementptr inbounds i64, i64* %123, i64 0
store i64 %122, i64* %124
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 = trunc i64 %5 to i16
%7 = lshr i64 %4, 24
%8 = trunc i64 %7 to i16
%9 = lshr i64 %4, 32
%10 = trunc i64 %9 to i16
%11 = lshr i64 %4, 40
%12 = lshr i64 %4, 48
%13 = shl nuw nsw i64 %7, 8
%14 = and i64 %5, 255
%15 = shl nuw nsw i64 %11, 8
%16 = and i64 %9, 255
%17 = and i64 %4, -281474976710656
%18 = and i64 %15, 65280
%19 = or i64 %18, %16
%20 = shl nuw nsw i64 %19, 32
%21 = or i64 %20, %17
%22 = and i64 %13, 65280
%23 = or i64 %22, %14
%24 = shl nuw nsw i64 %23, 16
%25 = or i64 %21, %24
%26 = and i64 %4, 65535
%27 = or i64 %25, %26
%28 = and i64 %4, 8
%29 = icmp eq i64 %28, 0
br i1 %29, label %43, label %30
30: ; preds = %2
%31 = trunc i64 %12 to i16
%32 = and i64 %3, 1
%33 = icmp eq i64 %32, 0
br i1 %33, label %34, label %52
34: ; preds = %30
%35 = shl i64 %27, 3
%36 = mul i64 %35, %27
%37 = and i64 %36, 248
%38 = or i64 %37, %27
%39 = trunc i64 %23 to i16
%40 = lshr i16 %39, 8
%41 = trunc i64 %19 to i16
%42 = lshr i16 %41, 8
br label %52
43: ; preds = %2
%44 = lshr i64 %4, 1
%45 = and i64 %44, 6
%46 = or i64 %45, 1
%47 = shl i64 %4, %46
%48 = shl i64 %47, 3
%49 = and i64 %48, 112
%50 = or i64 %27, %49
%51 = trunc i64 %11 to i16
br label %52
52: ; preds = %30, %34, %43
%53 = phi i16 [ %42, %34 ], [ %51, %43 ], [ %6, %30 ]
%54 = phi i16 [ %41, %34 ], [ %10, %43 ], [ %10, %30 ]
%55 = phi i64 [ %38, %34 ], [ %4, %43 ], [ %4, %30 ]
%56 = phi i64 [ %12, %34 ], [ %12, %43 ], [ %11, %30 ]
%57 = phi i64 [ %38, %34 ], [ %50, %43 ], [ %4, %30 ]
%58 = phi i16 [ %39, %34 ], [ %6, %43 ], [ %31, %30 ]
%59 = phi i16 [ %40, %34 ], [ %8, %43 ], [ %8, %30 ]
%60 = and i64 %55, -72057594037927936
%61 = shl i16 %59, 8
%62 = and i16 %58, 255
%63 = or i16 %61, %62
%64 = shl i16 %53, 8
%65 = and i16 %54, 255
%66 = or i16 %65, %64
%67 = shl i64 %56, 48
%68 = and i64 %67, 71776119061217280
%69 = or i64 %60, %68
%70 = zext i16 %66 to i64
%71 = shl nuw nsw i64 %70, 32
%72 = or i64 %69, %71
%73 = zext i16 %63 to i64
%74 = shl nuw nsw i64 %73, 16
%75 = or i64 %74, %72
%76 = and i64 %57, 65535
%77 = or i64 %75, %76
%78 = mul i64 %77, 623241920
%79 = add i64 %78, 137413431168
store i64 %79, i64* %1
ret void
}