generate 4

/* no idea whose this is.  if whoever made it wants to say something and claim credit, please let me know. */

#include <stdio.h>
#include <stdlib.h>
#include pidiv.h
#include gender.h

#define DEFAULT_MODE CLI
#define NUM_POKEMON 493
#define IV_MAX 31

#define TEST 29

#define PRNG(x) (0x41c64E6D*(x)+0x6073)
#define PRNG_REV(x) (0xEEB9EB65*(x)+0xA3561A1)
#define APRNG(x) (0x6C078965*(x)+0x1)
#define APRNG_REV(x) (0x9638806D*(x)+0x69c77F93)

// High and low functions for u32
#define HIGH(x) ((x)>>16&0xFFFF)
#define LOW(x) ((x)&0xFFFF)

#define RAND8 random(0x100)
#define RAND16 random(0x10000)

typedef unsigned char u8;           // 0 to 255
typedef unsigned short u16;         // 0 to 65535
typedef unsigned long u32;          // 0 to 4294967295
typedef unsigned long long u64;     // 0 to 1.8*10^19
typedef signed char s8;             // -127 to 127 (usually -128)
typedef signed short s16;           // -32767 to 32767 (usually -32768)
typedef signed long s32;            // +/- 2147483647
typedef signed long long s64;       // +/- 9.2*10^18

int mode;
s32 * pref_stats;
s32 * stats;
u8 * pref_ivs;
u8 * ivs;
u8 * algorithms;
u8 * ic_log;
u8 gender_threshold;
u64 num_results;
u64 found;
u8 log_length;
u8 tail;

enum {CLI, GUI, NUM_MODES};
enum {HP, ATK, DEF, SPD, SATK, SDEF, NUM_IVS};
enum {NORMAL, WILD, UNCOMMON, RARE, VERY_RARE, SUPER_RARE, NUM_ALGORITHMS};
enum {NATURE, CLASS, GENDER, SHINY, HP_TYPE, HP_POWER, TID, SID, NUM_STATS};

u8 get_gender_threshold(int pokemon)
{
    return (pokemon <= 0 || pokemon > NUM_POKEMON) ? gender[0] : gender[pokemon];
}

int cli_input()
{
    // temp code
    int i;
    for(i = 0; i < NUM_IVS; i++) {
        pref_ivs[i]=TEST;
    }
    for(i = 0; i< NUM_ALGORITHMS; i++) {
        algorithms[i] = 1;
    }
    pref_stats[NATURE] = -1;
    pref_stats[CLASS] = -1;
    pref_stats[GENDER] = -1;
    pref_stats[SHINY] = 0;
    pref_stats[HP_TYPE] = -1;
    pref_stats[HP_POWER] = 30;
    pref_stats[TID] = -1;
    pref_stats[SID] = -1;

    /* TODO: cli_input */
    return 0;
}

int gui_input()
{
    /* TODO: gui_input */
    return 0;
}

int get_input()
{
    if(mode == CLI) {
        return cli_input();
    } else if(mode == GUI) {
        return gui_input();
    }
    return 1;
}

void init_all()
{
    int i;
    pref_stats = (s32*) calloc(NUM_STATS, sizeof(s32));
    if(pref_stats==NULL) exit (1);
    stats = (s32*) calloc(NUM_STATS, sizeof(s32));
    if(stats==NULL) exit (1);
    pref_ivs = (u8*) calloc(NUM_IVS, sizeof(u8));
    if(pref_ivs==NULL) exit (1);
    ivs = (u8*) calloc(NUM_IVS, sizeof(u8));
    if(ivs==NULL) exit (1);
    algorithms = (u8*) calloc(NUM_ALGORITHMS, sizeof(u8));
    if(algorithms==NULL) exit (1);
    ic_log = NULL;
    mode = DEFAULT_MODE;
    gender_threshold = 255;
    num_results = 0;
    found = 0;
    log_lenghth = 0;
    tail = -1;
    return;
}

void init_ic()
{
    for(i = 0; i < NUM_IVS; i++) {
        log_length += IV_MAX-pref_ivs[i];
    }
    if(algorithms==NULL) exit (1);
    ic_log = (u8*) calloc(log_length, sizeof(u8));
}

void free_all()
{
    free(pref_stats);
    free(stats);
    free(pref_ivs);
    free(ivs);
    free(algorithms);
    if(ic_log) free(ic_log);
    return;
}

int cli_print_data(u32 pid, u8 algorithm) {
    // temp code
    printf("%010u %2d %2d %2d %2d %2d %2d %1d %2d %1d %1d %1d %2d %2d %05u %05u\n", pid, ivs[HP], ivs[ATK], ivs[DEF], ivs[SPD], ivs[SATK], ivs[SDEF], algorithm, stats[NATURE], stats[CLASS], stats[GENDER], stats[SHINY], stats[HP_TYPE], stats[HP_POWER], stats[TID], stats[SID]);

    /* TODO: real cli_print_data */
    return 0;
}

int gui_print_data(u32 pid, u8 algorithm)
{
    /* TODO: gui_print_data */
    return 0;
}

int print_data(u32 pid, u8 algorithm)
{
    if(mode == CLI) {
        return cli_print_data(pid, algorithm);
    } else if(mode == GUI) {
        return gui_print_data(pid, algorithm);
    }
    return 1;
}

