Cracking this algorithm.

Alright, a friend of mine wrote a simple encryption scheme...much like the one i posted not too long ago. I've been attempting to crack it, and don't think I completely understand how to do so. I'll post his src, and my crack. As a side note, I've been challenged to crack it. I have one month, and I cannot brute force.

Encryption Scheme:

Code:

---

#include <iostream.h>  //for cin and cout
#include <string.h>  //for strcpy()
#include <fstream.h>  //for ifstream and ofstream
#include <stdlib.h>  //for system() and srand() and rand()
#include <sys/stat.h>  //for stat() and stat structure

int main(void)
{
    char file[1024];  //to hold file path
    cout << "File to Encrypt: " << flush;
    cin.getline(file, 1023); //input file path from user
    struct stat result; //this will hold the the file's size
    stat(file, &result); //get the file's size from it's path, and place it in the result structure
    unsigned long flen = result.st_size;  //set our local variable to the size of the file
    cout << flen << " Bytes.  Enter 1 if correct: " << flush;
    unsigned long key, choice;
    cin >> choice;
    if (choice != 1)  //verify that data is correct before continueing
    {
        return 0;
    }
    cout << "Key: " << flush;
    cin >> key;  //input the encryption key
    cout << "Enter 1 if you are encrypting, 0 if decrypting: " << flush;
    cin >> choice;
    bool e_or_d;
    switch (choice)  //set encrypt or decrypt
    {
        case 0: e_or_d = false;
                break;
        case 1: e_or_d = true;
                break;
        default: return 0;
    }   
    system("cls");  //clear the screen
    cout << "Verify" << endl
        << "------" << endl
        << "File: " << file << endl
        << "Size: " << flen << endl
        << "Key : " << key << endl;
    if (e_or_d)
    {
        cout << "Encrypting" << endl;
    }
    else
    {
        cout << "Decrypting" << endl;
    }
    cout << endl
        << "Enter 1 if this is correct: " << flush;
    cin >> choice;
    if (choice == 0)  //verify that all data is correct again
    {
        return 0;
    }
    system("cls");
    cout << "Encrypting, standbye..." << flush;
    ifstream in(file, ios::binary);  //open our file
    strcpy(&file[strlen(file)], ".eng"); //this will turn something like C:\hello.txt into C:\hello.txt.eng
    ofstream out(file, ios::binary | ios::trunc);  //open our output file
    char buf;  //our buffer
    unsigned long x;  //counter variable
    srand(key); //randomize by the key
    for (x = 0; x < flen; x++) //loop until we've reached all bytes
    {
        in.get(buf);  //get 1 byte from file
        if (e_or_d)
            buf += (rand() % 713) - 331;  //encrypt it using this function.  To decrypt it's -=
        else
            buf -= (rand() % 713) - 331;  //decrypt it
        out.put(buf);  //output the new byte
    }
    out.flush();  //make sure everything has been written to the disk
    in.close();  //close file
    out.close();  //close file
    cout << "done" << endl << endl
        << "Saved as " << file << endl << endl
        << "Goodbye\n" << flush;  //closing message
    system("pause");  //pause
    return 0; //end program
}

---

He encrypted a file called hellokittyenc.txt. I am attempting to crack it, and output to hellokitty.txt. I assumed that all of the letters in his file (it is plaintext) would all have the same number added to it, and would be one of the 256 characters in the ASCII table. I don't understand why my crack doesn't work. The only things that come to mind are problems with character translations opening that TXT in binary mode...but he has successfully encrypted/decrypted it with the key. Any suggestions?

NOTE: While running the program, I pause every 20 or so, and view the output to see if it's turned into plain english, if not I resume for another 20 or so. I have to stop every once in a while, because the cmd screen will not scroll all the way back up to view the first like 200 attempts.

Code:

---

#include <iostream.h>
#include <fstream.h>



char tmp;
int x = 0;

main()
{
    for(x = 0; x <= 255; x++)
    {
        ofstream out("hellokitty.txt", ios::binary | ios::trunc);
        ifstream in("hellokittyenc.txt", ios::binary);
       
        while(!in.eof())
        {
                in.get(tmp);
                tmp -= x;
                out.put(tmp);
        }
       
        out.flush();
        in.close();
        out.close();
        cout << "Code: " << x << endl;
        system("type hellokitty.txt");
        cout << endl;
        cout << "Attempted Decryption Complete\n";
        cout << endl;
    }
   
    system("pause");
       
}

---

The reason the single character thing that was mentioned in the last couple of crypto-related posts is because the number was never changed for every byte. The algorithms that used that did not change the number, leaving that possiblity open.

The code here calls the random function again to encrypt. So that won't work.

Code:

---

in.get(buf);  //get 1 byte from file
        if (e_or_d)
            buf += (rand() % 713) - 331;  //encrypt it using this function.  To decrypt it's -=

---

I bolded what I am stressing. rand() and where it is located.


What happens is that for each byte, a new random number is calculated. But since the rand() function is 100% predictable, it can be used for reliable encryption and decryption. This is where we can begin attacking the code...


We know the key is used to seed the random number generator. We also know for a fact that rand() produces a signed 16bit number, but only returns the positive range. This is essentially half of the 16bits, or 15bits. This raises the problem called collisions. Collisions are things where more than one key (the key the user types in for this program) can produce the same output as another key. Provided I am right with everything, we know we can "crack" the file within (2^16)/2 -- (really 2^15) guesses, or 32768 guesses.

It is in a range where brute forcing is easy. You will need to brute-force to figure out the key, or one of its collisions. If an algorithm can't withstand some brute-force attacks after some analysis, it isn't very good. Basically, all we do is analyze it to see if we can make brute-forcing a painless task, and here it is. Due to limits of implementation, we can brute-force it in 2^15 tries. This is a sorry number of tries. Personally, I don't mind calculating 2^15 combinations, but when things get to like 2^32 combinations, I draw the line and won't bother working on it because it would begin to take way too long from there on.

----------------------------------------------------------------

For your code, you need to implement what he did with the random number generator into your code. Basically, have a loop that seeds the random number generator numbers from 1 to 32768 or so, and then it does the decryption stuff. The decryption stuff would call rand() again and again, changing the seed value while doing so. But when it gets to the end, and it doesn't look right, it will seed rand() with a new number. It will change slowly because of what rand() does, so sifting through the output is easier because once it begins to look recongnizable, within a few tries of that it will become even clearer, etc. Anyways, give that a shot.

Tim_axe made a really good point there... just as a helper in future decrypting challenges, you should place all the output in a file [through the command prompt]. Sure you need to check it, especially if it's increasing in size too much. Make sure the cracking/brute-forcing program outputs the seeds as well so you know where you left off, and then go to the code and change it.

I know it doesn't sound elegant. You could make the program take the starting seed in from the command prompt, or dump it/reload it from a file. But the important part is that you're trying to break something, and however you manage to get the job done is up to you :)

well the agreement was that i can't brute force it. what i assumed was brute-force on this algorithm was starting x at 0, and x++ until 32768. and each time x++, i srand(x), and attempt to decrypt it. is there any other way? frequency analysis wouldn't work because of te character translations in opening that TXT in binary mode.

A_T

Well, he encrypted a text file..with a rude message to me. I know the first word is "Hello". So what I did is start with x=-32767 (the lowest INT goes) and subtract that from the first byte in the file. If it didn't yield an 'H', I incremented x by one, not exceeding the maximum of INT (32768). The 'H' is decrypted by the number -32571, and again on every increment of 256 following that.

