void RandomFunc(unsigned int input[1], unsigned int output[1]) {
  unsigned int state[1];
  unsigned int local1;
  char copy11;
  char copy12;
  char copy14;
  {
    state[0UL] = (input[0UL] - 51238316UL) - 339126204U;
    local1 = 0UL;
    while (local1 < 0U) {
      if (state[0UL] > local1) {
        state[0UL] |=
            (((state[local1] >> ((state[local1] & 15U) | 1UL)) |
              (state[local1] << (32 - ((state[local1] & 15U) | 1UL)))) &
             63U)
            << 4UL;
        copy11 = *((char *)(&state[local1]) + 3);
        *((char *)(&state[local1]) + 3) = *((char *)(&state[local1]) + 2);
        *((char *)(&state[local1]) + 2) = copy11;
        copy11 = *((char *)(&state[local1]) + 2);
        *((char *)(&state[local1]) + 2) = *((char *)(&state[local1]) + 1);
        *((char *)(&state[local1]) + 1) = copy11;
      } else {
        copy12 = *((char *)(&state[local1]) + 1);
        *((char *)(&state[local1]) + 1) = *((char *)(&state[local1]) + 0);
        *((char *)(&state[local1]) + 0) = copy12;
        copy12 = *((char *)(&state[local1]) + 0);
        *((char *)(&state[local1]) + 0) = *((char *)(&state[local1]) + 2);
        *((char *)(&state[local1]) + 2) = copy12;
      }
      if (state[0UL] == local1) {
        copy14 = *((char *)(&state[local1]) + 1);
        *((char *)(&state[local1]) + 1) = *((char *)(&state[local1]) + 3);
        *((char *)(&state[local1]) + 3) = copy14;
        state[0UL] |= (state[local1] * state[local1] & 7U) << 2UL;
      } else {
        state[local1] = state[0UL] | state[local1];
        state[0UL] |=
            (((state[0UL] >> (((state[0UL] >> 3U) & 15U) | 1UL)) |
              (state[0UL] << (32 - (((state[0UL] >> 3U) & 15U) | 1UL)))) &
             15U)
            << 3UL;
      }
      local1++;
    }
    output[0UL] = state[0UL] * 116928511UL;
  }
}


x86 assembly (clang, -O0):
<RandomFunc>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
sub    $0x30dd5ac,%rax
sub    $0x1436a7bc,%rax
mov    %eax,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
jae    12c6 <RandomFunc+0x1c6>
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jbe    11d3 <RandomFunc+0xd3>
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp,%rax,4),%eax
mov    -0x18(%rbp),%ecx
mov    -0x14(%rbp,%rcx,4),%ecx
and    $0xf,%ecx
mov    %ecx,%ecx
or     $0x1,%rcx
shr    %cl,%eax
mov    -0x18(%rbp),%ecx
mov    -0x14(%rbp,%rcx,4),%edx
mov    -0x18(%rbp),%ecx
mov    -0x14(%rbp,%rcx,4),%ecx
and    $0xf,%ecx
mov    %ecx,%ecx
mov    %ecx,%esi
or     $0x1,%rsi
mov    $0x20,%ecx
sub    %rsi,%rcx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
and    $0x3f,%eax
shl    $0x4,%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x11(%rbp,%rax,4),%al
mov    %al,-0x19(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x12(%rbp,%rax,4),%cl
mov    -0x18(%rbp),%eax
mov    %cl,-0x11(%rbp,%rax,4)
mov    -0x19(%rbp),%cl
mov    -0x18(%rbp),%eax
mov    %cl,-0x12(%rbp,%rax,4)
mov    -0x18(%rbp),%eax
mov    -0x12(%rbp,%rax,4),%al
mov    %al,-0x19(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x13(%rbp,%rax,4),%cl
mov    -0x18(%rbp),%eax
mov    %cl,-0x12(%rbp,%rax,4)
mov    -0x19(%rbp),%cl
mov    -0x18(%rbp),%eax
mov    %cl,-0x13(%rbp,%rax,4)
jmp    1217 <RandomFunc+0x117>
mov    -0x18(%rbp),%eax
mov    -0x13(%rbp,%rax,4),%al
mov    %al,-0x1a(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp,%rax,4),%cl
mov    -0x18(%rbp),%eax
mov    %cl,-0x13(%rbp,%rax,4)
mov    -0x1a(%rbp),%cl
mov    -0x18(%rbp),%eax
mov    %cl,-0x14(%rbp,%rax,4)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp,%rax,4),%al
mov    %al,-0x1a(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x12(%rbp,%rax,4),%cl
mov    -0x18(%rbp),%eax
mov    %cl,-0x14(%rbp,%rax,4)
mov    -0x1a(%rbp),%cl
mov    -0x18(%rbp),%eax
mov    %cl,-0x12(%rbp,%rax,4)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jne    1265 <RandomFunc+0x165>
mov    -0x18(%rbp),%eax
mov    -0x13(%rbp,%rax,4),%al
mov    %al,-0x1b(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x11(%rbp,%rax,4),%cl
mov    -0x18(%rbp),%eax
mov    %cl,-0x13(%rbp,%rax,4)
mov    -0x1b(%rbp),%cl
mov    -0x18(%rbp),%eax
mov    %cl,-0x11(%rbp,%rax,4)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp,%rax,4),%eax
mov    -0x18(%rbp),%ecx
imul   -0x14(%rbp,%rcx,4),%eax
and    $0x7,%eax
shl    $0x2,%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    12b8 <RandomFunc+0x1b8>
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%eax
or     -0x14(%rbp,%rax,4),%ecx
mov    -0x18(%rbp),%eax
mov    %ecx,-0x14(%rbp,%rax,4)
mov    -0x14(%rbp),%eax
mov    -0x14(%rbp),%ecx
shr    $0x3,%ecx
and    $0xf,%ecx
mov    %ecx,%ecx
or     $0x1,%rcx
shr    %cl,%eax
mov    -0x14(%rbp),%edx
mov    -0x14(%rbp),%ecx
shr    $0x3,%ecx
and    $0xf,%ecx
mov    %ecx,%ecx
mov    %ecx,%esi
or     $0x1,%rsi
mov    $0x20,%ecx
sub    %rsi,%rcx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
and    $0xf,%eax
shl    $0x3,%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1128 <RandomFunc+0x28>
mov    -0x14(%rbp),%eax
imul   $0x6f82fff,%rax,%rax
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<RandomFunc>:
imul   $0x6f82fff,(%rdi),%eax
add    $0x5300fd68,%eax
mov    %eax,(%rsi)
ret

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

LLVM IR (-O2):
define void @RandomFunc(i32* nocapture %0, i32* nocapture writeonly %1) {
%3 = load i32, i32* %0
%4 = mul i32 %3, 116928511
%5 = add i32 %4, 1392573800
store i32 %5, i32* %1
ret void
}