void RandomFunc(unsigned long input[1], unsigned long output[1]) {
  unsigned long state[1];
  unsigned short copy11;
  unsigned short copy12;
  unsigned short copy13;
  unsigned short copy14;
  unsigned int copy15;
  char copy17;
  char copy18;
  char copy19;
  {
    state[0UL] = input[0UL] + 0xffffffffff660b45UL;
    if ((state[0UL] >> 4UL) & 1UL) {
      if ((state[0UL] >> 4UL) & 1UL) {
        if ((state[0UL] >> 2UL) & 1UL) {
          copy11 = *((unsigned short *)(&state[0UL]) + 0);
          *((unsigned short *)(&state[0UL]) + 0) =
              *((unsigned short *)(&state[0UL]) + 1);
          *((unsigned short *)(&state[0UL]) + 1) = copy11;
          copy12 = *((unsigned short *)(&state[0UL]) + 1);
          *((unsigned short *)(&state[0UL]) + 1) =
              *((unsigned short *)(&state[0UL]) + 3);
          *((unsigned short *)(&state[0UL]) + 3) = copy12;
          copy12 = *((unsigned short *)(&state[0UL]) + 0);
          *((unsigned short *)(&state[0UL]) + 0) =
              *((unsigned short *)(&state[0UL]) + 2);
          *((unsigned short *)(&state[0UL]) + 2) = copy12;
        } else {
          copy13 = *((unsigned short *)(&state[0UL]) + 3);
          *((unsigned short *)(&state[0UL]) + 3) =
              *((unsigned short *)(&state[0UL]) + 0);
          *((unsigned short *)(&state[0UL]) + 0) = copy13;
          state[0UL] += state[0UL];
        }
      } else if ((state[0UL] >> 1UL) & 1UL) {
        copy14 = *((unsigned short *)(&state[0UL]) + 0);
        *((unsigned short *)(&state[0UL]) + 0) =
            *((unsigned short *)(&state[0UL]) + 1);
        *((unsigned short *)(&state[0UL]) + 1) = copy14;
        copy14 = *((unsigned short *)(&state[0UL]) + 3);
        *((unsigned short *)(&state[0UL]) + 3) =
            *((unsigned short *)(&state[0UL]) + 0);
        *((unsigned short *)(&state[0UL]) + 0) = copy14;
        state[0UL] += state[0UL];
      } else {
        copy15 = *((unsigned int *)(&state[0UL]) + 0);
        *((unsigned int *)(&state[0UL]) + 0) =
            *((unsigned int *)(&state[0UL]) + 1);
        *((unsigned int *)(&state[0UL]) + 1) = copy15;
      }
    } else if ((state[0UL] >> 4UL) & 1UL) {
      copy17 = *((char *)(&state[0UL]) + 3);
      *((char *)(&state[0UL]) + 3) = *((char *)(&state[0UL]) + 7);
      *((char *)(&state[0UL]) + 7) = copy17;
      state[0UL] *= state[0UL];
    } else {
      copy18 = *((char *)(&state[0UL]) + 4);
      *((char *)(&state[0UL]) + 4) = *((char *)(&state[0UL]) + 5);
      *((char *)(&state[0UL]) + 5) = copy18;
      copy19 = *((char *)(&state[0UL]) + 4);
      *((char *)(&state[0UL]) + 4) = *((char *)(&state[0UL]) + 3);
      *((char *)(&state[0UL]) + 3) = copy19;
    }
    output[0UL] = (state[0UL] + 526763427UL) - 655319563553431640UL;
  }
}


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    $0xffffffffff660b45,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x4,%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     1248 <RandomFunc+0x148>
mov    -0x18(%rbp),%rax
shr    $0x4,%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     11d5 <RandomFunc+0xd5>
mov    -0x18(%rbp),%rax
shr    $0x2,%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     11ac <RandomFunc+0xac>
mov    -0x18(%rbp),%ax
mov    %ax,-0x1a(%rbp)
mov    -0x16(%rbp),%ax
mov    %ax,-0x18(%rbp)
mov    -0x1a(%rbp),%ax
mov    %ax,-0x16(%rbp)
mov    -0x16(%rbp),%ax
mov    %ax,-0x1c(%rbp)
mov    -0x12(%rbp),%ax
mov    %ax,-0x16(%rbp)
mov    -0x1c(%rbp),%ax
mov    %ax,-0x12(%rbp)
mov    -0x18(%rbp),%ax
mov    %ax,-0x1c(%rbp)
mov    -0x14(%rbp),%ax
mov    %ax,-0x18(%rbp)
mov    -0x1c(%rbp),%ax
mov    %ax,-0x14(%rbp)
jmp    11d0 <RandomFunc+0xd0>
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    -0x18(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    1243 <RandomFunc+0x143>
mov    -0x18(%rbp),%rax
shr    $0x1,%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     122c <RandomFunc+0x12c>
mov    -0x18(%rbp),%ax
mov    %ax,-0x20(%rbp)
mov    -0x16(%rbp),%ax
mov    %ax,-0x18(%rbp)
mov    -0x20(%rbp),%ax
mov    %ax,-0x16(%rbp)
mov    -0x12(%rbp),%ax
mov    %ax,-0x20(%rbp)
mov    -0x18(%rbp),%ax
mov    %ax,-0x12(%rbp)
mov    -0x20(%rbp),%ax
mov    %ax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    123e <RandomFunc+0x13e>
mov    -0x18(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    1243 <RandomFunc+0x143>
jmp    12ab <RandomFunc+0x1ab>
mov    -0x18(%rbp),%rax
shr    $0x4,%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     1282 <RandomFunc+0x182>
mov    -0x15(%rbp),%al
mov    %al,-0x25(%rbp)
mov    -0x11(%rbp),%al
mov    %al,-0x15(%rbp)
mov    -0x25(%rbp),%al
mov    %al,-0x11(%rbp)
mov    -0x18(%rbp),%rax
imul   -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    12a6 <RandomFunc+0x1a6>
mov    -0x14(%rbp),%al
mov    %al,-0x26(%rbp)
mov    -0x13(%rbp),%al
mov    %al,-0x14(%rbp)
mov    -0x26(%rbp),%al
mov    %al,-0x13(%rbp)
mov    -0x14(%rbp),%al
mov    %al,-0x27(%rbp)
mov    -0x15(%rbp),%al
mov    %al,-0x14(%rbp)
mov    -0x27(%rbp),%al
mov    %al,-0x15(%rbp)
jmp    12ab <RandomFunc+0x1ab>
mov    -0x18(%rbp),%rcx
add    $0x1f65c5a3,%rcx
movabs $0x91829abc7f76058,%rax
29 18 09
sub    %rax,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<RandomFunc>:
push   %rbp
push   %rbx
mov    %rsi,%r10
mov    $0xffffffffff660b45,%rax
add    (%rdi),%rax
mov    %rax,%rdx
shr    $0x10,%rdx
mov    %rax,%rbx
shr    $0x18,%rbx
mov    %rax,%r9
shr    $0x20,%r9
mov    %rax,%r8
shr    $0x30,%r8
mov    %rax,%rdi
shr    $0x38,%rdi
mov    %ebx,%ecx
shl    $0x8,%ecx
movzbl %dl,%ebp
or     %ecx,%ebp
mov    %ebp,%ecx
shl    $0x10,%ecx
movzwl %ax,%esi
or     %ecx,%esi
test   $0x10,%sil
jne    115d <RandomFunc+0x5d>
mov    %rbx,%rbp
mov    %r9d,%ebx
and    $0xff00,%ebx
mov    %r9d,%esi
jmp    11c1 <RandomFunc+0xc1>
shl    $0x8,%edi
movzbl %r8b,%edx
or     %edi,%edx
test   $0x4,%sil
jne    11aa <RandomFunc+0xaa>
movzwl %r9w,%r8d
or     %edx,%ecx
shl    $0x30,%rax
shl    $0x20,%r8
or     %rax,%r8
lea    (%r8,%rcx,1),%rdx
lea    (%rdx,%rdx,1),%rax
shr    $0xf,%rcx
mov    %ecx,%ebx
and    $0xff00,%ebx
shr    $0x1f,%rdx
mov    %rdx,%rbp
movzbl %dh,%esi
shr    $0x2f,%r8
mov    %rax,%rdi
shr    $0x38,%rdi
mov    %ecx,%edx
jmp    11c1 <RandomFunc+0xc1>
mov    %rbx,%rsi
mov    %edi,%ebx
movzwl %ax,%ecx
shr    $0x8,%ecx
movzbl %sil,%esi
mov    %eax,%r8d
mov    %ecx,%edi
mov    %r9d,%eax
movzbl %dl,%ecx
or     %ecx,%ebx
movzwl %bx,%ecx
shl    $0x10,%rcx
movzwl %ax,%eax
shl    $0x8,%esi
movzbl %bpl,%edx
or     %esi,%edx
movzwl %di,%esi
shl    $0x8,%esi
movzbl %r8b,%edi
or     %esi,%edi
movzwl %dx,%edx
shl    $0x30,%rdi
or     %rax,%rdi
shl    $0x20,%rdx
or     %rdi,%rdx
or     %rcx,%rdx
movabs $0xf6e7d654576e654b,%rax
add    %rdx,%rax
mov    %rax,(%r10)
pop    %rbx
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 i16
%7 = alloca i16
%8 = alloca i16
%9 = alloca i16
%10 = alloca i32
%11 = alloca i8
%12 = alloca i8
%13 = alloca i8
store i64* %0, i64** %3
store i64* %1, i64** %4
%14 = load i64*, i64** %3
%15 = getelementptr inbounds i64, i64* %14, i64 0
%16 = load i64, i64* %15
%17 = add i64 %16, -10089659
%18 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
store i64 %17, i64* %18
%19 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%20 = load i64, i64* %19
%21 = lshr i64 %20, 4
%22 = and i64 %21, 1
%23 = icmp ne i64 %22, 0
br i1 %23, label %24, label %164
24: ; preds = %2
%25 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%26 = load i64, i64* %25
%27 = lshr i64 %26, 4
%28 = and i64 %27, 1
%29 = icmp ne i64 %28, 0
br i1 %29, label %30, label %104
30: ; preds = %24
%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, 1
%35 = icmp ne i64 %34, 0
br i1 %35, label %36, label %82
36: ; preds = %30
%37 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%38 = bitcast i64* %37 to i16*
%39 = getelementptr inbounds i16, i16* %38, i64 0
%40 = load i16, i16* %39
store i16 %40, i16* %6
%41 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%42 = bitcast i64* %41 to i16*
%43 = getelementptr inbounds i16, i16* %42, i64 1
%44 = load i16, i16* %43
%45 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%46 = bitcast i64* %45 to i16*
%47 = getelementptr inbounds i16, i16* %46, i64 0
store i16 %44, i16* %47
%48 = load i16, i16* %6
%49 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%50 = bitcast i64* %49 to i16*
%51 = getelementptr inbounds i16, i16* %50, i64 1
store i16 %48, i16* %51
%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* %7
%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 3
%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* %7
%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 3
store i16 %63, i16* %66
%67 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%68 = bitcast i64* %67 to i16*
%69 = getelementptr inbounds i16, i16* %68, i64 0
%70 = load i16, i16* %69
store i16 %70, i16* %7
%71 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%72 = bitcast i64* %71 to i16*
%73 = getelementptr inbounds i16, i16* %72, i64 2
%74 = load i16, i16* %73
%75 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%76 = bitcast i64* %75 to i16*
%77 = getelementptr inbounds i16, i16* %76, i64 0
store i16 %74, i16* %77
%78 = load i16, i16* %7
%79 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%80 = bitcast i64* %79 to i16*
%81 = getelementptr inbounds i16, i16* %80, i64 2
store i16 %78, i16* %81
br label %103
82: ; preds = %30
%83 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%84 = bitcast i64* %83 to i16*
%85 = getelementptr inbounds i16, i16* %84, i64 3
%86 = load i16, i16* %85
store i16 %86, i16* %8
%87 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%88 = bitcast i64* %87 to i16*
%89 = getelementptr inbounds i16, i16* %88, i64 0
%90 = load i16, i16* %89
%91 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%92 = bitcast i64* %91 to i16*
%93 = getelementptr inbounds i16, i16* %92, i64 3
store i16 %90, i16* %93
%94 = load i16, i16* %8
%95 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%96 = bitcast i64* %95 to i16*
%97 = getelementptr inbounds i16, i16* %96, i64 0
store i16 %94, i16* %97
%98 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%99 = load i64, i64* %98
%100 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%101 = load i64, i64* %100
%102 = add i64 %101, %99
store i64 %102, i64* %100
br label %103
103: ; preds = %82, %36
br label %163
104: ; preds = %24
%105 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%106 = load i64, i64* %105
%107 = lshr i64 %106, 1
%108 = and i64 %107, 1
%109 = icmp ne i64 %108, 0
br i1 %109, label %110, label %146
110: ; preds = %104
%111 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%112 = bitcast i64* %111 to i16*
%113 = getelementptr inbounds i16, i16* %112, i64 0
%114 = load i16, i16* %113
store i16 %114, i16* %9
%115 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%116 = bitcast i64* %115 to i16*
%117 = getelementptr inbounds i16, i16* %116, i64 1
%118 = load i16, i16* %117
%119 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%120 = bitcast i64* %119 to i16*
%121 = getelementptr inbounds i16, i16* %120, i64 0
store i16 %118, i16* %121
%122 = load i16, i16* %9
%123 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%124 = bitcast i64* %123 to i16*
%125 = getelementptr inbounds i16, i16* %124, i64 1
store i16 %122, i16* %125
%126 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%127 = bitcast i64* %126 to i16*
%128 = getelementptr inbounds i16, i16* %127, i64 3
%129 = load i16, i16* %128
store i16 %129, i16* %9
%130 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%131 = bitcast i64* %130 to i16*
%132 = getelementptr inbounds i16, i16* %131, i64 0
%133 = load i16, i16* %132
%134 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%135 = bitcast i64* %134 to i16*
%136 = getelementptr inbounds i16, i16* %135, i64 3
store i16 %133, i16* %136
%137 = load i16, i16* %9
%138 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%139 = bitcast i64* %138 to i16*
%140 = getelementptr inbounds i16, i16* %139, i64 0
store i16 %137, i16* %140
%141 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%142 = load i64, i64* %141
%143 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%144 = load i64, i64* %143
%145 = add i64 %144, %142
store i64 %145, i64* %143
br label %162
146: ; preds = %104
%147 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%148 = bitcast i64* %147 to i32*
%149 = getelementptr inbounds i32, i32* %148, i64 0
%150 = load i32, i32* %149
store i32 %150, i32* %10
%151 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%152 = bitcast i64* %151 to i32*
%153 = getelementptr inbounds i32, i32* %152, i64 1
%154 = load i32, i32* %153
%155 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%156 = bitcast i64* %155 to i32*
%157 = getelementptr inbounds i32, i32* %156, i64 0
store i32 %154, i32* %157
%158 = load i32, i32* %10
%159 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%160 = bitcast i64* %159 to i32*
%161 = getelementptr inbounds i32, i32* %160, i64 1
store i32 %158, i32* %161
br label %162
162: ; preds = %146, %110
br label %163
163: ; preds = %162, %103
br label %223
164: ; preds = %2
%165 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%166 = load i64, i64* %165
%167 = lshr i64 %166, 4
%168 = and i64 %167, 1
%169 = icmp ne i64 %168, 0
br i1 %169, label %170, label %191
170: ; preds = %164
%171 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%172 = bitcast i64* %171 to i8*
%173 = getelementptr inbounds i8, i8* %172, i64 3
%174 = load i8, i8* %173
store i8 %174, i8* %11
%175 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%176 = bitcast i64* %175 to i8*
%177 = getelementptr inbounds i8, i8* %176, i64 7
%178 = load i8, i8* %177
%179 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%180 = bitcast i64* %179 to i8*
%181 = getelementptr inbounds i8, i8* %180, i64 3
store i8 %178, i8* %181
%182 = load i8, i8* %11
%183 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%184 = bitcast i64* %183 to i8*
%185 = getelementptr inbounds i8, i8* %184, i64 7
store i8 %182, i8* %185
%186 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%187 = load i64, i64* %186
%188 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%189 = load i64, i64* %188
%190 = mul i64 %189, %187
store i64 %190, i64* %188
br label %222
191: ; preds = %164
%192 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%193 = bitcast i64* %192 to i8*
%194 = getelementptr inbounds i8, i8* %193, i64 4
%195 = load i8, i8* %194
store i8 %195, i8* %12
%196 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%197 = bitcast i64* %196 to i8*
%198 = getelementptr inbounds i8, i8* %197, i64 5
%199 = load i8, i8* %198
%200 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%201 = bitcast i64* %200 to i8*
%202 = getelementptr inbounds i8, i8* %201, i64 4
store i8 %199, i8* %202
%203 = load i8, i8* %12
%204 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%205 = bitcast i64* %204 to i8*
%206 = getelementptr inbounds i8, i8* %205, i64 5
store i8 %203, i8* %206
%207 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%208 = bitcast i64* %207 to i8*
%209 = getelementptr inbounds i8, i8* %208, i64 4
%210 = load i8, i8* %209
store i8 %210, i8* %13
%211 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%212 = bitcast i64* %211 to i8*
%213 = getelementptr inbounds i8, i8* %212, i64 3
%214 = load i8, i8* %213
%215 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%216 = bitcast i64* %215 to i8*
%217 = getelementptr inbounds i8, i8* %216, i64 4
store i8 %214, i8* %217
%218 = load i8, i8* %13
%219 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%220 = bitcast i64* %219 to i8*
%221 = getelementptr inbounds i8, i8* %220, i64 3
store i8 %218, i8* %221
br label %222
222: ; preds = %191, %170
br label %223
223: ; preds = %222, %163
%224 = getelementptr inbounds [1 x i64], [1 x i64]* %5, i64 0, i64 0
%225 = load i64, i64* %224
%226 = add i64 %225, 526763427
%227 = sub i64 %226, 655319563553431640
%228 = load i64*, i64** %4
%229 = getelementptr inbounds i64, i64* %228, i64 0
store i64 %227, i64* %229
ret void
}

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