void RandomFunc(unsigned long input[1], unsigned long output[1]) {
  unsigned long state[1];
  char copy11;
  {
    state[0UL] = input[0UL] + 1373777115UL;
    if (state[0UL] & 1UL) {
      if ((state[0UL] >> 2UL) & 1UL) {
        if ((state[0UL] >> 3UL) & 1UL) {
          state[0UL] |=
              ((state[0UL] << (((state[0UL] >> 2UL) & 7UL) | 1UL)) & 15UL)
              << 2UL;
        } else {
          state[0UL] += state[0UL];
        }
      } else if ((state[0UL] >> 2UL) & 1UL) {
        state[0UL] |= (state[0UL] * state[0UL] & 15UL) << 2UL;
      } else {
        state[0UL] |= (state[0UL] & 31UL) << 3UL;
      }
    } else if ((state[0UL] >> 4UL) & 1UL) {
      copy11 = *((char *)(&state[0UL]) + 5);
      *((char *)(&state[0UL]) + 5) = *((char *)(&state[0UL]) + 0);
      *((char *)(&state[0UL]) + 0) = copy11;
    } else {
      state[0UL] |= (state[0UL] & 63UL) << 4UL;
    }
    output[0UL] = (state[0UL] + 319257925UL) - 20975680UL;
  }
}


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    $0x51e22cdb,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     11ea <RandomFunc+0xea>
mov    -0x18(%rbp),%rax
shr    $0x2,%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     1198 <RandomFunc+0x98>
mov    -0x18(%rbp),%rax
shr    $0x3,%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     1187 <RandomFunc+0x87>
mov    -0x18(%rbp),%rax
mov    -0x18(%rbp),%rcx
shr    $0x2,%rcx
and    $0x7,%rcx
or     $0x1,%rcx
shl    %cl,%rax
and    $0xf,%rax
shl    $0x2,%rax
or     -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    1193 <RandomFunc+0x93>
mov    -0x18(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    11e5 <RandomFunc+0xe5>
mov    -0x18(%rbp),%rax
shr    $0x2,%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     11cc <RandomFunc+0xcc>
mov    -0x18(%rbp),%rax
imul   -0x18(%rbp),%rax
and    $0xf,%rax
shl    $0x2,%rax
or     -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    11e0 <RandomFunc+0xe0>
mov    -0x18(%rbp),%rax
and    $0x1f,%rax
shl    $0x3,%rax
or     -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    11e5 <RandomFunc+0xe5>
jmp    1230 <RandomFunc+0x130>
mov    -0x18(%rbp),%rax
shr    $0x4,%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     1217 <RandomFunc+0x117>
mov    -0x13(%rbp),%al
mov    %al,-0x19(%rbp)
mov    -0x18(%rbp),%al
mov    %al,-0x13(%rbp)
mov    -0x19(%rbp),%al
mov    %al,-0x18(%rbp)
jmp    122b <RandomFunc+0x12b>
mov    -0x18(%rbp),%rax
and    $0x3f,%rax
shl    $0x4,%rax
or     -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    1230 <RandomFunc+0x130>
mov    -0x18(%rbp),%rcx
add    $0x13077d45,%rcx
sub    $0x1401040,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<RandomFunc>:
mov    $0x51e22cdb,%edx
add    (%rdi),%rdx
mov    %rdx,%r9
shr    $0x28,%r9
test   $0x1,%dl
jne    112d <RandomFunc+0x2d>
test   $0x10,%dl
jne    113e <RandomFunc+0x3e>
mov    %edx,%edi
and    $0x3f,%edi
shl    $0x4,%rdi
or     %rdx,%rdi
mov    %r9,%r8
mov    %rdi,%r9
jmp    1180 <RandomFunc+0x80>
test   $0x4,%dl
jne    1146 <RandomFunc+0x46>
lea    0x0(,%rdx,8),%ecx
movzbl %cl,%edi
jmp    1174 <RandomFunc+0x74>
mov    %rdx,%r8
mov    %rdx,%rdi
jmp    1180 <RandomFunc+0x80>
test   $0x8,%dl
jne    115d <RandomFunc+0x5d>
add    %rdx,%rdx
mov    %rdx,%r8
shr    $0x28,%r8
mov    %rdx,%rdi
mov    %rdx,%r9
jmp    1180 <RandomFunc+0x80>
mov    %rdx,%rcx
shr    $0x2,%rcx
and    $0x6,%cl
or     $0x1,%cl
mov    %edx,%edi
shl    %cl,%edi
shl    $0x2,%edi
and    $0x38,%edi
or     %rdx,%rdi
mov    %r9,%r8
mov    %rdi,%r9
mov    %rdi,%rdx
movabs $0xffff000000000000,%rcx
and    %rdx,%rcx
movzbl %r8b,%edx
shl    $0x28,%rdx
movabs $0xffffffff00,%rax
and    %rdi,%rax
or     %rdx,%rax
movzbl %r9b,%edx
or     %rax,%rdx
lea    (%rcx,%rdx,1),%rax
add    $0x11c76d05,%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
store i64* %0, i64** %3
store i64* %1, i64** %4
%7 = load i64*, i64** %3
%8 = getelementptr inbounds i64, i64* %7, i64 0
%9 = load i64, i64* %8
%10 = add i64 %9, 1373777115
%11 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
store i64 %10, i64* %11
%12 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%13 = load i64, i64* %12
%14 = and i64 %13, 1
%15 = icmp ne i64 %14, 0
br i1 %15, label %16, label %76
16: ; preds = %2
%17 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%18 = load i64, i64* %17
%19 = lshr i64 %18, 2
%20 = and i64 %19, 1
%21 = icmp ne i64 %20, 0
br i1 %21, label %22, label %49
22: ; preds = %16
%23 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%24 = load i64, i64* %23
%25 = lshr i64 %24, 3
%26 = and i64 %25, 1
%27 = icmp ne i64 %26, 0
br i1 %27, label %28, label %42
28: ; preds = %22
%29 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%30 = load i64, i64* %29
%31 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%32 = load i64, i64* %31
%33 = lshr i64 %32, 2
%34 = and i64 %33, 7
%35 = or i64 %34, 1
%36 = shl i64 %30, %35
%37 = and i64 %36, 15
%38 = shl i64 %37, 2
%39 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%40 = load i64, i64* %39
%41 = or i64 %40, %38
store i64 %41, i64* %39
br label %48
42: ; preds = %22
%43 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%44 = load i64, i64* %43
%45 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%46 = load i64, i64* %45
%47 = add i64 %46, %44
store i64 %47, i64* %45
br label %48
48: ; preds = %42, %28
br label %75
49: ; preds = %16
%50 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%51 = load i64, i64* %50
%52 = lshr i64 %51, 2
%53 = and i64 %52, 1
%54 = icmp ne i64 %53, 0
br i1 %54, label %55, label %66
55: ; preds = %49
%56 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%57 = load i64, i64* %56
%58 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%59 = load i64, i64* %58
%60 = mul i64 %57, %59
%61 = and i64 %60, 15
%62 = shl i64 %61, 2
%63 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%64 = load i64, i64* %63
%65 = or i64 %64, %62
store i64 %65, i64* %63
br label %74
66: ; preds = %49
%67 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%68 = load i64, i64* %67
%69 = and i64 %68, 31
%70 = shl i64 %69, 3
%71 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%72 = load i64, i64* %71
%73 = or i64 %72, %70
store i64 %73, i64* %71
br label %74
74: ; preds = %66, %55
br label %75
75: ; preds = %74, %48
br label %107
76: ; preds = %2
%77 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%78 = load i64, i64* %77
%79 = lshr i64 %78, 4
%80 = and i64 %79, 1
%81 = icmp ne i64 %80, 0
br i1 %81, label %82, label %98
82: ; preds = %76
%83 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%84 = bitcast i64* %83 to i8*
%85 = getelementptr inbounds i8, i8* %84, i64 5
%86 = load i8, i8* %85
store i8 %86, i8* %6
%87 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%88 = bitcast i64* %87 to i8*
%89 = getelementptr inbounds i8, i8* %88, i64 0
%90 = load i8, i8* %89
%91 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%92 = bitcast i64* %91 to i8*
%93 = getelementptr inbounds i8, i8* %92, i64 5
store i8 %90, i8* %93
%94 = load i8, i8* %6
%95 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%96 = bitcast i64* %95 to i8*
%97 = getelementptr inbounds i8, i8* %96, i64 0
store i8 %94, i8* %97
br label %106
98: ; preds = %76
%99 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%100 = load i64, i64* %99
%101 = and i64 %100, 63
%102 = shl i64 %101, 4
%103 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%104 = load i64, i64* %103
%105 = or i64 %104, %102
store i64 %105, i64* %103
br label %106
106: ; preds = %98, %82
br label %107
107: ; preds = %106, %75
%108 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%109 = load i64, i64* %108
%110 = add i64 %109, 319257925
%111 = sub i64 %110, 20975680
%112 = load i64*, i64** %4
%113 = getelementptr inbounds i64, i64* %112, i64 0
store i64 %111, i64* %113
ret void
}