int check_pid(u32 pid, u8 algorithm)
{
    int ret;
    stats[NATURE] = (s32) pid%25;
    stats[CLASS] = (s32) pid&0x1;
    stats[HP_TYPE] = (s32) ((ivs[5]&0x1)<<5|(ivs[4]&0x1)<<4|(ivs[3]&0x1)<<3|(ivs[2]&0x1)<<2|(ivs[1]&0x1)<<1|ivs[0]&0x1)*15/63;
    stats[HP_POWER] = (s32) ((ivs[5]&0x2)<<4|(ivs[4]&0x2)<<3|(ivs[3]&0x2)<<2|(ivs[2]&0x2)<<1|(ivs[2]&0x2)|(ivs[2]&0x2)>>1)*40/63+30;
    stats[TID] = (s32) (prefs[TID]>=0 ? prefs[TID] : (prefs[SID]<0 ? RAND16 : (prefs[SHINY] ? HIGH(pid)^LOW(pid)^prefs[SID] : RAND16)));
    stats[SID] = (s32) (prefs[SID]>=0 ? prefs[SID] : (prefs[SHINY] ? HIGH(pid)^LOW(pid)^stats[TID] : RAND16));
    stats[SHINY] = (HIGH(pid)^LOW(pid)^stats[TID]^stats[SID]) < 8 ? 1 : 0;
    stats[GENDER] = gender_threshold==0 ? 0 : (gender_threshold==254 ? 1 : (gender_threshold==255 ? 2 : ((pid&0xFF) > gender_threshold ? 0 : 1)));
    if(!(1<<stats[NATURE]&prefs[NATURE]))
        return 0;
    if(stats[CLASS] != prefs[CLASS] && prefs[CLASS] >= 0)
        return 0;
    if(stats[GENDER] != prefs[GENDER] && prefs[GENDER] >= 0)
        return 0;
    if(!stats[SHINY] && prefs[SHINY])
        return 0;
    if(!(1<<stats[HP_TYPE]&prefs[HP_TYPE]))
        return 0;
    if(stats[HP_POWER] < prefs[HP_POWER])
        return 0;
    ret = print_data(pid, algorithm);
    return ret;
}

int ivs_to_pid(u32 root, int iv1)
{
    int ret;
    u32 x[5];
    u8 found[] = {0, 0, 0};
    x[0] = PRNG_REV(root);
    if(algorithms[NORMAL] || algorithms[WILD] || algorithms[SUPER_RARE]) {
        if ((HIGH(x[0])&0x7FFF) == iv1)
            found[0] = 1;
    }
    x[1] = PRNG_REV(x[0]);
    if(algorithms[UNCOMMON] || algorithms[RARE]) {
        if ((HIGH(x[1])&0x7FFF) == iv1)
            found[1] = 1;
    }
    x[2] = rev(x[1]);
    if(algorithms[VERY_RARE]) {
        if ((HIGH(x[2])&0x7FFF) == iv1)
            found[2] = 1;
    }
    if(found[0]) {
        ret = check_pid(((x[1]&0xFFFF0000)|HIGH(x[2]), NORMAL);
        if(ret) return ret;
    }
    if(!algorithms[WILD] && !algorithms[UNCOMMON] && !algorithms[RARE] && !algorithms[VERY_RARE] && !algorithms[SUPER_RARE])
        return 0;
    x[3] = rev(x[2]);
    if(found[0] || found[1]) {
        ret = check_pid(((x[2]&0xFFFF0000)|HIGH(x[3]), found[0] ? WILD : UNCOMMON);
        if(ret) return ret;
    }
    if(!algorithms[RARE] && !algorithms[VERY_RARE] && !algorithms[SUPER_RARE])
        return 0;
    x[4] = rev(x[3]);
    if(found[0] || found[1] || found[2]) {
        ret = check_pid(((x[3]&0xFFFF0000)|HIGH(x[4])), found[1] ? RARE : (found[2] ? VERY_RARE : SUPER_RARE));
        if(ret) return ret;
    }
    return 0;
}

int root_loop()
{
    int ret;
    u32 i;
    u32 j;
    u32 iv1 = ivs[HP]|ivs[ATK]<<5|ivs[DEF]<<10;
    u32 iv2 = ivs[SPD]|ivs[SATK]<<5|ivs[SDEF]<<10;
    for(i = 0; i < 2; i++) {
        for(j = 0; j < 0x10000; j++) {
            ret = ivs_to_pid(i<<31|iv2<<16|j, iv1);
            if(ret) return ret;
        }
    }
    return 0;
}

int flip(int i)
{
    int ret;
    ivs[ic_log[i]]++;
    ic_log[i]++;
    if((i != 0 && ic_log[i] > ic_log[i-1]) || ic_log[i] >= NUM_IVS) {
        ic_log[i] = 0;
        ivs[0]--;
        if(i>0) {
            ret = flip(i-1);
            if(ret) return ret;
        } else {
            ret = exp_log();
            if(ret) return ret;
        }
    } else {
        ivs[ic_log[i]]--;
    }
    if(ivs[ic_log[i]] < pref_ivs[ic_log[i]] || ivs[ic_log[i]] > IV_MAX) return flip(i);
    return 0;
}

int exp_log()
{
    tail++;
    if(tail > log_length) return 1;
    ic_log[tail]=0;
    ivs[0]--;
    if(ivs[0]<pref_ivs[0]) return flip(tail);
    return 0;
}

int iv_loop()
{
    int i;
    int ret;
    int stop = 0;
    for(i = 0; i < NUM_IVS; i++) {
        ivs[i] = IV_MAX;
    }
    ret = root_loop();
    if(ret) return ret;
    stop = exp_log();
    while(!stop) {
        ret = root_loop();
        if(ret) return ret;
        stop = flip(tail);
    }
}

int main()
{
    int ret;
    mode = CLI;
    init_all();
    ret = get_input();
    if(ret) {
        free_all();
        return ret;
    }
    init_ic();
    ret = iv_loop();
    free_all();
    return ret;
}