void RandomFunc(unsigned long input[1], unsigned long output[1]) {
  unsigned long state[1];
  unsigned long local1;
  char copy11;
  char copy12;
  char copy13;
  unsigned short copy15;
  {
    state[0UL] = (input[0UL] + 51238316UL) + 274866410UL;
    local1 = 0UL;
    while (local1 < input[1UL]) {
      if (state[0UL] < local1) {
        if (state[0UL] == local1) {
          copy11 = *((char *)(&state[local1]) + 7);
          *((char *)(&state[local1]) + 7) = *((char *)(&state[local1]) + 3);
          *((char *)(&state[local1]) + 3) = copy11;
          copy11 = *((char *)(&state[local1]) + 6);
          *((char *)(&state[local1]) + 6) = *((char *)(&state[local1]) + 5);
          *((char *)(&state[local1]) + 5) = copy11;
          state[0UL] -= state[local1];
        } else {
          copy12 = *((char *)(&state[0UL]) + 5);
          *((char *)(&state[0UL]) + 5) = *((char *)(&state[0UL]) + 1);
          *((char *)(&state[0UL]) + 1) = copy12;
          copy12 = *((char *)(&state[0UL]) + 0);
          *((char *)(&state[0UL]) + 0) = *((char *)(&state[0UL]) + 5);
          *((char *)(&state[0UL]) + 5) = copy12;
          copy13 = *((char *)(&state[0UL]) + 1);
          *((char *)(&state[0UL]) + 1) = *((char *)(&state[0UL]) + 0);
          *((char *)(&state[0UL]) + 0) = copy13;
        }
      } else if (state[0UL] > local1) {
        copy15 = *((unsigned short *)(&state[0UL]) + 1);
        *((unsigned short *)(&state[0UL]) + 1) =
            *((unsigned short *)(&state[0UL]) + 3);
        *((unsigned short *)(&state[0UL]) + 3) = copy15;
      } else {
        state[0UL] *= state[0UL];
      }
      local1 += 2UL;
    }
    output[0UL] = state[0UL] + 336211242UL;
  }
}


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)
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
cmp    0x8(%rcx),%rax
jae    1247 <RandomFunc+0x147>
mov    -0x18(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    11f9 <RandomFunc+0xf9>
mov    -0x18(%rbp),%rax
cmp    -0x20(%rbp),%rax
jne    11be <RandomFunc+0xbe>
mov    -0x20(%rbp),%rax
mov    -0x11(%rbp,%rax,8),%al
mov    %al,-0x21(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x15(%rbp,%rax,8),%cl
mov    -0x20(%rbp),%rax
mov    %cl,-0x11(%rbp,%rax,8)
mov    -0x21(%rbp),%cl
mov    -0x20(%rbp),%rax
mov    %cl,-0x15(%rbp,%rax,8)
mov    -0x20(%rbp),%rax
mov    -0x12(%rbp,%rax,8),%al
mov    %al,-0x21(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x13(%rbp,%rax,8),%cl
mov    -0x20(%rbp),%rax
mov    %cl,-0x12(%rbp,%rax,8)
mov    -0x21(%rbp),%cl
mov    -0x20(%rbp),%rax
mov    %cl,-0x13(%rbp,%rax,8)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp,%rax,8),%rcx
mov    -0x18(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x18(%rbp)
jmp    11f4 <RandomFunc+0xf4>
mov    -0x13(%rbp),%al
mov    %al,-0x22(%rbp)
mov    -0x17(%rbp),%al
mov    %al,-0x13(%rbp)
mov    -0x22(%rbp),%al
mov    %al,-0x17(%rbp)
mov    -0x18(%rbp),%al
mov    %al,-0x22(%rbp)
mov    -0x13(%rbp),%al
mov    %al,-0x18(%rbp)
mov    -0x22(%rbp),%al
mov    %al,-0x13(%rbp)
mov    -0x17(%rbp),%al
mov    %al,-0x23(%rbp)
mov    -0x18(%rbp),%al
mov    %al,-0x17(%rbp)
mov    -0x23(%rbp),%al
mov    %al,-0x18(%rbp)
jmp    1236 <RandomFunc+0x136>
mov    -0x18(%rbp),%rax
cmp    -0x20(%rbp),%rax
jbe    1224 <RandomFunc+0x124>
mov    -0x16(%rbp),%ax
mov    %ax,-0x26(%rbp)
mov    -0x12(%rbp),%ax
mov    %ax,-0x16(%rbp)
mov    -0x26(%rbp),%ax
mov    %ax,-0x12(%rbp)
jmp    1231 <RandomFunc+0x131>
mov    -0x18(%rbp),%rax
imul   -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    1236 <RandomFunc+0x136>
mov    -0x20(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x20(%rbp)
jmp    112b <RandomFunc+0x2b>
mov    -0x18(%rbp),%rcx
add    $0x140a2d2a,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<RandomFunc>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    $0x136ff696,%r11d
add    (%rdi),%r11
mov    %r11,%r8
shr    $0x8,%r8
mov    %r11,%r12
shr    $0x10,%r12
mov    %r11,%r10
shr    $0x20,%r10
mov    %r11,%r13
shr    $0x28,%r13
mov    %r11,%rbx
shr    $0x30,%rbx
mov    0x8(%rdi),%r9
test   %r9,%r9
je     11e4 <RandomFunc+0xe4>
xor    %edi,%edi
jmp    116e <RandomFunc+0x6e>
cs nopw 0x0(%rax,%rax,1)
mov    %ebx,%r15d
mov    %r11d,%r14d
mov    %r12d,%ebx
mov    %r13d,%r11d
mov    %ebx,%r12d
add    $0x2,%rdi
mov    %r14d,%r13d
mov    %r15d,%ebx
cmp    %r9,%rdi
jae    11ea <RandomFunc+0xea>
movzwl %bx,%ecx
shl    $0x30,%rcx
movzbl %r13b,%eax
shl    $0x28,%rax
or     %rcx,%rax
movzbl %r10b,%ecx
shl    $0x20,%rcx
or     %rax,%rcx
movzwl %r12w,%eax
shl    $0x10,%rax
or     %rcx,%rax
movzbl %r8b,%edx
shl    $0x8,%rdx
or     %rax,%rdx
movzbl %r11b,%ecx
or     %rdx,%rcx
cmp    %rdi,%rcx
jb     1150 <RandomFunc+0x50>
mov    %r12d,%r15d
mov    %r13d,%r14d
ja     115c <RandomFunc+0x5c>
imul   %rcx,%rcx
mov    %rcx,%r8
shr    $0x8,%r8
mov    %rcx,%rbx
shr    $0x10,%rbx
mov    %rcx,%r10
shr    $0x20,%r10
mov    %rcx,%r14
shr    $0x28,%r14
mov    %rcx,%r15
shr    $0x30,%r15
mov    %ecx,%r11d
jmp    115c <RandomFunc+0x5c>
mov    %ebx,%r15d
mov    %r13d,%r14d
movzwl %r15w,%eax
shl    $0x30,%rax
movzbl %r14b,%ecx
shl    $0x28,%rcx
or     %rax,%rcx
movzbl %r10b,%eax
shl    $0x20,%rax
or     %rcx,%rax
movzwl %r12w,%ecx
shl    $0x10,%rcx
or     %rax,%rcx
movzbl %r8b,%eax
shl    $0x8,%rax
movzbl %r11b,%edx
or     %rcx,%rdx
add    %rdx,%rax
add    $0x140a2d2a,%rax
mov    %rax,(%rsi)
pop    %rbx
pop    %r12
pop    %r13
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 i64
%7 = alloca i8
%8 = alloca i8
%9 = alloca i8
%10 = alloca i16
store i64* %0, i64** %3
store i64* %1, i64** %4
%11 = load i64*, i64** %3
%12 = getelementptr inbounds i64, i64* %11, i64 0
%13 = load i64, i64* %12
%14 = add i64 %13, 51238316
%15 = add i64 %14, 274866410
%16 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
store i64 %15, i64* %16
store i64 0, i64* %6
br label %17
17: ; preds = %153, %2
%18 = load i64, i64* %6
%19 = load i64*, i64** %3
%20 = getelementptr inbounds i64, i64* %19, i64 1
%21 = load i64, i64* %20
%22 = icmp ult i64 %18, %21
br i1 %22, label %23, label %156
23: ; preds = %17
%24 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%25 = load i64, i64* %24
%26 = load i64, i64* %6
%27 = icmp ult i64 %25, %26
br i1 %27, label %28, label %125
28: ; preds = %23
%29 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%30 = load i64, i64* %29
%31 = load i64, i64* %6
%32 = icmp eq i64 %30, %31
br i1 %32, label %33, label %78
33: ; preds = %28
%34 = load i64, i64* %6
%35 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 %34
%36 = bitcast i64* %35 to i8*
%37 = getelementptr inbounds i8, i8* %36, i64 7
%38 = load i8, i8* %37
store i8 %38, i8* %7
%39 = load i64, i64* %6
%40 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 %39
%41 = bitcast i64* %40 to i8*
%42 = getelementptr inbounds i8, i8* %41, i64 3
%43 = load i8, i8* %42
%44 = load i64, i64* %6
%45 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 %44
%46 = bitcast i64* %45 to i8*
%47 = getelementptr inbounds i8, i8* %46, i64 7
store i8 %43, i8* %47
%48 = load i8, i8* %7
%49 = load i64, i64* %6
%50 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 %49
%51 = bitcast i64* %50 to i8*
%52 = getelementptr inbounds i8, i8* %51, i64 3
store i8 %48, i8* %52
%53 = load i64, i64* %6
%54 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 %53
%55 = bitcast i64* %54 to i8*
%56 = getelementptr inbounds i8, i8* %55, i64 6
%57 = load i8, i8* %56
store i8 %57, i8* %7
%58 = load i64, i64* %6
%59 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 %58
%60 = bitcast i64* %59 to i8*
%61 = getelementptr inbounds i8, i8* %60, i64 5
%62 = load i8, i8* %61
%63 = load i64, i64* %6
%64 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 %63
%65 = bitcast i64* %64 to i8*
%66 = getelementptr inbounds i8, i8* %65, i64 6
store i8 %62, i8* %66
%67 = load i8, i8* %7
%68 = load i64, i64* %6
%69 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 %68
%70 = bitcast i64* %69 to i8*
%71 = getelementptr inbounds i8, i8* %70, i64 5
store i8 %67, i8* %71
%72 = load i64, i64* %6
%73 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 %72
%74 = load i64, i64* %73
%75 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%76 = load i64, i64* %75
%77 = sub i64 %76, %74
store i64 %77, i64* %75
br label %124
78: ; preds = %28
%79 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%80 = bitcast i64* %79 to i8*
%81 = getelementptr inbounds i8, i8* %80, i64 5
%82 = load i8, i8* %81
store i8 %82, i8* %8
%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 1
%86 = load i8, i8* %85
%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 5
store i8 %86, i8* %89
%90 = load i8, i8* %8
%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 1
store i8 %90, i8* %93
%94 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%95 = bitcast i64* %94 to i8*
%96 = getelementptr inbounds i8, i8* %95, i64 0
%97 = load i8, i8* %96
store i8 %97, i8* %8
%98 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%99 = bitcast i64* %98 to i8*
%100 = getelementptr inbounds i8, i8* %99, i64 5
%101 = load i8, i8* %100
%102 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%103 = bitcast i64* %102 to i8*
%104 = getelementptr inbounds i8, i8* %103, i64 0
store i8 %101, i8* %104
%105 = load i8, i8* %8
%106 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%107 = bitcast i64* %106 to i8*
%108 = getelementptr inbounds i8, i8* %107, i64 5
store i8 %105, i8* %108
%109 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%110 = bitcast i64* %109 to i8*
%111 = getelementptr inbounds i8, i8* %110, i64 1
%112 = load i8, i8* %111
store i8 %112, i8* %9
%113 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%114 = bitcast i64* %113 to i8*
%115 = getelementptr inbounds i8, i8* %114, i64 0
%116 = load i8, i8* %115
%117 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%118 = bitcast i64* %117 to i8*
%119 = getelementptr inbounds i8, i8* %118, i64 1
store i8 %116, i8* %119
%120 = load i8, i8* %9
%121 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%122 = bitcast i64* %121 to i8*
%123 = getelementptr inbounds i8, i8* %122, i64 0
store i8 %120, i8* %123
br label %124
124: ; preds = %78, %33
br label %153
125: ; preds = %23
%126 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%127 = load i64, i64* %126
%128 = load i64, i64* %6
%129 = icmp ugt i64 %127, %128
br i1 %129, label %130, label %146
130: ; preds = %125
%131 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%132 = bitcast i64* %131 to i16*
%133 = getelementptr inbounds i16, i16* %132, i64 1
%134 = load i16, i16* %133
store i16 %134, i16* %10
%135 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%136 = bitcast i64* %135 to i16*
%137 = getelementptr inbounds i16, i16* %136, i64 3
%138 = load i16, i16* %137
%139 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%140 = bitcast i64* %139 to i16*
%141 = getelementptr inbounds i16, i16* %140, i64 1
store i16 %138, i16* %141
%142 = load i16, i16* %10
%143 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%144 = bitcast i64* %143 to i16*
%145 = getelementptr inbounds i16, i16* %144, i64 3
store i16 %142, i16* %145
br label %152
146: ; preds = %125
%147 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%148 = load i64, i64* %147
%149 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%150 = load i64, i64* %149
%151 = mul i64 %150, %148
store i64 %151, i64* %149
br label %152
152: ; preds = %146, %130
br label %153
153: ; preds = %152, %124
%154 = load i64, i64* %6
%155 = add i64 %154, 2
store i64 %155, i64* %6
br label %17
156: ; preds = %17
%157 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%158 = load i64, i64* %157
%159 = add i64 %158, 336211242
%160 = load i64*, i64** %4
%161 = getelementptr inbounds i64, i64* %160, i64 0
store i64 %159, i64* %161
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 = trunc i64 %4 to i8
%6 = lshr i64 %4, 8
%7 = trunc i64 %6 to i8
%8 = lshr i64 %4, 16
%9 = trunc i64 %8 to i16
%10 = lshr i64 %4, 32
%11 = trunc i64 %10 to i8
%12 = lshr i64 %4, 40
%13 = trunc i64 %12 to i8
%14 = lshr i64 %4, 48
%15 = trunc i64 %14 to i16
%16 = getelementptr inbounds i64, i64* %0, i64 1
%17 = load i64, i64* %16
%18 = icmp eq i64 %17, 0
br i1 %18, label %68, label %19
19: ; preds = %2, %59
%20 = phi i64 [ %66, %59 ], [ 0, %2 ]
%21 = phi i8 [ %65, %59 ], [ %5, %2 ]
%22 = phi i8 [ %64, %59 ], [ %7, %2 ]
%23 = phi i16 [ %63, %59 ], [ %9, %2 ]
%24 = phi i8 [ %62, %59 ], [ %11, %2 ]
%25 = phi i8 [ %61, %59 ], [ %13, %2 ]
%26 = phi i16 [ %60, %59 ], [ %15, %2 ]
%27 = zext i16 %26 to i64
%28 = shl nuw i64 %27, 48
%29 = zext i8 %25 to i64
%30 = shl nuw nsw i64 %29, 40
%31 = or i64 %30, %28
%32 = zext i8 %24 to i64
%33 = shl nuw nsw i64 %32, 32
%34 = or i64 %31, %33
%35 = zext i16 %23 to i64
%36 = shl nuw nsw i64 %35, 16
%37 = or i64 %34, %36
%38 = zext i8 %22 to i64
%39 = shl nuw nsw i64 %38, 8
%40 = or i64 %37, %39
%41 = zext i8 %21 to i64
%42 = or i64 %40, %41
%43 = icmp ult i64 %42, %20
br i1 %43, label %59, label %44
44: ; preds = %19
%45 = icmp ugt i64 %42, %20
br i1 %45, label %59, label %46
46: ; preds = %44
%47 = mul i64 %42, %42
%48 = trunc i64 %47 to i8
%49 = lshr i64 %47, 8
%50 = trunc i64 %49 to i8
%51 = lshr i64 %47, 16
%52 = trunc i64 %51 to i16
%53 = lshr i64 %47, 32
%54 = trunc i64 %53 to i8
%55 = lshr i64 %47, 40
%56 = trunc i64 %55 to i8
%57 = lshr i64 %47, 48
%58 = trunc i64 %57 to i16
br label %59
59: ; preds = %44, %19, %46
%60 = phi i16 [ %58, %46 ], [ %26, %19 ], [ %23, %44 ]
%61 = phi i8 [ %56, %46 ], [ %21, %19 ], [ %25, %44 ]
%62 = phi i8 [ %54, %46 ], [ %24, %19 ], [ %24, %44 ]
%63 = phi i16 [ %52, %46 ], [ %23, %19 ], [ %26, %44 ]
%64 = phi i8 [ %50, %46 ], [ %22, %19 ], [ %22, %44 ]
%65 = phi i8 [ %48, %46 ], [ %25, %19 ], [ %21, %44 ]
%66 = add nuw i64 %20, 2
%67 = icmp ult i64 %66, %17
br i1 %67, label %19, label %68
68: ; preds = %59, %2
%69 = phi i16 [ %15, %2 ], [ %60, %59 ]
%70 = phi i8 [ %13, %2 ], [ %61, %59 ]
%71 = phi i8 [ %11, %2 ], [ %62, %59 ]
%72 = phi i16 [ %9, %2 ], [ %63, %59 ]
%73 = phi i8 [ %7, %2 ], [ %64, %59 ]
%74 = phi i8 [ %5, %2 ], [ %65, %59 ]
%75 = zext i16 %69 to i64
%76 = shl nuw i64 %75, 48
%77 = zext i8 %70 to i64
%78 = shl nuw nsw i64 %77, 40
%79 = zext i8 %71 to i64
%80 = shl nuw nsw i64 %79, 32
%81 = zext i16 %72 to i64
%82 = shl nuw nsw i64 %81, 16
%83 = zext i8 %73 to i64
%84 = shl nuw nsw i64 %83, 8
%85 = zext i8 %74 to i64
%86 = or i64 %76, %78
%87 = or i64 %86, %80
%88 = or i64 %87, 336211242
%89 = add i64 %88, %82
%90 = add nuw nsw i64 %89, %85
%91 = add i64 %90, %84
store i64 %91, i64* %1
ret void
}