void RandomFunc(unsigned short input[1], unsigned short output[1]) {
  unsigned short state[1];
  char copy11;
  char copy12;
  char copy13;
  {
    state[0UL] = input[0UL] + (unsigned short)11483;
    if (state[0UL] & (unsigned short)1) {
      if ((state[0UL] >> (unsigned short)2) & (unsigned short)1) {
        if ((state[0UL] >> (unsigned short)3) & (unsigned short)1) {
          copy11 = *((char *)(&state[0UL]) + 0);
          *((char *)(&state[0UL]) + 0) = *((char *)(&state[0UL]) + 1);
          *((char *)(&state[0UL]) + 1) = copy11;
          copy11 = *((char *)(&state[0UL]) + 1);
          *((char *)(&state[0UL]) + 1) = *((char *)(&state[0UL]) + 0);
          *((char *)(&state[0UL]) + 0) = copy11;
          state[0UL] =
              (state[0UL] >>
               (((state[0UL] >> (unsigned short)1) & (unsigned short)15) |
                1UL)) |
              (state[0UL] << (16 - (((state[0UL] >> (unsigned short)1) &
                                     (unsigned short)15) |
                                    1UL)));
        } else {
          state[0UL] =
              (state[0UL] >>
               (((state[0UL] >> (unsigned short)3) & (unsigned short)15) |
                1UL)) |
              (state[0UL] << (16 - (((state[0UL] >> (unsigned short)3) &
                                     (unsigned short)15) |
                                    1UL)));
          state[0UL] |= (state[0UL] & (unsigned short)63) << 4UL;
        }
      } else if ((state[0UL] >> (unsigned short)3) & (unsigned short)1) {
        state[0UL] =
            (state[0UL] << (((state[0UL] >> (unsigned short)1) &
                             (unsigned short)15) |
                            1UL)) |
            (state[0UL] >>
             (16 - (((state[0UL] >> (unsigned short)1) & (unsigned short)15) |
                    1UL)));
        copy12 = *((char *)(&state[0UL]) + 1);
        *((char *)(&state[0UL]) + 1) = *((char *)(&state[0UL]) + 0);
        *((char *)(&state[0UL]) + 0) = copy12;
      } else {
        state[0UL] |= (state[0UL] & (unsigned short)31) << 3UL;
        state[0UL] *= state[0UL];
      }
    } else if ((state[0UL] >> (unsigned short)4) & (unsigned short)1) {
      state[0UL] |=
          (((state[0UL] >>
             (((state[0UL] >> (unsigned short)4) & (unsigned short)15) | 1UL)) |
            (state[0UL] << (16 - (((state[0UL] >> (unsigned short)4) &
                                   (unsigned short)15) |
                                  1UL)))) &
           (unsigned short)31)
          << 4UL;
      copy13 = *((char *)(&state[0UL]) + 1);
      *((char *)(&state[0UL]) + 1) = *((char *)(&state[0UL]) + 0);
      *((char *)(&state[0UL]) + 0) = copy13;
    } else {
      state[0UL] |= ((state[0UL] + state[0UL]) & (unsigned short)31) << 3UL;
      state[0UL] += state[0UL];
    }
    output[0UL] = (state[0UL] >> (unsigned short)1) >> (unsigned short)3;
  }
}


