Linear congruential generator with non constant increment Consider this random generator function.

A simplified version is provided below (this is C++, mind that "seed" is a reference):

uint32_t Rand(uint64_t&amp; seed)
{
    seed = 1683268614LL * (seed &amp; 0xffffffff) + (seed &gt;&gt; 32);
    return seed &amp; 0xffffffff;
}


For those unfamiliar with C++: &amp; denotes bit-wise AND, LL as a suffix denotes signed long long (signed 64-bit usually), &gt;&gt; denotes plain bit-shift, the uint64_t&amp; in the header denotes that the input is a reference to an unsigned 64-bit integer, that is, updates also apply outside the function.

This is almost a linear congruential generator (LCG), the only difference is that the increment is not a constant, but a part of the seed itself.

My question is on the security of this algorithm, since LCGs are very easy to break.

Does using a non constant increment improve or decrease security? How could this be cracked other than by bruteforceing it?
The state can be trivially recovered from two consecutive output (and hence all further outputs can be predicted).

For the first output, the system updates the seed to $\text{seed}_1$, and then outputs the lower 32 bits of $\text{seed_1}$, which we'll call $\text{output}_1$

For the second output, the system first computes:


  $\text{seed}_2$ = 1683268614LL * $\text{output}_1$ + ($\text{seed}_1$ >> 32)


Then, the system outputs $\text{output}_2$, the lower 32 bits of $\text{seed}_2$.

Hence, if the attacker computes:


  $\text{output}_2$ - 1683268614LL * $\text{output}_1$ $\bmod{2^{32}}$


That gives him the upper 32 bits of $\text{seed}_1$.  With the entire value of $\text{seed}_1$, the rest of the sequence can be predicted.

With a standard LCG, you can also reconstruct internal states, but not this easily...