LLVM IR (-O2):
define void @RandomFunc(i64* nocapture %0, i64* nocapture writeonly %1) {
%3 = load i64, i64* %0
%4 = add i64 %3, 1373777115
%5 = lshr i64 %4, 40
%6 = and i64 %4, 1
%7 = icmp eq i64 %6, 0
br i1 %7, label %29, label %8
8: ; preds = %2
%9 = lshr i64 %4, 2
%10 = and i64 %4, 4
%11 = icmp eq i64 %10, 0
br i1 %11, label %25, label %12
12: ; preds = %8
%13 = and i64 %4, 8
%14 = icmp eq i64 %13, 0
br i1 %14, label %22, label %15
15: ; preds = %12
%16 = and i64 %9, 6
%17 = or i64 %16, 1
%18 = shl i64 %4, %17
%19 = shl i64 %18, 2
%20 = and i64 %19, 56
%21 = or i64 %20, %4
br label %36
22: ; preds = %12
%23 = shl i64 %4, 1
%24 = lshr i64 %23, 40
br label %36
25: ; preds = %8
%26 = shl i64 %4, 3
%27 = and i64 %26, 248
%28 = or i64 %27, %4
br label %36
29: ; preds = %2
%30 = and i64 %4, 16
%31 = icmp eq i64 %30, 0
br i1 %31, label %32, label %36
32: ; preds = %29
%33 = shl i64 %4, 4
%34 = and i64 %33, 1008
%35 = or i64 %34, %4
br label %36
36: ; preds = %29, %32, %22, %15, %25
%37 = phi i64 [ %5, %15 ], [ %24, %22 ], [ %5, %25 ], [ %5, %32 ], [ %4, %29 ]
%38 = phi i64 [ %21, %15 ], [ %23, %22 ], [ %28, %25 ], [ %35, %32 ], [ %4, %29 ]
%39 = phi i64 [ %21, %15 ], [ %23, %22 ], [ %28, %25 ], [ %35, %32 ], [ %5, %29 ]
%40 = phi i64 [ %21, %15 ], [ %23, %22 ], [ %28, %25 ], [ %4, %32 ], [ %4, %29 ]
%41 = and i64 %40, -281474976710656
%42 = shl i64 %37, 40
%43 = and i64 %42, 280375465082880
%44 = and i64 %38, 1099511627520
%45 = and i64 %39, 255
%46 = add nuw nsw i64 %44, 298282245
%47 = add nuw nsw i64 %46, %43
%48 = add nuw nsw i64 %47, %45
%49 = add i64 %48, %41
store i64 %49, i64* %1
ret void
}