The train, where it comes from (programming+maths puzzle) (over, solution posted)

Yesterday's train is going somewhere, but there also has to be a place where trains come from.
Here is a similar piece of code for helping the description, again Java, again built around java.util.Random

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

It displays five characters and two numbers, which is similar to what has happened with the other train, but the order has changed. The puzzle part also says something similar: knowing the 2 numbers is enough to find out the previously generated characters (or anything else). The numbers are 1812438423 and 1443536622.
In contrast to the previous puzzle, this one is about finding a counterpart for 42091840247402 (strictly said it is enough to find the number which follows it), and it involves discrete maths. 281474976710656 is (too) much more than 65536, by the way.

Hint 0: the links from the previous train still might have some use here
Hint 1a: solving the other train is part of solving this one
Hint 1b: the strange equation "(a*x) % m=b" is called a linear congruence, and it is solvable. Its normal notation is ax≡b (mod m)
Hint 2: I was not exactly interested in coding a congruence solver from scratch. But searching for online linear congruence solver with Google delivers results
Hint 2a: JavaScript solvers use 32-bit precision, however they are very easy to port into other programming languages
Hint 2b: The WolframAlpha widget does not show its source code, but it seems to have the necessary precision (tried shortly)

Hint pack all+1

• 1L << 48 is 2^48. Binary and-ing with ((1L << 48) - 1) is a modulo operation with 2^48. Example with smaller numbers: 2^4=16, something&15=something%16
• do not forget subtracting the 11 (0xBL) from the "target" seed
• if you want to use the example code, note that the constructor Random(x) immediately xor-s the seed, so you will need to initialize with new java.util.Random(calculatedseed^0x5DEECE66DL) in order to set the internal state to calculatedseed
• the WolframAlpha widget

Megahint / example calculation
The example displays 1480905861 (or 5844D485 in hexadecimal) as the second number. Let us assume that we know the entire seed for this moment, 97052646561403 (5844D485D67B in hexadecimal).
Take a small note of 0x5DEECE66DL being 25214903917 in decimal, and 0xBL being 11 as already mentioned a bit above. Our modulo is 2^48, which is 281474976710656.
Then the congruence to solve is 25214903917x≡97052646561403-11 (mod 281474976710656)
97052646561403-11 happens to be 97052646561392, and then the entire thing can be typed into the WolframAlpha widget. 25214903917x to the first line (the x is necessary), 281474976710656 to the second, and 97052646561392 to the third.
After a few moments the widget will produce some x=16(17592186044416m+4005227429539) result, where 17592186044416*16 is simply 281474976710656, the modulus (2^48), and 4005227429539*16 is 64083638872624, the number what we need. It is 3A48A287EA30 in hexadecimal, and indeed the previous number was 977838727 (3A48A287 in hexadecimal).
Or one can also check that 3A48A287EA30*5DEECE66D+B=19055844D485D67B

Solution

The internal seed can be found exactly as for the other train, and then congruences described in Megahint can be solved 2-3 times.

    public static void main(String[] args) {
        long currknown=1812438423L << 16; // known part of the current seed
        long nextknown=1443536622L << 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
                System.out.println(currtest);
        }
    }

The result will be 118779964526270.
Solving the congruence once results in 228952716318111 (d03b3553959f).
Solving it for the second time results in 98150579699556 (5944766fff64).
Then one can either grab the values from these seeds, or solve the congruence for a third time, and run the original code with 277356786112797l^0x5DEECE66DL passed to new java.util.Random(...).
The solution leads to http://www.steamgifts.com/giveaway/ovDYS/, a train of 4 giveaways.
The example leads to a 140.