void RandomFunc(unsigned long input[1], unsigned long output[1]) {
  unsigned long state[1];
  unsigned short copy11;
  char copy12;
  unsigned short copy13;
  {
    state[0UL] = (input[0UL] + 51238316UL) + 274866410UL;
    if ((state[0UL] >> 4UL) & 1UL) {
      if ((state[0UL] >> 3UL) & 1UL) {
        if ((state[0UL] >> 2UL) & 1UL) {
          state[0UL] += state[0UL];
        } else {
          state[0UL] += state[0UL];
        }
      } else if ((state[0UL] >> 2UL) & 1UL) {
        copy11 = *((unsigned short *)(&state[0UL]) + 1);
        *((unsigned short *)(&state[0UL]) + 1) =
            *((unsigned short *)(&state[0UL]) + 0);
        *((unsigned short *)(&state[0UL]) + 0) = copy11;
      } else {
        copy12 = *((char *)(&state[0UL]) + 7);
        *((char *)(&state[0UL]) + 7) = *((char *)(&state[0UL]) + 6);
        *((char *)(&state[0UL]) + 6) = copy12;
      }
    } else {
      copy13 = *((unsigned short *)(&state[0UL]) + 3);
      *((unsigned short *)(&state[0UL]) + 3) =
          *((unsigned short *)(&state[0UL]) + 0);
      *((unsigned short *)(&state[0UL]) + 0) = copy13;
      copy13 = *((unsigned short *)(&state[0UL]) + 1);
      *((unsigned short *)(&state[0UL]) + 1) =
          *((unsigned short *)(&state[0UL]) + 2);
      *((unsigned short *)(&state[0UL]) + 2) = copy13;
    }
    output[0UL] = (state[0UL] + 760496316UL) + 0xffffffffea7c99b7UL;
  }
}


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    $0x30dd5ac,%rax
add    $0x106220ea,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x4,%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     11d6 <RandomFunc+0xd6>
mov    -0x18(%rbp),%rax
shr    $0x3,%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     1187 <RandomFunc+0x87>
mov    -0x18(%rbp),%rax
shr    $0x2,%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     1176 <RandomFunc+0x76>
mov    -0x18(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    1182 <RandomFunc+0x82>
mov    -0x18(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    11d1 <RandomFunc+0xd1>
mov    -0x18(%rbp),%rax
shr    $0x2,%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     11ba <RandomFunc+0xba>
mov    -0x16(%rbp),%ax
mov    %ax,-0x1a(%rbp)
mov    -0x18(%rbp),%ax
mov    %ax,-0x16(%rbp)
mov    -0x1a(%rbp),%ax
mov    %ax,-0x18(%rbp)
jmp    11cc <RandomFunc+0xcc>
mov    -0x11(%rbp),%al
mov    %al,-0x1b(%rbp)
mov    -0x12(%rbp),%al
mov    %al,-0x11(%rbp)
mov    -0x1b(%rbp),%al
mov    %al,-0x12(%rbp)
jmp    11d1 <RandomFunc+0xd1>
jmp    1206 <RandomFunc+0x106>
mov    -0x12(%rbp),%ax
mov    %ax,-0x1e(%rbp)
mov    -0x18(%rbp),%ax
mov    %ax,-0x12(%rbp)
mov    -0x1e(%rbp),%ax
mov    %ax,-0x18(%rbp)
mov    -0x16(%rbp),%ax
mov    %ax,-0x1e(%rbp)
mov    -0x14(%rbp),%ax
mov    %ax,-0x16(%rbp)
mov    -0x1e(%rbp),%ax
mov    %ax,-0x14(%rbp)
mov    -0x18(%rbp),%rcx
add    $0x2d5440bc,%rcx
add    $0xffffffffea7c99b7,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<RandomFunc>:
push   %rbx
movabs $0xffff00000000,%r8
mov    $0x136ff696,%ecx
add    (%rdi),%rcx
mov    %rcx,%r10
shr    $0x10,%r10
mov    %rcx,%rdx
shr    $0x20,%rdx
mov    %rcx,%rbx
shr    $0x30,%rbx
mov    %rcx,%rdi
shr    $0x38,%rdi
mov    %edi,%eax
shl    $0x8,%eax
movzbl %bl,%r11d
or     %eax,%r11d
test   $0x10,%cl
jne    114f <RandomFunc+0x4f>
mov    %rcx,%rdi
shr    $0x8,%rdi
mov    %rdx,%r9
mov    %r10,%rdx
jmp    11ae <RandomFunc+0xae>
test   $0x8,%cl
jne    1172 <RandomFunc+0x72>
test   $0x4,%cl
mov    %rcx,%r9
cmove  %r10,%r9
cmove  %ecx,%r10d
mov    %rbx,%rcx
cmove  %rdi,%rcx
cmove  %rbx,%rdi
mov    %r10d,%r11d
jmp    11ae <RandomFunc+0xae>
shl    $0x30,%r11
mov    %rcx,%rax
and    %r8,%rax
or     %r11,%rax
movzwl %cx,%r11d
and    $0xffff0000,%ecx
or     %rax,%rcx
or     %rcx,%r11
add    %r11,%r11
mov    %r11,%r9
shr    $0x10,%r9
mov    %r11,%rdx
shr    $0x20,%rdx
mov    %r11,%rcx
shr    $0x30,%rcx
mov    %r11,%rdi
shr    $0x38,%rdi
shl    $0x38,%rdi
movzbl %cl,%eax
shl    $0x30,%rax
shl    $0x20,%rdx
and    %r8,%rdx
shl    $0x10,%r9d
movzwl %r11w,%ecx
or     %r9,%rcx
or     %rdx,%rcx
or     %rax,%rcx
lea    (%rdi,%rcx,1),%rax
add    $0x17d0da73,%rax
mov    %rax,(%rsi)
pop    %rbx
ret

LLVM IR (-O0):
define void @RandomFunc(i64* %0, i64* %1) {
%3 = alloca i64*
%4 = alloca i64*
%5 = alloca [1 x i64]
%6 = alloca i16
%7 = alloca i8
%8 = alloca i16
store i64* %0, i64** %3
store i64* %1, i64** %4
%9 = load i64*, i64** %3
%10 = getelementptr inbounds i64, i64* %9, i64 0
%11 = load i64, i64* %10
%12 = add i64 %11, 51238316
%13 = add i64 %12, 274866410
%14 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
store i64 %13, i64* %14
%15 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%16 = load i64, i64* %15
%17 = lshr i64 %16, 4
%18 = and i64 %17, 1
%19 = icmp ne i64 %18, 0
br i1 %19, label %20, label %85
20: ; preds = %2
%21 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%22 = load i64, i64* %21
%23 = lshr i64 %22, 3
%24 = and i64 %23, 1
%25 = icmp ne i64 %24, 0
br i1 %25, label %26, label %45
26: ; preds = %20
%27 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%28 = load i64, i64* %27
%29 = lshr i64 %28, 2
%30 = and i64 %29, 1
%31 = icmp ne i64 %30, 0
br i1 %31, label %32, label %38
32: ; preds = %26
%33 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%34 = load i64, i64* %33
%35 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%36 = load i64, i64* %35
%37 = add i64 %36, %34
store i64 %37, i64* %35
br label %44
38: ; preds = %26
%39 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%40 = load i64, i64* %39
%41 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%42 = load i64, i64* %41
%43 = add i64 %42, %40
store i64 %43, i64* %41
br label %44
44: ; preds = %38, %32
br label %84
45: ; preds = %20
%46 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%47 = load i64, i64* %46
%48 = lshr i64 %47, 2
%49 = and i64 %48, 1
%50 = icmp ne i64 %49, 0
br i1 %50, label %51, label %67
51: ; preds = %45
%52 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%53 = bitcast i64* %52 to i16*
%54 = getelementptr inbounds i16, i16* %53, i64 1
%55 = load i16, i16* %54
store i16 %55, i16* %6
%56 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%57 = bitcast i64* %56 to i16*
%58 = getelementptr inbounds i16, i16* %57, i64 0
%59 = load i16, i16* %58
%60 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%61 = bitcast i64* %60 to i16*
%62 = getelementptr inbounds i16, i16* %61, i64 1
store i16 %59, i16* %62
%63 = load i16, i16* %6
%64 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%65 = bitcast i64* %64 to i16*
%66 = getelementptr inbounds i16, i16* %65, i64 0
store i16 %63, i16* %66
br label %83
67: ; preds = %45
%68 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%69 = bitcast i64* %68 to i8*
%70 = getelementptr inbounds i8, i8* %69, i64 7
%71 = load i8, i8* %70
store i8 %71, i8* %7
%72 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%73 = bitcast i64* %72 to i8*
%74 = getelementptr inbounds i8, i8* %73, i64 6
%75 = load i8, i8* %74
%76 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%77 = bitcast i64* %76 to i8*
%78 = getelementptr inbounds i8, i8* %77, i64 7
store i8 %75, i8* %78
%79 = load i8, i8* %7
%80 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%81 = bitcast i64* %80 to i8*
%82 = getelementptr inbounds i8, i8* %81, i64 6
store i8 %79, i8* %82
br label %83
83: ; preds = %67, %51
br label %84
84: ; preds = %83, %44
br label %116
85: ; preds = %2
%86 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%87 = bitcast i64* %86 to i16*
%88 = getelementptr inbounds i16, i16* %87, i64 3
%89 = load i16, i16* %88
store i16 %89, i16* %8
%90 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%91 = bitcast i64* %90 to i16*
%92 = getelementptr inbounds i16, i16* %91, i64 0
%93 = load i16, i16* %92
%94 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%95 = bitcast i64* %94 to i16*
%96 = getelementptr inbounds i16, i16* %95, i64 3
store i16 %93, i16* %96
%97 = load i16, i16* %8
%98 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%99 = bitcast i64* %98 to i16*
%100 = getelementptr inbounds i16, i16* %99, i64 0
store i16 %97, i16* %100
%101 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%102 = bitcast i64* %101 to i16*
%103 = getelementptr inbounds i16, i16* %102, i64 1
%104 = load i16, i16* %103
store i16 %104, i16* %8
%105 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%106 = bitcast i64* %105 to i16*
%107 = getelementptr inbounds i16, i16* %106, i64 2
%108 = load i16, i16* %107
%109 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%110 = bitcast i64* %109 to i16*
%111 = getelementptr inbounds i16, i16* %110, i64 1
store i16 %108, i16* %111
%112 = load i16, i16* %8
%113 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%114 = bitcast i64* %113 to i16*
%115 = getelementptr inbounds i16, i16* %114, i64 2
store i16 %112, i16* %115
br label %116
116: ; preds = %85, %84
%117 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%118 = load i64, i64* %117
%119 = add i64 %118, 760496316
%120 = add i64 %119, -360932937
%121 = load i64*, i64** %4
%122 = getelementptr inbounds i64, i64* %121, i64 0
store i64 %120, i64* %122
ret void
}

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