void RandomFunc(unsigned long input[1], unsigned long output[1]) {
  unsigned long state[1];
  unsigned long local2;
  unsigned long local1;
  unsigned short copy11;
  {
    state[0UL] = input[0UL] ^ 700325083UL;
    local1 = 0UL;
    while (local1 < input[1UL]) {
      local2 = 0UL;
      while (local2 < input[1UL]) {
        if (state[0UL] == local2 << (((local1 >> 4UL) & 7UL) | 1UL)) {
          copy11 = *((unsigned short *)(&state[0UL]) + 1);
          *((unsigned short *)(&state[0UL]) + 1) =
              *((unsigned short *)(&state[0UL]) + 3);
          *((unsigned short *)(&state[0UL]) + 3) = copy11;
          copy11 = *((unsigned short *)(&state[0UL]) + 0);
          *((unsigned short *)(&state[0UL]) + 0) =
              *((unsigned short *)(&state[0UL]) + 2);
          *((unsigned short *)(&state[0UL]) + 2) = copy11;
        } else {
          state[local2] <<= (state[local2] & 7UL) | 1UL;
        }
        local2 += 2UL;
      }
      local1 += 2UL;
    }
    output[0UL] = state[0UL] | 293908934UL;
  }
}


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
xor    $0x29be1cdb,%rax
mov    %rax,-0x18(%rbp)
movq   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
cmp    0x8(%rcx),%rax
jae    11f4 <RandomFunc+0xf4>
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
cmp    0x8(%rcx),%rax
jae    11e3 <RandomFunc+0xe3>
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rcx
shr    $0x4,%rcx
and    $0x7,%rcx
or     $0x1,%rcx
shl    %cl,%rdx
mov    %rdx,%rcx
cmp    %rcx,%rax
jne    11ad <RandomFunc+0xad>
mov    -0x16(%rbp),%ax
mov    %ax,-0x2a(%rbp)
mov    -0x12(%rbp),%ax
mov    %ax,-0x16(%rbp)
mov    -0x2a(%rbp),%ax
mov    %ax,-0x12(%rbp)
mov    -0x18(%rbp),%ax
mov    %ax,-0x2a(%rbp)
mov    -0x14(%rbp),%ax
mov    %ax,-0x18(%rbp)
mov    -0x2a(%rbp),%ax
mov    %ax,-0x14(%rbp)
jmp    11d2 <RandomFunc+0xd2>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp,%rax,8),%rcx
and    $0x7,%rcx
or     $0x1,%rcx
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp,%rax,8),%rdx
shl    %cl,%rdx
mov    %rdx,%rcx
mov    %rcx,-0x18(%rbp,%rax,8)
mov    -0x20(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x20(%rbp)
jmp    113f <RandomFunc+0x3f>
mov    -0x28(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x28(%rbp)
jmp    1125 <RandomFunc+0x25>
mov    -0x18(%rbp),%rcx
or     $0x1184b1c6,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<RandomFunc>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    (%rdi),%r15
mov    0x8(%rdi),%r9
mov    %r15,%r11
xor    $0x29be1cdb,%r11
mov    %r11,%r14
shr    $0x10,%r14
mov    %r15,%rcx
shr    $0x20,%rcx
shr    $0x30,%r15
test   %r9,%r9
je     11d1 <RandomFunc+0xd1>
xor    %r10d,%r10d
jmp    114d <RandomFunc+0x4d>
nopl   0x0(%rax)
add    $0x2,%r10
cmp    %r9,%r10
jae    11d1 <RandomFunc+0xd1>
mov    %r10,%r8
shr    $0x4,%r8
and    $0x6,%r8d
or     $0x1,%r8
xor    %eax,%eax
jmp    1169 <RandomFunc+0x69>
add    $0x2,%rax
cmp    %r9,%rax
jae    1140 <RandomFunc+0x40>
mov    %r15d,%r12d
mov    %ecx,%ebp
movzwl %r15w,%ecx
shl    $0x30,%rcx
movzwl %bp,%edx
shl    $0x20,%rdx
or     %rcx,%rdx
movzwl %r14w,%edi
shl    $0x10,%rdi
or     %rdx,%rdi
movzwl %r11w,%edx
or     %rdx,%rdi
mov    %rax,%rbx
mov    %r8d,%ecx
shl    %cl,%rbx
mov    %r14d,%r15d
mov    %r11d,%ecx
mov    %r12d,%r14d
mov    %ebp,%r11d
cmp    %rbx,%rdi
je     1160 <RandomFunc+0x60>
and    $0x6,%dl
or     $0x1,%dl
mov    %edx,%ecx
shl    %cl,%rdi
mov    %rdi,%r14
shr    $0x10,%r14
mov    %rdi,%rcx
shr    $0x20,%rcx
mov    %rdi,%r15
shr    $0x30,%r15
mov    %edi,%r11d
jmp    1160 <RandomFunc+0x60>
movzwl %r15w,%eax
shl    $0x30,%rax
movzwl %cx,%ecx
shl    $0x20,%rcx
or     %rax,%rcx
movzwl %r14w,%eax
shl    $0x10,%rax
or     %rcx,%rax
movzwl %r11w,%ecx
or     %rax,%rcx
or     $0x1184b1c6,%rcx
mov    %rcx,(%rsi)
pop    %rbx
pop    %r12
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 i64
%7 = alloca i64
%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 = xor i64 %11, 700325083
%13 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
store i64 %12, i64* %13
store i64 0, i64* %7
br label %14
14: ; preds = %81, %2
%15 = load i64, i64* %7
%16 = load i64*, i64** %3
%17 = getelementptr inbounds i64, i64* %16, i64 1
%18 = load i64, i64* %17
%19 = icmp ult i64 %15, %18
br i1 %19, label %20, label %84
20: ; preds = %14
store i64 0, i64* %6
br label %21
21: ; preds = %78, %20
%22 = load i64, i64* %6
%23 = load i64*, i64** %3
%24 = getelementptr inbounds i64, i64* %23, i64 1
%25 = load i64, i64* %24
%26 = icmp ult i64 %22, %25
br i1 %26, label %27, label %81
27: ; preds = %21
%28 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%29 = load i64, i64* %28
%30 = load i64, i64* %6
%31 = load i64, i64* %7
%32 = lshr i64 %31, 4
%33 = and i64 %32, 7
%34 = or i64 %33, 1
%35 = shl i64 %30, %34
%36 = icmp eq i64 %29, %35
br i1 %36, label %37, label %68
37: ; preds = %27
%38 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%39 = bitcast i64* %38 to i16*
%40 = getelementptr inbounds i16, i16* %39, i64 1
%41 = load i16, i16* %40
store i16 %41, i16* %8
%42 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%43 = bitcast i64* %42 to i16*
%44 = getelementptr inbounds i16, i16* %43, i64 3
%45 = load i16, i16* %44
%46 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%47 = bitcast i64* %46 to i16*
%48 = getelementptr inbounds i16, i16* %47, i64 1
store i16 %45, i16* %48
%49 = load i16, i16* %8
%50 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%51 = bitcast i64* %50 to i16*
%52 = getelementptr inbounds i16, i16* %51, i64 3
store i16 %49, i16* %52
%53 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%54 = bitcast i64* %53 to i16*
%55 = getelementptr inbounds i16, i16* %54, i64 0
%56 = load i16, i16* %55
store i16 %56, i16* %8
%57 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%58 = bitcast i64* %57 to i16*
%59 = getelementptr inbounds i16, i16* %58, i64 2
%60 = load i16, i16* %59
%61 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%62 = bitcast i64* %61 to i16*
%63 = getelementptr inbounds i16, i16* %62, i64 0
store i16 %60, i16* %63
%64 = load i16, i16* %8
%65 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%66 = bitcast i64* %65 to i16*
%67 = getelementptr inbounds i16, i16* %66, i64 2
store i16 %64, i16* %67
br label %78
68: ; preds = %27
%69 = load i64, i64* %6
%70 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 %69
%71 = load i64, i64* %70
%72 = and i64 %71, 7
%73 = or i64 %72, 1
%74 = load i64, i64* %6
%75 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 %74
%76 = load i64, i64* %75
%77 = shl i64 %76, %73
store i64 %77, i64* %75
br label %78
78: ; preds = %68, %37
%79 = load i64, i64* %6
%80 = add i64 %79, 2
store i64 %80, i64* %6
br label %21
81: ; preds = %21
%82 = load i64, i64* %7
%83 = add i64 %82, 2
store i64 %83, i64* %7
br label %14
84: ; preds = %14
%85 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%86 = load i64, i64* %85
%87 = or i64 %86, 293908934
%88 = load i64*, i64** %4
%89 = getelementptr inbounds i64, i64* %88, i64 0
store i64 %87, i64* %89
ret void
}

LLVM IR (-O2):
define void @RandomFunc(i64* nocapture %0, i64* nocapture writeonly %1) {
%3 = load i64, i64* %0
%4 = xor i64 %3, 700325083
%5 = trunc i64 %4 to i16
%6 = lshr i64 %4, 16
%7 = trunc i64 %6 to i16
%8 = lshr i64 %3, 32
%9 = trunc i64 %8 to i16
%10 = lshr i64 %3, 48
%11 = trunc i64 %10 to i16
%12 = getelementptr inbounds i64, i64* %0, i64 1
%13 = load i64, i64* %12
%14 = icmp eq i64 %13, 0
br i1 %14, label %63, label %15
15: ; preds = %2, %60
%16 = phi i64 [ %61, %60 ], [ 0, %2 ]
%17 = phi i16 [ %57, %60 ], [ %5, %2 ]
%18 = phi i16 [ %56, %60 ], [ %7, %2 ]
%19 = phi i16 [ %55, %60 ], [ %9, %2 ]
%20 = phi i16 [ %54, %60 ], [ %11, %2 ]
%21 = lshr i64 %16, 4
%22 = and i64 %21, 6
%23 = or i64 %22, 1
br label %24
24: ; preds = %15, %53
%25 = phi i64 [ 0, %15 ], [ %58, %53 ]
%26 = phi i16 [ %17, %15 ], [ %57, %53 ]
%27 = phi i16 [ %18, %15 ], [ %56, %53 ]
%28 = phi i16 [ %19, %15 ], [ %55, %53 ]
%29 = phi i16 [ %20, %15 ], [ %54, %53 ]
%30 = zext i16 %29 to i64
%31 = shl nuw i64 %30, 48
%32 = zext i16 %28 to i64
%33 = shl nuw nsw i64 %32, 32
%34 = or i64 %33, %31
%35 = zext i16 %27 to i64
%36 = shl nuw nsw i64 %35, 16
%37 = or i64 %34, %36
%38 = zext i16 %26 to i64
%39 = or i64 %37, %38
%40 = shl i64 %25, %23
%41 = icmp eq i64 %39, %40
br i1 %41, label %53, label %42
42: ; preds = %24
%43 = and i64 %38, 6
%44 = or i64 %43, 1
%45 = shl i64 %39, %44
%46 = trunc i64 %45 to i16
%47 = lshr i64 %45, 16
%48 = trunc i64 %47 to i16
%49 = lshr i64 %45, 32
%50 = trunc i64 %49 to i16
%51 = lshr i64 %45, 48
%52 = trunc i64 %51 to i16
br label %53
53: ; preds = %24, %42
%54 = phi i16 [ %52, %42 ], [ %27, %24 ]
%55 = phi i16 [ %50, %42 ], [ %26, %24 ]
%56 = phi i16 [ %48, %42 ], [ %29, %24 ]
%57 = phi i16 [ %46, %42 ], [ %28, %24 ]
%58 = add nuw i64 %25, 2
%59 = icmp ult i64 %58, %13
br i1 %59, label %24, label %60
60: ; preds = %53
%61 = add nuw i64 %16, 2
%62 = icmp ult i64 %61, %13
br i1 %62, label %15, label %63
63: ; preds = %60, %2
%64 = phi i16 [ %11, %2 ], [ %54, %60 ]
%65 = phi i16 [ %9, %2 ], [ %55, %60 ]
%66 = phi i16 [ %7, %2 ], [ %56, %60 ]
%67 = phi i16 [ %5, %2 ], [ %57, %60 ]
%68 = zext i16 %64 to i64
%69 = shl nuw i64 %68, 48
%70 = zext i16 %65 to i64
%71 = shl nuw nsw i64 %70, 32
%72 = or i64 %71, %69
%73 = zext i16 %66 to i64
%74 = shl nuw nsw i64 %73, 16
%75 = or i64 %72, %74
%76 = zext i16 %67 to i64
%77 = or i64 %75, %76
%78 = or i64 %77, 293908934
store i64 %78, i64* %1
ret void
}