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 if (state[0UL] & 1UL) {
      state[0UL] += state[0UL];
    } else {
      copy13 = *((unsigned short *)(&state[0UL]) + 0);
      *((unsigned short *)(&state[0UL]) + 0) =
          *((unsigned short *)(&state[0UL]) + 3);
      *((unsigned short *)(&state[0UL]) + 3) = copy13;
    }
    output[0UL] = state[0UL] + 1340868088UL;
  }
}


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    1216 <RandomFunc+0x116>
mov    -0x18(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     11f9 <RandomFunc+0xf9>
mov    -0x18(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    1211 <RandomFunc+0x111>
mov    -0x18(%rbp),%ax
mov    %ax,-0x1e(%rbp)
mov    -0x12(%rbp),%ax
mov    %ax,-0x18(%rbp)
mov    -0x1e(%rbp),%ax
mov    %ax,-0x12(%rbp)
jmp    1216 <RandomFunc+0x116>
mov    -0x18(%rbp),%rcx
add    $0x4fec05f8,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<RandomFunc>:
push   %r14
push   %rbx
movabs $0xffff00000000,%r8
mov    (%rdi),%r10
lea    0x136ff696(%r10),%rdi
mov    %rdi,%r11
shr    $0x10,%r11
mov    %rdi,%r9
shr    $0x30,%r9
mov    %rdi,%rcx
shr    $0x38,%rcx
mov    %ecx,%eax
shl    $0x8,%eax
movzbl %r9b,%r14d
or     %eax,%r14d
mov    %r14,%rax
shl    $0x30,%rax
mov    %rdi,%rbx
and    %r8,%rbx
or     %rax,%rbx
mov    %edi,%edx
and    $0xffff0000,%edx
or     %rbx,%rdx
movzwl %di,%eax
or     %rdx,%rax
test   $0x10,%dil
jne    1174 <RandomFunc+0x74>
test   $0x1,%r10b
jne    119c <RandomFunc+0x9c>
mov    %rdi,%rcx
shr    $0x8,%rcx
mov    %r14d,%eax
mov    %rdi,%r10
jmp    11b7 <RandomFunc+0xb7>
test   $0x8,%dil
jne    119c <RandomFunc+0x9c>
test   $0x4,%dil
mov    %rdi,%rdx
cmove  %r11,%rdx
cmove  %edi,%r11d
mov    %r11d,%eax
mov    %r9,%r10
cmove  %rcx,%r10
cmove  %r9,%rcx
mov    %rdx,%r11
jmp    11b7 <RandomFunc+0xb7>
add    %rax,%rax
mov    %rax,%r11
shr    $0x10,%r11
mov    %rax,%r10
shr    $0x30,%r10
mov    %rax,%rcx
shr    $0x38,%rcx
mov    %rax,%rdi
shl    $0x38,%rcx
movzbl %r10b,%edx
shl    $0x30,%rdx
and    %r8,%rdi
shl    $0x10,%r11d
movzwl %ax,%eax
or     %r11,%rax
add    %rdi,%rax
add    %rdx,%rax
add    %rcx,%rax
add    $0x4fec05f8,%rax
mov    %rax,(%rsi)
pop    %rbx
pop    %r14
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 %113
85: ; preds = %2
%86 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%87 = load i64, i64* %86
%88 = and i64 %87, 1
%89 = icmp ne i64 %88, 0
br i1 %89, label %90, label %96
90: ; preds = %85
%91 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%92 = load i64, i64* %91
%93 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%94 = load i64, i64* %93
%95 = add i64 %94, %92
store i64 %95, i64* %93
br label %112
96: ; preds = %85
%97 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%98 = bitcast i64* %97 to i16*
%99 = getelementptr inbounds i16, i16* %98, i64 0
%100 = load i16, i16* %99
store i16 %100, i16* %8
%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 3
%104 = load i16, i16* %103
%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 0
store i16 %104, i16* %107
%108 = load i16, i16* %8
%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 3
store i16 %108, i16* %111
br label %112
112: ; preds = %96, %90
br label %113
113: ; preds = %112, %84
%114 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%115 = load i64, i64* %114
%116 = add i64 %115, 1340868088
%117 = load i64*, i64** %4
%118 = getelementptr inbounds i64, i64* %117, i64 0
store i64 %116, i64* %118
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, 48
%7 = lshr i64 %4, 56
%8 = trunc i64 %7 to i16
%9 = shl nuw i16 %8, 8
%10 = trunc i64 %6 to i16
%11 = and i16 %10, 255
%12 = or i16 %9, %11
%13 = zext i16 %12 to i64
%14 = shl nuw i64 %13, 48
%15 = and i64 %4, 281470681743360
%16 = or i64 %14, %15
%17 = and i64 %4, 4294901760
%18 = or i64 %16, %17
%19 = and i64 %4, 65535
%20 = or i64 %18, %19
%21 = and i64 %4, 16
%22 = icmp eq i64 %21, 0
br i1 %22, label %40, label %23
23: ; preds = %2
%24 = and i64 %4, 8
%25 = icmp eq i64 %24, 0
%26 = and i64 %4, 4
%27 = icmp eq i64 %26, 0
br i1 %25, label %34, label %28
28: ; preds = %23
%29 = shl i64 %20, 1
%30 = trunc i64 %29 to i16
%31 = lshr i64 %29, 16
%32 = lshr i64 %29, 48
%33 = lshr i64 %29, 56
br label %51
34: ; preds = %23
%35 = select i1 %27, i64 %5, i64 %4
%36 = select i1 %27, i64 %4, i64 %5
%37 = trunc i64 %36 to i16
%38 = select i1 %27, i64 %7, i64 %6
%39 = select i1 %27, i64 %6, i64 %7
br label %51
40: ; preds = %2
%41 = and i64 %3, 1
%42 = icmp eq i64 %41, 0
br i1 %42, label %49, label %43
43: ; preds = %40
%44 = shl i64 %20, 1
%45 = trunc i64 %44 to i16
%46 = lshr i64 %44, 16
%47 = lshr i64 %44, 48
%48 = lshr i64 %44, 56
br label %51
49: ; preds = %40
%50 = lshr i64 %4, 8
br label %51
51: ; preds = %28, %34, %43, %49
%52 = phi i64 [ %46, %43 ], [ %5, %49 ], [ %35, %34 ], [ %31, %28 ]
%53 = phi i16 [ %45, %43 ], [ %12, %49 ], [ %37, %34 ], [ %30, %28 ]
%54 = phi i64 [ %44, %43 ], [ %4, %49 ], [ %4, %34 ], [ %29, %28 ]
%55 = phi i64 [ %47, %43 ], [ %4, %49 ], [ %38, %34 ], [ %32, %28 ]
%56 = phi i64 [ %48, %43 ], [ %50, %49 ], [ %39, %34 ], [ %33, %28 ]
%57 = shl i64 %56, 56
%58 = shl i64 %55, 48
%59 = and i64 %58, 71776119061217280
%60 = and i64 %54, 281470681743360
%61 = shl i64 %52, 16
%62 = and i64 %61, 4294901760
%63 = zext i16 %53 to i64
%64 = add nuw nsw i64 %63, 1340868088
%65 = add nuw nsw i64 %64, %62
%66 = add nuw nsw i64 %65, %60
%67 = add nuw nsw i64 %66, %59
%68 = add i64 %67, %57
store i64 %68, i64* %1
ret void
}