x86 assembly (clang, -O0):
<RandomFunc>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movzwl (%rax),%eax
add    $0x2cdb,%eax
mov    %ax,-0x12(%rbp)
movzwl -0x12(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     12a5 <RandomFunc+0x1a5>
movzwl -0x12(%rbp),%eax
sar    $0x2,%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1210 <RandomFunc+0x110>
movzwl -0x12(%rbp),%eax
sar    $0x3,%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     11b9 <RandomFunc+0xb9>
mov    -0x12(%rbp),%al
mov    %al,-0x13(%rbp)
mov    -0x11(%rbp),%al
mov    %al,-0x12(%rbp)
mov    -0x13(%rbp),%al
mov    %al,-0x11(%rbp)
mov    -0x11(%rbp),%al
mov    %al,-0x13(%rbp)
mov    -0x12(%rbp),%al
mov    %al,-0x11(%rbp)
mov    -0x13(%rbp),%al
mov    %al,-0x12(%rbp)
movzwl -0x12(%rbp),%eax
movzwl -0x12(%rbp),%ecx
sar    $0x1,%ecx
and    $0xf,%ecx
movslq %ecx,%rcx
or     $0x1,%rcx
sar    %cl,%eax
movzwl -0x12(%rbp),%edx
movzwl -0x12(%rbp),%ecx
sar    $0x1,%ecx
and    $0xf,%ecx
movslq %ecx,%rsi
or     $0x1,%rsi
mov    $0x10,%ecx
sub    %rsi,%rcx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %ax,-0x12(%rbp)
jmp    120b <RandomFunc+0x10b>
movzwl -0x12(%rbp),%eax
movzwl -0x12(%rbp),%ecx
sar    $0x3,%ecx
and    $0xf,%ecx
movslq %ecx,%rcx
or     $0x1,%rcx
sar    %cl,%eax
movzwl -0x12(%rbp),%edx
movzwl -0x12(%rbp),%ecx
sar    $0x3,%ecx
and    $0xf,%ecx
movslq %ecx,%rsi
or     $0x1,%rsi
mov    $0x10,%ecx
sub    %rsi,%rcx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %ax,-0x12(%rbp)
movzwl -0x12(%rbp),%ecx
and    $0x3f,%ecx
shl    $0x4,%ecx
movzwl -0x12(%rbp),%eax
or     %ecx,%eax
mov    %ax,-0x12(%rbp)
jmp    12a0 <RandomFunc+0x1a0>
movzwl -0x12(%rbp),%eax
sar    $0x3,%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1278 <RandomFunc+0x178>
movzwl -0x12(%rbp),%eax
movzwl -0x12(%rbp),%ecx
sar    $0x1,%ecx
and    $0xf,%ecx
movslq %ecx,%rcx
or     $0x1,%rcx
shl    %cl,%eax
movzwl -0x12(%rbp),%edx
movzwl -0x12(%rbp),%ecx
sar    $0x1,%ecx
and    $0xf,%ecx
movslq %ecx,%rsi
or     $0x1,%rsi
mov    $0x10,%ecx
sub    %rsi,%rcx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %ax,-0x12(%rbp)
mov    -0x11(%rbp),%al
mov    %al,-0x14(%rbp)
mov    -0x12(%rbp),%al
mov    %al,-0x11(%rbp)
mov    -0x14(%rbp),%al
mov    %al,-0x12(%rbp)
jmp    129b <RandomFunc+0x19b>
movzwl -0x12(%rbp),%ecx
and    $0x1f,%ecx
shl    $0x3,%ecx
movzwl -0x12(%rbp),%eax
or     %ecx,%eax
mov    %ax,-0x12(%rbp)
movzwl -0x12(%rbp),%ecx
movzwl -0x12(%rbp),%eax
imul   %ecx,%eax
mov    %ax,-0x12(%rbp)
jmp    12a0 <RandomFunc+0x1a0>
jmp    134a <RandomFunc+0x24a>
movzwl -0x12(%rbp),%eax
sar    $0x4,%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     131d <RandomFunc+0x21d>
movzwl -0x12(%rbp),%eax
movzwl -0x12(%rbp),%ecx
sar    $0x4,%ecx
and    $0xf,%ecx
movslq %ecx,%rcx
or     $0x1,%rcx
sar    %cl,%eax
mov    %eax,-0x1c(%rbp)
movzwl -0x12(%rbp),%eax
movzwl -0x12(%rbp),%ecx
sar    $0x4,%ecx
and    $0xf,%ecx
movslq %ecx,%rdx
or     $0x1,%rdx
mov    $0x10,%ecx
sub    %rdx,%rcx
shl    %cl,%eax
mov    -0x1c(%rbp),%ecx
or     %eax,%ecx
and    $0x1f,%ecx
shl    $0x4,%ecx
movzwl -0x12(%rbp),%eax
or     %ecx,%eax
mov    %ax,-0x12(%rbp)
mov    -0x11(%rbp),%al
mov    %al,-0x15(%rbp)
mov    -0x12(%rbp),%al
mov    %al,-0x11(%rbp)
mov    -0x15(%rbp),%al
mov    %al,-0x12(%rbp)
jmp    1345 <RandomFunc+0x245>
movzwl -0x12(%rbp),%ecx
movzwl -0x12(%rbp),%eax
add    %eax,%ecx
and    $0x1f,%ecx
shl    $0x3,%ecx
movzwl -0x12(%rbp),%eax
or     %ecx,%eax
mov    %ax,-0x12(%rbp)
movzwl -0x12(%rbp),%ecx
movzwl -0x12(%rbp),%eax
add    %ecx,%eax
mov    %ax,-0x12(%rbp)
jmp    134a <RandomFunc+0x24a>
movzwl -0x12(%rbp),%eax
sar    $0x1,%eax
sar    $0x3,%eax
mov    %ax,%cx
mov    -0x10(%rbp),%rax
mov    %cx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<RandomFunc>:
movzwl (%rdi),%ecx
add    $0x2cdb,%ecx
movzwl %cx,%eax
test   $0x1,%cl
jne    112a <RandomFunc+0x2a>
mov    %eax,%ecx
test   $0x10,%al
jne    1143 <RandomFunc+0x43>
shl    $0x4,%ecx
movzbl %cl,%ecx
or     %eax,%ecx
lea    (%rcx,%rcx,1),%eax
shr    $0x7,%ecx
movzbl %cl,%edx
jmp    119d <RandomFunc+0x9d>
test   $0x4,%al
jne    115b <RandomFunc+0x5b>
test   $0x8,%al
jne    117b <RandomFunc+0x7b>
lea    0x0(,%rax,8),%ecx
movzbl %cl,%ecx
or     %eax,%ecx
imul   %ecx,%ecx
jmp    1174 <RandomFunc+0x74>
shr    $0x4,%ecx
or     $0x1,%ecx
mov    %eax,%edx
ror    %cl,%dx
and    $0x1f,%edx
shl    $0x4,%edx
or     %eax,%edx
movzbl %dh,%eax
jmp    119d <RandomFunc+0x9d>
mov    %eax,%ecx
test   $0x8,%al
jne    118f <RandomFunc+0x8f>
shr    $0x3,%ecx
or     $0x1,%ecx
ror    %cl,%ax
mov    %eax,%ecx
and    $0x3f,%ecx
shl    $0x4,%ecx
or     %eax,%ecx
movzbl %ch,%edx
mov    %ecx,%eax
jmp    119d <RandomFunc+0x9d>
mov    %eax,%edx
mov    %eax,%ecx
shr    %ecx
or     $0x1,%ecx
rol    %cl,%dx
movzwl %dx,%eax
shr    $0x8,%eax
jmp    119d <RandomFunc+0x9d>
shr    %ecx
or     $0x1,%ecx
ror    %cl,%ax
movzwl %ax,%edx
shr    $0x8,%edx
shl    $0x8,%edx
movzbl %al,%eax
or     %edx,%eax
movzwl %ax,%eax
shr    $0x4,%eax
mov    %ax,(%rsi)
ret

LLVM IR (-O0):
define void @RandomFunc(i16* %0, i16* %1) {
%3 = alloca i16*
%4 = alloca i16*
%5 = alloca [1 x i16]
%6 = alloca i8
%7 = alloca i8
%8 = alloca i8
store i16* %0, i16** %3
store i16* %1, i16** %4
%9 = load i16*, i16** %3
%10 = getelementptr inbounds i16, i16* %9, i64 0
%11 = load i16, i16* %10
%12 = zext i16 %11 to i32
%13 = add nsw i32 %12, 11483
%14 = trunc i32 %13 to i16
%15 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
store i16 %14, i16* %15
%16 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%17 = load i16, i16* %16
%18 = zext i16 %17 to i32
%19 = and i32 %18, 1
%20 = icmp ne i32 %19, 0
br i1 %20, label %21, label %206
21: ; preds = %2
%22 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%23 = load i16, i16* %22
%24 = zext i16 %23 to i32
%25 = ashr i32 %24, 2
%26 = and i32 %25, 1
%27 = icmp ne i32 %26, 0
br i1 %27, label %28, label %134
28: ; preds = %21
%29 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%30 = load i16, i16* %29
%31 = zext i16 %30 to i32
%32 = ashr i32 %31, 3
%33 = and i32 %32, 1
%34 = icmp ne i32 %33, 0
br i1 %34, label %35, label %94
35: ; preds = %28
%36 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%37 = bitcast i16* %36 to i8*
%38 = getelementptr inbounds i8, i8* %37, i64 0
%39 = load i8, i8* %38
store i8 %39, i8* %6
%40 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%41 = bitcast i16* %40 to i8*
%42 = getelementptr inbounds i8, i8* %41, i64 1
%43 = load i8, i8* %42
%44 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%45 = bitcast i16* %44 to i8*
%46 = getelementptr inbounds i8, i8* %45, i64 0
store i8 %43, i8* %46
%47 = load i8, i8* %6
%48 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%49 = bitcast i16* %48 to i8*
%50 = getelementptr inbounds i8, i8* %49, i64 1
store i8 %47, i8* %50
%51 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%52 = bitcast i16* %51 to i8*
%53 = getelementptr inbounds i8, i8* %52, i64 1
%54 = load i8, i8* %53
store i8 %54, i8* %6
%55 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%56 = bitcast i16* %55 to i8*
%57 = getelementptr inbounds i8, i8* %56, i64 0
%58 = load i8, i8* %57
%59 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%60 = bitcast i16* %59 to i8*
%61 = getelementptr inbounds i8, i8* %60, i64 1
store i8 %58, i8* %61
%62 = load i8, i8* %6
%63 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%64 = bitcast i16* %63 to i8*
%65 = getelementptr inbounds i8, i8* %64, i64 0
store i8 %62, i8* %65
%66 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%67 = load i16, i16* %66
%68 = zext i16 %67 to i32
%69 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%70 = load i16, i16* %69
%71 = zext i16 %70 to i32
%72 = ashr i32 %71, 1
%73 = and i32 %72, 15
%74 = sext i32 %73 to i64
%75 = or i64 %74, 1
%76 = trunc i64 %75 to i32
%77 = ashr i32 %68, %76
%78 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%79 = load i16, i16* %78
%80 = zext i16 %79 to i32
%81 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%82 = load i16, i16* %81
%83 = zext i16 %82 to i32
%84 = ashr i32 %83, 1
%85 = and i32 %84, 15
%86 = sext i32 %85 to i64
%87 = or i64 %86, 1
%88 = sub i64 16, %87
%89 = trunc i64 %88 to i32
%90 = shl i32 %80, %89
%91 = or i32 %77, %90
%92 = trunc i32 %91 to i16
%93 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
store i16 %92, i16* %93
br label %133
94: ; preds = %28
%95 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%96 = load i16, i16* %95
%97 = zext i16 %96 to i32
%98 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%99 = load i16, i16* %98
%100 = zext i16 %99 to i32
%101 = ashr i32 %100, 3
%102 = and i32 %101, 15
%103 = sext i32 %102 to i64
%104 = or i64 %103, 1
%105 = trunc i64 %104 to i32
%106 = ashr i32 %97, %105
%107 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%108 = load i16, i16* %107
%109 = zext i16 %108 to i32
%110 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%111 = load i16, i16* %110
%112 = zext i16 %111 to i32
%113 = ashr i32 %112, 3
%114 = and i32 %113, 15
%115 = sext i32 %114 to i64
%116 = or i64 %115, 1
%117 = sub i64 16, %116
%118 = trunc i64 %117 to i32
%119 = shl i32 %109, %118
%120 = or i32 %106, %119
%121 = trunc i32 %120 to i16
%122 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
store i16 %121, i16* %122
%123 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%124 = load i16, i16* %123
%125 = zext i16 %124 to i32
%126 = and i32 %125, 63
%127 = shl i32 %126, 4
%128 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%129 = load i16, i16* %128
%130 = zext i16 %129 to i32
%131 = or i32 %130, %127
%132 = trunc i32 %131 to i16
store i16 %132, i16* %128
br label %133
133: ; preds = %94, %35
br label %205
134: ; preds = %21
%135 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%136 = load i16, i16* %135
%137 = zext i16 %136 to i32
%138 = ashr i32 %137, 3
%139 = and i32 %138, 1
%140 = icmp ne i32 %139, 0
br i1 %140, label %141, label %185
141: ; preds = %134
%142 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%143 = load i16, i16* %142
%144 = zext i16 %143 to i32
%145 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%146 = load i16, i16* %145
%147 = zext i16 %146 to i32
%148 = ashr i32 %147, 1
%149 = and i32 %148, 15
%150 = sext i32 %149 to i64
%151 = or i64 %150, 1
%152 = trunc i64 %151 to i32
%153 = shl i32 %144, %152
%154 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%155 = load i16, i16* %154
%156 = zext i16 %155 to i32
%157 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%158 = load i16, i16* %157
%159 = zext i16 %158 to i32
%160 = ashr i32 %159, 1
%161 = and i32 %160, 15
%162 = sext i32 %161 to i64
%163 = or i64 %162, 1
%164 = sub i64 16, %163
%165 = trunc i64 %164 to i32
%166 = ashr i32 %156, %165
%167 = or i32 %153, %166
%168 = trunc i32 %167 to i16
%169 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
store i16 %168, i16* %169
%170 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%171 = bitcast i16* %170 to i8*
%172 = getelementptr inbounds i8, i8* %171, i64 1
%173 = load i8, i8* %172
store i8 %173, i8* %7
%174 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%175 = bitcast i16* %174 to i8*
%176 = getelementptr inbounds i8, i8* %175, i64 0
%177 = load i8, i8* %176
%178 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%179 = bitcast i16* %178 to i8*
%180 = getelementptr inbounds i8, i8* %179, i64 1
store i8 %177, i8* %180
%181 = load i8, i8* %7
%182 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%183 = bitcast i16* %182 to i8*
%184 = getelementptr inbounds i8, i8* %183, i64 0
store i8 %181, i8* %184
br label %204
185: ; preds = %134
%186 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%187 = load i16, i16* %186
%188 = zext i16 %187 to i32
%189 = and i32 %188, 31
%190 = shl i32 %189, 3
%191 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%192 = load i16, i16* %191
%193 = zext i16 %192 to i32
%194 = or i32 %193, %190
%195 = trunc i32 %194 to i16
store i16 %195, i16* %191
%196 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%197 = load i16, i16* %196
%198 = zext i16 %197 to i32
%199 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%200 = load i16, i16* %199
%201 = zext i16 %200 to i32
%202 = mul nsw i32 %201, %198
%203 = trunc i32 %202 to i16
store i16 %203, i16* %199
br label %204
204: ; preds = %185, %141
br label %205
205: ; preds = %204, %133
br label %286
206: ; preds = %2
%207 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%208 = load i16, i16* %207
%209 = zext i16 %208 to i32
%210 = ashr i32 %209, 4
%211 = and i32 %210, 1
%212 = icmp ne i32 %211, 0
br i1 %212, label %213, label %262
213: ; preds = %206
%214 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%215 = load i16, i16* %214
%216 = zext i16 %215 to i32
%217 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%218 = load i16, i16* %217
%219 = zext i16 %218 to i32
%220 = ashr i32 %219, 4
%221 = and i32 %220, 15
%222 = sext i32 %221 to i64
%223 = or i64 %222, 1
%224 = trunc i64 %223 to i32
%225 = ashr i32 %216, %224
%226 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%227 = load i16, i16* %226
%228 = zext i16 %227 to i32
%229 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%230 = load i16, i16* %229
%231 = zext i16 %230 to i32
%232 = ashr i32 %231, 4
%233 = and i32 %232, 15
%234 = sext i32 %233 to i64
%235 = or i64 %234, 1
%236 = sub i64 16, %235
%237 = trunc i64 %236 to i32
%238 = shl i32 %228, %237
%239 = or i32 %225, %238
%240 = and i32 %239, 31
%241 = shl i32 %240, 4
%242 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%243 = load i16, i16* %242
%244 = zext i16 %243 to i32
%245 = or i32 %244, %241
%246 = trunc i32 %245 to i16
store i16 %246, i16* %242
%247 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%248 = bitcast i16* %247 to i8*
%249 = getelementptr inbounds i8, i8* %248, i64 1
%250 = load i8, i8* %249
store i8 %250, i8* %8
%251 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%252 = bitcast i16* %251 to i8*
%253 = getelementptr inbounds i8, i8* %252, i64 0
%254 = load i8, i8* %253
%255 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%256 = bitcast i16* %255 to i8*
%257 = getelementptr inbounds i8, i8* %256, i64 1
store i8 %254, i8* %257
%258 = load i8, i8* %8
%259 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%260 = bitcast i16* %259 to i8*
%261 = getelementptr inbounds i8, i8* %260, i64 0
store i8 %258, i8* %261
br label %285
262: ; preds = %206
%263 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%264 = load i16, i16* %263
%265 = zext i16 %264 to i32
%266 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%267 = load i16, i16* %266
%268 = zext i16 %267 to i32
%269 = add nsw i32 %265, %268
%270 = and i32 %269, 31
%271 = shl i32 %270, 3
%272 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%273 = load i16, i16* %272
%274 = zext i16 %273 to i32
%275 = or i32 %274, %271
%276 = trunc i32 %275 to i16
store i16 %276, i16* %272
%277 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%278 = load i16, i16* %277
%279 = zext i16 %278 to i32
%280 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%281 = load i16, i16* %280
%282 = zext i16 %281 to i32
%283 = add nsw i32 %282, %279
%284 = trunc i32 %283 to i16
store i16 %284, i16* %280
br label %285
285: ; preds = %262, %213
br label %286
286: ; preds = %285, %205
%287 = getelementptr inbounds [1 x i16], [1 x i16]* %5, i64 0, i64 0
%288 = load i16, i16* %287
%289 = zext i16 %288 to i32
%290 = ashr i32 %289, 1
%291 = ashr i32 %290, 3
%292 = trunc i32 %291 to i16
%293 = load i16*, i16** %4
%294 = getelementptr inbounds i16, i16* %293, i64 0
store i16 %292, i16* %294
ret void
}

LLVM IR (-O2):
define void @RandomFunc(i16* nocapture %0, i16* nocapture writeonly %1) {
%3 = load i16, i16* %0
%4 = add i16 %3, 11483
%5 = zext i16 %4 to i32
%6 = and i32 %5, 1
%7 = icmp eq i32 %6, 0
br i1 %7, label %39, label %8
8: ; preds = %2
%9 = and i32 %5, 4
%10 = icmp eq i32 %9, 0
%11 = and i32 %5, 8
%12 = icmp eq i32 %11, 0
br i1 %10, label %27, label %13
13: ; preds = %8
br i1 %12, label %19, label %14
14: ; preds = %13
%15 = lshr i16 %4, 1
%16 = or i16 %15, 1
%17 = tail call i16 @llvm.fshr.i16(i16 %4, i16 %4, i16 %16)
%18 = lshr i16 %17, 8
br label %56
19: ; preds = %13
%20 = lshr i16 %4, 3
%21 = or i16 %20, 1
%22 = tail call i16 @llvm.fshr.i16(i16 %4, i16 %4, i16 %21)
%23 = shl i16 %22, 4
%24 = and i16 %23, 1008
%25 = or i16 %24, %22
%26 = lshr i16 %25, 8
br label %56
27: ; preds = %8
br i1 %12, label %33, label %28
28: ; preds = %27
%29 = lshr i16 %4, 1
%30 = or i16 %29, 1
%31 = tail call i16 @llvm.fshl.i16(i16 %4, i16 %4, i16 %30)
%32 = lshr i16 %31, 8
br label %56
33: ; preds = %27
%34 = shl i16 %4, 3
%35 = and i16 %34, 248
%36 = or i16 %35, %4
%37 = mul i16 %36, %36
%38 = lshr i16 %37, 8
br label %56
39: ; preds = %2
%40 = and i32 %5, 16
%41 = icmp eq i32 %40, 0
br i1 %41, label %50, label %42
42: ; preds = %39
%43 = lshr i16 %4, 4
%44 = or i16 %43, 1
%45 = tail call i16 @llvm.fshr.i16(i16 %4, i16 %4, i16 %44)
%46 = shl i16 %45, 4
%47 = and i16 %46, 496
%48 = or i16 %47, %4
%49 = lshr i16 %48, 8
br label %56
50: ; preds = %39
%51 = shl i16 %4, 4
%52 = and i16 %51, 240
%53 = or i16 %52, %4
%54 = shl i16 %53, 1
%55 = lshr i16 %54, 8
br label %56
56: ; preds = %42, %50, %19, %14, %33, %28
%57 = phi i16 [ %17, %14 ], [ %25, %19 ], [ %32, %28 ], [ %37, %33 ], [ %49, %42 ], [ %54, %50 ]
%58 = phi i16 [ %18, %14 ], [ %26, %19 ], [ %31, %28 ], [ %38, %33 ], [ %48, %42 ], [ %55, %50 ]
%59 = shl i16 %58, 8
%60 = and i16 %57, 240
%61 = or i16 %59, %60
%62 = lshr exact i16 %61, 4
store i16 %62, i16* %1
ret void
}