The train, where it goes (programming puzzle, really) (solution posted)

Cult of the RNG, bad news: your deity is pseudo.

While the titles are similar, I have 2 train puzzles rolling now. http://www.steamgifts.com/discussion/u1kMH/ is the other one

Have you ever wanted to predict the future? Now here is the opportunity. Many computing environments use a linear congruential generator (Wikipedia) for creating a pseudo-random sequence of numbers. Now the thing is that this beast is predictable, back and forth.
Java is such an environment (as mentioned in the Wikipedia article, and also described in its own documentation, Random).
Here is an example code:

    public static void main(String[] args) {
        java.util.Random r=new java.util.Random(88572484529474l);
        System.out.println(r.nextInt());
        System.out.println(r.nextInt());
        byte b[]=new byte[5];
        r.nextBytes(b);
        System.out.println(new String(b));
    }

It will display 2 numbers and a five-letter character sequence (hint: there are online environments for Java on Tutorialspoint, repl.it and perhaps at other locations).

What the puzzle is here is that knowing the 2 numbers is enough for predicting what kind of character sequence (or anything else) the generator will produce next. The numbers are 9258196 and 1399737795.

Hint -2: while it is possible to do, there is no need for finding out a counterpart for 88572484529474
Hint -1: whatever you try, make sure to have the necessary 48-bit precision (typically 'long' and 'int64' types)
Hint 0: Java itself is not an absolute must...
Hint 1: ... but (re)implementing its random number generator will be necessary. The java.util.Random docs page contains the related expressions
Hint 2: and try ("brute force") some 65536 possibilities
Some hints from the other train may be useful here.

Solution

The documentation and the hints describe the task pretty well. The internal state variable seed is a 48-bit number, as the documentation says it at the very beginning and also repeatedly shows the & ((1L << 48) - 1) step used for ensuring it.
nextInt() simply calls next(32), and next(bits) does 2 things:

• updates the seed to (seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1), which is really a simple multiplication and addition, just the result is truncated to 48 bits at the end
• and returns (seed >>> (48 - bits)), so seed >>> 16 in our case. It is simply about dropping the lowest 16 bits of the number, and returning the rest as a 32-bit integer

Here comes the puzzle part: as we know the numbers returned now and in the next step, we know 32 bits of the current seed and the next seed. What we do not know is just a 16-bit number (the bits which are dropped), so something between 0 and 65535. And trying the simple calculation above 65536 times is not really a challenge to any computer manufactured in the last 30-40 years.
So here is the simple brute-forcing code:

    public static void main(String[] args) {
        long currknown=9258196L << 16; // known part of the current seed
        long nextknown=1399737795L << 16; // known part of the next seed
        long nextmask=0xFFFFFFFF0000L; // mask for testing the known part of the number only

        long mul = 0x5DEECE66DL; // from Java documentation
        long add = 0xBL; // from Java documentation

        for (int i = 0; i < 65536; i++)
        {
            long currtest=currknown+i;
            if( ((currtest*mul+add) & nextmask) == nextknown ) // do an actual generation step and test the result
            {
                java.util.Random r=new java.util.Random(currtest^mul); // Random xor-s the seed
                System.out.println(r.nextInt()); // should be 1399737795
                byte b[]=new byte[5];
                r.nextBytes(b);
                System.out.println(new String(b));
            }
        }
    }

And then there was a train starting from http://www.steamgifts.com/giveaway/z7wL2/
The example leads to a Thief Gold and a Papo & Yo.