So on the next time around, I subtracted -32571 from the first byte, and ran the same test on the second byte with x, until I found the string 'Hello'. I don't know what comes after 'Hello', so I don't know where to go from here. I suppose I could brute force it by srand(x), but srand() takes an unsigned long int, which is 0 - 4,294,967,295...so that's alot of possibilities seeing as I'd have to seed rand() that many times and test the file. If I'm stumped, I'll do a brute force overnight to atleast get the code, then using that code, I could figure out some sort of other pattern, possibly. I don't want to encrypt my own file with a password, and brute force that, knowing the key...because I know his TXT doesn't have any type of problems (i.e. character translations).

I can see why my original crack did not work either. I was subtracting x (a constant within that loop) from every byte. Which means if x=109, then 109 was subtracted from every byte. But he adds a random number to one byte of the file, then another random number to the next byte, and so on and so forth.

Here is the crack that I've been using for the first 5 bytes. I changed the output file for the results everytime (i.e. results_1.txt to results_2.txt). Also, lower in the code, where 'i' is initialized within a for loop. If I'm trying to find 'Hel', then the for loop becomes:

Code:

---

while(!check.eof())
        {
            for(int i = 0; i < 3; i++)
            {
                check.get(buf[i]);
            }
                if(!strcmp(buf, "Hel"))
                {

---

Here's the code, in it's entirety. I commented out all the tmp += crap at the start, because those will only work for those first 5 bytes that I already know.

Code:

---

#include <iostream.h>
#include <fstream.h>



char tmp;
char buf[6];
int x = 0;
ofstream result("results_5.txt", ios::trunc);
main()
{
    //for(x = -331; x <= 682; x++)
    //for(x = -32768; x <= 32767; x++)
    for(x = 0; x < 32767; x++)
    {
        ofstream out("hellokitty.txt", ios::binary | ios::trunc);
        ifstream in("hellokittyenc.txt", ios::binary);
        while(!in.eof())
        {
            /*
            in.get(tmp);
            tmp -= -32571;
            out.put(tmp);

            in.get(tmp);
            tmp -= -32672;
            out.put(tmp);
           
            in.get(tmp);
            tmp -= 246;
            out.put(tmp);
           
            in.get(tmp);
            tmp -= 212;
            out.put(tmp);
            */
           
            in.get(tmp);
            tmp -= x;
            out.put(tmp);
           
        }
       
        out.flush();
        in.close();
        out.close();
        result << "Code: " << x << endl;
        cout << "Code: " << x << endl;
        //FINDS 'H' ON CODE: -32571 AND ALL INCREMENTS OF 256 FOLLOWING
        //FINDS 'He' ON CODE: -32672 AND ALL INCREMENTS OF 256 FOLLOWING
        //FINDS 'Hel' ON CODE: 246
        //FINDS 'Hell' ON CODE: 212
        //FINDS 'Hello' ON CODE: 122
        ifstream check("hellokitty.txt", ios::binary);
        while(!check.eof())
        {
            for(int i = 0; i < 5; i++)
            {
                check.get(buf[i]);
            }
                if(!strcmp(buf, "Hello"))
                {
                    result << "Possible Decryption!\n";
                    cout << "Possible Decryption!\n";
                    check.close();
                    system("type hellokitty.txt");
                    result << "[see hellokitty.txt]";
                    result << "\nIf this is a match, close bet_crack now.\n";
                    cout << "\nIf this is a match, close bet_crack now.\n";
                    system("pause");
                    break;
                }

                else
                {
                    break;
                }
            }

        result << "Attempted Decryption Complete\n\n";
        cout << "Attempted Decryption Complete\n\n";

    }
    result.close();
    system("pause");
       
}

---

Still looking for suggestions.

A_T

What you should try to do is to find all of the seeds (srand()) that produce a random-number (rand()) that could be used to make the right values (-32571, etc) to successfully decypt the first character. I *think* you only need to worry about numbers between 0 and 32768 when seeding. Then, if the first seed works, try for the second one (call rand() again) and see if that gets what you know is the 2nd character. If it doesn't, re-seed incrementally (0 to 32768) and try again until it happens.

So in this isolated sceneario, your goal is to find the right key. After you have the key, you can easily get the message. Spliting those two things up might be important.

Basically (I think you've already described the process a bit in your code):
Load encrypted file
Seed the random-number generator from 0 to 32768 (loop)
->Get a random number, use his formula, and check if the output is "H"
-> ->If the output is "H", get another random-number, and check if the output is "e"
-> -> ->You probably have the right initial seed if you get "He" - you've cracked the key for that file
-> ->If the output is not "H", then increment the seed since this one isn't working...
-> (End Loop)
Display the initial seed
Modify his program to use that initial seed to decrypt the whole file -- since the first one just figures out the key for you based on known-plaintext type attacks.


I don't have time to code anything, but I think the pseudo-code should get you somewhere. What I described is limited to only encrypted files that you know the first couple of (decrypted) characters for with this paticular algorithm/formula. If your friend won't tell you what the first character is for some file, you'll have to resort to more manual ways of checking/brute-forcing...

Good luck.

Thanks Tim_Axe. The problem is, srand() returns an unsigned long int. So there are over 4 billion seeds to test out. Then he +='s the byte with rand(), modulous, and subtraction, which actually drops the maximum 'hash' to -331 -> 682. 'Hash' meaning the number that the byte is actually encrypted with. So I'd have to find which srand() that produces these keys. But I'm looking for a more universal way. As if I've intercepted a file and have no clue what the first characters are. If you could explain that manual way..while keeping it as a non-bruteforce attack, that would be of great help. If you don't have time to code, pseudo-code is also well appreciated. Right now, I'm working on a brute force...having a few troubles. But I figure if i can get one key, and the resulting encryption, it would be of some help.

Although srand() will take an unsigned long int, it has issues with collisions when you call rand(). Check the following code out:

Code:

---

#include <stdlib.h>

int main ( void )
{
    long key1 = 0, key2 = 0;
   
    srand(key1);
   
    while (printf("When seed is %i, output is %i\n", key1, rand()))
    {
        srand(key1++);
    }
   
    getch();
    return 0;
}

---

When you run it, you will eventually find that there are collisions. Here is an example after running the program for approximately 4 seconds on my computer, piping the input into a file:

Quote:

---

D:\My Projects\AntiOnline\261497>main > output.txt
^C
D:\My Projects\AntiOnline\261497>egrep ", output is 38$" output.txt
When seed is 0, output is 38
When seed is 1, output is 38
When seed is 30104, output is 38
When seed is 60207, output is 38
When seed is 80276, output is 38
When seed is 110379, output is 38
When seed is 140482, output is 38
When seed is 170585, output is 38
When seed is 220757, output is 38
When seed is 250860, output is 38
When seed is 280963, output is 38
When seed is 311066, output is 38
When seed is 331135, output is 38
When seed is 361238, output is 38
When seed is 391341, output is 38

D:\My Projects\AntiOnline\261497>egrep ", output is 3$" output.txt
When seed is 20059, output is 3
When seed is 50162, output is 3
When seed is 80265, output is 3
When seed is 100334, output is 3
When seed is 130437, output is 3
When seed is 160540, output is 3
When seed is 190643, output is 3
When seed is 240815, output is 3
When seed is 270918, output is 3
When seed is 301021, output is 3
When seed is 331124, output is 3
When seed is 351193, output is 3
When seed is 381296, output is 3

D:\My Projects\AntiOnline\261497>

---

This means you don't have to do 4 billion combinations to find the collisions you're looking for. You could do about 32768 tries to find a collision, although as a safety-overlap you could go to like 40000 tries or more, but it isn't necessary.


One brick at a time ;)



Edit: Although to be honest, I don't know if srand() has any effect on later seeds. IE, even if seeds 30104 and 391341 produced an initial random number of 38, would the next random number be different than something that was seeded originally with 38, or different from each other? I think it will be the same; however I have not acturally tested this.

Edit2: The code is code from another post on AO. I haven't cleaned it up, so some variables remain unused.

The problem with this "algorithm" is that it is ENTIRELY dependent on your C library's implementation of rand() and srand().

This means that different C libraries, will almost certainly result in files which cannot be decrypted at all. rand() should not be relied on performing the same on every C library.

HOWEVER, yes most of the above points do stand. There is one thing I'd like to mention though:

Tim_axe said that you could find collisions in srand() by calling it, and comparing the first value you get from rand(). This is not, however, true, because rand() produces a sequence of numbers, not just one. You can't just compare the first value, you need to check the entire (infinite) sequence. However, because we know that the period of rand() must be finite, it's sufficient to check the entire period. In practice, I'd suggest it's acceptable to just check the first 8 or so values - which are extremely unlikely to be the same if the sequence is different.

So there might be a lot less collisions than Tim_axe suggests.

Additionally the number of collisions could be as low as 0 (in the 32-bit keyspace).

On 64-bit machines this algorithm is likely to be extremely different. rand() will still only return 1-32k, but the random state may be 64-bit instead, so the period larger. The keysize could be bigger.

Slarty

I'm running a brute-force now. Well, two to be exact. I don't know how to thread, so I just have two instances of the program running. One started with x = 0, srand(x), x++. The other started at x = 4294967295, srand(x), x--. At least this way, it runs twice as fast. Time to set priority to high and let you guys know the outcome. Now, this is the brute-force, which will now satisfy the deal with my friend. I'm still clueless on how to go about cracking this without trying every combonation. Thanks again.

A_T

Cracked Beeotch! Okay, I got the password, and decrypted it with his prog. He used 72417 as the seed. Is there anyway that this information would help me with gaining some sort of patterns with this? I'm aware, as slarty mentioned, that this is somewhat specific to my implementation of rand() (it's GNU, for the record). But since he uses the same compiler I do (Dev-C++), then it shouldn't be a problem. I don't mean to be a bother, but I've always enjoyed cryptography, even in it's simplest forms...so I need to learn a bit more about it. This is the furthest I've made it in the field thus far, so what I do from now on is relatively new. The most of done before is using switch() statements, turning our alphabet in to Al Bhed's alphabet. (Al Bhed is a language in one of those Final Fantasy things), but they just had a rearranged alphabet.

A_T

Good job on it!


slarty is right and my guess was wrong -- even if the first number is the same with some seeds, the next couple of numbers will be different...

Code:

---

#include <stdlib.h>

int main ( void )
{
    long key1 = 0;
   
    srand(key1);
   
    while (printf("When seed is -- %6i, output is -- %6i --", key1, rand()))
    {
        printf(" %6i --", rand());
        printf(" %6i --", rand());
        printf(" %6i --", rand());
        printf(" %6i\n", rand());
        srand(key1++);
    }
   
    getch();
    return 0;
}

---

Run for about 15 seconds...

Quote:

---

D:\My Projects\AntiOnline\261497>main > output2.txt
^C
D:\My Projects\AntiOnline\261497>egrep "\-\-[ ][ ][ ][ ][ ]50" output2.txt
When seed is -- 50, output is -- 198 -- 10103 -- 11846 -- 1891 -- 22749
When seed is -- 1668, output is -- 5482 -- 1217 -- 14700 -- 7949 -- 50
When seed is -- 10039, output is -- 50 -- 27966 -- 2527 -- 17052 -- 32441
When seed is -- 10826, output is -- 2620 -- 50 -- 4158 -- 14976 -- 23547
When seed is -- 11686, output is -- 5428 -- 3104 -- 31921 -- 50 -- 13953
When seed is -- 18970, output is -- 29215 -- 11744 -- 50 -- 1195 -- 8289
When seed is -- 36820, output is -- 21969 -- 14158 -- 10103 -- 8401 -- 50
When seed is -- 40142, output is -- 50 -- 3244 -- 12033 -- 25577 -- 22506
When seed is -- 51004, output is -- 2752 -- 50 -- 567 -- 10955 -- 25622
When seed is -- 53306, output is -- 10270 -- 3042 -- 50 -- 26783 -- 12972
When seed is -- 71972, output is -- 5689 -- 27099 -- 5506 -- 8854 -- 50
When seed is -- 87321, output is -- 23044 -- 17509 -- 50 -- 28528 -- 16245
When seed is -- 90314, output is -- 50 -- 9313 -- 22907 -- 25962 -- 20310
When seed is -- 91182, output is -- 2885 -- 50 -- 29744 -- 6934 -- 27697
When seed is -- 107124, output is -- 22177 -- 7272 -- 909 -- 9306 -- 50
When seed is -- 120417, output is -- 50 -- 17359 -- 32413 -- 1719 -- 10376
When seed is -- 121336, output is -- 3051 -- 31976 -- 50 -- 30273 -- 19518
When seed is -- 122849, output is -- 7992 -- 8619 -- 27710 -- 50 -- 27901
When seed is -- 131360, output is -- 3017 -- 50 -- 26153 -- 2914 -- 29772
When seed is -- 132927, output is -- 8135 -- 50 -- 2670 -- 26926 -- 5318
When seed is -- 142247, output is -- 5802 -- 3422 -- 2540 -- 50 -- 28607
When seed is -- 142276, output is -- 5896 -- 20214 -- 29081 -- 9758 -- 50
When seed is -- 150520, output is -- 50 -- 25404 -- 9150 -- 10245 -- 441
When seed is -- 155672, output is -- 16874 -- 23274 -- 50 -- 23093 -- 24201
When seed is -- 161645, output is -- 3611 -- 30993 -- 10138 -- 50 -- 29314
When seed is -- 171538, output is -- 3150 -- 50 -- 22562 -- 31661 -- 31847
When seed is -- 173105, output is -- 8267 -- 50 -- 31847 -- 22906 -- 7393
When seed is -- 177428, output is -- 22384 -- 387 -- 24484 -- 10211 -- 50
When seed is -- 180623, output is -- 50 -- 682 -- 18656 -- 18770 -- 23275
When seed is -- 181043, output is -- 1421 -- 25796 -- 17736 -- 50 -- 30020
When seed is -- 189687, output is -- 29649 -- 4973 -- 50 -- 24838 -- 27474
When seed is -- 200441, output is -- 31999 -- 20599 -- 25334 -- 50 -- 30727
When seed is -- 200692, output is -- 50 -- 31473 -- 20025 -- 10630 -- 31013
When seed is -- 212580, output is -- 6104 -- 13328 -- 19887 -- 10663 -- 50
When seed is -- 213283, output is -- 8399 -- 50 -- 28256 -- 18885 -- 9468
When seed is -- 219839, output is -- 29809 -- 15402 -- 164 -- 50 -- 31434
When seed is -- 223702, output is -- 9655 -- 19440 -- 50 -- 26583 -- 30746
When seed is -- 230795, output is -- 50 -- 6751 -- 29530 -- 19155 -- 21079
When seed is -- 239237, output is -- 27618 -- 10206 -- 7762 -- 50 -- 32140
When seed is -- 247732, output is -- 22591 -- 26270 -- 15291 -- 11116 -- 50
When seed is -- 253461, output is -- 8532 -- 50 -- 24665 -- 14864 -- 11543
When seed is -- 258038, output is -- 23478 -- 10738 -- 50 -- 19403 -- 2662
When seed is -- 260898, output is -- 50 -- 14796 -- 6268 -- 27680 -- 11145
When seed is -- 282884, output is -- 6311 -- 6443 -- 10694 -- 11568 -- 50
When seed is -- 291001, output is -- 50 -- 22842 -- 15774 -- 3438 -- 1210
When seed is -- 292053, output is -- 3485 -- 25205 -- 50 -- 21148 -- 5934
When seed is -- 293639, output is -- 8664 -- 50 -- 21074 -- 10843 -- 13617
When seed is -- 318036, output is -- 22799 -- 19384 -- 6097 -- 12021 -- 50
When seed is -- 326068, output is -- 16260 -- 6905 -- 50 -- 22893 -- 9207
When seed is -- 330861, output is -- 31912 -- 12720 -- 240 -- 14995 -- 50
When seed is -- 333817, output is -- 8797 -- 50 -- 17483 -- 6823 -- 15692
When seed is -- 335384, output is -- 13914 -- 50 -- 26768 -- 30835 -- 24007
When seed is -- 341173, output is -- 50 -- 28911 -- 26648 -- 3823 -- 31782
When seed is -- 350400, output is -- 30182 -- 15721 -- 3550 -- 50 -- 13320
When seed is -- 360404, output is -- 30083 -- 30970 -- 50 -- 15713 -- 13890
When seed is -- 366013, output is -- 15631 -- 25662 -- 28411 -- 15448 -- 50
When seed is -- 369798, output is -- 27992 -- 10524 -- 11148 -- 50 -- 14027
When seed is -- 371276, output is -- 50 -- 4189 -- 3386 -- 12348 -- 21848
When seed is -- 375562, output is -- 14046 -- 50 -- 23177 -- 26815 -- 26081
When seed is -- 389196, output is -- 25801 -- 5327 -- 18746 -- 50 -- 14733
When seed is -- 394419, output is -- 10089 -- 12670 -- 50 -- 17458 -- 17163
When seed is -- 401165, output is -- 32119 -- 5835 -- 23815 -- 15900 -- 50
When seed is -- 401379, output is -- 50 -- 12234 -- 12891 -- 20873 -- 11913
When seed is -- 408594, output is -- 23611 -- 130 -- 26344 -- 50 -- 15440
When seed is -- 415740, output is -- 14179 -- 50 -- 19586 -- 22794 -- 28156
When seed is -- 427992, output is -- 21421 -- 27701 -- 1174 -- 50 -- 16146
When seed is -- 428434, output is -- 22864 -- 27137 -- 50 -- 19202 -- 20436
When seed is -- 431482, output is -- 50 -- 20279 -- 22397 -- 29399 -- 1979
When seed is -- 436317, output is -- 15839 -- 18776 -- 19218 -- 16353 -- 50
When seed is -- 447390, output is -- 19230 -- 22504 -- 8773 -- 50 -- 16853
When seed is -- 451551, output is -- 50 -- 18303 -- 23766 -- 21258 -- 9717
When seed is -- 455918, output is -- 14311 -- 50 -- 15995 -- 18773 -- 30231
When seed is -- 462770, output is -- 3919 -- 18435 -- 50 -- 12023 -- 25119
When seed is -- 471469, output is -- 32326 -- 31718 -- 14621 -- 16805 -- 50
When seed is -- 481654, output is -- 50 -- 26349 -- 504 -- 29783 -- 32551
When seed is -- 496096, output is -- 14444 -- 50 -- 12404 -- 14752 -- 32306
When seed is -- 496785, output is -- 16694 -- 134 -- 50 -- 13768 -- 28392
When seed is -- 506621, output is -- 16046 -- 11891 -- 10024 -- 17258 -- 50
When seed is -- 511757, output is -- 50 -- 1626 -- 10009 -- 5541 -- 22616
When seed is -- 530800, output is -- 29468 -- 14601 -- 50 -- 15512 -- 31665
When seed is -- 536274, output is -- 14576 -- 50 -- 8813 -- 10732 -- 1613
When seed is -- 537841, output is -- 19693 -- 50 -- 18098 -- 1976 -- 9927
When seed is -- 541773, output is -- 32534 -- 24832 -- 5428 -- 17710 -- 50
When seed is -- 541860, output is -- 50 -- 9672 -- 19515 -- 14066 -- 12682
When seed is -- 558553, output is -- 21794 -- 28020 -- 4561 -- 50 -- 30801
When seed is -- 565136, output is -- 10523 -- 5899 -- 50 -- 8333 -- 3580
When seed is -- 576925, output is -- 16253 -- 5006 -- 831 -- 18162 -- 50
When seed is -- 577951, output is -- 19604 -- 22823 -- 12159 -- 50 -- 31507
When seed is -- 578019, output is -- 19826 -- 50 -- 14507 -- 30724 -- 12002
When seed is -- 592032, output is -- 50 -- 15741 -- 30389 -- 14451 -- 10486
When seed is -- 597349, output is -- 17413 -- 17626 -- 19757 -- 50 -- 32214
When seed is -- 599151, output is -- 23298 -- 20366 -- 50 -- 10078 -- 6853
When seed is -- 612077, output is -- 32741 -- 17947 -- 29002 -- 18615 -- 50
When seed is -- 616747, output is -- 15223 -- 12429 -- 27355 -- 50 -- 152
When seed is -- 618197, output is -- 19958 -- 50 -- 10916 -- 26703 -- 14077
When seed is -- 622135, output is -- 50 -- 23786 -- 7127 -- 22976 -- 551
When seed is -- 633166, output is -- 3305 -- 2065 -- 50 -- 11822 -- 10126
When seed is -- 636145, output is -- 13033 -- 7232 -- 2185 -- 50 -- 859
When seed is -- 647229, output is -- 16460 -- 30888 -- 24406 -- 19067 -- 50
When seed is -- 652238, output is -- 50 -- 31832 -- 16632 -- 31502 -- 23385
When seed is -- 655543, output is -- 10842 -- 2035 -- 9783 -- 50 -- 1565
When seed is -- 658375, output is -- 20091 -- 50 -- 7325 -- 22682 -- 16152
When seed is -- 667502, output is -- 17128 -- 26131 -- 50 -- 4643 -- 14809
When seed is -- 674941, output is -- 8652 -- 29606 -- 17381 -- 50 -- 2272
When seed is -- 682381, output is -- 180 -- 11062 -- 19809 -- 19520 -- 50
When seed is -- 695206, output is -- 9293 -- 4398 -- 13952 -- 22494 -- 50
When seed is -- 698553, output is -- 20223 -- 50 -- 3734 -- 18662 -- 18227
When seed is -- 701517, output is -- 29902 -- 7830 -- 50 -- 6387 -- 18082
When seed is -- 702410, output is -- 50 -- 5133 -- 27507 -- 31887 -- 21189
When seed is -- 730358, output is -- 25781 -- 17339 -- 9355 -- 22947 -- 50
When seed is -- 732513, output is -- 50 -- 13179 -- 4245 -- 7644 -- 11254
When seed is -- 735532, output is -- 9909 -- 22298 -- 50 -- 8132 -- 21354
When seed is -- 738731, output is -- 20355 -- 50 -- 143 -- 14641 -- 20302
When seed is -- 740298, output is -- 25473 -- 50 -- 9427 -- 5885 -- 28616
When seed is -- 762616, output is -- 50 -- 21224 -- 13750 -- 16169 -- 1320
When seed is -- 765510, output is -- 9500 -- 30280 -- 4758 -- 23399 -- 50
When seed is -- 769868, output is -- 23732 -- 13595 -- 50 -- 953 -- 26038
When seed is -- 780476, output is -- 25605 -- 50 -- 5836 -- 1865 -- 30691
When seed is -- 786104, output is -- 11216 -- 2353 -- 13169 -- 50 -- 16220
When seed is -- 792719, output is -- 50 -- 29270 -- 23256 -- 24695 -- 24154
When seed is -- 800662, output is -- 25988 -- 10454 -- 162 -- 23852 -- 50
When seed is -- 803883, output is -- 3738 -- 28063 -- 50 -- 2697 -- 29310
When seed is -- 805502, output is -- 9025 -- 29924 -- 20767 -- 50 -- 16926
When seed is -- 812788, output is -- 50 -- 27293 -- 24625 -- 16554 -- 31892
When seed is -- 820654, output is -- 25738 -- 50 -- 2245 -- 30612 -- 32766
When seed is -- 824900, output is -- 6835 -- 24728 -- 28366 -- 50 -- 17633
When seed is -- 835814, output is -- 9708 -- 23395 -- 28333 -- 24304 -- 50
When seed is -- 837898, output is -- 16513 -- 9762 -- 50 -- 4442 -- 32583
When seed is -- 842891, output is -- 50 -- 2571 -- 1362 -- 25080 -- 21957
When seed is -- 844298, output is -- 4645 -- 19531 -- 3196 -- 50 -- 18339
When seed is -- 860832, output is -- 25870 -- 50 -- 31423 -- 26591 -- 2073
When seed is -- 863696, output is -- 2455 -- 14334 -- 10794 -- 50 -- 19046
When seed is -- 870966, output is -- 26195 -- 3568 -- 23736 -- 24757 -- 50
When seed is -- 872234, output is -- 30336 -- 1059 -- 50 -- 30030 -- 4498
When seed is -- 872994, output is -- 50 -- 10616 -- 10868 -- 837 -- 12023
When seed is -- 883094, output is -- 264 -- 9137 -- 18392 -- 50 -- 19753
When seed is -- 901010, output is -- 26002 -- 50 -- 27832 -- 22571 -- 4148
When seed is -- 902492, output is -- 30842 -- 3940 -- 25990 -- 50 -- 20459
When seed is -- 903097, output is -- 50 -- 18662 -- 20373 -- 9362 -- 2089
When seed is -- 906118, output is -- 9915 -- 16510 -- 19139 -- 25209 -- 50
When seed is -- 906249, output is -- 10343 -- 15527 -- 50 -- 31775 -- 7771
When seed is -- 940264, output is -- 23117 -- 29994 -- 50 -- 752 -- 11044
When seed is -- 941188, output is -- 26135 -- 50 -- 24241 -- 18550 -- 6223
When seed is -- 941270, output is -- 26403 -- 29451 -- 14543 -- 25662 -- 50
When seed is -- 942755, output is -- 31252 -- 50 -- 757 -- 9794 -- 14537
When seed is -- 953269, output is -- 50 -- 24731 -- 31248 -- 9747 -- 32660
When seed is -- 974279, output is -- 3124 -- 11693 -- 50 -- 2497 -- 14317
When seed is -- 974600, output is -- 4172 -- 21292 -- 50 -- 26340 -- 15727
When seed is -- 976422, output is -- 10122 -- 9624 -- 9946 -- 26114 -- 50
When seed is -- 982933, output is -- 31384 -- 50 -- 29934 -- 5774 -- 16612
When seed is -- 983372, output is -- 50 -- 9 -- 7986 -- 18272 -- 22726
When seed is -- 994257, output is -- 2828 -- 14652 -- 14180 -- 50 -- 932
When seed is -- 1008615, output is -- 16947 -- 2991 -- 50 -- 28085 -- 19000
When seed is -- 1011574, output is -- 26610 -- 22566 -- 5349 -- 26566 -- 50
When seed is -- 1013475, output is -- 50 -- 8054 -- 17491 -- 26798 -- 12792
When seed is -- 1013655, output is -- 638 -- 9455 -- 21778 -- 50 -- 1639
When seed is -- 1023111, output is -- 31517 -- 50 -- 26343 -- 1753 -- 18687
When seed is -- 1033053, output is -- 31215 -- 4258 -- 29376 -- 50 -- 2346
When seed is -- 1042630, output is -- 29722 -- 17458 -- 50 -- 29830 -- 22273
When seed is -- 1046726, output is -- 10330 -- 2739 -- 752 -- 27019 -- 50
When seed is -- 1052451, output is -- 29025 -- 31829 -- 4206 -- 50 -- 3052
When seed is -- 1059551, output is -- 19443 -- 28843 -- 27663 -- 29994 -- 50
When seed is -- 1063289, output is -- 31649 -- 50 -- 22752 -- 30500 -- 20762
When seed is -- 1063647, output is -- 50 -- 14123 -- 28366 -- 27183 -- 10595
When seed is -- 1071849, output is -- 26835 -- 26633 -- 11804 -- 50 -- 3759
When seed is -- 1076645, output is -- 9728 -- 31926 -- 50 -- 31575 -- 25546
When seed is -- 1076966, output is -- 10777 -- 8756 -- 50 -- 22650 -- 26956
When seed is -- 1091247, output is -- 24644 -- 21436 -- 19402 -- 50 -- 4465
When seed is -- 1093750, output is -- 50 -- 22169 -- 5103 -- 2940 -- 661
When seed is -- 1094703, output is -- 3162 -- 9016 -- 23067 -- 30446 -- 50
When seed is -- 1103467, output is -- 31782 -- 50 -- 19161 -- 26480 -- 22837
When seed is -- 1105034, output is -- 4131 -- 50 -- 28446 -- 17724 -- 31151
When seed is -- 1110645, output is -- 22454 -- 16239 -- 27000 -- 50 -- 5172
When seed is -- 1110981, output is -- 23551 -- 23223 -- 50 -- 24395 -- 30229
When seed is -- 1123853, output is -- 50 -- 30214 -- 14609 -- 11465 -- 23495
When seed is -- 1129855, output is -- 19650 -- 21957 -- 18470 -- 30898 -- 50
When seed is -- 1144996, output is -- 3558 -- 4923 -- 50 -- 26140 -- 734
When seed is -- 1145212, output is -- 4263 -- 50 -- 24855 -- 13704 -- 458
When seed is -- 1153956, output is -- 50 -- 5492 -- 24114 -- 19991 -- 13560
When seed is -- 1165007, output is -- 3370 -- 2131 -- 13873 -- 31351 -- 50
When seed is -- 1179011, output is -- 16333 -- 19390 -- 50 -- 27884 -- 4006
When seed is -- 1179332, output is -- 17381 -- 28988 -- 50 -- 18960 -- 5417
When seed is -- 1185390, output is -- 4396 -- 50 -- 21264 -- 9683 -- 2533
When seed is -- 1200159, output is -- 19857 -- 15072 -- 9277 -- 31803 -- 50
When seed is -- 1204128, output is -- 50 -- 11561 -- 2221 -- 20376 -- 11364
When seed is -- 1213347, output is -- 30156 -- 10687 -- 50 -- 20705 -- 8690
When seed is -- 1221808, output is -- 25018 -- 21754 -- 22789 -- 50 -- 19120
When seed is -- 1225568, output is -- 4528 -- 50 -- 17673 -- 5662 -- 4607
When seed is -- 1234231, output is -- 50 -- 19606 -- 11727 -- 28901 -- 1430
When seed is -- 1235311, output is -- 3577 -- 28013 -- 4680 -- 32256 -- 50
When seed is -- 1241206, output is -- 22827 -- 16557 -- 30387 -- 50 -- 19826
When seed is -- 1247362, output is -- 10162 -- 25155 -- 50 -- 22450 -- 11962
When seed is -- 1260604, output is -- 20637 -- 11360 -- 5217 -- 50 -- 20533
When seed is -- 1264334, output is -- 50 -- 27652 -- 21232 -- 4658 -- 24263
When seed is -- 1265746, output is -- 4661 -- 50 -- 14082 -- 1641 -- 6682
When seed is -- 1270463, output is -- 20064 -- 8187 -- 83 -- 32708 -- 50
When seed is -- 1280002, output is -- 18447 -- 6163 -- 12815 -- 50 -- 21239
When seed is -- 1281377, output is -- 22937 -- 6854 -- 50 -- 24194 -- 15235
When seed is -- 1299400, output is -- 16256 -- 966 -- 20413 -- 50 -- 21946
When seed is -- 1305615, output is -- 3784 -- 21128 -- 28254 -- 393 -- 50
When seed is -- 1305924, output is -- 4793 -- 50 -- 10491 -- 30389 -- 8757
When seed is -- 1307491, output is -- 9910 -- 50 -- 19776 -- 21633 -- 17071
When seed is -- 1314506, output is -- 50 -- 953 -- 32107 -- 5043 -- 22067
When seed is -- 1315713, output is -- 3992 -- 30920 -- 50 -- 17015 -- 19918
When seed is -- 1318798, output is -- 14066 -- 28537 -- 28011 -- 50 -- 22652
When seed is -- 1338196, output is -- 11876 -- 23341 -- 2841 -- 50 -- 23359
When seed is -- 1340767, output is -- 20272 -- 1301 -- 23658 -- 845 -- 50
When seed is -- 1344609, output is -- 50 -- 8999 -- 8844 -- 13569 -- 12133
When seed is -- 1347669, output is -- 10043 -- 50 -- 16185 -- 17613 -- 19146
When seed is -- 1349728, output is -- 16767 -- 12619 -- 50 -- 18760 -- 23191
When seed is -- 1374712, output is -- 50 -- 17044 -- 18350 -- 22094 -- 2198
When seed is -- 1375919, output is -- 3991 -- 14243 -- 19061 -- 1298 -- 50
When seed is -- 1383743, output is -- 29541 -- 27086 -- 50 -- 20504 -- 26464
When seed is -- 1387847, output is -- 10175 -- 50 -- 12594 -- 13592 -- 21221
When seed is -- 1404815, output is -- 50 -- 25090 -- 27855 -- 30619 -- 25032
When seed is -- 1411071, output is -- 20479 -- 27184 -- 14464 -- 1750 -- 50
When seed is -- 1418079, output is -- 10596 -- 18384 -- 50 -- 13325 -- 31147
When seed is -- 1423896, output is -- 29592 -- 20520 -- 8607 -- 4725 -- 50
When seed is -- 1424884, output is -- 50 -- 23113 -- 29225 -- 22479 -- 2
When seed is -- 1428025, output is -- 10308 -- 50 -- 9003 -- 9571 -- 23296
When seed is -- 1449359, output is -- 14439 -- 28856 -- 31397 -- 50 -- 4539
When seed is -- 1452094, output is -- 23371 -- 83 -- 50 -- 15069 -- 1652
When seed is -- 1454987, output is -- 50 -- 31159 -- 5962 -- 31004 -- 22836
When seed is -- 1459048, output is -- 13312 -- 693 -- 4010 -- 5177 -- 50
When seed is -- 1468203, output is -- 10440 -- 50 -- 5412 -- 5550 -- 25371
When seed is -- 1468757, output is -- 12249 -- 23659 -- 6227 -- 50 -- 5245
When seed is -- 1485090, output is -- 50 -- 6436 -- 15468 -- 6761 -- 12901
When seed is -- 1486109, output is -- 3378 -- 14551 -- 50 -- 16814 -- 4925
When seed is -- 1488155, output is -- 10059 -- 18462 -- 13825 -- 50 -- 5952
When seed is -- 1494200, output is -- 29799 -- 13635 -- 32182 -- 5630 -- 50
When seed is -- 1507553, output is -- 7869 -- 13265 -- 21423 -- 50 -- 6658
When seed is -- 1508381, output is -- 10573 -- 50 -- 1821 -- 1530 -- 27446
When seed is -- 1509948, output is -- 15690 -- 50 -- 11106 -- 25542 -- 2992
When seed is -- 1515193, output is -- 50 -- 14482 -- 24973 -- 15287 -- 2967
When seed is -- 1520445, output is -- 17200 -- 5848 -- 50 -- 9635 -- 9608
When seed is -- 1526951, output is -- 5678 -- 8068 -- 29021 -- 50 -- 7365
When seed is -- 1529352, output is -- 13519 -- 26576 -- 27585 -- 6082 -- 50
When seed is -- 1546349, output is -- 3488 -- 2871 -- 3851 -- 50 -- 8072
When seed is -- 1550126, output is -- 15822 -- 50 -- 7515 -- 21522 -- 5067
When seed is -- 1554460, output is -- 29975 -- 20315 -- 50 -- 11379 -- 12881
When seed is -- 1564504, output is -- 30007 -- 6749 -- 22988 -- 6534 -- 50
When seed is -- 1565365, output is -- 50 -- 20551 -- 3080 -- 15672 -- 771
When seed is -- 1588475, output is -- 9982 -- 2015 -- 50 -- 13124 -- 16153
When seed is -- 1590304, output is -- 15955 -- 50 -- 3924 -- 17501 -- 7142
When seed is -- 1595468, output is -- 50 -- 28597 -- 12585 -- 24197 -- 23604
When seed is -- 1599656, output is -- 13726 -- 19691 -- 18392 -- 6987 -- 50
When seed is -- 1622811, output is -- 23805 -- 26080 -- 50 -- 5944 -- 20837
When seed is -- 1625571, output is -- 50 -- 3874 -- 22091 -- 32722 -- 13670
When seed is -- 1630482, output is -- 16087 -- 50 -- 333 -- 13480 -- 9217
When seed is -- 1634808, output is -- 30214 -- 32632 -- 13795 -- 7439 -- 50
When seed is -- 1656826, output is -- 3811 -- 7780 -- 50 -- 7689 -- 24109
When seed is -- 1657512, output is -- 6052 -- 8387 -- 32408 -- 50 -- 22019
When seed is -- 1669960, output is -- 13934 -- 12805 -- 9198 -- 7892 -- 50
When seed is -- 1670660, output is -- 16219 -- 50 -- 29510 -- 9459 -- 11292
When seed is -- 1675743, output is -- 50 -- 9943 -- 198 -- 339 -- 11474
When seed is -- 1676910, output is -- 3861 -- 3190 -- 7238 -- 50 -- 22726
When seed is -- 1690841, output is -- 16586 -- 22247 -- 50 -- 9434 -- 27382
When seed is -- 1696308, output is -- 1671 -- 30761 -- 14836 -- 50 -- 23433
When seed is -- 1705112, output is -- 30421 -- 25747 -- 4601 -- 8344 -- 50
When seed is -- 1705846, output is -- 50 -- 17989 -- 9703 -- 8865 -- 1539
When seed is -- 1710838, output is -- 16352 -- 50 -- 25919 -- 5439 -- 13367
When seed is -- 1712405, output is -- 21469 -- 50 -- 2436 -- 29451 -- 21681
When seed is -- 1715706, output is -- 32249 -- 25564 -- 22434 -- 50 -- 24139
When seed is -- 1725177, output is -- 30409 -- 13545 -- 50 -- 2254 -- 32065
When seed is -- 1735104, output is -- 30058 -- 20367 -- 30032 -- 50 -- 24846
When seed is -- 1735949, output is -- 50 -- 26034 -- 19209 -- 17390 -- 24373
When seed is -- 1740264, output is -- 14141 -- 5920 -- 5 -- 8797 -- 50
When seed is -- 1752583, output is -- 21601 -- 50 -- 31613 -- 25431 -- 23756
When seed is -- 1754502, output is -- 27868 -- 15170 -- 4862 -- 50 -- 25552
When seed is -- 1759192, output is -- 10416 -- 28012 -- 50 -- 3999 -- 2570
When seed is -- 1766052, output is -- 50 -- 1312 -- 28714 -- 25915 -- 14439
When seed is -- 1773900, output is -- 25678 -- 9973 -- 12460 -- 50 -- 26259
When seed is -- 1775416, output is -- 30628 -- 18861 -- 28176 -- 9249 -- 50
When seed is -- 1786121, output is -- 50 -- 32104 -- 30083 -- 17775 -- 22177
When seed is -- 1788241, output is -- 6974 -- 12197 -- 22319 -- 12224 -- 50
When seed is -- 1792761, output is -- 21734 -- 50 -- 28022 -- 21410 -- 25831
When seed is -- 1793207, output is -- 23190 -- 9711 -- 50 -- 5744 -- 5843
When seed is -- 1816224, output is -- 50 -- 7381 -- 6821 -- 26300 -- 12242
When seed is -- 1823393, output is -- 23461 -- 25138 -- 17722 -- 12676 -- 50
When seed is -- 1827543, output is -- 4245 -- 1009 -- 50 -- 31332 -- 10526
When seed is -- 1832939, output is -- 21866 -- 50 -- 24431 -- 17389 -- 27906
When seed is -- 1846327, output is -- 50 -- 15427 -- 16326 -- 2057 -- 2308
When seed is -- 1858545, output is -- 7181 -- 5312 -- 13125 -- 13129 -- 50
When seed is -- 1861558, output is -- 17020 -- 15476 -- 50 -- 309 -- 13799
When seed is -- 1873117, output is -- 21999 -- 50 -- 20840 -- 13368 -- 29981
When seed is -- 1874684, output is -- 27116 -- 50 -- 30125 -- 4613 -- 5527
When seed is -- 1876430, output is -- 50 -- 23472 -- 25832 -- 10583 -- 25142
When seed is -- 1885063, output is -- 28241 -- 15488 -- 8248 -- 50 -- 7439
When seed is -- 1893697, output is -- 23668 -- 18253 -- 8529 -- 13581 -- 50
When seed is -- 1895573, output is -- 29795 -- 29943 -- 50 -- 2054 -- 17072
When seed is -- 1904461, output is -- 26051 -- 10291 -- 15846 -- 50 -- 8145
When seed is -- 1914862, output is -- 27248 -- 50 -- 26534 -- 592 -- 7602
When seed is -- 1923859, output is -- 23861 -- 5095 -- 23444 -- 50 -- 8852
When seed is -- 1926602, output is -- 50 -- 29541 -- 3939 -- 10968 -- 22945
When seed is -- 1928849, output is -- 7388 -- 31194 -- 3932 -- 14034 -- 50
When seed is -- 1929909, output is -- 10850 -- 21241 -- 50 -- 27642 -- 21755
When seed is -- 1943257, output is -- 21671 -- 32666 -- 31042 -- 50 -- 9558
When seed is -- 1955040, output is -- 27381 -- 50 -- 22943 -- 29340 -- 9677
When seed is -- 1956705, output is -- 50 -- 4819 -- 13444 -- 19493 -- 13011
When seed is -- 1962655, output is -- 19480 -- 27469 -- 5872 -- 50 -- 10265
When seed is -- 1963924, output is -- 23624 -- 2940 -- 50 -- 29387 -- 25028
When seed is -- 1964001, output is -- 23876 -- 11368 -- 32103 -- 14486 -- 50
When seed is -- 1982053, output is -- 17290 -- 22272 -- 13470 -- 50 -- 10971
When seed is -- 1986808, output is -- 50 -- 12864 -- 22950 -- 28018 -- 3077
When seed is -- 1995218, output is -- 27513 -- 50 -- 19352 -- 25319 -- 11752
When seed is -- 1997939, output is -- 3631 -- 17408 -- 50 -- 31132 -- 28301
When seed is -- 1999153, output is -- 7595 -- 24309 -- 27506 -- 14939 -- 50
When seed is -- 2016911, output is -- 50 -- 20910 -- 32455 -- 3776 -- 25910
When seed is -- 2032275, output is -- 17454 -- 8705 -- 50 -- 23952 -- 216
When seed is -- 2034305, output is -- 24083 -- 4482 -- 22910 -- 15391 -- 50
When seed is -- 2035396, output is -- 27646 -- 50 -- 15761 -- 21298 -- 13827
When seed is -- 2036980, output is -- 50 -- 18934 -- 1056 -- 28403 -- 880
When seed is -- 2066290, output is -- 30229 -- 23173 -- 50 -- 25697 -- 3489
When seed is -- 2067083, output is -- 50 -- 26979 -- 10562 -- 4161 -- 23714
When seed is -- 2069457, output is -- 7803 -- 17424 -- 18313 -- 15843 -- 50
When seed is -- 2075574, output is -- 27778 -- 50 -- 12170 -- 17278 -- 15901
When seed is -- 2077141, output is -- 127 -- 50 -- 21455 -- 8522 -- 24216
When seed is -- 2093216, output is -- 19854 -- 27787 -- 9259 -- 50 -- 24919
When seed is -- 2097186, output is -- 50 -- 2256 -- 20068 -- 12686 -- 13780
When seed is -- 2100305, output is -- 10235 -- 4872 -- 50 -- 27442 -- 6761
When seed is -- 2104609, output is -- 24290 -- 30365 -- 13716 -- 16296 -- 50
When seed is -- 2112614, output is -- 17663 -- 22590 -- 16857 -- 50 -- 25626
When seed is -- 2117319, output is -- 260 -- 50 -- 17864 -- 4501 -- 26290
When seed is -- 2127289, output is -- 50 -- 10302 -- 29573 -- 21211 -- 3845
When seed is -- 2132012, output is -- 15473 -- 17393 -- 24455 -- 50 -- 26332
When seed is -- 2134641, output is -- 24058 -- 28938 -- 50 -- 20262 -- 11445
When seed is -- 2139761, output is -- 8010 -- 10538 -- 9120 -- 16748 -- 50
When seed is -- 2151410, output is -- 13283 -- 12196 -- 32053 -- 50 -- 27039
When seed is -- 2152586, output is -- 17123 -- 3874 -- 3263 -- 19723 -- 50
When seed is -- 2157497, output is -- 392 -- 50 -- 14273 -- 481 -- 28365
When seed is -- 2168656, output is -- 4065 -- 10637 -- 50 -- 22007 -- 14717
When seed is -- 2170808, output is -- 11092 -- 7000 -- 6883 -- 50 -- 27745
When seed is -- 2177461, output is -- 50 -- 16371 -- 7680 -- 21596 -- 1649
When seed is -- 2187738, output is -- 843 -- 16816 -- 31434 -- 20175 -- 50
When seed is -- 2190206, output is -- 8902 -- 1803 -- 14481 -- 50 -- 28452
When seed is -- 2197675, output is -- 525 -- 50 -- 10682 -- 29228 -- 30440
When seed is -- 2202671, output is -- 16840 -- 25104 -- 50 -- 23751 -- 17990
When seed is -- 2207564, output is -- 50 -- 24417 -- 17185 -- 30122 -- 24483
When seed is -- 2209604, output is -- 6712 -- 29374 -- 22079 -- 50 -- 29159
When seed is -- 2222890, output is -- 17330 -- 29757 -- 26837 -- 20628 -- 50
When seed is -- 2237007, output is -- 30662 -- 16402 -- 50 -- 16572 -- 22673
When seed is -- 2237667, output is -- 50 -- 32462 -- 26691 -- 5879 -- 14548
When seed is -- 2237853, output is -- 657 -- 50 -- 7091 -- 25207 -- 32515
When seed is -- 2258042, output is -- 1050 -- 9930 -- 22240 -- 21080 -- 50
When seed is -- 2271022, output is -- 10669 -- 30869 -- 50 -- 18317 -- 25946
When seed is -- 2278031, output is -- 790 -- 50 -- 3500 -- 21187 -- 1822
When seed is -- 2279598, output is -- 5907 -- 50 -- 12784 -- 12431 -- 10136
When seed is -- 2287839, output is -- 50 -- 5763 -- 4797 -- 6264 -- 12352
When seed is -- 2293194, output is -- 17538 -- 22872 -- 17644 -- 21533 -- 50
When seed is -- 2305037, output is -- 23444 -- 12568 -- 50 -- 20061 -- 29219
When seed is -- 2317942, output is -- 50 -- 13809 -- 14303 -- 14789 -- 2418
When seed is -- 2319776, output is -- 6039 -- 50 -- 9193 -- 8410 -- 12211
When seed is -- 2320767, output is -- 9275 -- 2121 -- 17867 -- 50 -- 10339
When seed is -- 2328346, output is -- 1257 -- 3045 -- 13047 -- 21985 -- 50
When seed is -- 2339373, output is -- 4499 -- 3866 -- 50 -- 12882 -- 1134
When seed is -- 2340165, output is -- 7085 -- 29692 -- 25465 -- 50 -- 11045
When seed is -- 2348045, output is -- 50 -- 21854 -- 23809 -- 23314 -- 25251
When seed is -- 2359563, output is -- 4895 -- 24495 -- 295 -- 50 -- 11752
When seed is -- 2359954, output is -- 6172 -- 50 -- 5603 -- 4390 -- 14286
When seed is -- 2363498, output is -- 17745 -- 15986 -- 8450 -- 22438 -- 50
When seed is -- 2373388, output is -- 17273 -- 18333 -- 50 -- 14626 -- 4407
When seed is -- 2378148, output is -- 50 -- 29900 -- 546 -- 31840 -- 15317
When seed is -- 2378961, output is -- 2704 -- 19298 -- 7894 -- 50 -- 12458
When seed is -- 2398217, output is -- 50 -- 27924 -- 1915 -- 23699 -- 23055
When seed is -- 2398359, output is -- 514 -- 14101 -- 15492 -- 50 -- 13165
When seed is -- 2398650, output is -- 1464 -- 28928 -- 3853 -- 22890 -- 50
When seed is -- 2400132, output is -- 6304 -- 50 -- 2012 -- 369 -- 16361
When seed is -- 2407403, output is -- 30048 -- 33 -- 50 -- 16371 -- 7680
When seed is -- 2417757, output is -- 31092 -- 8904 -- 23090 -- 50 -- 13871
When seed is -- 2428320, output is -- 50 -- 3201 -- 11421 -- 32225 -- 13121
When seed is -- 2433802, output is -- 17952 -- 9101 -- 32025 -- 23343 -- 50
When seed is -- 2440310, output is -- 6436 -- 50 -- 31189 -- 29116 -- 18436
When seed is -- 2441739, output is -- 11103 -- 24098 -- 50 -- 9192 -- 12363
When seed is -- 2458423, output is -- 50 -- 11247 -- 20926 -- 7982 -- 3186
When seed is -- 2468954, output is -- 1672 -- 22042 -- 27428 -- 23795 -- 50
When seed is -- 2475754, output is -- 23878 -- 5798 -- 50 -- 10936 -- 15636
When seed is -- 2480488, output is -- 6569 -- 50 -- 27598 -- 25096 -- 20511
When seed is -- 2482055, output is -- 11686 -- 50 -- 4114 -- 16340 -- 28825
When seed is -- 2488526, output is -- 50 -- 19292 -- 30432 -- 16507 -- 26020
When seed is -- 2504106, output is -- 18159 -- 2216 -- 22831 -- 24247 -- 50

D:\My Projects\AntiOnline\261497>

---

So you would have to go through the entire keyspace of like 4 billion characters to find what you are looking for. But at least this works out that if you have the first 3 random numbers, you can find out exactly what number it was seeded with and then you can be 100% sure you have the right key. ( 2^32 input, 2^15 output per number generated, once you get past two random numbers (2^30 in the output) you will have the 3rd one bring the input < output, which isn't possible and some combinations aren't possible and are pretty rare after that) I probably don't make a whole lot of sense, haha.


If you don't want to have to brute force, you'd have to somehow reverse the GNU implementation of srand() and rand() and understand it perfectly well, study your friend's program for a long time, and then study a lot of regular expressions and write a program that can detect patterns in text/encrypted files, and then figure out what srand() is most likely to produce some text output as per the algorithm of the program that encrypted it... It would probably take much more time than brute-forcing in this case, unless you have millions of files to work with and you don't want to do them manually... At least with brute-force, you don't have to reverse the GNU srand() and rand(), only use them, and then use some regular expressions to find out what looks like a message among all of your output. I make even less sense now, lol.

I got lost...

A_T