void RandomFunc(unsigned int input[1], unsigned int output[1]) {
  unsigned int state[1];
  unsigned int local1;
  unsigned short copy11;
  unsigned short copy12;
  unsigned short copy13;
  char copy14;
  unsigned short copy16;
  unsigned short copy17;
  {
    state[0UL] = input[0UL] + 4284877637U;
    local1 = 0UL;
    while (local1 < 0U) {
      if (state[0UL] > local1) {
        if (state[0UL] > local1) {
          copy11 = *((unsigned short *)(&state[local1]) + 1);
          *((unsigned short *)(&state[local1]) + 1) =
              *((unsigned short *)(&state[local1]) + 0);
          *((unsigned short *)(&state[local1]) + 0) = copy11;
          copy11 = *((unsigned short *)(&state[local1]) + 0);
          *((unsigned short *)(&state[local1]) + 0) =
              *((unsigned short *)(&state[local1]) + 1);
          *((unsigned short *)(&state[local1]) + 1) = copy11;
          state[local1] += state[local1];
        } else {
          copy12 = *((unsigned short *)(&state[local1]) + 1);
          *((unsigned short *)(&state[local1]) + 1) =
              *((unsigned short *)(&state[local1]) + 0);
          *((unsigned short *)(&state[local1]) + 0) = copy12;
          copy13 = *((unsigned short *)(&state[local1]) + 1);
          *((unsigned short *)(&state[local1]) + 1) =
              *((unsigned short *)(&state[local1]) + 0);
          *((unsigned short *)(&state[local1]) + 0) = copy13;
        }
      } else if (state[0UL] <= local1) {
        copy14 = *((char *)(&state[0UL]) + 0);
        *((char *)(&state[0UL]) + 0) = *((char *)(&state[0UL]) + 2);
        *((char *)(&state[0UL]) + 2) = copy14;
      } else {
        copy16 = *((unsigned short *)(&state[local1]) + 1);
        *((unsigned short *)(&state[local1]) + 1) =
            *((unsigned short *)(&state[local1]) + 0);
        *((unsigned short *)(&state[local1]) + 0) = copy16;
        copy17 = *((unsigned short *)(&state[local1]) + 0);
        *((unsigned short *)(&state[local1]) + 0) =
            *((unsigned short *)(&state[local1]) + 1);
        *((unsigned short *)(&state[local1]) + 1) = copy17;
      }
      local1 += 2UL;
    }
    output[0UL] = (state[0UL] + 319257925UL) + 958663989U;
  }
}


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
add    $0xff660b45,%eax
mov    %eax,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
jae    1286 <RandomFunc+0x186>
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jbe    11ff <RandomFunc+0xff>
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jbe    11aa <RandomFunc+0xaa>
mov    -0x18(%rbp),%eax
mov    -0x12(%rbp,%rax,4),%ax
mov    %ax,-0x1a(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp,%rax,4),%cx
mov    -0x18(%rbp),%eax
mov    %cx,-0x12(%rbp,%rax,4)
mov    -0x1a(%rbp),%cx
mov    -0x18(%rbp),%eax
mov    %cx,-0x14(%rbp,%rax,4)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp,%rax,4),%ax
mov    %ax,-0x1a(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x12(%rbp,%rax,4),%cx
mov    -0x18(%rbp),%eax
mov    %cx,-0x14(%rbp,%rax,4)
mov    -0x1a(%rbp),%cx
mov    -0x18(%rbp),%eax
mov    %cx,-0x12(%rbp,%rax,4)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp,%rax,4),%ecx
mov    -0x18(%rbp),%eax
add    -0x14(%rbp,%rax,4),%ecx
mov    %ecx,-0x14(%rbp,%rax,4)
jmp    11fa <RandomFunc+0xfa>
mov    -0x18(%rbp),%eax
mov    -0x12(%rbp,%rax,4),%ax
mov    %ax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp,%rax,4),%cx
mov    -0x18(%rbp),%eax
mov    %cx,-0x12(%rbp,%rax,4)
mov    -0x1c(%rbp),%cx
mov    -0x18(%rbp),%eax
mov    %cx,-0x14(%rbp,%rax,4)
mov    -0x18(%rbp),%eax
mov    -0x12(%rbp,%rax,4),%ax
mov    %ax,-0x1e(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp,%rax,4),%cx
mov    -0x18(%rbp),%eax
mov    %cx,-0x12(%rbp,%rax,4)
mov    -0x1e(%rbp),%cx
mov    -0x18(%rbp),%eax
mov    %cx,-0x14(%rbp,%rax,4)
jmp    1277 <RandomFunc+0x177>
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
ja     1222 <RandomFunc+0x122>
mov    -0x14(%rbp),%al
mov    %al,-0x1f(%rbp)
mov    -0x12(%rbp),%al
mov    %al,-0x14(%rbp)
mov    -0x1f(%rbp),%al
mov    %al,-0x12(%rbp)
jmp    1272 <RandomFunc+0x172>
mov    -0x18(%rbp),%eax
mov    -0x12(%rbp,%rax,4),%ax
mov    %ax,-0x22(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp,%rax,4),%cx
mov    -0x18(%rbp),%eax
mov    %cx,-0x12(%rbp,%rax,4)
mov    -0x22(%rbp),%cx
mov    -0x18(%rbp),%eax
mov    %cx,-0x14(%rbp,%rax,4)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp,%rax,4),%ax
mov    %ax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x12(%rbp,%rax,4),%cx
mov    -0x18(%rbp),%eax
mov    %cx,-0x14(%rbp,%rax,4)
mov    -0x24(%rbp),%cx
mov    -0x18(%rbp),%eax
mov    %cx,-0x12(%rbp,%rax,4)
jmp    1277 <RandomFunc+0x177>
mov    -0x18(%rbp),%eax
add    $0x2,%rax
mov    %eax,-0x18(%rbp)
jmp    1121 <RandomFunc+0x21>
mov    -0x14(%rbp),%eax
add    $0x13077d45,%rax
add    $0x39240d35,%rax
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<RandomFunc>:
mov    $0x4b9195bf,%eax
add    (%rdi),%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 i16
%8 = alloca i16
%9 = alloca i16
%10 = alloca i8
%11 = alloca i16
%12 = alloca i16
store i32* %0, i32** %3
store i32* %1, i32** %4
%13 = load i32*, i32** %3
%14 = getelementptr inbounds i32, i32* %13, i64 0
%15 = load i32, i32* %14
%16 = add i32 %15, -10089659
%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 = %204, %2
%19 = load i32, i32* %6
%20 = icmp ult i32 %19, 0
br i1 %20, label %21, label %209
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 %135
26: ; preds = %21
%27 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 0
%28 = load i32, i32* %27
%29 = load i32, i32* %6
%30 = icmp ugt i32 %28, %29
br i1 %30, label %31, label %87
31: ; preds = %26
%32 = load i32, i32* %6
%33 = zext i32 %32 to i64
%34 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 %33
%35 = bitcast i32* %34 to i16*
%36 = getelementptr inbounds i16, i16* %35, i64 1
%37 = load i16, i16* %36
store i16 %37, i16* %7
%38 = load i32, i32* %6
%39 = zext i32 %38 to i64
%40 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 %39
%41 = bitcast i32* %40 to i16*
%42 = getelementptr inbounds i16, i16* %41, i64 0
%43 = load i16, i16* %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 = bitcast i32* %46 to i16*
%48 = getelementptr inbounds i16, i16* %47, i64 1
store i16 %43, i16* %48
%49 = load i16, i16* %7
%50 = load i32, i32* %6
%51 = zext i32 %50 to i64
%52 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 %51
%53 = bitcast i32* %52 to i16*
%54 = getelementptr inbounds i16, i16* %53, i64 0
store i16 %49, i16* %54
%55 = load i32, i32* %6
%56 = zext i32 %55 to i64
%57 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 %56
%58 = bitcast i32* %57 to i16*
%59 = getelementptr inbounds i16, i16* %58, i64 0
%60 = load i16, i16* %59
store i16 %60, i16* %7
%61 = load i32, i32* %6
%62 = zext i32 %61 to i64
%63 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 %62
%64 = bitcast i32* %63 to i16*
%65 = getelementptr inbounds i16, i16* %64, i64 1
%66 = load i16, i16* %65
%67 = load i32, i32* %6
%68 = zext i32 %67 to i64
%69 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 %68
%70 = bitcast i32* %69 to i16*
%71 = getelementptr inbounds i16, i16* %70, i64 0
store i16 %66, i16* %71
%72 = load i16, i16* %7
%73 = load i32, i32* %6
%74 = zext i32 %73 to i64
%75 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 %74
%76 = bitcast i32* %75 to i16*
%77 = getelementptr inbounds i16, i16* %76, i64 1
store i16 %72, i16* %77
%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 = load i32, i32* %80
%82 = load i32, i32* %6
%83 = zext i32 %82 to i64
%84 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 %83
%85 = load i32, i32* %84
%86 = add i32 %85, %81
store i32 %86, i32* %84
br label %134
87: ; preds = %26
%88 = load i32, i32* %6
%89 = zext i32 %88 to i64
%90 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 %89
%91 = bitcast i32* %90 to i16*
%92 = getelementptr inbounds i16, i16* %91, i64 1
%93 = load i16, i16* %92
store i16 %93, i16* %8
%94 = load i32, i32* %6
%95 = zext i32 %94 to i64
%96 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 %95
%97 = bitcast i32* %96 to i16*
%98 = getelementptr inbounds i16, i16* %97, i64 0
%99 = load i16, i16* %98
%100 = load i32, i32* %6
%101 = zext i32 %100 to i64
%102 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 %101
%103 = bitcast i32* %102 to i16*
%104 = getelementptr inbounds i16, i16* %103, i64 1
store i16 %99, i16* %104
%105 = load i16, i16* %8
%106 = load i32, i32* %6
%107 = zext i32 %106 to i64
%108 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 %107
%109 = bitcast i32* %108 to i16*
%110 = getelementptr inbounds i16, i16* %109, i64 0
store i16 %105, i16* %110
%111 = load i32, i32* %6
%112 = zext i32 %111 to i64
%113 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 %112
%114 = bitcast i32* %113 to i16*
%115 = getelementptr inbounds i16, i16* %114, i64 1
%116 = load i16, i16* %115
store i16 %116, i16* %9
%117 = load i32, i32* %6
%118 = zext i32 %117 to i64
%119 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 %118
%120 = bitcast i32* %119 to i16*
%121 = getelementptr inbounds i16, i16* %120, i64 0
%122 = load i16, i16* %121
%123 = load i32, i32* %6
%124 = zext i32 %123 to i64
%125 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 %124
%126 = bitcast i32* %125 to i16*
%127 = getelementptr inbounds i16, i16* %126, i64 1
store i16 %122, i16* %127
%128 = load i16, i16* %9
%129 = load i32, i32* %6
%130 = zext i32 %129 to i64
%131 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 %130
%132 = bitcast i32* %131 to i16*
%133 = getelementptr inbounds i16, i16* %132, i64 0
store i16 %128, i16* %133
br label %134
134: ; preds = %87, %31
br label %204
135: ; preds = %21
%136 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 0
%137 = load i32, i32* %136
%138 = load i32, i32* %6
%139 = icmp ule i32 %137, %138
br i1 %139, label %140, label %156
140: ; preds = %135
%141 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 0
%142 = bitcast i32* %141 to i8*
%143 = getelementptr inbounds i8, i8* %142, i64 0
%144 = load i8, i8* %143
store i8 %144, i8* %10
%145 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 0
%146 = bitcast i32* %145 to i8*
%147 = getelementptr inbounds i8, i8* %146, i64 2
%148 = load i8, i8* %147
%149 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 0
%150 = bitcast i32* %149 to i8*
%151 = getelementptr inbounds i8, i8* %150, i64 0
store i8 %148, i8* %151
%152 = load i8, i8* %10
%153 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 0
%154 = bitcast i32* %153 to i8*
%155 = getelementptr inbounds i8, i8* %154, i64 2
store i8 %152, i8* %155
br label %203
156: ; preds = %135
%157 = load i32, i32* %6
%158 = zext i32 %157 to i64
%159 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 %158
%160 = bitcast i32* %159 to i16*
%161 = getelementptr inbounds i16, i16* %160, i64 1
%162 = load i16, i16* %161
store i16 %162, i16* %11
%163 = load i32, i32* %6
%164 = zext i32 %163 to i64
%165 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 %164
%166 = bitcast i32* %165 to i16*
%167 = getelementptr inbounds i16, i16* %166, i64 0
%168 = load i16, i16* %167
%169 = load i32, i32* %6
%170 = zext i32 %169 to i64
%171 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 %170
%172 = bitcast i32* %171 to i16*
%173 = getelementptr inbounds i16, i16* %172, i64 1
store i16 %168, i16* %173
%174 = load i16, i16* %11
%175 = load i32, i32* %6
%176 = zext i32 %175 to i64
%177 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 %176
%178 = bitcast i32* %177 to i16*
%179 = getelementptr inbounds i16, i16* %178, i64 0
store i16 %174, i16* %179
%180 = load i32, i32* %6
%181 = zext i32 %180 to i64
%182 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 %181
%183 = bitcast i32* %182 to i16*
%184 = getelementptr inbounds i16, i16* %183, i64 0
%185 = load i16, i16* %184
store i16 %185, i16* %12
%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 = bitcast i32* %188 to i16*
%190 = getelementptr inbounds i16, i16* %189, i64 1
%191 = load i16, i16* %190
%192 = load i32, i32* %6
%193 = zext i32 %192 to i64
%194 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 %193
%195 = bitcast i32* %194 to i16*
%196 = getelementptr inbounds i16, i16* %195, i64 0
store i16 %191, i16* %196
%197 = load i16, i16* %12
%198 = load i32, i32* %6
%199 = zext i32 %198 to i64
%200 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 %199
%201 = bitcast i32* %200 to i16*
%202 = getelementptr inbounds i16, i16* %201, i64 1
store i16 %197, i16* %202
br label %203
203: ; preds = %156, %140
br label %204
204: ; preds = %203, %134
%205 = load i32, i32* %6
%206 = zext i32 %205 to i64
%207 = add i64 %206, 2
%208 = trunc i64 %207 to i32
store i32 %208, i32* %6
br label %18
209: ; preds = %18
%210 = getelementptr inbounds [1 x i32], [1 x i32]* %5, i64 0, i64 0
%211 = load i32, i32* %210
%212 = zext i32 %211 to i64
%213 = add i64 %212, 319257925
%214 = add i64 %213, 958663989
%215 = trunc i64 %214 to i32
%216 = load i32*, i32** %4
%217 = getelementptr inbounds i32, i32* %216, i64 0
store i32 %215, i32* %217
ret void
}

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